2 * Copyright (c) 2003-2008 Fabrice Bellard
3 * Copyright (c) 2009 Red Hat, Inc.
5 * Permission is hereby granted, free of charge, to any person obtaining a copy
6 * of this software and associated documentation files (the "Software"), to deal
7 * in the Software without restriction, including without limitation the rights
8 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 * copies of the Software, and to permit persons to whom the Software is
10 * furnished to do so, subject to the following conditions:
12 * The above copyright notice and this permission notice shall be included in
13 * all copies or substantial portions of the Software.
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 #include "net/queue.h"
25 #include "qemu-queue.h"
28 /* The delivery handler may only return zero if it will call
29 * qemu_net_queue_flush() when it determines that it is once again able
30 * to deliver packets. It must also call qemu_net_queue_purge() in its
33 * If a sent callback is provided to send(), the caller must handle a
34 * zero return from the delivery handler by not sending any more packets
35 * until we have invoked the callback. Only in that case will we queue
38 * If a sent callback isn't provided, we just drop the packet to avoid
43 QTAILQ_ENTRY(NetPacket
) entry
;
44 NetClientState
*sender
;
47 NetPacketSent
*sent_cb
;
54 QTAILQ_HEAD(packets
, NetPacket
) packets
;
56 unsigned delivering
: 1;
59 NetQueue
*qemu_new_net_queue(void *opaque
)
63 queue
= g_malloc0(sizeof(NetQueue
));
65 queue
->opaque
= opaque
;
67 QTAILQ_INIT(&queue
->packets
);
69 queue
->delivering
= 0;
74 void qemu_del_net_queue(NetQueue
*queue
)
76 NetPacket
*packet
, *next
;
78 QTAILQ_FOREACH_SAFE(packet
, &queue
->packets
, entry
, next
) {
79 QTAILQ_REMOVE(&queue
->packets
, packet
, entry
);
86 static ssize_t
qemu_net_queue_append(NetQueue
*queue
,
87 NetClientState
*sender
,
91 NetPacketSent
*sent_cb
)
95 packet
= g_malloc(sizeof(NetPacket
) + size
);
96 packet
->sender
= sender
;
97 packet
->flags
= flags
;
99 packet
->sent_cb
= sent_cb
;
100 memcpy(packet
->data
, buf
, size
);
102 QTAILQ_INSERT_TAIL(&queue
->packets
, packet
, entry
);
107 static ssize_t
qemu_net_queue_append_iov(NetQueue
*queue
,
108 NetClientState
*sender
,
110 const struct iovec
*iov
,
112 NetPacketSent
*sent_cb
)
118 for (i
= 0; i
< iovcnt
; i
++) {
119 max_len
+= iov
[i
].iov_len
;
122 packet
= g_malloc(sizeof(NetPacket
) + max_len
);
123 packet
->sender
= sender
;
124 packet
->sent_cb
= sent_cb
;
125 packet
->flags
= flags
;
128 for (i
= 0; i
< iovcnt
; i
++) {
129 size_t len
= iov
[i
].iov_len
;
131 memcpy(packet
->data
+ packet
->size
, iov
[i
].iov_base
, len
);
135 QTAILQ_INSERT_TAIL(&queue
->packets
, packet
, entry
);
140 static ssize_t
qemu_net_queue_deliver(NetQueue
*queue
,
141 NetClientState
*sender
,
148 queue
->delivering
= 1;
149 ret
= qemu_deliver_packet(sender
, flags
, data
, size
, queue
->opaque
);
150 queue
->delivering
= 0;
155 static ssize_t
qemu_net_queue_deliver_iov(NetQueue
*queue
,
156 NetClientState
*sender
,
158 const struct iovec
*iov
,
163 queue
->delivering
= 1;
164 ret
= qemu_deliver_packet_iov(sender
, flags
, iov
, iovcnt
, queue
->opaque
);
165 queue
->delivering
= 0;
170 ssize_t
qemu_net_queue_send(NetQueue
*queue
,
171 NetClientState
*sender
,
175 NetPacketSent
*sent_cb
)
179 if (queue
->delivering
|| !qemu_can_send_packet(sender
)) {
180 return qemu_net_queue_append(queue
, sender
, flags
, data
, size
, sent_cb
);
183 ret
= qemu_net_queue_deliver(queue
, sender
, flags
, data
, size
);
185 qemu_net_queue_append(queue
, sender
, flags
, data
, size
, sent_cb
);
189 qemu_net_queue_flush(queue
);
194 ssize_t
qemu_net_queue_send_iov(NetQueue
*queue
,
195 NetClientState
*sender
,
197 const struct iovec
*iov
,
199 NetPacketSent
*sent_cb
)
203 if (queue
->delivering
|| !qemu_can_send_packet(sender
)) {
204 return qemu_net_queue_append_iov(queue
, sender
, flags
,
205 iov
, iovcnt
, sent_cb
);
208 ret
= qemu_net_queue_deliver_iov(queue
, sender
, flags
, iov
, iovcnt
);
210 qemu_net_queue_append_iov(queue
, sender
, flags
, iov
, iovcnt
, sent_cb
);
214 qemu_net_queue_flush(queue
);
219 void qemu_net_queue_purge(NetQueue
*queue
, NetClientState
*from
)
221 NetPacket
*packet
, *next
;
223 QTAILQ_FOREACH_SAFE(packet
, &queue
->packets
, entry
, next
) {
224 if (packet
->sender
== from
) {
225 QTAILQ_REMOVE(&queue
->packets
, packet
, entry
);
231 void qemu_net_queue_flush(NetQueue
*queue
)
233 while (!QTAILQ_EMPTY(&queue
->packets
)) {
237 packet
= QTAILQ_FIRST(&queue
->packets
);
238 QTAILQ_REMOVE(&queue
->packets
, packet
, entry
);
240 ret
= qemu_net_queue_deliver(queue
,
246 QTAILQ_INSERT_HEAD(&queue
->packets
, packet
, entry
);
250 if (packet
->sent_cb
) {
251 packet
->sent_cb(packet
->sender
, ret
);