Re: [Qemu-devel] [PATCH v4 5/5] net/announce: Expand test for stopping self announce

[Jason Wang <jasowang@redhat.com>]

On 2019/6/13 下午5:59, Dr. David Alan Gilbert (git) wrote:
> From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
>
> Expand self-announce test to check we can stop an announce timer.
> We set it up to send 300 packets, but after we receive
> the first one we tell it to stop.
>
> We error if:
>     a) We receive more than 30 of the packets
>     b) We're still receiving packets after a lot longer than the
>        30 seconds should have arrived
>
> Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
> ---
>   tests/virtio-net-test.c | 57 ++++++++++++++++++++++++++++++++++++++---
>   1 file changed, 54 insertions(+), 3 deletions(-)
>
> diff --git a/tests/virtio-net-test.c b/tests/virtio-net-test.c
> index 663cf7ea7e..3b49b431dc 100644
> --- a/tests/virtio-net-test.c
> +++ b/tests/virtio-net-test.c
> @@ -184,21 +184,72 @@ static void announce_self(void *obj, void *data, QGuestAllocator *t_alloc)
>       QDict *rsp;
>       int ret;
>       uint16_t *proto = (uint16_t *)&buffer[12];
> +    size_t total_received = 0;
> +    uint64_t start, now, last_rxt, deadline;
>   
> +    /* Send a set of packets over a few second period */
>       rsp = qmp("{ 'execute' : 'announce-self', "
>                     " 'arguments': {"
> -                      " 'initial': 50, 'max': 550,"
> -                      " 'rounds': 10, 'step': 50 } }");
> +                      " 'initial': 20, 'max': 100,"
> +                      " 'rounds': 300, 'step': 10, 'id': 'bob' } }");
>       assert(!qdict_haskey(rsp, "error"));
>       qobject_unref(rsp);
>   
> -    /* Catch the packet and make sure it's a RARP */
> +    /* Catch the first packet and make sure it's a RARP */
>       ret = qemu_recv(sv[0], &len, sizeof(len), 0);
>       g_assert_cmpint(ret, ==,  sizeof(len));
>       len = ntohl(len);
>   
>       ret = qemu_recv(sv[0], buffer, len, 0);
>       g_assert_cmpint(*proto, ==, htons(ETH_P_RARP));
> +
> +    /*
> +     * Stop the announcment by settings rounds to 0 on the
> +     * existing timer.
> +     */
> +    rsp = qmp("{ 'execute' : 'announce-self', "
> +                  " 'arguments': {"
> +                      " 'initial': 20, 'max': 100,"
> +                      " 'rounds': 0, 'step': 10, 'id': 'bob' } }");
> +    assert(!qdict_haskey(rsp, "error"));
> +    qobject_unref(rsp);
> +
> +    /* Now make sure the packets stop */
> +
> +    /* Times are in us */
> +    start = g_get_monotonic_time();
> +    /* 30 packets, max gap 100ms, * 2 for wiggle */
> +    deadline = start + 1000 * (100 * 30 * 2);
> +    last_rxt = start;
> +
> +    do {


while (ture) looks better here.


> +        int saved_err;
> +        ret = qemu_recv(sv[0], buffer, 60, MSG_DONTWAIT);
> +        saved_err = errno;
> +        now = g_get_monotonic_time();
> +        g_assert_cmpint(now, <, deadline);

The maximum gap allowed is 1000 * 100 * 4, and we allow at most 30 
packets that's 30 * 1000 * 100 * 4 which is 1200000.

But the deadline is 1000 * 100 * 30 * 2 which is 6000000.

Does this mean deadline is conflict with the assumption above?

Thanks


> +
> +        if (ret >= 0) {
> +            if (ret) {
> +                last_rxt = now;
> +            }
> +            total_received += ret;
> +
> +            /* Check it's not spewing loads */
> +            g_assert_cmpint(total_received, <, 60 * 30 * 2);
> +        } else {
> +            g_assert_cmpint(saved_err, ==, EAGAIN);
> +
> +            /* 400ms, i.e. 4 worst case gaps */
> +            if ((now - last_rxt) > (1000 * 100 * 4)) {
> +                /* Nothings arrived for a while - must have stopped */
> +                break;
> +            };
> +
> +            /* 100ms */
> +            g_usleep(1000 * 100);
> +        }
> +    } while (true);
>   }
>   
>   static void virtio_net_test_cleanup(void *sockets)