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 {
+ 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);
+
+ 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)
--
2.21.0
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)
* Jason Wang (jasowang@redhat.com) wrote:
>
> 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.
OK, changed.
>
> > + 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?
I've changed deadline to match (i.e. * 4) - but it's only a worst-case
that we shouldn't hit anyway; I'm expecting it to actually stop after
1 or 2 packets worst case, the *4 in the maximum gap is there just to
deal with a busy system that takes a bit longer.
Dave
> 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)
--
Dr. David Alan Gilbert / dgilbert@redhat.com / Manchester, UK
© 2016 - 2026 Red Hat, Inc.