Commit 58e19e6e authored by Markus Armbruster's avatar Markus Armbruster Committed by Michael S. Tsirkin
Browse files

log: Clean up misuse of Range for -dfilter 



Range encodes an integer interval [a,b] as { begin = a, end = b + 1 },
where a \in [0,2^64-1] and b \in [1,2^64].  Thus, zero end is to be
interpreted as 2^64.

The implementation of -dfilter (commit 3514552e) uses Range
differently: it encodes [a,b] as { begin = a, end = b }.  The code
works, but it contradicts the specification of Range in range.h.

Switch to the specified representation.  Since it can't represent
[0,UINT64_MAX], we have to reject that now.  Add a test for it.

While we're rejecting anyway: observe that we reject -dfilter LOB..UPB
where LOB > UPB when UPB is zero, but happily create an empty Range
when it isn't.  Reject it then, too, and add a test for it.

While there, add a positive test for the problematic upper bound
UINT64_MAX.

Signed-off-by: default avatarMarkus Armbruster <armbru@redhat.com>
Reviewed-by: default avatarEric Blake <eblake@redhat.com>
Reviewed-by: default avatarMichael S. Tsirkin <mst@redhat.com>
Reviewed-by: default avatarMichael S. Tsirkin <mst@redhat.com>
Signed-off-by: default avatarMichael S. Tsirkin <mst@redhat.com>
parent 5178ecd8

tests/test-logging.c

+10 −0
Original line number Diff line number Diff line
@@ -68,6 +68,16 @@ static void test_parse_range(void) 
    g_assert(qemu_log_in_addr_range(0x2050));

    g_assert(qemu_log_in_addr_range(0x3050));



    qemu_set_dfilter_ranges("0xffffffffffffffff-1", &error_abort);

    g_assert(qemu_log_in_addr_range(UINT64_MAX));

    g_assert_false(qemu_log_in_addr_range(UINT64_MAX - 1));



    qemu_set_dfilter_ranges("0..0xffffffffffffffff", &err);

    error_free_or_abort(&err);



    qemu_set_dfilter_ranges("2..1", &err);

    error_free_or_abort(&err);



    qemu_set_dfilter_ranges("0x1000+onehundred", &err);

    error_free_or_abort(&err);

util/log.c

+15 −13
Original line number Diff line number Diff line
@@ -131,8 +131,8 @@ bool qemu_log_in_addr_range(uint64_t addr) 
    if (debug_regions) {

        int i = 0;

        for (i = 0; i < debug_regions->len; i++) {

            struct Range *range = &g_array_index(debug_regions, Range, i);

            if (addr >= range->begin && addr <= range->end) {

            Range *range = &g_array_index(debug_regions, Range, i);

            if (addr >= range->begin && addr <= range->end - 1) {

                return true;

            }

        }
@@ -158,7 +158,7 @@ void qemu_set_dfilter_ranges(const char *filter_spec, Error **errp) 
    for (i = 0; ranges[i]; i++) {

        const char *r = ranges[i];

        const char *range_op, *r2, *e;

        uint64_t r1val, r2val;

        uint64_t r1val, r2val, lob, upb;

        struct Range range;



        range_op = strstr(r, "-");
@@ -187,27 +187,29 @@ void qemu_set_dfilter_ranges(const char *filter_spec, Error **errp) 
                       (int)(r2 - range_op), range_op);

            goto out;

        }

        if (r2val == 0) {

            error_setg(errp, "Invalid range");

            goto out;

        }



        switch (*range_op) {

        case '+':

            range.begin = r1val;

            range.end = r1val + (r2val - 1);

            lob = r1val;

            upb = r1val + r2val - 1;

            break;

        case '-':

            range.end = r1val;

            range.begin = r1val - (r2val - 1);

            upb = r1val;

            lob = r1val - (r2val - 1);

            break;

        case '.':

            range.begin = r1val;

            range.end = r2val;

            lob = r1val;

            upb = r2val;

            break;

        default:

            g_assert_not_reached();

        }

        if (lob > upb || (lob == 0 && upb == UINT64_MAX)) {

            error_setg(errp, "Invalid range");

            goto out;

        }

        range.begin = lob;

        range.end = upb + 1;

        g_array_append_val(debug_regions, range);

    }

out: