From: Eric Blake <eblake@redhat.com>
To: qemu-devel@nongnu.org
Cc: hreitz@redhat.com, armbru@redhat.com, richard.henderson@linaro.org
Subject: [PATCH v2 09/19] test-cutils: Add coverage of qemu_strtod
Date: Thu, 11 May 2023 21:10:23 -0500 [thread overview]
Message-ID: <20230512021033.1378730-10-eblake@redhat.com> (raw)
In-Reply-To: <20230512021033.1378730-1-eblake@redhat.com>
It's hard to tweak code for consistency if I can't prove what will or
won't break from those tweaks. Time to add unit tests for
qemu_strtod() and qemu_strtod_finite().
Among other things, I wrote a check whether we have C99 semantics for
strtod("0x1") (which MUST parse hex numbers) rather than C89 (which
must stop parsing at 'x'). These days, I suspect that is okay; but if
it fails CI checks, knowing the difference will help us decide what we
want to do about it. Note that C2x, while not final at the time of
this patch, has been considering whether to make strtol("0b1") parse
as 1 with no slop instead of the C17 parse of 0 with slop "b1"; that
decision may also bleed over to strtod(). But for now, I didn't think
it worth adding unit tests on that front (to strtol or strtod) as
things may still change.
Likewise, there are plenty more corner cases of strtod proper that I
don't explicitly test here, but there are enough unit tests added here
that it covers all the branches reached in our wrappers. In
particular, it demonstrates the difference on when *value is left
uninitialized, which an upcoming patch will normalize.
Signed-off-by: Eric Blake <eblake@redhat.com>
---
v2: Added g_assert_false(signbit(res)) anywhere I used
g_assert_cmpfloat(res,==,0.0); add a test for strtod() hex parsing and
handling of junk after ERANGE, which is major enough that I dropped
R-b
---
tests/unit/test-cutils.c | 510 +++++++++++++++++++++++++++++++++++++++
1 file changed, 510 insertions(+)
diff --git a/tests/unit/test-cutils.c b/tests/unit/test-cutils.c
index d3076c3fec1..1763839a157 100644
--- a/tests/unit/test-cutils.c
+++ b/tests/unit/test-cutils.c
@@ -25,6 +25,8 @@
* THE SOFTWARE.
*/
+#include <math.h>
+
#include "qemu/osdep.h"
#include "qemu/cutils.h"
#include "qemu/units.h"
@@ -2668,6 +2670,485 @@ static void test_qemu_strtou64_full_erange_junk(void)
g_assert_cmpint(res, ==, UINT64_MAX);
}
+static void test_qemu_strtod_simple(void)
+{
+ const char *str;
+ const char *endptr;
+ int err;
+ double res;
+
+ /* no radix or exponent */
+ str = "1";
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtod(str, &endptr, &res);
+ g_assert_cmpint(err, ==, 0);
+ g_assert_cmpfloat(res, ==, 1.0);
+ g_assert_true(endptr == str + 1);
+
+ /* leading space and sign */
+ str = " -0.0";
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtod(str, &endptr, &res);
+ g_assert_cmpint(err, ==, 0);
+ g_assert_cmpfloat(res, ==, -0.0);
+ g_assert_true(signbit(res));
+ g_assert_true(endptr == str + 5);
+
+ /* fraction only */
+ str = "+.5";
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtod(str, &endptr, &res);
+ g_assert_cmpint(err, ==, 0);
+ g_assert_cmpfloat(res, ==, 0.5);
+ g_assert_true(endptr == str + 3);
+
+ /* exponent */
+ str = "1.e+1";
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtod(str, &endptr, &res);
+ g_assert_cmpint(err, ==, 0);
+ g_assert_cmpfloat(res, ==, 10.0);
+ g_assert_true(endptr == str + 5);
+
+ /* hex without radix */
+ str = "0x10";
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtod(str, &endptr, &res);
+ g_assert_cmpint(err, ==, 0);
+ g_assert_cmpfloat(res, ==, 16.0);
+ g_assert_true(endptr == str + 4);
+}
+
+static void test_qemu_strtod_einval(void)
+{
+ const char *str;
+ const char *endptr;
+ int err;
+ double res;
+
+ /* empty */
+ str = "";
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtod(str, &endptr, &res);
+ g_assert_cmpint(err, ==, -EINVAL);
+ g_assert_cmpfloat(res, ==, 0.0);
+ g_assert_false(signbit(res));
+ g_assert_true(endptr == str);
+
+ /* NULL */
+ str = NULL;
+ endptr = "random";
+ res = 999;
+ err = qemu_strtod(str, &endptr, &res);
+ g_assert_cmpint(err, ==, -EINVAL);
+ g_assert_cmpfloat(res, ==, 999.0);
+ g_assert_null(endptr);
+
+ /* not recognizable */
+ str = " junk";
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtod(str, &endptr, &res);
+ g_assert_cmpint(err, ==, -EINVAL);
+ g_assert_cmpfloat(res, ==, 0.0);
+ g_assert_false(signbit(res));
+ g_assert_true(endptr == str);
+}
+
+static void test_qemu_strtod_erange(void)
+{
+ const char *str;
+ const char *endptr;
+ int err;
+ double res;
+
+ /* overflow */
+ str = "9e999";
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtod(str, &endptr, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpfloat(res, ==, HUGE_VAL);
+ g_assert_true(endptr == str + 5);
+
+ str = "-9e+999";
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtod(str, &endptr, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpfloat(res, ==, -HUGE_VAL);
+ g_assert_true(endptr == str + 7);
+
+ /* underflow */
+ str = "-9e-999";
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtod(str, &endptr, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpfloat(res, >=, -DBL_MIN);
+ g_assert_cmpfloat(res, <=, -0.0);
+ g_assert_true(signbit(res));
+ g_assert_true(endptr == str + 7);
+}
+
+static void test_qemu_strtod_nonfinite(void)
+{
+ const char *str;
+ const char *endptr;
+ int err;
+ double res;
+
+ /* infinity */
+ str = "inf";
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtod(str, &endptr, &res);
+ g_assert_cmpint(err, ==, 0);
+ g_assert_true(isinf(res));
+ g_assert_false(signbit(res));
+ g_assert_true(endptr == str + 3);
+
+ str = "-infinity";
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtod(str, &endptr, &res);
+ g_assert_cmpint(err, ==, 0);
+ g_assert_true(isinf(res));
+ g_assert_true(signbit(res));
+ g_assert_true(endptr == str + 9);
+
+ /* not a number */
+ str = " NaN";
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtod(str, &endptr, &res);
+ g_assert_cmpint(err, ==, 0);
+ g_assert_true(isnan(res));
+ g_assert_true(endptr == str + 4);
+}
+
+static void test_qemu_strtod_trailing(void)
+{
+ const char *str;
+ const char *endptr;
+ int err;
+ double res;
+
+ /* trailing whitespace */
+ str = "1. ";
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtod(str, &endptr, &res);
+ g_assert_cmpint(err, ==, 0);
+ g_assert_cmpfloat(res, ==, 1.0);
+ g_assert_true(endptr == str + 2);
+
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtod(str, NULL, &res);
+ g_assert_cmpint(err, ==, -EINVAL);
+ g_assert_cmpfloat(res, ==, 1.0);
+
+ /* trailing e is not an exponent */
+ str = ".5e";
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtod(str, &endptr, &res);
+ g_assert_cmpint(err, ==, 0);
+ g_assert_cmpfloat(res, ==, 0.5);
+ g_assert_true(endptr == str + 2);
+
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtod(str, NULL, &res);
+ g_assert_cmpint(err, ==, -EINVAL);
+ g_assert_cmpfloat(res, ==, 0.5);
+
+ /* trailing ( not part of long NaN */
+ str = "nan(";
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtod(str, &endptr, &res);
+ g_assert_cmpint(err, ==, 0);
+ g_assert_true(isnan(res));
+ g_assert_true(endptr == str + 3);
+
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtod(str, NULL, &res);
+ g_assert_cmpint(err, ==, -EINVAL);
+ g_assert_true(isnan(res));
+}
+
+static void test_qemu_strtod_erange_junk(void)
+{
+ const char *str;
+ const char *endptr;
+ int err;
+ double res;
+
+ /* EINVAL has priority over ERANGE */
+ str = "1e-999junk";
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtod(str, &endptr, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpfloat(res, <=, DBL_MIN);
+ g_assert_cmpfloat(res, >=, 0.0);
+ g_assert_false(signbit(res));
+ g_assert_true(endptr == str + 6);
+
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtod(str, NULL, &res);
+ g_assert_cmpint(err, ==, -EINVAL);
+ g_assert_cmpfloat(res, ==, 0.0);
+ g_assert_false(signbit(res));
+}
+
+static void test_qemu_strtod_finite_simple(void)
+{
+ const char *str;
+ const char *endptr;
+ int err;
+ double res;
+
+ /* no radix or exponent */
+ str = "1";
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtod_finite(str, &endptr, &res);
+ g_assert_cmpint(err, ==, 0);
+ g_assert_cmpfloat(res, ==, 1.0);
+ g_assert_true(endptr == str + 1);
+
+ /* leading space and sign */
+ str = " -0.0";
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtod_finite(str, &endptr, &res);
+ g_assert_cmpint(err, ==, 0);
+ g_assert_cmpfloat(res, ==, -0.0);
+ g_assert_true(signbit(res));
+ g_assert_true(endptr == str + 5);
+
+ /* fraction only */
+ str = "+.5";
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtod_finite(str, &endptr, &res);
+ g_assert_cmpint(err, ==, 0);
+ g_assert_cmpfloat(res, ==, 0.5);
+ g_assert_true(endptr == str + 3);
+
+ /* exponent */
+ str = "1.e+1";
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtod_finite(str, &endptr, &res);
+ g_assert_cmpint(err, ==, 0);
+ g_assert_cmpfloat(res, ==, 10.0);
+ g_assert_true(endptr == str + 5);
+
+ /* hex without radix */
+ str = "0x10";
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtod(str, &endptr, &res);
+ g_assert_cmpint(err, ==, 0);
+ g_assert_cmpfloat(res, ==, 16.0);
+ g_assert_true(endptr == str + 4);
+}
+
+static void test_qemu_strtod_finite_einval(void)
+{
+ const char *str;
+ const char *endptr;
+ int err;
+ double res;
+
+ /* empty */
+ str = "";
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtod_finite(str, &endptr, &res);
+ g_assert_cmpint(err, ==, -EINVAL);
+ g_assert_cmpfloat(res, ==, 999.0);
+ g_assert_true(endptr == str);
+
+ /* NULL */
+ str = NULL;
+ endptr = "random";
+ res = 999;
+ err = qemu_strtod_finite(str, &endptr, &res);
+ g_assert_cmpint(err, ==, -EINVAL);
+ g_assert_cmpfloat(res, ==, 999.0);
+ g_assert_null(endptr);
+
+ /* not recognizable */
+ str = " junk";
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtod_finite(str, &endptr, &res);
+ g_assert_cmpint(err, ==, -EINVAL);
+ g_assert_cmpfloat(res, ==, 999.0);
+ g_assert_true(endptr == str);
+}
+
+static void test_qemu_strtod_finite_erange(void)
+{
+ const char *str;
+ const char *endptr;
+ int err;
+ double res;
+
+ /* overflow */
+ str = "9e999";
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtod_finite(str, &endptr, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpfloat(res, ==, HUGE_VAL);
+ g_assert_true(endptr == str + 5);
+
+ str = "-9e+999";
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtod_finite(str, &endptr, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpfloat(res, ==, -HUGE_VAL);
+ g_assert_true(endptr == str + 7);
+
+ /* underflow */
+ str = "-9e-999";
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtod_finite(str, &endptr, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpfloat(res, >=, -DBL_MIN);
+ g_assert_cmpfloat(res, <=, -0.0);
+ g_assert_true(signbit(res));
+ g_assert_true(endptr == str + 7);
+}
+
+static void test_qemu_strtod_finite_nonfinite(void)
+{
+ const char *str;
+ const char *endptr;
+ int err;
+ double res;
+
+ /* infinity */
+ str = "inf";
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtod_finite(str, &endptr, &res);
+ g_assert_cmpint(err, ==, -EINVAL);
+ g_assert_cmpfloat(res, ==, 999.0);
+ g_assert_true(endptr == str);
+
+ str = "-infinity";
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtod_finite(str, &endptr, &res);
+ g_assert_cmpint(err, ==, -EINVAL);
+ g_assert_cmpfloat(res, ==, 999.0);
+ g_assert_true(endptr == str);
+
+ /* not a number */
+ str = " NaN";
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtod_finite(str, &endptr, &res);
+ g_assert_cmpint(err, ==, -EINVAL);
+ g_assert_cmpfloat(res, ==, 999.0);
+ g_assert_true(endptr == str);
+}
+
+static void test_qemu_strtod_finite_trailing(void)
+{
+ const char *str;
+ const char *endptr;
+ int err;
+ double res;
+
+ /* trailing whitespace */
+ str = "1. ";
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtod_finite(str, &endptr, &res);
+ g_assert_cmpint(err, ==, 0);
+ g_assert_cmpfloat(res, ==, 1.0);
+ g_assert_true(endptr == str + 2);
+
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtod_finite(str, NULL, &res);
+ g_assert_cmpint(err, ==, -EINVAL);
+ g_assert_cmpfloat(res, ==, 999.0);
+
+ /* trailing e is not an exponent */
+ str = ".5e";
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtod_finite(str, &endptr, &res);
+ g_assert_cmpint(err, ==, 0);
+ g_assert_cmpfloat(res, ==, 0.5);
+ g_assert_true(endptr == str + 2);
+
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtod_finite(str, NULL, &res);
+ g_assert_cmpint(err, ==, -EINVAL);
+ g_assert_cmpfloat(res, ==, 999.0);
+
+ /* trailing ( not part of long NaN */
+ str = "nan(";
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtod_finite(str, &endptr, &res);
+ g_assert_cmpint(err, ==, -EINVAL);
+ g_assert_cmpfloat(res, ==, 999.0);
+ g_assert_true(endptr == str);
+
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtod_finite(str, NULL, &res);
+ g_assert_cmpint(err, ==, -EINVAL);
+ g_assert_cmpfloat(res, ==, 999.0);
+}
+
+static void test_qemu_strtod_finite_erange_junk(void)
+{
+ const char *str;
+ const char *endptr;
+ int err;
+ double res;
+
+ /* EINVAL has priority over ERANGE */
+ str = "1e-999junk";
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtod_finite(str, &endptr, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpfloat(res, <=, DBL_MIN);
+ g_assert_cmpfloat(res, >=, 0.0);
+ g_assert_false(signbit(res));
+ g_assert_true(endptr == str + 6);
+
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtod_finite(str, NULL, &res);
+ g_assert_cmpint(err, ==, -EINVAL);
+ g_assert_cmpfloat(res, ==, 999.0);
+}
+
static void test_qemu_strtosz_simple(void)
{
const char *str;
@@ -3510,6 +3991,35 @@ int main(int argc, char **argv)
g_test_add_func("/cutils/qemu_strtou64_full/erange_junk",
test_qemu_strtou64_full_erange_junk);
+ /* qemu_strtod() tests */
+ g_test_add_func("/cutils/qemu_strtod/simple",
+ test_qemu_strtod_simple);
+ g_test_add_func("/cutils/qemu_strtod/einval",
+ test_qemu_strtod_einval);
+ g_test_add_func("/cutils/qemu_strtod/erange",
+ test_qemu_strtod_erange);
+ g_test_add_func("/cutils/qemu_strtod/nonfinite",
+ test_qemu_strtod_nonfinite);
+ g_test_add_func("/cutils/qemu_strtod/trailing",
+ test_qemu_strtod_trailing);
+ g_test_add_func("/cutils/qemu_strtod/erange_junk",
+ test_qemu_strtod_erange_junk);
+
+ /* qemu_strtod_finite() tests */
+ g_test_add_func("/cutils/qemu_strtod_finite/simple",
+ test_qemu_strtod_finite_simple);
+ g_test_add_func("/cutils/qemu_strtod_finite/einval",
+ test_qemu_strtod_finite_einval);
+ g_test_add_func("/cutils/qemu_strtod_finite/erange",
+ test_qemu_strtod_finite_erange);
+ g_test_add_func("/cutils/qemu_strtod_finite/nonfinite",
+ test_qemu_strtod_finite_nonfinite);
+ g_test_add_func("/cutils/qemu_strtod_finite/trailing",
+ test_qemu_strtod_finite_trailing);
+ g_test_add_func("/cutils/qemu_strtod_finite/erange_junk",
+ test_qemu_strtod_finite_erange_junk);
+
+ /* qemu_strtosz() tests */
g_test_add_func("/cutils/strtosz/simple",
test_qemu_strtosz_simple);
g_test_add_func("/cutils/strtosz/hex",
--
2.40.1
next prev parent reply other threads:[~2023-05-12 2:13 UTC|newest]
Thread overview: 48+ messages / expand[flat|nested] mbox.gz Atom feed top
2023-05-12 2:10 [PATCH v2 00/19] Fix qemu_strtosz() read-out-of-bounds Eric Blake
2023-05-12 2:10 ` [PATCH v2 01/19] test-cutils: Avoid g_assert in unit tests Eric Blake
2023-05-12 3:20 ` Philippe Mathieu-Daudé
2023-05-12 12:11 ` Eric Blake
2023-05-12 2:10 ` [PATCH v2 02/19] test-cutils: Use g_assert_cmpuint where appropriate Eric Blake
2023-05-12 2:10 ` [PATCH v2 03/19] test-cutils: Test integral qemu_strto* value on failures Eric Blake
2023-05-12 2:10 ` [PATCH v2 04/19] test-cutils: Test more integer corner cases Eric Blake
2023-05-19 14:27 ` Hanna Czenczek
2023-05-19 15:17 ` Eric Blake
2023-05-12 2:10 ` [PATCH v2 05/19] cutils: Fix wraparound parsing in qemu_strtoui Eric Blake
2023-05-18 13:34 ` Eric Blake
2023-05-19 14:42 ` Hanna Czenczek
2023-05-19 16:31 ` Eric Blake
2023-05-12 2:10 ` [PATCH v2 06/19] cutils: Document differences between parse_uint and qemu_strtou64 Eric Blake
2023-05-19 14:44 ` Hanna Czenczek
2023-05-12 2:10 ` [PATCH v2 07/19] cutils: Adjust signature of parse_uint[_full] Eric Blake
2023-05-12 16:25 ` Eric Blake
2023-05-19 14:51 ` Hanna Czenczek
2023-05-12 2:10 ` [PATCH v2 08/19] cutils: Allow NULL endptr in parse_uint() Eric Blake
2023-05-12 16:44 ` Eric Blake
2023-05-19 14:54 ` Hanna Czenczek
2023-05-12 2:10 ` Eric Blake [this message]
2023-05-19 15:05 ` [PATCH v2 09/19] test-cutils: Add coverage of qemu_strtod Hanna Czenczek
2023-05-19 17:52 ` Eric Blake
2023-05-22 10:56 ` Hanna Czenczek
2023-05-22 12:59 ` Eric Blake
2023-05-12 2:10 ` [PATCH v2 10/19] test-cutils: Prepare for upcoming semantic change in qemu_strtosz Eric Blake
2023-05-12 2:10 ` [PATCH v2 11/19] test-cutils: Refactor qemu_strtosz tests for less boilerplate Eric Blake
2023-05-19 15:13 ` Hanna Czenczek
2023-05-19 17:54 ` Eric Blake
2023-05-12 2:10 ` [PATCH v2 12/19] cutils: Allow NULL str in qemu_strtosz Eric Blake
2023-05-12 3:25 ` Philippe Mathieu-Daudé
2023-05-19 15:15 ` Hanna Czenczek
2023-05-12 2:10 ` [PATCH v2 13/19] numa: Check for qemu_strtosz_MiB error Eric Blake
2023-05-12 2:10 ` [PATCH v2 14/19] test-cutils: Add more coverage to qemu_strtosz11; rgb:1e1e/1e1e/1e1e Eric Blake
2023-05-19 15:26 ` [PATCH v2 14/19] test-cutils: Add more coverage to qemu_strtosz11;rgb:1e1e/1e1e/1e1e Hanna Czenczek
2023-05-19 18:02 ` Eric Blake
2023-05-12 2:10 ` [PATCH v2 15/19] cutils: Set value in all qemu_strtosz* error paths Eric Blake
2023-05-19 15:29 ` Hanna Czenczek
2023-05-12 2:10 ` [PATCH v2 16/19] cutils: Set value in all integral qemu_strto* " Eric Blake
2023-05-12 2:10 ` [PATCH v2 17/19] cutils: Use parse_uint in qemu_strtosz for negative rejection Eric Blake
2023-05-12 19:34 ` Eric Blake
2023-05-19 15:32 ` Hanna Czenczek
2023-05-12 2:10 ` [PATCH v2 18/19] cutils: Improve qemu_strtod* error paths Eric Blake
2023-05-18 13:47 ` Eric Blake
2023-05-12 2:10 ` [PATCH v2 19/19] cutils: Improve qemu_strtosz handling of fractions Eric Blake
2023-05-19 15:36 ` Hanna Czenczek
2023-05-12 12:24 ` [PATCH v2 00/19] Fix qemu_strtosz() read-out-of-bounds Eric Blake
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20230512021033.1378730-10-eblake@redhat.com \
--to=eblake@redhat.com \
--cc=armbru@redhat.com \
--cc=hreitz@redhat.com \
--cc=qemu-devel@nongnu.org \
--cc=richard.henderson@linaro.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).