This copies intprops.h to virintprops.h. A couple of conditionals were cut out since we don't need to support OpenVMS or ancient GCC 2.x Signed-off-by: Daniel P. Berrangé <berrange(a)redhat.com&gt; --- build-aux/syntax-check.mk | 7 +- src/hyperv/hyperv_driver.c | 2 +- src/libvirt-domain.c | 2 +- src/nwfilter/nwfilter_ebiptables_driver.c | 2 +- src/nwfilter/nwfilter_learnipaddr.c | 2 +- src/remote/remote_daemon_dispatch.c | 2 +- src/remote/remote_driver.c | 2 +- src/util/Makefile.inc.am | 1 + src/util/virfile.c | 2 +- src/util/virhostcpu.c | 2 +- src/util/virintprops.h | 526 ++++++++++++++++++++++ src/util/virlog.c | 2 +- src/util/virnetdevbridge.c | 2 +- src/util/virpidfile.c | 2 +- tests/virsystemdtest.c | 2 +- tools/virsh-domain-monitor.c | 2 +- tools/virt-login-shell.c | 7 +- 17 files changed, 548 insertions(+), 19 deletions(-) create mode 100644 src/util/virintprops.h diff --git a/build-aux/syntax-check.mk b/build-aux/syntax-check.mk index 7e7c59c3df..5b85b4d1de 100644 --- a/build-aux/syntax-check.mk +++ b/build-aux/syntax-check.mk @@ -1611,13 +1611,13 @@ gl_extract_define_simple = \ /^\# *define ([A-Z]\w+)\(/ and print $$1 # Filter out duplicates and convert to a space-separated list: _intprops_names = \ - $(shell f=$(gnulib_dir)/lib/intprops.h; \ + $(shell f=$(srcdir)/src/util/virintprops.h; \ perl -lne '$(gl_extract_define_simple)' $$f | sort -u | tr '\n' ' ') # Remove trailing space and convert to a regular expression: _intprops_syms_re = $(subst $(_sp),|,$(strip $(_intprops_names))) # Prohibit the inclusion of intprops.h without an actual use. sc_prohibit_intprops_without_use: - @h='intprops.h' \ + @h='virintprops.h' \ re='\<($(_intprops_syms_re)) *\(' \ $(_sc_header_without_use) @@ -2360,3 +2360,6 @@ exclude_file_name_regexp--sc_prohibit_strcmp = \ exclude_file_name_regexp--sc_prohibit_backslash_alignment = \ ^build-aux/syntax-check\.mk$$ + +exclude_file_name_regexp--sc_prohibit_wrong_filename_in_comment = \ + ^src/util/virintprops\.h$$ diff --git a/src/hyperv/hyperv_driver.c b/src/hyperv/hyperv_driver.c index c9d22ec7c4..f9751b7591 100644 --- a/src/hyperv/hyperv_driver.c +++ b/src/hyperv/hyperv_driver.c @@ -36,7 +36,7 @@ #include "openwsman.h" #include "virstring.h" #include "virkeycode.h" -#include "intprops.h" +#include "virintprops.h" #define VIR_FROM_THIS VIR_FROM_HYPERV diff --git a/src/libvirt-domain.c b/src/libvirt-domain.c index eb66999f07..9144f0a98a 100644 --- a/src/libvirt-domain.c +++ b/src/libvirt-domain.c @@ -21,7 +21,7 @@ #include <config.h> #include <sys/stat.h> -#include "intprops.h" +#include "virintprops.h" #include "datatypes.h" #include "viralloc.h" diff --git a/src/nwfilter/nwfilter_ebiptables_driver.c b/src/nwfilter/nwfilter_ebiptables_driver.c index eec1414023..8e85c9723b 100644 --- a/src/nwfilter/nwfilter_ebiptables_driver.c +++ b/src/nwfilter/nwfilter_ebiptables_driver.c @@ -40,7 +40,7 @@ #include "virfile.h" #include "vircommand.h" #include "configmake.h" -#include "intprops.h" +#include "virintprops.h" #include "virstring.h" #include "virfirewall.h" diff --git a/src/nwfilter/nwfilter_learnipaddr.c b/src/nwfilter/nwfilter_learnipaddr.c index 46ef65401c..91e7e1d100 100644 --- a/src/nwfilter/nwfilter_learnipaddr.c +++ b/src/nwfilter/nwfilter_learnipaddr.c @@ -39,7 +39,7 @@ #include "internal.h" -#include "intprops.h" +#include "virintprops.h" #include "virbuffer.h" #include "viralloc.h" #include "virlog.h" diff --git a/src/remote/remote_daemon_dispatch.c b/src/remote/remote_daemon_dispatch.c index 9c294ddc39..995d463266 100644 --- a/src/remote/remote_daemon_dispatch.c +++ b/src/remote/remote_daemon_dispatch.c @@ -31,7 +31,7 @@ #include "remote_daemon_stream.h" #include "viruuid.h" #include "vircommand.h" -#include "intprops.h" +#include "virintprops.h" #include "virnetserverservice.h" #include "virnetserver.h" #include "virfile.h" diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c index c11f73ab4d..7eb9e1bc7c 100644 --- a/src/remote/remote_driver.c +++ b/src/remote/remote_driver.c @@ -43,7 +43,7 @@ #include "viralloc.h" #include "virfile.h" #include "vircommand.h" -#include "intprops.h" +#include "virintprops.h" #include "virtypedparam.h" #include "viruri.h" #include "virauth.h" diff --git a/src/util/Makefile.inc.am b/src/util/Makefile.inc.am index dfa8347853..03054e8862 100644 --- a/src/util/Makefile.inc.am +++ b/src/util/Makefile.inc.am @@ -102,6 +102,7 @@ UTIL_SOURCES = \ util/viridentity.h \ util/virinitctl.c \ util/virinitctl.h \ + util/virintprops.h \ util/viriptables.c \ util/viriptables.h \ util/viriscsi.c \ diff --git a/src/util/virfile.c b/src/util/virfile.c index 5acac85bb9..a6d2d4a8e3 100644 --- a/src/util/virfile.c +++ b/src/util/virfile.c @@ -68,7 +68,7 @@ #endif #include "configmake.h" -#include "intprops.h" +#include "virintprops.h" #include "viralloc.h" #include "vircommand.h" #include "virerror.h" diff --git a/src/util/virhostcpu.c b/src/util/virhostcpu.c index 7f14340f49..c948278c9a 100644 --- a/src/util/virhostcpu.c +++ b/src/util/virhostcpu.c @@ -43,7 +43,7 @@ #include "virhostcpupriv.h" #include "physmem.h" #include "virerror.h" -#include "intprops.h" +#include "virintprops.h" #include "virarch.h" #include "virfile.h" #include "virtypedparam.h" diff --git a/src/util/virintprops.h b/src/util/virintprops.h new file mode 100644 index 0000000000..7cde3c0445 --- /dev/null +++ b/src/util/virintprops.h @@ -0,0 +1,526 @@ +/* + * Based on GNULIB intprops.h -- properties of integer types + * + * Copyright (C) 2001-2019 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 <https://www.gnu.org/licenses/>;. + * + * Written by Paul Eggert. + */ + +#pragma once + +#include "internal.h" + +#include <limits.h> + +/* Return a value with the common real type of E and V and the value of V. + Do not evaluate E. */ +#define VIR_INT_CONVERT(e, v) ((1 ? 0 : (e)) + (v)) + +/* Act like VIR_INT_CONVERT (E, -V) but work around a bug in IRIX 6.5 cc; see + <https://lists.gnu.org/r/bug-gnulib/2011-05/msg00406.html>;. */ +#define VIR_INT_NEGATE_CONVERT(e, v) ((1 ? 0 : (e)) - (v)) + +/* The extra casts in the following macros work around compiler bugs, + e.g., in Cray C 5.0.3.0. */ + +/* True if the arithmetic type T is an integer type. bool counts as + an integer. */ +#define TYPE_IS_INTEGER(t) ((t) 1.5 == 1) + +/* True if the real type T is signed. */ +#define TYPE_SIGNED(t) (! ((t) 0 < (t) -1)) + +/* Return 1 if the real expression E, after promotion, has a + signed or floating type. Do not evaluate E. */ +#define EXPR_SIGNED(e) (VIR_INT_NEGATE_CONVERT (e, 1) < 0) + + +/* Minimum and maximum values for integer types and expressions. */ + +/* The width in bits of the integer type or expression T. + Do not evaluate T. + Padding bits are not supported; this is checked at compile-time below. */ +#define TYPE_WIDTH(t) (sizeof(t) * CHAR_BIT) + +/* The maximum and minimum values for the integer type T. */ +#define TYPE_MINIMUM(t) ((t) ~ TYPE_MAXIMUM (t)) +#define TYPE_MAXIMUM(t) \ + ((t) (! TYPE_SIGNED (t) \ + ? (t) -1 \ + : ((((t) 1 << (TYPE_WIDTH (t) - 2)) - 1) * 2 + 1))) + +/* The maximum and minimum values for the type of the expression E, + after integer promotion. E is not evaluated. */ +#define VIR_INT_MINIMUM(e) \ + (EXPR_SIGNED (e) \ + ? ~ VIR_SIGNED_INT_MAXIMUM (e) \ + : VIR_INT_CONVERT (e, 0)) +#define VIR_INT_MAXIMUM(e) \ + (EXPR_SIGNED (e) \ + ? VIR_SIGNED_INT_MAXIMUM (e) \ + : VIR_INT_NEGATE_CONVERT (e, 1)) +#define VIR_SIGNED_INT_MAXIMUM(e) \ + (((VIR_INT_CONVERT (e, 1) << (TYPE_WIDTH ((e) + 0) - 2)) - 1) * 2 + 1) + +/* This include file assumes that signed types are two's complement without + padding bits; the above macros have undefined behavior otherwise. + If this is a problem for you, please let us know how to fix it for your host. + This assumption is tested by the intprops-tests module. */ + +/* Return 1 if the integer type or expression T might be signed. Return 0 + if it is definitely unsigned. This macro does not evaluate its argument, + and expands to an integer constant expression. */ +#define VIR_SIGNED_TYPE_OR_EXPR(t) TYPE_SIGNED (__typeof__ (t)) + +/* Bound on length of the string representing an unsigned integer + value representable in B bits. log10 (2.0) < 146/485. The + smallest value of B where this bound is not tight is 2621. */ +#define INT_BITS_STRLEN_BOUND(b) (((b) * 146 + 484) / 485) + +/* Bound on length of the string representing an integer type or expression T. + Subtract 1 for the sign bit if T is signed, and then add 1 more for + a minus sign if needed. + + Because VIR_SIGNED_TYPE_OR_EXPR sometimes returns 1 when its argument is + unsigned, this macro may overestimate the true bound by one byte when + applied to unsigned types of size 2, 4, 16, ... bytes. */ +#define INT_STRLEN_BOUND(t) \ + (INT_BITS_STRLEN_BOUND (TYPE_WIDTH (t) - VIR_SIGNED_TYPE_OR_EXPR (t)) \ + + VIR_SIGNED_TYPE_OR_EXPR (t)) + +/* Bound on buffer size needed to represent an integer type or expression T, + including the terminating null. */ +#define INT_BUFSIZE_BOUND(t) (INT_STRLEN_BOUND (t) + 1) + + +/* Range overflow checks. + + The INT_<op>_RANGE_OVERFLOW macros return 1 if the corresponding C + operators might not yield numerically correct answers due to + arithmetic overflow. They do not rely on undefined or + implementation-defined behavior. Their implementations are simple + and straightforward, but they are a bit harder to use than the + INT_<op>_OVERFLOW macros described below. + + Example usage: + + long int x = ...; + long int y = ...; + if (INT_MULTIPLY_RANGE_OVERFLOW (x, y, LONG_MIN, LONG_MAX)) + printf ("multiply would overflow"); + else + printf ("product is %ld", x * y); + + Restrictions on *_RANGE_OVERFLOW macros: + + These macros do not check for all possible numerical problems or + undefined or unspecified behavior: they do not check for division + by zero, for bad shift counts, or for shifting negative numbers. + + These macros may evaluate their arguments zero or multiple times, + so the arguments should not have side effects. The arithmetic + arguments (including the MIN and MAX arguments) must be of the same + integer type after the usual arithmetic conversions, and the type + must have minimum value MIN and maximum MAX. Unsigned types should + use a zero MIN of the proper type. + + These macros are tuned for constant MIN and MAX. For commutative + operations such as A + B, they are also tuned for constant B. */ + +/* Return 1 if A + B would overflow in [MIN,MAX] arithmetic. + See above for restrictions. */ +#define INT_ADD_RANGE_OVERFLOW(a, b, min, max) \ + ((b) < 0 \ + ? (a) < (min) - (b) \ + : (max) - (b) < (a)) + +/* Return 1 if A - B would overflow in [MIN,MAX] arithmetic. + See above for restrictions. */ +#define INT_SUBTRACT_RANGE_OVERFLOW(a, b, min, max) \ + ((b) < 0 \ + ? (max) + (b) < (a) \ + : (a) < (min) + (b)) + +/* Return 1 if - A would overflow in [MIN,MAX] arithmetic. + See above for restrictions. */ +#define INT_NEGATE_RANGE_OVERFLOW(a, min, max) \ + ((min) < 0 \ + ? (a) < - (max) \ + : 0 < (a)) + +/* Return 1 if A * B would overflow in [MIN,MAX] arithmetic. + See above for restrictions. Avoid && and || as they tickle + bugs in Sun C 5.11 2010/08/13 and other compilers; see + <https://lists.gnu.org/r/bug-gnulib/2011-05/msg00401.html>;. */ +#define INT_MULTIPLY_RANGE_OVERFLOW(a, b, min, max) \ + ((b) < 0 \ + ? ((a) < 0 \ + ? (a) < (max) / (b) \ + : (b) == -1 \ + ? 0 \ + : (min) / (b) < (a)) \ + : (b) == 0 \ + ? 0 \ + : ((a) < 0 \ + ? (a) < (min) / (b) \ + : (max) / (b) < (a))) + +/* Return 1 if A / B would overflow in [MIN,MAX] arithmetic. + See above for restrictions. Do not check for division by zero. */ +#define INT_DIVIDE_RANGE_OVERFLOW(a, b, min, max) \ + ((min) < 0 && (b) == -1 && (a) < - (max)) + +/* Return 1 if A % B would overflow in [MIN,MAX] arithmetic. + See above for restrictions. Do not check for division by zero. + Mathematically, % should never overflow, but on x86-like hosts + INT_MIN % -1 traps, and the C standard permits this, so treat this + as an overflow too. */ +#define INT_REMAINDER_RANGE_OVERFLOW(a, b, min, max) \ + INT_DIVIDE_RANGE_OVERFLOW (a, b, min, max) + +/* Return 1 if A << B would overflow in [MIN,MAX] arithmetic. + See above for restrictions. Here, MIN and MAX are for A only, and B need + not be of the same type as the other arguments. The C standard says that + behavior is undefined for shifts unless 0 <= B < wordwidth, and that when + A is negative then A << B has undefined behavior and A >> B has + implementation-defined behavior, but do not check these other + restrictions. */ +#define INT_LEFT_SHIFT_RANGE_OVERFLOW(a, b, min, max) \ + ((a) < 0 \ + ? (a) < (min) >> (b) \ + : (max) >> (b) < (a)) + +/* True if __builtin_add_overflow (A, B, P) works when P is non-null. */ +#if 5 <= __GNUC__ && !defined __ICC +# define VIR_HAS_BUILTIN_OVERFLOW 1 +#else +# define VIR_HAS_BUILTIN_OVERFLOW 0 +#endif + +/* True if __builtin_add_overflow_p (A, B, C) works. */ +#define VIR_HAS_BUILTIN_OVERFLOW_P (7 <= __GNUC__) + +/* The VIR*_OVERFLOW macros have the same restrictions as the + *_RANGE_OVERFLOW macros, except that they do not assume that operands + (e.g., A and B) have the same type as MIN and MAX. Instead, they assume + that the result (e.g., A + B) has that type. */ +#if VIR_HAS_BUILTIN_OVERFLOW_P +# define VIR_ADD_OVERFLOW(a, b, min, max) \ + __builtin_add_overflow_p (a, b, (__typeof__ ((a) + (b))) 0) +# define VIR_SUBTRACT_OVERFLOW(a, b, min, max) \ + __builtin_sub_overflow_p (a, b, (__typeof__ ((a) - (b))) 0) +# define VIR_MULTIPLY_OVERFLOW(a, b, min, max) \ + __builtin_mul_overflow_p (a, b, (__typeof__ ((a) * (b))) 0) +#else +# define VIR_ADD_OVERFLOW(a, b, min, max) \ + ((min) < 0 ? INT_ADD_RANGE_OVERFLOW (a, b, min, max) \ + : (a) < 0 ? (b) <= (a) + (b) \ + : (b) < 0 ? (a) <= (a) + (b) \ + : (a) + (b) < (b)) +# define VIR_SUBTRACT_OVERFLOW(a, b, min, max) \ + ((min) < 0 ? INT_SUBTRACT_RANGE_OVERFLOW (a, b, min, max) \ + : (a) < 0 ? 1 \ + : (b) < 0 ? (a) - (b) <= (a) \ + : (a) < (b)) +# define VIR_MULTIPLY_OVERFLOW(a, b, min, max) \ + (((min) == 0 && (((a) < 0 && 0 < (b)) || ((b) < 0 && 0 < (a)))) \ + || INT_MULTIPLY_RANGE_OVERFLOW (a, b, min, max)) +#endif +#define VIR_DIVIDE_OVERFLOW(a, b, min, max) \ + ((min) < 0 ? (b) == VIR_INT_NEGATE_CONVERT (min, 1) && (a) < - (max) \ + : (a) < 0 ? (b) <= (a) + (b) - 1 \ + : (b) < 0 && (a) + (b) <= (a)) +#define VIR_REMAINDER_OVERFLOW(a, b, min, max) \ + ((min) < 0 ? (b) == VIR_INT_NEGATE_CONVERT (min, 1) && (a) < - (max) \ + : (a) < 0 ? (a) % (b) != ((max) - (b) + 1) % (b) \ + : (b) < 0 && ! VIR_UNSIGNED_NEG_MULTIPLE (a, b, max)) + +/* Return a nonzero value if A is a mathematical multiple of B, where + A is unsigned, B is negative, and MAX is the maximum value of A's + type. A's type must be the same as (A % B)'s type. Normally (A % + -B == 0) suffices, but things get tricky if -B would overflow. */ +#define VIR_UNSIGNED_NEG_MULTIPLE(a, b, max) \ + (((b) < -VIR_SIGNED_INT_MAXIMUM (b) \ + ? (VIR_SIGNED_INT_MAXIMUM (b) == (max) \ + ? (a) \ + : (a) % (VIR_INT_CONVERT (a, VIR_SIGNED_INT_MAXIMUM (b)) + 1)) \ + : (a) % - (b)) \ + == 0) + +/* Check for integer overflow, and report low order bits of answer. + + The INT_<op>_OVERFLOW macros return 1 if the corresponding C operators + might not yield numerically correct answers due to arithmetic overflow. + The INT_<op>_WRAPV macros compute the low-order bits of the sum, + difference, and product of two C integers, and return 1 if these + low-order bits are not numerically correct. + These macros work correctly on all known practical hosts, and do not rely + on undefined behavior due to signed arithmetic overflow. + + Example usage, assuming A and B are long int: + + if (INT_MULTIPLY_OVERFLOW (a, b)) + printf ("result would overflow\n"); + else + printf ("result is %ld (no overflow)\n", a * b); + + Example usage with WRAPV flavor: + + long int result; + bool overflow = INT_MULTIPLY_WRAPV (a, b, &result); + printf ("result is %ld (%s)\n", result, + overflow ? "after overflow" : "no overflow"); + + Restrictions on these macros: + + These macros do not check for all possible numerical problems or + undefined or unspecified behavior: they do not check for division + by zero, for bad shift counts, or for shifting negative numbers. + + These macros may evaluate their arguments zero or multiple times, so the + arguments should not have side effects. + + The WRAPV macros are not constant expressions. They support only + +, binary -, and *. Because the WRAPV macros convert the result, + they report overflow in different circumstances than the OVERFLOW + macros do. + + These macros are tuned for their last input argument being a constant. + + Return 1 if the integer expressions A * B, A - B, -A, A * B, A / B, + A % B, and A << B would overflow, respectively. */ + +#define INT_ADD_OVERFLOW(a, b) \ + VIR_BINARY_OP_OVERFLOW (a, b, VIR_ADD_OVERFLOW) +#define INT_SUBTRACT_OVERFLOW(a, b) \ + VIR_BINARY_OP_OVERFLOW (a, b, VIR_SUBTRACT_OVERFLOW) +#if VIR_HAS_BUILTIN_OVERFLOW_P +# define INT_NEGATE_OVERFLOW(a) INT_SUBTRACT_OVERFLOW (0, a) +#else +# define INT_NEGATE_OVERFLOW(a) \ + INT_NEGATE_RANGE_OVERFLOW (a, VIR_INT_MINIMUM (a), VIR_INT_MAXIMUM (a)) +#endif +#define INT_MULTIPLY_OVERFLOW(a, b) \ + VIR_BINARY_OP_OVERFLOW (a, b, VIR_MULTIPLY_OVERFLOW) +#define INT_DIVIDE_OVERFLOW(a, b) \ + VIR_BINARY_OP_OVERFLOW (a, b, VIR_DIVIDE_OVERFLOW) +#define INT_REMAINDER_OVERFLOW(a, b) \ + VIR_BINARY_OP_OVERFLOW (a, b, VIR_REMAINDER_OVERFLOW) +#define INT_LEFT_SHIFT_OVERFLOW(a, b) \ + INT_LEFT_SHIFT_RANGE_OVERFLOW (a, b, \ + VIR_INT_MINIMUM (a), VIR_INT_MAXIMUM (a)) + +/* Return 1 if the expression A <op> B would overflow, + where OP_RESULT_OVERFLOW (A, B, MIN, MAX) does the actual test, + assuming MIN and MAX are the minimum and maximum for the result type. + Arguments should be free of side effects. */ +#define VIR_BINARY_OP_OVERFLOW(a, b, op_result_overflow) \ + op_result_overflow (a, b, \ + VIR_INT_MINIMUM (VIR_INT_CONVERT (a, b)), \ + VIR_INT_MAXIMUM (VIR_INT_CONVERT (a, b))) + +/* Store the low-order bits of A + B, A - B, A * B, respectively, into *R. + Return 1 if the result overflows. See above for restrictions. */ +#define INT_ADD_WRAPV(a, b, r) \ + VIR_INT_OP_WRAPV (a, b, r, +, __builtin_add_overflow, \ + VIR_INT_ADD_RANGE_OVERFLOW) +#define INT_SUBTRACT_WRAPV(a, b, r) \ + VIR_INT_OP_WRAPV (a, b, r, -, __builtin_sub_overflow, \ + VIR_INT_SUBTRACT_RANGE_OVERFLOW) +#define INT_MULTIPLY_WRAPV(a, b, r) \ + VIR_INT_OP_WRAPV (a, b, r, *, VIR_BUILTIN_MUL_OVERFLOW, \ + VIR_INT_MULTIPLY_RANGE_OVERFLOW) + +/* Like __builtin_mul_overflow, but work around GCC bug 91450. */ +#define VIR_BUILTIN_MUL_OVERFLOW(a, b, r) \ + ((!VIR_SIGNED_TYPE_OR_EXPR (*(r)) && EXPR_SIGNED (a) && EXPR_SIGNED (b) \ + && VIR_INT_MULTIPLY_RANGE_OVERFLOW (a, b, 0, (__typeof__ (*(r))) -1)) \ + ? ((void) __builtin_mul_overflow (a, b, r), 1) \ + : __builtin_mul_overflow (a, b, r)) + +/* Nonzero if this compiler has GCC bug 68193 or Clang bug 25390. See: + https://gcc.gnu.org/bugzilla/show_bug.cgi?id=68193 + https://llvm.org/bugs/show_bug.cgi?id=25390 + For now, assume all versions of GCC-like compilers generate bogus + warnings for _Generic. This matters only for older compilers that + lack __builtin_add_overflow. */ +#if __GNUC__ +# define VIR__GENERIC_BOGUS 1 +#else +# define VIR__GENERIC_BOGUS 0 +#endif + +/* Store the low-order bits of A <op> B into *R, where OP specifies + the operation. BUILTIN is the builtin operation, and OVERFLOW the + overflow predicate. Return 1 if the result overflows. See above + for restrictions. */ +#if VIR_HAS_BUILTIN_OVERFLOW +# define VIR_INT_OP_WRAPV(a, b, r, op, builtin, overflow) builtin (a, b, r) +#elif 201112 <= __STDC_VERSION__ && !VIR__GENERIC_BOGUS +# define VIR_INT_OP_WRAPV(a, b, r, op, builtin, overflow) \ + (_Generic \ + (*(r), \ + signed char: \ + VIR_INT_OP_CALC (a, b, r, op, overflow, unsigned int, \ + signed char, SCHAR_MIN, SCHAR_MAX), \ + unsigned char: \ + VIR_INT_OP_CALC (a, b, r, op, overflow, unsigned int, \ + unsigned char, 0, UCHAR_MAX), \ + short int: \ + VIR_INT_OP_CALC (a, b, r, op, overflow, unsigned int, \ + short int, SHRT_MIN, SHRT_MAX), \ + unsigned short int: \ + VIR_INT_OP_CALC (a, b, r, op, overflow, unsigned int, \ + unsigned short int, 0, USHRT_MAX), \ + int: \ + VIR_INT_OP_CALC (a, b, r, op, overflow, unsigned int, \ + int, INT_MIN, INT_MAX), \ + unsigned int: \ + VIR_INT_OP_CALC (a, b, r, op, overflow, unsigned int, \ + unsigned int, 0, UINT_MAX), \ + long int: \ + VIR_INT_OP_CALC (a, b, r, op, overflow, unsigned long int, \ + long int, LONG_MIN, LONG_MAX), \ + unsigned long int: \ + VIR_INT_OP_CALC (a, b, r, op, overflow, unsigned long int, \ + unsigned long int, 0, ULONG_MAX), \ + long long int: \ + VIR_INT_OP_CALC (a, b, r, op, overflow, unsigned long long int, \ + long long int, LLONG_MIN, LLONG_MAX), \ + unsigned long long int: \ + VIR_INT_OP_CALC (a, b, r, op, overflow, unsigned long long int, \ + unsigned long long int, 0, ULLONG_MAX))) +#else +/* Store the low-order bits of A <op> B into *R, where OP specifies + the operation and OVERFLOW the overflow predicate. If *R is + signed, its type is ST with bounds SMIN..SMAX; otherwise its type + is UT with bounds U..UMAX. ST and UT are narrower than int. + Return 1 if the result overflows. See above for restrictions. */ +# define VIR_INT_OP_WRAPV_SMALLISH(a,b,r,op,overflow,st,smin,smax,ut,umax) \ + (TYPE_SIGNED (__typeof__ (*(r))) \ + ? VIR_INT_OP_CALC (a, b, r, op, overflow, unsigned int, st, smin, smax) \ + : VIR_INT_OP_CALC (a, b, r, op, overflow, unsigned int, ut, 0, umax)) + +# define VIR_INT_OP_WRAPV(a, b, r, op, builtin, overflow) \ + (sizeof(*(r)) == sizeof(signed char) \ + ? VIR_INT_OP_WRAPV_SMALLISH(a, b, r, op, overflow, \ + signed char, SCHAR_MIN, SCHAR_MAX, \ + unsigned char, UCHAR_MAX) \ + : sizeof(*(r)) == sizeof(short int) \ + ? VIR_INT_OP_WRAPV_SMALLISH(a, b, r, op, overflow, \ + short int, SHRT_MIN, SHRT_MAX, \ + unsigned short int, USHRT_MAX) \ + : sizeof(*(r)) == sizeof(int) \ + ? (EXPR_SIGNED(*(r)) \ + ? VIR_INT_OP_CALC(a, b, r, op, overflow, unsigned int, \ + int, INT_MIN, INT_MAX) \ + : VIR_INT_OP_CALC(a, b, r, op, overflow, unsigned int, \ + unsigned int, 0, UINT_MAX)) \ + : VIR_INT_OP_WRAPV_LONGISH(a, b, r, op, overflow)) +# define VIR_INT_OP_WRAPV_LONGISH(a, b, r, op, overflow) \ + (sizeof(*(r)) == sizeof(long int) \ + ? (EXPR_SIGNED (*(r)) \ + ? VIR_INT_OP_CALC (a, b, r, op, overflow, unsigned long int, \ + long int, LONG_MIN, LONG_MAX) \ + : VIR_INT_OP_CALC (a, b, r, op, overflow, unsigned long int, \ + unsigned long int, 0, ULONG_MAX)) \ + : (EXPR_SIGNED (*(r)) \ + ? VIR_INT_OP_CALC (a, b, r, op, overflow, unsigned long long int, \ + long long int, LLONG_MIN, LLONG_MAX) \ + : VIR_INT_OP_CALC (a, b, r, op, overflow, unsigned long long int, \ + unsigned long long int, 0, ULLONG_MAX))) +#endif + +/* Store the low-order bits of A <op> B into *R, where the operation + is given by OP. Use the unsigned type UT for calculation to avoid + overflow problems. *R's type is T, with extrema TMIN and TMAX. + T must be a signed integer type. Return 1 if the result overflows. */ +#define VIR_INT_OP_CALC(a, b, r, op, overflow, ut, t, tmin, tmax) \ + (overflow (a, b, tmin, tmax) \ + ? (*(r) = VIR_INT_OP_WRAPV_VIA_UNSIGNED (a, b, op, ut, t), 1) \ + : (*(r) = VIR_INT_OP_WRAPV_VIA_UNSIGNED (a, b, op, ut, t), 0)) + +/* Return the low-order bits of A <op> B, where the operation is given + by OP. Use the unsigned type UT for calculation to avoid undefined + behavior on signed integer overflow, and convert the result to type T. + UT is at least as wide as T and is no narrower than unsigned int, + T is two's complement, and there is no padding or trap representations. + Assume that converting UT to T yields the low-order bits, as is + done in all known two's-complement C compilers. E.g., see: + https://gcc.gnu.org/onlinedocs/gcc/Integers-implementation.html + + According to the C standard, converting UT to T yields an + implementation-defined result or signal for values outside T's + range. However, code that works around this theoretical problem + runs afoul of a compiler bug in Oracle Studio 12.3 x86. See: + https://lists.gnu.org/r/bug-gnulib/2017-04/msg00049.html + As the compiler bug is real, don't try to work around the + theoretical problem. */ + +#define VIR_INT_OP_WRAPV_VIA_UNSIGNED(a, b, op, ut, t) \ + ((t) ((ut) (a) op (ut) (b))) + +/* Return true if the numeric values A + B, A - B, A * B fall outside + the range TMIN..TMAX. Arguments should be integer expressions + without side effects. TMIN should be signed and nonpositive. + TMAX should be positive, and should be signed unless TMIN is zero. */ +#define VIR_INT_ADD_RANGE_OVERFLOW(a, b, tmin, tmax) \ + ((b) < 0 \ + ? (((tmin) \ + ? ((EXPR_SIGNED (VIR_INT_CONVERT (a, (tmin) - (b))) || (b) < (tmin)) \ + && (a) < (tmin) - (b)) \ + : (a) <= -1 - (b)) \ + || ((EXPR_SIGNED (a) ? 0 <= (a) : (tmax) < (a)) && (tmax) < (a) + (b))) \ + : (a) < 0 \ + ? (((tmin) \ + ? ((EXPR_SIGNED (VIR_INT_CONVERT (b, (tmin) - (a))) || (a) < (tmin)) \ + && (b) < (tmin) - (a)) \ + : (b) <= -1 - (a)) \ + || ((EXPR_SIGNED (VIR_INT_CONVERT (a, b)) || (tmax) < (b)) \ + && (tmax) < (a) + (b))) \ + : (tmax) < (b) || (tmax) - (b) < (a)) +#define VIR_INT_SUBTRACT_RANGE_OVERFLOW(a, b, tmin, tmax) \ + (((a) < 0) == ((b) < 0) \ + ? ((a) < (b) \ + ? !(tmin) || -1 - (tmin) < (b) - (a) - 1 \ + : (tmax) < (a) - (b)) \ + : (a) < 0 \ + ? ((!EXPR_SIGNED (VIR_INT_CONVERT ((a) - (tmin), b)) && (a) - (tmin) < 0) \ + || (a) - (tmin) < (b)) \ + : ((! (EXPR_SIGNED (VIR_INT_CONVERT (tmax, b)) \ + && EXPR_SIGNED (VIR_INT_CONVERT ((tmax) + (b), a))) \ + && (tmax) <= -1 - (b)) \ + || (tmax) + (b) < (a))) +#define VIR_INT_MULTIPLY_RANGE_OVERFLOW(a, b, tmin, tmax) \ + ((b) < 0 \ + ? ((a) < 0 \ + ? (EXPR_SIGNED (VIR_INT_CONVERT (tmax, b)) \ + ? (a) < (tmax) / (b) \ + : ((INT_NEGATE_OVERFLOW (b) \ + ? VIR_INT_CONVERT (b, tmax) >> (TYPE_WIDTH (b) - 1) \ + : (tmax) / -(b)) \ + <= -1 - (a))) \ + : INT_NEGATE_OVERFLOW (VIR_INT_CONVERT (b, tmin)) && (b) == -1 \ + ? (EXPR_SIGNED (a) \ + ? 0 < (a) + (tmin) \ + : 0 < (a) && -1 - (tmin) < (a) - 1) \ + : (tmin) / (b) < (a)) \ + : (b) == 0 \ + ? 0 \ + : ((a) < 0 \ + ? (INT_NEGATE_OVERFLOW (VIR_INT_CONVERT (a, tmin)) && (a) == -1 \ + ? (EXPR_SIGNED (b) ? 0 < (b) + (tmin) : -1 - (tmin) < (b) - 1) \ + : (tmin) / (a) < (b)) \ + : (tmax) / (b) < (a))) diff --git a/src/util/virlog.c b/src/util/virlog.c index 8a9fb34161..dc04f57640 100644 --- a/src/util/virlog.c +++ b/src/util/virlog.c @@ -45,7 +45,7 @@ #include "virthread.h" #include "virfile.h" #include "virtime.h" -#include "intprops.h" +#include "virintprops.h" #include "virstring.h" #include "configmake.h" diff --git a/src/util/virnetdevbridge.c b/src/util/virnetdevbridge.c index 3a7a6dc730..e89b81101a 100644 --- a/src/util/virnetdevbridge.c +++ b/src/util/virnetdevbridge.c @@ -25,7 +25,7 @@ #include "virfile.h" #include "viralloc.h" #include "virlog.h" -#include "intprops.h" +#include "virintprops.h" #include "virstring.h" #include <sys/ioctl.h> diff --git a/src/util/virpidfile.c b/src/util/virpidfile.c index b08e0d8d52..83e8da4516 100644 --- a/src/util/virpidfile.c +++ b/src/util/virpidfile.c @@ -31,7 +31,7 @@ #include "virfile.h" #include "viralloc.h" #include "virutil.h" -#include "intprops.h" +#include "virintprops.h" #include "virlog.h" #include "virerror.h" #include "virstring.h" diff --git a/tests/virsystemdtest.c b/tests/virsystemdtest.c index 9b95ca6789..7fa02f2e8c 100644 --- a/tests/virsystemdtest.c +++ b/tests/virsystemdtest.c @@ -33,7 +33,7 @@ # include "virlog.h" # include "virmock.h" # include "rpc/virnetsocket.h" -# include "intprops.h" +# include "virintprops.h" # define VIR_FROM_THIS VIR_FROM_NONE VIR_LOG_INIT("tests.systemdtest"); diff --git a/tools/virsh-domain-monitor.c b/tools/virsh-domain-monitor.c index e357635757..e224b70293 100644 --- a/tools/virsh-domain-monitor.c +++ b/tools/virsh-domain-monitor.c @@ -29,7 +29,7 @@ #include "internal.h" #include "conf/virdomainobjlist.h" -#include "intprops.h" +#include "virintprops.h" #include "viralloc.h" #include "virmacaddr.h" #include "virxml.h" diff --git a/tools/virt-login-shell.c b/tools/virt-login-shell.c index 7d1e0ccc8a..5ad77aaae2 100644 --- a/tools/virt-login-shell.c +++ b/tools/virt-login-shell.c @@ -29,15 +29,14 @@ #include <string.h> /* - * These gnulib files are used for their macros only, + * This GNULIB file is used for its macros only, * so don't introduce a link time dep, which we must avoid */ #include "gnulib/lib/configmake.h" -#include "gnulib/lib/intprops.h" int main(int argc, char **argv) { - char uidstr[INT_BUFSIZE_BOUND(uid_t)]; - char gidstr[INT_BUFSIZE_BOUND(gid_t)]; + char uidstr[100]; + char gidstr[100]; const char * newargv[6]; size_t nargs = 0; char *newenv[] = { -- 2.24.1

Some UNIX platforms don't declare 'environ' in their header files. We can unconditionally declare it ourselves to avoid this problem. There is no need to do this in the aa-helper code since that is Linux only code. Signed-off-by: Daniel P. Berrangé <berrange(a)redhat.com&gt; --- tests/commandhelper.c | 3 +++ tests/commandtest.c | 3 +++ 2 files changed, 6 insertions(+) diff --git a/tests/commandhelper.c b/tests/commandhelper.c index 77cbcd4680..a7a3c44e33 100644 --- a/tests/commandhelper.c +++ b/tests/commandhelper.c @@ -31,6 +31,9 @@ #ifndef WIN32 +/* Some UNIX lack it in headers & it doesn't hurt to redeclare */ +extern char **environ; + # define VIR_FROM_THIS VIR_FROM_NONE static int envsort(const void *a, const void *b) diff --git a/tests/commandtest.c b/tests/commandtest.c index 5df1aa4221..cc8676811e 100644 --- a/tests/commandtest.c +++ b/tests/commandtest.c @@ -58,6 +58,9 @@ main(void) #else +/* Some UNIX lack it in headers & it doesn't hurt to redeclare */ +extern char **environ; + static int checkoutput(const char *testname, char *prefix) { -- 2.24.1

Some syntax check rules validate usage of headers provided by gnulib. We want to validate these only against the gnulib modules we've chosen to use, not all modules, since we're trying to eliminate them. Signed-off-by: Daniel P. Berrangé <berrange(a)redhat.com&gt; --- build-aux/syntax-check.mk | 3 --- 1 file changed, 3 deletions(-) diff --git a/build-aux/syntax-check.mk b/build-aux/syntax-check.mk index 5b85b4d1de..9138ba1fe2 100644 --- a/build-aux/syntax-check.mk +++ b/build-aux/syntax-check.mk @@ -132,9 +132,6 @@ local-check := \ syntax-check: $(local-check) -# We use .gnulib, not gnulib. -gnulib_dir = $(srcdir)/.gnulib - # We haven't converted all scripts to using gnulib's init.sh yet. _test_script_regex = \<\(init\|test-lib\)\.sh\> -- 2.24.1

All UNIX platforms we care about have openpty() in the libutil library. Use of pty.h must also be made conditional, excluding Win32. Signed-off-by: Daniel P. Berrangé <berrange(a)redhat.com&gt; --- configure.ac | 4 ++++ src/util/Makefile.inc.am | 1 + src/util/virfile.c | 14 +++++++++++++- 3 files changed, 18 insertions(+), 1 deletion(-) diff --git a/configure.ac b/configure.ac index 002a3dcdb0..3e5032a8c4 100644 --- a/configure.ac +++ b/configure.ac @@ -383,10 +383,13 @@ dnl Availability of various common headers (non-fatal if missing). AC_CHECK_HEADERS([\ ifaddrs.h \ libtasn1.h \ + util.h \ + libutil.h \ linux/magic.h \ mntent.h \ net/ethernet.h \ netinet/tcp.h \ + pty.h \ pwd.h \ stdarg.h \ syslog.h \ @@ -430,6 +433,7 @@ dnl header could be found. AM_CONDITIONAL([HAVE_LIBTASN1], [test "x$ac_cv_header_libtasn1_h" = "xyes"]) AC_CHECK_LIB([intl],[gettext],[]) +AC_CHECK_LIB([util],[openpty],[]) dnl diff --git a/src/util/Makefile.inc.am b/src/util/Makefile.inc.am index 03054e8862..c65fcb5f9b 100644 --- a/src/util/Makefile.inc.am +++ b/src/util/Makefile.inc.am @@ -283,6 +283,7 @@ libvirt_util_la_CFLAGS = \ $(NULL) libvirt_util_la_LIBADD = \ -lm \ + $(OPENPTY_LIBS) \ $(CAPNG_LIBS) \ $(YAJL_LIBS) \ $(LIBNL_LIBS) \ diff --git a/src/util/virfile.c b/src/util/virfile.c index a6d2d4a8e3..14bfd3beb6 100644 --- a/src/util/virfile.c +++ b/src/util/virfile.c @@ -27,7 +27,19 @@ #include <passfd.h> #include <fcntl.h> -#include <pty.h> +#include <termios.h> +#ifdef HAVE_PTY_H +/* Linux openpty */ +# include <pty.h> +#endif /* !HAVE_PTY_H */ +#ifdef HAVE_UTIL_H +/* macOS openpty */ +# include <util.h> +#endif /* !HAVE_LIBUTIL_H */ +#ifdef HAVE_LIBUTIL_H +/* FreeBSD openpty */ +# include <libutil.h> +#endif /* !HAVE_LIBUTIL_H */ #include <sys/stat.h> #include <sys/types.h> #include <sys/socket.h> -- 2.24.1

Windows sockets take a SOCKET HANDLE object instead of a file descriptor. Wrap them in the same way that gnulib does so that they use C runtime file descriptors. While we could in theory use GSocket, it is hard to get the exact same semantics libvirt has for its current socket usage. Wrapping the Winsock2 APIs is thus the easiest approach in the short term. Signed-off-by: Daniel P. Berrangé <berrange(a)redhat.com&gt; --- src/util/Makefile.inc.am | 2 + src/util/virsocket.c | 346 +++++++++++++++++++++++++++++++++++++++ src/util/virsocket.h | 89 ++++++++++ 3 files changed, 437 insertions(+) create mode 100644 src/util/virsocket.c create mode 100644 src/util/virsocket.h diff --git a/src/util/Makefile.inc.am b/src/util/Makefile.inc.am index c65fcb5f9b..ef9b55a047 100644 --- a/src/util/Makefile.inc.am +++ b/src/util/Makefile.inc.am @@ -189,6 +189,8 @@ UTIL_SOURCES = \ util/virseclabel.h \ util/virsecret.c \ util/virsecret.h \ + util/virsocket.c \ + util/virsocket.h \ util/virsocketaddr.c \ util/virsocketaddr.h \ util/virstorageencryption.c \ diff --git a/src/util/virsocket.c b/src/util/virsocket.c new file mode 100644 index 0000000000..367b707c59 --- /dev/null +++ b/src/util/virsocket.c @@ -0,0 +1,346 @@ +/* + * Copyright (C) 2020 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, see + * <http://www.gnu.org/licenses/>;. + */ + +#include <config.h> + +#include "virsocket.h" + +#ifdef WIN32 + +# include <fcntl.h> + +# define FD2SK(fd) _get_osfhandle(fd) +# define SK2FD(sk) (_open_osfhandle((intptr_t) (sk), O_RDWR | O_BINARY)) + +# define GET_HANDLE(fd) \ + +# define RETURN_ERROR(call) \ + if ((call) < 0) { \ + set_errno(); \ + return -1; \ + } + +# undef accept +# undef bind +# undef closesocket +# undef connect +# undef dup +# undef dup2 +# undef getpeername +# undef getsockname +# undef getsockopt +# undef ioctlsocket +# undef listen +# undef setsockopt +# undef socket + +static void +set_errno(void) +{ + int err = WSAGetLastError(); + + /* Map some WSAE* errors to the runtime library's error codes. */ + switch (err) { + case WSA_INVALID_HANDLE: + errno = EBADF; + break; + case WSA_NOT_ENOUGH_MEMORY: + errno = ENOMEM; + break; + case WSA_INVALID_PARAMETER: + errno = EINVAL; + break; + case WSAENAMETOOLONG: + errno = ENAMETOOLONG; + break; + case WSAENOTEMPTY: + errno = ENOTEMPTY; + break; + case WSAEWOULDBLOCK: + errno = EWOULDBLOCK; + break; + case WSAEINPROGRESS: + errno = EINPROGRESS; + break; + case WSAEALREADY: + errno = EALREADY; + break; + case WSAENOTSOCK: + errno = ENOTSOCK; + break; + case WSAEDESTADDRREQ: + errno = EDESTADDRREQ; + break; + case WSAEMSGSIZE: + errno = EMSGSIZE; + break; + case WSAEPROTOTYPE: + errno = EPROTOTYPE; + break; + case WSAENOPROTOOPT: + errno = ENOPROTOOPT; + break; + case WSAEPROTONOSUPPORT: + errno = EPROTONOSUPPORT; + break; + case WSAEOPNOTSUPP: + errno = EOPNOTSUPP; + break; + case WSAEAFNOSUPPORT: + errno = EAFNOSUPPORT; + break; + case WSAEADDRINUSE: + errno = EADDRINUSE; + break; + case WSAEADDRNOTAVAIL: + errno = EADDRNOTAVAIL; + break; + case WSAENETDOWN: + errno = ENETDOWN; + break; + case WSAENETUNREACH: + errno = ENETUNREACH; + break; + case WSAENETRESET: + errno = ENETRESET; + break; + case WSAECONNABORTED: + errno = ECONNABORTED; + break; + case WSAECONNRESET: + errno = ECONNRESET; + break; + case WSAENOBUFS: + errno = ENOBUFS; + break; + case WSAEISCONN: + errno = EISCONN; + break; + case WSAENOTCONN: + errno = ENOTCONN; + break; + case WSAETIMEDOUT: + errno = ETIMEDOUT; + break; + case WSAECONNREFUSED: + errno = ECONNREFUSED; + break; + case WSAELOOP: + errno = ELOOP; + break; + case WSAEHOSTUNREACH: + errno = EHOSTUNREACH; + break; + default: + errno = (err > 10000 && err < 10025) ? err - 10000 : err; + break; + } +} + + +int +vir_accept(int fd, struct sockaddr *addr, socklen_t *addrlen) +{ + SOCKET sk = FD2SK(fd); + SOCKET csk; + + if (sk == INVALID_SOCKET) { + errno = EBADF; + return -1; + } + + csk = accept(sk, addr, addrlen); + + if (csk == INVALID_SOCKET) { + set_errno(); + return -1; + } + + return SK2FD(csk); +} + + +int +vir_bind(int fd, const struct sockaddr *addr, socklen_t addrlen) +{ + SOCKET sk = FD2SK(fd); + + if (sk == INVALID_SOCKET) { + errno = EBADF; + return -1; + } + + if (bind(sk, addr, addrlen) < 0) { + set_errno(); + return -1; + } + + return 0; +} + + +int +vir_closesocket(int fd) +{ + SOCKET sk = FD2SK(fd); + + if (sk == INVALID_SOCKET) { + errno = EBADF; + return -1; + } + + if (closesocket(sk) < 0) { + set_errno(); + return -1; + } + + return 0; +} + + +int +vir_connect(int fd, const struct sockaddr *addr, socklen_t addrlen) +{ + SOCKET sk = FD2SK(fd); + + if (sk == INVALID_SOCKET) { + errno = EBADF; + return -1; + } + + if (connect(sk, addr, addrlen) < 0) { + set_errno(); + return -1; + } + + return 0; +} + + +int +vir_getpeername(int fd, struct sockaddr *addr, socklen_t *addrlen) +{ + SOCKET sk = FD2SK(fd); + + if (sk == INVALID_SOCKET) { + errno = EBADF; + return -1; + } + + if (getpeername(sk, addr, addrlen) < 0) { + set_errno(); + return -1; + } + + return 0; +} + + +int +vir_getsockname(int fd, struct sockaddr *addr, socklen_t *addrlen) +{ + SOCKET sk = FD2SK(fd); + + if (sk == INVALID_SOCKET) { + errno = EBADF; + return -1; + } + + if (getsockname(sk, addr, addrlen) < 0) { + set_errno(); + return -1; + } + + return 0; +} + + +int +vir_listen(int fd, int backlog) +{ + SOCKET sk = FD2SK(fd); + + if (sk == INVALID_SOCKET) { + errno = EBADF; + return -1; + } + + if (listen(sk, backlog) < 0) { + set_errno(); + return -1; + } + + return 0; +} + + +int +vir_getsockopt(int fd, int level, int optname, + void *optval, socklen_t *optlen) +{ + SOCKET sk = FD2SK(fd); + + if (sk == INVALID_SOCKET) { + errno = EBADF; + return -1; + } + + if (getsockopt(sk, level, optname, optval, optlen) < 0) { + set_errno(); + return -1; + } + + return 0; +} + + +int +vir_setsockopt(int fd, int level, int optname, + const void *optval, socklen_t optlen) +{ + SOCKET sk = FD2SK(fd); + + if (sk == INVALID_SOCKET) { + errno = EBADF; + return -1; + } + + if (setsockopt(sk, level, optname, optval, optlen) < 0) { + set_errno(); + return -1; + } + + return 0; +} + + +int +vir_socket(int domain, int type, int protocol) +{ + SOCKET sk; + + sk = socket(domain, type, protocol); + if (sk == INVALID_SOCKET) { + set_errno(); + return -1; + } + + return SK2FD(sk); +} + +#endif /* WIN32 */ diff --git a/src/util/virsocket.h b/src/util/virsocket.h new file mode 100644 index 0000000000..4ed38dbd5f --- /dev/null +++ b/src/util/virsocket.h @@ -0,0 +1,89 @@ +/* + * Copyright (C) 2020 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, see + * <http://www.gnu.org/licenses/>;. + */ + +#pragma once + +#include "internal.h" + +#ifdef WIN32 + +# define WIN32_LEAN_AND_MEAN +# include <errno.h> +# include <winsock2.h> +# include <ws2tcpip.h> +# include <io.h> + +int vir_accept(int fd, struct sockaddr *addr, socklen_t *addrlen); +int vir_bind(int fd, const struct sockaddr *addr, socklen_t addrlen); +int vir_closesocket(int fd); +int vir_connect(int fd, const struct sockaddr *addr, socklen_t addrlen); +int vir_dup(int oldfd); +int vir_dup2(int oldfd, int newfd); +int vir_getpeername(int fd, struct sockaddr *addr, socklen_t *addrlen); +int vir_getsockname(int fd, struct sockaddr *addr, socklen_t *addrlen); +int vir_listen(int fd, int backlog); +int vir_getsockopt(int fd, int level, int optname, + void *optval, socklen_t *optlen); +int vir_setsockopt(int fd, int level, int optname, + const void *optval, socklen_t optlen); +int vir_socket(int domain, int type, int protocol); + + +/* Get rid of GNULIB's replacements */ +# undef accept +# undef bind +# undef closesocket +# undef connect +# undef dup +# undef dup2 +# undef getpeername +# undef getsockname +# undef getsockopt +# undef ioctlsocket +# undef listen +# undef setsockopt +# undef socket + +/* Provide our own replacements */ +# define accept vir_accept +# define bind vir_bind +# define closesocket vir_closesocket +# define connect vir_connect +# define dup _dup +# define dup2 _dup2 +# define getpeername vir_getpeername +# define getsockname vir_getsockname +# define getsockopt vir_getsockopt +# define listen vir_listen +# define setsockopt vir_setsockopt +# define socket vir_socket + +#else + +# include <sys/socket.h> +# include <unistd.h> +# include <sys/ioctl.h> +# include <arpa/inet.h> +# include <netinet/in.h> +# include <netinet/udp.h> +# include <netinet/tcp.h> +# include <sys/un.h> + +# define closesocket close + +#endif -- 2.24.1

Convert to use socket wrappers. Aside from the header file include change, this requires changing close -> closesocket since our portability isn't trying to replace the close function. Signed-off-by: Daniel P. Berrangé <berrange(a)redhat.com&gt; --- src/rpc/virnetsocket.c | 34 +++++++++++++++++++++++----------- src/util/virportallocator.c | 8 +++----- 2 files changed, 26 insertions(+), 16 deletions(-) diff --git a/src/rpc/virnetsocket.c b/src/rpc/virnetsocket.c index 9ad7c2cc28..973827ebde 100644 --- a/src/rpc/virnetsocket.c +++ b/src/rpc/virnetsocket.c @@ -44,6 +44,7 @@ # include <selinux/selinux.h> #endif +#include "virsocket.h" #include "virnetsocket.h" #include "virutil.h" #include "viralloc.h" @@ -403,7 +404,8 @@ int virNetSocketNewListenTCP(const char *nodename, goto error; } bindErrno = errno; - VIR_FORCE_CLOSE(fd); + closesocket(fd); + fd = -1; runp = runp->ai_next; continue; } @@ -454,7 +456,8 @@ int virNetSocketNewListenTCP(const char *nodename, virObjectUnref(socks[i]); VIR_FREE(socks); freeaddrinfo(ai); - VIR_FORCE_CLOSE(fd); + if (fd != -1) + closesocket(fd); return -1; } @@ -521,7 +524,8 @@ int virNetSocketNewListenUNIX(const char *path, error: if (path[0] != '@') unlink(path); - VIR_FORCE_CLOSE(fd); + if (fd != -1) + closesocket(fd); return -1; } #else @@ -605,7 +609,8 @@ int virNetSocketNewConnectTCP(const char *nodename, break; savedErrno = errno; - VIR_FORCE_CLOSE(fd); + closesocket(fd); + fd = -1; runp = runp->ai_next; } @@ -637,7 +642,8 @@ int virNetSocketNewConnectTCP(const char *nodename, error: freeaddrinfo(ai); - VIR_FORCE_CLOSE(fd); + if (fd != -1) + closesocket(fd); return -1; } @@ -758,8 +764,8 @@ int virNetSocketNewConnectUNIX(const char *path, VIR_FREE(lockpath); VIR_FREE(rundir); - if (ret < 0) - VIR_FORCE_CLOSE(fd); + if (ret < 0 && fd != -1) + closesocket(fd); return ret; } @@ -1370,8 +1376,10 @@ void virNetSocketDispose(void *obj) virObjectUnref(sock->libsshSession); #endif - if (sock->ownsFd) - VIR_FORCE_CLOSE(sock->fd); + if (sock->ownsFd && sock->fd != -1) { + closesocket(sock->fd); + sock->fd = -1; + } VIR_FORCE_CLOSE(sock->errfd); virProcessAbort(sock->pid); @@ -2144,7 +2152,8 @@ int virNetSocketAccept(virNetSocketPtr sock, virNetSocketPtr *clientsock) ret = 0; cleanup: - VIR_FORCE_CLOSE(fd); + if (fd != -1) + closesocket(fd); virObjectUnlock(sock); return ret; } @@ -2264,7 +2273,10 @@ void virNetSocketClose(virNetSocketPtr sock) virObjectLock(sock); - VIR_FORCE_CLOSE(sock->fd); + if (sock->fd != -1) { + closesocket(sock->fd); + sock->fd = -1; + } #ifdef HAVE_SYS_UN_H /* If a server socket, then unlink UNIX path */ diff --git a/src/util/virportallocator.c b/src/util/virportallocator.c index 494bf9107a..285b8ddc45 100644 --- a/src/util/virportallocator.c +++ b/src/util/virportallocator.c @@ -21,10 +21,7 @@ #include <config.h> -#include <sys/socket.h> -#include <arpa/inet.h> -#include <netinet/in.h> - +#include "virsocket.h" #include "viralloc.h" #include "virbitmap.h" #include "virportallocator.h" @@ -192,7 +189,8 @@ virPortAllocatorBindToPort(bool *used, ret = 0; cleanup: - VIR_FORCE_CLOSE(fd); + if (fd != -1) + closesocket(fd); return ret; } -- 2.24.1

We don't need all the platforms gnulib deals with, so this is a cut down version of GNULIB's physmem.c code. This also allows us to integrate libvirt's error reporting functions closer to the error cause. Signed-off-by: Daniel P. Berrangé <berrange(a)redhat.com&gt; --- build-aux/syntax-check.mk | 2 +- src/conf/capabilities.c | 1 - src/util/virhostcpu.c | 1 - src/util/virhostmem.c | 182 +++++++++++++++++++++++++++++++------- 4 files changed, 153 insertions(+), 33 deletions(-) diff --git a/build-aux/syntax-check.mk b/build-aux/syntax-check.mk index 9138ba1fe2..2bbadd426c 100644 --- a/build-aux/syntax-check.mk +++ b/build-aux/syntax-check.mk @@ -2335,7 +2335,7 @@ exclude_file_name_regexp--sc_prohibit_virXXXFree = \ ^(docs/|tests/|examples/|tools/|build-aux/syntax-check\.mk|src/test/test_driver.c|src/libvirt_public.syms|include/libvirt/libvirt-(domain|network|nodedev|storage|stream|secret|nwfilter|interface|domain-snapshot).h|src/libvirt-(domain|qemu|network|nodedev|storage|stream|secret|nwfilter|interface|domain-snapshot).c$$) exclude_file_name_regexp--sc_prohibit_sysconf_pagesize = \ - ^(build-aux/syntax-check\.mk|src/util/virutil\.c)$$ + ^(build-aux/syntax-check\.mk|src/util/vir(hostmem|util)\.c)$$ exclude_file_name_regexp--sc_prohibit_pthread_create = \ ^(build-aux/syntax-check\.mk|src/util/virthread\.c|tests/.*)$$ diff --git a/src/conf/capabilities.c b/src/conf/capabilities.c index 9a39858280..ade04b7cd6 100644 --- a/src/conf/capabilities.c +++ b/src/conf/capabilities.c @@ -26,7 +26,6 @@ #include "capabilities.h" #include "cpu_conf.h" #include "domain_conf.h" -#include "physmem.h" #include "storage_conf.h" #include "viralloc.h" #include "virarch.h" diff --git a/src/util/virhostcpu.c b/src/util/virhostcpu.c index c948278c9a..277b8efa62 100644 --- a/src/util/virhostcpu.c +++ b/src/util/virhostcpu.c @@ -41,7 +41,6 @@ #include "viralloc.h" #define LIBVIRT_VIRHOSTCPUPRIV_H_ALLOW #include "virhostcpupriv.h" -#include "physmem.h" #include "virerror.h" #include "virintprops.h" #include "virarch.h" diff --git a/src/util/virhostmem.c b/src/util/virhostmem.c index 34e6f7adcf..9c08b9bd78 100644 --- a/src/util/virhostmem.c +++ b/src/util/virhostmem.c @@ -33,9 +33,13 @@ # include <sys/resource.h> #endif +#ifdef WIN32 +# define WIN32_LEAN_AND_MEAN +# include <windows.h> +#endif + #include "viralloc.h" #include "virhostmem.h" -#include "physmem.h" #include "virerror.h" #include "virarch.h" #include "virfile.h" @@ -577,13 +581,151 @@ virHostMemGetParameters(virTypedParameterPtr params G_GNUC_UNUSED, } +#ifdef WIN32 +/* MEMORYSTATUSEX is missing from older windows headers, so define + a local replacement. */ +typedef struct +{ + DWORD dwLength; + DWORD dwMemoryLoad; + DWORDLONG ullTotalPhys; + DWORDLONG ullAvailPhys; + DWORDLONG ullTotalPageFile; + DWORDLONG ullAvailPageFile; + DWORDLONG ullTotalVirtual; + DWORDLONG ullAvailVirtual; + DWORDLONG ullAvailExtendedVirtual; +} lMEMORYSTATUSEX; +typedef WINBOOL(WINAPI *PFN_MS_EX) (lMEMORYSTATUSEX*); +#endif /* !WIN32 */ + +static unsigned long long +virHostMemGetTotal(void) +{ +#if defined HAVE_SYSCTLBYNAME + /* This works on freebsd & macOS. */ + unsigned long long physmem = 0; + size_t len = sizeof(physmem); + + if (sysctlbyname("hw.physmem", &physmem, &len, NULL, 0) < 0) { + virReportSystemError(errno, "%s", + _("Unable to query memory total")); + return 0; + } + + return physmem; +#elif defined _SC_PHYS_PAGES && defined _SC_PAGESIZE + /* this works on linux */ + long long pages; + long long pagesize; + if ((pages = sysconf(_SC_PHYS_PAGES)) < 0) { + virReportSystemError(errno, "%s", + _("Unable to query memory total")); + return 0; + } + if ((pagesize = sysconf(_SC_PAGESIZE)) < 0) { + virReportSystemError(errno, "%s", + _("Unable to query memory page size")); + return 0; + } + return (unsigned long long)pages * (unsigned long long)pagesize; +#elif defined WIN32 + PFN_MS_EX pfnex; + HMODULE h = GetModuleHandle("kernel32.dll"); + + if (!h) { + virReportSystemError(errno, "%s", + _("Unable to access kernel32.dll")); + return 0; + } + + /* Use GlobalMemoryStatusEx if available. */ + if ((pfnex = (PFN_MS_EX) GetProcAddress(h, "GlobalMemoryStatusEx"))) { + lMEMORYSTATUSEX lms_ex; + lms_ex.dwLength = sizeof(lms_ex); + if (!pfnex(&lms_ex)) { + virReportSystemError(EIO, "%s", + _("Unable to query memory total")); + return 0; + } + return lms_ex.ullTotalPhys; + } else { + /* Fall back to GlobalMemoryStatus which is always available. + but returns wrong results for physical memory > 4GB. */ + MEMORYSTATUS ms; + GlobalMemoryStatus(&ms); + return ms.dwTotalPhys; + } +#endif +} + + +static unsigned long long +virHostMemGetAvailable(void) +{ +#if defined HAVE_SYSCTLBYNAME + /* This works on freebsd and macOS */ + unsigned long long usermem = 0; + size_t len = sizeof(usermem); + + if (sysctlbyname("hw.usermem", &usermem, &len, NULL, 0) < 0) { + virReportSystemError(errno, "%s", + _("Unable to query memory available")); + return 0; + } + + return usermem; +#elif defined _SC_AVPHYS_PAGES && defined _SC_PAGESIZE + /* this works on linux */ + long long pages; + long long pagesize; + if ((pages = sysconf(_SC_AVPHYS_PAGES)) < 0) { + virReportSystemError(errno, "%s", + _("Unable to query memory available")); + return 0; + } + if ((pagesize = sysconf(_SC_PAGESIZE)) < 0) { + virReportSystemError(errno, "%s", + _("Unable to query memory page size")); + return 0; + } + return (unsigned long long)pages * (unsigned long long)pagesize; +#elif defined WIN32 + PFN_MS_EX pfnex; + HMODULE h = GetModuleHandle("kernel32.dll"); + + if (!h) { + virReportSystemError(errno, "%s", + _("Unable to access kernel32.dll")); + return 0; + } + + /* Use GlobalMemoryStatusEx if available. */ + if ((pfnex = (PFN_MS_EX) GetProcAddress(h, "GlobalMemoryStatusEx"))) { + lMEMORYSTATUSEX lms_ex; + lms_ex.dwLength = sizeof(lms_ex); + if (!pfnex(&lms_ex)) { + virReportSystemError(EIO, "%s", + _("Unable to query memory available")); + return 0; + } + return lms_ex.ullAvailPhys; + } else { + /* Fall back to GlobalMemoryStatus which is always available. + but returns wrong results for physical memory > 4GB */ + MEMORYSTATUS ms; + GlobalMemoryStatus(&ms); + return ms.dwAvailPhys; + } +#endif +} + + static int virHostMemGetCellsFreeFake(unsigned long long *freeMems, int startCell, int maxCells G_GNUC_UNUSED) { - double avail = physmem_available(); - if (startCell != 0) { virReportError(VIR_ERR_INTERNAL_ERROR, _("start cell %d out of range (0-%d)"), @@ -591,13 +733,8 @@ virHostMemGetCellsFreeFake(unsigned long long *freeMems, return -1; } - freeMems[0] = (unsigned long long)avail; - - if (!freeMems[0]) { - virReportError(VIR_ERR_INTERNAL_ERROR, "%s", - _("Cannot determine free memory")); + if ((freeMems[0] = virHostMemGetAvailable()) == 0) return -1; - } return 1; } @@ -606,28 +743,13 @@ static int virHostMemGetInfoFake(unsigned long long *mem, unsigned long long *freeMem) { - if (mem) { - double total = physmem_total(); - if (!total) { - virReportError(VIR_ERR_INTERNAL_ERROR, "%s", - _("Cannot determine free memory")); - return -1; - } - - *mem = (unsigned long long) total; - } - - if (freeMem) { - double avail = physmem_available(); - - if (!avail) { - virReportError(VIR_ERR_INTERNAL_ERROR, "%s", - _("Cannot determine free memory")); - return -1; - } + if (mem && + (*mem = virHostMemGetTotal()) == 0) + return -1; - *freeMem = (unsigned long long) avail; - } + if (freeMem && + (*freeMem = virHostMemGetAvailable()) == 0) + return -1; return 0; } -- 2.24.1

Libvirt's original atomic ops impls were largely copied from GLib's code at the time. The only API difference was that libvirt's virAtomicIntInc() would return a value, but g_atomic_int_inc was void. We thus use g_atomic_int_add(v, 1) instead, though this means virAtomicIntInc() now returns the original value, instead of the new value. This rewrites libvirt's impl in terms of g_atomic_int* as a short term conversion. The key motivation was to quickly eliminate use of GNULIB's verify_expr() macro which is not a direct match for G_STATIC_ASSERT_EXPR. Long term all the callers should be updated to use g_atomic_int* directly. Signed-off-by: Daniel P. Berrangé <berrange(a)redhat.com&gt; --- src/libxl/libxl_domain.c | 2 +- src/libxl/libxl_driver.c | 2 +- src/lxc/lxc_process.c | 4 +- src/nwfilter/nwfilter_dhcpsnoop.c | 6 +- src/qemu/qemu_process.c | 4 +- src/util/viratomic.h | 351 ++---------------------------- src/util/virprocess.c | 2 +- tests/viratomictest.c | 2 +- 8 files changed, 26 insertions(+), 347 deletions(-) diff --git a/src/libxl/libxl_domain.c b/src/libxl/libxl_domain.c index 915aaeb8b0..f9be4ad583 100644 --- a/src/libxl/libxl_domain.c +++ b/src/libxl/libxl_domain.c @@ -1473,7 +1473,7 @@ libxlDomainStart(libxlDriverPrivatePtr driver, if (virDomainObjSave(vm, driver->xmlopt, cfg->stateDir) < 0) goto destroy_dom; - if (virAtomicIntInc(&driver->nactive) == 1 && driver->inhibitCallback) + if (virAtomicIntInc(&driver->nactive) == 0 && driver->inhibitCallback) driver->inhibitCallback(true, driver->inhibitOpaque); /* finally we can call the 'started' hook script if any */ diff --git a/src/libxl/libxl_driver.c b/src/libxl/libxl_driver.c index f021ec9c5d..ef02a066d9 100644 --- a/src/libxl/libxl_driver.c +++ b/src/libxl/libxl_driver.c @@ -446,7 +446,7 @@ libxlReconnectDomain(virDomainObjPtr vm, virDomainObjSetState(vm, VIR_DOMAIN_RUNNING, VIR_DOMAIN_RUNNING_UNKNOWN); - if (virAtomicIntInc(&driver->nactive) == 1 && driver->inhibitCallback) + if (virAtomicIntInc(&driver->nactive) == 0 && driver->inhibitCallback) driver->inhibitCallback(true, driver->inhibitOpaque); /* Enable domain death events */ diff --git a/src/lxc/lxc_process.c b/src/lxc/lxc_process.c index 0a9ccdf9ec..af8593d6a5 100644 --- a/src/lxc/lxc_process.c +++ b/src/lxc/lxc_process.c @@ -1468,7 +1468,7 @@ int virLXCProcessStart(virConnectPtr conn, if (virCommandHandshakeNotify(cmd) < 0) goto cleanup; - if (virAtomicIntInc(&driver->nactive) == 1 && driver->inhibitCallback) + if (virAtomicIntInc(&driver->nactive) == 0 && driver->inhibitCallback) driver->inhibitCallback(true, driver->inhibitOpaque); if (lxcContainerWaitForContinue(handshakefds[0]) < 0) { @@ -1670,7 +1670,7 @@ virLXCProcessReconnectDomain(virDomainObjPtr vm, virDomainObjSetState(vm, VIR_DOMAIN_RUNNING, VIR_DOMAIN_RUNNING_UNKNOWN); - if (virAtomicIntInc(&driver->nactive) == 1 && driver->inhibitCallback) + if (virAtomicIntInc(&driver->nactive) == 0 && driver->inhibitCallback) driver->inhibitCallback(true, driver->inhibitOpaque); if (!(priv->monitor = virLXCProcessConnectMonitor(driver, vm))) diff --git a/src/nwfilter/nwfilter_dhcpsnoop.c b/src/nwfilter/nwfilter_dhcpsnoop.c index 9a71d13d57..f3acaf00dd 100644 --- a/src/nwfilter/nwfilter_dhcpsnoop.c +++ b/src/nwfilter/nwfilter_dhcpsnoop.c @@ -888,7 +888,7 @@ virNWFilterSnoopReqLeaseDel(virNWFilterSnoopReqPtr req, skip_instantiate: VIR_FREE(ipl); - virAtomicIntDecAndTest(&virNWFilterSnoopState.nLeases); + ignore_value(virAtomicIntDecAndTest(&virNWFilterSnoopState.nLeases)); lease_not_found: VIR_FREE(ipstr); @@ -1167,7 +1167,7 @@ static void virNWFilterDHCPDecodeWorker(void *jobdata, void *opaque) _("Instantiation of rules failed on " "interface '%s'"), req->binding->portdevname); } - virAtomicIntDecAndTest(job->qCtr); + ignore_value(virAtomicIntDecAndTest(job->qCtr)); VIR_FREE(job); } @@ -1568,7 +1568,7 @@ virNWFilterDHCPSnoopThread(void *req0) pcap_close(pcapConf[i].handle); } - virAtomicIntDecAndTest(&virNWFilterSnoopState.nThreads); + ignore_value(virAtomicIntDecAndTest(&virNWFilterSnoopState.nThreads)); return; } diff --git a/src/qemu/qemu_process.c b/src/qemu/qemu_process.c index 4195042194..1a98f56946 100644 --- a/src/qemu/qemu_process.c +++ b/src/qemu/qemu_process.c @@ -5570,7 +5570,7 @@ qemuProcessInit(virQEMUDriverPtr driver, qemuDomainSetFakeReboot(driver, vm, false); virDomainObjSetState(vm, VIR_DOMAIN_PAUSED, VIR_DOMAIN_PAUSED_STARTING_UP); - if (virAtomicIntInc(&driver->nactive) == 1 && driver->inhibitCallback) + if (virAtomicIntInc(&driver->nactive) == 0 && driver->inhibitCallback) driver->inhibitCallback(true, driver->inhibitOpaque); /* Run an early hook to set-up missing devices */ @@ -8138,7 +8138,7 @@ qemuProcessReconnect(void *opaque) goto error; } - if (virAtomicIntInc(&driver->nactive) == 1 && driver->inhibitCallback) + if (virAtomicIntInc(&driver->nactive) == 0 && driver->inhibitCallback) driver->inhibitCallback(true, driver->inhibitOpaque); cleanup: diff --git a/src/util/viratomic.h b/src/util/viratomic.h index 9dfb77b992..12b116a6cd 100644 --- a/src/util/viratomic.h +++ b/src/util/viratomic.h @@ -1,11 +1,7 @@ /* * viratomic.h: atomic integer operations * - * Copyright (C) 2012 Red Hat, Inc. - * - * Based on code taken from GLib 2.32, under the LGPLv2+ - * - * Copyright (C) 2011 Ryan Lortie + * Copyright (C) 2012-2020 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 @@ -21,18 +17,15 @@ * License along with this library. If not, see * <http://www.gnu.org/licenses/>;. * + * APIs in this header should no longer be used. Direct + * use of the g_atomic APIs is preferred & existing code + * should be converted as needed. */ #pragma once #include "internal.h" -#ifdef VIR_ATOMIC_OPS_GCC -# define VIR_STATIC /* Nothing; we just never define the functions */ -#else -# define VIR_STATIC static -#endif - /** * virAtomicIntGet: * Gets the current value of atomic. @@ -40,8 +33,7 @@ * This call acts as a full compiler and hardware memory barrier * (before the get) */ -VIR_STATIC int virAtomicIntGet(volatile int *atomic) - ATTRIBUTE_NONNULL(1); +#define virAtomicIntGet(v) g_atomic_int_get(v) /** * virAtomicIntSet: @@ -50,21 +42,18 @@ VIR_STATIC int virAtomicIntGet(volatile int *atomic) * This call acts as a full compiler and hardware memory barrier * (after the set) */ -VIR_STATIC void virAtomicIntSet(volatile int *atomic, - int newval) - ATTRIBUTE_NONNULL(1); +#define virAtomicIntSet(i, newv) g_atomic_int_set(i, newv) /** * virAtomicIntInc: * Increments the value of atomic by 1. * * Think of this operation as an atomic version of - * { *atomic += 1; return *atomic; } + * { tmp = *atomic; *atomic += 1; return tmp; } * * This call acts as a full compiler and hardware memory barrier. */ -VIR_STATIC int virAtomicIntInc(volatile int *atomic) - ATTRIBUTE_NONNULL(1); +#define virAtomicIntInc(i) g_atomic_int_add(i, 1) /** * virAtomicIntDecAndTest: @@ -75,8 +64,7 @@ VIR_STATIC int virAtomicIntInc(volatile int *atomic) * * This call acts as a full compiler and hardware memory barrier. */ -VIR_STATIC bool virAtomicIntDecAndTest(volatile int *atomic) - ATTRIBUTE_NONNULL(1); +#define virAtomicIntDecAndTest(i) (!!g_atomic_int_dec_and_test(i)) /** * virAtomicIntCompareExchange: @@ -91,10 +79,8 @@ VIR_STATIC bool virAtomicIntDecAndTest(volatile int *atomic) * * This call acts as a full compiler and hardware memory barrier. */ -VIR_STATIC bool virAtomicIntCompareExchange(volatile int *atomic, - int oldval, - int newval) - ATTRIBUTE_NONNULL(1); +#define virAtomicIntCompareExchange(i, oldi, newi) \ + (!!g_atomic_int_compare_and_exchange(i, oldi, newi)) /** * virAtomicIntAdd: @@ -105,9 +91,7 @@ VIR_STATIC bool virAtomicIntCompareExchange(volatile int *atomic, * * This call acts as a full compiler and hardware memory barrier. */ -VIR_STATIC int virAtomicIntAdd(volatile int *atomic, - int val) - ATTRIBUTE_NONNULL(1); +#define virAtomicIntAdd(i, v) g_atomic_int_add(i, v) /** * virAtomicIntAnd: @@ -119,9 +103,7 @@ VIR_STATIC int virAtomicIntAdd(volatile int *atomic, * Think of this operation as an atomic version of * { tmp = *atomic; *atomic &= val; return tmp; } */ -VIR_STATIC unsigned int virAtomicIntAnd(volatile unsigned int *atomic, - unsigned int val) - ATTRIBUTE_NONNULL(1); +#define virAtomicIntAnd(i, v) g_atomic_int_and(i, v) /** * virAtomicIntOr: @@ -133,9 +115,7 @@ VIR_STATIC unsigned int virAtomicIntAnd(volatile unsigned int *atomic, * * This call acts as a full compiler and hardware memory barrier. */ -VIR_STATIC unsigned int virAtomicIntOr(volatile unsigned int *atomic, - unsigned int val) - ATTRIBUTE_NONNULL(1); +#define virAtomicIntOr(i, v) g_atomic_int_or(i, v) /** * virAtomicIntXor: @@ -147,305 +127,4 @@ VIR_STATIC unsigned int virAtomicIntOr(volatile unsigned int *atomic, * * This call acts as a full compiler and hardware memory barrier. */ -VIR_STATIC unsigned int virAtomicIntXor(volatile unsigned int *atomic, - unsigned int val) - ATTRIBUTE_NONNULL(1); - -#undef VIR_STATIC - -#ifdef VIR_ATOMIC_OPS_GCC - -# define virAtomicIntGet(atomic) \ - (__extension__ ({ \ - (void)verify_expr(sizeof(*(atomic)) == sizeof(int), 0); \ - (void)(0 ? *(atomic) ^ *(atomic) : 0); \ - __sync_synchronize(); \ - (int)*(atomic); \ - })) -# define virAtomicIntSet(atomic, newval) \ - (__extension__ ({ \ - (void)verify_expr(sizeof(*(atomic)) == sizeof(int), 0); \ - (void)(0 ? *(atomic) ^ (newval) : 0); \ - *(atomic) = (newval); \ - __sync_synchronize(); \ - })) -# define virAtomicIntInc(atomic) \ - (__extension__ ({ \ - (void)verify_expr(sizeof(*(atomic)) == sizeof(int), 0); \ - (void)(0 ? *(atomic) ^ *(atomic) : 0); \ - __sync_add_and_fetch((atomic), 1); \ - })) -# define virAtomicIntDecAndTest(atomic) \ - (__extension__ ({ \ - (void)verify_expr(sizeof(*(atomic)) == sizeof(int), 0); \ - (void)(0 ? *(atomic) ^ *(atomic) : 0); \ - __sync_fetch_and_sub((atomic), 1) == 1; \ - })) -# define virAtomicIntCompareExchange(atomic, oldval, newval) \ - (__extension__ ({ \ - (void)verify_expr(sizeof(*(atomic)) == sizeof(int), 0); \ - (void)(0 ? *(atomic) ^ (newval) ^ (oldval) : 0); \ - (bool)__sync_bool_compare_and_swap((atomic), \ - (oldval), (newval)); \ - })) -# define virAtomicIntAdd(atomic, val) \ - (__extension__ ({ \ - (void)verify_expr(sizeof(*(atomic)) == sizeof(int), 0); \ - (void)(0 ? *(atomic) ^ (val) : 0); \ - (int) __sync_fetch_and_add((atomic), (val)); \ - })) -# define virAtomicIntAnd(atomic, val) \ - (__extension__ ({ \ - (void)verify_expr(sizeof(*(atomic)) == sizeof(int), 0); \ - (void) (0 ? *(atomic) ^ (val) : 0); \ - (unsigned int) __sync_fetch_and_and((atomic), (val)); \ - })) -# define virAtomicIntOr(atomic, val) \ - (__extension__ ({ \ - (void)verify_expr(sizeof(*(atomic)) == sizeof(int), 0); \ - (void) (0 ? *(atomic) ^ (val) : 0); \ - (unsigned int) __sync_fetch_and_or((atomic), (val)); \ - })) -# define virAtomicIntXor(atomic, val) \ - (__extension__ ({ \ - (void)verify_expr(sizeof(*(atomic)) == sizeof(int), 0); \ - (void) (0 ? *(atomic) ^ (val) : 0); \ - (unsigned int) __sync_fetch_and_xor((atomic), (val)); \ - })) - - -#else - -# ifdef VIR_ATOMIC_OPS_WIN32 - -# include <winsock2.h> -# include <windows.h> -# include <intrin.h> -# if !defined(_M_AMD64) && !defined (_M_IA64) && !defined(_M_X64) -# define InterlockedAnd _InterlockedAnd -# define InterlockedOr _InterlockedOr -# define InterlockedXor _InterlockedXor -# endif - -/* - * http://msdn.microsoft.com/en-us/library/ms684122(v=vs.85).aspx - */ -static inline int -virAtomicIntGet(volatile int *atomic) -{ - MemoryBarrier(); - return *atomic; -} - -static inline void -virAtomicIntSet(volatile int *atomic, - int newval) -{ - *atomic = newval; - MemoryBarrier(); -} - -static inline int -virAtomicIntInc(volatile int *atomic) -{ - return InterlockedIncrement((volatile LONG *)atomic); -} - -static inline bool -virAtomicIntDecAndTest(volatile int *atomic) -{ - return InterlockedDecrement((volatile LONG *)atomic) == 0; -} - -static inline bool -virAtomicIntCompareExchange(volatile int *atomic, - int oldval, - int newval) -{ - return InterlockedCompareExchange((volatile LONG *)atomic, newval, oldval) == oldval; -} - -static inline int -virAtomicIntAdd(volatile int *atomic, - int val) -{ - return InterlockedExchangeAdd((volatile LONG *)atomic, val); -} - -static inline unsigned int -virAtomicIntAnd(volatile unsigned int *atomic, - unsigned int val) -{ - return InterlockedAnd((volatile LONG *)atomic, val); -} - -static inline unsigned int -virAtomicIntOr(volatile unsigned int *atomic, - unsigned int val) -{ - return InterlockedOr((volatile LONG *)atomic, val); -} - -static inline unsigned int -virAtomicIntXor(volatile unsigned int *atomic, - unsigned int val) -{ - return InterlockedXor((volatile LONG *)atomic, val); -} - - -# else -# ifdef VIR_ATOMIC_OPS_PTHREAD -# include <pthread.h> - -extern pthread_mutex_t virAtomicLock; - -static inline int -virAtomicIntGet(volatile int *atomic) -{ - int value; - - pthread_mutex_lock(&virAtomicLock); - value = *atomic; - pthread_mutex_unlock(&virAtomicLock); - - return value; -} - -static inline void -virAtomicIntSet(volatile int *atomic, - int value) -{ - pthread_mutex_lock(&virAtomicLock); - *atomic = value; - pthread_mutex_unlock(&virAtomicLock); -} - -static inline int -virAtomicIntInc(volatile int *atomic) -{ - int value; - - pthread_mutex_lock(&virAtomicLock); - value = ++(*atomic); - pthread_mutex_unlock(&virAtomicLock); - - return value; -} - -static inline bool -virAtomicIntDecAndTest(volatile int *atomic) -{ - bool is_zero; - - pthread_mutex_lock(&virAtomicLock); - is_zero = --(*atomic) == 0; - pthread_mutex_unlock(&virAtomicLock); - - return is_zero; -} - -static inline bool -virAtomicIntCompareExchange(volatile int *atomic, - int oldval, - int newval) -{ - bool success; - - pthread_mutex_lock(&virAtomicLock); - - if ((success = (*atomic == oldval))) - *atomic = newval; - - pthread_mutex_unlock(&virAtomicLock); - - return success; -} - -static inline int -virAtomicIntAdd(volatile int *atomic, - int val) -{ - int oldval; - - pthread_mutex_lock(&virAtomicLock); - oldval = *atomic; - *atomic = oldval + val; - pthread_mutex_unlock(&virAtomicLock); - - return oldval; -} - -static inline unsigned int -virAtomicIntAnd(volatile unsigned int *atomic, - unsigned int val) -{ - unsigned int oldval; - - pthread_mutex_lock(&virAtomicLock); - oldval = *atomic; - *atomic = oldval & val; - pthread_mutex_unlock(&virAtomicLock); - - return oldval; -} - -static inline unsigned int -virAtomicIntOr(volatile unsigned int *atomic, - unsigned int val) -{ - unsigned int oldval; - - pthread_mutex_lock(&virAtomicLock); - oldval = *atomic; - *atomic = oldval | val; - pthread_mutex_unlock(&virAtomicLock); - - return oldval; -} - -static inline unsigned int -virAtomicIntXor(volatile unsigned int *atomic, - unsigned int val) -{ - unsigned int oldval; - - pthread_mutex_lock(&virAtomicLock); - oldval = *atomic; - *atomic = oldval ^ val; - pthread_mutex_unlock(&virAtomicLock); - - return oldval; -} - - -# else -# error "No atomic integer impl for this platform" -# endif -# endif - -/* The int/unsigned int casts here ensure that you can - * pass either an int or unsigned int to all atomic op - * functions, in the same way that we can with GCC - * atomic op helpers. - */ -# define virAtomicIntGet(atomic) \ - virAtomicIntGet((int *)atomic) -# define virAtomicIntSet(atomic, val) \ - virAtomicIntSet((int *)atomic, val) -# define virAtomicIntInc(atomic) \ - virAtomicIntInc((int *)atomic) -# define virAtomicIntDecAndTest(atomic) \ - virAtomicIntDecAndTest((int *)atomic) -# define virAtomicIntCompareExchange(atomic, oldval, newval) \ - virAtomicIntCompareExchange((int *)atomic, oldval, newval) -# define virAtomicIntAdd(atomic, val) \ - virAtomicIntAdd((int *)atomic, val) -# define virAtomicIntAnd(atomic, val) \ - virAtomicIntAnd((unsigned int *)atomic, val) -# define virAtomicIntOr(atomic, val) \ - virAtomicIntOr((unsigned int *)atomic, val) -# define virAtomicIntXor(atomic, val) \ - virAtomicIntXor((unsigned int *)atomic, val) - -#endif +#define virAtomicIntXor(i, v) g_atomic_int_xor(i, v) diff --git a/src/util/virprocess.c b/src/util/virprocess.c index 32f19e6b63..d5589daf6a 100644 --- a/src/util/virprocess.c +++ b/src/util/virprocess.c @@ -1021,7 +1021,7 @@ int virProcessGetStartTime(pid_t pid, unsigned long long *timestamp) { static int warned; - if (virAtomicIntInc(&warned) == 1) { + if (virAtomicIntInc(&warned) == 0) { VIR_WARN("Process start time of pid %lld not available on this platform", (long long) pid); } diff --git a/tests/viratomictest.c b/tests/viratomictest.c index 8c885a5b96..e30df66cd7 100644 --- a/tests/viratomictest.c +++ b/tests/viratomictest.c @@ -50,7 +50,7 @@ testTypes(const void *data G_GNUC_UNUSED) testAssertEq(virAtomicIntAdd(&u, 1), 5); testAssertEq(u, 6); - testAssertEq(virAtomicIntInc(&u), 7); + testAssertEq(virAtomicIntInc(&u), 6); testAssertEq(u, 7); res = virAtomicIntDecAndTest(&u); -- 2.24.1

G_STATIC_ASSERT() is a drop-in functional equivalent of the GNULIB verify() macro. Signed-off-by: Daniel P. Berrangé <berrange(a)redhat.com&gt; --- build-aux/syntax-check.mk | 6 ------ src/conf/snapshot_conf.h | 2 +- src/conf/virdomaincheckpointobjlist.c | 8 ++++---- src/esx/esx_network_driver.c | 2 +- src/esx/esx_storage_backend_iscsi.c | 2 +- src/esx/esx_storage_backend_vmfs.c | 2 +- src/internal.h | 1 - src/libxl/xen_xm.c | 3 +-- src/nwfilter/nwfilter_dhcpsnoop.c | 4 ++-- src/qemu/qemu_blockjob.h | 4 ++-- src/qemu/qemu_capabilities.c | 2 +- src/qemu/qemu_driver.c | 2 +- src/qemu/qemu_firmware.h | 2 +- src/qemu/qemu_migration_params.c | 2 +- src/remote/remote_daemon_dispatch.c | 10 +++++----- src/util/virarch.c | 3 +-- src/util/vircgroup.h | 2 +- src/util/vircrypto.c | 2 +- src/util/virenum.h | 8 ++++---- src/util/virinitctl.c | 4 ++-- src/util/virkeycode.c | 22 +++++++++++----------- src/util/virmacaddr.h | 2 +- src/util/virobject.h | 8 ++++---- src/util/virperf.c | 2 +- src/util/virstoragefile.c | 4 ++-- src/util/virtypedparam.h | 2 +- src/util/virutil.c | 3 +-- src/vz/vz_driver.c | 2 +- tests/virstringtest.c | 7 +++---- tools/virsh-domain.c | 2 +- tools/virsh-network.c | 2 +- tools/virsh-nodedev.c | 2 +- tools/virsh-pool.c | 2 +- tools/virsh-secret.c | 2 +- tools/virt-host-validate-common.c | 4 ++-- 35 files changed, 63 insertions(+), 74 deletions(-) diff --git a/build-aux/syntax-check.mk b/build-aux/syntax-check.mk index 2bbadd426c..7d5597e028 100644 --- a/build-aux/syntax-check.mk +++ b/build-aux/syntax-check.mk @@ -1635,12 +1635,6 @@ sc_prohibit_dirent_without_use: re='\<($(_dirent_syms_re))\>' \ $(_sc_header_without_use) -# Prohibit the inclusion of verify.h without an actual use. -sc_prohibit_verify_without_use: - @h='verify.h' \ - re='\<(verify(true|expr)?|assume|static_assert) *\(' \ - $(_sc_header_without_use) - # Don't include xfreopen.h unless you use one of its functions. sc_prohibit_xfreopen_without_use: @h='xfreopen.h' re='\<xfreopen *\(' $(_sc_header_without_use) diff --git a/src/conf/snapshot_conf.h b/src/conf/snapshot_conf.h index c02d0fa263..b5b1ef2718 100644 --- a/src/conf/snapshot_conf.h +++ b/src/conf/snapshot_conf.h @@ -56,7 +56,7 @@ typedef enum { VIR_DOMAIN_SNAPSHOT_DISK_SNAPSHOT, VIR_DOMAIN_SNAPSHOT_LAST } virDomainSnapshotState; -verify((int)VIR_DOMAIN_SNAPSHOT_DISK_SNAPSHOT == VIR_DOMAIN_LAST); +G_STATIC_ASSERT((int)VIR_DOMAIN_SNAPSHOT_DISK_SNAPSHOT == VIR_DOMAIN_LAST); /* Stores disk-snapshot information */ typedef struct _virDomainSnapshotDiskDef virDomainSnapshotDiskDef; diff --git a/src/conf/virdomaincheckpointobjlist.c b/src/conf/virdomaincheckpointobjlist.c index 41181477f4..a4942ea706 100644 --- a/src/conf/virdomaincheckpointobjlist.c +++ b/src/conf/virdomaincheckpointobjlist.c @@ -91,13 +91,13 @@ virDomainCheckpointObjListGetNames(virDomainCheckpointObjListPtr checkpoints, unsigned int flags) { /* We intentionally chose our public flags to match the common flags */ - verify(VIR_DOMAIN_CHECKPOINT_LIST_ROOTS == + G_STATIC_ASSERT(VIR_DOMAIN_CHECKPOINT_LIST_ROOTS == (int) VIR_DOMAIN_MOMENT_LIST_ROOTS); - verify(VIR_DOMAIN_CHECKPOINT_LIST_TOPOLOGICAL == + G_STATIC_ASSERT(VIR_DOMAIN_CHECKPOINT_LIST_TOPOLOGICAL == (int) VIR_DOMAIN_MOMENT_LIST_TOPOLOGICAL); - verify(VIR_DOMAIN_CHECKPOINT_LIST_LEAVES == + G_STATIC_ASSERT(VIR_DOMAIN_CHECKPOINT_LIST_LEAVES == (int) VIR_DOMAIN_MOMENT_LIST_LEAVES); - verify(VIR_DOMAIN_CHECKPOINT_LIST_NO_LEAVES == + G_STATIC_ASSERT(VIR_DOMAIN_CHECKPOINT_LIST_NO_LEAVES == (int) VIR_DOMAIN_MOMENT_LIST_NO_LEAVES); return virDomainMomentObjListGetNames(checkpoints->base, from, names, diff --git a/src/esx/esx_network_driver.c b/src/esx/esx_network_driver.c index 4f359c61e2..0d52818e18 100644 --- a/src/esx/esx_network_driver.c +++ b/src/esx/esx_network_driver.c @@ -41,7 +41,7 @@ * The UUID of a network is the MD5 sum of its key. Therefore, verify that * UUID and MD5 sum match in size, because we rely on that. */ -verify(VIR_CRYPTO_HASH_SIZE_MD5 == VIR_UUID_BUFLEN); +G_STATIC_ASSERT(VIR_CRYPTO_HASH_SIZE_MD5 == VIR_UUID_BUFLEN); static int diff --git a/src/esx/esx_storage_backend_iscsi.c b/src/esx/esx_storage_backend_iscsi.c index 72ab0d3cb0..395a347cf3 100644 --- a/src/esx/esx_storage_backend_iscsi.c +++ b/src/esx/esx_storage_backend_iscsi.c @@ -43,7 +43,7 @@ * The UUID of a storage pool is the MD5 sum of its mount path. Therefore, * verify that UUID and MD5 sum match in size, because we rely on that. */ -verify(VIR_CRYPTO_HASH_SIZE_MD5 == VIR_UUID_BUFLEN); +G_STATIC_ASSERT(VIR_CRYPTO_HASH_SIZE_MD5 == VIR_UUID_BUFLEN); diff --git a/src/esx/esx_storage_backend_vmfs.c b/src/esx/esx_storage_backend_vmfs.c index 61b30c3c1d..4f613bf93b 100644 --- a/src/esx/esx_storage_backend_vmfs.c +++ b/src/esx/esx_storage_backend_vmfs.c @@ -49,7 +49,7 @@ VIR_LOG_INIT("esx.esx_storage_backend_vmfs"); * The UUID of a storage pool is the MD5 sum of its mount path. Therefore, * verify that UUID and MD5 sum match in size, because we rely on that. */ -verify(VIR_CRYPTO_HASH_SIZE_MD5 == VIR_UUID_BUFLEN); +G_STATIC_ASSERT(VIR_CRYPTO_HASH_SIZE_MD5 == VIR_UUID_BUFLEN); diff --git a/src/internal.h b/src/internal.h index 686b7cfcc2..dad3cf757c 100644 --- a/src/internal.h +++ b/src/internal.h @@ -22,7 +22,6 @@ #include <errno.h> #include <limits.h> -#include <verify.h> #include <stdbool.h> #include <stdint.h> #include <stdio.h> diff --git a/src/libxl/xen_xm.c b/src/libxl/xen_xm.c index 5d5d521c18..54eb6fc97d 100644 --- a/src/libxl/xen_xm.c +++ b/src/libxl/xen_xm.c @@ -26,7 +26,6 @@ #include "virerror.h" #include "virconf.h" #include "viralloc.h" -#include "verify.h" #include "xenxs_private.h" #include "xen_xm.h" #include "domain_conf.h" @@ -581,7 +580,7 @@ xenFormatXMInputDevs(virConfPtr conf, virDomainDefPtr def) /* Computing the vcpu_avail bitmask works because MAX_VIRT_CPUS is either 32, or 64 on a platform where long is big enough. */ -verify(MAX_VIRT_CPUS <= sizeof(1UL) * CHAR_BIT); +G_STATIC_ASSERT(MAX_VIRT_CPUS <= sizeof(1UL) * CHAR_BIT); /* * Convert a virDomainDef object into an XM config record. diff --git a/src/nwfilter/nwfilter_dhcpsnoop.c b/src/nwfilter/nwfilter_dhcpsnoop.c index f3acaf00dd..629f974177 100644 --- a/src/nwfilter/nwfilter_dhcpsnoop.c +++ b/src/nwfilter/nwfilter_dhcpsnoop.c @@ -186,7 +186,7 @@ struct _virNWFilterSnoopEthHdr { uint16_t eh_type; uint8_t eh_data[]; } ATTRIBUTE_PACKED; -verify(sizeof(struct _virNWFilterSnoopEthHdr) == 14); +G_STATIC_ASSERT(sizeof(struct _virNWFilterSnoopEthHdr) == 14); typedef struct _virNWFilterSnoopDHCPHdr virNWFilterSnoopDHCPHdr; typedef virNWFilterSnoopDHCPHdr *virNWFilterSnoopDHCPHdrPtr; @@ -208,7 +208,7 @@ struct _virNWFilterSnoopDHCPHdr { char d_file[128]; uint8_t d_opts[]; } ATTRIBUTE_PACKED; -verify(sizeof(struct _virNWFilterSnoopDHCPHdr) == 236); +G_STATIC_ASSERT(sizeof(struct _virNWFilterSnoopDHCPHdr) == 236); /* DHCP options */ diff --git a/src/qemu/qemu_blockjob.h b/src/qemu/qemu_blockjob.h index 7d584a2980..2f29e8209c 100644 --- a/src/qemu/qemu_blockjob.h +++ b/src/qemu/qemu_blockjob.h @@ -44,7 +44,7 @@ typedef enum { QEMU_BLOCKJOB_STATE_PIVOTING, QEMU_BLOCKJOB_STATE_LAST } qemuBlockjobState; -verify((int)QEMU_BLOCKJOB_STATE_NEW == VIR_DOMAIN_BLOCK_JOB_LAST); +G_STATIC_ASSERT((int)QEMU_BLOCKJOB_STATE_NEW == VIR_DOMAIN_BLOCK_JOB_LAST); VIR_ENUM_DECL(qemuBlockjobState); @@ -67,7 +67,7 @@ typedef enum { QEMU_BLOCKJOB_TYPE_BROKEN, QEMU_BLOCKJOB_TYPE_LAST } qemuBlockJobType; -verify((int)QEMU_BLOCKJOB_TYPE_INTERNAL == VIR_DOMAIN_BLOCK_JOB_TYPE_LAST); +G_STATIC_ASSERT((int)QEMU_BLOCKJOB_TYPE_INTERNAL == VIR_DOMAIN_BLOCK_JOB_TYPE_LAST); VIR_ENUM_DECL(qemuBlockjob); diff --git a/src/qemu/qemu_capabilities.c b/src/qemu/qemu_capabilities.c index da0c7a257f..0867116096 100644 --- a/src/qemu/qemu_capabilities.c +++ b/src/qemu/qemu_capabilities.c @@ -2490,7 +2490,7 @@ static const char *preferredMachines[] = "sim", /* VIR_ARCH_XTENSA */ "sim", /* VIR_ARCH_XTENSAEB */ }; -verify(G_N_ELEMENTS(preferredMachines) == VIR_ARCH_LAST); +G_STATIC_ASSERT(G_N_ELEMENTS(preferredMachines) == VIR_ARCH_LAST); void diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index d6b1e9f00c..d01b4eb76f 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -2765,7 +2765,7 @@ qemuDomainGetControlInfo(virDomainPtr dom, #define QEMU_SAVE_PARTIAL "LibvirtQemudPart" #define QEMU_SAVE_VERSION 2 -verify(sizeof(QEMU_SAVE_MAGIC) == sizeof(QEMU_SAVE_PARTIAL)); +G_STATIC_ASSERT(sizeof(QEMU_SAVE_MAGIC) == sizeof(QEMU_SAVE_PARTIAL)); typedef enum { QEMU_SAVE_FORMAT_RAW = 0, diff --git a/src/qemu/qemu_firmware.h b/src/qemu/qemu_firmware.h index 37cbfae39d..2fdd71ba52 100644 --- a/src/qemu/qemu_firmware.h +++ b/src/qemu/qemu_firmware.h @@ -57,4 +57,4 @@ qemuFirmwareGetSupported(const char *machine, virFirmwarePtr **fws, size_t *nfws); -verify(VIR_DOMAIN_OS_DEF_FIRMWARE_LAST <= 64); +G_STATIC_ASSERT(VIR_DOMAIN_OS_DEF_FIRMWARE_LAST <= 64); diff --git a/src/qemu/qemu_migration_params.c b/src/qemu/qemu_migration_params.c index 9430ce1d00..1b28e5e031 100644 --- a/src/qemu/qemu_migration_params.c +++ b/src/qemu/qemu_migration_params.c @@ -218,7 +218,7 @@ static const qemuMigrationParamType qemuMigrationParamTypes[] = { [QEMU_MIGRATION_PARAM_MAX_POSTCOPY_BANDWIDTH] = QEMU_MIGRATION_PARAM_TYPE_ULL, [QEMU_MIGRATION_PARAM_MULTIFD_CHANNELS] = QEMU_MIGRATION_PARAM_TYPE_INT, }; -verify(G_N_ELEMENTS(qemuMigrationParamTypes) == QEMU_MIGRATION_PARAM_LAST); +G_STATIC_ASSERT(G_N_ELEMENTS(qemuMigrationParamTypes) == QEMU_MIGRATION_PARAM_LAST); virBitmapPtr diff --git a/src/remote/remote_daemon_dispatch.c b/src/remote/remote_daemon_dispatch.c index 995d463266..9fd49161ce 100644 --- a/src/remote/remote_daemon_dispatch.c +++ b/src/remote/remote_daemon_dispatch.c @@ -1332,7 +1332,7 @@ static virConnectDomainEventGenericCallback domainEventCallbacks[] = { VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventBlockThreshold), }; -verify(G_N_ELEMENTS(domainEventCallbacks) == VIR_DOMAIN_EVENT_ID_LAST); +G_STATIC_ASSERT(G_N_ELEMENTS(domainEventCallbacks) == VIR_DOMAIN_EVENT_ID_LAST); static int remoteRelayNetworkEventLifecycle(virConnectPtr conn, @@ -1369,7 +1369,7 @@ static virConnectNetworkEventGenericCallback networkEventCallbacks[] = { VIR_NETWORK_EVENT_CALLBACK(remoteRelayNetworkEventLifecycle), }; -verify(G_N_ELEMENTS(networkEventCallbacks) == VIR_NETWORK_EVENT_ID_LAST); +G_STATIC_ASSERT(G_N_ELEMENTS(networkEventCallbacks) == VIR_NETWORK_EVENT_ID_LAST); static int remoteRelayStoragePoolEventLifecycle(virConnectPtr conn, @@ -1436,7 +1436,7 @@ static virConnectStoragePoolEventGenericCallback storageEventCallbacks[] = { VIR_STORAGE_POOL_EVENT_CALLBACK(remoteRelayStoragePoolEventRefresh), }; -verify(G_N_ELEMENTS(storageEventCallbacks) == VIR_STORAGE_POOL_EVENT_ID_LAST); +G_STATIC_ASSERT(G_N_ELEMENTS(storageEventCallbacks) == VIR_STORAGE_POOL_EVENT_ID_LAST); static int remoteRelayNodeDeviceEventLifecycle(virConnectPtr conn, @@ -1503,7 +1503,7 @@ static virConnectNodeDeviceEventGenericCallback nodeDeviceEventCallbacks[] = { VIR_NODE_DEVICE_EVENT_CALLBACK(remoteRelayNodeDeviceEventUpdate), }; -verify(G_N_ELEMENTS(nodeDeviceEventCallbacks) == VIR_NODE_DEVICE_EVENT_ID_LAST); +G_STATIC_ASSERT(G_N_ELEMENTS(nodeDeviceEventCallbacks) == VIR_NODE_DEVICE_EVENT_ID_LAST); static int remoteRelaySecretEventLifecycle(virConnectPtr conn, @@ -1570,7 +1570,7 @@ static virConnectSecretEventGenericCallback secretEventCallbacks[] = { VIR_SECRET_EVENT_CALLBACK(remoteRelaySecretEventValueChanged), }; -verify(G_N_ELEMENTS(secretEventCallbacks) == VIR_SECRET_EVENT_ID_LAST); +G_STATIC_ASSERT(G_N_ELEMENTS(secretEventCallbacks) == VIR_SECRET_EVENT_ID_LAST); static void remoteRelayDomainQemuMonitorEvent(virConnectPtr conn, diff --git a/src/util/virarch.c b/src/util/virarch.c index f41e3e86bb..b132e178c3 100644 --- a/src/util/virarch.c +++ b/src/util/virarch.c @@ -25,7 +25,6 @@ #include "virlog.h" #include "virarch.h" -#include "verify.h" VIR_LOG_INIT("util.arch"); @@ -81,7 +80,7 @@ static const struct virArchData { { "xtensaeb", 32, VIR_ARCH_BIG_ENDIAN }, }; -verify(G_N_ELEMENTS(virArchData) == VIR_ARCH_LAST); +G_STATIC_ASSERT(G_N_ELEMENTS(virArchData) == VIR_ARCH_LAST); /** diff --git a/src/util/vircgroup.h b/src/util/vircgroup.h index 3eefe78787..15263f534a 100644 --- a/src/util/vircgroup.h +++ b/src/util/vircgroup.h @@ -49,7 +49,7 @@ VIR_ENUM_DECL(virCgroupController); * bit array stored in int. Like this: * 1 << VIR_CGROUP_CONTROLLER_CPU * Make sure we will not overflow */ -verify(VIR_CGROUP_CONTROLLER_LAST < 8 * sizeof(int)); +G_STATIC_ASSERT(VIR_CGROUP_CONTROLLER_LAST < 8 * sizeof(int)); typedef enum { VIR_CGROUP_THREAD_VCPU = 0, diff --git a/src/util/vircrypto.c b/src/util/vircrypto.c index 87fabfbba1..90aed32c53 100644 --- a/src/util/vircrypto.c +++ b/src/util/vircrypto.c @@ -47,7 +47,7 @@ struct virHashInfo { }; -verify(G_N_ELEMENTS(hashinfo) == VIR_CRYPTO_HASH_LAST); +G_STATIC_ASSERT(G_N_ELEMENTS(hashinfo) == VIR_CRYPTO_HASH_LAST); ssize_t virCryptoHashBuf(virCryptoHash hash, diff --git a/src/util/virenum.h b/src/util/virenum.h index d68421b203..d74af35530 100644 --- a/src/util/virenum.h +++ b/src/util/virenum.h @@ -42,7 +42,7 @@ virEnumToString(const char * const *types, G_N_ELEMENTS(name ## TypeList), \ type); \ } \ - verify(G_N_ELEMENTS(name ## TypeList) == lastVal) + G_STATIC_ASSERT(G_N_ELEMENTS(name ## TypeList) == lastVal) #define VIR_ENUM_DECL(name) \ const char *name ## TypeToString(int type); \ @@ -72,6 +72,6 @@ virTristateSwitch virTristateSwitchFromBool(bool val); /* the two enums must be in sync to be able to use helpers interchangeably in * some special cases */ -verify((int)VIR_TRISTATE_BOOL_YES == (int)VIR_TRISTATE_SWITCH_ON); -verify((int)VIR_TRISTATE_BOOL_NO == (int)VIR_TRISTATE_SWITCH_OFF); -verify((int)VIR_TRISTATE_BOOL_ABSENT == (int)VIR_TRISTATE_SWITCH_ABSENT); +G_STATIC_ASSERT((int)VIR_TRISTATE_BOOL_YES == (int)VIR_TRISTATE_SWITCH_ON); +G_STATIC_ASSERT((int)VIR_TRISTATE_BOOL_NO == (int)VIR_TRISTATE_SWITCH_OFF); +G_STATIC_ASSERT((int)VIR_TRISTATE_BOOL_ABSENT == (int)VIR_TRISTATE_SWITCH_ABSENT); diff --git a/src/util/virinitctl.c b/src/util/virinitctl.c index 955e8f398e..d7e29f24c3 100644 --- a/src/util/virinitctl.c +++ b/src/util/virinitctl.c @@ -96,9 +96,9 @@ struct virInitctlRequest { }; # ifdef MAXHOSTNAMELEN - verify(sizeof(struct virInitctlRequest) == 320 + MAXHOSTNAMELEN); + G_STATIC_ASSERT(sizeof(struct virInitctlRequest) == 320 + MAXHOSTNAMELEN); # else - verify(sizeof(struct virInitctlRequest) == 384); + G_STATIC_ASSERT(sizeof(struct virInitctlRequest) == 384); # endif diff --git a/src/util/virkeycode.c b/src/util/virkeycode.c index 1a0a94e3ab..1475f69b84 100644 --- a/src/util/virkeycode.c +++ b/src/util/virkeycode.c @@ -56,17 +56,17 @@ static const unsigned short *virKeymapValues[VIR_KEYCODE_SET_LAST] = { #define VIR_KEYMAP_ENTRY_MAX G_N_ELEMENTS(virKeyCodeTable_linux) -verify(VIR_KEYMAP_ENTRY_MAX == G_N_ELEMENTS(virKeyCodeTable_atset1)); -verify(VIR_KEYMAP_ENTRY_MAX == G_N_ELEMENTS(virKeyCodeTable_atset2)); -verify(VIR_KEYMAP_ENTRY_MAX == G_N_ELEMENTS(virKeyCodeTable_atset3)); -verify(VIR_KEYMAP_ENTRY_MAX == G_N_ELEMENTS(virKeyCodeTable_osx)); -verify(VIR_KEYMAP_ENTRY_MAX == G_N_ELEMENTS(virKeyCodeTable_xtkbd)); -verify(VIR_KEYMAP_ENTRY_MAX == G_N_ELEMENTS(virKeyCodeTable_usb)); -verify(VIR_KEYMAP_ENTRY_MAX == G_N_ELEMENTS(virKeyCodeTable_win32)); -verify(VIR_KEYMAP_ENTRY_MAX == G_N_ELEMENTS(virKeyCodeTable_qnum)); -verify(VIR_KEYMAP_ENTRY_MAX == G_N_ELEMENTS(virKeyNameTable_linux)); -verify(VIR_KEYMAP_ENTRY_MAX == G_N_ELEMENTS(virKeyNameTable_osx)); -verify(VIR_KEYMAP_ENTRY_MAX == G_N_ELEMENTS(virKeyNameTable_win32)); +G_STATIC_ASSERT(VIR_KEYMAP_ENTRY_MAX == G_N_ELEMENTS(virKeyCodeTable_atset1)); +G_STATIC_ASSERT(VIR_KEYMAP_ENTRY_MAX == G_N_ELEMENTS(virKeyCodeTable_atset2)); +G_STATIC_ASSERT(VIR_KEYMAP_ENTRY_MAX == G_N_ELEMENTS(virKeyCodeTable_atset3)); +G_STATIC_ASSERT(VIR_KEYMAP_ENTRY_MAX == G_N_ELEMENTS(virKeyCodeTable_osx)); +G_STATIC_ASSERT(VIR_KEYMAP_ENTRY_MAX == G_N_ELEMENTS(virKeyCodeTable_xtkbd)); +G_STATIC_ASSERT(VIR_KEYMAP_ENTRY_MAX == G_N_ELEMENTS(virKeyCodeTable_usb)); +G_STATIC_ASSERT(VIR_KEYMAP_ENTRY_MAX == G_N_ELEMENTS(virKeyCodeTable_win32)); +G_STATIC_ASSERT(VIR_KEYMAP_ENTRY_MAX == G_N_ELEMENTS(virKeyCodeTable_qnum)); +G_STATIC_ASSERT(VIR_KEYMAP_ENTRY_MAX == G_N_ELEMENTS(virKeyNameTable_linux)); +G_STATIC_ASSERT(VIR_KEYMAP_ENTRY_MAX == G_N_ELEMENTS(virKeyNameTable_osx)); +G_STATIC_ASSERT(VIR_KEYMAP_ENTRY_MAX == G_N_ELEMENTS(virKeyNameTable_win32)); VIR_ENUM_IMPL(virKeycodeSet, VIR_KEYCODE_SET_LAST, diff --git a/src/util/virmacaddr.h b/src/util/virmacaddr.h index 0296cfa965..e43ac3f32a 100644 --- a/src/util/virmacaddr.h +++ b/src/util/virmacaddr.h @@ -38,7 +38,7 @@ struct _virMacAddr { * must not have any extra members added - it must remain exactly * 6 bytes in length. */ -verify(sizeof(struct _virMacAddr) == 6); +G_STATIC_ASSERT(sizeof(struct _virMacAddr) == 6); int virMacAddrCompare(const char *mac1, const char *mac2); diff --git a/src/util/virobject.h b/src/util/virobject.h index 5c4bcf4dde..62a8a3d132 100644 --- a/src/util/virobject.h +++ b/src/util/virobject.h @@ -80,10 +80,10 @@ virClassPtr virClassForObjectRWLockable(void); * function or as a macro defined to NULL. */ #define VIR_CLASS_NEW(name, prnt) \ - verify_expr(offsetof(name, parent) == 0, \ - (name##Class = virClassNew(prnt, #name, sizeof(name), \ - sizeof(((name *)NULL)->parent), \ - name##Dispose))) + (G_STATIC_ASSERT_EXPR(offsetof(name, parent) == 0), \ + (name##Class = virClassNew(prnt, #name, sizeof(name),\ + sizeof(((name *)NULL)->parent), \ + name##Dispose))) virClassPtr virClassNew(virClassPtr parent, diff --git a/src/util/virperf.c b/src/util/virperf.c index fe2c3f8864..29c388a1f2 100644 --- a/src/util/virperf.c +++ b/src/util/virperf.c @@ -168,7 +168,7 @@ static struct virPerfEventAttr attrs[] = { .attrConfig = PERF_COUNT_SW_EMULATION_FAULTS }, }; -verify(G_N_ELEMENTS(attrs) == VIR_PERF_EVENT_LAST); +G_STATIC_ASSERT(G_N_ELEMENTS(attrs) == VIR_PERF_EVENT_LAST); typedef struct virPerfEventAttr *virPerfEventAttrPtr; diff --git a/src/util/virstoragefile.c b/src/util/virstoragefile.c index 1397f532fd..90e9b6796e 100644 --- a/src/util/virstoragefile.c +++ b/src/util/virstoragefile.c @@ -386,7 +386,7 @@ static struct FileTypeInfo const fileTypeInfo[] = { 4+4+4, 8, 512, NULL, vmdk4GetBackingStore, NULL }, }; -verify(G_N_ELEMENTS(fileTypeInfo) == VIR_STORAGE_FILE_LAST); +G_STATIC_ASSERT(G_N_ELEMENTS(fileTypeInfo) == VIR_STORAGE_FILE_LAST); /* qcow2 compatible features in the order they appear on-disk */ @@ -400,7 +400,7 @@ enum qcow2CompatibleFeature { static const int qcow2CompatibleFeatureArray[] = { VIR_STORAGE_FILE_FEATURE_LAZY_REFCOUNTS, }; -verify(G_N_ELEMENTS(qcow2CompatibleFeatureArray) == +G_STATIC_ASSERT(G_N_ELEMENTS(qcow2CompatibleFeatureArray) == QCOW2_COMPATIBLE_FEATURE_LAST); static int diff --git a/src/util/virtypedparam.h b/src/util/virtypedparam.h index ea48ee5009..3ac2e68144 100644 --- a/src/util/virtypedparam.h +++ b/src/util/virtypedparam.h @@ -33,7 +33,7 @@ */ #define VIR_TYPED_PARAM_MULTIPLE (1U << 31) -verify(!(VIR_TYPED_PARAM_LAST & VIR_TYPED_PARAM_MULTIPLE)); +G_STATIC_ASSERT(!(VIR_TYPED_PARAM_LAST & VIR_TYPED_PARAM_MULTIPLE)); typedef struct _virTypedParameterRemoteValue virTypedParameterRemoteValue; typedef struct virTypedParameterRemoteValue *virTypedParameterRemoteValuePtr; diff --git a/src/util/virutil.c b/src/util/virutil.c index a0fd7618ee..beb890a7f4 100644 --- a/src/util/virutil.c +++ b/src/util/virutil.c @@ -68,7 +68,6 @@ #include "virlog.h" #include "virbuffer.h" #include "viralloc.h" -#include "verify.h" #include "virfile.h" #include "vircommand.h" #include "nonblocking.h" @@ -76,7 +75,7 @@ #include "virstring.h" #include "virutil.h" -verify(sizeof(gid_t) <= sizeof(unsigned int) && +G_STATIC_ASSERT(sizeof(gid_t) <= sizeof(unsigned int) && sizeof(uid_t) <= sizeof(unsigned int)); #define VIR_FROM_THIS VIR_FROM_NONE diff --git a/src/vz/vz_driver.c b/src/vz/vz_driver.c index bcdbb50404..bd427fb07e 100644 --- a/src/vz/vz_driver.c +++ b/src/vz/vz_driver.c @@ -122,7 +122,7 @@ vzBuildCapabilities(void) if (virCapabilitiesInitCaches(caps) < 0) goto error; - verify(G_N_ELEMENTS(archs) == G_N_ELEMENTS(emulators)); + G_STATIC_ASSERT(G_N_ELEMENTS(archs) == G_N_ELEMENTS(emulators)); for (i = 0; i < G_N_ELEMENTS(ostypes); i++) for (j = 0; j < G_N_ELEMENTS(archs); j++) diff --git a/tests/virstringtest.c b/tests/virstringtest.c index 1f195ab4b9..88f50185e5 100644 --- a/tests/virstringtest.c +++ b/tests/virstringtest.c @@ -20,7 +20,6 @@ #include "testutils.h" -#include "verify.h" #include "virerror.h" #include "viralloc.h" #include "virfile.h" @@ -420,9 +419,9 @@ struct stringToLongData { * not guaranteed by POSIX. Good luck to you if you are crazy enough * to try and port libvirt to a platform with 16-bit int. Gnulib * already assumes that signed integers are two's complement. */ -verify(sizeof(int) == 4); -verify(sizeof(long) == sizeof(int) || sizeof(long) == sizeof(long long)); -verify(sizeof(long long) == 8); +G_STATIC_ASSERT(sizeof(int) == 4); +G_STATIC_ASSERT(sizeof(long) == sizeof(int) || sizeof(long) == sizeof(long long)); +G_STATIC_ASSERT(sizeof(long long) == 8); static int testStringToLong(const void *opaque) diff --git a/tools/virsh-domain.c b/tools/virsh-domain.c index 358067dce4..a74817cd91 100644 --- a/tools/virsh-domain.c +++ b/tools/virsh-domain.c @@ -13478,7 +13478,7 @@ virshDomainEventCallback virshDomainEventCallbacks[] = { { "block-threshold", VIR_DOMAIN_EVENT_CALLBACK(virshEventBlockThresholdPrint), }, }; -verify(VIR_DOMAIN_EVENT_ID_LAST == G_N_ELEMENTS(virshDomainEventCallbacks)); +G_STATIC_ASSERT(VIR_DOMAIN_EVENT_ID_LAST == G_N_ELEMENTS(virshDomainEventCallbacks)); static const vshCmdInfo info_event[] = { {.name = "help", diff --git a/tools/virsh-network.c b/tools/virsh-network.c index 700cb0d3e1..a02c85fcb1 100644 --- a/tools/virsh-network.c +++ b/tools/virsh-network.c @@ -1242,7 +1242,7 @@ virshNetworkEventCallback virshNetworkEventCallbacks[] = { { "lifecycle", VIR_NETWORK_EVENT_CALLBACK(vshEventLifecyclePrint), }, }; -verify(VIR_NETWORK_EVENT_ID_LAST == G_N_ELEMENTS(virshNetworkEventCallbacks)); +G_STATIC_ASSERT(VIR_NETWORK_EVENT_ID_LAST == G_N_ELEMENTS(virshNetworkEventCallbacks)); static const vshCmdInfo info_network_event[] = { {.name = "help", diff --git a/tools/virsh-nodedev.c b/tools/virsh-nodedev.c index cb2fc26d1a..68790ea802 100644 --- a/tools/virsh-nodedev.c +++ b/tools/virsh-nodedev.c @@ -845,7 +845,7 @@ virshNodeDeviceEventCallback virshNodeDeviceEventCallbacks[] = { VIR_NODE_DEVICE_EVENT_CALLBACK(vshEventLifecyclePrint), }, { "update", vshEventGenericPrint, } }; -verify(VIR_NODE_DEVICE_EVENT_ID_LAST == G_N_ELEMENTS(virshNodeDeviceEventCallbacks)); +G_STATIC_ASSERT(VIR_NODE_DEVICE_EVENT_ID_LAST == G_N_ELEMENTS(virshNodeDeviceEventCallbacks)); static const vshCmdInfo info_node_device_event[] = { diff --git a/tools/virsh-pool.c b/tools/virsh-pool.c index feae0787cb..9c32449fbb 100644 --- a/tools/virsh-pool.c +++ b/tools/virsh-pool.c @@ -1972,7 +1972,7 @@ virshPoolEventCallback virshPoolEventCallbacks[] = { VIR_STORAGE_POOL_EVENT_CALLBACK(vshEventLifecyclePrint), }, { "refresh", vshEventGenericPrint, } }; -verify(VIR_STORAGE_POOL_EVENT_ID_LAST == G_N_ELEMENTS(virshPoolEventCallbacks)); +G_STATIC_ASSERT(VIR_STORAGE_POOL_EVENT_ID_LAST == G_N_ELEMENTS(virshPoolEventCallbacks)); static const vshCmdInfo info_pool_event[] = { diff --git a/tools/virsh-secret.c b/tools/virsh-secret.c index 66369a25dc..01c62b9ce8 100644 --- a/tools/virsh-secret.c +++ b/tools/virsh-secret.c @@ -649,7 +649,7 @@ virshSecretEventCallback virshSecretEventCallbacks[] = { VIR_SECRET_EVENT_CALLBACK(vshEventLifecyclePrint), }, { "value-changed", vshEventGenericPrint, }, }; -verify(VIR_SECRET_EVENT_ID_LAST == G_N_ELEMENTS(virshSecretEventCallbacks)); +G_STATIC_ASSERT(VIR_SECRET_EVENT_ID_LAST == G_N_ELEMENTS(virshSecretEventCallbacks)); static const vshCmdInfo info_secret_event[] = { {.name = "help", diff --git a/tools/virt-host-validate-common.c b/tools/virt-host-validate-common.c index bce0f14917..6a715ede76 100644 --- a/tools/virt-host-validate-common.c +++ b/tools/virt-host-validate-common.c @@ -96,7 +96,7 @@ static const char * failMessages[] = { N_("NOTE"), }; -verify(G_N_ELEMENTS(failMessages) == VIR_HOST_VALIDATE_LAST); +G_STATIC_ASSERT(G_N_ELEMENTS(failMessages) == VIR_HOST_VALIDATE_LAST); static const char *failEscapeCodes[] = { "\033[31m", @@ -104,7 +104,7 @@ static const char *failEscapeCodes[] = { "\033[34m", }; -verify(G_N_ELEMENTS(failEscapeCodes) == VIR_HOST_VALIDATE_LAST); +G_STATIC_ASSERT(G_N_ELEMENTS(failEscapeCodes) == VIR_HOST_VALIDATE_LAST); void virHostMsgFail(virHostValidateLevel level, const char *format, -- 2.24.1

The GNULIB termios module ensures termios.h exists, but this is not neccessary and libvirt doesn't use any of its functionality on platforms where it is missing. It is thus sufficient to conditonallyinclude termios.h Signed-off-by: Daniel P. Berrangé <berrange(a)redhat.com&gt; --- configure.ac | 1 + src/util/virfdstream.c | 4 +++- src/util/virfile.c | 4 +++- src/util/virutil.c | 1 - tools/virsh.h | 1 - tools/vsh.h | 4 +++- 6 files changed, 10 insertions(+), 5 deletions(-) diff --git a/configure.ac b/configure.ac index 3e5032a8c4..5e75688658 100644 --- a/configure.ac +++ b/configure.ac @@ -398,6 +398,7 @@ AC_CHECK_HEADERS([\ sys/sysctl.h \ sys/ucred.h \ sys/un.h \ + termios.h \ ]) dnl Check whether endian provides handy macros. AC_CHECK_DECLS([htole64], [], [], [[#include <endian.h>]]) diff --git a/src/util/virfdstream.c b/src/util/virfdstream.c index 719185d992..4d17dd0353 100644 --- a/src/util/virfdstream.c +++ b/src/util/virfdstream.c @@ -31,7 +31,9 @@ # include <sys/un.h> #endif #include <netinet/in.h> -#include <termios.h> +#ifdef HAVE_TERMIOS_H +# include <termios.h> +#endif #include "virfdstream.h" #include "virerror.h" diff --git a/src/util/virfile.c b/src/util/virfile.c index 14bfd3beb6..0a743c8c3b 100644 --- a/src/util/virfile.c +++ b/src/util/virfile.c @@ -27,7 +27,9 @@ #include <passfd.h> #include <fcntl.h> -#include <termios.h> +#ifdef HAVE_TERMIOS_H +# include <termios.h> +#endif /* !HAVE_TERMIOS_H */ #ifdef HAVE_PTY_H /* Linux openpty */ # include <pty.h> diff --git a/src/util/virutil.c b/src/util/virutil.c index beb890a7f4..6d1a914ae3 100644 --- a/src/util/virutil.c +++ b/src/util/virutil.c @@ -35,7 +35,6 @@ #endif #include <sys/types.h> -#include <termios.h> #if WITH_DEVMAPPER # include <libdevmapper.h> diff --git a/tools/virsh.h b/tools/virsh.h index 903a2e53b6..fa9e54b1d1 100644 --- a/tools/virsh.h +++ b/tools/virsh.h @@ -23,7 +23,6 @@ #include <stdarg.h> #include <unistd.h> #include <sys/stat.h> -#include <termios.h> #include "internal.h" #include "virerror.h" diff --git a/tools/vsh.h b/tools/vsh.h index 960cae8df0..75272c2c97 100644 --- a/tools/vsh.h +++ b/tools/vsh.h @@ -23,7 +23,9 @@ #include <stdarg.h> #include <unistd.h> #include <sys/stat.h> -#include <termios.h> +#ifdef HAVE_TERMIOS_H +# include <termios.h> +#endif #include "internal.h" #include "virerror.h" -- 2.24.1

gmtime_r/localtime_r are mostly used in combination with strftime to format timestamps in libvirt. This can all be replaced with GDateTime resulting in simpler code that is also more portable. There is some boundary condition problem in parsing POSIX timezone offsets in GLib which tickles our test suite. The test suite is hacked to avoid the problem. The upsteam GLib bug report is Signed-off-by: Daniel P. Berrangé <berrange(a)redhat.com&gt; --- src/conf/domain_conf.c | 11 ++++---- src/libxl/libxl_domain.c | 10 +++---- src/qemu/qemu_command.c | 17 ++++------- src/qemu/qemu_driver.c | 10 +++---- src/util/virtime.c | 35 ++++------------------- tests/qemuxml2argvmock.c | 12 ++++---- tests/virtimetest.c | 39 +++++++++++++------------ tools/virsh-checkpoint.c | 20 +++++-------- tools/virsh-domain-monitor.c | 14 ++++----- tools/virsh-domain.c | 13 ++++----- tools/virsh-network.c | 11 ++++---- tools/virsh-snapshot.c | 19 ++++--------- tools/virt-admin.c | 55 ++++++++---------------------------- tools/vsh.c | 16 ++++------- 14 files changed, 96 insertions(+), 186 deletions(-) diff --git a/src/conf/domain_conf.c b/src/conf/domain_conf.c index 1290241923..a582f5f79e 100644 --- a/src/conf/domain_conf.c +++ b/src/conf/domain_conf.c @@ -26784,11 +26784,12 @@ virDomainGraphicsAuthDefFormatAttr(virBufferPtr buf, def->passwd); if (def->expires) { - char strbuf[100]; - struct tm tmbuf, *tm; - tm = gmtime_r(&def->validTo, &tmbuf); - strftime(strbuf, sizeof(strbuf), "%Y-%m-%dT%H:%M:%S", tm); - virBufferAsprintf(buf, " passwdValidTo='%s'", strbuf); + g_autoptr(GDateTime) then = NULL; + g_autofree char *thenstr = NULL; + + then = g_date_time_new_from_unix_utc(def->validTo); + thenstr = g_date_time_format(then, "%Y-%m-%dT%H:%M:%S"); + virBufferAsprintf(buf, " passwdValidTo='%s'", thenstr); } if (def->connected) diff --git a/src/libxl/libxl_domain.c b/src/libxl/libxl_domain.c index f9be4ad583..d63eca0bd6 100644 --- a/src/libxl/libxl_domain.c +++ b/src/libxl/libxl_domain.c @@ -943,16 +943,14 @@ libxlDomainAutoCoreDump(libxlDriverPrivatePtr driver, virDomainObjPtr vm) { g_autoptr(libxlDriverConfig) cfg = libxlDriverConfigGet(driver); - time_t curtime = time(NULL); - char timestr[100]; - struct tm time_info; + g_autoptr(GDateTime) now = g_date_time_new_now_local(); + g_autofree char *nowstr = NULL; char *dumpfile = NULL; - localtime_r(&curtime, &time_info); - strftime(timestr, sizeof(timestr), "%Y-%m-%d-%H:%M:%S", &time_info); + nowstr = g_date_time_format(now, "%Y-%m-%d-%H:%M:%S"); dumpfile = g_strdup_printf("%s/%s-%s", cfg->autoDumpDir, vm->def->name, - timestr); + nowstr); /* Unlock virDomainObj while dumping core */ virObjectUnlock(vm); diff --git a/src/qemu/qemu_command.c b/src/qemu/qemu_command.c index 904d2beab5..62cd3be7c4 100644 --- a/src/qemu/qemu_command.c +++ b/src/qemu/qemu_command.c @@ -6070,8 +6070,9 @@ qemuBuildClockArgStr(virDomainClockDefPtr def) break; case VIR_DOMAIN_CLOCK_OFFSET_VARIABLE: { - time_t now = time(NULL); - struct tm nowbits; + g_autoptr(GDateTime) now = g_date_time_new_now_utc(); + g_autoptr(GDateTime) then = NULL; + g_autofree char *thenstr = NULL; if (def->data.variable.basis == VIR_DOMAIN_CLOCK_BASIS_LOCALTIME) { long localOffset; @@ -6094,8 +6095,8 @@ qemuBuildClockArgStr(virDomainClockDefPtr def) def->data.variable.basis = VIR_DOMAIN_CLOCK_BASIS_UTC; } - now += def->data.variable.adjustment; - gmtime_r(&now, &nowbits); + then = g_date_time_add_seconds(now, def->data.variable.adjustment); + thenstr = g_date_time_format(then, "%Y-%m-%dT%H:%M:%S"); /* when an RTC_CHANGE event is received from qemu, we need to * have the adjustment used at domain start time available to @@ -6105,13 +6106,7 @@ qemuBuildClockArgStr(virDomainClockDefPtr def) */ def->data.variable.adjustment0 = def->data.variable.adjustment; - virBufferAsprintf(&buf, "base=%d-%02d-%02dT%02d:%02d:%02d", - nowbits.tm_year + 1900, - nowbits.tm_mon + 1, - nowbits.tm_mday, - nowbits.tm_hour, - nowbits.tm_min, - nowbits.tm_sec); + virBufferAsprintf(&buf, "base=%s", thenstr); } break; default: diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index d01b4eb76f..0801959465 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -4091,9 +4091,8 @@ getAutoDumpPath(virQEMUDriverPtr driver, virDomainObjPtr vm) { g_autofree char *domname = virDomainDefGetShortName(vm->def); - char timestr[100]; - struct tm time_info; - time_t curtime = time(NULL); + g_autoptr(GDateTime) now = g_date_time_new_now_local(); + g_autofree char *nowstr = NULL; g_autoptr(virQEMUDriverConfig) cfg = NULL; if (!domname) @@ -4101,10 +4100,9 @@ getAutoDumpPath(virQEMUDriverPtr driver, cfg = virQEMUDriverGetConfig(driver); - localtime_r(&curtime, &time_info); - strftime(timestr, sizeof(timestr), "%Y-%m-%d-%H:%M:%S", &time_info); + nowstr = g_date_time_format(now, "%Y-%m-%d-%H:%M:%S"); - return g_strdup_printf("%s/%s-%s", cfg->autoDumpPath, domname, timestr); + return g_strdup_printf("%s/%s-%s", cfg->autoDumpPath, domname, nowstr); } static void diff --git a/src/util/virtime.c b/src/util/virtime.c index 13f899cb91..bc8f06cd48 100644 --- a/src/util/virtime.c +++ b/src/util/virtime.c @@ -302,8 +302,8 @@ char *virTimeStringThen(unsigned long long when) /** * virTimeLocalOffsetFromUTC: * - * This function is threadsafe, but is *not* async signal safe (due to - * gmtime_r() and mktime()). + * This function is threadsafe, but is *not* async signal safe + * due to use of GLib APIs. * * @offset: pointer to time_t that will be set to the difference * between localtime and UTC in seconds (east of UTC is a @@ -314,34 +314,11 @@ char *virTimeStringThen(unsigned long long when) int virTimeLocalOffsetFromUTC(long *offset) { - struct tm gmtimeinfo; - time_t current, utc; + g_autoptr(GDateTime) now = g_date_time_new_now_local(); + GTimeSpan diff = g_date_time_get_utc_offset(now); - /* time() gives seconds since Epoch in current timezone */ - if ((current = time(NULL)) == (time_t)-1) { - virReportSystemError(errno, "%s", - _("failed to get current system time")); - return -1; - } - - /* treat current as if it were in UTC */ - if (!gmtime_r(&current, &gmtimeinfo)) { - virReportSystemError(errno, "%s", - _("gmtime_r failed")); - return -1; - } - - /* tell mktime to figure out itself whether or not DST is in effect */ - gmtimeinfo.tm_isdst = -1; - - /* mktime() also obeys current timezone rules */ - if ((utc = mktime(&gmtimeinfo)) == (time_t)-1) { - virReportSystemError(errno, "%s", - _("mktime failed")); - return -1; - } - - *offset = current - utc; + /* GTimeSpan measures microseconds, we want seconds */ + *offset = diff / 1000000; return 0; } diff --git a/tests/qemuxml2argvmock.c b/tests/qemuxml2argvmock.c index 8143de1618..e5841bc8e3 100644 --- a/tests/qemuxml2argvmock.c +++ b/tests/qemuxml2argvmock.c @@ -47,12 +47,14 @@ long virGetSystemPageSize(void) return 4096; } -time_t time(time_t *t) +GDateTime *g_date_time_new_now_utc(void) { - const time_t ret = 1234567890; - if (t) - *t = ret; - return ret; + return g_date_time_new_from_unix_utc(1234567890); +} + +GDateTime *g_date_time_new_now_local(void) +{ + return g_date_time_new_from_unix_local(1234567890); } bool diff --git a/tests/virtimetest.c b/tests/virtimetest.c index f8a81ff090..f9ac55192d 100644 --- a/tests/virtimetest.c +++ b/tests/virtimetest.c @@ -101,20 +101,12 @@ testTimeLocalOffset(const void *args) static bool isNearYearEnd(void) { - time_t current = time(NULL); - struct tm timeinfo; + g_autoptr(GDateTime) now = g_date_time_new_now_local(); - if (current == (time_t)-1) { - VIR_DEBUG("time() failed"); - return false; - } - if (!localtime_r(&current, &timeinfo)) { - VIR_DEBUG("localtime_r() failed"); - return false; - } - - return (timeinfo.tm_mon == 0 && timeinfo.tm_mday == 1) || - (timeinfo.tm_mon == 11 && timeinfo.tm_mday == 31); + return ((g_date_time_get_month(now) == 1 && + g_date_time_get_day_of_month(now) == 1) || + (g_date_time_get_month(now) == 12 && + g_date_time_get_day_of_month(now) == 31)); } @@ -186,14 +178,21 @@ mymain(void) /* test DST processing with timezones that always * have DST in effect; what's more, cover a zone with * with an unusual DST different than a usual one hour + * + * These tests originally used '0' as the first day, + * but changed to '1' due to GLib GTimeZone parsing bug: + * https://gitlab.gnome.org/GNOME/glib/issues/1999 + * + * Once we depend on a new enough GLib, we can put then + * back to 0 again. */ - TEST_LOCALOFFSET("VIR-00:30VID,0/00:00:00,365/23:59:59", + TEST_LOCALOFFSET("VIR-00:30VID,1/00:00:00,364/23:59:59", ((1 * 60) + 30) * 60); - TEST_LOCALOFFSET("VIR-02:30VID,0/00:00:00,365/23:59:59", + TEST_LOCALOFFSET("VIR-02:30VID,1/00:00:00,364/23:59:59", ((3 * 60) + 30) * 60); - TEST_LOCALOFFSET("VIR-02:30VID-04:30,0/00:00:00,365/23:59:59", + TEST_LOCALOFFSET("VIR-02:30VID-04:30,1/00:00:00,364/23:59:59", ((4 * 60) + 30) * 60); - TEST_LOCALOFFSET("VIR-12:00VID-13:00,0/00:00:00,365/23:59:59", + TEST_LOCALOFFSET("VIR-12:00VID-13:00,1/00:00:00,364/23:59:59", ((13 * 60) + 0) * 60); if (!isNearYearEnd()) { @@ -209,11 +208,11 @@ mymain(void) * tests, except on Dec 31 and Jan 1. */ - TEST_LOCALOFFSET("VIR02:45VID00:45,0/00:00:00,365/23:59:59", + TEST_LOCALOFFSET("VIR02:45VID00:45,1/00:00:00,364/23:59:59", -45 * 60); - TEST_LOCALOFFSET("VIR05:00VID04:00,0/00:00:00,365/23:59:59", + TEST_LOCALOFFSET("VIR05:00VID04:00,1/00:00:00,364/23:59:59", ((-4 * 60) + 0) * 60); - TEST_LOCALOFFSET("VIR11:00VID10:00,0/00:00:00,365/23:59:59", + TEST_LOCALOFFSET("VIR11:00VID10:00,1/00:00:00,364/23:59:59", ((-10 * 60) + 0) * 60); } diff --git a/tools/virsh-checkpoint.c b/tools/virsh-checkpoint.c index f9749b5f6d..e82a67f075 100644 --- a/tools/virsh-checkpoint.c +++ b/tools/virsh-checkpoint.c @@ -719,9 +719,8 @@ cmdCheckpointList(vshControl *ctl, char *doc = NULL; virDomainCheckpointPtr checkpoint = NULL; long long creation_longlong; - time_t creation_time_t; - char timestr[100]; - struct tm time_info; + g_autoptr(GDateTime) then = NULL; + g_autofree gchar *thenstr = NULL; bool tree = vshCommandOptBool(cmd, "tree"); bool name = vshCommandOptBool(cmd, "name"); bool from = vshCommandOptBool(cmd, "from"); @@ -835,21 +834,16 @@ cmdCheckpointList(vshControl *ctl, if (virXPathLongLong("string(/domaincheckpoint/creationTime)", ctxt, &creation_longlong) < 0) continue; - creation_time_t = creation_longlong; - if (creation_time_t != creation_longlong) { - vshError(ctl, "%s", _("time_t overflow")); - continue; - } - localtime_r(&creation_time_t, &time_info); - strftime(timestr, sizeof(timestr), "%Y-%m-%d %H:%M:%S %z", - &time_info); + + then = g_date_time_new_from_unix_local(creation_longlong); + thenstr = g_date_time_format(then, "%Y-%m-%d %H:%M:%S %z"); if (parent) { - if (vshTableRowAppend(table, chk_name, timestr, + if (vshTableRowAppend(table, chk_name, thenstr, NULLSTR_EMPTY(parent_chk), NULL) < 0) goto cleanup; } else { - if (vshTableRowAppend(table, chk_name, timestr, NULL) < 0) + if (vshTableRowAppend(table, chk_name, thenstr, NULL) < 0) goto cleanup; } } diff --git a/tools/virsh-domain-monitor.c b/tools/virsh-domain-monitor.c index e224b70293..27428e18fd 100644 --- a/tools/virsh-domain-monitor.c +++ b/tools/virsh-domain-monitor.c @@ -1535,17 +1535,13 @@ cmdDomTime(vshControl *ctl, const vshCmd *cmd) goto cleanup; if (pretty) { - char timestr[100]; - time_t cur_time = seconds; - struct tm time_info; + g_autoptr(GDateTime) then = NULL; + g_autofree char *thenstr = NULL; - if (!gmtime_r(&cur_time, &time_info)) { - vshError(ctl, _("Unable to format time")); - goto cleanup; - } - strftime(timestr, sizeof(timestr), "%Y-%m-%d %H:%M:%S", &time_info); + then = g_date_time_new_from_unix_utc(seconds); + thenstr = g_date_time_format(then, "%Y-%m-%d %H:%M:%S"); - vshPrint(ctl, _("Time: %s"), timestr); + vshPrint(ctl, _("Time: %s"), thenstr); } else { vshPrint(ctl, _("Time: %lld"), seconds); } diff --git a/tools/virsh-domain.c b/tools/virsh-domain.c index a74817cd91..397fa847d6 100644 --- a/tools/virsh-domain.c +++ b/tools/virsh-domain.c @@ -5492,9 +5492,8 @@ static const vshCmdOptDef opts_screenshot[] = { static char * virshGenFileName(vshControl *ctl, virDomainPtr dom, const char *mime) { - char timestr[100]; - time_t cur_time; - struct tm time_info; + g_autoptr(GDateTime) now = g_date_time_new_now_local(); + g_autofree char *nowstr = NULL; const char *ext = NULL; char *ret = NULL; @@ -5509,12 +5508,10 @@ virshGenFileName(vshControl *ctl, virDomainPtr dom, const char *mime) ext = ".png"; /* add mime type here */ - time(&cur_time); - localtime_r(&cur_time, &time_info); - strftime(timestr, sizeof(timestr), "%Y-%m-%d-%H:%M:%S", &time_info); + nowstr = g_date_time_format(now, "%Y-%m-%d-%H:%M:%S"); - ret = g_strdup_printf("%s-%s%s", virDomainGetName(dom), timestr, - NULLSTR_EMPTY(ext)); + ret = g_strdup_printf("%s-%s%s", virDomainGetName(dom), + nowstr, NULLSTR_EMPTY(ext)); return ret; } diff --git a/tools/virsh-network.c b/tools/virsh-network.c index a02c85fcb1..ed90736345 100644 --- a/tools/virsh-network.c +++ b/tools/virsh-network.c @@ -1433,11 +1433,10 @@ cmdNetworkDHCPLeases(vshControl *ctl, const vshCmd *cmd) const char *typestr = NULL; g_autofree char *cidr_format = NULL; virNetworkDHCPLeasePtr lease = leases[i]; - time_t expirytime_tmp = lease->expirytime; - struct tm ts; - char expirytime[32]; - localtime_r(&expirytime_tmp, &ts); - strftime(expirytime, sizeof(expirytime), "%Y-%m-%d %H:%M:%S", &ts); + g_autoptr(GDateTime) then = g_date_time_new_from_unix_local(lease->expirytime); + g_autofree char *thenstr = NULL; + + thenstr = g_date_time_format(then, "%Y-%m-%d %H:%M:%S"); if (lease->type == VIR_IP_ADDR_TYPE_IPV4) typestr = "ipv4"; @@ -1447,7 +1446,7 @@ cmdNetworkDHCPLeases(vshControl *ctl, const vshCmd *cmd) cidr_format = g_strdup_printf("%s/%d", lease->ipaddr, lease->prefix); if (vshTableRowAppend(table, - expirytime, + thenstr, NULLSTR_MINUS(lease->mac), NULLSTR_MINUS(typestr), NULLSTR_MINUS(cidr_format), diff --git a/tools/virsh-snapshot.c b/tools/virsh-snapshot.c index a42397b42e..d5e68e4b18 100644 --- a/tools/virsh-snapshot.c +++ b/tools/virsh-snapshot.c @@ -1492,9 +1492,8 @@ cmdSnapshotList(vshControl *ctl, const vshCmd *cmd) virDomainSnapshotPtr snapshot = NULL; char *state = NULL; long long creation_longlong; - time_t creation_time_t; - char timestr[100]; - struct tm time_info; + g_autoptr(GDateTime) then = NULL; + g_autofree gchar *thenstr = NULL; bool tree = vshCommandOptBool(cmd, "tree"); bool name = vshCommandOptBool(cmd, "name"); bool from = vshCommandOptBool(cmd, "from"); @@ -1624,22 +1623,16 @@ cmdSnapshotList(vshControl *ctl, const vshCmd *cmd) if (virXPathLongLong("string(/domainsnapshot/creationTime)", ctxt, &creation_longlong) < 0) continue; - creation_time_t = creation_longlong; - if (creation_time_t != creation_longlong) { - vshError(ctl, "%s", _("time_t overflow")); - continue; - } - localtime_r(&creation_time_t, &time_info); - strftime(timestr, sizeof(timestr), "%Y-%m-%d %H:%M:%S %z", - &time_info); + then = g_date_time_new_from_unix_local(creation_longlong); + thenstr = g_date_time_format(then, "%Y-%m-%d %H:%M:%S %z"); if (parent) { - if (vshTableRowAppend(table, snap_name, timestr, state, + if (vshTableRowAppend(table, snap_name, thenstr, state, NULLSTR_EMPTY(parent_snap), NULL) < 0) goto cleanup; } else { - if (vshTableRowAppend(table, snap_name, timestr, state, + if (vshTableRowAppend(table, snap_name, thenstr, state, NULL) < 0) goto cleanup; } diff --git a/tools/virt-admin.c b/tools/virt-admin.c index 30106d1971..c71ebb1012 100644 --- a/tools/virt-admin.c +++ b/tools/virt-admin.c @@ -69,40 +69,6 @@ vshAdmClientTransportToString(int transport) return str ? _(str) : _("unknown"); } -/* - * vshAdmGetTimeStr: - * - * Produces string representation (local time) of @then - * (seconds since epoch UTC) using format 'YYYY-MM-DD HH:MM:SS+ZZZZ'. - * - * Returns 0 if conversion finished successfully, -1 in case of an error. - * Caller is responsible for freeing the string returned. - */ -static int -vshAdmGetTimeStr(vshControl *ctl, time_t then, char **result) -{ - char *tmp = NULL; - struct tm timeinfo; - - if (!localtime_r(&then, &timeinfo)) - goto error; - - if (VIR_ALLOC_N(tmp, VIRT_ADMIN_TIME_BUFLEN) < 0) - goto error; - - if (strftime(tmp, VIRT_ADMIN_TIME_BUFLEN, "%Y-%m-%d %H:%M:%S%z", - &timeinfo) == 0) { - VIR_FREE(tmp); - goto error; - } - - *result = tmp; - return 0; - - error: - vshError(ctl, "%s", _("Timestamp string conversion failed")); - return -1; -} /* * vshAdmCatchDisconnect: @@ -646,19 +612,19 @@ cmdSrvClientsList(vshControl *ctl, const vshCmd *cmd) goto cleanup; for (i = 0; i < nclts; i++) { - g_autofree char *timestr = NULL; + g_autoptr(GDateTime) then = NULL; + g_autofree gchar *thenstr = NULL; g_autofree char *idStr = NULL; virAdmClientPtr client = clts[i]; id = virAdmClientGetID(client); + then = g_date_time_new_from_unix_local(virAdmClientGetTimestamp(client)); transport = virAdmClientGetTransport(client); - if (vshAdmGetTimeStr(ctl, virAdmClientGetTimestamp(client), - &timestr) < 0) - goto cleanup; + thenstr = g_date_time_format(then, "%Y-%m-%d %H:%M:%S%z"); idStr = g_strdup_printf("%llu", id); if (vshTableRowAppend(table, idStr, vshAdmClientTransportToString(transport), - timestr, NULL) < 0) + thenstr, NULL) < 0) goto cleanup; } @@ -714,7 +680,8 @@ cmdClientInfo(vshControl *ctl, const vshCmd *cmd) size_t i; unsigned long long id; const char *srvname = NULL; - char *timestr = NULL; + g_autoptr(GDateTime) then = NULL; + g_autofree gchar *thenstr = NULL; virAdmServerPtr srv = NULL; virAdmClientPtr clnt = NULL; virTypedParameterPtr params = NULL; @@ -739,12 +706,13 @@ cmdClientInfo(vshControl *ctl, const vshCmd *cmd) goto cleanup; } - if (vshAdmGetTimeStr(ctl, virAdmClientGetTimestamp(clnt), &timestr) < 0) - goto cleanup; + + then = g_date_time_new_from_unix_local(virAdmClientGetTimestamp(clnt)); + thenstr = g_date_time_format(then, "%Y-%m-%d %H:%M:%S%z"); /* this info is provided by the client object itself */ vshPrint(ctl, "%-15s: %llu\n", "id", virAdmClientGetID(clnt)); - vshPrint(ctl, "%-15s: %s\n", "connection_time", timestr); + vshPrint(ctl, "%-15s: %s\n", "connection_time", thenstr); vshPrint(ctl, "%-15s: %s\n", "transport", vshAdmClientTransportToString(virAdmClientGetTransport(clnt))); @@ -760,7 +728,6 @@ cmdClientInfo(vshControl *ctl, const vshCmd *cmd) virTypedParamsFree(params, nparams); virAdmServerFree(srv); virAdmClientFree(clnt); - VIR_FREE(timestr); return ret; } diff --git a/tools/vsh.c b/tools/vsh.c index a36b6bfe23..eeb9659ef9 100644 --- a/tools/vsh.c +++ b/tools/vsh.c @@ -2197,8 +2197,8 @@ vshOutputLogFile(vshControl *ctl, int log_level, const char *msg_format, char *str = NULL; size_t len; const char *lvl = ""; - time_t stTime; - struct tm stTm; + g_autoptr(GDateTime) now = g_date_time_new_now_local(); + g_autofree gchar *nowstr = NULL; if (ctl->log_fd == -1) return; @@ -2208,15 +2208,9 @@ vshOutputLogFile(vshControl *ctl, int log_level, const char *msg_format, * * [YYYY.MM.DD HH:MM:SS SIGNATURE PID] LOG_LEVEL message */ - time(&stTime); - localtime_r(&stTime, &stTm); - virBufferAsprintf(&buf, "[%d.%02d.%02d %02d:%02d:%02d %s %d] ", - (1900 + stTm.tm_year), - (1 + stTm.tm_mon), - stTm.tm_mday, - stTm.tm_hour, - stTm.tm_min, - stTm.tm_sec, + nowstr = g_date_time_format(now, "%Y.%m.%d %H:%M:%S"); + virBufferAsprintf(&buf, "[%s %s %d] ", + nowstr, ctl->progname, (int) getpid()); switch (log_level) { -- 2.24.1