Commit 6f6dc9ed authored by Michal Privoznik's avatar Michal Privoznik

configure: Drop support for libvirt older than 0.9.0

Historically, we wanted libvirt-snmp to build on RHEL-6.0 which
contained ancient libvirt. It's not the case anymore - after six
years it is safe to assume everybody upgraded to something newer.
Signed-off-by: 's avatarMichal Privoznik <mprivozn@redhat.com>
Reviewed-by: 's avatarMartin Kletzander <mkletzan@redhat.com>
parent 5593c8a4
......@@ -23,39 +23,12 @@ dnl
dnl do we have libvirt installed?
LIBVIRT_REQUIRED=0.8.0
LIBVIRT_REQUIRED=0.9.0
PKG_CHECK_MODULES(LIBVIRT, libvirt >= $LIBVIRT_REQUIRED)
LIBVIRT_LIBS="$LIBVIRT_LIBS -lvirt"
AC_SUBST(LIBVIRT_LIBS)
dnl do we have old libvirt?
save_CFLAGS="$CFLAGS"
save_LDFLAGS="$LDFLAGS"
save_LIBS="$LIBS"
CFLAGS="$CFLAGS $LIBVIRT_CFLAGS"
LDFLAGS="$CFLAGS $LIBVIRT_LIBS"
AC_CHECK_LIB([virt], [virEventRunDefaultImpl], [old=0], [old=1])
CFLAGS="$save_CFLAGS"
LDFLAGS="$save_LDFLAGS"
LIBS="$save_LIBS"
if test $old = 1 ; then
AC_DEFINE_UNQUOTED([LIBVIRT_OLD], ["$old"], [we are using old libvirt
which does not have new event api])
AC_CHECK_FUNCS([gettimeofday])
AC_CHECK_FUNCS([memmove])
AC_CHECK_HEADERS([fcntl.h])
AC_CHECK_HEADERS([stddef.h])
AC_CHECK_HEADERS([sys/time.h])
AC_CHECK_TYPES([ptrdiff_t])
AC_C_INLINE
AC_FUNC_REALLOC
AC_HEADER_STDBOOL
AC_TYPE_PID_T
AC_HEADER_TIME
fi
AM_CONDITIONAL([LIBVIRT_OLD], [test $old = 1])
SNMP_CONFIG="net-snmp-config"
SNMP_CFLAGS=""
SNMP_LIBS=""
......
bin_PROGRAMS=libvirtMib_subagent
LIBVIRT_OLD_SRCS = \
threads.c \
event_poll.c \
memory.c \
util.c
LIBVIRT_OLD_HDRS = \
internal.h \
ignore-value.h \
threads.h \
event_poll.h \
memory.h \
util.h
USER_SRCS = \
libvirtGuestTable_data_get.c \
libvirtGuestTable_data_set.c \
......@@ -61,10 +47,6 @@ libvirtMib_subagent_LDADD= \
$(LIBVIRT_LIBS) \
$(SNMP_LIBS)
if LIBVIRT_OLD
libvirtMib_subagent_SOURCES+=${LIBVIRT_OLD_SRCS} ${LIBVIRT_OLD_HDRS}
endif
EXTRA_DIST = LIBVIRT-MIB.txt
install-data-local:
......
This diff is collapsed.
/*
* event.h: event loop for monitoring file handles
*
* Copyright (C) 2007 Daniel P. Berrange
* Copyright (C) 2007 Red Hat, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Author: Daniel P. Berrange <berrange@redhat.com>
*/
#ifndef __VIR_EVENT_POLL_H__
# define __VIR_EVENT_POLL_H__
# include "internal.h"
/**
* virEventPollAddHandle: register a callback for monitoring file handle events
*
* @fd: file handle to monitor for events
* @events: bitset of events to watch from POLLnnn constants
* @cb: callback to invoke when an event occurs
* @opaque: user data to pass to callback
*
* returns -1 if the file handle cannot be registered, 0 upon success
*/
int virEventPollAddHandle(int fd, int events,
virEventHandleCallback cb,
void *opaque,
virFreeCallback ff);
/**
* virEventPollUpdateHandle: change event set for a monitored file handle
*
* @watch: watch whose handle to update
* @events: bitset of events to watch from POLLnnn constants
*
* Will not fail if fd exists
*/
void virEventPollUpdateHandle(int watch, int events);
/**
* virEventPollRemoveHandle: unregister a callback from a file handle
*
* @watch: watch whose handle to remove
*
* returns -1 if the file handle was not registered, 0 upon success
*/
int virEventPollRemoveHandle(int watch);
/**
* virEventPollAddTimeout: register a callback for a timer event
*
* @frequency: time between events in milliseconds
* @cb: callback to invoke when an event occurs
* @opaque: user data to pass to callback
*
* Setting frequency to -1 will disable the timer. Setting the frequency
* to zero will cause it to fire on every event loop iteration.
*
* returns -1 if the file handle cannot be registered, a positive
* integer timer id upon success
*/
int virEventPollAddTimeout(int frequency,
virEventTimeoutCallback cb,
void *opaque,
virFreeCallback ff);
/**
* virEventPollUpdateTimeout: change frequency for a timer
*
* @timer: timer id to change
* @frequency: time between events in milliseconds
*
* Setting frequency to -1 will disable the timer. Setting the frequency
* to zero will cause it to fire on every event loop iteration.
*
* Will not fail if timer exists
*/
void virEventPollUpdateTimeout(int timer, int frequency);
/**
* virEventPollRemoveTimeout: unregister a callback for a timer
*
* @timer: the timer id to remove
*
* returns -1 if the timer was not registered, 0 upon success
*/
int virEventPollRemoveTimeout(int timer);
/**
* virEventPollInit: Initialize the event loop
*
* returns -1 if initialization failed
*/
int virEventPollInit(void);
/**
* virEventPollRunOnce: run a single iteration of the event loop.
*
* Blocks the caller until at least one file handle has an
* event or the first timer expires.
*
* returns -1 if the event monitoring failed
*/
int virEventPollRunOnce(void);
int virEventPollFromNativeEvents(int events);
int virEventPollToNativeEvents(int events);
/**
* virEventPollInterrupt: wakeup any thread waiting in poll()
*
* return -1 if wakup failed
*/
int virEventPollInterrupt(void);
#endif /* __VIRTD_EVENT_H__ */
/* -*- buffer-read-only: t -*- vi: set ro: */
/* DO NOT EDIT! GENERATED AUTOMATICALLY! */
/* ignore a function return without a compiler warning
Copyright (C) 2008-2011 Free Software Foundation, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
/* Written by Jim Meyering, Eric Blake and Pádraig Brady. */
/* Use "ignore_value" to avoid a warning when using a function declared with
gcc's warn_unused_result attribute, but for which you really do want to
ignore the result. Traditionally, people have used a "(void)" cast to
indicate that a function's return value is deliberately unused. However,
if the function is declared with __attribute__((warn_unused_result)),
gcc issues a warning even with the cast.
Caution: most of the time, you really should heed gcc's warning, and
check the return value. However, in those exceptional cases in which
you're sure you know what you're doing, use this function.
For the record, here's one of the ignorable warnings:
"copy.c:233: warning: ignoring return value of 'fchown',
declared with attribute warn_unused_result". */
#ifndef _GL_IGNORE_VALUE_H
# define _GL_IGNORE_VALUE_H
# ifndef _GL_ATTRIBUTE_DEPRECATED
/* The __attribute__((__deprecated__)) feature
is available in gcc versions 3.1 and newer. */
# if __GNUC__ < 3 || (__GNUC__ == 3 && __GNUC_MINOR__ < 1)
# define _GL_ATTRIBUTE_DEPRECATED /* empty */
# else
# define _GL_ATTRIBUTE_DEPRECATED __attribute__ ((__deprecated__))
# endif
# endif
/* The __attribute__((__warn_unused_result__)) feature
is available in gcc versions 3.4 and newer,
while the typeof feature has been available since 2.7 at least. */
# if __GNUC__ < 3 || (__GNUC__ == 3 && __GNUC_MINOR__ < 4)
# define ignore_value(x) ((void) (x))
# else
# define ignore_value(x) (({ __typeof__ (x) __x = (x); (void) __x; }))
# endif
/* ignore_value works for scalars, pointers and aggregates;
deprecate ignore_ptr. */
static inline void _GL_ATTRIBUTE_DEPRECATED
ignore_ptr (void *p) { (void) p; } /* deprecated: use ignore_value */
#endif
/*
* internal.h: internal definitions just used by code from the library
*
* Copy: Copyright (C) 2005-2006, 2010-2011 Red Hat, Inc.
*
* See libvirt's COPYING.LIB for the License of this software
*
*/
#ifndef __INTERNAL_H__
# define __INTERNAL_H__
# include <stdio.h>
# include <stdlib.h>
# include <stdbool.h>
# include <stddef.h>
# include <errno.h>
# include <string.h>
# include <libvirt/libvirt.h>
# include <libvirt/virterror.h>
/* C99 uses __func__. __FUNCTION__ is legacy. */
# ifndef __GNUC__
# define __FUNCTION__ __func__
# endif
# ifdef __GNUC__
# ifndef __GNUC_PREREQ
# if defined __GNUC__ && defined __GNUC_MINOR__
# define __GNUC_PREREQ(maj, min) \
((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min))
# else
# define __GNUC_PREREQ(maj,min) 0
# endif
/* Work around broken limits.h on debian etch */
# if defined _GCC_LIMITS_H_ && ! defined ULLONG_MAX
# define ULLONG_MAX ULONG_LONG_MAX
# endif
# endif /* __GNUC__ */
/**
* ATTRIBUTE_UNUSED:
*
* Macro to flag conciously unused parameters to functions
*/
# ifndef ATTRIBUTE_UNUSED
# define ATTRIBUTE_UNUSED __attribute__((__unused__))
# endif
/**
* ATTRIBUTE_SENTINEL:
*
* Macro to check for NULL-terminated varargs lists
*/
# ifndef ATTRIBUTE_SENTINEL
# if __GNUC_PREREQ (4, 0)
# define ATTRIBUTE_SENTINEL __attribute__((__sentinel__))
# else
# define ATTRIBUTE_SENTINEL
# endif
# endif
/**
* ATTRIBUTE_FMT_PRINTF
*
* Macro used to check printf like functions, if compiling
* with gcc.
*
* We use gnulib which guarentees we always have GNU style
* printf format specifiers even on broken Win32 platforms
* hence we have to force 'gnu_printf' for new GCC
*/
# ifndef ATTRIBUTE_FMT_PRINTF
# if __GNUC_PREREQ (4, 4)
# define ATTRIBUTE_FMT_PRINTF(fmtpos,argpos) __attribute__((__format__ (gnu_printf, fmtpos,argpos)))
# else
# define ATTRIBUTE_FMT_PRINTF(fmtpos,argpos) __attribute__((__format__ (printf, fmtpos,argpos)))
# endif
# endif
# ifndef ATTRIBUTE_RETURN_CHECK
# if __GNUC_PREREQ (3, 4)
# define ATTRIBUTE_RETURN_CHECK __attribute__((__warn_unused_result__))
# else
# define ATTRIBUTE_RETURN_CHECK
# endif
# endif
/**
* ATTRIBUTE_PACKED
*
* force a structure to be packed, i.e. not following architecture and
* compiler best alignments for its sub components. It's needed for example
* for the network filetering code when defining the content of raw
* ethernet packets.
* Others compiler than gcc may use something different e.g. #pragma pack(1)
*/
# ifndef ATTRIBUTE_PACKED
# if __GNUC_PREREQ (3, 3)
# define ATTRIBUTE_PACKED __attribute__((packed))
# else
# error "Need an __attribute__((packed)) equivalent"
# endif
# endif
# ifndef ATTRIBUTE_NONNULL
# if __GNUC_PREREQ (3, 3)
# define ATTRIBUTE_NONNULL(m) __attribute__((__nonnull__(m)))
# else
# define ATTRIBUTE_NONNULL(m)
# endif
# endif
# else
# ifndef ATTRIBUTE_UNUSED
# define ATTRIBUTE_UNUSED
# endif
# ifndef ATTRIBUTE_FMT_PRINTF
# define ATTRIBUTE_FMT_PRINTF(...)
# endif
# ifndef ATTRIBUTE_RETURN_CHECK
# define ATTRIBUTE_RETURN_CHECK
# endif
# endif /* __GNUC__ */
extern int verbose;
#define VIR_DEBUG0(fmt) if (verbose) fprintf(stderr, "%s:%d :: " fmt "\n", \
__func__, __LINE__)
#define VIR_DEBUG(fmt, ...) if (verbose) fprintf(stderr, "%s:%d: " fmt "\n", \
__func__, __LINE__, __VA_ARGS__)
#define VIR_WARN(fmt, ...) if (verbose) fprintf(stderr, "%s:%d: " fmt "\n", \
__func__, __LINE__, __VA_ARGS__)
#endif
......@@ -24,17 +24,12 @@
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/poll.h>
#include <pthread.h>
#include <signal.h>
#include "libvirtSnmp.h"
#include "libvirtGuestTable.h" /* include our MIB structures*/
#include "libvirtNotifications.h"
#ifdef LIBVIRT_OLD
# include "event_poll.h"
#endif
#define DEBUG0(fmt) if (verbose) printf("%s:%d :: " fmt "\n", \
__func__, __LINE__)
......@@ -302,11 +297,7 @@ void *
pollingThreadFunc(void *foo)
{
while (run) {
#ifdef LIBVIRT_OLD
if (virEventPollRunOnce() < 0) {
#else
if (virEventRunDefaultImpl() < 0) {
#endif
showError(conn);
pthread_exit(NULL);
}
......@@ -368,21 +359,8 @@ int libvirtSnmpInit(void)
verbose = verbose_env != NULL;
/* if we don't already have registered callback */
if (callbackRet == -1) {
#ifdef LIBVIRT_OLD
if (virEventPollInit() < 0)
return -1;
virEventRegisterImpl(virEventPollAddHandle,
virEventPollUpdateHandle,
virEventPollRemoveHandle,
virEventPollAddTimeout,
virEventPollUpdateTimeout,
virEventPollRemoveTimeout);
#else
if (callbackRet == -1)
virEventRegisterDefaultImpl();
#endif
}
/* TODO: configure the URI */
/* Use libvirt env variable LIBVIRT_DEFAULT_URI by default*/
......
/*
* memory.c: safer memory allocation
*
* Copyright (C) 2010-2011 Red Hat, Inc.
* Copyright (C) 2008 Daniel P. Berrange
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include <config.h>
#include <stdlib.h>
#include "memory.h"
#include "ignore-value.h"
#if TEST_OOM
static int testMallocNext = 0;
static int testMallocFailFirst = 0;
static int testMallocFailLast = 0;
static void (*testMallocHook)(int, void*) = NULL;
static void *testMallocHookData = NULL;
void virAllocTestInit(void)
{
testMallocNext = 1;
testMallocFailFirst = 0;
testMallocFailLast = 0;
}
int virAllocTestCount(void)
{
return testMallocNext - 1;
}
void virAllocTestHook(void (*func)(int, void*), void *data)
{
testMallocHook = func;
testMallocHookData = data;
}
void virAllocTestOOM(int n, int m)
{
testMallocNext = 1;
testMallocFailFirst = n;
testMallocFailLast = n + m - 1;
}
static int virAllocTestFail(void)
{
int fail = 0;
if (testMallocNext == 0)
return 0;
fail =
testMallocNext >= testMallocFailFirst &&
testMallocNext <= testMallocFailLast;
if (fail && testMallocHook)
(testMallocHook)(testMallocNext, testMallocHookData);
testMallocNext++;
return fail;
}
#endif
/**
* virAlloc:
* @ptrptr: pointer to pointer for address of allocated memory
* @size: number of bytes to allocate
*
* Allocate 'size' bytes of memory. Return the address of the
* allocated memory in 'ptrptr'. The newly allocated memory is
* filled with zeros.
*
* Returns -1 on failure to allocate, zero on success
*/
int virAlloc(void *ptrptr, size_t size)
{
#if TEST_OOM
if (virAllocTestFail()) {
*(void **)ptrptr = NULL;
return -1;
}
#endif
*(void **)ptrptr = calloc(1, size);
if (*(void **)ptrptr == NULL)
return -1;
return 0;
}
/**
* virAllocN:
* @ptrptr: pointer to pointer for address of allocated memory
* @size: number of bytes to allocate
* @count: number of elements to allocate
*
* Allocate an array of memory 'count' elements long,
* each with 'size' bytes. Return the address of the
* allocated memory in 'ptrptr'. The newly allocated
* memory is filled with zeros.
*
* Returns -1 on failure to allocate, zero on success
*/
int virAllocN(void *ptrptr, size_t size, size_t count)
{
#if TEST_OOM
if (virAllocTestFail()) {
*(void **)ptrptr = NULL;
return -1;
}
#endif
*(void**)ptrptr = calloc(count, size);
if (*(void**)ptrptr == NULL)
return -1;
return 0;
}
/**
* virReallocN:
* @ptrptr: pointer to pointer for address of allocated memory
* @size: number of bytes to allocate
* @count: number of elements in array
*
* Resize the block of memory in 'ptrptr' to be an array of
* 'count' elements, each 'size' bytes in length. Update 'ptrptr'
* with the address of the newly allocated memory. On failure,
* 'ptrptr' is not changed and still points to the original memory
* block. Any newly allocated memory in 'ptrptr' is uninitialized.
*
* Returns -1 on failure to allocate, zero on success
*/
int virReallocN(void *ptrptr, size_t size, size_t count)
{
void *tmp;
#if TEST_OOM
if (virAllocTestFail())
return -1;
#endif
if (xalloc_oversized(count, size)) {
errno = ENOMEM;
return -1;
}
tmp = realloc(*(void**)ptrptr, size * count);
if (!tmp && (size * count))
return -1;
*(void**)ptrptr = tmp;
return 0;
}
/**
* virExpandN:
* @ptrptr: pointer to pointer for address of allocated memory
* @size: number of bytes per element
* @countptr: pointer to number of elements in array
* @add: number of elements to add
*
* Resize the block of memory in 'ptrptr' to be an array of
* '*countptr' + 'add' elements, each 'size' bytes in length.
* Update 'ptrptr' and 'countptr' with the details of the newly
* allocated memory. On failure, 'ptrptr' and 'countptr' are not
* changed. Any newly allocated memory in 'ptrptr' is zero-filled.
*
* Returns -1 on failure to allocate, zero on success
*/
int virExpandN(void *ptrptr, size_t size, size_t *countptr, size_t add)
{
int ret;
if (*countptr + add < *countptr) {
errno = ENOMEM;
return -1;
}
ret = virReallocN(ptrptr, size, *countptr + add);
if (ret == 0) {
memset(*(char **)ptrptr + (size * *countptr), 0, size * add);
*countptr += add;
}
return ret;
}
/**
* virResizeN:
* @ptrptr: pointer to pointer for address of allocated memory
* @size: number of bytes per element
* @allocptr: pointer to number of elements allocated in array
* @count: number of elements currently used in array
* @add: minimum number of additional elements to support in array
*
* If 'count' + 'add' is larger than '*allocptr', then resize the
* block of memory in 'ptrptr' to be an array of at least 'count' +
* 'add' elements, each 'size' bytes in length. Update 'ptrptr' and
* 'allocptr' with the details of the newly allocated memory. On
* failure, 'ptrptr' and 'allocptr' are not changed. Any newly
* allocated memory in 'ptrptr' is zero-filled.
*
* Returns -1 on failure to allocate, zero on success
*/
int virResizeN(void *ptrptr, size_t size, size_t *allocptr, size_t count,
size_t add)
{
size_t delta;
if (count + add < count) {
errno = ENOMEM;
return -1;
}
if (count + add <= *allocptr)
return 0;
delta = count + add - *allocptr;
if (delta < *allocptr / 2)
delta = *allocptr / 2;
return virExpandN(ptrptr, size, allocptr, delta);
}
/**
* virShrinkN:
* @ptrptr: pointer to pointer for address of allocated memory
* @size: number of bytes per element
* @countptr: pointer to number of elements in array
* @toremove: number of elements to remove
*
* Resize the block of memory in 'ptrptr' to be an array of
* '*countptr' - 'toremove' elements, each 'size' bytes in length.
* Update 'ptrptr' and 'countptr' with the details of the newly
* allocated memory. If 'toremove' is larger than 'countptr', free
* the entire array.
*/
void virShrinkN(void *ptrptr, size_t size, size_t *countptr, size_t toremove)
{
if (toremove < *countptr)
ignore_value(virReallocN(ptrptr, size, *countptr -= toremove));
else {
virFree(ptrptr);
*countptr = 0;
}
}
/**
* Vir_Alloc_Var:
* @ptrptr: pointer to hold address of allocated memory
* @struct_size: size of initial struct
* @element_size: size of array elements
* @count: number of array elements to allocate
*
* Allocate struct_size bytes plus an array of 'count' elements, each
* of size element_size. This sort of allocation is useful for
* receiving the data of certain ioctls and other APIs which return a
* struct in which the last element is an array of undefined length.
* The caller of this type of API is expected to know the length of
* the array that will be returned and allocate a suitable buffer to
* contain the returned data. C99 refers to these variable length
* objects as structs containing flexible array members.
*
* Returns -1 on failure, 0 on success
*/
int virAllocVar(void *ptrptr, size_t struct_size, size_t element_size, size_t count)
{
size_t alloc_size = 0;
#if TEST_OOM
if (virAllocTestFail())
return -1;
#endif
if (VIR_ALLOC_VAR_OVERSIZED(struct_size, count, element_size)) {
errno = ENOMEM;
return -1;
}
alloc_size = struct_size + (element_size * count);
*(void **)ptrptr = calloc(1, alloc_size);
if (*(void **)ptrptr == NULL)
return -1;
return 0;
}
/**
* virFree:
* @ptrptr: pointer to pointer for address of memory to be freed
*
* Release the chunk of memory in the pointer pointed to by
* the 'ptrptr' variable. After release, 'ptrptr' will be
* updated to point to NULL.
*/
void virFree(void *ptrptr)
{
int save_errno = errno;