@@ -26,7 +26,6 @@ typedef void (FilterCleanup) (NetFilterState *nf);
*/
typedef ssize_t (FilterReceiveIOV)(NetFilterState *nc,
NetClientState *sender,
- unsigned flags,
const struct iovec *iov,
int iovcnt,
NetPacketSent *sent_cb);
@@ -65,14 +64,12 @@ struct NetFilterState {
ssize_t qemu_netfilter_receive(NetFilterState *nf,
NetFilterDirection direction,
NetClientState *sender,
- unsigned flags,
const struct iovec *iov,
int iovcnt,
NetPacketSent *sent_cb);
/* pass the packet to the next filter */
ssize_t qemu_netfilter_pass_to_next(NetClientState *sender,
- unsigned flags,
const struct iovec *iov,
int iovcnt,
void *opaque);
@@ -71,7 +71,6 @@ typedef struct NetClientInfo {
NetClientDriver type;
size_t size;
NetReceive *receive;
- NetReceive *receive_raw;
NetReceiveIOV *receive_iov;
NetCanReceive *can_receive;
NetStart *start;
@@ -30,16 +30,12 @@ typedef struct NetQueue NetQueue;
typedef void (NetPacketSent) (NetClientState *sender, ssize_t ret);
-#define QEMU_NET_PACKET_FLAG_NONE 0
-#define QEMU_NET_PACKET_FLAG_RAW (1<<0)
-
/* Returns:
* >0 - success
* 0 - queue packet for future redelivery
* <0 - failure (discard packet)
*/
typedef ssize_t (NetQueueDeliverFunc)(NetClientState *sender,
- unsigned flags,
const struct iovec *iov,
int iovcnt,
void *opaque);
@@ -48,7 +44,6 @@ NetQueue *qemu_new_net_queue(NetQueueDeliverFunc *deliver, void *opaque);
void qemu_net_queue_append_iov(NetQueue *queue,
NetClientState *sender,
- unsigned flags,
const struct iovec *iov,
int iovcnt,
NetPacketSent *sent_cb);
@@ -65,14 +60,12 @@ ssize_t qemu_net_queue_receive_iov(NetQueue *queue,
ssize_t qemu_net_queue_send(NetQueue *queue,
NetClientState *sender,
- unsigned flags,
const uint8_t *data,
size_t size,
NetPacketSent *sent_cb);
ssize_t qemu_net_queue_send_iov(NetQueue *queue,
NetClientState *sender,
- unsigned flags,
const struct iovec *iov,
int iovcnt,
NetPacketSent *sent_cb);
@@ -158,7 +158,7 @@ ReplayNetState *replay_register_net(NetFilterState *nfs);
/*! Unregisters replay network filter. */
void replay_unregister_net(ReplayNetState *rns);
/*! Called to write network packet to the replay log. */
-void replay_net_packet_event(ReplayNetState *rns, unsigned flags,
+void replay_net_packet_event(ReplayNetState *rns,
const struct iovec *iov, int iovcnt);
/* Audio */
@@ -150,8 +150,8 @@ struct NetFilterDumpState {
};
static ssize_t filter_dump_receive_iov(NetFilterState *nf, NetClientState *sndr,
- unsigned flags, const struct iovec *iov,
- int iovcnt, NetPacketSent *sent_cb)
+ const struct iovec *iov, int iovcnt,
+ NetPacketSent *sent_cb)
{
NetFilterDumpState *nfds = FILTER_DUMP(nf);
@@ -58,7 +58,6 @@ static void filter_buffer_release_timer(void *opaque)
/* filter APIs */
static ssize_t filter_buffer_receive_iov(NetFilterState *nf,
NetClientState *sender,
- unsigned flags,
const struct iovec *iov,
int iovcnt,
NetPacketSent *sent_cb)
@@ -79,8 +78,7 @@ static ssize_t filter_buffer_receive_iov(NetFilterState *nf,
* the packets without caring about the receiver. This is suboptimal.
* May need more thoughts (e.g keeping sent_cb).
*/
- qemu_net_queue_append_iov(s->incoming_queue, sender, flags,
- iov, iovcnt, NULL);
+ qemu_net_queue_append_iov(s->incoming_queue, sender, iov, iovcnt, NULL);
return iov_size(iov, iovcnt);
}
@@ -145,12 +145,12 @@ static void redirector_to_filter(NetFilterState *nf,
if (nf->direction == NET_FILTER_DIRECTION_ALL ||
nf->direction == NET_FILTER_DIRECTION_TX) {
- qemu_netfilter_pass_to_next(nf->netdev, 0, &iov, 1, nf);
+ qemu_netfilter_pass_to_next(nf->netdev, &iov, 1, nf);
}
if (nf->direction == NET_FILTER_DIRECTION_ALL ||
nf->direction == NET_FILTER_DIRECTION_RX) {
- qemu_netfilter_pass_to_next(nf->netdev->peer, 0, &iov, 1, nf);
+ qemu_netfilter_pass_to_next(nf->netdev->peer, &iov, 1, nf);
}
}
@@ -31,7 +31,6 @@ struct NetFilterReplayState {
static ssize_t filter_replay_receive_iov(NetFilterState *nf,
NetClientState *sndr,
- unsigned flags,
const struct iovec *iov,
int iovcnt, NetPacketSent *sent_cb)
{
@@ -39,7 +38,7 @@ static ssize_t filter_replay_receive_iov(NetFilterState *nf,
switch (replay_mode) {
case REPLAY_MODE_RECORD:
if (nf->netdev == sndr) {
- replay_net_packet_event(nfrs->rns, flags, iov, iovcnt);
+ replay_net_packet_event(nfrs->rns, iov, iovcnt);
return iov_size(iov, iovcnt);
}
return 0;
@@ -251,7 +251,6 @@ static int handle_secondary_tcp_pkt(RewriterState *rf,
static ssize_t colo_rewriter_receive_iov(NetFilterState *nf,
NetClientState *sender,
- unsigned flags,
const struct iovec *iov,
int iovcnt,
NetPacketSent *sent_cb)
@@ -294,7 +293,7 @@ static ssize_t colo_rewriter_receive_iov(NetFilterState *nf,
if (sender == nf->netdev) {
/* NET_FILTER_DIRECTION_TX */
if (!handle_primary_tcp_pkt(s, conn, pkt, &key)) {
- qemu_net_queue_send(s->incoming_queue, sender, 0,
+ qemu_net_queue_send(s->incoming_queue, sender,
(const uint8_t *)pkt->data, pkt->size, NULL);
packet_destroy(pkt, NULL);
pkt = NULL;
@@ -307,7 +306,7 @@ static ssize_t colo_rewriter_receive_iov(NetFilterState *nf,
} else {
/* NET_FILTER_DIRECTION_RX */
if (!handle_secondary_tcp_pkt(s, conn, pkt, &key)) {
- qemu_net_queue_send(s->incoming_queue, sender, 0,
+ qemu_net_queue_send(s->incoming_queue, sender,
(const uint8_t *)pkt->data, pkt->size, NULL);
packet_destroy(pkt, NULL);
pkt = NULL;
@@ -28,7 +28,6 @@ static inline bool qemu_can_skip_netfilter(NetFilterState *nf)
ssize_t qemu_netfilter_receive(NetFilterState *nf,
NetFilterDirection direction,
NetClientState *sender,
- unsigned flags,
const struct iovec *iov,
int iovcnt,
NetPacketSent *sent_cb)
@@ -39,7 +38,7 @@ ssize_t qemu_netfilter_receive(NetFilterState *nf,
if (nf->direction == direction ||
nf->direction == NET_FILTER_DIRECTION_ALL) {
return NETFILTER_GET_CLASS(OBJECT(nf))->receive_iov(
- nf, sender, flags, iov, iovcnt, sent_cb);
+ nf, sender, iov, iovcnt, sent_cb);
}
return 0;
@@ -62,7 +61,6 @@ static NetFilterState *netfilter_next(NetFilterState *nf,
}
ssize_t qemu_netfilter_pass_to_next(NetClientState *sender,
- unsigned flags,
const struct iovec *iov,
int iovcnt,
void *opaque)
@@ -96,7 +94,7 @@ ssize_t qemu_netfilter_pass_to_next(NetClientState *sender,
* to the sender, so sent_cb shouldn't be called later, just
* pass NULL to next.
*/
- ret = qemu_netfilter_receive(next, direction, sender, flags, iov,
+ ret = qemu_netfilter_receive(next, direction, sender, iov,
iovcnt, NULL);
if (ret) {
return ret;
@@ -111,7 +109,7 @@ ssize_t qemu_netfilter_pass_to_next(NetClientState *sender,
*/
if (sender && sender->peer) {
qemu_net_queue_send_iov(sender->peer->incoming_queue,
- sender, flags, iov, iovcnt, NULL);
+ sender, iov, iovcnt, NULL);
}
out:
@@ -250,7 +250,6 @@ static void qemu_net_client_destructor(NetClientState *nc)
g_free(nc);
}
static ssize_t qemu_deliver_packet_iov(NetClientState *sender,
- unsigned flags,
const struct iovec *iov,
int iovcnt,
void *opaque);
@@ -604,7 +603,6 @@ int qemu_can_send_packet(NetClientState *sender)
static ssize_t filter_receive_iov(NetClientState *nc,
NetFilterDirection direction,
NetClientState *sender,
- unsigned flags,
const struct iovec *iov,
int iovcnt,
NetPacketSent *sent_cb)
@@ -614,7 +612,7 @@ static ssize_t filter_receive_iov(NetClientState *nc,
if (direction == NET_FILTER_DIRECTION_TX) {
QTAILQ_FOREACH(nf, &nc->filters, next) {
- ret = qemu_netfilter_receive(nf, direction, sender, flags, iov,
+ ret = qemu_netfilter_receive(nf, direction, sender, iov,
iovcnt, sent_cb);
if (ret) {
return ret;
@@ -622,7 +620,7 @@ static ssize_t filter_receive_iov(NetClientState *nc,
}
} else {
QTAILQ_FOREACH_REVERSE(nf, &nc->filters, next) {
- ret = qemu_netfilter_receive(nf, direction, sender, flags, iov,
+ ret = qemu_netfilter_receive(nf, direction, sender, iov,
iovcnt, sent_cb);
if (ret) {
return ret;
@@ -636,7 +634,6 @@ static ssize_t filter_receive_iov(NetClientState *nc,
static ssize_t filter_receive(NetClientState *nc,
NetFilterDirection direction,
NetClientState *sender,
- unsigned flags,
const uint8_t *data,
size_t size,
NetPacketSent *sent_cb)
@@ -646,7 +643,7 @@ static ssize_t filter_receive(NetClientState *nc,
.iov_len = size
};
- return filter_receive_iov(nc, direction, sender, flags, &iov, 1, sent_cb);
+ return filter_receive_iov(nc, direction, sender, &iov, 1, sent_cb);
}
void qemu_purge_queued_packets(NetClientState *nc)
@@ -683,10 +680,9 @@ void qemu_flush_queued_packets(NetClientState *nc)
qemu_flush_or_purge_queued_packets(nc, false);
}
-static ssize_t qemu_send_packet_async_with_flags(NetClientState *sender,
- unsigned flags,
- const uint8_t *buf, int size,
- NetPacketSent *sent_cb)
+ssize_t qemu_send_packet_async(NetClientState *sender,
+ const uint8_t *buf, int size,
+ NetPacketSent *sent_cb)
{
NetQueue *queue;
int ret;
@@ -702,28 +698,20 @@ static ssize_t qemu_send_packet_async_with_flags(NetClientState *sender,
/* Let filters handle the packet first */
ret = filter_receive(sender, NET_FILTER_DIRECTION_TX,
- sender, flags, buf, size, sent_cb);
+ sender, buf, size, sent_cb);
if (ret) {
return ret;
}
ret = filter_receive(sender->peer, NET_FILTER_DIRECTION_RX,
- sender, flags, buf, size, sent_cb);
+ sender, buf, size, sent_cb);
if (ret) {
return ret;
}
queue = sender->peer->incoming_queue;
- return qemu_net_queue_send(queue, sender, flags, buf, size, sent_cb);
-}
-
-ssize_t qemu_send_packet_async(NetClientState *sender,
- const uint8_t *buf, int size,
- NetPacketSent *sent_cb)
-{
- return qemu_send_packet_async_with_flags(sender, QEMU_NET_PACKET_FLAG_NONE,
- buf, size, sent_cb);
+ return qemu_net_queue_send(queue, sender, buf, size, sent_cb);
}
ssize_t qemu_send_packet(NetClientState *nc, const uint8_t *buf, int size)
@@ -752,12 +740,17 @@ ssize_t qemu_receive_packet_iov(NetClientState *nc, const struct iovec *iov,
ssize_t qemu_send_packet_raw(NetClientState *nc, const uint8_t *buf, int size)
{
- return qemu_send_packet_async_with_flags(nc, QEMU_NET_PACKET_FLAG_RAW,
- buf, size, NULL);
+ struct virtio_net_hdr_v1_hash vnet_hdr = { };
+ struct iovec iov[] = {
+ { .iov_base = &vnet_hdr, .iov_len = nc->vnet_hdr_len },
+ { .iov_base = (void *)buf, .iov_len = size }
+ };
+
+ return qemu_sendv_packet_async(nc, iov, ARRAY_SIZE(iov), NULL);
}
static ssize_t nc_sendv_compat(NetClientState *nc, const struct iovec *iov,
- int iovcnt, unsigned flags)
+ int iovcnt)
{
uint8_t *buf = NULL;
uint8_t *buffer;
@@ -777,18 +770,13 @@ static ssize_t nc_sendv_compat(NetClientState *nc, const struct iovec *iov,
offset = iov_to_buf(iov, iovcnt, 0, buf, offset);
}
- if (flags & QEMU_NET_PACKET_FLAG_RAW && nc->info->receive_raw) {
- ret = nc->info->receive_raw(nc, buffer, offset);
- } else {
- ret = nc->info->receive(nc, buffer, offset);
- }
+ ret = nc->info->receive(nc, buffer, offset);
g_free(buf);
return ret;
}
static ssize_t qemu_deliver_packet_iov(NetClientState *sender,
- unsigned flags,
const struct iovec *iov,
int iovcnt,
void *opaque)
@@ -814,10 +802,10 @@ static ssize_t qemu_deliver_packet_iov(NetClientState *sender,
owned_reentrancy_guard->engaged_in_io = true;
}
- if (nc->info->receive_iov && !(flags & QEMU_NET_PACKET_FLAG_RAW)) {
+ if (nc->info->receive_iov) {
ret = nc->info->receive_iov(nc, iov, iovcnt);
} else {
- ret = nc_sendv_compat(nc, iov, iovcnt, flags);
+ ret = nc_sendv_compat(nc, iov, iovcnt);
}
if (owned_reentrancy_guard) {
@@ -849,22 +837,20 @@ ssize_t qemu_sendv_packet_async(NetClientState *sender,
/* Let filters handle the packet first */
ret = filter_receive_iov(sender, NET_FILTER_DIRECTION_TX, sender,
- QEMU_NET_PACKET_FLAG_NONE, iov, iovcnt, sent_cb);
+ iov, iovcnt, sent_cb);
if (ret) {
return ret;
}
ret = filter_receive_iov(sender->peer, NET_FILTER_DIRECTION_RX, sender,
- QEMU_NET_PACKET_FLAG_NONE, iov, iovcnt, sent_cb);
+ iov, iovcnt, sent_cb);
if (ret) {
return ret;
}
queue = sender->peer->incoming_queue;
- return qemu_net_queue_send_iov(queue, sender,
- QEMU_NET_PACKET_FLAG_NONE,
- iov, iovcnt, sent_cb);
+ return qemu_net_queue_send_iov(queue, sender, iov, iovcnt, sent_cb);
}
ssize_t
@@ -43,7 +43,6 @@
struct NetPacket {
QTAILQ_ENTRY(NetPacket) entry;
NetClientState *sender;
- unsigned flags;
int size;
NetPacketSent *sent_cb;
uint8_t data[];
@@ -92,7 +91,6 @@ void qemu_del_net_queue(NetQueue *queue)
static void qemu_net_queue_append(NetQueue *queue,
NetClientState *sender,
- unsigned flags,
const uint8_t *buf,
size_t size,
NetPacketSent *sent_cb)
@@ -104,7 +102,6 @@ static void qemu_net_queue_append(NetQueue *queue,
}
packet = g_malloc(sizeof(NetPacket) + size);
packet->sender = sender;
- packet->flags = flags;
packet->size = size;
packet->sent_cb = sent_cb;
memcpy(packet->data, buf, size);
@@ -115,7 +112,6 @@ static void qemu_net_queue_append(NetQueue *queue,
void qemu_net_queue_append_iov(NetQueue *queue,
NetClientState *sender,
- unsigned flags,
const struct iovec *iov,
int iovcnt,
NetPacketSent *sent_cb)
@@ -134,7 +130,6 @@ void qemu_net_queue_append_iov(NetQueue *queue,
packet = g_malloc(sizeof(NetPacket) + max_len);
packet->sender = sender;
packet->sent_cb = sent_cb;
- packet->flags = flags;
packet->size = 0;
for (i = 0; i < iovcnt; i++) {
@@ -150,7 +145,6 @@ void qemu_net_queue_append_iov(NetQueue *queue,
static ssize_t qemu_net_queue_deliver(NetQueue *queue,
NetClientState *sender,
- unsigned flags,
const uint8_t *data,
size_t size)
{
@@ -161,7 +155,7 @@ static ssize_t qemu_net_queue_deliver(NetQueue *queue,
};
queue->delivering = 1;
- ret = queue->deliver(sender, flags, &iov, 1, queue->opaque);
+ ret = queue->deliver(sender, &iov, 1, queue->opaque);
queue->delivering = 0;
return ret;
@@ -169,14 +163,13 @@ static ssize_t qemu_net_queue_deliver(NetQueue *queue,
static ssize_t qemu_net_queue_deliver_iov(NetQueue *queue,
NetClientState *sender,
- unsigned flags,
const struct iovec *iov,
int iovcnt)
{
ssize_t ret = -1;
queue->delivering = 1;
- ret = queue->deliver(sender, flags, iov, iovcnt, queue->opaque);
+ ret = queue->deliver(sender, iov, iovcnt, queue->opaque);
queue->delivering = 0;
return ret;
@@ -190,7 +183,7 @@ ssize_t qemu_net_queue_receive(NetQueue *queue,
return 0;
}
- return qemu_net_queue_deliver(queue, NULL, 0, data, size);
+ return qemu_net_queue_deliver(queue, NULL, data, size);
}
ssize_t qemu_net_queue_receive_iov(NetQueue *queue,
@@ -201,12 +194,11 @@ ssize_t qemu_net_queue_receive_iov(NetQueue *queue,
return 0;
}
- return qemu_net_queue_deliver_iov(queue, NULL, 0, iov, iovcnt);
+ return qemu_net_queue_deliver_iov(queue, NULL, iov, iovcnt);
}
ssize_t qemu_net_queue_send(NetQueue *queue,
NetClientState *sender,
- unsigned flags,
const uint8_t *data,
size_t size,
NetPacketSent *sent_cb)
@@ -214,13 +206,13 @@ ssize_t qemu_net_queue_send(NetQueue *queue,
ssize_t ret;
if (queue->delivering || !qemu_can_send_packet(sender)) {
- qemu_net_queue_append(queue, sender, flags, data, size, sent_cb);
+ qemu_net_queue_append(queue, sender, data, size, sent_cb);
return 0;
}
- ret = qemu_net_queue_deliver(queue, sender, flags, data, size);
+ ret = qemu_net_queue_deliver(queue, sender, data, size);
if (ret == 0) {
- qemu_net_queue_append(queue, sender, flags, data, size, sent_cb);
+ qemu_net_queue_append(queue, sender, data, size, sent_cb);
return 0;
}
@@ -231,7 +223,6 @@ ssize_t qemu_net_queue_send(NetQueue *queue,
ssize_t qemu_net_queue_send_iov(NetQueue *queue,
NetClientState *sender,
- unsigned flags,
const struct iovec *iov,
int iovcnt,
NetPacketSent *sent_cb)
@@ -239,13 +230,13 @@ ssize_t qemu_net_queue_send_iov(NetQueue *queue,
ssize_t ret;
if (queue->delivering || !qemu_can_send_packet(sender)) {
- qemu_net_queue_append_iov(queue, sender, flags, iov, iovcnt, sent_cb);
+ qemu_net_queue_append_iov(queue, sender, iov, iovcnt, sent_cb);
return 0;
}
- ret = qemu_net_queue_deliver_iov(queue, sender, flags, iov, iovcnt);
+ ret = qemu_net_queue_deliver_iov(queue, sender, iov, iovcnt);
if (ret == 0) {
- qemu_net_queue_append_iov(queue, sender, flags, iov, iovcnt, sent_cb);
+ qemu_net_queue_append_iov(queue, sender, iov, iovcnt, sent_cb);
return 0;
}
@@ -285,7 +276,6 @@ bool qemu_net_queue_flush(NetQueue *queue)
ret = qemu_net_queue_deliver(queue,
packet->sender,
- packet->flags,
packet->data,
packet->size);
if (ret == 0) {
@@ -131,41 +131,6 @@ static ssize_t tap_receive_iov(NetClientState *nc, const struct iovec *iov,
return tap_write_packet(s, iovp, iovcnt);
}
-static ssize_t tap_receive_raw(NetClientState *nc, const uint8_t *buf, size_t size)
-{
- TAPState *s = DO_UPCAST(TAPState, nc, nc);
- struct iovec iov[2];
- int iovcnt = 0;
- struct virtio_net_hdr_mrg_rxbuf hdr = { };
-
- if (s->host_vnet_hdr_len) {
- iov[iovcnt].iov_base = &hdr;
- iov[iovcnt].iov_len = s->host_vnet_hdr_len;
- iovcnt++;
- }
-
- iov[iovcnt].iov_base = (char *)buf;
- iov[iovcnt].iov_len = size;
- iovcnt++;
-
- return tap_write_packet(s, iov, iovcnt);
-}
-
-static ssize_t tap_receive(NetClientState *nc, const uint8_t *buf, size_t size)
-{
- TAPState *s = DO_UPCAST(TAPState, nc, nc);
- struct iovec iov[1];
-
- if (s->host_vnet_hdr_len && !s->using_vnet_hdr) {
- return tap_receive_raw(nc, buf, size);
- }
-
- iov[0].iov_base = (char *)buf;
- iov[0].iov_len = size;
-
- return tap_write_packet(s, iov, 1);
-}
-
#ifndef __sun__
ssize_t tap_read_packet(int tapfd, uint8_t *buf, int maxlen)
{
@@ -355,8 +320,6 @@ int tap_get_fd(NetClientState *nc)
static NetClientInfo net_tap_info = {
.type = NET_CLIENT_DRIVER_TAP,
.size = sizeof(TAPState),
- .receive = tap_receive,
- .receive_raw = tap_receive_raw,
.receive_iov = tap_receive_iov,
.poll = tap_poll,
.cleanup = tap_cleanup,
@@ -24,7 +24,6 @@ struct ReplayNetState {
typedef struct NetEvent {
uint8_t id;
- uint32_t flags;
uint8_t *data;
size_t size;
} NetEvent;
@@ -50,11 +49,10 @@ void replay_unregister_net(ReplayNetState *rns)
g_free(rns);
}
-void replay_net_packet_event(ReplayNetState *rns, unsigned flags,
+void replay_net_packet_event(ReplayNetState *rns,
const struct iovec *iov, int iovcnt)
{
NetEvent *event = g_new(NetEvent, 1);
- event->flags = flags;
event->data = g_malloc(iov_size(iov, iovcnt));
event->size = iov_size(iov, iovcnt);
event->id = rns->id;
@@ -74,7 +72,7 @@ void replay_event_net_run(void *opaque)
assert(event->id < network_filters_count);
qemu_netfilter_pass_to_next(network_filters[event->id]->netdev,
- event->flags, &iov, 1, network_filters[event->id]);
+ &iov, 1, network_filters[event->id]);
g_free(event->data);
g_free(event);
@@ -85,7 +83,6 @@ void replay_event_net_save(void *opaque)
NetEvent *event = opaque;
replay_put_byte(event->id);
- replay_put_dword(event->flags);
replay_put_array(event->data, event->size);
}
@@ -94,7 +91,6 @@ void *replay_event_net_load(void)
NetEvent *event = g_new(NetEvent, 1);
event->id = replay_get_byte();
- event->flags = replay_get_dword();
replay_get_array_alloc(&event->data, &event->size);
return event;
While netmap implements virtio-net header, it does not implement receive_raw(). Instead of implementing receive_raw for netmap, add virtio-net headers in the common code and use receive_iov()/receive() instead. This also fixes the buffer size for the virtio-net header. Fixes: fbbdbddec0 ("tap: allow extended virtio header with hash info") Signed-off-by: Akihiko Odaki <akihiko.odaki@daynix.com> --- include/net/filter.h | 3 --- include/net/net.h | 1 - include/net/queue.h | 7 ----- include/sysemu/replay.h | 2 +- net/dump.c | 4 +-- net/filter-buffer.c | 4 +-- net/filter-mirror.c | 4 +-- net/filter-replay.c | 3 +-- net/filter-rewriter.c | 5 ++-- net/filter.c | 8 +++--- net/net.c | 60 ++++++++++++++++------------------------- net/queue.c | 30 +++++++-------------- net/tap.c | 37 ------------------------- replay/replay-net.c | 8 ++---- 14 files changed, 47 insertions(+), 129 deletions(-)