Commit bc3fbad8 authored by Peter Maydell's avatar Peter Maydell
Browse files

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



Net patches

# gpg: Signature made Tue 25 Feb 2014 13:32:33 GMT using RSA key ID 81AB73C8
# gpg: Good signature from "Stefan Hajnoczi <stefanha@redhat.com>"
# gpg:                 aka "Stefan Hajnoczi <stefanha@gmail.com>"
# gpg: WARNING: This key is not certified with a trusted signature!
# gpg:          There is no indication that the signature belongs to the owner.
# Primary key fingerprint: 8695 A8BF D3F9 7CDA AC35  775A 9CA4 ABB3 81AB 73C8

* remotes/stefanha/tags/net-pull-request:
  virtio-net: use qemu_get_queue() where possible
  vhost_net: use offload API instead of bypassing it
  net: remove implicit peer from offload API
  net: Disable netmap backend when not supported
  net: add offloading support to netmap backend
  net: make tap offloading callbacks static
  net: virtio-net and vmxnet3 use offloading API
  net: TAP uses NetClientInfo offloading callbacks
  net: extend NetClientInfo for offloading
  net: change vnet-hdr TAP prototypes
  opencores_eth: flush queue whenever can_receive can go from false to true

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents 28c05edf ad37bb3b

configure

+9 −1
Original line number Diff line number Diff line
@@ -2249,13 +2249,21 @@ EOF 
fi



##########################################

# netmap headers probe

# netmap support probe

# Apart from looking for netmap headers, we make sure that the host API version

# supports the netmap backend (>=11). The upper bound (15) is meant to simulate

# a minor/major version number. Minor new features will be marked with values up

# to 15, and if something happens that requires a change to the backend we will

# move above 15, submit the backend fixes and modify this two bounds.

if test "$netmap" != "no" ; then

  cat > $TMPC << EOF

#include <inttypes.h>

#include <net/if.h>

#include <net/netmap.h>

#include <net/netmap_user.h>

#if (NETMAP_API < 11) || (NETMAP_API > 15)

#error

#endif

int main(void) { return 0; }

EOF

  if compile_prog "" "" ; then

hw/net/vhost_net.c

+3 −3
Original line number Diff line number Diff line
@@ -106,7 +106,7 @@ struct vhost_net *vhost_net_init(NetClientState *backend, int devfd, 
        goto fail;

    }

    net->nc = backend;

    net->dev.backend_features = tap_has_vnet_hdr(backend) ? 0 :

    net->dev.backend_features = qemu_has_vnet_hdr(backend) ? 0 :

        (1 << VHOST_NET_F_VIRTIO_NET_HDR);

    net->backend = r;
@@ -117,7 +117,7 @@ struct vhost_net *vhost_net_init(NetClientState *backend, int devfd, 
    if (r < 0) {

        goto fail;

    }

    if (!tap_has_vnet_hdr_len(backend,

    if (!qemu_has_vnet_hdr_len(backend,

                               sizeof(struct virtio_net_hdr_mrg_rxbuf))) {

        net->dev.features &= ~(1 << VIRTIO_NET_F_MRG_RXBUF);

    }

hw/net/virtio-net.c

+6 −10
Original line number Diff line number Diff line
@@ -325,11 +325,7 @@ static void peer_test_vnet_hdr(VirtIONet *n) 
        return;

    }



    if (nc->peer->info->type != NET_CLIENT_OPTIONS_KIND_TAP) {

        return;

    }



    n->has_vnet_hdr = tap_has_vnet_hdr(nc->peer);

    n->has_vnet_hdr = qemu_has_vnet_hdr(nc->peer);

}



static int peer_has_vnet_hdr(VirtIONet *n)
@@ -342,7 +338,7 @@ static int peer_has_ufo(VirtIONet *n) 
    if (!peer_has_vnet_hdr(n))

        return 0;



    n->has_ufo = tap_has_ufo(qemu_get_queue(n->nic)->peer);

    n->has_ufo = qemu_has_ufo(qemu_get_queue(n->nic)->peer);



    return n->has_ufo;

}
@@ -361,8 +357,8 @@ static void virtio_net_set_mrg_rx_bufs(VirtIONet *n, int mergeable_rx_bufs) 
        nc = qemu_get_subqueue(n->nic, i);



        if (peer_has_vnet_hdr(n) &&

            tap_has_vnet_hdr_len(nc->peer, n->guest_hdr_len)) {

            tap_set_vnet_hdr_len(nc->peer, n->guest_hdr_len);

            qemu_has_vnet_hdr_len(nc->peer, n->guest_hdr_len)) {

            qemu_set_vnet_hdr_len(nc->peer, n->guest_hdr_len);

            n->host_hdr_len = n->guest_hdr_len;

        }

    }
@@ -463,7 +459,7 @@ static uint32_t virtio_net_bad_features(VirtIODevice *vdev) 


static void virtio_net_apply_guest_offloads(VirtIONet *n)

{

    tap_set_offload(qemu_get_subqueue(n->nic, 0)->peer,

    qemu_set_offload(qemu_get_queue(n->nic)->peer,

            !!(n->curr_guest_offloads & (1ULL << VIRTIO_NET_F_GUEST_CSUM)),

            !!(n->curr_guest_offloads & (1ULL << VIRTIO_NET_F_GUEST_TSO4)),

            !!(n->curr_guest_offloads & (1ULL << VIRTIO_NET_F_GUEST_TSO6)),
@@ -1544,7 +1540,7 @@ static void virtio_net_device_realize(DeviceState *dev, Error **errp) 
    peer_test_vnet_hdr(n);

    if (peer_has_vnet_hdr(n)) {

        for (i = 0; i < n->max_queues; i++) {

            tap_using_vnet_hdr(qemu_get_subqueue(n->nic, i)->peer, true);

            qemu_using_vnet_hdr(qemu_get_subqueue(n->nic, i)->peer, true);

        }

        n->host_hdr_len = sizeof(struct virtio_net_hdr);

    } else {

hw/net/vmxnet3.c

+10 −12
Original line number Diff line number Diff line
@@ -1290,7 +1290,7 @@ static void vmxnet3_update_features(VMXNET3State *s) 
              s->lro_supported, rxcso_supported,

              s->rx_vlan_stripping);

    if (s->peer_has_vhdr) {

        tap_set_offload(qemu_get_queue(s->nic)->peer,

        qemu_set_offload(qemu_get_queue(s->nic)->peer,

                         rxcso_supported,

                         s->lro_supported,

                         s->lro_supported,
@@ -1883,11 +1883,9 @@ static NetClientInfo net_vmxnet3_info = { 


static bool vmxnet3_peer_has_vnet_hdr(VMXNET3State *s)

{

    NetClientState *peer = qemu_get_queue(s->nic)->peer;

    NetClientState *nc = qemu_get_queue(s->nic);



    if ((NULL != peer)                              &&

        (peer->info->type == NET_CLIENT_OPTIONS_KIND_TAP)   &&

        tap_has_vnet_hdr(peer)) {

    if (qemu_has_vnet_hdr(nc->peer)) {

        return true;

    }
@@ -1935,10 +1933,10 @@ static void vmxnet3_net_init(VMXNET3State *s) 
    s->lro_supported = false;



    if (s->peer_has_vhdr) {

        tap_set_vnet_hdr_len(qemu_get_queue(s->nic)->peer,

        qemu_set_vnet_hdr_len(qemu_get_queue(s->nic)->peer,

            sizeof(struct virtio_net_hdr));



        tap_using_vnet_hdr(qemu_get_queue(s->nic)->peer, 1);

        qemu_using_vnet_hdr(qemu_get_queue(s->nic)->peer, 1);

    }



    qemu_format_nic_info_str(qemu_get_queue(s->nic), s->conf.macaddr.a);

include/net/net.h

+19 −0
Original line number Diff line number Diff line
@@ -50,6 +50,12 @@ typedef void (NetCleanup) (NetClientState *); 
typedef void (LinkStatusChanged)(NetClientState *);

typedef void (NetClientDestructor)(NetClientState *);

typedef RxFilterInfo *(QueryRxFilter)(NetClientState *);

typedef bool (HasUfo)(NetClientState *);

typedef bool (HasVnetHdr)(NetClientState *);

typedef bool (HasVnetHdrLen)(NetClientState *, int);

typedef void (UsingVnetHdr)(NetClientState *, bool);

typedef void (SetOffload)(NetClientState *, int, int, int, int, int);

typedef void (SetVnetHdrLen)(NetClientState *, int);



typedef struct NetClientInfo {

    NetClientOptionsKind type;
@@ -62,6 +68,12 @@ typedef struct NetClientInfo { 
    LinkStatusChanged *link_status_changed;

    QueryRxFilter *query_rx_filter;

    NetPoll *poll;

    HasUfo *has_ufo;

    HasVnetHdr *has_vnet_hdr;

    HasVnetHdrLen *has_vnet_hdr_len;

    UsingVnetHdr *using_vnet_hdr;

    SetOffload *set_offload;

    SetVnetHdrLen *set_vnet_hdr_len;

} NetClientInfo;



struct NetClientState {
@@ -120,6 +132,13 @@ ssize_t qemu_send_packet_async(NetClientState *nc, const uint8_t *buf, 
void qemu_purge_queued_packets(NetClientState *nc);

void qemu_flush_queued_packets(NetClientState *nc);

void qemu_format_nic_info_str(NetClientState *nc, uint8_t macaddr[6]);

bool qemu_has_ufo(NetClientState *nc);

bool qemu_has_vnet_hdr(NetClientState *nc);

bool qemu_has_vnet_hdr_len(NetClientState *nc, int len);

void qemu_using_vnet_hdr(NetClientState *nc, bool enable);

void qemu_set_offload(NetClientState *nc, int csum, int tso4, int tso6,

                      int ecn, int ufo);

void qemu_set_vnet_hdr_len(NetClientState *nc, int len);

void qemu_macaddr_default_if_unset(MACAddr *macaddr);

int qemu_show_nic_models(const char *arg, const char *const *models);

void qemu_check_nic_model(NICInfo *nd, const char *model);