Commit 0984a157 authored by Peter Maydell's avatar Peter Maydell
Browse files

Merge remote-tracking branch 'remotes/jasowang/tags/net-pull-request' into staging 



# gpg: Signature made Tue 05 Mar 2019 07:06:28 GMT
# gpg:                using RSA key EF04965B398D6211
# gpg: Good signature from "Jason Wang (Jason Wang on RedHat) <jasowang@redhat.com>" [marginal]
# gpg: WARNING: This key is not certified with sufficiently trusted signatures!
# gpg:          It is not certain that the signature belongs to the owner.
# Primary key fingerprint: 215D 46F4 8246 689E C77F  3562 EF04 965B 398D 6211

* remotes/jasowang/tags/net-pull-request:
  tests: Add a test for qemu self announcements
  hmp: Add hmp_announce_self
  qmp: Add announce-self command
  virtio-net: Allow qemu_announce_self to trigger virtio announcements
  net: Add a network device specific self-announcement ability
  migration: Switch to using announce timer
  virtio-net: Switch to using announce timer
  migration: Add announce parameters
  net: Introduce announce timer
  net: netmap: improve netmap_receive_iov()
  net: netmap: simplify netmap_receive()
  net: netmap: small improvements netmap_send()
  net/colo-compare.c: Remove duplicated code

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents b6179aaf 4b9b7000

hmp-commands.hx

+16 −0
Original line number Diff line number Diff line
@@ -936,6 +936,22 @@ Bug: can screw up when the buffer contains invalid UTF-8 sequences, 
NUL characters, after the ring buffer lost data, and when reading

stops because the size limit is reached.



ETEXI



    {

        .name       = "announce_self",

        .args_type  = "",

        .params     = "",

        .help       = "Trigger GARP/RARP announcements",

        .cmd        = hmp_announce_self,

    },



STEXI

@item announce_self

@findex announce_self

Trigger a round of GARP/RARP broadcasts; this is useful for explicitly updating the

network infrastructure after a reconfiguration or some forms of migration.

The timings of the round are set by the migration announce parameters.

ETEXI



    {

hmp.c

+33 −0
Original line number Diff line number Diff line
@@ -334,6 +334,18 @@ void hmp_info_migrate_parameters(Monitor *mon, const QDict *qdict) 
    params = qmp_query_migrate_parameters(NULL);



    if (params) {

        monitor_printf(mon, "%s: %" PRIu64 " ms\n",

            MigrationParameter_str(MIGRATION_PARAMETER_ANNOUNCE_INITIAL),

            params->announce_initial);

        monitor_printf(mon, "%s: %" PRIu64 " ms\n",

            MigrationParameter_str(MIGRATION_PARAMETER_ANNOUNCE_MAX),

            params->announce_max);

        monitor_printf(mon, "%s: %" PRIu64 "\n",

            MigrationParameter_str(MIGRATION_PARAMETER_ANNOUNCE_ROUNDS),

            params->announce_rounds);

        monitor_printf(mon, "%s: %" PRIu64 " ms\n",

            MigrationParameter_str(MIGRATION_PARAMETER_ANNOUNCE_STEP),

            params->announce_step);

        assert(params->has_compress_level);

        monitor_printf(mon, "%s: %u\n",

            MigrationParameter_str(MIGRATION_PARAMETER_COMPRESS_LEVEL),
@@ -1558,6 +1570,11 @@ void hmp_info_snapshots(Monitor *mon, const QDict *qdict) 


}



void hmp_announce_self(Monitor *mon, const QDict *qdict)

{

    qmp_announce_self(migrate_announce_params(), NULL);

}



void hmp_migrate_cancel(Monitor *mon, const QDict *qdict)

{

    qmp_migrate_cancel(NULL);
@@ -1757,6 +1774,22 @@ void hmp_migrate_set_parameter(Monitor *mon, const QDict *qdict) 
        p->has_max_postcopy_bandwidth = true;

        visit_type_size(v, param, &p->max_postcopy_bandwidth, &err);

        break;

    case MIGRATION_PARAMETER_ANNOUNCE_INITIAL:

        p->has_announce_initial = true;

        visit_type_size(v, param, &p->announce_initial, &err);

        break;

    case MIGRATION_PARAMETER_ANNOUNCE_MAX:

        p->has_announce_max = true;

        visit_type_size(v, param, &p->announce_max, &err);

        break;

    case MIGRATION_PARAMETER_ANNOUNCE_ROUNDS:

        p->has_announce_rounds = true;

        visit_type_size(v, param, &p->announce_rounds, &err);

        break;

    case MIGRATION_PARAMETER_ANNOUNCE_STEP:

        p->has_announce_step = true;

        visit_type_size(v, param, &p->announce_step, &err);

        break;

    default:

        assert(0);

    }

hmp.h

+1 −0
Original line number Diff line number Diff line
@@ -46,6 +46,7 @@ void hmp_sync_profile(Monitor *mon, const QDict *qdict); 
void hmp_system_reset(Monitor *mon, const QDict *qdict);

void hmp_system_powerdown(Monitor *mon, const QDict *qdict);

void hmp_exit_preconfig(Monitor *mon, const QDict *qdict);

void hmp_announce_self(Monitor *mon, const QDict *qdict);

void hmp_cpu(Monitor *mon, const QDict *qdict);

void hmp_memsave(Monitor *mon, const QDict *qdict);

void hmp_pmemsave(Monitor *mon, const QDict *qdict);

hw/net/trace-events

+6 −0
Original line number Diff line number Diff line
@@ -359,3 +359,9 @@ sunhme_rx_filter_reject(void) "rejecting incoming frame" 
sunhme_rx_filter_accept(void) "accepting incoming frame"

sunhme_rx_desc(uint32_t addr, int offset, uint32_t status, int len, int cr, int nr) "addr 0x%"PRIx32"(+0x%x) status 0x%"PRIx32 " len %d (ring %d/%d)"

sunhme_rx_xsum_calc(uint16_t xsum) "calculated incoming xsum as 0x%x"



# hw/net/virtio-net.c

virtio_net_announce_notify(void) ""

virtio_net_announce_timer(int round) "%d"

virtio_net_handle_announce(int round) "%d"

virtio_net_post_load_device(void)

hw/net/virtio-net.c

+54 −15
Original line number Diff line number Diff line
@@ -21,12 +21,14 @@ 
#include "qemu/timer.h"

#include "hw/virtio/virtio-net.h"

#include "net/vhost_net.h"

#include "net/announce.h"

#include "hw/virtio/virtio-bus.h"

#include "qapi/error.h"

#include "qapi/qapi-events-net.h"

#include "hw/virtio/virtio-access.h"

#include "migration/misc.h"

#include "standard-headers/linux/ethtool.h"

#include "trace.h"



#define VIRTIO_NET_VM_VERSION    11
@@ -148,14 +150,42 @@ static bool virtio_net_started(VirtIONet *n, uint8_t status) 
        (n->status & VIRTIO_NET_S_LINK_UP) && vdev->vm_running;

}



static void virtio_net_announce_notify(VirtIONet *net)

{

    VirtIODevice *vdev = VIRTIO_DEVICE(net);

    trace_virtio_net_announce_notify();



    net->status |= VIRTIO_NET_S_ANNOUNCE;

    virtio_notify_config(vdev);

}



static void virtio_net_announce_timer(void *opaque)

{

    VirtIONet *n = opaque;

    trace_virtio_net_announce_timer(n->announce_timer.round);



    n->announce_timer.round--;

    virtio_net_announce_notify(n);

}



static void virtio_net_announce(NetClientState *nc)

{

    VirtIONet *n = qemu_get_nic_opaque(nc);

    VirtIODevice *vdev = VIRTIO_DEVICE(n);



    n->announce_counter--;

    n->status |= VIRTIO_NET_S_ANNOUNCE;

    virtio_notify_config(vdev);

    /*

     * Make sure the virtio migration announcement timer isn't running

     * If it is, let it trigger announcement so that we do not cause

     * confusion.

     */

    if (n->announce_timer.round) {

        return;

    }



    if (virtio_vdev_has_feature(vdev, VIRTIO_NET_F_GUEST_ANNOUNCE) &&

        virtio_vdev_has_feature(vdev, VIRTIO_NET_F_CTRL_VQ)) {

            virtio_net_announce_notify(n);

    }

}



static void virtio_net_vhost_status(VirtIONet *n, uint8_t status)
@@ -467,8 +497,8 @@ static void virtio_net_reset(VirtIODevice *vdev) 
    n->nobcast = 0;

    /* multiqueue is disabled by default */

    n->curr_queues = 1;

    timer_del(n->announce_timer);

    n->announce_counter = 0;

    timer_del(n->announce_timer.tm);

    n->announce_timer.round = 0;

    n->status &= ~VIRTIO_NET_S_ANNOUNCE;



    /* Flush any MAC and VLAN filter table state */
@@ -964,13 +994,12 @@ static int virtio_net_handle_vlan_table(VirtIONet *n, uint8_t cmd, 
static int virtio_net_handle_announce(VirtIONet *n, uint8_t cmd,

                                      struct iovec *iov, unsigned int iov_cnt)

{

    trace_virtio_net_handle_announce(n->announce_timer.round);

    if (cmd == VIRTIO_NET_CTRL_ANNOUNCE_ACK &&

        n->status & VIRTIO_NET_S_ANNOUNCE) {

        n->status &= ~VIRTIO_NET_S_ANNOUNCE;

        if (n->announce_counter) {

            timer_mod(n->announce_timer,

                      qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) +

                      self_announce_delay(n->announce_counter));

        if (n->announce_timer.round) {

            qemu_announce_timer_step(&n->announce_timer);

        }

        return VIRTIO_NET_OK;

    } else {
@@ -2286,6 +2315,7 @@ static int virtio_net_post_load_device(void *opaque, int version_id) 
    VirtIODevice *vdev = VIRTIO_DEVICE(n);

    int i, link_down;



    trace_virtio_net_post_load_device();

    virtio_net_set_mrg_rx_bufs(n, n->mergeable_rx_bufs,

                               virtio_vdev_has_feature(vdev,

                                                       VIRTIO_F_VERSION_1));
@@ -2322,8 +2352,15 @@ static int virtio_net_post_load_device(void *opaque, int version_id) 


    if (virtio_vdev_has_feature(vdev, VIRTIO_NET_F_GUEST_ANNOUNCE) &&

        virtio_vdev_has_feature(vdev, VIRTIO_NET_F_CTRL_VQ)) {

        n->announce_counter = SELF_ANNOUNCE_ROUNDS;

        timer_mod(n->announce_timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL));

        qemu_announce_timer_reset(&n->announce_timer, migrate_announce_params(),

                                  QEMU_CLOCK_VIRTUAL,

                                  virtio_net_announce_timer, n);

        if (n->announce_timer.round) {

            timer_mod(n->announce_timer.tm,

                      qemu_clock_get_ms(n->announce_timer.type));

        } else {

            qemu_announce_timer_del(&n->announce_timer);

        }

    }



    return 0;
@@ -2546,6 +2583,7 @@ static NetClientInfo net_virtio_info = { 
    .receive = virtio_net_receive,

    .link_status_changed = virtio_net_set_link_status,

    .query_rx_filter = virtio_net_query_rxfilter,

    .announce = virtio_net_announce,

};



static bool virtio_net_guest_notifier_pending(VirtIODevice *vdev, int idx)
@@ -2679,8 +2717,10 @@ static void virtio_net_device_realize(DeviceState *dev, Error **errp) 
    qemu_macaddr_default_if_unset(&n->nic_conf.macaddr);

    memcpy(&n->mac[0], &n->nic_conf.macaddr, sizeof(n->mac));

    n->status = VIRTIO_NET_S_LINK_UP;

    n->announce_timer = timer_new_ms(QEMU_CLOCK_VIRTUAL,

    qemu_announce_timer_reset(&n->announce_timer, migrate_announce_params(),

                              QEMU_CLOCK_VIRTUAL,

                              virtio_net_announce_timer, n);

    n->announce_timer.round = 0;



    if (n->netclient_type) {

        /*
@@ -2743,8 +2783,7 @@ static void virtio_net_device_unrealize(DeviceState *dev, Error **errp) 
        virtio_net_del_queue(n, i);

    }



    timer_del(n->announce_timer);

    timer_free(n->announce_timer);

    qemu_announce_timer_del(&n->announce_timer);

    g_free(n->vqs);

    qemu_del_nic(n->nic);

    virtio_net_rsc_cleanup(n);