[libvirt] [PATCH 02/28] Rename bitmap.{c,h} to virbitmap.{c,h}

From: "Daniel P. Berrange" <berrange(a)redhat.com&gt; Signed-off-by: Daniel P. Berrange <berrange(a)redhat.com&gt; --- src/Makefile.am | 2 +- src/conf/cpu_conf.h | 2 +- src/conf/domain_conf.c | 3 +- src/conf/domain_conf.h | 2 +- src/conf/network_conf.h | 2 +- src/conf/snapshot_conf.c | 2 +- src/libxl/libxl_conf.h | 2 +- src/qemu/qemu_capabilities.c | 2 +- src/qemu/qemu_conf.h | 2 +- src/qemu/qemu_driver.c | 2 +- src/qemu/qemu_monitor.h | 2 +- src/qemu/qemu_monitor_json.h | 2 +- src/qemu/qemu_process.c | 2 +- src/util/bitmap.c | 636 ------------------------------------------- src/util/bitmap.h | 109 -------- src/util/dnsmasq.c | 2 +- src/util/processinfo.h | 2 +- src/util/virbitmap.c | 636 +++++++++++++++++++++++++++++++++++++++++++ src/util/virbitmap.h | 109 ++++++++ tests/virbitmaptest.c | 2 +- tools/virsh-domain.c | 2 +- tools/virsh.c | 2 +- 22 files changed, 763 insertions(+), 764 deletions(-) delete mode 100644 src/util/bitmap.c delete mode 100644 src/util/bitmap.h create mode 100644 src/util/virbitmap.c create mode 100644 src/util/virbitmap.h diff --git a/src/Makefile.am b/src/Makefile.am index 149ffc9..25a21e8 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -53,7 +53,6 @@ augeastest_DATA = # These files are not related to driver APIs. Simply generic # helper APIs for various purposes UTIL_SOURCES = \ - util/bitmap.c util/bitmap.h \ util/buf.c util/buf.h \ util/command.c util/command.h \ util/conf.c util/conf.h \ @@ -83,6 +82,7 @@ UTIL_SOURCES = \ util/viraudit.c util/viraudit.h \ util/virauth.c util/virauth.h \ util/virauthconfig.c util/virauthconfig.h \ + util/virbitmap.c util/virbitmap.h \ util/virfile.c util/virfile.h \ util/virnodesuspend.c util/virnodesuspend.h \ util/virobject.c util/virobject.h \ diff --git a/src/conf/cpu_conf.h b/src/conf/cpu_conf.h index 879f8eb..38fc675 100644 --- a/src/conf/cpu_conf.h +++ b/src/conf/cpu_conf.h @@ -27,7 +27,7 @@ # include "util.h" # include "buf.h" # include "xml.h" -# include "bitmap.h" +# include "virbitmap.h" # define VIR_CPU_VENDOR_ID_LENGTH 12 diff --git a/src/conf/domain_conf.c b/src/conf/domain_conf.c index 19af058..c90c6b9 100644 --- a/src/conf/domain_conf.c +++ b/src/conf/domain_conf.c @@ -44,14 +44,13 @@ #include "nwfilter_conf.h" #include "storage_file.h" #include "virfile.h" -#include "bitmap.h" +#include "virbitmap.h" #include "count-one-bits.h" #include "secret_conf.h" #include "netdev_vport_profile_conf.h" #include "netdev_bandwidth_conf.h" #include "netdev_vlan_conf.h" #include "device_conf.h" -#include "bitmap.h" #define VIR_FROM_THIS VIR_FROM_DOMAIN diff --git a/src/conf/domain_conf.h b/src/conf/domain_conf.h index bc9ef88..26d2264 100644 --- a/src/conf/domain_conf.h +++ b/src/conf/domain_conf.h @@ -46,7 +46,7 @@ # include "virnetdevvlan.h" # include "virobject.h" # include "device_conf.h" -# include "bitmap.h" +# include "virbitmap.h" # include "storage_file.h" /* forward declarations of all device types, required by diff --git a/src/conf/network_conf.h b/src/conf/network_conf.h index 72cf64b..4d70fe6 100644 --- a/src/conf/network_conf.h +++ b/src/conf/network_conf.h @@ -38,7 +38,7 @@ # include "virnetdevvlan.h" # include "virmacaddr.h" # include "device_conf.h" -# include "bitmap.h" +# include "virbitmap.h" enum virNetworkForwardType { VIR_NETWORK_FORWARD_NONE = 0, diff --git a/src/conf/snapshot_conf.c b/src/conf/snapshot_conf.c index bba1bb7..95b7943 100644 --- a/src/conf/snapshot_conf.c +++ b/src/conf/snapshot_conf.c @@ -29,7 +29,7 @@ #include <unistd.h> #include "internal.h" -#include "bitmap.h" +#include "virbitmap.h" #include "buf.h" #include "count-one-bits.h" #include "datatypes.h" diff --git a/src/libxl/libxl_conf.h b/src/libxl/libxl_conf.h index 6bcf805..c8808a1 100644 --- a/src/libxl/libxl_conf.h +++ b/src/libxl/libxl_conf.h @@ -34,7 +34,7 @@ # include "domain_event.h" # include "capabilities.h" # include "configmake.h" -# include "bitmap.h" +# include "virbitmap.h" # define LIBXL_VNC_PORT_MIN 5900 diff --git a/src/qemu/qemu_capabilities.c b/src/qemu/qemu_capabilities.c index 104a3f8..45962b0 100644 --- a/src/qemu/qemu_capabilities.c +++ b/src/qemu/qemu_capabilities.c @@ -35,7 +35,7 @@ #include "cpu/cpu.h" #include "domain_conf.h" #include "command.h" -#include "bitmap.h" +#include "virbitmap.h" #include "virnodesuspend.h" #include "qemu_monitor.h" diff --git a/src/qemu/qemu_conf.h b/src/qemu/qemu_conf.h index cfa6fff..bcf21c3 100644 --- a/src/qemu/qemu_conf.h +++ b/src/qemu/qemu_conf.h @@ -39,7 +39,7 @@ # include "hostusb.h" # include "cpu_conf.h" # include "driver.h" -# include "bitmap.h" +# include "virbitmap.h" # include "command.h" # include "threadpool.h" # include "locking/lock_manager.h" diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index 2dd6922..e87397f 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -92,7 +92,7 @@ #include "virnodesuspend.h" #include "virtime.h" #include "virtypedparam.h" -#include "bitmap.h" +#include "virbitmap.h" #define VIR_FROM_THIS VIR_FROM_QEMU diff --git a/src/qemu/qemu_monitor.h b/src/qemu/qemu_monitor.h index dbfab88..8c42b12 100644 --- a/src/qemu/qemu_monitor.h +++ b/src/qemu/qemu_monitor.h @@ -28,7 +28,7 @@ # include "internal.h" # include "domain_conf.h" -# include "bitmap.h" +# include "virbitmap.h" # include "virhash.h" # include "json.h" # include "device_conf.h" diff --git a/src/qemu/qemu_monitor_json.h b/src/qemu/qemu_monitor_json.h index acca4ec..2b09a8f 100644 --- a/src/qemu/qemu_monitor_json.h +++ b/src/qemu/qemu_monitor_json.h @@ -28,7 +28,7 @@ # include "internal.h" # include "qemu_monitor.h" -# include "bitmap.h" +# include "virbitmap.h" int qemuMonitorJSONIOProcess(qemuMonitorPtr mon, const char *data, diff --git a/src/qemu/qemu_process.c b/src/qemu/qemu_process.c index cc0e947..969cbc7 100644 --- a/src/qemu/qemu_process.c +++ b/src/qemu/qemu_process.c @@ -69,7 +69,7 @@ #include "virprocess.h" #include "virtime.h" #include "virnetdevtap.h" -#include "bitmap.h" +#include "virbitmap.h" #define VIR_FROM_THIS VIR_FROM_QEMU diff --git a/src/util/bitmap.c b/src/util/bitmap.c deleted file mode 100644 index c29f5f3..0000000 --- a/src/util/bitmap.c +++ /dev/null @@ -1,636 +0,0 @@ -/* - * bitmap.h: Simple bitmap operations - * - * Copyright (C) 2010-2012 Red Hat, Inc. - * Copyright (C) 2010 Novell, 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, see - * <http://www.gnu.org/licenses/>;. - * - * Author: Jim Fehlig <jfehlig(a)novell.com&gt; - */ - -#include <config.h> - -#include <limits.h> -#include <stdint.h> -#include <stdio.h> -#include <string.h> -#include <stdlib.h> -#include <sys/types.h> - -#include "bitmap.h" -#include "memory.h" -#include "buf.h" -#include "util.h" -#include "c-ctype.h" -#include "count-one-bits.h" - - -struct _virBitmap { - size_t max_bit; - size_t map_len; - unsigned long *map; -}; - - -#define VIR_BITMAP_BITS_PER_UNIT ((int) sizeof(unsigned long) * CHAR_BIT) -#define VIR_BITMAP_UNIT_OFFSET(b) ((b) / VIR_BITMAP_BITS_PER_UNIT) -#define VIR_BITMAP_BIT_OFFSET(b) ((b) % VIR_BITMAP_BITS_PER_UNIT) -#define VIR_BITMAP_BIT(b) (1UL << VIR_BITMAP_BIT_OFFSET(b)) - - -/** - * virBitmapNew: - * @size: number of bits - * - * Allocate a bitmap capable of containing @size bits. - * - * Returns a pointer to the allocated bitmap or NULL if - * memory cannot be allocated. - */ -virBitmapPtr virBitmapNew(size_t size) -{ - virBitmapPtr bitmap; - size_t sz; - - if (SIZE_MAX - VIR_BITMAP_BITS_PER_UNIT < size || size == 0) - return NULL; - - sz = (size + VIR_BITMAP_BITS_PER_UNIT - 1) / - VIR_BITMAP_BITS_PER_UNIT; - - if (VIR_ALLOC(bitmap) < 0) - return NULL; - - if (VIR_ALLOC_N(bitmap->map, sz) < 0) { - VIR_FREE(bitmap); - return NULL; - } - - bitmap->max_bit = size; - bitmap->map_len = sz; - return bitmap; -} - -/** - * virBitmapFree: - * @bitmap: previously allocated bitmap - * - * Free @bitmap previously allocated by virBitmapNew. - */ -void virBitmapFree(virBitmapPtr bitmap) -{ - if (bitmap) { - VIR_FREE(bitmap->map); - VIR_FREE(bitmap); - } -} - - -int virBitmapCopy(virBitmapPtr dst, virBitmapPtr src) -{ - if (dst->max_bit != src->max_bit) { - errno = EINVAL; - return -1; - } - - memcpy(dst->map, src->map, src->map_len * sizeof(src->map[0])); - - return 0; -} - - -/** - * virBitmapSetBit: - * @bitmap: Pointer to bitmap - * @b: bit position to set - * - * Set bit position @b in @bitmap - * - * Returns 0 on if bit is successfully set, -1 on error. - */ -int virBitmapSetBit(virBitmapPtr bitmap, size_t b) -{ - if (bitmap->max_bit <= b) - return -1; - - bitmap->map[VIR_BITMAP_UNIT_OFFSET(b)] |= VIR_BITMAP_BIT(b); - return 0; -} - -/** - * virBitmapClearBit: - * @bitmap: Pointer to bitmap - * @b: bit position to clear - * - * Clear bit position @b in @bitmap - * - * Returns 0 on if bit is successfully clear, -1 on error. - */ -int virBitmapClearBit(virBitmapPtr bitmap, size_t b) -{ - if (bitmap->max_bit <= b) - return -1; - - bitmap->map[VIR_BITMAP_UNIT_OFFSET(b)] &= ~VIR_BITMAP_BIT(b); - return 0; -} - -/* Helper function. caller must ensure b < bitmap->max_bit */ -static bool virBitmapIsSet(virBitmapPtr bitmap, size_t b) -{ - return !!(bitmap->map[VIR_BITMAP_UNIT_OFFSET(b)] & VIR_BITMAP_BIT(b)); -} - -/** - * virBitmapGetBit: - * @bitmap: Pointer to bitmap - * @b: bit position to get - * @result: bool pointer to receive bit setting - * - * Get setting of bit position @b in @bitmap and store in @result - * - * On success, @result will contain the setting of @b and 0 is - * returned. On failure, -1 is returned and @result is unchanged. - */ -int virBitmapGetBit(virBitmapPtr bitmap, size_t b, bool *result) -{ - if (bitmap->max_bit <= b) - return -1; - - *result = virBitmapIsSet(bitmap, b); - return 0; -} - -/** - * virBitmapString: - * @bitmap: Pointer to bitmap - * - * Convert @bitmap to printable string. - * - * Returns pointer to the string or NULL on error. - */ -char *virBitmapString(virBitmapPtr bitmap) -{ - virBuffer buf = VIR_BUFFER_INITIALIZER; - size_t sz; - - virBufferAddLit(&buf, "0x"); - - sz = bitmap->map_len; - - while (sz--) { - virBufferAsprintf(&buf, "%0*lx", - VIR_BITMAP_BITS_PER_UNIT / 4, - bitmap->map[sz]); - } - - if (virBufferError(&buf)) { - virBufferFreeAndReset(&buf); - return NULL; - } - - return virBufferContentAndReset(&buf); -} - -/** - * virBitmapFormat: - * @bitmap: the bitmap - * - * This function is the counterpart of virBitmapParse. This function creates - * a human-readable string representing the bits in bitmap. - * - * See virBitmapParse for the format of @str. - * - * Returns the string on success or NULL otherwise. Caller should call - * VIR_FREE to free the string. - */ -char *virBitmapFormat(virBitmapPtr bitmap) -{ - virBuffer buf = VIR_BUFFER_INITIALIZER; - bool first = true; - int start, cur, prev; - - if (!bitmap) - return NULL; - - cur = virBitmapNextSetBit(bitmap, -1); - if (cur < 0) - return strdup(""); - - start = prev = cur; - while (prev >= 0) { - cur = virBitmapNextSetBit(bitmap, prev); - - if (cur == prev + 1) { - prev = cur; - continue; - } - - /* cur < 0 or cur > prev + 1 */ - - if (!first) - virBufferAddLit(&buf, ","); - else - first = false; - - if (prev == start) - virBufferAsprintf(&buf, "%d", start); - else - virBufferAsprintf(&buf, "%d-%d", start, prev); - - start = prev = cur; - } - - if (virBufferError(&buf)) { - virBufferFreeAndReset(&buf); - return NULL; - } - - return virBufferContentAndReset(&buf); -} - -/** - * virBitmapParse: - * @str: points to a string representing a human-readable bitmap - * @bitmap: a bitmap created from @str - * @bitmapSize: the upper limit of num of bits in created bitmap - * - * This function is the counterpart of virBitmapFormat. This function creates - * a bitmap, in which bits are set according to the content of @str. - * - * @str is a comma separated string of fields N, which means a number of bit - * to set, and ^N, which means to unset the bit, and N-M for ranges of bits - * to set. - * - * Returns the number of bits set in @bitmap, or -1 in case of error. - */ - -int virBitmapParse(const char *str, - char sep, - virBitmapPtr *bitmap, - size_t bitmapSize) -{ - int ret = 0; - bool neg = false; - const char *cur; - char *tmp; - int i, start, last; - - if (!str) - return -1; - - cur = str; - virSkipSpaces(&cur); - - if (*cur == 0) - return -1; - - *bitmap = virBitmapNew(bitmapSize); - if (!*bitmap) - return -1; - - while (*cur != 0 && *cur != sep) { - /* - * 3 constructs are allowed: - * - N : a single CPU number - * - N-M : a range of CPU numbers with N < M - * - ^N : remove a single CPU number from the current set - */ - if (*cur == '^') { - cur++; - neg = true; - } - - if (!c_isdigit(*cur)) - goto parse_error; - - if (virStrToLong_i(cur, &tmp, 10, &start) < 0) - goto parse_error; - if (start < 0) - goto parse_error; - - cur = tmp; - - virSkipSpaces(&cur); - - if (*cur == ',' || *cur == 0 || *cur == sep) { - if (neg) { - if (virBitmapIsSet(*bitmap, start)) { - ignore_value(virBitmapClearBit(*bitmap, start)); - ret--; - } - } else { - if (!virBitmapIsSet(*bitmap, start)) { - ignore_value(virBitmapSetBit(*bitmap, start)); - ret++; - } - } - } else if (*cur == '-') { - if (neg) - goto parse_error; - - cur++; - virSkipSpaces(&cur); - - if (virStrToLong_i(cur, &tmp, 10, &last) < 0) - goto parse_error; - if (last < start) - goto parse_error; - - cur = tmp; - - for (i = start; i <= last; i++) { - if (!virBitmapIsSet(*bitmap, i)) { - ignore_value(virBitmapSetBit(*bitmap, i)); - ret++; - } - } - - virSkipSpaces(&cur); - } - - if (*cur == ',') { - cur++; - virSkipSpaces(&cur); - neg = false; - } else if (*cur == 0 || *cur == sep) { - break; - } else { - goto parse_error; - } - } - - return ret; - -parse_error: - virBitmapFree(*bitmap); - *bitmap = NULL; - return -1; -} - -/** - * virBitmapNewCopy: - * @src: the source bitmap. - * - * Makes a copy of bitmap @src. - * - * returns the copied bitmap on success, or NULL otherwise. Caller - * should call virBitmapFree to free the returned bitmap. - */ -virBitmapPtr virBitmapNewCopy(virBitmapPtr src) -{ - virBitmapPtr dst; - - if ((dst = virBitmapNew(src->max_bit)) == NULL) - return NULL; - - if (virBitmapCopy(dst, src) != 0) { - virBitmapFree(dst); - return NULL; - } - - return dst; -} - -/** - * virBitmapNewData: - * @data: the data - * @len: length of @data in bytes - * - * Allocate a bitmap from a chunk of data containing bits - * information - * - * Returns a pointer to the allocated bitmap or NULL if - * memory cannot be allocated. - */ -virBitmapPtr virBitmapNewData(void *data, int len) -{ - virBitmapPtr bitmap; - int i, j; - unsigned long *p; - unsigned char *bytes = data; - - bitmap = virBitmapNew(len * CHAR_BIT); - if (!bitmap) - return NULL; - - /* le64toh is not provided by gnulib, so we do the conversion by hand */ - p = bitmap->map; - for (i = j = 0; i < len; i++, j++) { - if (j == sizeof(*p)) { - j = 0; - p++; - } - *p |= (unsigned long) bytes[i] << (j * CHAR_BIT); - } - - return bitmap; -} - -/** - * virBitmapToData: - * @data: the data - * @len: len of @data in byte - * - * Convert a bitmap to a chunk of data containing bits information. - * Data consists of sequential bytes, with lower bytes containing - * lower bits. - * - * Returns 0 on success, -1 otherwise. - */ -int virBitmapToData(virBitmapPtr bitmap, unsigned char **data, int *dataLen) -{ - int len; - unsigned long *l; - int i, j; - unsigned char *bytes; - - len = (bitmap->max_bit + CHAR_BIT - 1) / CHAR_BIT; - - if (VIR_ALLOC_N(*data, len) < 0) - return -1; - - bytes = *data; - *dataLen = len; - - /* htole64 is not provided by gnulib, so we do the conversion by hand */ - l = bitmap->map; - for (i = j = 0; i < len; i++, j++) { - if (j == sizeof(*l)) { - j = 0; - l++; - } - bytes[i] = *l >> (j * CHAR_BIT); - } - - return 0; -} - -/** - * virBitmapEqual: - * @b1: bitmap 1 - * @b2: bitmap 2 - * - * Compares two bitmaps, whose lengths can be different from each other. - * - * Returns true if two bitmaps have exactly the same set of bits set, - * otherwise false. - */ -bool virBitmapEqual(virBitmapPtr b1, virBitmapPtr b2) -{ - virBitmapPtr tmp; - int i; - - if (b1->max_bit > b2->max_bit) { - tmp = b1; - b1 = b2; - b2 = tmp; - } - - /* Now b1 is the smaller one, if not equal */ - - for (i = 0; i < b1->map_len; i++) { - if (b1->map[i] != b2->map[i]) - return false; - } - - for (; i < b2->map_len; i++) { - if (b2->map[i]) - return false; - } - - return true; -} - -size_t virBitmapSize(virBitmapPtr bitmap) -{ - return bitmap->max_bit; -} - -/** - * virBitmapSetAll: - * @bitmap: the bitmap - * - * set all bits in @bitmap. - */ -void virBitmapSetAll(virBitmapPtr bitmap) -{ - int tail = bitmap->max_bit % VIR_BITMAP_BITS_PER_UNIT; - - memset(bitmap->map, 0xff, - bitmap->map_len * (VIR_BITMAP_BITS_PER_UNIT / CHAR_BIT)); - - /* Ensure tail bits are clear. */ - if (tail) - bitmap->map[bitmap->map_len - 1] &= - -1UL >> (VIR_BITMAP_BITS_PER_UNIT - tail); -} - -/** - * virBitmapClearAll: - * @bitmap: the bitmap - * - * clear all bits in @bitmap. - */ -void virBitmapClearAll(virBitmapPtr bitmap) -{ - memset(bitmap->map, 0, - bitmap->map_len * (VIR_BITMAP_BITS_PER_UNIT / CHAR_BIT)); -} - -/** - * virBitmapIsAllSet: - * @bitmap: the bitmap to check - * - * check if all bits in @bitmap are set. - */ -bool virBitmapIsAllSet(virBitmapPtr bitmap) -{ - int i; - int unusedBits; - size_t sz; - - unusedBits = bitmap->map_len * VIR_BITMAP_BITS_PER_UNIT - bitmap->max_bit; - - sz = bitmap->map_len; - if (unusedBits > 0) - sz--; - - for (i = 0; i < sz; i++) - if (bitmap->map[i] != -1) - return false; - - if (unusedBits > 0) { - if ((bitmap->map[sz] & ((1UL << (VIR_BITMAP_BITS_PER_UNIT - unusedBits)) - 1)) - != ((1UL << (VIR_BITMAP_BITS_PER_UNIT - unusedBits)) - 1)) - return false; - } - - return true; -} - -/** - * virBitmapNextSetBit: - * @bitmap: the bitmap - * @pos: the position after which to search for a set bit - * - * search the first set bit after position @pos in bitmap @bitmap. - * @pos can be -1 to search for the first set bit. Position starts - * at 0. - * - * returns the position of the found bit, or -1 if no bit found. - */ -ssize_t virBitmapNextSetBit(virBitmapPtr bitmap, ssize_t pos) -{ - size_t nl; - size_t nb; - unsigned long bits; - - if (pos < 0) - pos = -1; - - pos++; - - if (pos >= bitmap->max_bit) - return -1; - - nl = pos / VIR_BITMAP_BITS_PER_UNIT; - nb = pos % VIR_BITMAP_BITS_PER_UNIT; - - bits = bitmap->map[nl] & ~((1UL << nb) - 1); - - while (bits == 0 && ++nl < bitmap->map_len) { - bits = bitmap->map[nl]; - } - - if (bits == 0) - return -1; - - return ffsl(bits) - 1 + nl * VIR_BITMAP_BITS_PER_UNIT; -} - -/* Return the number of bits currently set in the map. */ -size_t -virBitmapCountBits(virBitmapPtr bitmap) -{ - size_t i; - size_t ret = 0; - - for (i = 0; i < bitmap->map_len; i++) - ret += count_one_bits_l(bitmap->map[i]); - - return ret; -} diff --git a/src/util/bitmap.h b/src/util/bitmap.h deleted file mode 100644 index 346a1fb..0000000 --- a/src/util/bitmap.h +++ /dev/null @@ -1,109 +0,0 @@ -/* - * bitmap.h: Simple bitmap operations - * - * Copyright (C) 2012 Red Hat, Inc. - * Copyright (C) 2010 Novell, 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, see - * <http://www.gnu.org/licenses/>;. - * - * Author: Jim Fehlig <jfehlig(a)novell.com&gt; - */ - -#ifndef __BITMAP_H__ -# define __BITMAP_H__ - -# include "internal.h" - -# include <sys/types.h> - - -typedef struct _virBitmap virBitmap; -typedef virBitmap *virBitmapPtr; - -/* - * Allocate a bitmap capable of containing @size bits. - */ -virBitmapPtr virBitmapNew(size_t size) ATTRIBUTE_RETURN_CHECK; - -/* - * Free previously allocated bitmap - */ -void virBitmapFree(virBitmapPtr bitmap); - -/* - * Copy all bits from @src to @dst. The bitmap sizes - * must be the same - */ -int virBitmapCopy(virBitmapPtr dst, virBitmapPtr src); - -/* - * Set bit position @b in @bitmap - */ -int virBitmapSetBit(virBitmapPtr bitmap, size_t b) - ATTRIBUTE_NONNULL(1) ATTRIBUTE_RETURN_CHECK; - -/* - * Clear bit position @b in @bitmap - */ -int virBitmapClearBit(virBitmapPtr bitmap, size_t b) - ATTRIBUTE_NONNULL(1) ATTRIBUTE_RETURN_CHECK; - -/* - * Get setting of bit position @b in @bitmap and store in @result - */ -int virBitmapGetBit(virBitmapPtr bitmap, size_t b, bool *result) - ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(3) ATTRIBUTE_RETURN_CHECK; - -char *virBitmapString(virBitmapPtr bitmap) - ATTRIBUTE_NONNULL(1) ATTRIBUTE_RETURN_CHECK; - -char *virBitmapFormat(virBitmapPtr bitmap) - ATTRIBUTE_NONNULL(1); - -int virBitmapParse(const char *str, - char sep, - virBitmapPtr *bitmap, - size_t bitmapSize) - ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(3); - -virBitmapPtr virBitmapNewCopy(virBitmapPtr src) ATTRIBUTE_NONNULL(1); - -virBitmapPtr virBitmapNewData(void *data, int len) ATTRIBUTE_NONNULL(1); - -int virBitmapToData(virBitmapPtr bitmap, unsigned char **data, int *dataLen) - ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2); - -bool virBitmapEqual(virBitmapPtr b1, virBitmapPtr b2) - ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2); - -size_t virBitmapSize(virBitmapPtr bitmap) - ATTRIBUTE_NONNULL(1); - -void virBitmapSetAll(virBitmapPtr bitmap) - ATTRIBUTE_NONNULL(1); - -void virBitmapClearAll(virBitmapPtr bitmap) - ATTRIBUTE_NONNULL(1); - -bool virBitmapIsAllSet(virBitmapPtr bitmap) - ATTRIBUTE_NONNULL(1); - -ssize_t virBitmapNextSetBit(virBitmapPtr bitmap, ssize_t pos) - ATTRIBUTE_NONNULL(1); - -size_t virBitmapCountBits(virBitmapPtr bitmap) - ATTRIBUTE_NONNULL(1); - -#endif diff --git a/src/util/dnsmasq.c b/src/util/dnsmasq.c index e8eab1e..74593c8 100644 --- a/src/util/dnsmasq.c +++ b/src/util/dnsmasq.c @@ -39,7 +39,7 @@ #include "internal.h" #include "datatypes.h" -#include "bitmap.h" +#include "virbitmap.h" #include "dnsmasq.h" #include "util.h" #include "command.h" diff --git a/src/util/processinfo.h b/src/util/processinfo.h index 116c092..0ae23c6 100644 --- a/src/util/processinfo.h +++ b/src/util/processinfo.h @@ -23,7 +23,7 @@ # define __VIR_PROCESSINFO_H__ # include "internal.h" -# include "bitmap.h" +# include "virbitmap.h" int virProcessInfoSetAffinity(pid_t pid, virBitmapPtr map); diff --git a/src/util/virbitmap.c b/src/util/virbitmap.c new file mode 100644 index 0000000..0f13389 --- /dev/null +++ b/src/util/virbitmap.c @@ -0,0 +1,636 @@ +/* + * bitmap.h: Simple bitmap operations + * + * Copyright (C) 2010-2012 Red Hat, Inc. + * Copyright (C) 2010 Novell, 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, see + * <http://www.gnu.org/licenses/>;. + * + * Author: Jim Fehlig <jfehlig(a)novell.com&gt; + */ + +#include <config.h> + +#include <limits.h> +#include <stdint.h> +#include <stdio.h> +#include <string.h> +#include <stdlib.h> +#include <sys/types.h> + +#include "virbitmap.h" +#include "memory.h" +#include "buf.h" +#include "util.h" +#include "c-ctype.h" +#include "count-one-bits.h" + + +struct _virBitmap { + size_t max_bit; + size_t map_len; + unsigned long *map; +}; + + +#define VIR_BITMAP_BITS_PER_UNIT ((int) sizeof(unsigned long) * CHAR_BIT) +#define VIR_BITMAP_UNIT_OFFSET(b) ((b) / VIR_BITMAP_BITS_PER_UNIT) +#define VIR_BITMAP_BIT_OFFSET(b) ((b) % VIR_BITMAP_BITS_PER_UNIT) +#define VIR_BITMAP_BIT(b) (1UL << VIR_BITMAP_BIT_OFFSET(b)) + + +/** + * virBitmapNew: + * @size: number of bits + * + * Allocate a bitmap capable of containing @size bits. + * + * Returns a pointer to the allocated bitmap or NULL if + * memory cannot be allocated. + */ +virBitmapPtr virBitmapNew(size_t size) +{ + virBitmapPtr bitmap; + size_t sz; + + if (SIZE_MAX - VIR_BITMAP_BITS_PER_UNIT < size || size == 0) + return NULL; + + sz = (size + VIR_BITMAP_BITS_PER_UNIT - 1) / + VIR_BITMAP_BITS_PER_UNIT; + + if (VIR_ALLOC(bitmap) < 0) + return NULL; + + if (VIR_ALLOC_N(bitmap->map, sz) < 0) { + VIR_FREE(bitmap); + return NULL; + } + + bitmap->max_bit = size; + bitmap->map_len = sz; + return bitmap; +} + +/** + * virBitmapFree: + * @bitmap: previously allocated bitmap + * + * Free @bitmap previously allocated by virBitmapNew. + */ +void virBitmapFree(virBitmapPtr bitmap) +{ + if (bitmap) { + VIR_FREE(bitmap->map); + VIR_FREE(bitmap); + } +} + + +int virBitmapCopy(virBitmapPtr dst, virBitmapPtr src) +{ + if (dst->max_bit != src->max_bit) { + errno = EINVAL; + return -1; + } + + memcpy(dst->map, src->map, src->map_len * sizeof(src->map[0])); + + return 0; +} + + +/** + * virBitmapSetBit: + * @bitmap: Pointer to bitmap + * @b: bit position to set + * + * Set bit position @b in @bitmap + * + * Returns 0 on if bit is successfully set, -1 on error. + */ +int virBitmapSetBit(virBitmapPtr bitmap, size_t b) +{ + if (bitmap->max_bit <= b) + return -1; + + bitmap->map[VIR_BITMAP_UNIT_OFFSET(b)] |= VIR_BITMAP_BIT(b); + return 0; +} + +/** + * virBitmapClearBit: + * @bitmap: Pointer to bitmap + * @b: bit position to clear + * + * Clear bit position @b in @bitmap + * + * Returns 0 on if bit is successfully clear, -1 on error. + */ +int virBitmapClearBit(virBitmapPtr bitmap, size_t b) +{ + if (bitmap->max_bit <= b) + return -1; + + bitmap->map[VIR_BITMAP_UNIT_OFFSET(b)] &= ~VIR_BITMAP_BIT(b); + return 0; +} + +/* Helper function. caller must ensure b < bitmap->max_bit */ +static bool virBitmapIsSet(virBitmapPtr bitmap, size_t b) +{ + return !!(bitmap->map[VIR_BITMAP_UNIT_OFFSET(b)] & VIR_BITMAP_BIT(b)); +} + +/** + * virBitmapGetBit: + * @bitmap: Pointer to bitmap + * @b: bit position to get + * @result: bool pointer to receive bit setting + * + * Get setting of bit position @b in @bitmap and store in @result + * + * On success, @result will contain the setting of @b and 0 is + * returned. On failure, -1 is returned and @result is unchanged. + */ +int virBitmapGetBit(virBitmapPtr bitmap, size_t b, bool *result) +{ + if (bitmap->max_bit <= b) + return -1; + + *result = virBitmapIsSet(bitmap, b); + return 0; +} + +/** + * virBitmapString: + * @bitmap: Pointer to bitmap + * + * Convert @bitmap to printable string. + * + * Returns pointer to the string or NULL on error. + */ +char *virBitmapString(virBitmapPtr bitmap) +{ + virBuffer buf = VIR_BUFFER_INITIALIZER; + size_t sz; + + virBufferAddLit(&buf, "0x"); + + sz = bitmap->map_len; + + while (sz--) { + virBufferAsprintf(&buf, "%0*lx", + VIR_BITMAP_BITS_PER_UNIT / 4, + bitmap->map[sz]); + } + + if (virBufferError(&buf)) { + virBufferFreeAndReset(&buf); + return NULL; + } + + return virBufferContentAndReset(&buf); +} + +/** + * virBitmapFormat: + * @bitmap: the bitmap + * + * This function is the counterpart of virBitmapParse. This function creates + * a human-readable string representing the bits in bitmap. + * + * See virBitmapParse for the format of @str. + * + * Returns the string on success or NULL otherwise. Caller should call + * VIR_FREE to free the string. + */ +char *virBitmapFormat(virBitmapPtr bitmap) +{ + virBuffer buf = VIR_BUFFER_INITIALIZER; + bool first = true; + int start, cur, prev; + + if (!bitmap) + return NULL; + + cur = virBitmapNextSetBit(bitmap, -1); + if (cur < 0) + return strdup(""); + + start = prev = cur; + while (prev >= 0) { + cur = virBitmapNextSetBit(bitmap, prev); + + if (cur == prev + 1) { + prev = cur; + continue; + } + + /* cur < 0 or cur > prev + 1 */ + + if (!first) + virBufferAddLit(&buf, ","); + else + first = false; + + if (prev == start) + virBufferAsprintf(&buf, "%d", start); + else + virBufferAsprintf(&buf, "%d-%d", start, prev); + + start = prev = cur; + } + + if (virBufferError(&buf)) { + virBufferFreeAndReset(&buf); + return NULL; + } + + return virBufferContentAndReset(&buf); +} + +/** + * virBitmapParse: + * @str: points to a string representing a human-readable bitmap + * @bitmap: a bitmap created from @str + * @bitmapSize: the upper limit of num of bits in created bitmap + * + * This function is the counterpart of virBitmapFormat. This function creates + * a bitmap, in which bits are set according to the content of @str. + * + * @str is a comma separated string of fields N, which means a number of bit + * to set, and ^N, which means to unset the bit, and N-M for ranges of bits + * to set. + * + * Returns the number of bits set in @bitmap, or -1 in case of error. + */ + +int virBitmapParse(const char *str, + char sep, + virBitmapPtr *bitmap, + size_t bitmapSize) +{ + int ret = 0; + bool neg = false; + const char *cur; + char *tmp; + int i, start, last; + + if (!str) + return -1; + + cur = str; + virSkipSpaces(&cur); + + if (*cur == 0) + return -1; + + *bitmap = virBitmapNew(bitmapSize); + if (!*bitmap) + return -1; + + while (*cur != 0 && *cur != sep) { + /* + * 3 constructs are allowed: + * - N : a single CPU number + * - N-M : a range of CPU numbers with N < M + * - ^N : remove a single CPU number from the current set + */ + if (*cur == '^') { + cur++; + neg = true; + } + + if (!c_isdigit(*cur)) + goto parse_error; + + if (virStrToLong_i(cur, &tmp, 10, &start) < 0) + goto parse_error; + if (start < 0) + goto parse_error; + + cur = tmp; + + virSkipSpaces(&cur); + + if (*cur == ',' || *cur == 0 || *cur == sep) { + if (neg) { + if (virBitmapIsSet(*bitmap, start)) { + ignore_value(virBitmapClearBit(*bitmap, start)); + ret--; + } + } else { + if (!virBitmapIsSet(*bitmap, start)) { + ignore_value(virBitmapSetBit(*bitmap, start)); + ret++; + } + } + } else if (*cur == '-') { + if (neg) + goto parse_error; + + cur++; + virSkipSpaces(&cur); + + if (virStrToLong_i(cur, &tmp, 10, &last) < 0) + goto parse_error; + if (last < start) + goto parse_error; + + cur = tmp; + + for (i = start; i <= last; i++) { + if (!virBitmapIsSet(*bitmap, i)) { + ignore_value(virBitmapSetBit(*bitmap, i)); + ret++; + } + } + + virSkipSpaces(&cur); + } + + if (*cur == ',') { + cur++; + virSkipSpaces(&cur); + neg = false; + } else if (*cur == 0 || *cur == sep) { + break; + } else { + goto parse_error; + } + } + + return ret; + +parse_error: + virBitmapFree(*bitmap); + *bitmap = NULL; + return -1; +} + +/** + * virBitmapNewCopy: + * @src: the source bitmap. + * + * Makes a copy of bitmap @src. + * + * returns the copied bitmap on success, or NULL otherwise. Caller + * should call virBitmapFree to free the returned bitmap. + */ +virBitmapPtr virBitmapNewCopy(virBitmapPtr src) +{ + virBitmapPtr dst; + + if ((dst = virBitmapNew(src->max_bit)) == NULL) + return NULL; + + if (virBitmapCopy(dst, src) != 0) { + virBitmapFree(dst); + return NULL; + } + + return dst; +} + +/** + * virBitmapNewData: + * @data: the data + * @len: length of @data in bytes + * + * Allocate a bitmap from a chunk of data containing bits + * information + * + * Returns a pointer to the allocated bitmap or NULL if + * memory cannot be allocated. + */ +virBitmapPtr virBitmapNewData(void *data, int len) +{ + virBitmapPtr bitmap; + int i, j; + unsigned long *p; + unsigned char *bytes = data; + + bitmap = virBitmapNew(len * CHAR_BIT); + if (!bitmap) + return NULL; + + /* le64toh is not provided by gnulib, so we do the conversion by hand */ + p = bitmap->map; + for (i = j = 0; i < len; i++, j++) { + if (j == sizeof(*p)) { + j = 0; + p++; + } + *p |= (unsigned long) bytes[i] << (j * CHAR_BIT); + } + + return bitmap; +} + +/** + * virBitmapToData: + * @data: the data + * @len: len of @data in byte + * + * Convert a bitmap to a chunk of data containing bits information. + * Data consists of sequential bytes, with lower bytes containing + * lower bits. + * + * Returns 0 on success, -1 otherwise. + */ +int virBitmapToData(virBitmapPtr bitmap, unsigned char **data, int *dataLen) +{ + int len; + unsigned long *l; + int i, j; + unsigned char *bytes; + + len = (bitmap->max_bit + CHAR_BIT - 1) / CHAR_BIT; + + if (VIR_ALLOC_N(*data, len) < 0) + return -1; + + bytes = *data; + *dataLen = len; + + /* htole64 is not provided by gnulib, so we do the conversion by hand */ + l = bitmap->map; + for (i = j = 0; i < len; i++, j++) { + if (j == sizeof(*l)) { + j = 0; + l++; + } + bytes[i] = *l >> (j * CHAR_BIT); + } + + return 0; +} + +/** + * virBitmapEqual: + * @b1: bitmap 1 + * @b2: bitmap 2 + * + * Compares two bitmaps, whose lengths can be different from each other. + * + * Returns true if two bitmaps have exactly the same set of bits set, + * otherwise false. + */ +bool virBitmapEqual(virBitmapPtr b1, virBitmapPtr b2) +{ + virBitmapPtr tmp; + int i; + + if (b1->max_bit > b2->max_bit) { + tmp = b1; + b1 = b2; + b2 = tmp; + } + + /* Now b1 is the smaller one, if not equal */ + + for (i = 0; i < b1->map_len; i++) { + if (b1->map[i] != b2->map[i]) + return false; + } + + for (; i < b2->map_len; i++) { + if (b2->map[i]) + return false; + } + + return true; +} + +size_t virBitmapSize(virBitmapPtr bitmap) +{ + return bitmap->max_bit; +} + +/** + * virBitmapSetAll: + * @bitmap: the bitmap + * + * set all bits in @bitmap. + */ +void virBitmapSetAll(virBitmapPtr bitmap) +{ + int tail = bitmap->max_bit % VIR_BITMAP_BITS_PER_UNIT; + + memset(bitmap->map, 0xff, + bitmap->map_len * (VIR_BITMAP_BITS_PER_UNIT / CHAR_BIT)); + + /* Ensure tail bits are clear. */ + if (tail) + bitmap->map[bitmap->map_len - 1] &= + -1UL >> (VIR_BITMAP_BITS_PER_UNIT - tail); +} + +/** + * virBitmapClearAll: + * @bitmap: the bitmap + * + * clear all bits in @bitmap. + */ +void virBitmapClearAll(virBitmapPtr bitmap) +{ + memset(bitmap->map, 0, + bitmap->map_len * (VIR_BITMAP_BITS_PER_UNIT / CHAR_BIT)); +} + +/** + * virBitmapIsAllSet: + * @bitmap: the bitmap to check + * + * check if all bits in @bitmap are set. + */ +bool virBitmapIsAllSet(virBitmapPtr bitmap) +{ + int i; + int unusedBits; + size_t sz; + + unusedBits = bitmap->map_len * VIR_BITMAP_BITS_PER_UNIT - bitmap->max_bit; + + sz = bitmap->map_len; + if (unusedBits > 0) + sz--; + + for (i = 0; i < sz; i++) + if (bitmap->map[i] != -1) + return false; + + if (unusedBits > 0) { + if ((bitmap->map[sz] & ((1UL << (VIR_BITMAP_BITS_PER_UNIT - unusedBits)) - 1)) + != ((1UL << (VIR_BITMAP_BITS_PER_UNIT - unusedBits)) - 1)) + return false; + } + + return true; +} + +/** + * virBitmapNextSetBit: + * @bitmap: the bitmap + * @pos: the position after which to search for a set bit + * + * search the first set bit after position @pos in bitmap @bitmap. + * @pos can be -1 to search for the first set bit. Position starts + * at 0. + * + * returns the position of the found bit, or -1 if no bit found. + */ +ssize_t virBitmapNextSetBit(virBitmapPtr bitmap, ssize_t pos) +{ + size_t nl; + size_t nb; + unsigned long bits; + + if (pos < 0) + pos = -1; + + pos++; + + if (pos >= bitmap->max_bit) + return -1; + + nl = pos / VIR_BITMAP_BITS_PER_UNIT; + nb = pos % VIR_BITMAP_BITS_PER_UNIT; + + bits = bitmap->map[nl] & ~((1UL << nb) - 1); + + while (bits == 0 && ++nl < bitmap->map_len) { + bits = bitmap->map[nl]; + } + + if (bits == 0) + return -1; + + return ffsl(bits) - 1 + nl * VIR_BITMAP_BITS_PER_UNIT; +} + +/* Return the number of bits currently set in the map. */ +size_t +virBitmapCountBits(virBitmapPtr bitmap) +{ + size_t i; + size_t ret = 0; + + for (i = 0; i < bitmap->map_len; i++) + ret += count_one_bits_l(bitmap->map[i]); + + return ret; +} diff --git a/src/util/virbitmap.h b/src/util/virbitmap.h new file mode 100644 index 0000000..346a1fb --- /dev/null +++ b/src/util/virbitmap.h @@ -0,0 +1,109 @@ +/* + * bitmap.h: Simple bitmap operations + * + * Copyright (C) 2012 Red Hat, Inc. + * Copyright (C) 2010 Novell, 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, see + * <http://www.gnu.org/licenses/>;. + * + * Author: Jim Fehlig <jfehlig(a)novell.com&gt; + */ + +#ifndef __BITMAP_H__ +# define __BITMAP_H__ + +# include "internal.h" + +# include <sys/types.h> + + +typedef struct _virBitmap virBitmap; +typedef virBitmap *virBitmapPtr; + +/* + * Allocate a bitmap capable of containing @size bits. + */ +virBitmapPtr virBitmapNew(size_t size) ATTRIBUTE_RETURN_CHECK; + +/* + * Free previously allocated bitmap + */ +void virBitmapFree(virBitmapPtr bitmap); + +/* + * Copy all bits from @src to @dst. The bitmap sizes + * must be the same + */ +int virBitmapCopy(virBitmapPtr dst, virBitmapPtr src); + +/* + * Set bit position @b in @bitmap + */ +int virBitmapSetBit(virBitmapPtr bitmap, size_t b) + ATTRIBUTE_NONNULL(1) ATTRIBUTE_RETURN_CHECK; + +/* + * Clear bit position @b in @bitmap + */ +int virBitmapClearBit(virBitmapPtr bitmap, size_t b) + ATTRIBUTE_NONNULL(1) ATTRIBUTE_RETURN_CHECK; + +/* + * Get setting of bit position @b in @bitmap and store in @result + */ +int virBitmapGetBit(virBitmapPtr bitmap, size_t b, bool *result) + ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(3) ATTRIBUTE_RETURN_CHECK; + +char *virBitmapString(virBitmapPtr bitmap) + ATTRIBUTE_NONNULL(1) ATTRIBUTE_RETURN_CHECK; + +char *virBitmapFormat(virBitmapPtr bitmap) + ATTRIBUTE_NONNULL(1); + +int virBitmapParse(const char *str, + char sep, + virBitmapPtr *bitmap, + size_t bitmapSize) + ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(3); + +virBitmapPtr virBitmapNewCopy(virBitmapPtr src) ATTRIBUTE_NONNULL(1); + +virBitmapPtr virBitmapNewData(void *data, int len) ATTRIBUTE_NONNULL(1); + +int virBitmapToData(virBitmapPtr bitmap, unsigned char **data, int *dataLen) + ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2); + +bool virBitmapEqual(virBitmapPtr b1, virBitmapPtr b2) + ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2); + +size_t virBitmapSize(virBitmapPtr bitmap) + ATTRIBUTE_NONNULL(1); + +void virBitmapSetAll(virBitmapPtr bitmap) + ATTRIBUTE_NONNULL(1); + +void virBitmapClearAll(virBitmapPtr bitmap) + ATTRIBUTE_NONNULL(1); + +bool virBitmapIsAllSet(virBitmapPtr bitmap) + ATTRIBUTE_NONNULL(1); + +ssize_t virBitmapNextSetBit(virBitmapPtr bitmap, ssize_t pos) + ATTRIBUTE_NONNULL(1); + +size_t virBitmapCountBits(virBitmapPtr bitmap) + ATTRIBUTE_NONNULL(1); + +#endif diff --git a/tests/virbitmaptest.c b/tests/virbitmaptest.c index af94dab..db76672 100644 --- a/tests/virbitmaptest.c +++ b/tests/virbitmaptest.c @@ -21,7 +21,7 @@ #include "testutils.h" -#include "bitmap.h" +#include "virbitmap.h" static int test1(const void *data ATTRIBUTE_UNUSED) { diff --git a/tools/virsh-domain.c b/tools/virsh-domain.c index 561e0e7..765f30c 100644 --- a/tools/virsh-domain.c +++ b/tools/virsh-domain.c @@ -37,7 +37,7 @@ #include <libxml/xmlsave.h> #include "internal.h" -#include "bitmap.h" +#include "virbitmap.h" #include "buf.h" #include "c-ctype.h" #include "conf/domain_conf.h" diff --git a/tools/virsh.c b/tools/virsh.c index 465cb44..2f7d4a3 100644 --- a/tools/virsh.c +++ b/tools/virsh.c @@ -69,7 +69,7 @@ #include "command.h" #include "virkeycode.h" #include "virnetdevbandwidth.h" -#include "util/bitmap.h" +#include "virbitmap.h" #include "conf/domain_conf.h" #include "virtypedparam.h" -- 1.7.11.7