mirror of
https://gitlab.com/libvirt/libvirt.git
synced 2024-11-03 20:01:16 +00:00
2c78051a14
Introduce a Xen xl parser
This parser allows for users to convert the new xl disk format and
spice graphics config to libvirt xml format and vice versa. Regarding
the spice graphics config, the code is pretty much straight forward.
For the disk {formating, parsing}, this parser takes care of the new
xl format which include positional parameters and key/value parameters.
In xl format disk config a <diskspec> consists of parameters separated by
commas. If the parameters do not contain an '=' they are automatically
assigned to certain options following the order below
target, format, vdev, access
The above are the only mandatory parameters in the <diskspec> but there
are many more disk config options. These options can be specified as
key=value pairs. This takes care of the rest of the options such as
devtype, backend, backendtype, script, direct-io-safe,
The positional paramters can also be specified in key/value form
for example
/dev/vg/guest-volume,,hda
/dev/vg/guest-volume,raw,hda,rw
format=raw, vdev=hda, access=rw, target=/dev/vg/guest-volume
are interpleted to one config.
In xm format, the above diskspec would be written as
phy:/dev/vg/guest-volume,hda,w
The disk parser is based on the same parser used successfully by
the Xen project for several years now. Ian Jackson authored the
scanner, which is used by this commit with mimimal changes. Only
the PREFIX option is changed, to produce function and file names
more consistent with libvirt's convention.
Signed-off-by: Kiarie Kahurani <davidkiarie4@gmail.com>
Signed-off-by: Jim Fehlig <jfehlig@suse.com>
3000 lines
98 KiB
Plaintext
3000 lines
98 KiB
Plaintext
dnl Process this file with autoconf to produce a configure script.
|
|
|
|
dnl Copyright (C) 2005-2014 Red Hat, Inc.
|
|
dnl
|
|
dnl This library is free software; you can redistribute it and/or
|
|
dnl modify it under the terms of the GNU Lesser General Public
|
|
dnl License as published by the Free Software Foundation; either
|
|
dnl version 2.1 of the License, or (at your option) any later version.
|
|
dnl
|
|
dnl This library is distributed in the hope that it will be useful,
|
|
dnl but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
dnl Lesser General Public License for more details.
|
|
dnl
|
|
dnl You should have received a copy of the GNU Lesser General Public
|
|
dnl License along with this library. If not, see
|
|
dnl <http://www.gnu.org/licenses/>.
|
|
|
|
AC_INIT([libvirt], [1.2.12], [libvir-list@redhat.com], [], [http://libvirt.org])
|
|
AC_CONFIG_SRCDIR([src/libvirt.c])
|
|
AC_CONFIG_AUX_DIR([build-aux])
|
|
AC_CONFIG_HEADERS([config.h])
|
|
AH_BOTTOM([#include <config-post.h>])
|
|
AC_CONFIG_MACRO_DIR([m4])
|
|
dnl Make automake keep quiet about wildcards & other GNUmake-isms; also keep
|
|
dnl quiet about the fact that we intentionally cater to automake 1.9
|
|
AM_INIT_AUTOMAKE([-Wno-portability -Wno-obsolete tar-ustar subdir-objects])
|
|
|
|
# Maintainer note - comment this line out if you plan to rerun
|
|
# GNULIB_POSIXCHECK testing to see if libvirt should be using more modules.
|
|
# Leave it uncommented for normal releases, for faster ./configure.
|
|
gl_ASSERT_NO_GNULIB_POSIXCHECK
|
|
|
|
# Default to using the silent-rules feature when possible. Formatting
|
|
# chosen to bypass 'grep' checks that cause older automake to warn.
|
|
# Users (include rpm) can still change the default at configure time.
|
|
m4_ifndef([AM_SILENT_RULES],
|
|
[m4_define([AM_SILENT_RULES],[])])AM_SILENT_RULES([yes])
|
|
|
|
AC_CANONICAL_HOST
|
|
|
|
# First extract pieces from the version number string
|
|
LIBVIRT_MAJOR_VERSION=`echo $VERSION | awk -F. '{print $1}'`
|
|
LIBVIRT_MINOR_VERSION=`echo $VERSION | awk -F. '{print $2}'`
|
|
LIBVIRT_MICRO_VERSION=`echo $VERSION | awk -F. '{print $3}'`
|
|
LIBVIRT_VERSION=$LIBVIRT_MAJOR_VERSION.$LIBVIRT_MINOR_VERSION.$LIBVIRT_MICRO_VERSION$LIBVIRT_MICRO_VERSION_SUFFIX
|
|
LIBVIRT_VERSION_NUMBER=`expr $LIBVIRT_MAJOR_VERSION \* 1000000 + $LIBVIRT_MINOR_VERSION \* 1000 + $LIBVIRT_MICRO_VERSION`
|
|
|
|
# In libtool terminology we need to figure out:
|
|
#
|
|
# CURRENT
|
|
# The most recent interface number that this library implements.
|
|
#
|
|
# REVISION
|
|
# The implementation number of the CURRENT interface.
|
|
#
|
|
# AGE
|
|
# The difference between the newest and oldest interfaces that this
|
|
# library implements.
|
|
#
|
|
# In other words, the library implements all the interface numbers
|
|
# in the range from number `CURRENT - AGE' to `CURRENT'.
|
|
#
|
|
# Libtool assigns the soname version from `CURRENT - AGE', and we
|
|
# don't want that to ever change in libvirt. ie it must always be
|
|
# zero, to produce libvirt.so.0.
|
|
#
|
|
# We would, however, like the libvirt version number reflected
|
|
# in the so version'd symlinks, and this is based on AGE.REVISION
|
|
# eg libvirt.so.0.AGE.REVISION
|
|
#
|
|
# Assuming we do ever want to break soname version, this can
|
|
# toggled. But seriously, don't ever touch this.
|
|
LIBVIRT_SONUM=0
|
|
|
|
# The following examples show what libtool will do
|
|
#
|
|
# Input: 0.9.14 -> libvirt.so.0.9.14
|
|
# Input: 1.0.0 -> libvirt.so.0.1000.0
|
|
# Input: 2.5.8 -> libvirt.so.0.2005.8
|
|
#
|
|
AGE=`expr $LIBVIRT_MAJOR_VERSION '*' 1000 + $LIBVIRT_MINOR_VERSION`
|
|
REVISION=$LIBVIRT_MICRO_VERSION
|
|
CURRENT=`expr $LIBVIRT_SONUM + $AGE`
|
|
LIBVIRT_VERSION_INFO=$CURRENT:$REVISION:$AGE
|
|
|
|
AC_SUBST([LIBVIRT_MAJOR_VERSION])
|
|
AC_SUBST([LIBVIRT_MINOR_VERSION])
|
|
AC_SUBST([LIBVIRT_MICRO_VERSION])
|
|
AC_SUBST([LIBVIRT_SONUM])
|
|
AC_SUBST([LIBVIRT_VERSION])
|
|
AC_SUBST([LIBVIRT_VERSION_INFO])
|
|
AC_SUBST([LIBVIRT_VERSION_NUMBER])
|
|
|
|
AC_ARG_WITH([packager],
|
|
[AS_HELP_STRING([--with-packager],
|
|
[Extra packager name])],
|
|
[],[with_packager=no])
|
|
AC_ARG_WITH([packager-version],
|
|
[AS_HELP_STRING([--with-packager-version],
|
|
[Extra packager version])],
|
|
[],[with_packager_version=no])
|
|
if test "x$with_packager" != "xno"
|
|
then
|
|
AC_DEFINE_UNQUOTED([PACKAGER], ["$with_packager"],
|
|
[Extra package name])
|
|
fi
|
|
if test "x$with_packager_version" != "xno"
|
|
then
|
|
AC_DEFINE_UNQUOTED([PACKAGER_VERSION], ["$with_packager_version"],
|
|
[Extra package version])
|
|
fi
|
|
|
|
dnl Required minimum versions of all libs we depend on
|
|
LIBXML_REQUIRED="2.6.0"
|
|
GNUTLS_REQUIRED="1.0.25"
|
|
POLKIT_REQUIRED="0.6"
|
|
PARTED_REQUIRED="1.8.0"
|
|
DEVMAPPER_REQUIRED=1.0.0
|
|
LIBPCAP_REQUIRED="1.0.0"
|
|
LIBNL_REQUIRED="1.1"
|
|
|
|
dnl Checks for C compiler.
|
|
AC_PROG_CC
|
|
AC_PROG_INSTALL
|
|
AC_PROG_CPP
|
|
|
|
dnl Setting AB_VERSION makes the 'autobuild' lines of configure output
|
|
dnl slightly more useful
|
|
if test -d $srcdir/.git && git --version >/dev/null 2>&1 ; then
|
|
AB_VERSION=`cd $srcdir && git describe --match 'v[[0-9]]*' 2>/dev/null`
|
|
fi
|
|
|
|
gl_EARLY
|
|
gl_INIT
|
|
|
|
AC_TYPE_UID_T
|
|
|
|
dnl Support building Win32 DLLs (must appear *before* AM_PROG_LIBTOOL)
|
|
AC_LIBTOOL_WIN32_DLL
|
|
|
|
m4_ifndef([LT_INIT], [
|
|
AM_PROG_LIBTOOL
|
|
], [
|
|
LT_INIT([shared disable-static])
|
|
])
|
|
AM_PROG_CC_C_O
|
|
AM_PROG_LD
|
|
AM_PROG_LEX
|
|
|
|
AC_MSG_CHECKING([for how to mark DSO non-deletable at runtime])
|
|
LIBVIRT_NODELETE=
|
|
`$LD --help 2>&1 | grep -- "-z nodelete" >/dev/null` && \
|
|
LIBVIRT_NODELETE="-Wl,-z -Wl,nodelete"
|
|
AC_MSG_RESULT([$LIBVIRT_NODELETE])
|
|
AC_SUBST([LIBVIRT_NODELETE])
|
|
|
|
AC_MSG_CHECKING([for how to set DSO symbol versions])
|
|
VERSION_SCRIPT_FLAGS=-Wl,--version-script=
|
|
`$LD --help 2>&1 | grep -- --version-script >/dev/null` || \
|
|
VERSION_SCRIPT_FLAGS="-Wl,-M -Wl,"
|
|
AC_MSG_RESULT([$VERSION_SCRIPT_FLAGS])
|
|
|
|
dnl Specify if we rely on ifconfig instead of iproute2 (e.g. in case
|
|
dnl we're working on BSD)
|
|
want_ifconfig=no
|
|
|
|
dnl Make some notes about which OS we're compiling for, as the lxc and qemu
|
|
dnl drivers require linux headers, and storage_mpath, dtrace, and nwfilter
|
|
dnl are also linux specific. The "network" and storage_fs drivers are known
|
|
dnl to not work on MacOS X presently, so we also make a note if compiling
|
|
dnl for that
|
|
|
|
with_linux=no with_osx=no with_freebsd=no
|
|
case $host in
|
|
*-*-linux*) with_linux=yes ;;
|
|
*-*-darwin*) with_osx=yes ;;
|
|
*-*-freebsd*) with_freebsd=yes ;;
|
|
*-*-mingw* | *-*-msvc* ) with_win=yes ;;
|
|
esac
|
|
|
|
if test $with_linux = no; then
|
|
if test "x$with_lxc" != xyes
|
|
then
|
|
with_lxc=no
|
|
fi
|
|
with_dtrace=no
|
|
fi
|
|
|
|
if test $with_freebsd = yes; then
|
|
want_ifconfig=yes
|
|
|
|
with_firewalld=no
|
|
fi
|
|
|
|
AM_CONDITIONAL([WITH_LINUX], [test "$with_linux" = "yes"])
|
|
AM_CONDITIONAL([WITH_FREEBSD], [test "$with_freebsd" = "yes"])
|
|
|
|
# We don't support the daemon yet
|
|
if test "$with_win" = "yes" ; then
|
|
with_libvirtd=no
|
|
fi
|
|
|
|
# The daemon requires remote support. Likewise, if we are not using
|
|
# RPC, we don't need several libraries.
|
|
if test "$with_remote" = "no" ; then
|
|
with_libvirtd=no
|
|
with_gnutls=no
|
|
with_ssh2=no
|
|
with_sasl=no
|
|
fi
|
|
# Stateful drivers are useful only when building the daemon.
|
|
if test "$with_libvirtd" = "no" ; then
|
|
with_qemu=no
|
|
with_xen=no
|
|
with_lxc=no
|
|
with_libxl=no
|
|
with_uml=no
|
|
with_vbox=no
|
|
fi
|
|
|
|
# Check for compiler and library settings.
|
|
|
|
LIBVIRT_COMPILE_WARNINGS
|
|
LIBVIRT_COMPILE_PIE
|
|
LIBVIRT_LINKER_RELRO
|
|
LIBVIRT_LINKER_NO_INDIRECT
|
|
|
|
LIBVIRT_CHECK_APPARMOR
|
|
LIBVIRT_CHECK_ATTR
|
|
LIBVIRT_CHECK_AUDIT
|
|
LIBVIRT_CHECK_AVAHI
|
|
LIBVIRT_CHECK_BLKID
|
|
LIBVIRT_CHECK_CAPNG
|
|
LIBVIRT_CHECK_CURL
|
|
LIBVIRT_CHECK_DBUS
|
|
LIBVIRT_CHECK_FUSE
|
|
LIBVIRT_CHECK_GLUSTER
|
|
LIBVIRT_CHECK_HAL
|
|
LIBVIRT_CHECK_NETCF
|
|
LIBVIRT_CHECK_NUMACTL
|
|
LIBVIRT_CHECK_OPENWSMAN
|
|
LIBVIRT_CHECK_PCIACCESS
|
|
LIBVIRT_CHECK_READLINE
|
|
LIBVIRT_CHECK_SANLOCK
|
|
LIBVIRT_CHECK_SASL
|
|
LIBVIRT_CHECK_SELINUX
|
|
LIBVIRT_CHECK_SSH2
|
|
LIBVIRT_CHECK_SYSTEMD_DAEMON
|
|
LIBVIRT_CHECK_UDEV
|
|
LIBVIRT_CHECK_YAJL
|
|
|
|
AC_MSG_CHECKING([for CPUID instruction])
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
|
|
[[
|
|
#include <stdint.h>
|
|
]],
|
|
[[
|
|
uint32_t eax, ebx, ecx, edx;
|
|
asm volatile (
|
|
"cpuid"
|
|
: "=a" (eax), "=b" (ebx), "=c" (ecx), "=d" (edx)
|
|
: "a" (eax));
|
|
]])],
|
|
[have_cpuid=yes],
|
|
[have_cpuid=no])
|
|
if test "x$have_cpuid" = xyes; then
|
|
AC_DEFINE_UNQUOTED([HAVE_CPUID], 1, [whether CPUID instruction is supported])
|
|
fi
|
|
AC_MSG_RESULT([$have_cpuid])
|
|
|
|
AC_CHECK_SIZEOF([long])
|
|
|
|
dnl Availability of various common functions (non-fatal if missing),
|
|
dnl and various less common threadsafe functions
|
|
AC_CHECK_FUNCS_ONCE([cfmakeraw fallocate geteuid getgid getgrnam_r \
|
|
getmntent_r getpwuid_r getuid kill mmap newlocale posix_fallocate \
|
|
posix_memalign prlimit regexec sched_getaffinity setgroups setns \
|
|
setrlimit symlink sysctlbyname getifaddrs])
|
|
|
|
dnl Availability of pthread functions. Because of $LIB_PTHREAD, we
|
|
dnl cannot use AC_CHECK_FUNCS_ONCE. LIB_PTHREAD and LIBMULTITHREAD
|
|
dnl were set during gl_INIT by gnulib.
|
|
old_LIBS=$LIBS
|
|
LIBS="$LIBS $LIB_PTHREAD $LIBMULTITHREAD"
|
|
|
|
pthread_found=yes
|
|
AC_CHECK_FUNCS([pthread_mutexattr_init])
|
|
AC_CHECK_HEADER([pthread.h],,[pthread_found=no])
|
|
|
|
if test "$ac_cv_func_pthread_mutexattr_init:$pthread_found" != "yes:yes"
|
|
then
|
|
AC_MSG_ERROR([A pthreads impl is required for building libvirt])
|
|
fi
|
|
|
|
dnl At least mingw64-winpthreads #defines pthread_sigmask to 0,
|
|
dnl which in turn causes compilation to complain about unused variables.
|
|
dnl Expose this broken implementation, so we can work around it.
|
|
AC_CACHE_CHECK([whether pthread_sigmask does anything],
|
|
[lv_cv_pthread_sigmask_works],
|
|
[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
|
|
#include <sys/types.h>
|
|
#include <signal.h>
|
|
]], [[
|
|
#ifdef pthread_sigmask
|
|
int (*foo)(int, const sigset_t *, sigset_t *) = &pthread_sigmask;
|
|
return !foo;
|
|
#endif
|
|
]])], [lv_cv_pthread_sigmask_works=yes], [lv_cv_pthread_sigmask_works=no])])
|
|
if test "x$lv_cv_pthread_sigmask_works" != xyes; then
|
|
AC_DEFINE([FUNC_PTHREAD_SIGMASK_BROKEN], [1],
|
|
[Define to 1 if pthread_sigmask is not a real function])
|
|
fi
|
|
LIBS=$old_libs
|
|
|
|
dnl Availability of various common headers (non-fatal if missing).
|
|
AC_CHECK_HEADERS([pwd.h paths.h regex.h sys/un.h \
|
|
sys/poll.h syslog.h mntent.h net/ethernet.h linux/magic.h \
|
|
sys/un.h sys/syscall.h sys/sysctl.h netinet/tcp.h ifaddrs.h \
|
|
libtasn1.h sys/ucred.h sys/mount.h])
|
|
dnl Check whether endian provides handy macros.
|
|
AC_CHECK_DECLS([htole64], [], [], [[#include <endian.h>]])
|
|
|
|
dnl We need to decide at configure time if libvirt will use real atomic
|
|
dnl operations ("lock free") or emulated ones with a mutex.
|
|
|
|
dnl Note that the atomic ops are only available with GCC on x86 when
|
|
dnl using -march=i486 or higher. If we detect that the atomic ops are
|
|
dnl not available but would be available given the right flags, we want
|
|
dnl to abort and advise the user to fix their CFLAGS. It's better to do
|
|
dnl that then to silently fall back on emulated atomic ops just because
|
|
dnl the user had the wrong build environment.
|
|
|
|
atomic_ops=
|
|
|
|
AC_MSG_CHECKING([for atomic ops implementation])
|
|
|
|
AC_TRY_COMPILE([], [__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4;],[
|
|
atomic_ops=gcc
|
|
],[])
|
|
|
|
if test "$atomic_ops" = "" ; then
|
|
SAVE_CFLAGS="${CFLAGS}"
|
|
CFLAGS="-march=i486"
|
|
AC_TRY_COMPILE([],
|
|
[__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4;],
|
|
[AC_MSG_ERROR([Libvirt must be built with -march=i486 or later.])],
|
|
[])
|
|
CFLAGS="${SAVE_CFLAGS}"
|
|
|
|
case "$host" in
|
|
*-*-mingw* | *-*-msvc* )
|
|
atomic_ops=win32
|
|
;;
|
|
*)
|
|
if test "$ac_cv_header_pthread_h" = "yes" ; then
|
|
atomic_ops=pthread
|
|
else
|
|
AC_MSG_ERROR([Libvirt must be built with GCC or have pthread.h on non-Win32 platforms])
|
|
fi
|
|
;;
|
|
esac
|
|
fi
|
|
|
|
case "$atomic_ops" in
|
|
gcc)
|
|
AC_DEFINE([VIR_ATOMIC_OPS_GCC],[1],[Use GCC atomic ops])
|
|
;;
|
|
win32)
|
|
AC_DEFINE([VIR_ATOMIC_OPS_WIN32],[1],[Use Win32 atomic ops])
|
|
;;
|
|
pthread)
|
|
AC_DEFINE([VIR_ATOMIC_OPS_PTHREAD],[1],[Use pthread atomic ops emulation])
|
|
;;
|
|
esac
|
|
AM_CONDITIONAL([WITH_ATOMIC_OPS_PTHREAD],[test "$atomic_ops" = "pthread"])
|
|
AC_MSG_RESULT([$atomic_ops])
|
|
|
|
|
|
AC_CHECK_TYPE([struct ifreq],
|
|
[AC_DEFINE([HAVE_STRUCT_IFREQ],[1],
|
|
[Defined if struct ifreq exists in net/if.h])],
|
|
[], [[#include <sys/socket.h>
|
|
#include <net/if.h>
|
|
]])
|
|
|
|
dnl Our only use of libtasn1.h is in the testsuite, and can be skipped
|
|
dnl if the header is not present. Assume -ltasn1 is present if the
|
|
dnl header could be found.
|
|
AM_CONDITIONAL([HAVE_LIBTASN1], [test "x$ac_cv_header_libtasn1_h" = "xyes"])
|
|
|
|
AC_CHECK_LIB([intl],[gettext],[])
|
|
|
|
dnl Do we have rpcgen?
|
|
AC_PATH_PROG([RPCGEN], [rpcgen], [no])
|
|
AM_CONDITIONAL([HAVE_RPCGEN], [test "x$ac_cv_path_RPCGEN" != "xno"])
|
|
dnl Is this GLIBC's buggy rpcgen?
|
|
AM_CONDITIONAL([HAVE_GLIBC_RPCGEN],
|
|
[test "x$ac_cv_path_RPCGEN" != "xno" &&
|
|
$ac_cv_path_RPCGEN -t </dev/null >/dev/null 2>&1])
|
|
|
|
dnl Miscellaneous external programs.
|
|
AC_PATH_PROG([XMLLINT], [xmllint], [/usr/bin/xmllint])
|
|
AC_PATH_PROG([XMLCATALOG], [xmlcatalog], [/usr/bin/xmlcatalog])
|
|
AC_PATH_PROG([XSLTPROC], [xsltproc], [/usr/bin/xsltproc])
|
|
AC_PATH_PROG([AUGPARSE], [augparse], [/usr/bin/augparse])
|
|
AC_PROG_MKDIR_P
|
|
|
|
dnl External programs that we can use if they are available.
|
|
dnl We will hard-code paths to these programs unless we cannot
|
|
dnl detect them, in which case we'll search for the program
|
|
dnl along the $PATH at runtime and fail if it's not there.
|
|
AC_PATH_PROG([DMIDECODE], [dmidecode], [dmidecode],
|
|
[/sbin:/usr/sbin:/usr/local/sbin:$PATH])
|
|
AC_PATH_PROG([DNSMASQ], [dnsmasq], [dnsmasq],
|
|
[/sbin:/usr/sbin:/usr/local/sbin:$PATH])
|
|
AC_PATH_PROG([RADVD], [radvd], [radvd],
|
|
[/sbin:/usr/sbin:/usr/local/sbin:$PATH])
|
|
AC_PATH_PROG([TC], [tc], [tc],
|
|
[/sbin:/usr/sbin:/usr/local/sbin:$PATH])
|
|
AC_PATH_PROG([UDEVADM], [udevadm], [],
|
|
[/sbin:/usr/sbin:/usr/local/sbin:$PATH])
|
|
AC_PATH_PROG([UDEVSETTLE], [udevsettle], [],
|
|
[/sbin:/usr/sbin:/usr/local/sbin:$PATH])
|
|
AC_PATH_PROG([MODPROBE], [modprobe], [modprobe],
|
|
[/sbin:/usr/sbin:/usr/local/sbin:$PATH])
|
|
AC_PATH_PROG([RMMOD], [rmmod], [rmmod],
|
|
[/sbin:/usr/sbin:/usr/local/sbin:$PATH])
|
|
AC_PATH_PROG([OVSVSCTL], [ovs-vsctl], [ovs-vsctl],
|
|
[/sbin:/usr/sbin:/usr/local/sbin:$PATH])
|
|
AC_PATH_PROG([SCRUB], [scrub], [scrub],
|
|
[/sbin:/usr/sbin:/usr/local/sbin:$PATH])
|
|
AC_PATH_PROG([ADDR2LINE], [addr2line], [addr2line],
|
|
[/sbin:/usr/bin:/usr/sbin:/usr/local/sbin:$PATH])
|
|
|
|
AC_DEFINE_UNQUOTED([DMIDECODE],["$DMIDECODE"],
|
|
[Location or name of the dmidecode program])
|
|
AC_DEFINE_UNQUOTED([DNSMASQ],["$DNSMASQ"],
|
|
[Location or name of the dnsmasq program])
|
|
AC_DEFINE_UNQUOTED([RADVD],["$RADVD"],
|
|
[Location or name of the radvd program])
|
|
AC_DEFINE_UNQUOTED([TC],["$TC"],
|
|
[Location or name of the tc program (see iproute2)])
|
|
AC_DEFINE_UNQUOTED([OVSVSCTL],["$OVSVSCTL"],
|
|
[Location or name of the ovs-vsctl program])
|
|
|
|
if test -n "$UDEVADM"; then
|
|
AC_DEFINE_UNQUOTED([UDEVADM],["$UDEVADM"],
|
|
[Location or name of the udevadm program])
|
|
fi
|
|
if test -n "$UDEVSETTLE"; then
|
|
AC_DEFINE_UNQUOTED([UDEVSETTLE],["$UDEVSETTLE"],
|
|
[Location or name of the udevsettle program])
|
|
fi
|
|
if test -n "$MODPROBE"; then
|
|
AC_DEFINE_UNQUOTED([MODPROBE],["$MODPROBE"],
|
|
[Location or name of the modprobe program])
|
|
fi
|
|
if test -n "$RMMOD"; then
|
|
AC_DEFINE_UNQUOTED([RMMOD],["$RMMOD"],
|
|
[Location or name of the rmmod program])
|
|
fi
|
|
AC_DEFINE_UNQUOTED([SCRUB],["$SCRUB"],
|
|
[Location or name of the scrub program (for wiping algorithms)])
|
|
AC_DEFINE_UNQUOTED([ADDR2LINE],["$ADDR2LINE"],
|
|
[Location of addr2line program])
|
|
|
|
dnl Specific dir for HTML output ?
|
|
AC_ARG_WITH([html-dir], [AS_HELP_STRING([--with-html-dir=path],
|
|
[path to base html directory, default $datadir/doc/html])],
|
|
[HTML_DIR=$withval], [HTML_DIR='$(datadir)/doc'])
|
|
|
|
AC_ARG_WITH([html-subdir], [AS_HELP_STRING([--with-html-subdir=path],
|
|
[directory used under html-dir, default $PACKAGE-$VERSION/html])],
|
|
[test "x$withval" != "x" && HTML_DIR="$HTML_DIR/$withval"],
|
|
[HTML_DIR="$HTML_DIR/\$(PACKAGE)-\$(VERSION)/html"])
|
|
AC_SUBST([HTML_DIR])
|
|
|
|
dnl Specific XML catalog file for validation of generated html
|
|
AC_ARG_WITH([xml-catalog-file],
|
|
[AS_HELP_STRING([--with-xml-catalog-file=path],
|
|
[path to XML catalog file for validating
|
|
generated html, default /etc/xml/catalog])],
|
|
[XML_CATALOG_FILE=$withval],
|
|
[XML_CATALOG_FILE='/etc/xml/catalog'])
|
|
AC_SUBST([XML_CATALOG_FILE])
|
|
|
|
dnl if --prefix is /usr, don't use /usr/var for localstatedir
|
|
dnl or /usr/etc for sysconfdir
|
|
dnl as this makes a lot of things break in testing situations
|
|
|
|
if test "$prefix" = "/usr" && test "$localstatedir" = '${prefix}/var' ; then
|
|
localstatedir='/var'
|
|
fi
|
|
if test "$prefix" = "/usr" && test "$sysconfdir" = '${prefix}/etc' ; then
|
|
sysconfdir='/etc'
|
|
fi
|
|
|
|
dnl Allow to build without Xen, QEMU/KVM, test or remote driver
|
|
AC_ARG_WITH([xen],
|
|
[AS_HELP_STRING([--with-xen],
|
|
[add XEN support @<:@default=check@:>@])])
|
|
m4_divert_text([DEFAULTS], [with_xen=check])
|
|
AC_ARG_WITH([xen-inotify],
|
|
[AS_HELP_STRING([--with-xen-inotify],
|
|
[add XEN inotify support @<:@default=check@:>@])])
|
|
m4_divert_text([DEFAULTS], [with_xen_inotify=check])
|
|
AC_ARG_WITH([qemu],
|
|
[AS_HELP_STRING([--with-qemu],
|
|
[add QEMU/KVM support @<:@default=yes@:>@])])
|
|
m4_divert_text([DEFAULTS], [with_qemu=yes])
|
|
AC_ARG_WITH([uml],
|
|
[AS_HELP_STRING([--with-uml],
|
|
[add UML support @<:@default=check@:>@])])
|
|
m4_divert_text([DEFAULTS], [with_uml=check])
|
|
AC_ARG_WITH([openvz],
|
|
[AS_HELP_STRING([--with-openvz],
|
|
[add OpenVZ support @<:@default=check@:>@])])
|
|
m4_divert_text([DEFAULTS], [with_openvz=check])
|
|
AC_ARG_WITH([vmware],
|
|
[AS_HELP_STRING([--with-vmware],
|
|
[add VMware support @<:@default=yes@:>@])])
|
|
m4_divert_text([DEFAULTS], [with_vmware=yes])
|
|
AC_ARG_WITH([phyp],
|
|
[AS_HELP_STRING([--with-phyp],
|
|
[add PHYP support @<:@default=check@:>@])])
|
|
m4_divert_text([DEFAULTS], [with_phyp=check])
|
|
AC_ARG_WITH([xenapi],
|
|
[AS_HELP_STRING([--with-xenapi],
|
|
[add XenAPI support @<:@default=check@:>@])])
|
|
m4_divert_text([DEFAULTS], [with_xenapi=check])
|
|
AC_ARG_WITH([libxl],
|
|
[AS_HELP_STRING([--with-libxl],
|
|
[add libxenlight support @<:@default=check@:>@])])
|
|
m4_divert_text([DEFAULTS], [with_libxl=check])
|
|
AC_ARG_WITH([vbox],
|
|
[AS_HELP_STRING([--with-vbox=@<:@PFX@:>@],
|
|
[VirtualBox XPCOMC location @<:@default=yes@:>@])])
|
|
m4_divert_text([DEFAULTS], [with_vbox=yes])
|
|
AC_ARG_WITH([lxc],
|
|
[AS_HELP_STRING([--with-lxc],
|
|
[add Linux Container support @<:@default=check@:>@])])
|
|
m4_divert_text([DEFAULTS], [with_lxc=check])
|
|
AC_ARG_WITH([esx],
|
|
[AS_HELP_STRING([--with-esx],
|
|
[add ESX support @<:@default=check@:>@])])
|
|
m4_divert_text([DEFAULTS], [with_esx=check])
|
|
AC_ARG_WITH([hyperv],
|
|
[AS_HELP_STRING([--with-hyperv],
|
|
[add Hyper-V support @<:@default=check@:>@])])
|
|
m4_divert_text([DEFAULTS], [with_hyperv=check])
|
|
AC_ARG_WITH([parallels],
|
|
[AS_HELP_STRING([--with-parallels],
|
|
[add Parallels Cloud Server support @<:@default=check@:>@])])
|
|
m4_divert_text([DEFAULTS], [with_parallels=check])
|
|
AC_ARG_WITH([test],
|
|
[AS_HELP_STRING([--with-test],
|
|
[add test driver support @<:@default=yes@:>@])])
|
|
m4_divert_text([DEFAULTS], [with_test=yes])
|
|
AC_ARG_WITH([remote],
|
|
[AS_HELP_STRING([--with-remote],
|
|
[add remote driver support @<:@default=yes@:>@])])
|
|
m4_divert_text([DEFAULTS], [with_remote=yes])
|
|
AC_ARG_WITH([libvirtd],
|
|
[AS_HELP_STRING([--with-libvirtd],
|
|
[add libvirtd support @<:@default=yes@:>@])])
|
|
m4_divert_text([DEFAULTS], [with_libvirtd=yes])
|
|
AC_ARG_WITH([chrdev-lock-files],
|
|
[AS_HELP_STRING([--with-chrdev-lock-files],
|
|
[location for UUCP style lock files for character devices
|
|
(use auto for default paths on some platforms) @<:@default=auto@:>@])])
|
|
m4_divert_text([DEFAULTS], [with_chrdev_lock_files=auto])
|
|
AC_ARG_WITH([pm-utils],
|
|
[AS_HELP_STRING([--with-pm-utils],
|
|
[use pm-utils for power management @<:@default=yes@:>@])])
|
|
m4_divert_text([DEFAULTS], [with_pm_utils=check])
|
|
|
|
dnl
|
|
dnl in case someone want to build static binaries
|
|
dnl STATIC_BINARIES="-static"
|
|
dnl
|
|
STATIC_BINARIES=
|
|
AC_SUBST([STATIC_BINARIES])
|
|
|
|
dnl --enable-debug=(yes|no)
|
|
AC_ARG_ENABLE([debug],
|
|
[AS_HELP_STRING([--enable-debug=@<:@no|yes@:>@],
|
|
[enable debugging output @<:@default=yes@:>@])],
|
|
[],[enable_debug=yes])
|
|
AM_CONDITIONAL([ENABLE_DEBUG], test x"$enable_debug" = x"yes")
|
|
if test x"$enable_debug" = x"yes"; then
|
|
AC_DEFINE([ENABLE_DEBUG], [], [whether debugging is enabled])
|
|
fi
|
|
|
|
|
|
|
|
dnl
|
|
dnl init script flavor
|
|
dnl
|
|
AC_MSG_CHECKING([for init script flavor])
|
|
AC_ARG_WITH([init-script],
|
|
[AS_HELP_STRING([--with-init-script@<:@=STYLE@:>@],
|
|
[Style of init script to install: redhat, systemd, systemd+redhat,
|
|
upstart, check, none @<:@default=check@:>@])],
|
|
[],[with_init_script=check])
|
|
init_redhat=no
|
|
init_systemd=no
|
|
init_upstart=no
|
|
case "$with_init_script" in
|
|
systemd+redhat)
|
|
init_redhat=yes
|
|
init_systemd=yes
|
|
;;
|
|
systemd)
|
|
init_systemd=yes
|
|
;;
|
|
upstart)
|
|
init_upstart=yes
|
|
;;
|
|
redhat)
|
|
init_redhat=yes
|
|
;;
|
|
none)
|
|
;;
|
|
check)
|
|
if test "$cross_compiling" != yes && test -f /etc/redhat-release; then
|
|
init_redhat=yes
|
|
with_init_script=redhat
|
|
fi
|
|
;;
|
|
*)
|
|
AC_MSG_ERROR([Unknown initscript flavour $with_init_script])
|
|
;;
|
|
esac
|
|
AM_CONDITIONAL([LIBVIRT_INIT_SCRIPT_RED_HAT], test "$init_redhat" = "yes")
|
|
AM_CONDITIONAL([LIBVIRT_INIT_SCRIPT_UPSTART], test "$init_upstart" = "yes")
|
|
AM_CONDITIONAL([LIBVIRT_INIT_SCRIPT_SYSTEMD], test "$init_systemd" = "yes")
|
|
AC_MSG_RESULT($with_init_script)
|
|
|
|
|
|
AC_MSG_CHECKING([for whether to install sysctl config])
|
|
AC_ARG_WITH([sysctl],
|
|
[AS_HELP_STRING([--with-sysctl@<:@=yes/no@:>@],
|
|
[Whether to install sysctl configs @<:@default=check@:>@])],
|
|
[],[with_sysctl=check])
|
|
|
|
if test "$with_sysctl" = "yes" || test "$with_sysctl" = "check"
|
|
then
|
|
case $host in
|
|
*-*-linux*)
|
|
with_sysctl=yes
|
|
;;
|
|
**)
|
|
if test "$with_sysctl" = "yes"; then
|
|
AC_MSG_ERROR([No sysctl configuration supported for $host])
|
|
else
|
|
with_sysctl=no
|
|
fi
|
|
;;
|
|
esac
|
|
fi
|
|
AM_CONDITIONAL([WITH_SYSCTL], test "$with_sysctl" = "yes")
|
|
AC_MSG_RESULT($with_sysctl)
|
|
|
|
dnl RHEL-5 has a peculiar version of Xen, which requires some special casing
|
|
AC_ARG_WITH([rhel5-api],
|
|
[AS_HELP_STRING([--with-rhel5-api=@<:@ARG@:>@],
|
|
[build for the RHEL-5 API @<:@default=no@:>@])])
|
|
if test x"$with_rhel5_api" = x"yes"; then
|
|
AC_DEFINE([WITH_RHEL5_API], [1], [whether building for the RHEL-5 API])
|
|
fi
|
|
|
|
AC_PATH_PROG([IP_PATH], [ip], /sbin/ip, [/usr/sbin:$PATH])
|
|
AC_DEFINE_UNQUOTED([IP_PATH], "$IP_PATH", [path to ip binary])
|
|
|
|
AC_PATH_PROG([IPTABLES_PATH], [iptables], /sbin/iptables, [/usr/sbin:$PATH])
|
|
AC_DEFINE_UNQUOTED([IPTABLES_PATH], "$IPTABLES_PATH", [path to iptables binary])
|
|
|
|
AC_PATH_PROG([IP6TABLES_PATH], [ip6tables], /sbin/ip6tables, [/usr/sbin:$PATH])
|
|
AC_DEFINE_UNQUOTED([IP6TABLES_PATH], "$IP6TABLES_PATH", [path to ip6tables binary])
|
|
|
|
AC_PATH_PROG([EBTABLES_PATH], [ebtables], /sbin/ebtables, [/usr/sbin:$PATH])
|
|
AC_DEFINE_UNQUOTED([EBTABLES_PATH], "$EBTABLES_PATH", [path to ebtables binary])
|
|
|
|
|
|
dnl
|
|
dnl Checks for the OpenVZ driver
|
|
dnl
|
|
|
|
if test "$with_openvz" = "check"; then
|
|
with_openvz=$with_linux
|
|
fi
|
|
|
|
if test "$with_openvz" = "yes" && test "$with_linux" = "no"; then
|
|
AC_MSG_ERROR([The OpenVZ driver can be enabled on Linux only.])
|
|
fi
|
|
|
|
if test "$with_openvz" = "yes"; then
|
|
AC_DEFINE_UNQUOTED([WITH_OPENVZ], 1, [whether OpenVZ driver is enabled])
|
|
fi
|
|
AM_CONDITIONAL([WITH_OPENVZ], [test "$with_openvz" = "yes"])
|
|
|
|
|
|
dnl
|
|
dnl Checks for the VMware Workstation/Player driver
|
|
dnl
|
|
|
|
if test "$with_vmware" = "yes"; then
|
|
AC_DEFINE_UNQUOTED([WITH_VMWARE], 1, [whether VMware driver is enabled])
|
|
fi
|
|
AM_CONDITIONAL([WITH_VMWARE], [test "$with_vmware" = "yes"])
|
|
|
|
|
|
dnl
|
|
dnl check for XDR
|
|
dnl
|
|
|
|
if test x"$with_remote" = x"yes" || test x"$with_libvirtd" = x"yes"; then
|
|
dnl Where are the XDR functions?
|
|
dnl If portablexdr is installed, prefer that.
|
|
dnl Otherwise try -lrpc (Cygwin) -lxdr (some MinGW), -lnsl (Solaris)
|
|
dnl -ltirpc (glibc 2.13.90 or newer) or none (most Unix)
|
|
AC_CHECK_LIB([portablexdr],[xdrmem_create],[],[
|
|
AC_SEARCH_LIBS([xdrmem_create],[rpc xdr nsl tirpc],[],
|
|
[AC_MSG_ERROR([Cannot find a XDR library])])
|
|
])
|
|
|
|
dnl check for cygwin's variation in xdr function names
|
|
AC_CHECK_FUNCS([xdr_u_int64_t],[],[],[#include <rpc/xdr.h>])
|
|
|
|
dnl Cygwin/recent glibc requires -I/usr/include/tirpc for <rpc/rpc.h>
|
|
old_CFLAGS=$CFLAGS
|
|
AC_CACHE_CHECK([where to find <rpc/rpc.h>], [lv_cv_xdr_cflags], [
|
|
for add_CFLAGS in '' '-I/usr/include/tirpc' 'missing'; do
|
|
if test x"$add_CFLAGS" = xmissing; then
|
|
lv_cv_xdr_cflags=missing; break
|
|
fi
|
|
CFLAGS="$old_CFLAGS $add_CFLAGS"
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <rpc/rpc.h>
|
|
]])], [lv_cv_xdr_cflags=${add_CFLAGS:-none}; break])
|
|
done
|
|
])
|
|
CFLAGS=$old_CFLAGS
|
|
case $lv_cv_xdr_cflags in
|
|
none) XDR_CFLAGS= ;;
|
|
missing) AC_MSG_ERROR([Unable to find <rpc/rpc.h>]) ;;
|
|
*) XDR_CFLAGS=$lv_cv_xdr_cflags ;;
|
|
esac
|
|
AC_SUBST([XDR_CFLAGS])
|
|
fi
|
|
|
|
|
|
dnl
|
|
dnl check for libdl
|
|
dnl
|
|
|
|
dlfcn_found=yes
|
|
dlopen_found=yes
|
|
|
|
AC_CHECK_HEADER([dlfcn.h],, [dlfcn_found=no])
|
|
AC_SEARCH_LIBS([dlopen], [dl],, [dlopen_found=no])
|
|
|
|
case $ac_cv_search_dlopen:$host_os in
|
|
'none required'* | *:mingw* | *:msvc*) DLOPEN_LIBS= ;;
|
|
no*) AC_MSG_ERROR([Unable to find dlopen()]) ;;
|
|
*) if test "x$dlfcn_found" != "xyes"; then
|
|
AC_MSG_ERROR([Unable to find dlfcn.h])
|
|
fi
|
|
DLOPEN_LIBS=$ac_cv_search_dlopen ;;
|
|
esac
|
|
|
|
AC_SUBST([DLOPEN_LIBS])
|
|
|
|
|
|
dnl
|
|
dnl check for VirtualBox XPCOMC location
|
|
dnl
|
|
|
|
vbox_xpcomc_dir=
|
|
|
|
if test "x$with_vbox" != "xyes" && test "x$with_vbox" != "xno"; then
|
|
# intentionally don't do any further checks here on the provided path
|
|
vbox_xpcomc_dir=$with_vbox
|
|
with_vbox=yes
|
|
fi
|
|
|
|
AC_DEFINE_UNQUOTED([VBOX_XPCOMC_DIR], ["$vbox_xpcomc_dir"],
|
|
[Location of directory containing VirtualBox XPCOMC library])
|
|
|
|
if test "x$with_vbox" = "xyes"; then
|
|
AC_DEFINE_UNQUOTED([WITH_VBOX], 1, [whether VirtualBox driver is enabled])
|
|
fi
|
|
AM_CONDITIONAL([WITH_VBOX], [test "$with_vbox" = "yes"])
|
|
|
|
if test "$with_qemu" = "yes" ; then
|
|
AC_DEFINE_UNQUOTED([WITH_QEMU], 1, [whether QEMU driver is enabled])
|
|
fi
|
|
AM_CONDITIONAL([WITH_QEMU], [test "$with_qemu" = "yes"])
|
|
|
|
if test "$with_test" = "yes" ; then
|
|
AC_DEFINE_UNQUOTED([WITH_TEST], 1, [whether Test driver is enabled])
|
|
fi
|
|
AM_CONDITIONAL([WITH_TEST], [test "$with_test" = "yes"])
|
|
|
|
if test "$with_remote" = "yes" ; then
|
|
AC_DEFINE_UNQUOTED([WITH_REMOTE], 1, [whether Remote driver is enabled])
|
|
fi
|
|
AM_CONDITIONAL([WITH_REMOTE], [test "$with_remote" = "yes"])
|
|
|
|
if test "$with_libvirtd" = "yes" ; then
|
|
AC_DEFINE_UNQUOTED([WITH_LIBVIRTD], 1, [whether libvirtd daemon is enabled])
|
|
fi
|
|
AM_CONDITIONAL([WITH_LIBVIRTD], [test "$with_libvirtd" = "yes"])
|
|
|
|
|
|
old_LIBS="$LIBS"
|
|
old_CFLAGS="$CFLAGS"
|
|
LIBXENSERVER_LIBS=""
|
|
LIBXENSERVER_CFLAGS=""
|
|
dnl search for the XenServer library
|
|
fail=0
|
|
if test "$with_xenapi" != "no" ; then
|
|
if test "$with_xenapi" != "yes" && test "$with_xenapi" != "check" ; then
|
|
LIBXENSERVER_CFLAGS="-I$with_xenapi/include"
|
|
LIBXENSERVER_LIBS="-L$with_xenapi"
|
|
fi
|
|
CFLAGS="$CFLAGS $LIBXENSERVER_CFLAGS"
|
|
LIBS="$LIBS $LIBXENSERVER_LIBS"
|
|
AC_CHECK_LIB([xenserver], [xen_vm_start], [
|
|
LIBXENSERVER_LIBS="$LIBXENSERVER_LIBS -lxenserver"
|
|
],[
|
|
if test "$with_xenapi" = "yes"; then
|
|
fail=1
|
|
fi
|
|
with_xenapi=no
|
|
])
|
|
if test "$with_xenapi" != "no" ; then
|
|
if test "$with_curl" = "no"; then
|
|
if test "$with_xenapi" = "yes"; then
|
|
fail=1
|
|
fi
|
|
with_xenapi=no
|
|
else
|
|
with_xenapi=yes
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
LIBS="$old_LIBS"
|
|
CFLAGS="$old_CFLAGS"
|
|
|
|
if test $fail = 1; then
|
|
AC_MSG_ERROR([You must install libxenserver and libcurl to compile the XenAPI driver])
|
|
fi
|
|
|
|
if test "$with_xenapi" = "yes"; then
|
|
AC_DEFINE_UNQUOTED([WITH_XENAPI], 1, [whether XenAPI driver is enabled])
|
|
fi
|
|
|
|
AC_SUBST([LIBXENSERVER_CFLAGS])
|
|
AC_SUBST([LIBXENSERVER_LIBS])
|
|
|
|
old_LIBS="$LIBS"
|
|
old_CFLAGS="$CFLAGS"
|
|
LIBXL_LIBS=""
|
|
LIBXL_CFLAGS=""
|
|
dnl search for libxl, aka libxenlight
|
|
fail=0
|
|
if test "$with_libxl" != "no" ; then
|
|
if test "$with_libxl" != "yes" && test "$with_libxl" != "check" ; then
|
|
LIBXL_CFLAGS="-I$with_libxl/include"
|
|
LIBXL_LIBS="-L$with_libxl"
|
|
fi
|
|
CFLAGS="$CFLAGS $LIBXL_CFLAGS"
|
|
LIBS="$LIBS $LIBXL_LIBS"
|
|
AC_CHECK_LIB([xenlight], [libxl_ctx_alloc], [
|
|
with_libxl=yes
|
|
LIBXL_LIBS="$LIBXL_LIBS -lxenlight -lxenctrl"
|
|
],[
|
|
if test "$with_libxl" = "yes"; then
|
|
fail=1
|
|
fi
|
|
with_libxl=no
|
|
])
|
|
fi
|
|
|
|
LIBS="$old_LIBS"
|
|
CFLAGS="$old_CFLAGS"
|
|
|
|
if test $fail = 1; then
|
|
AC_MSG_ERROR([You must install the libxl Library from Xen >= 4.2 to compile libxenlight driver with -lxl])
|
|
fi
|
|
|
|
if test "$with_libxl" = "yes"; then
|
|
AC_DEFINE_UNQUOTED([WITH_LIBXL], 1, [whether libxenlight driver is enabled])
|
|
fi
|
|
AM_CONDITIONAL([WITH_LIBXL], [test "$with_libxl" = "yes"])
|
|
|
|
AC_SUBST([LIBXL_CFLAGS])
|
|
AC_SUBST([LIBXL_LIBS])
|
|
|
|
old_LIBS="$LIBS"
|
|
old_CFLAGS="$CFLAGS"
|
|
XEN_LIBS=""
|
|
XEN_CFLAGS=""
|
|
dnl search for the Xen store library
|
|
if test "$with_xen" != "no" ; then
|
|
if test "$with_xen" != "yes" && test "$with_xen" != "check" ; then
|
|
XEN_CFLAGS="-I$with_xen/include"
|
|
XEN_LIBS="-L$with_xen/lib64 -L$with_xen/lib"
|
|
fi
|
|
fail=0
|
|
CFLAGS="$CFLAGS $XEN_CFLAGS"
|
|
LIBS="$LIBS $XEN_LIBS"
|
|
AC_CHECK_LIB([xenstore], [xs_read], [
|
|
with_xen=yes
|
|
XEN_LIBS="$XEN_LIBS -lxenstore"
|
|
],[
|
|
if test "$with_xen" = "yes"; then
|
|
fail=1
|
|
fi
|
|
with_xen=no
|
|
])
|
|
fi
|
|
|
|
if test "$with_xen" != "no" ; then
|
|
dnl In Xen 4.2, xs.h is deprecated in favor of xenstore.h.
|
|
AC_CHECK_HEADERS([xenstore.h])
|
|
AC_CHECK_HEADERS([xen/xen.h xen/version.h xen/dom0_ops.h],,[
|
|
if test "$with_xen" = "yes"; then
|
|
fail=1
|
|
fi
|
|
with_xen=no
|
|
],
|
|
[#include <stdio.h>
|
|
#include <stdint.h>
|
|
])
|
|
fi
|
|
|
|
if test "$with_xen" != "no" ; then
|
|
dnl Search for the location of <xen/{linux,sys}/privcmd.h>.
|
|
found=
|
|
AC_CHECK_HEADERS([xen/sys/privcmd.h xen/linux/privcmd.h], [found=yes; break;], [],
|
|
[#include <stdio.h>
|
|
#include <stdint.h>
|
|
#include <xen/xen.h>
|
|
])
|
|
if test "x$found" != "xyes"; then
|
|
if test "$with_xen" = "yes"; then
|
|
fail=1
|
|
fi
|
|
with_xen=no
|
|
fi
|
|
fi
|
|
|
|
LIBS="$old_LIBS"
|
|
CFLAGS="$old_CFLAGS"
|
|
|
|
if test $fail = 1; then
|
|
AC_MSG_ERROR([You must install the Xen development package to compile Xen driver with -lxenstore])
|
|
fi
|
|
|
|
if test "$with_xen" = "yes"; then
|
|
AC_DEFINE_UNQUOTED([WITH_XEN], 1, [whether Xen driver is enabled])
|
|
fi
|
|
|
|
AM_CONDITIONAL([WITH_XEN], [test "$with_xen" = "yes"])
|
|
AC_SUBST([XEN_CFLAGS])
|
|
AC_SUBST([XEN_LIBS])
|
|
|
|
AM_CONDITIONAL([WITH_XENCONFIG], [test "$with_libxl" = "yes" || test "$with_xen" = "yes"])
|
|
|
|
dnl
|
|
dnl check for kernel headers required by xen_inotify
|
|
dnl
|
|
if test "$with_xen" != "yes"; then
|
|
with_xen_inotify=no
|
|
fi
|
|
if test "$with_xen_inotify" != "no"; then
|
|
AC_CHECK_HEADER([sys/inotify.h], [
|
|
with_xen_inotify=yes
|
|
], [
|
|
if test "$with_xen_inotify" = "check"; then
|
|
with_xen_inotify=no
|
|
AC_MSG_NOTICE([Header file <sys/inotify.h> is required for Xen Inotify support, disabling it])
|
|
else
|
|
AC_MSG_ERROR([Header file <sys/inotify.h> is required for Xen Inotify support!])
|
|
fi
|
|
0])
|
|
fi
|
|
if test "$with_xen_inotify" = "yes"; then
|
|
AC_DEFINE_UNQUOTED([WITH_XEN_INOTIFY], 1,[whether Xen inotify sub-driver is enabled])
|
|
fi
|
|
AM_CONDITIONAL([WITH_XEN_INOTIFY], [test "$with_xen_inotify" = "yes"])
|
|
|
|
dnl
|
|
dnl check for kvm headers
|
|
dnl
|
|
AC_CHECK_HEADERS([linux/kvm.h])
|
|
|
|
dnl
|
|
dnl check for sufficient headers for LXC
|
|
dnl
|
|
if test "$with_libvirtd" = "no" ; then
|
|
with_lxc=no
|
|
fi
|
|
if test "$with_lxc" = "yes" || test "$with_lxc" = "check"; then
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM(
|
|
[[
|
|
#include <sched.h>
|
|
#include <linux/loop.h>
|
|
#include <sys/epoll.h>
|
|
]], [[
|
|
unshare(!(LO_FLAGS_AUTOCLEAR + EPOLL_CLOEXEC));
|
|
]])], [
|
|
with_lxc=yes
|
|
AC_DEFINE([HAVE_DECL_LO_FLAGS_AUTOCLEAR], [1],
|
|
[Define to 1 if you have the declaration of `LO_FLAGS_AUTOCLEAR',
|
|
and to 0 if you don't.])
|
|
], [
|
|
if test "$with_lxc" = "check"; then
|
|
with_lxc=no
|
|
AC_MSG_NOTICE([Required kernel features were not found, disabling LXC])
|
|
else
|
|
AC_MSG_ERROR([Required kernel features for LXC were not found])
|
|
fi
|
|
])
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM(
|
|
[[
|
|
#include <sched.h>
|
|
#include <linux/loop.h>
|
|
#include <sys/epoll.h>
|
|
]], [[
|
|
unshare(!(LOOP_CTL_GET_FREE));
|
|
]])], [
|
|
AC_DEFINE([HAVE_DECL_LOOP_CTL_GET_FREE], [1],
|
|
[Define to 1 if you have the declaration of `LOOP_CTL_GET_FREE',
|
|
and to 0 if you don't.])
|
|
])
|
|
fi
|
|
if test "$with_lxc" = "yes" ; then
|
|
AC_DEFINE_UNQUOTED([WITH_LXC], 1, [whether LXC driver is enabled])
|
|
fi
|
|
AM_CONDITIONAL([WITH_LXC], [test "$with_lxc" = "yes"])
|
|
|
|
dnl
|
|
dnl Checks for the Parallels driver
|
|
dnl
|
|
|
|
|
|
if test "$with_parallels" = "yes" ||
|
|
test "$with_parallels" = "check"; then
|
|
PKG_CHECK_MODULES([PARALLELS_SDK], [parallels-sdk],
|
|
[PARALLELS_SDK_FOUND=yes], [PARALLELS_SDK_FOUND=no])
|
|
|
|
if test "$with_parallels" = "yes" && test "$PARALLELS_SDK_FOUND" = "no"; then
|
|
AC_MSG_ERROR([Parallels Virtualization SDK is needed to build the Parallels driver.])
|
|
fi
|
|
|
|
with_parallels=$PARALLELS_SDK_FOUND
|
|
if test "$with_parallels" = "yes"; then
|
|
AC_DEFINE_UNQUOTED([WITH_PARALLELS], 1,
|
|
[whether Parallels driver is enabled])
|
|
fi
|
|
fi
|
|
AM_CONDITIONAL([WITH_PARALLELS], [test "$with_parallels" = "yes"])
|
|
|
|
dnl
|
|
dnl Checks for bhyve driver
|
|
dnl
|
|
|
|
LIBVIRT_DRIVER_CHECK_BHYVE
|
|
|
|
dnl
|
|
dnl check for shell that understands <> redirection without truncation,
|
|
dnl needed by src/qemu/qemu_monitor_{text,json}.c.
|
|
dnl
|
|
if test "$with_qemu" = yes; then
|
|
lv_wrapper_shell=
|
|
AC_CACHE_CHECK([for shell that supports <> redirection],
|
|
[lv_cv_wrapper_shell],
|
|
[
|
|
# If cross-compiling, guess that /bin/sh is good enough except for
|
|
# Linux, where it might be dash 0.5.5 which is known broken; and on
|
|
# Linux, we have a good chance that /bin/bash will exist.
|
|
# If we guess wrong, a user can override the cache variable.
|
|
# Going through /bin/bash is a slight slowdown if /bin/sh works.
|
|
if test "$cross_compiling" = yes; then
|
|
case $host_os in
|
|
linux*) lv_cv_wrapper_shell=/bin/bash ;;
|
|
*) lv_cv_wrapper_shell=/bin/sh ;;
|
|
esac
|
|
else
|
|
for lv_cv_wrapper_shell in /bin/sh bash ksh zsh none; do
|
|
test $lv_cv_wrapper_shell = none &&
|
|
AC_MSG_ERROR([could not find decent shell])
|
|
echo a > conftest.a
|
|
($lv_cv_wrapper_shell -c ': 1<>conftest.a') 2>/dev/null &&
|
|
case `cat conftest.a`.$lv_cv_wrapper_shell in
|
|
a./*) break;; dnl /bin/sh is good enough
|
|
a.*) dnl bash, ksh, and zsh all understand 'command', use that
|
|
dnl to determine the absolute path of the shell
|
|
lv_cv_wrapper_shell=`$lv_cv_wrapper_shell -c \
|
|
"command -v $lv_cv_wrapper_shell"`
|
|
case $lv_cv_wrapper_shell in
|
|
/*) break;;
|
|
esac
|
|
;;
|
|
esac
|
|
done
|
|
rm -f conftest.a
|
|
fi
|
|
])
|
|
if test "x$lv_cv_wrapper_shell" != x/bin/sh; then
|
|
lv_wrapper_shell=$lv_cv_wrapper_shell
|
|
fi
|
|
if test "x$lv_wrapper_shell" != x; then
|
|
AC_DEFINE_UNQUOTED([VIR_WRAPPER_SHELL], ["$lv_wrapper_shell"],
|
|
[Define to the absolute path of a shell that does not truncate on
|
|
<> redirection, if /bin/sh does not fit the bill])
|
|
fi
|
|
fi
|
|
|
|
|
|
dnl
|
|
dnl check for kernel headers required by src/bridge.c
|
|
dnl
|
|
if test "$with_linux" = "yes"; then
|
|
# Various kernel versions have headers that are not self-standing, but
|
|
# yet are incompatible with the corresponding glibc headers. In order
|
|
# to guarantee compilation across a wide range of versions (from RHEL 5
|
|
# to rawhide), we first have to probe whether glibc and kernel can be
|
|
# used in tandem; and if not, provide workarounds that ensure that
|
|
# ABI-compatible IPv6 types are present for use by the kernel headers.
|
|
# These probes mirror the usage in virnetdevbridge.c
|
|
AC_CACHE_CHECK(
|
|
[whether <linux/*.h> and <netinet/*.h> headers are compatible],
|
|
[lv_cv_netinet_linux_compatible],
|
|
[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
|
|
#include <netinet/in.h>
|
|
#include <linux/in6.h>
|
|
]])],
|
|
[lv_cv_netinet_linux_compatible=yes],
|
|
[lv_cv_netinet_linux_compatible=no])])
|
|
if test "x$lv_cv_netinet_linux_compatible" != xyes; then
|
|
AC_DEFINE([NETINET_LINUX_WORKAROUND], [1],
|
|
[define to 1 if Linux kernel headers require a workaround to avoid
|
|
compilation errors when mixed with glibc netinet headers])
|
|
fi
|
|
AC_CHECK_HEADERS([linux/param.h linux/sockios.h linux/if_bridge.h linux/if_tun.h],,
|
|
[AC_MSG_ERROR([You must install kernel-headers in order to compile libvirt with QEMU or LXC support])],
|
|
[[#include <netinet/in.h>
|
|
#if NETINET_LINUX_WORKAROUND
|
|
# define in6_addr in6_addr_
|
|
# define sockaddr_in6 sockaddr_in6_
|
|
# define ipv6_mreq ipv6_mreq_
|
|
# define in6addr_any in6addr_any_
|
|
# define in6addr_loopback in6addr_loopback_
|
|
#endif
|
|
#include <linux/in6.h>
|
|
]])
|
|
fi
|
|
|
|
|
|
dnl Need to test if pkg-config exists
|
|
PKG_PROG_PKG_CONFIG
|
|
|
|
|
|
dnl ==========================================================================
|
|
dnl find libxml2 library, borrowed from xmlsec
|
|
dnl ==========================================================================
|
|
LIBXML_CONFIG="xml2-config"
|
|
LIBXML_CFLAGS=""
|
|
LIBXML_LIBS=""
|
|
LIBXML_FOUND="no"
|
|
|
|
AC_ARG_WITH([libxml], [AS_HELP_STRING([--with-libxml=@<:@PFX@:>@],
|
|
[libxml2 location])])
|
|
if test "x$with_libxml" = "xno" ; then
|
|
AC_MSG_CHECKING(for libxml2 libraries >= $LIBXML_REQUIRED)
|
|
AC_MSG_ERROR([libxml2 >= $LIBXML_REQUIRED is required for libvirt])
|
|
elif test "x$with_libxml" = "x" && test "x$PKG_CONFIG" != "x" ; then
|
|
PKG_CHECK_MODULES(LIBXML, libxml-2.0 >= $LIBXML_REQUIRED, [LIBXML_FOUND=yes], [LIBXML_FOUND=no])
|
|
fi
|
|
if test "$LIBXML_FOUND" = "no" ; then
|
|
if test "x$with_libxml" != "x" ; then
|
|
LIBXML_CONFIG=$with_libxml/bin/$LIBXML_CONFIG
|
|
fi
|
|
AC_MSG_CHECKING(libxml2 $LIBXML_CONFIG >= $LIBXML_REQUIRED )
|
|
if ! $LIBXML_CONFIG --version > /dev/null 2>&1 ; then
|
|
AC_MSG_ERROR([Could not find libxml2 anywhere (see config.log for details).])
|
|
fi
|
|
vers=`$LIBXML_CONFIG --version | awk -F. '{ printf "%d", ($1 * 1000 + $2) * 1000 + $3;}'`
|
|
minvers=`echo $LIBXML_REQUIRED | awk -F. '{ printf "%d", ($1 * 1000 + $2) * 1000 + $3;}'`
|
|
if test "$vers" -ge "$minvers" ; then
|
|
LIBXML_LIBS="`$LIBXML_CONFIG --libs`"
|
|
LIBXML_CFLAGS="`$LIBXML_CONFIG --cflags`"
|
|
LIBXML_FOUND="yes"
|
|
AC_MSG_RESULT(yes)
|
|
else
|
|
AC_MSG_ERROR(
|
|
[You need at least libxml2 $LIBXML_REQUIRED for this version of libvirt])
|
|
fi
|
|
fi
|
|
|
|
AC_SUBST([LIBXML_CFLAGS])
|
|
AC_SUBST([LIBXML_LIBS])
|
|
|
|
dnl xmlURI structure has query_raw?
|
|
old_cflags="$CFLAGS"
|
|
old_libs="$LIBS"
|
|
CFLAGS="$CFLAGS $LIBXML_CFLAGS"
|
|
LIBS="$LIBS $LIBXML_LIBS"
|
|
AC_CHECK_MEMBER([struct _xmlURI.query_raw],
|
|
[AC_DEFINE([HAVE_XMLURI_QUERY_RAW], [], [Have query_raw field in libxml2 xmlURI structure])],,
|
|
[#include <libxml/uri.h>])
|
|
CFLAGS="$old_cflags"
|
|
LIBS="$old_libs"
|
|
|
|
dnl GnuTLS library
|
|
AC_ARG_WITH([gnutls],
|
|
[AS_HELP_STRING([--with-gnutls],
|
|
[use GNUTLS for encryption @<:@default=check@:>@])],
|
|
[],
|
|
[with_gnutls=check])
|
|
|
|
|
|
if test "x$with_gnutls" != "xno"; then
|
|
if test "x$with_gnutls" != "xyes" && test "x$with_gnutls" != "xcheck"; then
|
|
GNUTLS_CFLAGS="-I$with_gnutls/include"
|
|
GNUTLS_LIBS="-L$with_gnutls/lib"
|
|
fi
|
|
fail=0
|
|
old_cflags="$CFLAGS"
|
|
old_libs="$LIBS"
|
|
CFLAGS="$CFLAGS $GNUTLS_CFLAGS"
|
|
LIBS="$LIBS $GNUTLS_LIBS"
|
|
|
|
GNUTLS_FOUND=no
|
|
GNUTLS_GCRYPT=unknown
|
|
if test -x "$PKG_CONFIG" ; then
|
|
dnl Triple probe: gnutls < 2.12 only used gcrypt, gnutls >= 3.0 uses
|
|
dnl only nettle, and versions in between had a configure option.
|
|
dnl Our goal is to avoid gcrypt if we can prove gnutls uses nettle,
|
|
dnl but it is a safe fallback to use gcrypt if we can't prove anything.
|
|
if $PKG_CONFIG --exists 'gnutls >= 3.0'; then
|
|
GNUTLS_GCRYPT=no
|
|
elif $PKG_CONFIG --exists 'gnutls >= 2.12'; then
|
|
GNUTLS_GCRYPT=probe
|
|
else
|
|
GNUTLS_GCRYPT=yes
|
|
fi
|
|
PKG_CHECK_MODULES(GNUTLS, gnutls >= $GNUTLS_REQUIRED,
|
|
[GNUTLS_FOUND=yes], [GNUTLS_FOUND=no])
|
|
fi
|
|
if test "$GNUTLS_FOUND" = "no"; then
|
|
dnl pkg-config couldn't help us, assume gcrypt is necessary
|
|
fail=0
|
|
GNUTLS_GCRYPT=yes
|
|
AC_CHECK_HEADER([gnutls/gnutls.h], [], [fail=1])
|
|
AC_CHECK_LIB([gnutls], [gnutls_handshake],[], [fail=1], [-lgcrypt])
|
|
|
|
test $fail = 0 && GNUTLS_FOUND=yes
|
|
|
|
GNUTLS_LIBS="$GNUTLS_LIBS -lgnutls"
|
|
fi
|
|
if test "$GNUTLS_FOUND" = "no"; then
|
|
if test "$with_gnutls" = "check"; then
|
|
with_gnutls=no
|
|
GNUTLS_LIBS=
|
|
GNUTLS_CFLAGS=
|
|
else
|
|
AC_MSG_ERROR([You must install the GnuTLS library in order to compile and run libvirt])
|
|
fi
|
|
else
|
|
dnl See comments above about when to use gcrypt.
|
|
if test "$GNUTLS_GCRYPT" = probe; then
|
|
case `$PKG_CONFIG --libs --static gnutls` in
|
|
*gcrypt*) GNUTLS_GCRYPT=yes ;;
|
|
*nettle*) GNUTLS_GCRYPT=no ;;
|
|
*) GNUTLS_GCRYPT=unknown ;;
|
|
esac
|
|
fi
|
|
if test "$GNUTLS_GCRYPT" = yes || test "$GNUTLS_GCRYPT" = unknown; then
|
|
GNUTLS_LIBS="$GNUTLS_LIBS -lgcrypt"
|
|
dnl We're not using gcrypt deprecated features so define
|
|
dnl GCRYPT_NO_DEPRECATED to avoid deprecated warnings
|
|
GNUTLS_CFLAGS="$GNUTLS_CFLAGS -DGCRYPT_NO_DEPRECATED"
|
|
AC_DEFINE_UNQUOTED([WITH_GNUTLS_GCRYPT], 1,
|
|
[set to 1 if it is known or assumed that GNUTLS uses gcrypt])
|
|
fi
|
|
|
|
dnl gnutls 3.x moved some declarations to a new header
|
|
AC_CHECK_HEADERS([gnutls/crypto.h], [], [], [[
|
|
#include <gnutls/gnutls.h>
|
|
]])
|
|
|
|
with_gnutls=yes
|
|
fi
|
|
|
|
LIBS="$old_libs"
|
|
CFLAGS="$old_CFLAGS"
|
|
fi
|
|
|
|
if test "x$with_gnutls" = "xyes" ; then
|
|
AC_DEFINE_UNQUOTED([WITH_GNUTLS], 1,
|
|
[whether GNUTLS is available for encryption])
|
|
fi
|
|
AM_CONDITIONAL([WITH_GNUTLS], [test "x$with_gnutls" = "xyes"])
|
|
AC_SUBST([GNUTLS_CFLAGS])
|
|
AC_SUBST([GNUTLS_LIBS])
|
|
|
|
|
|
dnl PolicyKit library
|
|
POLKIT_CFLAGS=
|
|
POLKIT_LIBS=
|
|
PKCHECK_PATH=
|
|
AC_ARG_WITH([polkit],
|
|
[AS_HELP_STRING([--with-polkit],
|
|
[use PolicyKit for UNIX socket access checks @<:@default=check@:>@])],
|
|
[],
|
|
[with_polkit=check])
|
|
|
|
with_polkit0=no
|
|
with_polkit1=no
|
|
if test "x$with_polkit" = "xyes" || test "x$with_polkit" = "xcheck"; then
|
|
dnl Check for new polkit first - just a binary
|
|
AC_PATH_PROG([PKCHECK_PATH],[pkcheck], [], [/usr/sbin:$PATH])
|
|
if test "x$PKCHECK_PATH" != "x" ; then
|
|
AC_DEFINE_UNQUOTED([PKCHECK_PATH],["$PKCHECK_PATH"],[Location of pkcheck program])
|
|
AC_MSG_CHECKING([whether pkcheck supports uid value])
|
|
pkcheck_supports_uid=`$PKG_CONFIG --variable pkcheck_supports_uid polkit-gobject-1`
|
|
if test "x$pkcheck_supports_uid" = "xtrue"; then
|
|
AC_MSG_RESULT([yes])
|
|
AC_DEFINE_UNQUOTED([PKCHECK_SUPPORTS_UID], 1, [Pass uid to pkcheck])
|
|
else
|
|
AC_MSG_RESULT([no])
|
|
fi
|
|
AC_DEFINE_UNQUOTED([WITH_POLKIT], 1,
|
|
[use PolicyKit for UNIX socket access checks])
|
|
AC_DEFINE_UNQUOTED([WITH_POLKIT1], 1,
|
|
[use PolicyKit for UNIX socket access checks])
|
|
with_polkit="yes"
|
|
with_polkit1="yes"
|
|
else
|
|
dnl Check for old polkit second - library + binary
|
|
PKG_CHECK_MODULES(POLKIT, polkit-dbus >= $POLKIT_REQUIRED,
|
|
[with_polkit=yes], [
|
|
if test "x$with_polkit" = "xcheck" ; then
|
|
with_polkit=no
|
|
else
|
|
AC_MSG_ERROR(
|
|
[You must install PolicyKit >= $POLKIT_REQUIRED to compile libvirt])
|
|
fi
|
|
])
|
|
if test "x$with_polkit" = "xyes" ; then
|
|
AC_DEFINE_UNQUOTED([WITH_POLKIT], 1,
|
|
[use PolicyKit for UNIX socket access checks])
|
|
AC_DEFINE_UNQUOTED([WITH_POLKIT0], 1,
|
|
[use PolicyKit for UNIX socket access checks])
|
|
|
|
old_CFLAGS=$CFLAGS
|
|
old_LIBS=$LIBS
|
|
CFLAGS="$CFLAGS $POLKIT_CFLAGS"
|
|
LIBS="$LIBS $POLKIT_LIBS"
|
|
AC_CHECK_FUNCS([polkit_context_is_caller_authorized])
|
|
CFLAGS="$old_CFLAGS"
|
|
LIBS="$old_LIBS"
|
|
|
|
AC_PATH_PROG([POLKIT_AUTH], [polkit-auth])
|
|
if test "x$POLKIT_AUTH" != "x"; then
|
|
AC_DEFINE_UNQUOTED([POLKIT_AUTH],["$POLKIT_AUTH"],[Location of polkit-auth program])
|
|
fi
|
|
with_polkit0="yes"
|
|
fi
|
|
fi
|
|
fi
|
|
AM_CONDITIONAL([WITH_POLKIT], [test "x$with_polkit" = "xyes"])
|
|
AM_CONDITIONAL([WITH_POLKIT0], [test "x$with_polkit0" = "xyes"])
|
|
AM_CONDITIONAL([WITH_POLKIT1], [test "x$with_polkit1" = "xyes"])
|
|
AC_SUBST([POLKIT_CFLAGS])
|
|
AC_SUBST([POLKIT_LIBS])
|
|
|
|
dnl firewalld
|
|
AC_ARG_WITH([firewalld],
|
|
[AS_HELP_STRING([--with-firewalld],
|
|
[enable firewalld support @<:@default=check@:>@])],
|
|
[],
|
|
[with_firewalld=check])
|
|
if test "x$with_firewalld" = "xcheck" ; then
|
|
with_firewalld=$with_dbus
|
|
fi
|
|
if test "x$with_firewalld" = "xyes" ; then
|
|
if test "x$with_dbus" != "xyes" ; then
|
|
AC_MSG_ERROR([You must have dbus enabled for firewalld support])
|
|
fi
|
|
AC_DEFINE_UNQUOTED([HAVE_FIREWALLD], [1], [whether firewalld support is enabled])
|
|
fi
|
|
AM_CONDITIONAL([HAVE_FIREWALLD], [test "x$with_firewalld" != "xno"])
|
|
|
|
|
|
dnl UUCP style file locks for character devices
|
|
if test "$with_chrdev_lock_files" != "no"; then
|
|
case $with_chrdev_lock_files in
|
|
yes | auto)
|
|
dnl Default locations for platforms, or disable if unknown
|
|
if test "$with_linux" = "yes"; then
|
|
with_chrdev_lock_files=/var/lock
|
|
elif test "$with_chrdev_lock_files" = "auto"; then
|
|
with_chrdev_lock_files=no
|
|
fi ;;
|
|
esac
|
|
if test "$with_chrdev_lock_files" = "yes"; then
|
|
AC_MSG_ERROR([You must specify path for the lock files on this
|
|
platform])
|
|
fi
|
|
if test "$with_chrdev_lock_files" != "no"; then
|
|
AC_DEFINE_UNQUOTED([VIR_CHRDEV_LOCK_FILE_PATH], "$with_chrdev_lock_files",
|
|
[path to directory containing UUCP device lock files])
|
|
fi
|
|
fi
|
|
AM_CONDITIONAL([VIR_CHRDEV_LOCK_FILE_PATH], [test "$with_chrdev_lock_files" != "no"])
|
|
|
|
|
|
AC_ARG_WITH([secdriver-selinux],
|
|
[AS_HELP_STRING([--with-secdriver-selinux],
|
|
[use SELinux security driver @<:@default=check@:>@])],
|
|
[],
|
|
[with_secdriver_selinux=check])
|
|
|
|
if test "$with_selinux" != "yes" ; then
|
|
if test "$with_secdriver_selinux" = "check" ; then
|
|
with_secdriver_selinux=no
|
|
fi
|
|
if test "$with_secdriver_selinux" != "no"; then
|
|
AC_MSG_ERROR([You must install the libselinux development package and enable SELinux with the --with-selinux=yes in order to compile libvirt --with-secdriver-selinux=yes])
|
|
fi
|
|
elif test "$with_secdriver_selinux" != "no"; then
|
|
old_cflags="$CFLAGS"
|
|
old_libs="$LIBS"
|
|
CFLAGS="$CFLAGS $SELINUX_CFLAGS"
|
|
LIBS="$CFLAGS $SELINUX_LIBS"
|
|
|
|
fail=0
|
|
AC_CHECK_FUNC([selinux_virtual_domain_context_path], [], [fail=1])
|
|
AC_CHECK_FUNC([selinux_virtual_image_context_path], [], [fail=1])
|
|
AC_CHECK_FUNCS([selinux_lxc_contexts_path])
|
|
CFLAGS="$old_cflags"
|
|
LIBS="$old_libs"
|
|
|
|
if test "$fail" = "1" ; then
|
|
if test "$with_secdriver_selinux" = "check" ; then
|
|
with_secdriver_selinux=no
|
|
else
|
|
AC_MSG_ERROR([You must install libselinux development package >= 2.0.82 in order to compile libvirt --with-secdriver-selinux=yes])
|
|
fi
|
|
else
|
|
with_secdriver_selinux=yes
|
|
AC_DEFINE_UNQUOTED([WITH_SECDRIVER_SELINUX], 1, [whether SELinux security driver is available])
|
|
fi
|
|
fi
|
|
AM_CONDITIONAL([WITH_SECDRIVER_SELINUX], [test "$with_secdriver_selinux" != "no"])
|
|
|
|
|
|
AC_ARG_WITH([secdriver-apparmor],
|
|
[AS_HELP_STRING([--with-secdriver-apparmor],
|
|
[use AppArmor security driver @<:@default=check@:>@])],
|
|
[],
|
|
[with_secdriver_apparmor=check])
|
|
|
|
if test "$with_apparmor" != "yes" ; then
|
|
if test "$with_secdriver_apparmor" = "check" ; then
|
|
with_secdriver_apparmor=no
|
|
fi
|
|
if test "$with_secdriver_apparmor" != "no" ; then
|
|
AC_MSG_ERROR([You must install the AppArmor development package in order to compile libvirt])
|
|
fi
|
|
elif test "with_secdriver_apparmor" != "no" ; then
|
|
with_secdriver_apparmor=yes
|
|
AC_DEFINE_UNQUOTED([WITH_SECDRIVER_APPARMOR], 1, [whether AppArmor security driver is available])
|
|
fi
|
|
AM_CONDITIONAL([WITH_SECDRIVER_APPARMOR], [test "$with_secdriver_apparmor" != "no"])
|
|
|
|
AC_ARG_WITH([apparmor-profiles],
|
|
[AS_HELP_STRING([--with-apparmor-profiles],
|
|
[install apparmor profiles @<:@default=no@:>@])],
|
|
[with_apparmor_profiles=yes],
|
|
[with_apparmor_profiles=no])
|
|
if test "$with_apparmor" = "no"; then
|
|
with_apparmor_profiles="no"
|
|
fi
|
|
AM_CONDITIONAL([WITH_APPARMOR_PROFILES], [test "$with_apparmor_profiles" != "no"])
|
|
|
|
dnl DTrace static probes
|
|
AC_ARG_WITH([dtrace],
|
|
[AS_HELP_STRING([--with-dtrace],
|
|
[use dtrace for static probing @<:@default=check@:>@])],
|
|
[],
|
|
[with_dtrace=check])
|
|
|
|
if test "$with_dtrace" != "no" ; then
|
|
AC_PATH_PROG([DTRACE], [dtrace], [], [/bin:/usr/bin])
|
|
if test -z "$DTRACE" ; then
|
|
if test "$with_dtrace" = "check"; then
|
|
with_dtrace=no
|
|
else
|
|
AC_MSG_ERROR([You must install the 'dtrace' binary to enable libvirt static probes])
|
|
fi
|
|
else
|
|
with_dtrace=yes
|
|
fi
|
|
if test "$with_dtrace" = "yes"; then
|
|
AC_DEFINE_UNQUOTED([WITH_DTRACE_PROBES], 1, [whether DTrace static probes are available])
|
|
fi
|
|
fi
|
|
AM_CONDITIONAL([WITH_DTRACE_PROBES], [test "$with_dtrace" != "no"])
|
|
|
|
|
|
dnl numad
|
|
AC_ARG_WITH([numad],
|
|
[AS_HELP_STRING([--with-numad],
|
|
[use numad to manage CPU placement dynamically @<:@default=check@:>@])],
|
|
[],
|
|
[with_numad=check])
|
|
|
|
if test "$with_numad" != "no" ; then
|
|
fail=0
|
|
|
|
AC_PATH_PROG([NUMAD], [numad], [], [/bin:/usr/bin:/usr/sbin])
|
|
|
|
if test "$with_numad" = "check"; then
|
|
test "$with_numactl" = "yes" || fail=1
|
|
if test -z "$NUMAD" || test $fail = 1; then
|
|
with_numad="no"
|
|
else
|
|
with_numad="yes"
|
|
fi
|
|
else
|
|
test -z "$NUMAD" &&
|
|
AC_MSG_ERROR([You must install numad package to manage CPU and memory placement dynamically])
|
|
|
|
test "$with_numactl" = "yes" || fail=1
|
|
test $fail = 1 &&
|
|
AC_MSG_ERROR([You must install the numactl development package in order to compile and run libvirt])
|
|
fi
|
|
fi
|
|
if test "$with_numad" = "yes"; then
|
|
AC_DEFINE_UNQUOTED([HAVE_NUMAD], 1, [whether numad is available])
|
|
AC_DEFINE_UNQUOTED([NUMAD],["$NUMAD"], [Location or name of the numad program])
|
|
fi
|
|
AM_CONDITIONAL([HAVE_NUMAD], [test "$with_numad" != "no"])
|
|
|
|
dnl pcap lib
|
|
LIBPCAP_CONFIG="pcap-config"
|
|
LIBPCAP_CFLAGS=""
|
|
LIBPCAP_LIBS=""
|
|
LIBPCAP_FOUND="no"
|
|
|
|
AC_ARG_WITH([libpcap], [AS_HELP_STRING([--with-libpcap=@<:@PFX@:>@],
|
|
[libpcap location])])
|
|
if test "$with_qemu" = "yes"; then
|
|
case $with_libpcap in
|
|
no) LIBPCAP_CONFIG= ;;
|
|
''|yes) LIBPCAP_CONFIG="pcap-config" ;;
|
|
*) LIBPCAP_CONFIG="$with_libpcap/bin/pcap-config" ;;
|
|
esac
|
|
AS_IF([test "x$LIBPCAP_CONFIG" != "x"], [
|
|
AC_MSG_CHECKING(libpcap $LIBPCAP_CONFIG >= $LIBPCAP_REQUIRED )
|
|
if ! $LIBPCAP_CONFIG --libs > /dev/null 2>&1 ; then
|
|
AC_MSG_RESULT(no)
|
|
else
|
|
LIBPCAP_LIBS="`$LIBPCAP_CONFIG --libs`"
|
|
LIBPCAP_CFLAGS="`$LIBPCAP_CONFIG --cflags`"
|
|
LIBPCAP_FOUND="yes"
|
|
AC_MSG_RESULT(yes)
|
|
fi
|
|
])
|
|
fi
|
|
|
|
if test "x$LIBPCAP_FOUND" = "xyes"; then
|
|
AC_DEFINE_UNQUOTED([HAVE_LIBPCAP], 1, [whether libpcap can be used])
|
|
fi
|
|
|
|
AC_SUBST([LIBPCAP_CFLAGS])
|
|
AC_SUBST([LIBPCAP_LIBS])
|
|
|
|
|
|
|
|
dnl
|
|
dnl Checks for the UML driver
|
|
dnl
|
|
|
|
if test "$with_libvirtd" = "no" ; then
|
|
with_uml=no
|
|
fi
|
|
if test "$with_uml" = "yes" || test "$with_uml" = "check"; then
|
|
AC_CHECK_HEADER([sys/inotify.h], [
|
|
with_uml=yes
|
|
], [
|
|
if test "$with_uml" = "check"; then
|
|
with_uml=no
|
|
AC_MSG_NOTICE([<sys/inotify.h> is required for the UML driver, disabling it])
|
|
else
|
|
AC_MSG_ERROR([The <sys/inotify.h> is required for the UML driver. Upgrade your libc6.])
|
|
fi
|
|
])
|
|
fi
|
|
if test "$with_uml" = "yes" ; then
|
|
AC_DEFINE_UNQUOTED([WITH_UML], 1, [whether UML driver is enabled])
|
|
fi
|
|
AM_CONDITIONAL([WITH_UML], [test "$with_uml" = "yes"])
|
|
|
|
|
|
|
|
dnl
|
|
dnl check for PHYP
|
|
dnl
|
|
|
|
if test "$with_phyp" != "no"; then
|
|
if test "$with_ssh2" = "no" ; then
|
|
if test "$with_phyp" = "check"; then
|
|
with_phyp=no
|
|
else
|
|
AC_MSG_ERROR([libssh2 is required for Phyp driver])
|
|
fi
|
|
else
|
|
with_phyp=yes
|
|
fi
|
|
fi
|
|
|
|
if test "$with_phyp" = "yes"; then
|
|
AC_DEFINE_UNQUOTED([WITH_PHYP], 1, [whether IBM HMC / IVM driver is enabled])
|
|
fi
|
|
|
|
AM_CONDITIONAL([WITH_PHYP],[test "$with_phyp" = "yes"])
|
|
|
|
dnl
|
|
dnl Should we build with pm-utils support?
|
|
dnl
|
|
if test "$with_pm_utils" = "check"; then
|
|
with_pm_utils=yes
|
|
if test "$with_dbus" = "yes"; then
|
|
if test "$init_systemd" = "yes"; then
|
|
with_pm_utils=no
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
if test "$with_pm_utils" = "yes"; then
|
|
AC_DEFINE_UNQUOTED([WITH_PM_UTILS], 1, [whether to use pm-utils])
|
|
fi
|
|
AM_CONDITIONAL([WITH_PM_UTILS], [test "$with_pm_utils" = "yes"])
|
|
|
|
dnl virsh libraries
|
|
VIRSH_LIBS="$VIRSH_LIBS $READLINE_LIBS"
|
|
AC_SUBST([VIRSH_LIBS])
|
|
|
|
dnl check if the network driver should be compiled
|
|
|
|
AC_ARG_WITH([network],
|
|
[AS_HELP_STRING([--with-network],
|
|
[with virtual network driver @<:@default=yes@:>@])],
|
|
[],[with_network=yes])
|
|
|
|
dnl there's no use compiling the network driver without the libvirt
|
|
dnl daemon, nor compiling it for MacOS X, where it breaks the compile
|
|
|
|
if test "$with_libvirtd" = "no" || test "$with_osx" = "yes"; then
|
|
with_network=no
|
|
fi
|
|
|
|
if test "$with_network" = "yes" ; then
|
|
AC_DEFINE_UNQUOTED([WITH_NETWORK], 1, [whether network driver is enabled])
|
|
fi
|
|
AM_CONDITIONAL([WITH_NETWORK], [test "$with_network" = "yes"])
|
|
|
|
with_bridge=no
|
|
if test "$with_qemu:$with_lxc:$with_network" != "no:no:no"; then
|
|
with_bridge=yes
|
|
AC_DEFINE_UNQUOTED([WITH_BRIDGE], 1, [whether bridge code is needed])
|
|
fi
|
|
AM_CONDITIONAL([WITH_BRIDGE], [test "$with_bridge" = "yes"])
|
|
|
|
|
|
AC_ARG_WITH([secrets],
|
|
[AS_HELP_STRING([--with-secrets],
|
|
[with local secrets management driver @<:@default=yes@:>@])],
|
|
[],[with_secrets=yes])
|
|
|
|
if test "$with_libvirtd" = "no"; then
|
|
with_secrets=no
|
|
fi
|
|
if test "$with_secrets" = "yes" ; then
|
|
AC_DEFINE_UNQUOTED([WITH_SECRETS], 1, [whether local secrets management driver is available])
|
|
fi
|
|
AM_CONDITIONAL([WITH_SECRETS], [test "$with_secrets" = "yes"])
|
|
|
|
|
|
AC_ARG_WITH([storage-dir],
|
|
[AS_HELP_STRING([--with-storage-dir],
|
|
[with directory backend for the storage driver @<:@default=yes@:>@])],
|
|
[],[with_storage_dir=yes])
|
|
AC_ARG_WITH([storage-fs],
|
|
[AS_HELP_STRING([--with-storage-fs],
|
|
[with FileSystem backend for the storage driver @<:@default=check@:>@])],
|
|
[],[with_storage_fs=check])
|
|
AC_ARG_WITH([storage-lvm],
|
|
[AS_HELP_STRING([--with-storage-lvm],
|
|
[with LVM backend for the storage driver @<:@default=check@:>@])],
|
|
[],[with_storage_lvm=check])
|
|
AC_ARG_WITH([storage-iscsi],
|
|
[AS_HELP_STRING([--with-storage-iscsi],
|
|
[with iSCSI backend for the storage driver @<:@default=check@:>@])],
|
|
[],[with_storage_iscsi=check])
|
|
AC_ARG_WITH([storage-scsi],
|
|
[AS_HELP_STRING([--with-storage-scsi],
|
|
[with SCSI backend for the storage driver @<:@default=check@:>@])],
|
|
[],[with_storage_scsi=check])
|
|
AC_ARG_WITH([storage-mpath],
|
|
[AS_HELP_STRING([--with-storage-mpath],
|
|
[with mpath backend for the storage driver @<:@default=check@:>@])],
|
|
[],[with_storage_mpath=check])
|
|
AC_ARG_WITH([storage-disk],
|
|
[AS_HELP_STRING([--with-storage-disk],
|
|
[with GPartd Disk backend for the storage driver @<:@default=check@:>@])],
|
|
[],[with_storage_disk=check])
|
|
AC_ARG_WITH([storage-rbd],
|
|
[AS_HELP_STRING([--with-storage-rbd],
|
|
[with RADOS Block Device backend for the storage driver
|
|
@<:@default=check@:>@])],
|
|
[],[with_storage_rbd=check])
|
|
AC_ARG_WITH([storage-sheepdog],
|
|
[AS_HELP_STRING([--with-storage-sheepdog],
|
|
[with Sheepdog backend for the storage driver @<:@default=check@:>@])],
|
|
[],[with_storage_sheepdog=check])
|
|
AC_ARG_WITH([storage-gluster],
|
|
[AS_HELP_STRING([--with-storage-gluster],
|
|
[with Gluster backend for the storage driver @<:@default=check@:>@])],
|
|
[],[with_storage_gluster=check])
|
|
AC_ARG_WITH([storage-zfs],
|
|
[AS_HELP_STRING([--with-storage-zfs],
|
|
[with ZFS backend for the storage driver @<:@default=check@:>@])],
|
|
[],[with_storage_zfs=check])
|
|
|
|
if test "$with_libvirtd" = "no"; then
|
|
with_storage_dir=no
|
|
with_storage_fs=no
|
|
with_storage_lvm=no
|
|
with_storage_iscsi=no
|
|
with_storage_scsi=no
|
|
with_storage_mpath=no
|
|
with_storage_disk=no
|
|
with_storage_rbd=no
|
|
with_storage_sheepdog=no
|
|
with_storage_gluster=no
|
|
with_storage_zfs=no
|
|
fi
|
|
if test "$with_storage_dir" = "yes" ; then
|
|
AC_DEFINE_UNQUOTED([WITH_STORAGE_DIR], 1, [whether directory backend for storage driver is enabled])
|
|
fi
|
|
AM_CONDITIONAL([WITH_STORAGE_DIR], [test "$with_storage_dir" = "yes"])
|
|
|
|
dnl storage-fs does not work on MacOS X
|
|
|
|
if test "$with_osx" = "yes"; then
|
|
with_storage_fs=no
|
|
fi
|
|
|
|
if test "$with_storage_fs" = "yes" || test "$with_storage_fs" = "check"; then
|
|
AC_CHECK_HEADER([mntent.h],,
|
|
[
|
|
if test "$with_storage_fs" = "check"; then
|
|
with_storage_fs=no
|
|
AC_MSG_NOTICE([<mntent.h> is required for the FS storage driver, disabling it])
|
|
else
|
|
AC_MSG_ERROR([<mntent.h> is required for the FS storage driver])
|
|
fi
|
|
])
|
|
fi
|
|
|
|
if test "$with_storage_fs" = "yes" || test "$with_storage_fs" = "check"; then
|
|
AC_PATH_PROG([MOUNT], [mount], [], [$PATH:/sbin:/usr/sbin])
|
|
AC_PATH_PROG([UMOUNT], [umount], [], [$PATH:/sbin:/usr/sbin])
|
|
AC_PATH_PROG([MKFS], [mkfs], [], [$PATH:/sbin:/usr/sbin])
|
|
if test "$with_storage_fs" = "yes" ; then
|
|
if test -z "$MOUNT" ; then AC_MSG_ERROR([We need mount for FS storage driver]) ; fi
|
|
if test -z "$UMOUNT" ; then AC_MSG_ERROR([We need umount for FS storage driver]) ; fi
|
|
if test -z "$MKFS" ; then AC_MSG_ERROR([We need mkfs for FS storage driver]) ; fi
|
|
else
|
|
if test -z "$MOUNT" ; then with_storage_fs=no ; fi
|
|
if test -z "$UMOUNT" ; then with_storage_fs=no ; fi
|
|
if test -z "$MKFS" ; then with_storage_fs=no ; fi
|
|
|
|
if test "$with_storage_fs" = "check" ; then with_storage_fs=yes ; fi
|
|
fi
|
|
|
|
if test "$with_storage_fs" = "yes" ; then
|
|
AC_DEFINE_UNQUOTED([WITH_STORAGE_FS], 1, [whether FS backend for storage driver is enabled])
|
|
AC_DEFINE_UNQUOTED([MOUNT],["$MOUNT"],
|
|
[Location or name of the mount program])
|
|
AC_DEFINE_UNQUOTED([UMOUNT],["$UMOUNT"],
|
|
[Location or name of the mount program])
|
|
AC_DEFINE_UNQUOTED([MKFS],["$MKFS"],
|
|
[Location or name of the mkfs program])
|
|
fi
|
|
fi
|
|
AM_CONDITIONAL([WITH_STORAGE_FS], [test "$with_storage_fs" = "yes"])
|
|
if test "$with_storage_fs" = "yes"; then
|
|
AC_PATH_PROG([SHOWMOUNT], [showmount], [], [$PATH:/sbin:/usr/sbin])
|
|
AC_DEFINE_UNQUOTED([SHOWMOUNT], ["$SHOWMOUNT"],
|
|
[Location or name of the showmount program])
|
|
fi
|
|
|
|
if test "$with_storage_lvm" = "yes" || test "$with_storage_lvm" = "check"; then
|
|
AC_PATH_PROG([PVCREATE], [pvcreate], [], [$PATH:/sbin:/usr/sbin])
|
|
AC_PATH_PROG([VGCREATE], [vgcreate], [], [$PATH:/sbin:/usr/sbin])
|
|
AC_PATH_PROG([LVCREATE], [lvcreate], [], [$PATH:/sbin:/usr/sbin])
|
|
AC_PATH_PROG([PVREMOVE], [pvremove], [], [$PATH:/sbin:/usr/sbin])
|
|
AC_PATH_PROG([VGREMOVE], [vgremove], [], [$PATH:/sbin:/usr/sbin])
|
|
AC_PATH_PROG([LVREMOVE], [lvremove], [], [$PATH:/sbin:/usr/sbin])
|
|
AC_PATH_PROG([LVCHANGE], [lvchange], [], [$PATH:/sbin:/usr/sbin])
|
|
AC_PATH_PROG([VGCHANGE], [vgchange], [], [$PATH:/sbin:/usr/sbin])
|
|
AC_PATH_PROG([VGSCAN], [vgscan], [], [$PATH:/sbin:/usr/sbin])
|
|
AC_PATH_PROG([PVS], [pvs], [], [$PATH:/sbin:/usr/sbin])
|
|
AC_PATH_PROG([VGS], [vgs], [], [$PATH:/sbin:/usr/sbin])
|
|
AC_PATH_PROG([LVS], [lvs], [], [$PATH:/sbin:/usr/sbin])
|
|
|
|
if test "$with_storage_lvm" = "yes" ; then
|
|
if test -z "$PVCREATE" ; then AC_MSG_ERROR([We need pvcreate for LVM storage driver]) ; fi
|
|
if test -z "$VGCREATE" ; then AC_MSG_ERROR([We need vgcreate for LVM storage driver]) ; fi
|
|
if test -z "$LVCREATE" ; then AC_MSG_ERROR([We need lvcreate for LVM storage driver]) ; fi
|
|
if test -z "$PVREMOVE" ; then AC_MSG_ERROR([We need pvremove for LVM storage driver]) ; fi
|
|
if test -z "$VGREMOVE" ; then AC_MSG_ERROR([We need vgremove for LVM storage driver]) ; fi
|
|
if test -z "$LVREMOVE" ; then AC_MSG_ERROR([We need lvremove for LVM storage driver]) ; fi
|
|
if test -z "$LVCHANGE" ; then AC_MSG_ERROR([We need lvchange for LVM storage driver]) ; fi
|
|
if test -z "$VGCHANGE" ; then AC_MSG_ERROR([We need vgchange for LVM storage driver]) ; fi
|
|
if test -z "$VGSCAN" ; then AC_MSG_ERROR([We need vgscan for LVM storage driver]) ; fi
|
|
if test -z "$PVS" ; then AC_MSG_ERROR([We need pvs for LVM storage driver]) ; fi
|
|
if test -z "$VGS" ; then AC_MSG_ERROR([We need vgs for LVM storage driver]) ; fi
|
|
if test -z "$LVS" ; then AC_MSG_ERROR([We need lvs for LVM storage driver]) ; fi
|
|
else
|
|
if test -z "$PVCREATE" ; then with_storage_lvm=no ; fi
|
|
if test -z "$VGCREATE" ; then with_storage_lvm=no ; fi
|
|
if test -z "$LVCREATE" ; then with_storage_lvm=no ; fi
|
|
if test -z "$PVREMOVE" ; then with_storage_lvm=no ; fi
|
|
if test -z "$VGREMOVE" ; then with_storage_lvm=no ; fi
|
|
if test -z "$LVREMOVE" ; then with_storage_lvm=no ; fi
|
|
if test -z "$LVCHANGE" ; then with_storage_lvm=no ; fi
|
|
if test -z "$VGCHANGE" ; then with_storage_lvm=no ; fi
|
|
if test -z "$VGSCAN" ; then with_storage_lvm=no ; fi
|
|
if test -z "$PVS" ; then with_storage_lvm=no ; fi
|
|
if test -z "$VGS" ; then with_storage_lvm=no ; fi
|
|
if test -z "$LVS" ; then with_storage_lvm=no ; fi
|
|
|
|
if test "$with_storage_lvm" = "check" ; then with_storage_lvm=yes ; fi
|
|
fi
|
|
|
|
if test "$with_storage_lvm" = "yes" ; then
|
|
AC_DEFINE_UNQUOTED([WITH_STORAGE_LVM], 1, [whether LVM backend for storage driver is enabled])
|
|
AC_DEFINE_UNQUOTED([PVCREATE],["$PVCREATE"],[Location of pvcreate program])
|
|
AC_DEFINE_UNQUOTED([VGCREATE],["$VGCREATE"],[Location of vgcreate program])
|
|
AC_DEFINE_UNQUOTED([LVCREATE],["$LVCREATE"],[Location of lvcreate program])
|
|
AC_DEFINE_UNQUOTED([PVREMOVE],["$PVREMOVE"],[Location of pvremove program])
|
|
AC_DEFINE_UNQUOTED([VGREMOVE],["$VGREMOVE"],[Location of vgremove program])
|
|
AC_DEFINE_UNQUOTED([LVREMOVE],["$LVREMOVE"],[Location of lvremove program])
|
|
AC_DEFINE_UNQUOTED([LVCHANGE],["$LVCHANGE"],[Location of lvchange program])
|
|
AC_DEFINE_UNQUOTED([VGCHANGE],["$VGCHANGE"],[Location of vgchange program])
|
|
AC_DEFINE_UNQUOTED([VGSCAN],["$VGSCAN"],[Location of vgscan program])
|
|
AC_DEFINE_UNQUOTED([PVS],["$PVS"],[Location of pvs program])
|
|
AC_DEFINE_UNQUOTED([VGS],["$VGS"],[Location of vgs program])
|
|
AC_DEFINE_UNQUOTED([LVS],["$LVS"],[Location of lvs program])
|
|
fi
|
|
fi
|
|
AM_CONDITIONAL([WITH_STORAGE_LVM], [test "$with_storage_lvm" = "yes"])
|
|
|
|
|
|
|
|
if test "$with_storage_iscsi" = "yes" || test "$with_storage_iscsi" = "check"; then
|
|
AC_PATH_PROG([ISCSIADM], [iscsiadm], [], [$PATH:/sbin:/usr/sbin])
|
|
if test "$with_storage_iscsi" = "yes" ; then
|
|
if test -z "$ISCSIADM" ; then AC_MSG_ERROR([We need iscsiadm for iSCSI storage driver]) ; fi
|
|
else
|
|
if test -z "$ISCSIADM" ; then with_storage_iscsi=no ; fi
|
|
|
|
if test "$with_storage_iscsi" = "check" ; then with_storage_iscsi=yes ; fi
|
|
fi
|
|
|
|
if test "$with_storage_iscsi" = "yes" ; then
|
|
AC_DEFINE_UNQUOTED([WITH_STORAGE_ISCSI], 1, [whether iSCSI backend for storage driver is enabled])
|
|
fi
|
|
fi
|
|
if test -z "$ISCIADM" ; then
|
|
AC_DEFINE_UNQUOTED([ISCSIADM],["iscsiadm"],[Name of iscsiadm program])
|
|
else
|
|
AC_DEFINE_UNQUOTED([ISCSIADM],["$ISCSIADM"],[Location of iscsiadm program])
|
|
fi
|
|
AM_CONDITIONAL([WITH_STORAGE_ISCSI], [test "$with_storage_iscsi" = "yes"])
|
|
|
|
if test "$with_storage_scsi" = "check"; then
|
|
with_storage_scsi=yes
|
|
|
|
AC_DEFINE_UNQUOTED([WITH_STORAGE_SCSI], 1,
|
|
[whether SCSI backend for storage driver is enabled])
|
|
fi
|
|
AM_CONDITIONAL([WITH_STORAGE_SCSI], [test "$with_storage_scsi" = "yes"])
|
|
|
|
if test "$with_storage_mpath" = "check"; then
|
|
if test "$with_linux" = "yes"; then
|
|
with_storage_mpath=yes
|
|
|
|
AC_DEFINE_UNQUOTED([WITH_STORAGE_MPATH], 1,
|
|
[whether mpath backend for storage driver is enabled])
|
|
else
|
|
with_storage_mpath=no
|
|
fi
|
|
fi
|
|
AM_CONDITIONAL([WITH_STORAGE_MPATH], [test "$with_storage_mpath" = "yes"])
|
|
|
|
LIBRBD_LIBS=
|
|
if test "$with_storage_rbd" = "yes" || test "$with_storage_rbd" = "check"; then
|
|
AC_CHECK_HEADER([rbd/librbd.h], [LIBRBD_FOUND=yes; break;])
|
|
|
|
if test "$LIBRBD_FOUND" = "yes"; then
|
|
with_storage_rbd=yes
|
|
LIBRBD_LIBS="-lrbd -lrados"
|
|
AC_DEFINE_UNQUOTED([WITH_STORAGE_RBD], [1],
|
|
[whether RBD backend for storage driver is enabled])
|
|
else
|
|
with_storage_rbd=no
|
|
fi
|
|
fi
|
|
AM_CONDITIONAL([WITH_STORAGE_RBD], [test "$with_storage_rbd" = "yes"])
|
|
AC_SUBST([LIBRBD_LIBS])
|
|
|
|
if test "$with_storage_sheepdog" = "yes" ||
|
|
test "$with_storage_sheepdog" = "check"; then
|
|
AC_PATH_PROG([COLLIE], [collie], [], [$PATH:/sbin:/usr/sbin])
|
|
|
|
if test "$with_storage_sheepdog" = "yes"; then
|
|
if test -z "$COLLIE"; then
|
|
AC_MSG_ERROR([We need collie for Sheepdog storage driver])
|
|
fi
|
|
else
|
|
if test -z "$COLLIE"; then
|
|
with_storage_sheepdog=no
|
|
fi
|
|
|
|
if test "$with_storage_sheepdog" = "check"; then
|
|
with_storage_sheepdog=yes
|
|
fi
|
|
fi
|
|
|
|
if test "$with_storage_sheepdog" = "yes"; then
|
|
AC_DEFINE_UNQUOTED([WITH_STORAGE_SHEEPDOG], 1,
|
|
[whether Sheepdog backend for storage driver is enabled])
|
|
AC_DEFINE_UNQUOTED([COLLIE],["$COLLIE"],[Location of collie program])
|
|
fi
|
|
fi
|
|
AM_CONDITIONAL([WITH_STORAGE_SHEEPDOG],
|
|
[test "$with_storage_sheepdog" = "yes"])
|
|
|
|
if test "$with_storage_gluster" = "check"; then
|
|
with_storage_gluster=$with_glusterfs
|
|
fi
|
|
if test "$with_storage_gluster" = "yes"; then
|
|
if test "$with_glusterfs" = no; then
|
|
AC_MSG_ERROR([Need glusterfs (libgfapi) for gluster storage driver])
|
|
fi
|
|
AC_DEFINE_UNQUOTED([WITH_STORAGE_GLUSTER], [1],
|
|
[whether Gluster backend for storage driver is enabled])
|
|
fi
|
|
AM_CONDITIONAL([WITH_STORAGE_GLUSTER], [test "$with_storage_gluster" = "yes"])
|
|
|
|
if test "$with_storage_zfs" = "check"; then
|
|
with_storage_zfs=$with_freebsd
|
|
fi
|
|
|
|
if test "$with_storage_zfs" = "yes" && test "$with_freebsd" = "no"; then
|
|
AC_MSG_ERROR([The ZFS storage driver can be enabled on FreeBSD only.])
|
|
fi
|
|
|
|
if test "$with_storage_zfs" = "yes" ||
|
|
test "$with_storage_zfs" = "check"; then
|
|
AC_PATH_PROG([ZFS], [zfs], [], [$PATH:/sbin:/usr/sbin])
|
|
AC_PATH_PROG([ZPOOL], [zpool], [], [$PATH:/sbin:/usr/sbin])
|
|
|
|
if test "$with_storage_zfs" = "yes"; then
|
|
if test -z "$ZFS" || test -z "$ZPOOL"; then
|
|
AC_MSG_ERROR([We need zfs and zpool for ZFS storage driver])
|
|
fi
|
|
else
|
|
if test -z "$ZFS" || test -z "$ZPOOL"; then
|
|
with_storage_zfs=no
|
|
fi
|
|
|
|
if test "$with_storage_zfs" = "check"; then
|
|
with_storage_zfs=yes
|
|
fi
|
|
fi
|
|
|
|
if test "$with_storage_zfs" = "yes"; then
|
|
AC_DEFINE_UNQUOTED([WITH_STORAGE_ZFS], 1,
|
|
[whether ZFS backend for storage driver is enabled])
|
|
AC_DEFINE_UNQUOTED([ZFS], ["$ZFS"], [Location of zfs program])
|
|
AC_DEFINE_UNQUOTED([ZPOOL], ["$ZPOOL"], [Location of zpool program])
|
|
fi
|
|
fi
|
|
AM_CONDITIONAL([WITH_STORAGE_ZFS],
|
|
[test "$with_storage_zfs" = "yes"])
|
|
|
|
if test "$with_storage_fs" = "yes" ||
|
|
test "$with_storage_gluster" = "yes"; then
|
|
AC_PATH_PROG([GLUSTER_CLI], [gluster], [], [$PATH:/sbin:/usr/sbin])
|
|
if test "x$GLUSTER_CLI" != "x"; then
|
|
AC_DEFINE_UNQUOTED([GLUSTER_CLI], ["$GLUSTER_CLI"],
|
|
[Location or name of the gluster command line tool])
|
|
fi
|
|
fi
|
|
|
|
LIBPARTED_CFLAGS=
|
|
LIBPARTED_LIBS=
|
|
if test "$with_storage_disk" = "yes" ||
|
|
test "$with_storage_disk" = "check"; then
|
|
AC_PATH_PROG([PARTED], [parted], [], [$PATH:/sbin:/usr/sbin])
|
|
AC_PATH_PROG([DMSETUP], [dmsetup], [], [$PATH:/sbin:/usr/sbin])
|
|
if test -z "$PARTED" ; then
|
|
PARTED_FOUND=no
|
|
else
|
|
PARTED_FOUND=yes
|
|
fi
|
|
|
|
if test -z "$DMSETUP" ; then
|
|
DMSETUP_FOUND=no
|
|
else
|
|
DMSETUP_FOUND=yes
|
|
fi
|
|
|
|
if test "$PARTED_FOUND" = "yes" && test "x$PKG_CONFIG" != "x" ; then
|
|
PKG_CHECK_MODULES([LIBPARTED], [libparted >= $PARTED_REQUIRED], [],
|
|
[PARTED_FOUND=no])
|
|
fi
|
|
if test "$PARTED_FOUND" = "no"; then
|
|
# RHEL-5 vintage parted is missing pkg-config files
|
|
save_LIBS="$LIBS"
|
|
save_CFLAGS="$CFLAGS"
|
|
PARTED_FOUND=yes
|
|
AC_CHECK_HEADER([parted/parted.h],,[PARTED_FOUND=no])
|
|
AC_CHECK_LIB([uuid], [uuid_generate],,[PARTED_FOUND=no])
|
|
AC_CHECK_LIB([parted], [ped_device_read],,[PARTED_FOUND=no])
|
|
LIBPARTED_LIBS="-luuid -lparted"
|
|
LIBS="$save_LIBS"
|
|
CFLAGS="$save_CFLAGS"
|
|
fi
|
|
|
|
if test "$with_storage_disk" = "yes" &&
|
|
test "$PARTED_FOUND:$DMSETUP_FOUND" != "yes:yes"; then
|
|
AC_MSG_ERROR([Need both parted and dmsetup for disk storage driver])
|
|
fi
|
|
|
|
if test "$with_storage_disk" = "check"; then
|
|
if test "$PARTED_FOUND:$DMSETUP_FOUND" != "yes:yes"; then
|
|
with_storage_disk=no
|
|
else
|
|
with_storage_disk=yes
|
|
fi
|
|
fi
|
|
|
|
if test "$with_storage_disk" = "yes"; then
|
|
AC_DEFINE_UNQUOTED([WITH_STORAGE_DISK], 1,
|
|
[whether Disk backend for storage driver is enabled])
|
|
AC_DEFINE_UNQUOTED([PARTED],["$PARTED"],
|
|
[Location or name of the parted program])
|
|
AC_DEFINE_UNQUOTED([DMSETUP],["$DMSETUP"],
|
|
[Location or name of the dmsetup program])
|
|
fi
|
|
fi
|
|
AM_CONDITIONAL([WITH_STORAGE_DISK], [test "$with_storage_disk" = "yes"])
|
|
AC_SUBST([LIBPARTED_CFLAGS])
|
|
AC_SUBST([LIBPARTED_LIBS])
|
|
|
|
if test "$with_storage_mpath" = "yes" ||
|
|
test "$with_storage_disk" = "yes"; then
|
|
DEVMAPPER_CFLAGS=
|
|
DEVMAPPER_LIBS=
|
|
PKG_CHECK_MODULES([DEVMAPPER], [devmapper >= $DEVMAPPER_REQUIRED], [], [DEVMAPPER_FOUND=no])
|
|
if test "$DEVMAPPER_FOUND" = "no"; then
|
|
# devmapper is missing pkg-config files in ubuntu, suse, etc
|
|
save_LIBS="$LIBS"
|
|
save_CFLAGS="$CFLAGS"
|
|
DEVMAPPER_FOUND=yes
|
|
AC_CHECK_LIB([devmapper], [dm_task_run],,[DEVMAPPER_FOUND=no])
|
|
DEVMAPPER_LIBS="-ldevmapper"
|
|
LIBS="$save_LIBS"
|
|
CFLAGS="$save_CFLAGS"
|
|
fi
|
|
AC_CHECK_HEADERS([libdevmapper.h],,[DEVMAPPER_FOUND=no])
|
|
if test "$DEVMAPPER_FOUND" = "no" ; then
|
|
AC_MSG_ERROR([You must install device-mapper-devel/libdevmapper >= $DEVMAPPER_REQUIRED to compile libvirt])
|
|
fi
|
|
|
|
fi
|
|
AC_SUBST([DEVMAPPER_CFLAGS])
|
|
AC_SUBST([DEVMAPPER_LIBS])
|
|
|
|
with_storage=no
|
|
for backend in dir fs lvm iscsi scsi mpath rbd disk; do
|
|
if eval test \$with_storage_$backend = yes; then
|
|
with_storage=yes
|
|
break
|
|
fi
|
|
done
|
|
if test $with_storage = yes; then
|
|
AC_DEFINE([WITH_STORAGE], [1],
|
|
[Define to 1 if at least one storage backend is in use])
|
|
fi
|
|
AM_CONDITIONAL([WITH_STORAGE], [test "$with_storage" = "yes"])
|
|
|
|
dnl
|
|
dnl check for (ESX)
|
|
dnl
|
|
|
|
if test "$with_curl" != "yes" ; then
|
|
if test "$with_esx" != "yes"; then
|
|
with_esx=no
|
|
else
|
|
AC_MSG_ERROR([Curl is required for the ESX driver])
|
|
fi
|
|
else
|
|
if test "$with_esx" = "check"; then
|
|
with_esx=yes
|
|
fi
|
|
fi
|
|
|
|
if test "$with_esx" = "yes" ; then
|
|
AC_DEFINE_UNQUOTED([WITH_ESX], 1, [whether ESX driver is enabled])
|
|
fi
|
|
AM_CONDITIONAL([WITH_ESX], [test "$with_esx" = "yes"])
|
|
|
|
with_vmx=yes
|
|
if test "$with_esx" != "yes" && test "$with_vmware" != "yes"; then
|
|
with_vmx=no
|
|
fi
|
|
if test "$with_vmx" = "yes" ; then
|
|
AC_DEFINE_UNQUOTED([WITH_VMX], 1, [whether VMware VMX config handling is enabled])
|
|
fi
|
|
AM_CONDITIONAL([WITH_VMX], [test "$with_vmx" = "yes"])
|
|
|
|
if test "$with_xenapi" = "yes" ; then
|
|
AC_DEFINE_UNQUOTED([WITH_XENAPI], 1, [whether XenAPI driver is enabled])
|
|
fi
|
|
AM_CONDITIONAL([WITH_XENAPI], [test "$with_xenapi" = "yes"])
|
|
|
|
|
|
dnl
|
|
dnl check for Hyper-V
|
|
dnl
|
|
|
|
if test "$with_hyperv" != "no"; then
|
|
if test "$with_openwsman" != "yes"; then
|
|
if test "$with_hyperv" = "check"; then
|
|
with_hyperv=no
|
|
else
|
|
AC_MSG_ERROR([openwsman is required for the Hyper-V driver])
|
|
fi
|
|
else
|
|
with_hyperv=yes
|
|
fi
|
|
fi
|
|
|
|
if test "$with_hyperv" = "yes" ; then
|
|
AC_DEFINE_UNQUOTED([WITH_HYPERV], 1, [whether Hyper-V driver is enabled])
|
|
fi
|
|
AM_CONDITIONAL([WITH_HYPERV], [test "$with_hyperv" = "yes"])
|
|
|
|
|
|
dnl Allow perl/python overrides
|
|
AC_PATH_PROGS([PYTHON], [python2 python])
|
|
AC_PATH_PROG([PERL], [perl])
|
|
if test -z "$PERL"; then
|
|
AC_MSG_ERROR([Failed to find perl.])
|
|
fi
|
|
|
|
AC_ARG_WITH([test-suite],
|
|
[AS_HELP_STRING([--with-test-suite],
|
|
[build test suite by default @<:@default=check@:>@])],
|
|
[case "${withval}" in
|
|
yes|no|check) ;;
|
|
*) AC_MSG_ERROR([bad value ${withval} for tests option]) ;;
|
|
esac],
|
|
[withval=check])
|
|
|
|
AC_MSG_CHECKING([Whether to build test suite by default])
|
|
if test "$withval" = "check" ; then
|
|
if test -d $srcdir/.git ; then
|
|
withval=yes
|
|
else
|
|
withval=no
|
|
fi
|
|
fi
|
|
AC_MSG_RESULT([$withval])
|
|
AM_CONDITIONAL([WITH_TESTS], [test "$withval" = "yes"])
|
|
|
|
AC_ARG_ENABLE([expensive-tests],
|
|
[AS_HELP_STRING([--enable-expensive-tests],
|
|
[set the default for enabling expensive tests (gnulib and long timeouts) ]
|
|
[@<:@default=check@:>@; use VIR_TEST_EXPENSIVE to override during make])],
|
|
[case $enableval in
|
|
0|no) VIR_TEST_EXPENSIVE_DEFAULT=0 ;;
|
|
1|yes) VIR_TEST_EXPENSIVE_DEFAULT=1 ;;
|
|
check) ;;
|
|
*) AC_MSG_ERROR([bad value ${enableval} for enable-expensive-tests option])
|
|
;;
|
|
esac], [enableval=check])
|
|
if test "$enableval" = check; then
|
|
if test -d $srcdir/.git ; then
|
|
VIR_TEST_EXPENSIVE_DEFAULT=0
|
|
else
|
|
VIR_TEST_EXPENSIVE_DEFAULT=1
|
|
fi
|
|
fi
|
|
AC_SUBST([VIR_TEST_EXPENSIVE_DEFAULT])
|
|
AM_CONDITIONAL([WITH_EXPENSIVE_TESTS], [test $VIR_TEST_EXPENSIVE_DEFAULT = 1])
|
|
|
|
AC_ARG_ENABLE([test-coverage],
|
|
[AS_HELP_STRING([--enable-test-coverage],
|
|
[turn on code coverage instrumentation @<:@default=no@:>@])],
|
|
[case "${enableval}" in
|
|
yes|no) ;;
|
|
*) AC_MSG_ERROR([bad value ${enableval} for test-coverage option]) ;;
|
|
esac],
|
|
[enableval=no])
|
|
enable_coverage=$enableval
|
|
|
|
if test "${enable_coverage}" = yes; then
|
|
save_WARN_CFLAGS=$WARN_CFLAGS
|
|
WARN_CFLAGS=
|
|
gl_WARN_ADD([-fprofile-arcs])
|
|
gl_WARN_ADD([-ftest-coverage])
|
|
COVERAGE_FLAGS=$WARN_CFLAGS
|
|
AC_SUBST([COVERAGE_CFLAGS], [$COVERAGE_FLAGS])
|
|
AC_SUBST([COVERAGE_LDFLAGS], [$COVERAGE_FLAGS])
|
|
WARN_CFLAGS=$save_WARN_CFLAGS
|
|
fi
|
|
|
|
AC_ARG_ENABLE([test-oom],
|
|
[AS_HELP_STRING([--enable-test-oom],
|
|
[memory allocation failure checking @<:@default=no@:>@])],
|
|
[case "${enableval}" in
|
|
yes|no) ;;
|
|
*) AC_MSG_ERROR([bad value ${enableval} for test-oom option]) ;;
|
|
esac],
|
|
[enableval=no])
|
|
enable_oom=$enableval
|
|
|
|
if test "${enable_oom}" = yes; then
|
|
have_trace=yes
|
|
AC_CHECK_HEADER([execinfo.h],[],[have_trace=no])
|
|
AC_CHECK_FUNC([backtrace],[],[have_trace=no])
|
|
if test "$have_trace" = "yes"; then
|
|
AC_DEFINE([TEST_OOM_TRACE], 1, [Whether backtrace() is available])
|
|
fi
|
|
AC_DEFINE([TEST_OOM], 1, [Whether malloc OOM checking is enabled])
|
|
fi
|
|
|
|
|
|
AC_ARG_ENABLE([test-locking],
|
|
[AS_HELP_STRING([--enable-test-locking],
|
|
[thread locking tests using CIL @<:@default=no@:>@])],
|
|
[case "${enableval}" in
|
|
yes|no) ;;
|
|
*) AC_MSG_ERROR([bad value ${enableval} for test-locking option]) ;;
|
|
esac],
|
|
[enableval=no])
|
|
enable_locking=$enableval
|
|
|
|
if test "$enable_locking" = "yes"; then
|
|
LOCK_CHECKING_CFLAGS="-save-temps"
|
|
AC_SUBST([LOCK_CHECKING_CFLAGS])
|
|
fi
|
|
AM_CONDITIONAL([WITH_CIL],[test "$enable_locking" = "yes"])
|
|
|
|
dnl Enable building libvirtd?
|
|
AM_CONDITIONAL([WITH_LIBVIRTD],[test "x$with_libvirtd" = "xyes"])
|
|
|
|
dnl Check for gettext - don't go any newer than what RHEL 5 supports
|
|
dnl
|
|
dnl save and restore CPPFLAGS around gettext check as the internal iconv
|
|
dnl check might leave -I/usr/local/include in CPPFLAGS on FreeBSD resulting
|
|
dnl in the build picking up previously installed libvirt/libvirt.h instead
|
|
dnl of the correct one from the source tree.
|
|
dnl compute the difference between save_CPPFLAGS and CPPFLAGS and append it
|
|
dnl to INCLUDES in order to preserve changes made by gettext but in a place
|
|
dnl that does not break the build
|
|
save_CPPFLAGS="$CPPFLAGS"
|
|
AM_GNU_GETTEXT_VERSION([0.17])
|
|
AM_GNU_GETTEXT([external])
|
|
GETTEXT_CPPFLAGS=
|
|
if test "x$save_CPPFLAGS" != "x$CPPFLAGS"; then
|
|
set dummy $CPPFLAGS; shift
|
|
for var
|
|
do
|
|
case " $var " in
|
|
" $save_CPPFLAGS ") ;;
|
|
*) GETTEXT_CPPFLAGS="$GETTEXT_CPPFLAGS $var" ;;
|
|
esac
|
|
done
|
|
fi
|
|
CPPFLAGS="$save_CPPFLAGS"
|
|
AC_SUBST([GETTEXT_CPPFLAGS])
|
|
|
|
ALL_LINGUAS=`cd "$srcdir/po" > /dev/null && ls *.po | sed 's+\.po$++'`
|
|
|
|
dnl Extra link-time flags for Cygwin.
|
|
dnl Copied from libxml2 configure.in, but I removed mingw changes
|
|
dnl for now since I'm not supporting mingw at present. - RWMJ
|
|
CYGWIN_EXTRA_LDFLAGS=
|
|
CYGWIN_EXTRA_LIBADD=
|
|
MINGW_EXTRA_LDFLAGS=
|
|
WIN32_EXTRA_CFLAGS=
|
|
dnl libvirt.syms is generated in builddir, but libvirt_qemu.syms is in git;
|
|
dnl hence the asymmetric naming of these two symbol files.
|
|
LIBVIRT_SYMBOL_FILE=libvirt.syms
|
|
LIBVIRT_LXC_SYMBOL_FILE='$(srcdir)/libvirt_lxc.syms'
|
|
LIBVIRT_QEMU_SYMBOL_FILE='$(srcdir)/libvirt_qemu.syms'
|
|
MSCOM_LIBS=
|
|
case "$host" in
|
|
*-*-cygwin*)
|
|
CYGWIN_EXTRA_LDFLAGS="-no-undefined"
|
|
CYGWIN_EXTRA_LIBADD="${INTLLIBS}"
|
|
MSCOM_LIBS="-lole32 -loleaut32"
|
|
;;
|
|
*-*-mingw*)
|
|
MINGW_EXTRA_LDFLAGS="-no-undefined"
|
|
MSCOM_LIBS="-lole32 -loleaut32"
|
|
;;
|
|
*-*-msvc*)
|
|
MSCOM_LIBS="-lole32 -loleaut32"
|
|
;;
|
|
esac
|
|
case "$host" in
|
|
*-*-mingw* | *-*-cygwin* | *-*-msvc* )
|
|
# If the host is Windows, and shared libraries are disabled, we
|
|
# need to add -DLIBVIRT_STATIC to the CFLAGS for proper linking
|
|
if test "x$enable_shared" = "xno"; then
|
|
WIN32_EXTRA_CFLAGS="-DLIBVIRT_STATIC"
|
|
fi
|
|
esac
|
|
case "$host" in
|
|
*-*-mingw* | *-*-msvc* )
|
|
# Also set the symbol file to .def, so src/Makefile generates libvirt.def
|
|
# from libvirt.syms and passes libvirt.def instead of libvirt.syms to the linker
|
|
LIBVIRT_SYMBOL_FILE=libvirt.def
|
|
LIBVIRT_LXC_SYMBOL_FILE=libvirt_lxc.def
|
|
LIBVIRT_QEMU_SYMBOL_FILE=libvirt_qemu.def
|
|
# mingw's ld has the --version-script parameter, but it requires a .def file
|
|
# instead to work properly, therefore clear --version-script here and use
|
|
# -Wl, to pass the .def file to the linker
|
|
# cygwin's ld has the --version-script parameter too, but for some reason
|
|
# it's working there as expected
|
|
VERSION_SCRIPT_FLAGS="-Wl,"
|
|
;;
|
|
esac
|
|
AC_SUBST([CYGWIN_EXTRA_LDFLAGS])
|
|
AC_SUBST([CYGWIN_EXTRA_LIBADD])
|
|
AC_SUBST([MINGW_EXTRA_LDFLAGS])
|
|
AC_SUBST([WIN32_EXTRA_CFLAGS])
|
|
AC_SUBST([LIBVIRT_SYMBOL_FILE])
|
|
AC_SUBST([LIBVIRT_LXC_SYMBOL_FILE])
|
|
AC_SUBST([LIBVIRT_QEMU_SYMBOL_FILE])
|
|
AC_SUBST([VERSION_SCRIPT_FLAGS])
|
|
AC_SUBST([MSCOM_LIBS])
|
|
|
|
|
|
dnl Look for windres to build a Windows icon resource.
|
|
case "$host" in
|
|
*-*-mingw* | *-*-cygwin* | *-*-msvc* )
|
|
AC_CHECK_TOOL([WINDRES], [windres], [])
|
|
;;
|
|
esac
|
|
AM_CONDITIONAL([WITH_WIN_ICON], [test "$WINDRES" != ""])
|
|
|
|
|
|
dnl Driver-Modules library
|
|
AC_ARG_WITH([driver-modules],
|
|
[AS_HELP_STRING([--with-driver-modules],
|
|
[build drivers as loadable modules @<:@default=check@:>@])],
|
|
[],
|
|
[with_driver_modules=check])
|
|
|
|
if test "$with_libvirtd" = "no" ; then
|
|
with_driver_modules=no
|
|
fi
|
|
|
|
DRIVER_MODULE_CFLAGS=
|
|
DRIVER_MODULE_LIBS=
|
|
if test "$with_driver_modules" = "yes" || test "$with_driver_modules" = "check"; then
|
|
if test "$dlfcn_found" != "yes" || test "$dlopen_found" != "yes"; then
|
|
if test "$with_driver_modules" = "yes" ; then
|
|
AC_MSG_ERROR([You must have dlfcn.h / dlopen() support to build driver modules])
|
|
else
|
|
with_driver_modules=no
|
|
fi
|
|
else
|
|
with_driver_modules=yes
|
|
fi
|
|
fi
|
|
|
|
if test "$with_driver_modules" = "yes" ; then
|
|
DRIVER_MODULE_LDFLAGS="-export-dynamic"
|
|
case $ac_cv_search_dlopen in
|
|
no*) DRIVER_MODULE_LIBS= ;;
|
|
*) DRIVER_MODULE_LIBS=$ac_cv_search_dlopen ;;
|
|
esac
|
|
AC_DEFINE_UNQUOTED([WITH_DRIVER_MODULES], 1, [whether to build drivers as modules])
|
|
fi
|
|
AM_CONDITIONAL([WITH_DRIVER_MODULES], [test "$with_driver_modules" != "no"])
|
|
AC_SUBST([DRIVER_MODULE_LDFLAGS])
|
|
AC_SUBST([DRIVER_MODULE_LIBS])
|
|
|
|
|
|
# Set LV_LIBTOOL_OBJDIR to "." or $lt_cv_objdir, depending on whether
|
|
# we're building shared libraries. This is the name of the directory
|
|
# in which .o files will be created.
|
|
test "$enable_shared" = no && lt_cv_objdir=.
|
|
LV_LIBTOOL_OBJDIR=${lt_cv_objdir-.}
|
|
AC_SUBST([LV_LIBTOOL_OBJDIR])
|
|
|
|
|
|
with_nodedev=no;
|
|
if test "$with_hal" = "yes" || test "$with_udev" = "yes";
|
|
then
|
|
with_nodedev=yes
|
|
AC_DEFINE_UNQUOTED([WITH_NODE_DEVICES], 1, [with node device driver])
|
|
fi
|
|
AM_CONDITIONAL([WITH_NODE_DEVICES], [test "$with_nodedev" = "yes"])
|
|
|
|
dnl nwfilter should only be compiled for linux, and only if the
|
|
dnl libvirt daemon is also being compiled
|
|
|
|
with_nwfilter=yes
|
|
if test "$with_libvirtd" = "no" || test "$with_linux" != "yes"; then
|
|
with_nwfilter=no
|
|
fi
|
|
if test "$with_nwfilter" = "yes" ; then
|
|
AC_DEFINE([WITH_NWFILTER], 1, [whether local network filter management driver is available])
|
|
fi
|
|
AM_CONDITIONAL([WITH_NWFILTER], [test "$with_nwfilter" = "yes"])
|
|
|
|
dnl check if the interface driver should be compiled
|
|
AC_ARG_WITH([interface],
|
|
[AS_HELP_STRING([--with-interface],
|
|
[with host interface driver @<:@default=check@:>@])],
|
|
[],[with_interface=check])
|
|
|
|
dnl Don't compile the interface driver without libvirtd
|
|
if test "$with_libvirtd" = "no" ; then
|
|
with_interface=no
|
|
fi
|
|
|
|
dnl The interface driver depends on the netcf library or udev library
|
|
case $with_interface:$with_netcf:$with_udev in
|
|
check:*yes*) with_interface=yes ;;
|
|
check:no:no) with_interface=no ;;
|
|
yes:no:no) AC_MSG_ERROR([Requested the Interface driver without netcf or udev support]) ;;
|
|
esac
|
|
|
|
if test "$with_interface" = "yes" ; then
|
|
AC_DEFINE_UNQUOTED([WITH_INTERFACE], [1],
|
|
[whether the interface driver is enabled])
|
|
fi
|
|
AM_CONDITIONAL([WITH_INTERFACE], [test "$with_interface" = "yes"])
|
|
|
|
|
|
if test $with_freebsd = yes || test $with_osx = yes; then
|
|
default_qemu_user=root
|
|
default_qemu_group=wheel
|
|
else
|
|
default_qemu_user=root
|
|
default_qemu_group=root
|
|
fi
|
|
|
|
AC_ARG_WITH([qemu-user],
|
|
[AS_HELP_STRING([--with-qemu-user],
|
|
[username to run QEMU system instance as
|
|
@<:@default=platform dependent@:>@])],
|
|
[QEMU_USER=${withval}],
|
|
[QEMU_USER=${default_qemu_user}])
|
|
AC_ARG_WITH([qemu-group],
|
|
[AS_HELP_STRING([--with-qemu-group],
|
|
[groupname to run QEMU system instance as
|
|
@<:@default=platform dependent@:>@])],
|
|
[QEMU_GROUP=${withval}],
|
|
[QEMU_GROUP=${default_qemu_group}])
|
|
AC_DEFINE_UNQUOTED([QEMU_USER], ["$QEMU_USER"], [QEMU user account])
|
|
AC_DEFINE_UNQUOTED([QEMU_GROUP], ["$QEMU_GROUP"], [QEMU group account])
|
|
|
|
|
|
AC_ARG_WITH([macvtap],
|
|
[AS_HELP_STRING([--with-macvtap],
|
|
[enable macvtap device @<:@default=check@:>@])],
|
|
[with_macvtap=${withval}],
|
|
[with_macvtap=check])
|
|
|
|
AC_MSG_CHECKING([whether to compile with macvtap support])
|
|
if test "$with_macvtap" != "no" ; then
|
|
AC_TRY_COMPILE([ #include <sys/socket.h>
|
|
#include <linux/rtnetlink.h> ],
|
|
[ int x = MACVLAN_MODE_BRIDGE;
|
|
int y = IFLA_VF_MAX; ],
|
|
[ with_macvtap=yes ],
|
|
[ if test "$with_macvtap" = "yes" ; then
|
|
AC_MSG_ERROR([Installed linux headers don't show support for macvtap device.])
|
|
fi
|
|
with_macvtap=no ])
|
|
if test "$with_macvtap" = "yes" ; then
|
|
val=1
|
|
else
|
|
val=0
|
|
fi
|
|
AC_DEFINE_UNQUOTED([WITH_MACVTAP], $val, [whether macvtap support is enabled])
|
|
fi
|
|
AM_CONDITIONAL([WITH_MACVTAP], [test "$with_macvtap" = "yes"])
|
|
AC_MSG_RESULT([$with_macvtap])
|
|
if test "$with_macvtap" = yes; then
|
|
AC_CHECK_DECLS([MACVLAN_MODE_PASSTHRU], [], [], [[
|
|
#include <sys/socket.h>
|
|
#include <linux/if_link.h>
|
|
]])
|
|
fi
|
|
|
|
|
|
AC_ARG_WITH([virtualport],
|
|
[AS_HELP_STRING([--with-virtualport],
|
|
[enable virtual port support @<:@default=check@:>@])],
|
|
[with_virtualport=${withval}],
|
|
[with_virtualport=check])
|
|
|
|
dnl Warn the user and error out if they requested virtualport support with configure
|
|
dnl options, but the required macvtap support isn't available
|
|
|
|
if test "$with_virtualport" = "yes"; then
|
|
if test "$with_macvtap" = "no"; then
|
|
AC_MSG_ERROR([--with-virtualport requires --with-macvtap])
|
|
fi
|
|
fi
|
|
|
|
dnl virtualport checks
|
|
|
|
if test "$with_macvtap" != "yes"; then
|
|
with_virtualport=no
|
|
fi
|
|
if test "$with_virtualport" != "no"; then
|
|
AC_MSG_CHECKING([whether to compile with virtual port support])
|
|
AC_TRY_COMPILE([ #include <sys/socket.h>
|
|
#include <linux/rtnetlink.h> ],
|
|
[ int x = IFLA_PORT_MAX; ],
|
|
[ with_virtualport=yes ],
|
|
[ if test "$with_virtualport" = "yes" ; then
|
|
AC_MSG_ERROR([Installed linux headers don't show support for virtual port support.])
|
|
fi
|
|
with_virtualport=no ])
|
|
if test "$with_virtualport" = "yes"; then
|
|
val=1
|
|
else
|
|
val=0
|
|
fi
|
|
AC_DEFINE_UNQUOTED([WITH_VIRTUALPORT], $val,
|
|
[whether vsi vepa support is enabled])
|
|
AC_MSG_RESULT([$with_virtualport])
|
|
fi
|
|
AM_CONDITIONAL([WITH_VIRTUALPORT], [test "$with_virtualport" = "yes"])
|
|
|
|
dnl GET_VLAN_VID_CMD is required for virNetDevGetVLanID
|
|
AC_CHECK_DECLS([GET_VLAN_VID_CMD], [], [], [[#include <linux/if_vlan.h>]])
|
|
|
|
dnl netlink library
|
|
|
|
have_libnl=no
|
|
|
|
if test "$with_linux" = "yes"; then
|
|
# When linking with netcf, we must ensure that we pick the same version
|
|
# of libnl that netcf picked. Prefer libnl-3 unless we can prove
|
|
# netcf linked against libnl-1, or unless the user set LIBNL_CFLAGS.
|
|
# (Setting LIBNL_CFLAGS is already used by PKG_CHECK_MODULES to
|
|
# override any probing, so if it set, you know which libnl is in use.)
|
|
libnl_ldd=
|
|
for dir in /usr/lib64 /usr/lib /usr/lib/*-linux-gnu*; do
|
|
if test -f $dir/libnetcf.so; then
|
|
libnl_ldd=`(ldd $dir/libnetcf.so) 2>&1`
|
|
break
|
|
fi
|
|
done
|
|
case $libnl_ldd:${LIBNL_CFLAGS+set} in
|
|
*libnl-3.so.*:) LIBNL_REQUIRED=3.0 ;;
|
|
esac
|
|
case $libnl_ldd:${LIBNL_CFLAGS+set} in
|
|
*libnl.so.1*:) ;;
|
|
*)
|
|
PKG_CHECK_MODULES([LIBNL], [libnl-3.0], [
|
|
have_libnl=yes
|
|
AC_DEFINE([HAVE_LIBNL3], [1], [Use libnl-3.0])
|
|
AC_DEFINE([HAVE_LIBNL], [1], [whether the netlink library is available])
|
|
PKG_CHECK_MODULES([LIBNL_ROUTE3], [libnl-route-3.0])
|
|
LIBNL_CFLAGS="$LIBNL_CFLAGS $LIBNL_ROUTE3_CFLAGS"
|
|
LIBNL_LIBS="$LIBNL_LIBS $LIBNL_ROUTE3_LIBS"
|
|
], [:]) ;;
|
|
esac
|
|
if test "$have_libnl" = no; then
|
|
PKG_CHECK_MODULES([LIBNL], [libnl-1 >= $LIBNL_REQUIRED], [
|
|
have_libnl=yes
|
|
AC_DEFINE_UNQUOTED([HAVE_LIBNL], [1],
|
|
[whether the netlink library is available])
|
|
AC_DEFINE_UNQUOTED([HAVE_LIBNL1], [1],
|
|
[whether the netlink v1 library is available])
|
|
], [
|
|
if test "$with_macvtap" = "yes"; then
|
|
if test "$LIBNL_REQUIRED" = "3.0";then
|
|
AC_MSG_ERROR([libnl3-devel >= $LIBNL_REQUIRED is required for macvtap support])
|
|
else
|
|
AC_MSG_ERROR([libnl-devel >= $LIBNL_REQUIRED is required for macvtap support])
|
|
fi
|
|
fi
|
|
])
|
|
fi
|
|
fi
|
|
AM_CONDITIONAL([HAVE_LIBNL], [test "$have_libnl" = "yes"])
|
|
|
|
AC_SUBST([LIBNL_CFLAGS])
|
|
AC_SUBST([LIBNL_LIBS])
|
|
|
|
dnl wireshark dissector
|
|
|
|
AC_ARG_WITH([wireshark-dissector],
|
|
[AS_HELP_STRING([--with-wireshark-dissector],
|
|
[enable wireshark dissector plugin support @<:@default=check@:>@])],
|
|
[ with_wireshark_dissector=$withval ],
|
|
[ with_wireshark_dissector=check ])
|
|
|
|
AC_DEFUN([LIBVIRT_WS_HANDLE_ERROR], [
|
|
if test "$with_wireshark_dissector" = "yes"; then
|
|
AC_MSG_ERROR([$1])
|
|
else
|
|
with_wireshark_dissector=no
|
|
fi
|
|
])
|
|
if test "$with_wireshark_dissector" != "no"; then
|
|
dnl Check for XDR headers existence
|
|
AC_CHECK_HEADERS([rpc/types.h])
|
|
|
|
dnl Check for glib-2.0 existence
|
|
PKG_CHECK_MODULES([GLIB], [glib-2.0], [
|
|
WS_DISSECTOR_CPPFLAGS="$WS_DISSECTOR_CPPFLAGS `$PKG_CONFIG --cflags glib-2.0`"
|
|
], [
|
|
LIBVIRT_WS_HANDLE_ERROR([pkg-config 'glib-2.0' is required for wireshark-dissector support])
|
|
])
|
|
|
|
dnl Search for wireshark(or tshark) command
|
|
AC_PATH_PROG([WIRESHARK], [wireshark])
|
|
AC_PATH_PROG([WIRESHARK], [tshark])
|
|
if test -z "$WIRESHARK"; then
|
|
LIBVIRT_WS_HANDLE_ERROR([command not found wireshark or tshark])
|
|
else
|
|
dnl Check for wireshark headers
|
|
save_CPPFLAGS="$CPPFLAGS"
|
|
WS_DISSECTOR_CPPFLAGS="$WS_DISSECTOR_CPPFLAGS -I`dirname $WIRESHARK`/../include/wireshark"
|
|
CPPFLAGS="$CPPFLAGS $WS_DISSECTOR_CPPFLAGS"
|
|
AC_CHECK_HEADERS([wireshark/config.h],, [
|
|
LIBVIRT_WS_HANDLE_ERROR([wireshark/config.h is required for wireshark-dissector support])
|
|
])
|
|
AC_CHECK_HEADERS([wireshark/epan/packet.h wireshark/epan/dissectors/packet-tcp.h],, [
|
|
LIBVIRT_WS_HANDLE_ERROR([wireshark/epan/{packet,packet-tcp}.h are required for wireshark-dissector support])
|
|
], [
|
|
#include <wireshark/config.h>
|
|
])
|
|
CPPFLAGS="$save_CPPFLAGS"
|
|
fi
|
|
if test "$with_wireshark_dissector" != "no"; then
|
|
with_wireshark_dissector=yes
|
|
fi
|
|
fi
|
|
AC_SUBST([WS_DISSECTOR_CPPFLAGS])
|
|
AM_CONDITIONAL([WITH_WIRESHARK_DISSECTOR], [test "$with_wireshark_dissector" = "yes"])
|
|
|
|
AC_ARG_WITH([ws-plugindir],
|
|
[AS_HELP_STRING([--with-ws-plugindir],
|
|
[wireshark plugins directory for use when installing wireshark plugin])],
|
|
[ws_plugindir=$withval])
|
|
|
|
if test "$with_wireshark_dissector" != "no" && test -z "$ws_plugindir"; then
|
|
ws_version=`$WIRESHARK -v | head -1 | cut -f 2 -d' '`
|
|
ws_plugindir="$libdir/wireshark/plugins/$ws_version"
|
|
fi
|
|
AC_SUBST([ws_plugindir])
|
|
|
|
# Check for Linux vs. BSD ifreq members
|
|
AC_CHECK_MEMBERS([struct ifreq.ifr_newname,
|
|
struct ifreq.ifr_ifindex,
|
|
struct ifreq.ifr_index,
|
|
struct ifreq.ifr_hwaddr],
|
|
[], [],
|
|
[#include <sys/socket.h>
|
|
#include <net/if.h>
|
|
])
|
|
|
|
# Check for BSD approach for setting MAC addr
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM(
|
|
[[
|
|
#include <sys/types.h>
|
|
#include <sys/socket.h>
|
|
#include <net/if_dl.h>
|
|
]],
|
|
[[
|
|
link_addr(0, 0)]])],
|
|
[AC_DEFINE([HAVE_DECL_LINK_ADDR],
|
|
[1],
|
|
[whether link_addr is available])])
|
|
|
|
# Check for BSD approach for bridge management
|
|
AC_CHECK_DECLS([BRDGSFD, BRDGADD, BRDGDEL],
|
|
[AC_DEFINE([HAVE_BSD_BRIDGE_MGMT],
|
|
[1],
|
|
[whether BSD style bridge management is available])],
|
|
[],
|
|
[#include <stdint.h>
|
|
#include <net/if.h>
|
|
#include <net/ethernet.h>
|
|
#include <net/if_bridgevar.h>
|
|
])
|
|
|
|
# Check for BSD CPU affinity availability
|
|
AC_CHECK_DECLS([cpuset_getaffinity],
|
|
[AC_DEFINE([HAVE_BSD_CPU_AFFINITY],
|
|
[1],
|
|
[whether BSD CPU affinity management is available])],
|
|
[],
|
|
[#include <sys/param.h>
|
|
#include <sys/cpuset.h>
|
|
])
|
|
|
|
# Check for BSD kvm (kernel memory interface)
|
|
if test $with_freebsd = yes; then
|
|
AC_CHECK_LIB([kvm], [kvm_getprocs], [],
|
|
[AC_MSG_ERROR([BSD kernel memory interface library is required to build on FreeBSD])]
|
|
)
|
|
fi
|
|
|
|
# FreeBSD 10-STABLE requires _IFI_OQDROPS to be defined for if_data.ifi_oqdrops
|
|
# field be available
|
|
old_CFLAGS="$CFLAGS"
|
|
CFLAGS="$CFLAGS -D_IFI_OQDROPS"
|
|
|
|
AC_CHECK_MEMBERS([struct if_data.ifi_oqdrops],
|
|
[],
|
|
[CFLAGS="$old_CFLAGS"],
|
|
[#include <net/if.h>
|
|
])
|
|
|
|
# Check if we need to look for ifconfig
|
|
if test "$want_ifconfig" = "yes"; then
|
|
AC_PATH_PROG([IFCONFIG_PATH], [ifconfig])
|
|
if test -z "$IFCONFIG_PATH"; then
|
|
AC_MSG_ERROR([Failed to find ifconfig.])
|
|
fi
|
|
AC_DEFINE_UNQUOTED([IFCONFIG_PATH], "$IFCONFIG_PATH", [path to ifconfig binary])
|
|
fi
|
|
|
|
# Detect when running under the clang static analyzer's scan-build driver
|
|
# or Coverity-prevent's cov-build. Define STATIC_ANALYSIS accordingly.
|
|
AC_CACHE_CHECK([whether this build is done by a static analysis tool],
|
|
[lv_cv_static_analysis], [
|
|
lv_cv_static_analysis=no
|
|
if test -n "${CCC_ANALYZER_ANALYSIS+set}" || \
|
|
test -n "$COVERITY_BUILD_COMMAND$COVERITY_LD_PRELOAD"; then
|
|
lv_cv_static_analysis=yes
|
|
fi
|
|
])
|
|
t=0
|
|
test "x$lv_cv_static_analysis" = xyes && t=1
|
|
AC_DEFINE_UNQUOTED([STATIC_ANALYSIS], [$t],
|
|
[Define to 1 when performing static analysis.])
|
|
|
|
AC_ARG_WITH([default-editor],
|
|
[AS_HELP_STRING([--with-default-editor],
|
|
[Editor to use for interactive commands
|
|
@<:@default=vi@:>@])],
|
|
[DEFAULT_EDITOR=${withval}],
|
|
[DEFAULT_EDITOR=vi])
|
|
AC_DEFINE_UNQUOTED([DEFAULT_EDITOR], ["$DEFAULT_EDITOR"], [Default editor to use])
|
|
|
|
# Some GNULIB base64 symbols clash with a kerberos library
|
|
AC_DEFINE_UNQUOTED([isbase64],[libvirt_gl_isbase64],[Hack to avoid symbol clash])
|
|
AC_DEFINE_UNQUOTED([base64_encode],[libvirt_gl_base64_encode],[Hack to avoid symbol clash])
|
|
AC_DEFINE_UNQUOTED([base64_encode_alloc],[libvirt_gl_base64_encode_alloc],[Hack to avoid symbol clash])
|
|
|
|
AC_CONFIG_FILES([run],
|
|
[chmod +x,-w run])
|
|
AC_CONFIG_FILES([\
|
|
Makefile src/Makefile include/Makefile docs/Makefile \
|
|
docs/schemas/Makefile \
|
|
gnulib/lib/Makefile \
|
|
gnulib/tests/Makefile \
|
|
libvirt.pc \
|
|
libvirt-qemu.pc \
|
|
libvirt-lxc.pc \
|
|
src/libvirt.pc \
|
|
src/libvirt-qemu.pc \
|
|
src/libvirt-lxc.pc \
|
|
libvirt.spec mingw-libvirt.spec \
|
|
po/Makefile.in \
|
|
include/libvirt/Makefile include/libvirt/libvirt.h \
|
|
daemon/Makefile \
|
|
tools/Makefile \
|
|
tests/Makefile \
|
|
examples/apparmor/Makefile \
|
|
examples/object-events/Makefile \
|
|
examples/domsuspend/Makefile \
|
|
examples/dominfo/Makefile \
|
|
examples/dommigrate/Makefile \
|
|
examples/domtop/Makefile \
|
|
examples/openauth/Makefile \
|
|
examples/hellolibvirt/Makefile \
|
|
examples/systemtap/Makefile \
|
|
examples/xml/nwfilter/Makefile \
|
|
examples/lxcconvert/Makefile \
|
|
tools/wireshark/Makefile \
|
|
tools/wireshark/src/Makefile])
|
|
AC_OUTPUT
|
|
|
|
AC_MSG_NOTICE([])
|
|
AC_MSG_NOTICE([Configuration summary])
|
|
AC_MSG_NOTICE([=====================])
|
|
AC_MSG_NOTICE([])
|
|
AC_MSG_NOTICE([Drivers])
|
|
AC_MSG_NOTICE([])
|
|
AC_MSG_NOTICE([ Xen: $with_xen])
|
|
AC_MSG_NOTICE([ QEMU: $with_qemu])
|
|
AC_MSG_NOTICE([ UML: $with_uml])
|
|
AC_MSG_NOTICE([ OpenVZ: $with_openvz])
|
|
AC_MSG_NOTICE([ VMware: $with_vmware])
|
|
AC_MSG_NOTICE([ VBox: $with_vbox])
|
|
AC_MSG_NOTICE([ XenAPI: $with_xenapi])
|
|
AC_MSG_NOTICE([ xenlight: $with_libxl])
|
|
AC_MSG_NOTICE([ LXC: $with_lxc])
|
|
AC_MSG_NOTICE([ PHYP: $with_phyp])
|
|
AC_MSG_NOTICE([ ESX: $with_esx])
|
|
AC_MSG_NOTICE([ Hyper-V: $with_hyperv])
|
|
AC_MSG_NOTICE([Parallels: $with_parallels])
|
|
LIBVIRT_DRIVER_RESULT_BHYVE
|
|
AC_MSG_NOTICE([ Test: $with_test])
|
|
AC_MSG_NOTICE([ Remote: $with_remote])
|
|
AC_MSG_NOTICE([ Network: $with_network])
|
|
AC_MSG_NOTICE([ Libvirtd: $with_libvirtd])
|
|
AC_MSG_NOTICE([Interface: $with_interface])
|
|
AC_MSG_NOTICE([ macvtap: $with_macvtap])
|
|
AC_MSG_NOTICE([ virtport: $with_virtualport])
|
|
AC_MSG_NOTICE([])
|
|
AC_MSG_NOTICE([Storage Drivers])
|
|
AC_MSG_NOTICE([])
|
|
AC_MSG_NOTICE([ Dir: $with_storage_dir])
|
|
AC_MSG_NOTICE([ FS: $with_storage_fs])
|
|
AC_MSG_NOTICE([ NetFS: $with_storage_fs])
|
|
AC_MSG_NOTICE([ LVM: $with_storage_lvm])
|
|
AC_MSG_NOTICE([ iSCSI: $with_storage_iscsi])
|
|
AC_MSG_NOTICE([ SCSI: $with_storage_scsi])
|
|
AC_MSG_NOTICE([ mpath: $with_storage_mpath])
|
|
AC_MSG_NOTICE([ Disk: $with_storage_disk])
|
|
AC_MSG_NOTICE([ RBD: $with_storage_rbd])
|
|
AC_MSG_NOTICE([Sheepdog: $with_storage_sheepdog])
|
|
AC_MSG_NOTICE([ Gluster: $with_storage_gluster])
|
|
AC_MSG_NOTICE([ ZFS: $with_storage_zfs])
|
|
AC_MSG_NOTICE([])
|
|
AC_MSG_NOTICE([Security Drivers])
|
|
AC_MSG_NOTICE([])
|
|
AC_MSG_NOTICE([ SELinux: $with_secdriver_selinux ($SELINUX_MOUNT)])
|
|
AC_MSG_NOTICE([AppArmor: $with_secdriver_apparmor (install profiles: $with_apparmor_profiles)])
|
|
AC_MSG_NOTICE([])
|
|
AC_MSG_NOTICE([Driver Loadable Modules])
|
|
AC_MSG_NOTICE([])
|
|
if test "$with_driver_modules" != "no" ; then
|
|
AC_MSG_NOTICE([ dlopen: $DRIVER_MODULE_CFLAGS $DRIVER_MODULE_LIBS])
|
|
else
|
|
AC_MSG_NOTICE([ dlopen: no])
|
|
fi
|
|
AC_MSG_NOTICE([])
|
|
AC_MSG_NOTICE([Libraries])
|
|
AC_MSG_NOTICE([])
|
|
LIBVIRT_RESULT_APPARMOR
|
|
LIBVIRT_RESULT_ATTR
|
|
LIBVIRT_RESULT_AUDIT
|
|
LIBVIRT_RESULT_AVAHI
|
|
LIBVIRT_RESULT_BLKID
|
|
LIBVIRT_RESULT_CAPNG
|
|
LIBVIRT_RESULT_CURL
|
|
LIBVIRT_RESULT_DBUS
|
|
LIBVIRT_RESULT_FUSE
|
|
LIBVIRT_RESULT_GLUSTER
|
|
LIBVIRT_RESULT_HAL
|
|
LIBVIRT_RESULT_NETCF
|
|
LIBVIRT_RESULT_NUMACTL
|
|
LIBVIRT_RESULT_OPENWSMAN
|
|
LIBVIRT_RESULT_PCIACCESS
|
|
LIBVIRT_RESULT_READLINE
|
|
LIBVIRT_RESULT_SANLOCK
|
|
LIBVIRT_RESULT_SASL
|
|
LIBVIRT_RESULT_SELINUX
|
|
LIBVIRT_RESULT_SSH2
|
|
LIBVIRT_RESULT_SYSTEMD_DAEMON
|
|
LIBVIRT_RESULT_UDEV
|
|
LIBVIRT_RESULT_YAJL
|
|
AC_MSG_NOTICE([ libxml: $LIBXML_CFLAGS $LIBXML_LIBS])
|
|
AC_MSG_NOTICE([ dlopen: $DLOPEN_LIBS])
|
|
if test "$with_hyperv" = "yes" ; then
|
|
AC_MSG_NOTICE([openwsman: $OPENWSMAN_CFLAGS $OPENWSMAN_LIBS])
|
|
else
|
|
AC_MSG_NOTICE([openwsman: no])
|
|
fi
|
|
if test "$with_gnutls" != "no" ; then
|
|
AC_MSG_NOTICE([ gnutls: $GNUTLS_CFLAGS $GNUTLS_LIBS])
|
|
else
|
|
AC_MSG_NOTICE([ gnutls: no])
|
|
fi
|
|
AC_MSG_NOTICE([firewalld: $with_firewalld])
|
|
if test "$with_polkit" = "yes" ; then
|
|
if test "$with_polkit0" = "yes" ; then
|
|
AC_MSG_NOTICE([ polkit: $POLKIT_CFLAGS $POLKIT_LIBS (version 0)])
|
|
else
|
|
AC_MSG_NOTICE([ polkit: $PKCHECK_PATH (version 1)])
|
|
fi
|
|
else
|
|
AC_MSG_NOTICE([ polkit: no])
|
|
fi
|
|
if test "$with_xen" = "yes" ; then
|
|
AC_MSG_NOTICE([ xen: $XEN_CFLAGS $XEN_LIBS])
|
|
else
|
|
AC_MSG_NOTICE([ xen: no])
|
|
fi
|
|
if test "$with_xenapi" = "yes" ; then
|
|
AC_MSG_NOTICE([ xenapi: $LIBXENSERVER_CFLAGS $LIBXENSERVER_LIBS])
|
|
else
|
|
AC_MSG_NOTICE([ xenapi: no])
|
|
fi
|
|
if test "$with_libxl" = "yes" ; then
|
|
AC_MSG_NOTICE([xenlight: $LIBXL_CFLAGS $LIBXL_LIBS])
|
|
else
|
|
AC_MSG_NOTICE([xenlight: no])
|
|
fi
|
|
if test "$with_qemu" = "yes" && test "$LIBPCAP_FOUND" != "no"; then
|
|
AC_MSG_NOTICE([ pcap: $LIBPCAP_CFLAGS $LIBPCAP_LIBS])
|
|
else
|
|
AC_MSG_NOTICE([ pcap: no])
|
|
fi
|
|
if test "$have_libnl" = "yes" ; then
|
|
AC_MSG_NOTICE([ nl: $LIBNL_CFLAGS $LIBNL_LIBS])
|
|
else
|
|
AC_MSG_NOTICE([ nl: no])
|
|
fi
|
|
if test "$with_vbox" = "yes" && test -n "$MSCOM_LIBS" ; then
|
|
AC_MSG_NOTICE([ mscom: $MSCOM_LIBS])
|
|
else
|
|
AC_MSG_NOTICE([ mscom: no])
|
|
fi
|
|
if test "$with_remote" = "yes" || test "$with_libvirtd" = "yes" ; then
|
|
AC_MSG_NOTICE([ xdr: $XDR_CFLAGS])
|
|
else
|
|
AC_MSG_NOTICE([ xdr: no])
|
|
fi
|
|
if test "$with_storage_rbd" = "yes" ; then
|
|
AC_MSG_NOTICE([ rbd: $LIBRBD_LIBS])
|
|
else
|
|
AC_MSG_NOTICE([ rbd: no])
|
|
fi
|
|
AC_MSG_NOTICE([pm-utils: $with_pm_utils])
|
|
|
|
AC_MSG_NOTICE([])
|
|
AC_MSG_NOTICE([Test suite])
|
|
AC_MSG_NOTICE([])
|
|
AC_MSG_NOTICE([ Coverage: $enable_coverage])
|
|
AC_MSG_NOTICE([ Alloc OOM: $enable_oom])
|
|
AC_MSG_NOTICE([])
|
|
AC_MSG_NOTICE([Miscellaneous])
|
|
AC_MSG_NOTICE([])
|
|
AC_MSG_NOTICE([ Debug: $enable_debug])
|
|
AC_MSG_NOTICE([ Use -Werror: $set_werror])
|
|
AC_MSG_NOTICE([ Warning Flags: $WARN_CFLAGS])
|
|
AC_MSG_NOTICE([ DTrace: $with_dtrace])
|
|
AC_MSG_NOTICE([ numad: $with_numad])
|
|
AC_MSG_NOTICE([ XML Catalog: $XML_CATALOG_FILE])
|
|
AC_MSG_NOTICE([ Init script: $with_init_script])
|
|
AC_MSG_NOTICE([Char device locks: $with_chrdev_lock_files])
|
|
AC_MSG_NOTICE([ Default Editor: $DEFAULT_EDITOR])
|
|
AC_MSG_NOTICE([])
|
|
AC_MSG_NOTICE([Developer Tools])
|
|
AC_MSG_NOTICE([])
|
|
AC_MSG_NOTICE([Wireshark dissector: $with_wireshark_dissector])
|
|
AC_MSG_NOTICE([])
|
|
AC_MSG_NOTICE([Privileges])
|
|
AC_MSG_NOTICE([])
|
|
AC_MSG_NOTICE([ QEMU: $QEMU_USER:$QEMU_GROUP])
|
|
AC_MSG_NOTICE([])
|