openkylin
/
qemu
mirror of https://gitee.com/openkylin/qemu.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity

net_pkt: Name vmxnet3 packet abstractions more generic 

This patch drops "vmx" prefix from packet abstractions names
to emphasize the fact they are generic and not tied to any
specific network device.

These abstractions will be reused by e1000e emulation implementation
introduced by following patches so their names need generalization.

This patch (except renamed files, adjusted comments and changes in MAINTAINTERS)
was produced by:

git grep -lz 'vmxnet_tx_pkt' | xargs -0 perl -i'' -pE "s/vmxnet_tx_pkt/net_tx_pkt/g"
git grep -lz 'vmxnet_rx_pkt' | xargs -0 perl -i'' -pE "s/vmxnet_rx_pkt/net_rx_pkt/g"
git grep -lz 'VmxnetTxPkt' | xargs -0 perl -i'' -pE "s/VmxnetTxPkt/NetTxPkt/g"
git grep -lz 'VMXNET_TX_PKT' | xargs -0 perl -i'' -pE "s/VMXNET_TX_PKT/NET_TX_PKT/g"
git grep -lz 'VmxnetRxPkt' | xargs -0 perl -i'' -pE "s/VmxnetRxPkt/NetRxPkt/g"
git grep -lz 'VMXNET_RX_PKT' | xargs -0 perl -i'' -pE "s/VMXNET_RX_PKT/NET_RX_PKT/g"
sed -ie 's/VMXNET_/NET_/g' hw/net/vmxnet_rx_pkt.c
sed -ie 's/VMXNET_/NET_/g' hw/net/vmxnet_tx_pkt.c

Signed-off-by: Dmitry Fleytman <dmitry.fleytman@ravellosystems.com>
Signed-off-by: Leonid Bloch <leonid.bloch@ravellosystems.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
This commit is contained in:
Dmitry Fleytman 2016-06-01 11:23:39 +03:00 committed by Jason Wang
parent ab64787201
commit 605d52e62f
8 changed files with 206 additions and 198 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
MAINTAINERS
View File

@ -953,6 +953,14 @@ S: Maintained
F: hw/*/xilinx_* F: hw/*/xilinx_*
F: include/hw/xilinx.h F: include/hw/xilinx.h
Network packet abstractions
M: Dmitry Fleytman <dmitry@daynix.com>
S: Maintained
F: include/net/eth.h
F: net/eth.c
F: hw/net/net_rx_pkt*
F: hw/net/net_tx_pkt*
Vmware Vmware
M: Dmitry Fleytman <dmitry@daynix.com> M: Dmitry Fleytman <dmitry@daynix.com>
S: Maintained S: Maintained

2
hw/net/Makefile.objs
View File

@ -8,7 +8,7 @@ common-obj-$(CONFIG_PCNET_PCI) += pcnet-pci.o
common-obj-$(CONFIG_PCNET_COMMON) += pcnet.o common-obj-$(CONFIG_PCNET_COMMON) += pcnet.o
common-obj-$(CONFIG_E1000_PCI) += e1000.o common-obj-$(CONFIG_E1000_PCI) += e1000.o
common-obj-$(CONFIG_RTL8139_PCI) += rtl8139.o common-obj-$(CONFIG_RTL8139_PCI) += rtl8139.o
common-obj-$(CONFIG_VMXNET3_PCI) += vmxnet_tx_pkt.o vmxnet_rx_pkt.o common-obj-$(CONFIG_VMXNET3_PCI) += net_tx_pkt.o net_rx_pkt.o
common-obj-$(CONFIG_VMXNET3_PCI) += vmxnet3.o common-obj-$(CONFIG_VMXNET3_PCI) += vmxnet3.o
common-obj-$(CONFIG_SMC91C111) += smc91c111.o common-obj-$(CONFIG_SMC91C111) += smc91c111.o

46
hw/net/vmxnet_rx_pkt.c → hw/net/net_rx_pkt.c
View File

@ -1,5 +1,5 @@
/* /*
* QEMU VMWARE VMXNET* paravirtual NICs - RX packets abstractions * QEMU RX packets abstractions
* *
* Copyright (c) 2012 Ravello Systems LTD (http://ravellosystems.com) * Copyright (c) 2012 Ravello Systems LTD (http://ravellosystems.com)
* *
@ -16,7 +16,7 @@
*/ */
#include "qemu/osdep.h" #include "qemu/osdep.h"
#include "vmxnet_rx_pkt.h" #include "net_rx_pkt.h"
#include "net/eth.h" #include "net/eth.h"
#include "qemu-common.h" #include "qemu-common.h"
#include "qemu/iov.h" #include "qemu/iov.h"
@ -28,12 +28,12 @@
* in case of VLAN tag stripping * in case of VLAN tag stripping
* and payload received from QEMU - in any case * and payload received from QEMU - in any case
*/ */
#define VMXNET_MAX_RX_PACKET_FRAGMENTS (2) #define NET_MAX_RX_PACKET_FRAGMENTS (2)
struct VmxnetRxPkt { struct NetRxPkt {
struct virtio_net_hdr virt_hdr; struct virtio_net_hdr virt_hdr;
uint8_t ehdr_buf[ETH_MAX_L2_HDR_LEN]; uint8_t ehdr_buf[ETH_MAX_L2_HDR_LEN];
struct iovec vec[VMXNET_MAX_RX_PACKET_FRAGMENTS]; struct iovec vec[NET_MAX_RX_PACKET_FRAGMENTS];
uint16_t vec_len; uint16_t vec_len;
uint32_t tot_len; uint32_t tot_len;
uint16_t tci; uint16_t tci;
@ -48,25 +48,25 @@ struct VmxnetRxPkt {
bool istcp; bool istcp;
}; };
void vmxnet_rx_pkt_init(struct VmxnetRxPkt **pkt, bool has_virt_hdr) void net_rx_pkt_init(struct NetRxPkt **pkt, bool has_virt_hdr)
{ {
struct VmxnetRxPkt *p = g_malloc0(sizeof *p); struct NetRxPkt *p = g_malloc0(sizeof *p);
p->has_virt_hdr = has_virt_hdr; p->has_virt_hdr = has_virt_hdr;
*pkt = p; *pkt = p;
} }
void vmxnet_rx_pkt_uninit(struct VmxnetRxPkt *pkt) void net_rx_pkt_uninit(struct NetRxPkt *pkt)
{ {
g_free(pkt); g_free(pkt);
} }
struct virtio_net_hdr *vmxnet_rx_pkt_get_vhdr(struct VmxnetRxPkt *pkt) struct virtio_net_hdr *net_rx_pkt_get_vhdr(struct NetRxPkt *pkt)
{ {
assert(pkt); assert(pkt);
return &pkt->virt_hdr; return &pkt->virt_hdr;
} }
void vmxnet_rx_pkt_attach_data(struct VmxnetRxPkt *pkt, const void *data, void net_rx_pkt_attach_data(struct NetRxPkt *pkt, const void *data,
size_t len, bool strip_vlan) size_t len, bool strip_vlan)
{ {
uint16_t tci = 0; uint16_t tci = 0;
@ -95,10 +95,10 @@ void vmxnet_rx_pkt_attach_data(struct VmxnetRxPkt *pkt, const void *data,
pkt->tci = tci; pkt->tci = tci;
} }
void vmxnet_rx_pkt_dump(struct VmxnetRxPkt *pkt) void net_rx_pkt_dump(struct NetRxPkt *pkt)
{ {
#ifdef VMXNET_RX_PKT_DEBUG #ifdef NET_RX_PKT_DEBUG
VmxnetRxPkt *pkt = (VmxnetRxPkt *)pkt; NetRxPkt *pkt = (NetRxPkt *)pkt;
assert(pkt); assert(pkt);
printf("RX PKT: tot_len: %d, vlan_stripped: %d, vlan_tag: %d\n", printf("RX PKT: tot_len: %d, vlan_stripped: %d, vlan_tag: %d\n",
@ -106,7 +106,7 @@ void vmxnet_rx_pkt_dump(struct VmxnetRxPkt *pkt)
#endif #endif
} }
void vmxnet_rx_pkt_set_packet_type(struct VmxnetRxPkt *pkt, void net_rx_pkt_set_packet_type(struct NetRxPkt *pkt,
eth_pkt_types_e packet_type) eth_pkt_types_e packet_type)
{ {
assert(pkt); assert(pkt);
@ -115,21 +115,21 @@ void vmxnet_rx_pkt_set_packet_type(struct VmxnetRxPkt *pkt,
} }
eth_pkt_types_e vmxnet_rx_pkt_get_packet_type(struct VmxnetRxPkt *pkt) eth_pkt_types_e net_rx_pkt_get_packet_type(struct NetRxPkt *pkt)
{ {
assert(pkt); assert(pkt);
return pkt->packet_type; return pkt->packet_type;
} }
size_t vmxnet_rx_pkt_get_total_len(struct VmxnetRxPkt *pkt) size_t net_rx_pkt_get_total_len(struct NetRxPkt *pkt)
{ {
assert(pkt); assert(pkt);
return pkt->tot_len; return pkt->tot_len;
} }
void vmxnet_rx_pkt_set_protocols(struct VmxnetRxPkt *pkt, const void *data, void net_rx_pkt_set_protocols(struct NetRxPkt *pkt, const void *data,
size_t len) size_t len)
{ {
assert(pkt); assert(pkt);
@ -138,7 +138,7 @@ void vmxnet_rx_pkt_set_protocols(struct VmxnetRxPkt *pkt, const void *data,
&pkt->isudp, &pkt->istcp); &pkt->isudp, &pkt->istcp);
} }
void vmxnet_rx_pkt_get_protocols(struct VmxnetRxPkt *pkt, void net_rx_pkt_get_protocols(struct NetRxPkt *pkt,
bool *isip4, bool *isip6, bool *isip4, bool *isip6,
bool *isudp, bool *istcp) bool *isudp, bool *istcp)
{ {
@ -150,14 +150,14 @@ void vmxnet_rx_pkt_get_protocols(struct VmxnetRxPkt *pkt,
*istcp = pkt->istcp; *istcp = pkt->istcp;
} }
struct iovec *vmxnet_rx_pkt_get_iovec(struct VmxnetRxPkt *pkt) struct iovec *net_rx_pkt_get_iovec(struct NetRxPkt *pkt)
{ {
assert(pkt); assert(pkt);
return pkt->vec; return pkt->vec;
} }
void vmxnet_rx_pkt_set_vhdr(struct VmxnetRxPkt *pkt, void net_rx_pkt_set_vhdr(struct NetRxPkt *pkt,
struct virtio_net_hdr *vhdr) struct virtio_net_hdr *vhdr)
{ {
assert(pkt); assert(pkt);
@ -165,21 +165,21 @@ void vmxnet_rx_pkt_set_vhdr(struct VmxnetRxPkt *pkt,
memcpy(&pkt->virt_hdr, vhdr, sizeof pkt->virt_hdr); memcpy(&pkt->virt_hdr, vhdr, sizeof pkt->virt_hdr);
} }
bool vmxnet_rx_pkt_is_vlan_stripped(struct VmxnetRxPkt *pkt) bool net_rx_pkt_is_vlan_stripped(struct NetRxPkt *pkt)
{ {
assert(pkt); assert(pkt);
return pkt->vlan_stripped; return pkt->vlan_stripped;
} }
bool vmxnet_rx_pkt_has_virt_hdr(struct VmxnetRxPkt *pkt) bool net_rx_pkt_has_virt_hdr(struct NetRxPkt *pkt)
{ {
assert(pkt); assert(pkt);
return pkt->has_virt_hdr; return pkt->has_virt_hdr;
} }
uint16_t vmxnet_rx_pkt_get_vlan_tag(struct VmxnetRxPkt *pkt) uint16_t net_rx_pkt_get_vlan_tag(struct NetRxPkt *pkt)
{ {
assert(pkt); assert(pkt);

40
hw/net/vmxnet_rx_pkt.h → hw/net/net_rx_pkt.h
View File

@ -1,5 +1,5 @@
/* /*
* QEMU VMWARE VMXNET* paravirtual NICs - RX packets abstraction * QEMU RX packets abstraction
* *
* Copyright (c) 2012 Ravello Systems LTD (http://ravellosystems.com) * Copyright (c) 2012 Ravello Systems LTD (http://ravellosystems.com)
* *
@ -15,15 +15,15 @@
* *
*/ */
#ifndef VMXNET_RX_PKT_H #ifndef NET_RX_PKT_H
#define VMXNET_RX_PKT_H #define NET_RX_PKT_H
#include "net/eth.h" #include "net/eth.h"
/* defines to enable packet dump functions */ /* defines to enable packet dump functions */
/*#define VMXNET_RX_PKT_DEBUG*/ /*#define NET_RX_PKT_DEBUG*/
struct VmxnetRxPkt; struct NetRxPkt;
/** /**
* Clean all rx packet resources * Clean all rx packet resources
@ -31,7 +31,7 @@ struct VmxnetRxPkt;
* @pkt: packet * @pkt: packet
* *
*/ */
void vmxnet_rx_pkt_uninit(struct VmxnetRxPkt *pkt); void net_rx_pkt_uninit(struct NetRxPkt *pkt);
/** /**
* Init function for rx packet functionality * Init function for rx packet functionality
@ -40,7 +40,7 @@ void vmxnet_rx_pkt_uninit(struct VmxnetRxPkt *pkt);
* @has_virt_hdr: device uses virtio header * @has_virt_hdr: device uses virtio header
* *
*/ */
void vmxnet_rx_pkt_init(struct VmxnetRxPkt **pkt, bool has_virt_hdr); void net_rx_pkt_init(struct NetRxPkt **pkt, bool has_virt_hdr);
/** /**
* returns total length of data attached to rx context * returns total length of data attached to rx context
@ -50,7 +50,7 @@ void vmxnet_rx_pkt_init(struct VmxnetRxPkt **pkt, bool has_virt_hdr);
* Return: nothing * Return: nothing
* *
*/ */
size_t vmxnet_rx_pkt_get_total_len(struct VmxnetRxPkt *pkt); size_t net_rx_pkt_get_total_len(struct NetRxPkt *pkt);
/** /**
* parse and set packet analysis results * parse and set packet analysis results
@ -60,7 +60,7 @@ size_t vmxnet_rx_pkt_get_total_len(struct VmxnetRxPkt *pkt);
* @len: data length * @len: data length
* *
*/ */
void vmxnet_rx_pkt_set_protocols(struct VmxnetRxPkt *pkt, const void *data, void net_rx_pkt_set_protocols(struct NetRxPkt *pkt, const void *data,
size_t len); size_t len);
/** /**
@ -73,7 +73,7 @@ void vmxnet_rx_pkt_set_protocols(struct VmxnetRxPkt *pkt, const void *data,
* @istcp: whether the packet given is TCP * @istcp: whether the packet given is TCP
* *
*/ */
void vmxnet_rx_pkt_get_protocols(struct VmxnetRxPkt *pkt, void net_rx_pkt_get_protocols(struct NetRxPkt *pkt,
bool *isip4, bool *isip6, bool *isip4, bool *isip6,
bool *isudp, bool *istcp); bool *isudp, bool *istcp);
@ -84,7 +84,7 @@ void vmxnet_rx_pkt_get_protocols(struct VmxnetRxPkt *pkt,
* @ret: virtio header * @ret: virtio header
* *
*/ */
struct virtio_net_hdr *vmxnet_rx_pkt_get_vhdr(struct VmxnetRxPkt *pkt); struct virtio_net_hdr *net_rx_pkt_get_vhdr(struct NetRxPkt *pkt);
/** /**
* returns packet type * returns packet type
@ -93,7 +93,7 @@ struct virtio_net_hdr *vmxnet_rx_pkt_get_vhdr(struct VmxnetRxPkt *pkt);
* @ret: packet type * @ret: packet type
* *
*/ */
eth_pkt_types_e vmxnet_rx_pkt_get_packet_type(struct VmxnetRxPkt *pkt); eth_pkt_types_e net_rx_pkt_get_packet_type(struct NetRxPkt *pkt);
/** /**
* returns vlan tag * returns vlan tag
@ -102,7 +102,7 @@ eth_pkt_types_e vmxnet_rx_pkt_get_packet_type(struct VmxnetRxPkt *pkt);
* @ret: VLAN tag * @ret: VLAN tag
* *
*/ */
uint16_t vmxnet_rx_pkt_get_vlan_tag(struct VmxnetRxPkt *pkt); uint16_t net_rx_pkt_get_vlan_tag(struct NetRxPkt *pkt);
/** /**
* tells whether vlan was stripped from the packet * tells whether vlan was stripped from the packet
@ -111,7 +111,7 @@ uint16_t vmxnet_rx_pkt_get_vlan_tag(struct VmxnetRxPkt *pkt);
* @ret: VLAN stripped sign * @ret: VLAN stripped sign
* *
*/ */
bool vmxnet_rx_pkt_is_vlan_stripped(struct VmxnetRxPkt *pkt); bool net_rx_pkt_is_vlan_stripped(struct NetRxPkt *pkt);
/** /**
* notifies caller if the packet has virtio header * notifies caller if the packet has virtio header
@ -120,7 +120,7 @@ bool vmxnet_rx_pkt_is_vlan_stripped(struct VmxnetRxPkt *pkt);
* @ret: true if packet has virtio header, false otherwize * @ret: true if packet has virtio header, false otherwize
* *
*/ */
bool vmxnet_rx_pkt_has_virt_hdr(struct VmxnetRxPkt *pkt); bool net_rx_pkt_has_virt_hdr(struct NetRxPkt *pkt);
/** /**
* attach data to rx packet * attach data to rx packet
@ -131,7 +131,7 @@ bool vmxnet_rx_pkt_has_virt_hdr(struct VmxnetRxPkt *pkt);
* @strip_vlan: should the module strip vlan from data * @strip_vlan: should the module strip vlan from data
* *
*/ */
void vmxnet_rx_pkt_attach_data(struct VmxnetRxPkt *pkt, const void *data, void net_rx_pkt_attach_data(struct NetRxPkt *pkt, const void *data,
size_t len, bool strip_vlan); size_t len, bool strip_vlan);
/** /**
@ -141,7 +141,7 @@ void vmxnet_rx_pkt_attach_data(struct VmxnetRxPkt *pkt, const void *data,
* @ret: pointer to IOVec * @ret: pointer to IOVec
* *
*/ */
struct iovec *vmxnet_rx_pkt_get_iovec(struct VmxnetRxPkt *pkt); struct iovec *net_rx_pkt_get_iovec(struct NetRxPkt *pkt);
/** /**
* prints rx packet data if debug is enabled * prints rx packet data if debug is enabled
@ -149,7 +149,7 @@ struct iovec *vmxnet_rx_pkt_get_iovec(struct VmxnetRxPkt *pkt);
* @pkt: packet * @pkt: packet
* *
*/ */
void vmxnet_rx_pkt_dump(struct VmxnetRxPkt *pkt); void net_rx_pkt_dump(struct NetRxPkt *pkt);
/** /**
* copy passed vhdr data to packet context * copy passed vhdr data to packet context
@ -158,7 +158,7 @@ void vmxnet_rx_pkt_dump(struct VmxnetRxPkt *pkt);
* @vhdr: VHDR buffer * @vhdr: VHDR buffer
* *
*/ */
void vmxnet_rx_pkt_set_vhdr(struct VmxnetRxPkt *pkt, void net_rx_pkt_set_vhdr(struct NetRxPkt *pkt,
struct virtio_net_hdr *vhdr); struct virtio_net_hdr *vhdr);
/** /**
@ -168,7 +168,7 @@ void vmxnet_rx_pkt_set_vhdr(struct VmxnetRxPkt *pkt,
* @packet_type: the packet type * @packet_type: the packet type
* *
*/ */
void vmxnet_rx_pkt_set_packet_type(struct VmxnetRxPkt *pkt, void net_rx_pkt_set_packet_type(struct NetRxPkt *pkt,
eth_pkt_types_e packet_type); eth_pkt_types_e packet_type);
#endif #endif

172
hw/net/vmxnet_tx_pkt.c → hw/net/net_tx_pkt.c
View File

@ -1,5 +1,5 @@
/* /*
* QEMU VMWARE VMXNET* paravirtual NICs - TX packets abstractions * QEMU TX packets abstractions
* *
* Copyright (c) 2012 Ravello Systems LTD (http://ravellosystems.com) * Copyright (c) 2012 Ravello Systems LTD (http://ravellosystems.com)
* *
@ -17,7 +17,7 @@
#include "qemu/osdep.h" #include "qemu/osdep.h"
#include "hw/hw.h" #include "hw/hw.h"
#include "vmxnet_tx_pkt.h" #include "net_tx_pkt.h"
#include "net/eth.h" #include "net/eth.h"
#include "qemu-common.h" #include "qemu-common.h"
#include "qemu/iov.h" #include "qemu/iov.h"
@ -26,14 +26,14 @@
#include "net/net.h" #include "net/net.h"
enum { enum {
VMXNET_TX_PKT_VHDR_FRAG = 0, NET_TX_PKT_VHDR_FRAG = 0,
VMXNET_TX_PKT_L2HDR_FRAG, NET_TX_PKT_L2HDR_FRAG,
VMXNET_TX_PKT_L3HDR_FRAG, NET_TX_PKT_L3HDR_FRAG,
VMXNET_TX_PKT_PL_START_FRAG NET_TX_PKT_PL_START_FRAG
}; };
/* TX packet private context */ /* TX packet private context */
struct VmxnetTxPkt { struct NetTxPkt {
struct virtio_net_hdr virt_hdr; struct virtio_net_hdr virt_hdr;
bool has_virt_hdr; bool has_virt_hdr;
@ -55,30 +55,30 @@ struct VmxnetTxPkt {
uint8_t l4proto; uint8_t l4proto;
}; };
void vmxnet_tx_pkt_init(struct VmxnetTxPkt **pkt, uint32_t max_frags, void net_tx_pkt_init(struct NetTxPkt **pkt, uint32_t max_frags,
bool has_virt_hdr) bool has_virt_hdr)
{ {
struct VmxnetTxPkt *p = g_malloc0(sizeof *p); struct NetTxPkt *p = g_malloc0(sizeof *p);
p->vec = g_malloc((sizeof *p->vec) * p->vec = g_malloc((sizeof *p->vec) *
(max_frags + VMXNET_TX_PKT_PL_START_FRAG)); (max_frags + NET_TX_PKT_PL_START_FRAG));
p->raw = g_malloc((sizeof *p->raw) * max_frags); p->raw = g_malloc((sizeof *p->raw) * max_frags);
p->max_payload_frags = max_frags; p->max_payload_frags = max_frags;
p->max_raw_frags = max_frags; p->max_raw_frags = max_frags;
p->has_virt_hdr = has_virt_hdr; p->has_virt_hdr = has_virt_hdr;
p->vec[VMXNET_TX_PKT_VHDR_FRAG].iov_base = &p->virt_hdr; p->vec[NET_TX_PKT_VHDR_FRAG].iov_base = &p->virt_hdr;
p->vec[VMXNET_TX_PKT_VHDR_FRAG].iov_len = p->vec[NET_TX_PKT_VHDR_FRAG].iov_len =
p->has_virt_hdr ? sizeof p->virt_hdr : 0; p->has_virt_hdr ? sizeof p->virt_hdr : 0;
p->vec[VMXNET_TX_PKT_L2HDR_FRAG].iov_base = &p->l2_hdr; p->vec[NET_TX_PKT_L2HDR_FRAG].iov_base = &p->l2_hdr;
p->vec[VMXNET_TX_PKT_L3HDR_FRAG].iov_base = NULL; p->vec[NET_TX_PKT_L3HDR_FRAG].iov_base = NULL;
p->vec[VMXNET_TX_PKT_L3HDR_FRAG].iov_len = 0; p->vec[NET_TX_PKT_L3HDR_FRAG].iov_len = 0;
*pkt = p; *pkt = p;
} }
void vmxnet_tx_pkt_uninit(struct VmxnetTxPkt *pkt) void net_tx_pkt_uninit(struct NetTxPkt *pkt)
{ {
if (pkt) { if (pkt) {
g_free(pkt->vec); g_free(pkt->vec);
@ -87,7 +87,7 @@ void vmxnet_tx_pkt_uninit(struct VmxnetTxPkt *pkt)
} }
} }
void vmxnet_tx_pkt_update_ip_checksums(struct VmxnetTxPkt *pkt) void net_tx_pkt_update_ip_checksums(struct NetTxPkt *pkt)
{ {
uint16_t csum; uint16_t csum;
uint32_t ph_raw_csum; uint32_t ph_raw_csum;
@ -100,36 +100,36 @@ void vmxnet_tx_pkt_update_ip_checksums(struct VmxnetTxPkt *pkt)
return; return;
} }
ip_hdr = pkt->vec[VMXNET_TX_PKT_L3HDR_FRAG].iov_base; ip_hdr = pkt->vec[NET_TX_PKT_L3HDR_FRAG].iov_base;
if (pkt->payload_len + pkt->vec[VMXNET_TX_PKT_L3HDR_FRAG].iov_len > if (pkt->payload_len + pkt->vec[NET_TX_PKT_L3HDR_FRAG].iov_len >
ETH_MAX_IP_DGRAM_LEN) { ETH_MAX_IP_DGRAM_LEN) {
return; return;
} }
ip_hdr->ip_len = cpu_to_be16(pkt->payload_len + ip_hdr->ip_len = cpu_to_be16(pkt->payload_len +
pkt->vec[VMXNET_TX_PKT_L3HDR_FRAG].iov_len); pkt->vec[NET_TX_PKT_L3HDR_FRAG].iov_len);
/* Calculate IP header checksum */ /* Calculate IP header checksum */
ip_hdr->ip_sum = 0; ip_hdr->ip_sum = 0;
csum = net_raw_checksum((uint8_t *)ip_hdr, csum = net_raw_checksum((uint8_t *)ip_hdr,
pkt->vec[VMXNET_TX_PKT_L3HDR_FRAG].iov_len); pkt->vec[NET_TX_PKT_L3HDR_FRAG].iov_len);
ip_hdr->ip_sum = cpu_to_be16(csum); ip_hdr->ip_sum = cpu_to_be16(csum);
/* Calculate IP pseudo header checksum */ /* Calculate IP pseudo header checksum */
ph_raw_csum = eth_calc_pseudo_hdr_csum(ip_hdr, pkt->payload_len); ph_raw_csum = eth_calc_pseudo_hdr_csum(ip_hdr, pkt->payload_len);
csum = cpu_to_be16(~net_checksum_finish(ph_raw_csum)); csum = cpu_to_be16(~net_checksum_finish(ph_raw_csum));
iov_from_buf(&pkt->vec[VMXNET_TX_PKT_PL_START_FRAG], pkt->payload_frags, iov_from_buf(&pkt->vec[NET_TX_PKT_PL_START_FRAG], pkt->payload_frags,
pkt->virt_hdr.csum_offset, &csum, sizeof(csum)); pkt->virt_hdr.csum_offset, &csum, sizeof(csum));
} }
static void vmxnet_tx_pkt_calculate_hdr_len(struct VmxnetTxPkt *pkt) static void net_tx_pkt_calculate_hdr_len(struct NetTxPkt *pkt)
{ {
pkt->hdr_len = pkt->vec[VMXNET_TX_PKT_L2HDR_FRAG].iov_len + pkt->hdr_len = pkt->vec[NET_TX_PKT_L2HDR_FRAG].iov_len +
pkt->vec[VMXNET_TX_PKT_L3HDR_FRAG].iov_len; pkt->vec[NET_TX_PKT_L3HDR_FRAG].iov_len;
} }
static bool vmxnet_tx_pkt_parse_headers(struct VmxnetTxPkt *pkt) static bool net_tx_pkt_parse_headers(struct NetTxPkt *pkt)
{ {
struct iovec *l2_hdr, *l3_hdr; struct iovec *l2_hdr, *l3_hdr;
size_t bytes_read; size_t bytes_read;
@ -138,8 +138,8 @@ static bool vmxnet_tx_pkt_parse_headers(struct VmxnetTxPkt *pkt)
assert(pkt); assert(pkt);
l2_hdr = &pkt->vec[VMXNET_TX_PKT_L2HDR_FRAG]; l2_hdr = &pkt->vec[NET_TX_PKT_L2HDR_FRAG];
l3_hdr = &pkt->vec[VMXNET_TX_PKT_L3HDR_FRAG]; l3_hdr = &pkt->vec[NET_TX_PKT_L3HDR_FRAG];
bytes_read = iov_to_buf(pkt->raw, pkt->raw_frags, 0, l2_hdr->iov_base, bytes_read = iov_to_buf(pkt->raw, pkt->raw_frags, 0, l2_hdr->iov_base,
ETH_MAX_L2_HDR_LEN); ETH_MAX_L2_HDR_LEN);
@ -216,16 +216,16 @@ static bool vmxnet_tx_pkt_parse_headers(struct VmxnetTxPkt *pkt)
break; break;
} }
vmxnet_tx_pkt_calculate_hdr_len(pkt); net_tx_pkt_calculate_hdr_len(pkt);
pkt->packet_type = get_eth_packet_type(l2_hdr->iov_base); pkt->packet_type = get_eth_packet_type(l2_hdr->iov_base);
return true; return true;
} }
static bool vmxnet_tx_pkt_rebuild_payload(struct VmxnetTxPkt *pkt) static bool net_tx_pkt_rebuild_payload(struct NetTxPkt *pkt)
{ {
size_t payload_len = iov_size(pkt->raw, pkt->raw_frags) - pkt->hdr_len; size_t payload_len = iov_size(pkt->raw, pkt->raw_frags) - pkt->hdr_len;
pkt->payload_frags = iov_copy(&pkt->vec[VMXNET_TX_PKT_PL_START_FRAG], pkt->payload_frags = iov_copy(&pkt->vec[NET_TX_PKT_PL_START_FRAG],
pkt->max_payload_frags, pkt->max_payload_frags,
pkt->raw, pkt->raw_frags, pkt->raw, pkt->raw_frags,
pkt->hdr_len, payload_len); pkt->hdr_len, payload_len);
@ -238,39 +238,39 @@ static bool vmxnet_tx_pkt_rebuild_payload(struct VmxnetTxPkt *pkt)
} }
} }
bool vmxnet_tx_pkt_parse(struct VmxnetTxPkt *pkt) bool net_tx_pkt_parse(struct NetTxPkt *pkt)
{ {
return vmxnet_tx_pkt_parse_headers(pkt) && return net_tx_pkt_parse_headers(pkt) &&
vmxnet_tx_pkt_rebuild_payload(pkt); net_tx_pkt_rebuild_payload(pkt);
} }
struct virtio_net_hdr *vmxnet_tx_pkt_get_vhdr(struct VmxnetTxPkt *pkt) struct virtio_net_hdr *net_tx_pkt_get_vhdr(struct NetTxPkt *pkt)
{ {
assert(pkt); assert(pkt);
return &pkt->virt_hdr; return &pkt->virt_hdr;
} }
static uint8_t vmxnet_tx_pkt_get_gso_type(struct VmxnetTxPkt *pkt, static uint8_t net_tx_pkt_get_gso_type(struct NetTxPkt *pkt,
bool tso_enable) bool tso_enable)
{ {
uint8_t rc = VIRTIO_NET_HDR_GSO_NONE; uint8_t rc = VIRTIO_NET_HDR_GSO_NONE;
uint16_t l3_proto; uint16_t l3_proto;
l3_proto = eth_get_l3_proto(pkt->vec[VMXNET_TX_PKT_L2HDR_FRAG].iov_base, l3_proto = eth_get_l3_proto(pkt->vec[NET_TX_PKT_L2HDR_FRAG].iov_base,
pkt->vec[VMXNET_TX_PKT_L2HDR_FRAG].iov_len); pkt->vec[NET_TX_PKT_L2HDR_FRAG].iov_len);
if (!tso_enable) { if (!tso_enable) {
goto func_exit; goto func_exit;
} }
rc = eth_get_gso_type(l3_proto, pkt->vec[VMXNET_TX_PKT_L3HDR_FRAG].iov_base, rc = eth_get_gso_type(l3_proto, pkt->vec[NET_TX_PKT_L3HDR_FRAG].iov_base,
pkt->l4proto); pkt->l4proto);
func_exit: func_exit:
return rc; return rc;
} }
void vmxnet_tx_pkt_build_vheader(struct VmxnetTxPkt *pkt, bool tso_enable, void net_tx_pkt_build_vheader(struct NetTxPkt *pkt, bool tso_enable,
bool csum_enable, uint32_t gso_size) bool csum_enable, uint32_t gso_size)
{ {
struct tcp_hdr l4hdr; struct tcp_hdr l4hdr;
@ -279,7 +279,7 @@ void vmxnet_tx_pkt_build_vheader(struct VmxnetTxPkt *pkt, bool tso_enable,
/* csum has to be enabled if tso is. */ /* csum has to be enabled if tso is. */
assert(csum_enable || !tso_enable); assert(csum_enable || !tso_enable);
pkt->virt_hdr.gso_type = vmxnet_tx_pkt_get_gso_type(pkt, tso_enable); pkt->virt_hdr.gso_type = net_tx_pkt_get_gso_type(pkt, tso_enable);
switch (pkt->virt_hdr.gso_type & ~VIRTIO_NET_HDR_GSO_ECN) { switch (pkt->virt_hdr.gso_type & ~VIRTIO_NET_HDR_GSO_ECN) {
case VIRTIO_NET_HDR_GSO_NONE: case VIRTIO_NET_HDR_GSO_NONE:
@ -294,7 +294,7 @@ void vmxnet_tx_pkt_build_vheader(struct VmxnetTxPkt *pkt, bool tso_enable,
case VIRTIO_NET_HDR_GSO_TCPV4: case VIRTIO_NET_HDR_GSO_TCPV4:
case VIRTIO_NET_HDR_GSO_TCPV6: case VIRTIO_NET_HDR_GSO_TCPV6:
iov_to_buf(&pkt->vec[VMXNET_TX_PKT_PL_START_FRAG], pkt->payload_frags, iov_to_buf(&pkt->vec[NET_TX_PKT_PL_START_FRAG], pkt->payload_frags,
0, &l4hdr, sizeof(l4hdr)); 0, &l4hdr, sizeof(l4hdr));
pkt->virt_hdr.hdr_len = pkt->hdr_len + l4hdr.th_off * sizeof(uint32_t); pkt->virt_hdr.hdr_len = pkt->hdr_len + l4hdr.th_off * sizeof(uint32_t);
pkt->virt_hdr.gso_size = IP_FRAG_ALIGN_SIZE(gso_size); pkt->virt_hdr.gso_size = IP_FRAG_ALIGN_SIZE(gso_size);
@ -322,23 +322,23 @@ void vmxnet_tx_pkt_build_vheader(struct VmxnetTxPkt *pkt, bool tso_enable,
} }
} }
void vmxnet_tx_pkt_setup_vlan_header(struct VmxnetTxPkt *pkt, uint16_t vlan) void net_tx_pkt_setup_vlan_header(struct NetTxPkt *pkt, uint16_t vlan)
{ {
bool is_new; bool is_new;
assert(pkt); assert(pkt);
eth_setup_vlan_headers(pkt->vec[VMXNET_TX_PKT_L2HDR_FRAG].iov_base, eth_setup_vlan_headers(pkt->vec[NET_TX_PKT_L2HDR_FRAG].iov_base,
vlan, &is_new); vlan, &is_new);
/* update l2hdrlen */ /* update l2hdrlen */
if (is_new) { if (is_new) {
pkt->hdr_len += sizeof(struct vlan_header); pkt->hdr_len += sizeof(struct vlan_header);
pkt->vec[VMXNET_TX_PKT_L2HDR_FRAG].iov_len += pkt->vec[NET_TX_PKT_L2HDR_FRAG].iov_len +=
sizeof(struct vlan_header); sizeof(struct vlan_header);
} }
} }
bool vmxnet_tx_pkt_add_raw_fragment(struct VmxnetTxPkt *pkt, hwaddr pa, bool net_tx_pkt_add_raw_fragment(struct NetTxPkt *pkt, hwaddr pa,
size_t len) size_t len)
{ {
hwaddr mapped_len = 0; hwaddr mapped_len = 0;
@ -364,33 +364,33 @@ bool vmxnet_tx_pkt_add_raw_fragment(struct VmxnetTxPkt *pkt, hwaddr pa,
return true; return true;
} }
eth_pkt_types_e vmxnet_tx_pkt_get_packet_type(struct VmxnetTxPkt *pkt) eth_pkt_types_e net_tx_pkt_get_packet_type(struct NetTxPkt *pkt)
{ {
assert(pkt); assert(pkt);
return pkt->packet_type; return pkt->packet_type;
} }
size_t vmxnet_tx_pkt_get_total_len(struct VmxnetTxPkt *pkt) size_t net_tx_pkt_get_total_len(struct NetTxPkt *pkt)
{ {
assert(pkt); assert(pkt);
return pkt->hdr_len + pkt->payload_len; return pkt->hdr_len + pkt->payload_len;
} }
void vmxnet_tx_pkt_dump(struct VmxnetTxPkt *pkt) void net_tx_pkt_dump(struct NetTxPkt *pkt)
{ {
#ifdef VMXNET_TX_PKT_DEBUG #ifdef NET_TX_PKT_DEBUG
assert(pkt); assert(pkt);
printf("TX PKT: hdr_len: %d, pkt_type: 0x%X, l2hdr_len: %lu, " printf("TX PKT: hdr_len: %d, pkt_type: 0x%X, l2hdr_len: %lu, "
"l3hdr_len: %lu, payload_len: %u\n", pkt->hdr_len, pkt->packet_type, "l3hdr_len: %lu, payload_len: %u\n", pkt->hdr_len, pkt->packet_type,
pkt->vec[VMXNET_TX_PKT_L2HDR_FRAG].iov_len, pkt->vec[NET_TX_PKT_L2HDR_FRAG].iov_len,
pkt->vec[VMXNET_TX_PKT_L3HDR_FRAG].iov_len, pkt->payload_len); pkt->vec[NET_TX_PKT_L3HDR_FRAG].iov_len, pkt->payload_len);
#endif #endif
} }
void vmxnet_tx_pkt_reset(struct VmxnetTxPkt *pkt) void net_tx_pkt_reset(struct NetTxPkt *pkt)
{ {
int i; int i;
@ -401,12 +401,12 @@ void vmxnet_tx_pkt_reset(struct VmxnetTxPkt *pkt)
memset(&pkt->virt_hdr, 0, sizeof(pkt->virt_hdr)); memset(&pkt->virt_hdr, 0, sizeof(pkt->virt_hdr));
g_free(pkt->vec[VMXNET_TX_PKT_L3HDR_FRAG].iov_base); g_free(pkt->vec[NET_TX_PKT_L3HDR_FRAG].iov_base);
pkt->vec[VMXNET_TX_PKT_L3HDR_FRAG].iov_base = NULL; pkt->vec[NET_TX_PKT_L3HDR_FRAG].iov_base = NULL;
assert(pkt->vec); assert(pkt->vec);
for (i = VMXNET_TX_PKT_L2HDR_FRAG; for (i = NET_TX_PKT_L2HDR_FRAG;
i < pkt->payload_frags + VMXNET_TX_PKT_PL_START_FRAG; i++) { i < pkt->payload_frags + NET_TX_PKT_PL_START_FRAG; i++) {
pkt->vec[i].iov_len = 0; pkt->vec[i].iov_len = 0;
} }
pkt->payload_len = 0; pkt->payload_len = 0;
@ -426,13 +426,13 @@ void vmxnet_tx_pkt_reset(struct VmxnetTxPkt *pkt)
pkt->l4proto = 0; pkt->l4proto = 0;
} }
static void vmxnet_tx_pkt_do_sw_csum(struct VmxnetTxPkt *pkt) static void net_tx_pkt_do_sw_csum(struct NetTxPkt *pkt)
{ {
struct iovec *iov = &pkt->vec[VMXNET_TX_PKT_L2HDR_FRAG]; struct iovec *iov = &pkt->vec[NET_TX_PKT_L2HDR_FRAG];
uint32_t csum_cntr; uint32_t csum_cntr;
uint16_t csum = 0; uint16_t csum = 0;
/* num of iovec without vhdr */ /* num of iovec without vhdr */
uint32_t iov_len = pkt->payload_frags + VMXNET_TX_PKT_PL_START_FRAG - 1; uint32_t iov_len = pkt->payload_frags + NET_TX_PKT_PL_START_FRAG - 1;
uint16_t csl; uint16_t csl;
struct ip_header *iphdr; struct ip_header *iphdr;
size_t csum_offset = pkt->virt_hdr.csum_start + pkt->virt_hdr.csum_offset; size_t csum_offset = pkt->virt_hdr.csum_start + pkt->virt_hdr.csum_offset;
@ -447,7 +447,7 @@ static void vmxnet_tx_pkt_do_sw_csum(struct VmxnetTxPkt *pkt)
csum_cntr = csum_cntr =
net_checksum_add_iov(iov, iov_len, pkt->virt_hdr.csum_start, csl); net_checksum_add_iov(iov, iov_len, pkt->virt_hdr.csum_start, csl);
/* add pseudo header to csum */ /* add pseudo header to csum */
iphdr = pkt->vec[VMXNET_TX_PKT_L3HDR_FRAG].iov_base; iphdr = pkt->vec[NET_TX_PKT_L3HDR_FRAG].iov_base;
csum_cntr += eth_calc_pseudo_hdr_csum(iphdr, csl); csum_cntr += eth_calc_pseudo_hdr_csum(iphdr, csl);
/* Put the checksum obtained into the packet */ /* Put the checksum obtained into the packet */
@ -456,30 +456,30 @@ static void vmxnet_tx_pkt_do_sw_csum(struct VmxnetTxPkt *pkt)
} }
enum { enum {
VMXNET_TX_PKT_FRAGMENT_L2_HDR_POS = 0, NET_TX_PKT_FRAGMENT_L2_HDR_POS = 0,
VMXNET_TX_PKT_FRAGMENT_L3_HDR_POS, NET_TX_PKT_FRAGMENT_L3_HDR_POS,
VMXNET_TX_PKT_FRAGMENT_HEADER_NUM NET_TX_PKT_FRAGMENT_HEADER_NUM
}; };
#define VMXNET_MAX_FRAG_SG_LIST (64) #define NET_MAX_FRAG_SG_LIST (64)
static size_t vmxnet_tx_pkt_fetch_fragment(struct VmxnetTxPkt *pkt, static size_t net_tx_pkt_fetch_fragment(struct NetTxPkt *pkt,
int *src_idx, size_t *src_offset, struct iovec *dst, int *dst_idx) int *src_idx, size_t *src_offset, struct iovec *dst, int *dst_idx)
{ {
size_t fetched = 0; size_t fetched = 0;
struct iovec *src = pkt->vec; struct iovec *src = pkt->vec;
*dst_idx = VMXNET_TX_PKT_FRAGMENT_HEADER_NUM; *dst_idx = NET_TX_PKT_FRAGMENT_HEADER_NUM;
while (fetched < pkt->virt_hdr.gso_size) { while (fetched < pkt->virt_hdr.gso_size) {
/* no more place in fragment iov */ /* no more place in fragment iov */
if (*dst_idx == VMXNET_MAX_FRAG_SG_LIST) { if (*dst_idx == NET_MAX_FRAG_SG_LIST) {
break; break;
} }
/* no more data in iovec */ /* no more data in iovec */
if (*src_idx == (pkt->payload_frags + VMXNET_TX_PKT_PL_START_FRAG)) { if (*src_idx == (pkt->payload_frags + NET_TX_PKT_PL_START_FRAG)) {
break; break;
} }
@ -502,35 +502,35 @@ static size_t vmxnet_tx_pkt_fetch_fragment(struct VmxnetTxPkt *pkt,
return fetched; return fetched;
} }
static bool vmxnet_tx_pkt_do_sw_fragmentation(struct VmxnetTxPkt *pkt, static bool net_tx_pkt_do_sw_fragmentation(struct NetTxPkt *pkt,
NetClientState *nc) NetClientState *nc)
{ {
struct iovec fragment[VMXNET_MAX_FRAG_SG_LIST]; struct iovec fragment[NET_MAX_FRAG_SG_LIST];
size_t fragment_len = 0; size_t fragment_len = 0;
bool more_frags = false; bool more_frags = false;
/* some pointers for shorter code */ /* some pointers for shorter code */
void *l2_iov_base, *l3_iov_base; void *l2_iov_base, *l3_iov_base;
size_t l2_iov_len, l3_iov_len; size_t l2_iov_len, l3_iov_len;
int src_idx = VMXNET_TX_PKT_PL_START_FRAG, dst_idx; int src_idx = NET_TX_PKT_PL_START_FRAG, dst_idx;
size_t src_offset = 0; size_t src_offset = 0;
size_t fragment_offset = 0; size_t fragment_offset = 0;
l2_iov_base = pkt->vec[VMXNET_TX_PKT_L2HDR_FRAG].iov_base; l2_iov_base = pkt->vec[NET_TX_PKT_L2HDR_FRAG].iov_base;
l2_iov_len = pkt->vec[VMXNET_TX_PKT_L2HDR_FRAG].iov_len; l2_iov_len = pkt->vec[NET_TX_PKT_L2HDR_FRAG].iov_len;
l3_iov_base = pkt->vec[VMXNET_TX_PKT_L3HDR_FRAG].iov_base; l3_iov_base = pkt->vec[NET_TX_PKT_L3HDR_FRAG].iov_base;
l3_iov_len = pkt->vec[VMXNET_TX_PKT_L3HDR_FRAG].iov_len; l3_iov_len = pkt->vec[NET_TX_PKT_L3HDR_FRAG].iov_len;
/* Copy headers */ /* Copy headers */
fragment[VMXNET_TX_PKT_FRAGMENT_L2_HDR_POS].iov_base = l2_iov_base; fragment[NET_TX_PKT_FRAGMENT_L2_HDR_POS].iov_base = l2_iov_base;
fragment[VMXNET_TX_PKT_FRAGMENT_L2_HDR_POS].iov_len = l2_iov_len; fragment[NET_TX_PKT_FRAGMENT_L2_HDR_POS].iov_len = l2_iov_len;
fragment[VMXNET_TX_PKT_FRAGMENT_L3_HDR_POS].iov_base = l3_iov_base; fragment[NET_TX_PKT_FRAGMENT_L3_HDR_POS].iov_base = l3_iov_base;
fragment[VMXNET_TX_PKT_FRAGMENT_L3_HDR_POS].iov_len = l3_iov_len; fragment[NET_TX_PKT_FRAGMENT_L3_HDR_POS].iov_len = l3_iov_len;
/* Put as much data as possible and send */ /* Put as much data as possible and send */
do { do {
fragment_len = vmxnet_tx_pkt_fetch_fragment(pkt, &src_idx, &src_offset, fragment_len = net_tx_pkt_fetch_fragment(pkt, &src_idx, &src_offset,
fragment, &dst_idx); fragment, &dst_idx);
more_frags = (fragment_offset + fragment_len < pkt->payload_len); more_frags = (fragment_offset + fragment_len < pkt->payload_len);
@ -549,13 +549,13 @@ static bool vmxnet_tx_pkt_do_sw_fragmentation(struct VmxnetTxPkt *pkt,
return true; return true;
} }
bool vmxnet_tx_pkt_send(struct VmxnetTxPkt *pkt, NetClientState *nc) bool net_tx_pkt_send(struct NetTxPkt *pkt, NetClientState *nc)
{ {
assert(pkt); assert(pkt);
if (!pkt->has_virt_hdr && if (!pkt->has_virt_hdr &&
pkt->virt_hdr.flags & VIRTIO_NET_HDR_F_NEEDS_CSUM) { pkt->virt_hdr.flags & VIRTIO_NET_HDR_F_NEEDS_CSUM) {
vmxnet_tx_pkt_do_sw_csum(pkt); net_tx_pkt_do_sw_csum(pkt);
} }
/* /*
@ -565,7 +565,7 @@ bool vmxnet_tx_pkt_send(struct VmxnetTxPkt *pkt, NetClientState *nc)
if (VIRTIO_NET_HDR_GSO_NONE != pkt->virt_hdr.gso_type) { if (VIRTIO_NET_HDR_GSO_NONE != pkt->virt_hdr.gso_type) {
if (pkt->payload_len > if (pkt->payload_len >
ETH_MAX_IP_DGRAM_LEN - ETH_MAX_IP_DGRAM_LEN -
pkt->vec[VMXNET_TX_PKT_L3HDR_FRAG].iov_len) { pkt->vec[NET_TX_PKT_L3HDR_FRAG].iov_len) {
return false; return false;
} }
} }
@ -573,9 +573,9 @@ bool vmxnet_tx_pkt_send(struct VmxnetTxPkt *pkt, NetClientState *nc)
if (pkt->has_virt_hdr || if (pkt->has_virt_hdr ||
pkt->virt_hdr.gso_type == VIRTIO_NET_HDR_GSO_NONE) { pkt->virt_hdr.gso_type == VIRTIO_NET_HDR_GSO_NONE) {
qemu_sendv_packet(nc, pkt->vec, qemu_sendv_packet(nc, pkt->vec,
pkt->payload_frags + VMXNET_TX_PKT_PL_START_FRAG); pkt->payload_frags + NET_TX_PKT_PL_START_FRAG);
return true; return true;
} }
return vmxnet_tx_pkt_do_sw_fragmentation(pkt, nc); return net_tx_pkt_do_sw_fragmentation(pkt, nc);
} }

36
hw/net/vmxnet_tx_pkt.h → hw/net/net_tx_pkt.h
View File

@ -1,5 +1,5 @@
/* /*
* QEMU VMWARE VMXNET* paravirtual NICs - TX packets abstraction * QEMU TX packets abstraction
* *
* Copyright (c) 2012 Ravello Systems LTD (http://ravellosystems.com) * Copyright (c) 2012 Ravello Systems LTD (http://ravellosystems.com)
* *
@ -15,16 +15,16 @@
* *
*/ */
#ifndef VMXNET_TX_PKT_H #ifndef NET_TX_PKT_H
#define VMXNET_TX_PKT_H #define NET_TX_PKT_H
#include "net/eth.h" #include "net/eth.h"
#include "exec/hwaddr.h" #include "exec/hwaddr.h"
/* define to enable packet dump functions */ /* define to enable packet dump functions */
/*#define VMXNET_TX_PKT_DEBUG*/ /*#define NET_TX_PKT_DEBUG*/
struct VmxnetTxPkt; struct NetTxPkt;
/** /**
* Init function for tx packet functionality * Init function for tx packet functionality
@ -33,7 +33,7 @@ struct VmxnetTxPkt;
* @max_frags: max tx ip fragments * @max_frags: max tx ip fragments
* @has_virt_hdr: device uses virtio header. * @has_virt_hdr: device uses virtio header.
*/ */
void vmxnet_tx_pkt_init(struct VmxnetTxPkt **pkt, uint32_t max_frags, void net_tx_pkt_init(struct NetTxPkt **pkt, uint32_t max_frags,
bool has_virt_hdr); bool has_virt_hdr);
/** /**
@ -41,7 +41,7 @@ void vmxnet_tx_pkt_init(struct VmxnetTxPkt **pkt, uint32_t max_frags,
* *
* @pkt: packet. * @pkt: packet.
*/ */
void vmxnet_tx_pkt_uninit(struct VmxnetTxPkt *pkt); void net_tx_pkt_uninit(struct NetTxPkt *pkt);
/** /**
* get virtio header * get virtio header
@ -49,7 +49,7 @@ void vmxnet_tx_pkt_uninit(struct VmxnetTxPkt *pkt);
* @pkt: packet * @pkt: packet
* @ret: virtio header * @ret: virtio header
*/ */
struct virtio_net_hdr *vmxnet_tx_pkt_get_vhdr(struct VmxnetTxPkt *pkt); struct virtio_net_hdr *net_tx_pkt_get_vhdr(struct NetTxPkt *pkt);
/** /**
* build virtio header (will be stored in module context) * build virtio header (will be stored in module context)
@ -60,7 +60,7 @@ struct virtio_net_hdr *vmxnet_tx_pkt_get_vhdr(struct VmxnetTxPkt *pkt);
* @gso_size: MSS size for TSO * @gso_size: MSS size for TSO
* *
*/ */
void vmxnet_tx_pkt_build_vheader(struct VmxnetTxPkt *pkt, bool tso_enable, void net_tx_pkt_build_vheader(struct NetTxPkt *pkt, bool tso_enable,
bool csum_enable, uint32_t gso_size); bool csum_enable, uint32_t gso_size);
/** /**
@ -70,7 +70,7 @@ void vmxnet_tx_pkt_build_vheader(struct VmxnetTxPkt *pkt, bool tso_enable,
* @vlan: VLAN tag * @vlan: VLAN tag
* *
*/ */
void vmxnet_tx_pkt_setup_vlan_header(struct VmxnetTxPkt *pkt, uint16_t vlan); void net_tx_pkt_setup_vlan_header(struct NetTxPkt *pkt, uint16_t vlan);
/** /**
* populate data fragment into pkt context. * populate data fragment into pkt context.
@ -80,7 +80,7 @@ void vmxnet_tx_pkt_setup_vlan_header(struct VmxnetTxPkt *pkt, uint16_t vlan);
* @len: length of fragment * @len: length of fragment
* *
*/ */
bool vmxnet_tx_pkt_add_raw_fragment(struct VmxnetTxPkt *pkt, hwaddr pa, bool net_tx_pkt_add_raw_fragment(struct NetTxPkt *pkt, hwaddr pa,
size_t len); size_t len);
/** /**
@ -89,7 +89,7 @@ bool vmxnet_tx_pkt_add_raw_fragment(struct VmxnetTxPkt *pkt, hwaddr pa,
* @pkt: packet * @pkt: packet
* *
*/ */
void vmxnet_tx_pkt_update_ip_checksums(struct VmxnetTxPkt *pkt); void net_tx_pkt_update_ip_checksums(struct NetTxPkt *pkt);
/** /**
* get length of all populated data. * get length of all populated data.
@ -98,7 +98,7 @@ void vmxnet_tx_pkt_update_ip_checksums(struct VmxnetTxPkt *pkt);
* @ret: total data length * @ret: total data length
* *
*/ */
size_t vmxnet_tx_pkt_get_total_len(struct VmxnetTxPkt *pkt); size_t net_tx_pkt_get_total_len(struct NetTxPkt *pkt);
/** /**
* get packet type * get packet type
@ -107,7 +107,7 @@ size_t vmxnet_tx_pkt_get_total_len(struct VmxnetTxPkt *pkt);
* @ret: packet type * @ret: packet type
* *
*/ */
eth_pkt_types_e vmxnet_tx_pkt_get_packet_type(struct VmxnetTxPkt *pkt); eth_pkt_types_e net_tx_pkt_get_packet_type(struct NetTxPkt *pkt);
/** /**
* prints packet data if debug is enabled * prints packet data if debug is enabled
@ -115,7 +115,7 @@ eth_pkt_types_e vmxnet_tx_pkt_get_packet_type(struct VmxnetTxPkt *pkt);
* @pkt: packet * @pkt: packet
* *
*/ */
void vmxnet_tx_pkt_dump(struct VmxnetTxPkt *pkt); void net_tx_pkt_dump(struct NetTxPkt *pkt);
/** /**
* reset tx packet private context (needed to be called between packets) * reset tx packet private context (needed to be called between packets)
@ -123,7 +123,7 @@ void vmxnet_tx_pkt_dump(struct VmxnetTxPkt *pkt);
* @pkt: packet * @pkt: packet
* *
*/ */
void vmxnet_tx_pkt_reset(struct VmxnetTxPkt *pkt); void net_tx_pkt_reset(struct NetTxPkt *pkt);
/** /**
* Send packet to qemu. handles sw offloads if vhdr is not supported. * Send packet to qemu. handles sw offloads if vhdr is not supported.
@ -133,7 +133,7 @@ void vmxnet_tx_pkt_reset(struct VmxnetTxPkt *pkt);
* @ret: operation result * @ret: operation result
* *
*/ */
bool vmxnet_tx_pkt_send(struct VmxnetTxPkt *pkt, NetClientState *nc); bool net_tx_pkt_send(struct NetTxPkt *pkt, NetClientState *nc);
/** /**
* parse raw packet data and analyze offload requirements. * parse raw packet data and analyze offload requirements.
@ -141,6 +141,6 @@ bool vmxnet_tx_pkt_send(struct VmxnetTxPkt *pkt, NetClientState *nc);
* @pkt: packet * @pkt: packet
* *
*/ */
bool vmxnet_tx_pkt_parse(struct VmxnetTxPkt *pkt); bool net_tx_pkt_parse(struct NetTxPkt *pkt);
#endif #endif

88
hw/net/vmxnet3.c
View File

@ -30,8 +30,8 @@
#include "vmxnet3.h" #include "vmxnet3.h"
#include "vmxnet_debug.h" #include "vmxnet_debug.h"
#include "vmware_utils.h" #include "vmware_utils.h"
#include "vmxnet_tx_pkt.h" #include "net_tx_pkt.h"
#include "vmxnet_rx_pkt.h" #include "net_rx_pkt.h"
#define PCI_DEVICE_ID_VMWARE_VMXNET3_REVISION 0x1 #define PCI_DEVICE_ID_VMWARE_VMXNET3_REVISION 0x1
#define VMXNET3_MSIX_BAR_SIZE 0x2000 #define VMXNET3_MSIX_BAR_SIZE 0x2000
@ -314,13 +314,13 @@ typedef struct {
bool peer_has_vhdr; bool peer_has_vhdr;
/* TX packets to QEMU interface */ /* TX packets to QEMU interface */
struct VmxnetTxPkt *tx_pkt; struct NetTxPkt *tx_pkt;
uint32_t offload_mode; uint32_t offload_mode;
uint32_t cso_or_gso_size; uint32_t cso_or_gso_size;
uint16_t tci; uint16_t tci;
bool needs_vlan; bool needs_vlan;
struct VmxnetRxPkt *rx_pkt; struct NetRxPkt *rx_pkt;
bool tx_sop; bool tx_sop;
bool skip_current_tx_pkt; bool skip_current_tx_pkt;
@ -546,18 +546,18 @@ vmxnet3_setup_tx_offloads(VMXNET3State *s)
{ {
switch (s->offload_mode) { switch (s->offload_mode) {
case VMXNET3_OM_NONE: case VMXNET3_OM_NONE:
vmxnet_tx_pkt_build_vheader(s->tx_pkt, false, false, 0); net_tx_pkt_build_vheader(s->tx_pkt, false, false, 0);
break; break;
case VMXNET3_OM_CSUM: case VMXNET3_OM_CSUM:
vmxnet_tx_pkt_build_vheader(s->tx_pkt, false, true, 0); net_tx_pkt_build_vheader(s->tx_pkt, false, true, 0);
VMW_PKPRN("L4 CSO requested\n"); VMW_PKPRN("L4 CSO requested\n");
break; break;
case VMXNET3_OM_TSO: case VMXNET3_OM_TSO:
vmxnet_tx_pkt_build_vheader(s->tx_pkt, true, true, net_tx_pkt_build_vheader(s->tx_pkt, true, true,
s->cso_or_gso_size); s->cso_or_gso_size);
vmxnet_tx_pkt_update_ip_checksums(s->tx_pkt); net_tx_pkt_update_ip_checksums(s->tx_pkt);
VMW_PKPRN("GSO offload requested."); VMW_PKPRN("GSO offload requested.");
break; break;
@ -590,12 +590,12 @@ static void
vmxnet3_on_tx_done_update_stats(VMXNET3State *s, int qidx, vmxnet3_on_tx_done_update_stats(VMXNET3State *s, int qidx,
Vmxnet3PktStatus status) Vmxnet3PktStatus status)
{ {
size_t tot_len = vmxnet_tx_pkt_get_total_len(s->tx_pkt); size_t tot_len = net_tx_pkt_get_total_len(s->tx_pkt);
struct UPT1_TxStats *stats = &s->txq_descr[qidx].txq_stats; struct UPT1_TxStats *stats = &s->txq_descr[qidx].txq_stats;
switch (status) { switch (status) {
case VMXNET3_PKT_STATUS_OK: case VMXNET3_PKT_STATUS_OK:
switch (vmxnet_tx_pkt_get_packet_type(s->tx_pkt)) { switch (net_tx_pkt_get_packet_type(s->tx_pkt)) {
case ETH_PKT_BCAST: case ETH_PKT_BCAST:
stats->bcastPktsTxOK++; stats->bcastPktsTxOK++;
stats->bcastBytesTxOK += tot_len; stats->bcastBytesTxOK += tot_len;
@ -643,7 +643,7 @@ vmxnet3_on_rx_done_update_stats(VMXNET3State *s,
Vmxnet3PktStatus status) Vmxnet3PktStatus status)
{ {
struct UPT1_RxStats *stats = &s->rxq_descr[qidx].rxq_stats; struct UPT1_RxStats *stats = &s->rxq_descr[qidx].rxq_stats;
size_t tot_len = vmxnet_rx_pkt_get_total_len(s->rx_pkt); size_t tot_len = net_rx_pkt_get_total_len(s->rx_pkt);
switch (status) { switch (status) {
case VMXNET3_PKT_STATUS_OUT_OF_BUF: case VMXNET3_PKT_STATUS_OUT_OF_BUF:
@ -654,7 +654,7 @@ vmxnet3_on_rx_done_update_stats(VMXNET3State *s,
stats->pktsRxError++; stats->pktsRxError++;
break; break;
case VMXNET3_PKT_STATUS_OK: case VMXNET3_PKT_STATUS_OK:
switch (vmxnet_rx_pkt_get_packet_type(s->rx_pkt)) { switch (net_rx_pkt_get_packet_type(s->rx_pkt)) {
case ETH_PKT_BCAST: case ETH_PKT_BCAST:
stats->bcastPktsRxOK++; stats->bcastPktsRxOK++;
stats->bcastBytesRxOK += tot_len; stats->bcastBytesRxOK += tot_len;
@ -715,10 +715,10 @@ vmxnet3_send_packet(VMXNET3State *s, uint32_t qidx)
} }
/* debug prints */ /* debug prints */
vmxnet3_dump_virt_hdr(vmxnet_tx_pkt_get_vhdr(s->tx_pkt)); vmxnet3_dump_virt_hdr(net_tx_pkt_get_vhdr(s->tx_pkt));
vmxnet_tx_pkt_dump(s->tx_pkt); net_tx_pkt_dump(s->tx_pkt);
if (!vmxnet_tx_pkt_send(s->tx_pkt, qemu_get_queue(s->nic))) { if (!net_tx_pkt_send(s->tx_pkt, qemu_get_queue(s->nic))) {
status = VMXNET3_PKT_STATUS_DISCARD; status = VMXNET3_PKT_STATUS_DISCARD;
goto func_exit; goto func_exit;
} }
@ -746,7 +746,7 @@ static void vmxnet3_process_tx_queue(VMXNET3State *s, int qidx)
data_len = (txd.len > 0) ? txd.len : VMXNET3_MAX_TX_BUF_SIZE; data_len = (txd.len > 0) ? txd.len : VMXNET3_MAX_TX_BUF_SIZE;
data_pa = le64_to_cpu(txd.addr); data_pa = le64_to_cpu(txd.addr);
if (!vmxnet_tx_pkt_add_raw_fragment(s->tx_pkt, if (!net_tx_pkt_add_raw_fragment(s->tx_pkt,
data_pa, data_pa,
data_len)) { data_len)) {
s->skip_current_tx_pkt = true; s->skip_current_tx_pkt = true;
@ -759,9 +759,9 @@ static void vmxnet3_process_tx_queue(VMXNET3State *s, int qidx)
} }
if (txd.eop) { if (txd.eop) {
if (!s->skip_current_tx_pkt && vmxnet_tx_pkt_parse(s->tx_pkt)) { if (!s->skip_current_tx_pkt && net_tx_pkt_parse(s->tx_pkt)) {
if (s->needs_vlan) { if (s->needs_vlan) {
vmxnet_tx_pkt_setup_vlan_header(s->tx_pkt, s->tci); net_tx_pkt_setup_vlan_header(s->tx_pkt, s->tci);
} }
vmxnet3_send_packet(s, qidx); vmxnet3_send_packet(s, qidx);
@ -773,7 +773,7 @@ static void vmxnet3_process_tx_queue(VMXNET3State *s, int qidx)
vmxnet3_complete_packet(s, qidx, txd_idx); vmxnet3_complete_packet(s, qidx, txd_idx);
s->tx_sop = true; s->tx_sop = true;
s->skip_current_tx_pkt = false; s->skip_current_tx_pkt = false;
vmxnet_tx_pkt_reset(s->tx_pkt); net_tx_pkt_reset(s->tx_pkt);
} }
} }
} }
@ -928,7 +928,7 @@ vmxnet3_get_next_rx_descr(VMXNET3State *s, bool is_head,
* in the case the host OS performs forwarding, it will forward an * in the case the host OS performs forwarding, it will forward an
* incorrectly checksummed packet. * incorrectly checksummed packet.
*/ */
static void vmxnet3_rx_need_csum_calculate(struct VmxnetRxPkt *pkt, static void vmxnet3_rx_need_csum_calculate(struct NetRxPkt *pkt,
const void *pkt_data, const void *pkt_data,
size_t pkt_len) size_t pkt_len)
{ {
@ -937,16 +937,16 @@ static void vmxnet3_rx_need_csum_calculate(struct VmxnetRxPkt *pkt,
uint8_t *data; uint8_t *data;
int len; int len;
if (!vmxnet_rx_pkt_has_virt_hdr(pkt)) { if (!net_rx_pkt_has_virt_hdr(pkt)) {
return; return;
} }
vhdr = vmxnet_rx_pkt_get_vhdr(pkt); vhdr = net_rx_pkt_get_vhdr(pkt);
if (!VMXNET_FLAG_IS_SET(vhdr->flags, VIRTIO_NET_HDR_F_NEEDS_CSUM)) { if (!VMXNET_FLAG_IS_SET(vhdr->flags, VIRTIO_NET_HDR_F_NEEDS_CSUM)) {
return; return;
} }
vmxnet_rx_pkt_get_protocols(pkt, &isip4, &isip6, &isudp, &istcp); net_rx_pkt_get_protocols(pkt, &isip4, &isip6, &isudp, &istcp);
if (!(isip4 || isip6) || !(istcp || isudp)) { if (!(isip4 || isip6) || !(istcp || isudp)) {
return; return;
} }
@ -970,7 +970,7 @@ static void vmxnet3_rx_need_csum_calculate(struct VmxnetRxPkt *pkt,
vhdr->flags |= VIRTIO_NET_HDR_F_DATA_VALID; vhdr->flags |= VIRTIO_NET_HDR_F_DATA_VALID;
} }
static void vmxnet3_rx_update_descr(struct VmxnetRxPkt *pkt, static void vmxnet3_rx_update_descr(struct NetRxPkt *pkt,
struct Vmxnet3_RxCompDesc *rxcd) struct Vmxnet3_RxCompDesc *rxcd)
{ {
int csum_ok, is_gso; int csum_ok, is_gso;
@ -978,16 +978,16 @@ static void vmxnet3_rx_update_descr(struct VmxnetRxPkt *pkt,
struct virtio_net_hdr *vhdr; struct virtio_net_hdr *vhdr;
uint8_t offload_type; uint8_t offload_type;
if (vmxnet_rx_pkt_is_vlan_stripped(pkt)) { if (net_rx_pkt_is_vlan_stripped(pkt)) {
rxcd->ts = 1; rxcd->ts = 1;
rxcd->tci = vmxnet_rx_pkt_get_vlan_tag(pkt); rxcd->tci = net_rx_pkt_get_vlan_tag(pkt);
} }
if (!vmxnet_rx_pkt_has_virt_hdr(pkt)) { if (!net_rx_pkt_has_virt_hdr(pkt)) {
goto nocsum; goto nocsum;
} }
vhdr = vmxnet_rx_pkt_get_vhdr(pkt); vhdr = net_rx_pkt_get_vhdr(pkt);
/* /*
* Checksum is valid when lower level tell so or when lower level * Checksum is valid when lower level tell so or when lower level
* requires checksum offload telling that packet produced/bridged * requires checksum offload telling that packet produced/bridged
@ -1004,7 +1004,7 @@ static void vmxnet3_rx_update_descr(struct VmxnetRxPkt *pkt,
goto nocsum; goto nocsum;
} }
vmxnet_rx_pkt_get_protocols(pkt, &isip4, &isip6, &isudp, &istcp); net_rx_pkt_get_protocols(pkt, &isip4, &isip6, &isudp, &istcp);
if ((!istcp && !isudp) || (!isip4 && !isip6)) { if ((!istcp && !isudp) || (!isip4 && !isip6)) {
goto nocsum; goto nocsum;
} }
@ -1063,13 +1063,13 @@ vmxnet3_indicate_packet(VMXNET3State *s)
uint32_t new_rxcd_gen = VMXNET3_INIT_GEN; uint32_t new_rxcd_gen = VMXNET3_INIT_GEN;
hwaddr new_rxcd_pa = 0; hwaddr new_rxcd_pa = 0;
hwaddr ready_rxcd_pa = 0; hwaddr ready_rxcd_pa = 0;
struct iovec *data = vmxnet_rx_pkt_get_iovec(s->rx_pkt); struct iovec *data = net_rx_pkt_get_iovec(s->rx_pkt);
size_t bytes_copied = 0; size_t bytes_copied = 0;
size_t bytes_left = vmxnet_rx_pkt_get_total_len(s->rx_pkt); size_t bytes_left = net_rx_pkt_get_total_len(s->rx_pkt);
uint16_t num_frags = 0; uint16_t num_frags = 0;
size_t chunk_size; size_t chunk_size;
vmxnet_rx_pkt_dump(s->rx_pkt); net_rx_pkt_dump(s->rx_pkt);
while (bytes_left > 0) { while (bytes_left > 0) {
@ -1226,9 +1226,9 @@ static void vmxnet3_deactivate_device(VMXNET3State *s)
{ {
if (s->device_active) { if (s->device_active) {
VMW_CBPRN("Deactivating vmxnet3..."); VMW_CBPRN("Deactivating vmxnet3...");
vmxnet_tx_pkt_reset(s->tx_pkt); net_tx_pkt_reset(s->tx_pkt);
vmxnet_tx_pkt_uninit(s->tx_pkt); net_tx_pkt_uninit(s->tx_pkt);
vmxnet_rx_pkt_uninit(s->rx_pkt); net_rx_pkt_uninit(s->rx_pkt);
s->device_active = false; s->device_active = false;
} }
} }
@ -1558,8 +1558,8 @@ static void vmxnet3_activate_device(VMXNET3State *s)
/* Preallocate TX packet wrapper */ /* Preallocate TX packet wrapper */
VMW_CFPRN("Max TX fragments is %u", s->max_tx_frags); VMW_CFPRN("Max TX fragments is %u", s->max_tx_frags);
vmxnet_tx_pkt_init(&s->tx_pkt, s->max_tx_frags, s->peer_has_vhdr); net_tx_pkt_init(&s->tx_pkt, s->max_tx_frags, s->peer_has_vhdr);
vmxnet_rx_pkt_init(&s->rx_pkt, s->peer_has_vhdr); net_rx_pkt_init(&s->rx_pkt, s->peer_has_vhdr);
/* Read rings memory locations for RX queues */ /* Read rings memory locations for RX queues */
for (i = 0; i < s->rxq_num; i++) { for (i = 0; i < s->rxq_num; i++) {
@ -1965,7 +1965,7 @@ vmxnet3_rx_filter_may_indicate(VMXNET3State *s, const void *data,
return false; return false;
} }
switch (vmxnet_rx_pkt_get_packet_type(s->rx_pkt)) { switch (net_rx_pkt_get_packet_type(s->rx_pkt)) {
case ETH_PKT_UCAST: case ETH_PKT_UCAST:
if (!VMXNET_FLAG_IS_SET(s->rx_mode, VMXNET3_RXM_UCAST)) { if (!VMXNET_FLAG_IS_SET(s->rx_mode, VMXNET3_RXM_UCAST)) {
return false; return false;
@ -2013,7 +2013,7 @@ vmxnet3_receive(NetClientState *nc, const uint8_t *buf, size_t size)
} }
if (s->peer_has_vhdr) { if (s->peer_has_vhdr) {
vmxnet_rx_pkt_set_vhdr(s->rx_pkt, (struct virtio_net_hdr *)buf); net_rx_pkt_set_vhdr(s->rx_pkt, (struct virtio_net_hdr *)buf);
buf += sizeof(struct virtio_net_hdr); buf += sizeof(struct virtio_net_hdr);
size -= sizeof(struct virtio_net_hdr); size -= sizeof(struct virtio_net_hdr);
} }
@ -2026,13 +2026,13 @@ vmxnet3_receive(NetClientState *nc, const uint8_t *buf, size_t size)
size = sizeof(min_buf); size = sizeof(min_buf);
} }
vmxnet_rx_pkt_set_packet_type(s->rx_pkt, net_rx_pkt_set_packet_type(s->rx_pkt,
get_eth_packet_type(PKT_GET_ETH_HDR(buf))); get_eth_packet_type(PKT_GET_ETH_HDR(buf)));
if (vmxnet3_rx_filter_may_indicate(s, buf, size)) { if (vmxnet3_rx_filter_may_indicate(s, buf, size)) {
vmxnet_rx_pkt_set_protocols(s->rx_pkt, buf, size); net_rx_pkt_set_protocols(s->rx_pkt, buf, size);
vmxnet3_rx_need_csum_calculate(s->rx_pkt, buf, size); vmxnet3_rx_need_csum_calculate(s->rx_pkt, buf, size);
vmxnet_rx_pkt_attach_data(s->rx_pkt, buf, size, s->rx_vlan_stripping); net_rx_pkt_attach_data(s->rx_pkt, buf, size, s->rx_vlan_stripping);
bytes_indicated = vmxnet3_indicate_packet(s) ? size : -1; bytes_indicated = vmxnet3_indicate_packet(s) ? size : -1;
if (bytes_indicated < size) { if (bytes_indicated < size) {
VMW_PKPRN("RX: %zu of %zu bytes indicated", bytes_indicated, size); VMW_PKPRN("RX: %zu of %zu bytes indicated", bytes_indicated, size);
@ -2536,8 +2536,8 @@ static int vmxnet3_post_load(void *opaque, int version_id)
VMXNET3State *s = opaque; VMXNET3State *s = opaque;
PCIDevice *d = PCI_DEVICE(s); PCIDevice *d = PCI_DEVICE(s);
vmxnet_tx_pkt_init(&s->tx_pkt, s->max_tx_frags, s->peer_has_vhdr); net_tx_pkt_init(&s->tx_pkt, s->max_tx_frags, s->peer_has_vhdr);
vmxnet_rx_pkt_init(&s->rx_pkt, s->peer_has_vhdr); net_rx_pkt_init(&s->rx_pkt, s->peer_has_vhdr);
if (s->msix_used) { if (s->msix_used) {
if (!vmxnet3_use_msix_vectors(s, VMXNET3_MAX_INTRS)) { if (!vmxnet3_use_msix_vectors(s, VMXNET3_MAX_INTRS)) {

4
tests/Makefile
View File

@ -198,8 +198,8 @@ check-qtest-i386-y += $(check-qtest-pci-y)
gcov-files-i386-y += $(gcov-files-pci-y) gcov-files-i386-y += $(gcov-files-pci-y)
check-qtest-i386-y += tests/vmxnet3-test$(EXESUF) check-qtest-i386-y += tests/vmxnet3-test$(EXESUF)
gcov-files-i386-y += hw/net/vmxnet3.c gcov-files-i386-y += hw/net/vmxnet3.c
gcov-files-i386-y += hw/net/vmxnet_rx_pkt.c gcov-files-i386-y += hw/net/net_rx_pkt.c
gcov-files-i386-y += hw/net/vmxnet_tx_pkt.c gcov-files-i386-y += hw/net/net_tx_pkt.c
check-qtest-i386-y += tests/pvpanic-test$(EXESUF) check-qtest-i386-y += tests/pvpanic-test$(EXESUF)
gcov-files-i386-y += i386-softmmu/hw/misc/pvpanic.c gcov-files-i386-y += i386-softmmu/hw/misc/pvpanic.c
check-qtest-i386-y += tests/i82801b11-test$(EXESUF) check-qtest-i386-y += tests/i82801b11-test$(EXESUF)