From patchwork Thu Oct 22 16:49:02 2009 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mark McLoughlin X-Patchwork-Id: 36719 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from lists.gnu.org (lists.gnu.org [199.232.76.165]) (using TLSv1 with cipher DHE-RSA-AES256-SHA (256/256 bits)) (Client did not present a certificate) by ozlabs.org (Postfix) with ESMTPS id 40F8AB7BB7 for ; Fri, 23 Oct 2009 04:36:44 +1100 (EST) Received: from localhost ([127.0.0.1]:39709 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1N11aW-0005pr-Qm for incoming@patchwork.ozlabs.org; Thu, 22 Oct 2009 13:36:36 -0400 Received: from mailman by lists.gnu.org with tmda-scanned (Exim 4.43) id 1N10si-0006Gh-B4 for qemu-devel@nongnu.org; Thu, 22 Oct 2009 12:51:21 -0400 Received: from exim by lists.gnu.org with spam-scanned (Exim 4.43) id 1N10sd-00068m-DL for qemu-devel@nongnu.org; Thu, 22 Oct 2009 12:51:18 -0400 Received: from [199.232.76.173] (port=54107 helo=monty-python.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1N10sa-00066b-IC for qemu-devel@nongnu.org; Thu, 22 Oct 2009 12:51:12 -0400 Received: from mx1.redhat.com ([209.132.183.28]:44584) by monty-python.gnu.org with esmtp (Exim 4.60) (envelope-from ) id 1N10sY-00042A-M8 for qemu-devel@nongnu.org; Thu, 22 Oct 2009 12:51:11 -0400 Received: from int-mx05.intmail.prod.int.phx2.redhat.com (int-mx05.intmail.prod.int.phx2.redhat.com [10.5.11.18]) by mx1.redhat.com (8.13.8/8.13.8) with ESMTP id n9MGp9O8009213 for ; Thu, 22 Oct 2009 12:51:09 -0400 Received: from blaa.localdomain (ovpn01.gateway.prod.ext.phx2.redhat.com [10.5.9.1]) by int-mx05.intmail.prod.int.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id n9MGp8Jm009828; Thu, 22 Oct 2009 12:51:09 -0400 Received: by blaa.localdomain (Postfix, from userid 500) id ED9F11EB; Thu, 22 Oct 2009 17:49:16 +0100 (IST) From: Mark McLoughlin To: qemu-devel@nongnu.org Date: Thu, 22 Oct 2009 17:49:02 +0100 Message-Id: <1256230156-29652-2-git-send-email-markmc@redhat.com> In-Reply-To: <1256230156-29652-1-git-send-email-markmc@redhat.com> References: <1256230156-29652-1-git-send-email-markmc@redhat.com> X-Scanned-By: MIMEDefang 2.67 on 10.5.11.18 X-detected-operating-system: by monty-python.gnu.org: Genre and OS details not recognized. Cc: Mark McLoughlin Subject: [Qemu-devel] [PATCH 01/15] net: move net-queue.[ch] under net/ X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.5 Precedence: list List-Id: qemu-devel.nongnu.org List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org Errors-To: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org Signed-off-by: Mark McLoughlin --- Makefile | 6 +- net-queue.c | 260 ----------------------------------------------------------- net-queue.h | 71 ---------------- net.h | 2 +- net/queue.c | 260 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ net/queue.h | 71 ++++++++++++++++ 6 files changed, 337 insertions(+), 333 deletions(-) delete mode 100644 net-queue.c delete mode 100644 net-queue.h create mode 100644 net/queue.c create mode 100644 net/queue.h diff --git a/Makefile b/Makefile index e78a3d0..6fb89fb 100644 --- a/Makefile +++ b/Makefile @@ -86,6 +86,10 @@ block-nested-$(CONFIG_CURL) += curl.o block-obj-y += $(addprefix block/, $(block-nested-y)) +net-obj-y = net.o +net-nested-y = queue.o +net-obj-y += $(addprefix net/, $(net-nested-y)) + ###################################################################### # libqemu_common.a: Target independent part of system emulation. The # long term path is to suppress *all* target specific code in case of @@ -93,6 +97,7 @@ block-obj-y += $(addprefix block/, $(block-nested-y)) # CPUs and machines. obj-y = $(block-obj-y) +obj-y += $(net-obj-y) obj-y += readline.o console.o obj-y += tcg-runtime.o host-utils.o @@ -121,7 +126,6 @@ obj-$(CONFIG_SD) += sd.o obj-y += bt.o bt-host.o bt-vhci.o bt-l2cap.o bt-sdp.o bt-hci.o bt-hid.o usb-bt.o obj-y += bt-hci-csr.o obj-y += buffered_file.o migration.o migration-tcp.o qemu-sockets.o -obj-y += net.o net-queue.o obj-y += qemu-char.o aio.o net-checksum.o savevm.o obj-y += msmouse.o ps2.o obj-y += qdev.o qdev-properties.o diff --git a/net-queue.c b/net-queue.c deleted file mode 100644 index f6b01e9..0000000 --- a/net-queue.c +++ /dev/null @@ -1,260 +0,0 @@ -/* - * Copyright (c) 2003-2008 Fabrice Bellard - * Copyright (c) 2009 Red Hat, Inc. - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to deal - * in the Software without restriction, including without limitation the rights - * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - * copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in - * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL - * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN - * THE SOFTWARE. - */ - -#include "net-queue.h" -#include "qemu-queue.h" - -/* The delivery handler may only return zero if it will call - * qemu_net_queue_flush() when it determines that it is once again able - * to deliver packets. It must also call qemu_net_queue_purge() in its - * cleanup path. - * - * If a sent callback is provided to send(), the caller must handle a - * zero return from the delivery handler by not sending any more packets - * until we have invoked the callback. Only in that case will we queue - * the packet. - * - * If a sent callback isn't provided, we just drop the packet to avoid - * unbounded queueing. - */ - -struct NetPacket { - QTAILQ_ENTRY(NetPacket) entry; - VLANClientState *sender; - unsigned flags; - int size; - NetPacketSent *sent_cb; - uint8_t data[0]; -}; - -struct NetQueue { - NetPacketDeliver *deliver; - NetPacketDeliverIOV *deliver_iov; - void *opaque; - - QTAILQ_HEAD(packets, NetPacket) packets; - - unsigned delivering : 1; -}; - -NetQueue *qemu_new_net_queue(NetPacketDeliver *deliver, - NetPacketDeliverIOV *deliver_iov, - void *opaque) -{ - NetQueue *queue; - - queue = qemu_mallocz(sizeof(NetQueue)); - - queue->deliver = deliver; - queue->deliver_iov = deliver_iov; - queue->opaque = opaque; - - QTAILQ_INIT(&queue->packets); - - queue->delivering = 0; - - return queue; -} - -void qemu_del_net_queue(NetQueue *queue) -{ - NetPacket *packet, *next; - - QTAILQ_FOREACH_SAFE(packet, &queue->packets, entry, next) { - QTAILQ_REMOVE(&queue->packets, packet, entry); - qemu_free(packet); - } - - qemu_free(queue); -} - -static ssize_t qemu_net_queue_append(NetQueue *queue, - VLANClientState *sender, - unsigned flags, - const uint8_t *buf, - size_t size, - NetPacketSent *sent_cb) -{ - NetPacket *packet; - - packet = qemu_malloc(sizeof(NetPacket) + size); - packet->sender = sender; - packet->flags = flags; - packet->size = size; - packet->sent_cb = sent_cb; - memcpy(packet->data, buf, size); - - QTAILQ_INSERT_TAIL(&queue->packets, packet, entry); - - return size; -} - -static ssize_t qemu_net_queue_append_iov(NetQueue *queue, - VLANClientState *sender, - unsigned flags, - const struct iovec *iov, - int iovcnt, - NetPacketSent *sent_cb) -{ - NetPacket *packet; - size_t max_len = 0; - int i; - - for (i = 0; i < iovcnt; i++) { - max_len += iov[i].iov_len; - } - - packet = qemu_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++) { - size_t len = iov[i].iov_len; - - memcpy(packet->data + packet->size, iov[i].iov_base, len); - packet->size += len; - } - - QTAILQ_INSERT_TAIL(&queue->packets, packet, entry); - - return packet->size; -} - -static ssize_t qemu_net_queue_deliver(NetQueue *queue, - VLANClientState *sender, - unsigned flags, - const uint8_t *data, - size_t size) -{ - ssize_t ret = -1; - - queue->delivering = 1; - ret = queue->deliver(sender, flags, data, size, queue->opaque); - queue->delivering = 0; - - return ret; -} - -static ssize_t qemu_net_queue_deliver_iov(NetQueue *queue, - VLANClientState *sender, - unsigned flags, - const struct iovec *iov, - int iovcnt) -{ - ssize_t ret = -1; - - queue->delivering = 1; - ret = queue->deliver_iov(sender, flags, iov, iovcnt, queue->opaque); - queue->delivering = 0; - - return ret; -} - -ssize_t qemu_net_queue_send(NetQueue *queue, - VLANClientState *sender, - unsigned flags, - const uint8_t *data, - size_t size, - NetPacketSent *sent_cb) -{ - ssize_t ret; - - if (queue->delivering) { - return qemu_net_queue_append(queue, sender, flags, data, size, NULL); - } - - ret = qemu_net_queue_deliver(queue, sender, flags, data, size); - if (ret == 0 && sent_cb != NULL) { - qemu_net_queue_append(queue, sender, flags, data, size, sent_cb); - return 0; - } - - qemu_net_queue_flush(queue); - - return ret; -} - -ssize_t qemu_net_queue_send_iov(NetQueue *queue, - VLANClientState *sender, - unsigned flags, - const struct iovec *iov, - int iovcnt, - NetPacketSent *sent_cb) -{ - ssize_t ret; - - if (queue->delivering) { - return qemu_net_queue_append_iov(queue, sender, flags, iov, iovcnt, NULL); - } - - ret = qemu_net_queue_deliver_iov(queue, sender, flags, iov, iovcnt); - if (ret == 0 && sent_cb != NULL) { - qemu_net_queue_append_iov(queue, sender, flags, iov, iovcnt, sent_cb); - return 0; - } - - qemu_net_queue_flush(queue); - - return ret; -} - -void qemu_net_queue_purge(NetQueue *queue, VLANClientState *from) -{ - NetPacket *packet, *next; - - QTAILQ_FOREACH_SAFE(packet, &queue->packets, entry, next) { - if (packet->sender == from) { - QTAILQ_REMOVE(&queue->packets, packet, entry); - qemu_free(packet); - } - } -} - -void qemu_net_queue_flush(NetQueue *queue) -{ - while (!QTAILQ_EMPTY(&queue->packets)) { - NetPacket *packet; - int ret; - - packet = QTAILQ_FIRST(&queue->packets); - QTAILQ_REMOVE(&queue->packets, packet, entry); - - ret = qemu_net_queue_deliver(queue, - packet->sender, - packet->flags, - packet->data, - packet->size); - if (ret == 0 && packet->sent_cb != NULL) { - QTAILQ_INSERT_HEAD(&queue->packets, packet, entry); - break; - } - - if (packet->sent_cb) { - packet->sent_cb(packet->sender, ret); - } - - qemu_free(packet); - } -} diff --git a/net-queue.h b/net-queue.h deleted file mode 100644 index a31958e..0000000 --- a/net-queue.h +++ /dev/null @@ -1,71 +0,0 @@ -/* - * Copyright (c) 2003-2008 Fabrice Bellard - * Copyright (c) 2009 Red Hat, Inc. - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to deal - * in the Software without restriction, including without limitation the rights - * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - * copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in - * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL - * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN - * THE SOFTWARE. - */ - -#ifndef QEMU_NET_QUEUE_H -#define QEMU_NET_QUEUE_H - -#include "qemu-common.h" - -typedef struct NetPacket NetPacket; -typedef struct NetQueue NetQueue; - -typedef void (NetPacketSent) (VLANClientState *sender, ssize_t ret); - -typedef ssize_t (NetPacketDeliver) (VLANClientState *sender, - unsigned flags, - const uint8_t *buf, - size_t size, - void *opaque); - -typedef ssize_t (NetPacketDeliverIOV) (VLANClientState *sender, - unsigned flags, - const struct iovec *iov, - int iovcnt, - void *opaque); - -#define QEMU_NET_PACKET_FLAG_NONE 0 -#define QEMU_NET_PACKET_FLAG_RAW (1<<0) - -NetQueue *qemu_new_net_queue(NetPacketDeliver *deliver, - NetPacketDeliverIOV *deliver_iov, - void *opaque); -void qemu_del_net_queue(NetQueue *queue); - -ssize_t qemu_net_queue_send(NetQueue *queue, - VLANClientState *sender, - unsigned flags, - const uint8_t *data, - size_t size, - NetPacketSent *sent_cb); - -ssize_t qemu_net_queue_send_iov(NetQueue *queue, - VLANClientState *sender, - unsigned flags, - const struct iovec *iov, - int iovcnt, - NetPacketSent *sent_cb); - -void qemu_net_queue_purge(NetQueue *queue, VLANClientState *from); -void qemu_net_queue_flush(NetQueue *queue); - -#endif /* QEMU_NET_QUEUE_H */ diff --git a/net.h b/net.h index 7e6cbf4..9ebb978 100644 --- a/net.h +++ b/net.h @@ -5,7 +5,7 @@ #include "qemu-common.h" #include "qdict.h" #include "qemu-option.h" -#include "net-queue.h" +#include "net/queue.h" /* VLANs support */ diff --git a/net/queue.c b/net/queue.c new file mode 100644 index 0000000..e91a9a5 --- /dev/null +++ b/net/queue.c @@ -0,0 +1,260 @@ +/* + * Copyright (c) 2003-2008 Fabrice Bellard + * Copyright (c) 2009 Red Hat, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#include "net/queue.h" +#include "qemu-queue.h" + +/* The delivery handler may only return zero if it will call + * qemu_net_queue_flush() when it determines that it is once again able + * to deliver packets. It must also call qemu_net_queue_purge() in its + * cleanup path. + * + * If a sent callback is provided to send(), the caller must handle a + * zero return from the delivery handler by not sending any more packets + * until we have invoked the callback. Only in that case will we queue + * the packet. + * + * If a sent callback isn't provided, we just drop the packet to avoid + * unbounded queueing. + */ + +struct NetPacket { + QTAILQ_ENTRY(NetPacket) entry; + VLANClientState *sender; + unsigned flags; + int size; + NetPacketSent *sent_cb; + uint8_t data[0]; +}; + +struct NetQueue { + NetPacketDeliver *deliver; + NetPacketDeliverIOV *deliver_iov; + void *opaque; + + QTAILQ_HEAD(packets, NetPacket) packets; + + unsigned delivering : 1; +}; + +NetQueue *qemu_new_net_queue(NetPacketDeliver *deliver, + NetPacketDeliverIOV *deliver_iov, + void *opaque) +{ + NetQueue *queue; + + queue = qemu_mallocz(sizeof(NetQueue)); + + queue->deliver = deliver; + queue->deliver_iov = deliver_iov; + queue->opaque = opaque; + + QTAILQ_INIT(&queue->packets); + + queue->delivering = 0; + + return queue; +} + +void qemu_del_net_queue(NetQueue *queue) +{ + NetPacket *packet, *next; + + QTAILQ_FOREACH_SAFE(packet, &queue->packets, entry, next) { + QTAILQ_REMOVE(&queue->packets, packet, entry); + qemu_free(packet); + } + + qemu_free(queue); +} + +static ssize_t qemu_net_queue_append(NetQueue *queue, + VLANClientState *sender, + unsigned flags, + const uint8_t *buf, + size_t size, + NetPacketSent *sent_cb) +{ + NetPacket *packet; + + packet = qemu_malloc(sizeof(NetPacket) + size); + packet->sender = sender; + packet->flags = flags; + packet->size = size; + packet->sent_cb = sent_cb; + memcpy(packet->data, buf, size); + + QTAILQ_INSERT_TAIL(&queue->packets, packet, entry); + + return size; +} + +static ssize_t qemu_net_queue_append_iov(NetQueue *queue, + VLANClientState *sender, + unsigned flags, + const struct iovec *iov, + int iovcnt, + NetPacketSent *sent_cb) +{ + NetPacket *packet; + size_t max_len = 0; + int i; + + for (i = 0; i < iovcnt; i++) { + max_len += iov[i].iov_len; + } + + packet = qemu_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++) { + size_t len = iov[i].iov_len; + + memcpy(packet->data + packet->size, iov[i].iov_base, len); + packet->size += len; + } + + QTAILQ_INSERT_TAIL(&queue->packets, packet, entry); + + return packet->size; +} + +static ssize_t qemu_net_queue_deliver(NetQueue *queue, + VLANClientState *sender, + unsigned flags, + const uint8_t *data, + size_t size) +{ + ssize_t ret = -1; + + queue->delivering = 1; + ret = queue->deliver(sender, flags, data, size, queue->opaque); + queue->delivering = 0; + + return ret; +} + +static ssize_t qemu_net_queue_deliver_iov(NetQueue *queue, + VLANClientState *sender, + unsigned flags, + const struct iovec *iov, + int iovcnt) +{ + ssize_t ret = -1; + + queue->delivering = 1; + ret = queue->deliver_iov(sender, flags, iov, iovcnt, queue->opaque); + queue->delivering = 0; + + return ret; +} + +ssize_t qemu_net_queue_send(NetQueue *queue, + VLANClientState *sender, + unsigned flags, + const uint8_t *data, + size_t size, + NetPacketSent *sent_cb) +{ + ssize_t ret; + + if (queue->delivering) { + return qemu_net_queue_append(queue, sender, flags, data, size, NULL); + } + + ret = qemu_net_queue_deliver(queue, sender, flags, data, size); + if (ret == 0 && sent_cb != NULL) { + qemu_net_queue_append(queue, sender, flags, data, size, sent_cb); + return 0; + } + + qemu_net_queue_flush(queue); + + return ret; +} + +ssize_t qemu_net_queue_send_iov(NetQueue *queue, + VLANClientState *sender, + unsigned flags, + const struct iovec *iov, + int iovcnt, + NetPacketSent *sent_cb) +{ + ssize_t ret; + + if (queue->delivering) { + return qemu_net_queue_append_iov(queue, sender, flags, iov, iovcnt, NULL); + } + + ret = qemu_net_queue_deliver_iov(queue, sender, flags, iov, iovcnt); + if (ret == 0 && sent_cb != NULL) { + qemu_net_queue_append_iov(queue, sender, flags, iov, iovcnt, sent_cb); + return 0; + } + + qemu_net_queue_flush(queue); + + return ret; +} + +void qemu_net_queue_purge(NetQueue *queue, VLANClientState *from) +{ + NetPacket *packet, *next; + + QTAILQ_FOREACH_SAFE(packet, &queue->packets, entry, next) { + if (packet->sender == from) { + QTAILQ_REMOVE(&queue->packets, packet, entry); + qemu_free(packet); + } + } +} + +void qemu_net_queue_flush(NetQueue *queue) +{ + while (!QTAILQ_EMPTY(&queue->packets)) { + NetPacket *packet; + int ret; + + packet = QTAILQ_FIRST(&queue->packets); + QTAILQ_REMOVE(&queue->packets, packet, entry); + + ret = qemu_net_queue_deliver(queue, + packet->sender, + packet->flags, + packet->data, + packet->size); + if (ret == 0 && packet->sent_cb != NULL) { + QTAILQ_INSERT_HEAD(&queue->packets, packet, entry); + break; + } + + if (packet->sent_cb) { + packet->sent_cb(packet->sender, ret); + } + + qemu_free(packet); + } +} diff --git a/net/queue.h b/net/queue.h new file mode 100644 index 0000000..a31958e --- /dev/null +++ b/net/queue.h @@ -0,0 +1,71 @@ +/* + * Copyright (c) 2003-2008 Fabrice Bellard + * Copyright (c) 2009 Red Hat, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#ifndef QEMU_NET_QUEUE_H +#define QEMU_NET_QUEUE_H + +#include "qemu-common.h" + +typedef struct NetPacket NetPacket; +typedef struct NetQueue NetQueue; + +typedef void (NetPacketSent) (VLANClientState *sender, ssize_t ret); + +typedef ssize_t (NetPacketDeliver) (VLANClientState *sender, + unsigned flags, + const uint8_t *buf, + size_t size, + void *opaque); + +typedef ssize_t (NetPacketDeliverIOV) (VLANClientState *sender, + unsigned flags, + const struct iovec *iov, + int iovcnt, + void *opaque); + +#define QEMU_NET_PACKET_FLAG_NONE 0 +#define QEMU_NET_PACKET_FLAG_RAW (1<<0) + +NetQueue *qemu_new_net_queue(NetPacketDeliver *deliver, + NetPacketDeliverIOV *deliver_iov, + void *opaque); +void qemu_del_net_queue(NetQueue *queue); + +ssize_t qemu_net_queue_send(NetQueue *queue, + VLANClientState *sender, + unsigned flags, + const uint8_t *data, + size_t size, + NetPacketSent *sent_cb); + +ssize_t qemu_net_queue_send_iov(NetQueue *queue, + VLANClientState *sender, + unsigned flags, + const struct iovec *iov, + int iovcnt, + NetPacketSent *sent_cb); + +void qemu_net_queue_purge(NetQueue *queue, VLANClientState *from); +void qemu_net_queue_flush(NetQueue *queue); + +#endif /* QEMU_NET_QUEUE_H */