blob: 9c32abdb8f44b88acd368ca5f7339e255c0b74eb [file] [log] [blame]
Mark McLoughlinf7105842009-10-08 19:58:31 +01001/*
2 * Copyright (c) 2003-2008 Fabrice Bellard
3 * Copyright (c) 2009 Red Hat, Inc.
4 *
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:
11 *
12 * The above copyright notice and this permission notice shall be included in
13 * all copies or substantial portions of the Software.
14 *
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
21 * THE SOFTWARE.
22 */
23
Peter Maydell2744d922016-01-29 17:50:00 +000024#include "qemu/osdep.h"
Mark McLoughline1144d02009-10-23 17:52:16 +010025#include "net/queue.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010026#include "qemu/queue.h"
Paolo Bonzini1422e322012-10-24 08:43:34 +020027#include "net/net.h"
Mark McLoughlinf7105842009-10-08 19:58:31 +010028
29/* The delivery handler may only return zero if it will call
30 * qemu_net_queue_flush() when it determines that it is once again able
31 * to deliver packets. It must also call qemu_net_queue_purge() in its
32 * cleanup path.
33 *
34 * If a sent callback is provided to send(), the caller must handle a
35 * zero return from the delivery handler by not sending any more packets
36 * until we have invoked the callback. Only in that case will we queue
37 * the packet.
38 *
39 * If a sent callback isn't provided, we just drop the packet to avoid
40 * unbounded queueing.
41 */
42
43struct NetPacket {
44 QTAILQ_ENTRY(NetPacket) entry;
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +010045 NetClientState *sender;
Mark McLoughlinc0b8e492009-10-22 17:43:40 +010046 unsigned flags;
Mark McLoughlinf7105842009-10-08 19:58:31 +010047 int size;
48 NetPacketSent *sent_cb;
49 uint8_t data[0];
50};
51
52struct NetQueue {
Mark McLoughlinf7105842009-10-08 19:58:31 +010053 void *opaque;
Luigi Rizzo7d91ddd2013-02-05 18:29:09 +010054 uint32_t nq_maxlen;
55 uint32_t nq_count;
Yang Hongyang3e033a42015-10-07 11:52:17 +080056 NetQueueDeliverFunc *deliver;
Mark McLoughlinf7105842009-10-08 19:58:31 +010057
58 QTAILQ_HEAD(packets, NetPacket) packets;
59
60 unsigned delivering : 1;
61};
62
Yang Hongyang3e033a42015-10-07 11:52:17 +080063NetQueue *qemu_new_net_queue(NetQueueDeliverFunc *deliver, void *opaque)
Mark McLoughlinf7105842009-10-08 19:58:31 +010064{
65 NetQueue *queue;
66
Markus Armbruster58889fe2014-12-04 14:28:17 +010067 queue = g_new0(NetQueue, 1);
Mark McLoughlinf7105842009-10-08 19:58:31 +010068
Mark McLoughlinf7105842009-10-08 19:58:31 +010069 queue->opaque = opaque;
Luigi Rizzo7d91ddd2013-02-05 18:29:09 +010070 queue->nq_maxlen = 10000;
71 queue->nq_count = 0;
Yang Hongyang3e033a42015-10-07 11:52:17 +080072 queue->deliver = deliver;
Mark McLoughlinf7105842009-10-08 19:58:31 +010073
74 QTAILQ_INIT(&queue->packets);
75
76 queue->delivering = 0;
77
78 return queue;
79}
80
81void qemu_del_net_queue(NetQueue *queue)
82{
83 NetPacket *packet, *next;
84
85 QTAILQ_FOREACH_SAFE(packet, &queue->packets, entry, next) {
86 QTAILQ_REMOVE(&queue->packets, packet, entry);
Anthony Liguori7267c092011-08-20 22:09:37 -050087 g_free(packet);
Mark McLoughlinf7105842009-10-08 19:58:31 +010088 }
89
Anthony Liguori7267c092011-08-20 22:09:37 -050090 g_free(queue);
Mark McLoughlinf7105842009-10-08 19:58:31 +010091}
92
Stefan Hajnoczi06b5f362012-08-20 13:35:23 +010093static void qemu_net_queue_append(NetQueue *queue,
94 NetClientState *sender,
95 unsigned flags,
96 const uint8_t *buf,
97 size_t size,
98 NetPacketSent *sent_cb)
Mark McLoughlinf7105842009-10-08 19:58:31 +010099{
100 NetPacket *packet;
101
Luigi Rizzo7d91ddd2013-02-05 18:29:09 +0100102 if (queue->nq_count >= queue->nq_maxlen && !sent_cb) {
103 return; /* drop if queue full and no callback */
104 }
Anthony Liguori7267c092011-08-20 22:09:37 -0500105 packet = g_malloc(sizeof(NetPacket) + size);
Mark McLoughlinf7105842009-10-08 19:58:31 +0100106 packet->sender = sender;
Mark McLoughlinc0b8e492009-10-22 17:43:40 +0100107 packet->flags = flags;
Mark McLoughlinf7105842009-10-08 19:58:31 +0100108 packet->size = size;
109 packet->sent_cb = sent_cb;
110 memcpy(packet->data, buf, size);
111
Luigi Rizzo7d91ddd2013-02-05 18:29:09 +0100112 queue->nq_count++;
Mark McLoughlinf7105842009-10-08 19:58:31 +0100113 QTAILQ_INSERT_TAIL(&queue->packets, packet, entry);
Mark McLoughlinf7105842009-10-08 19:58:31 +0100114}
115
Yang Hongyangb68c7f72015-10-07 11:52:20 +0800116void qemu_net_queue_append_iov(NetQueue *queue,
117 NetClientState *sender,
118 unsigned flags,
119 const struct iovec *iov,
120 int iovcnt,
121 NetPacketSent *sent_cb)
Mark McLoughlinf7105842009-10-08 19:58:31 +0100122{
123 NetPacket *packet;
124 size_t max_len = 0;
125 int i;
126
Luigi Rizzo7d91ddd2013-02-05 18:29:09 +0100127 if (queue->nq_count >= queue->nq_maxlen && !sent_cb) {
128 return; /* drop if queue full and no callback */
129 }
Mark McLoughlinf7105842009-10-08 19:58:31 +0100130 for (i = 0; i < iovcnt; i++) {
131 max_len += iov[i].iov_len;
132 }
133
Anthony Liguori7267c092011-08-20 22:09:37 -0500134 packet = g_malloc(sizeof(NetPacket) + max_len);
Mark McLoughlinf7105842009-10-08 19:58:31 +0100135 packet->sender = sender;
136 packet->sent_cb = sent_cb;
Mark McLoughlinc0b8e492009-10-22 17:43:40 +0100137 packet->flags = flags;
Mark McLoughlinf7105842009-10-08 19:58:31 +0100138 packet->size = 0;
139
140 for (i = 0; i < iovcnt; i++) {
141 size_t len = iov[i].iov_len;
142
143 memcpy(packet->data + packet->size, iov[i].iov_base, len);
144 packet->size += len;
145 }
146
Luigi Rizzo7d91ddd2013-02-05 18:29:09 +0100147 queue->nq_count++;
Mark McLoughlinf7105842009-10-08 19:58:31 +0100148 QTAILQ_INSERT_TAIL(&queue->packets, packet, entry);
Mark McLoughlinf7105842009-10-08 19:58:31 +0100149}
150
151static ssize_t qemu_net_queue_deliver(NetQueue *queue,
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +0100152 NetClientState *sender,
Mark McLoughlinc0b8e492009-10-22 17:43:40 +0100153 unsigned flags,
Mark McLoughlinf7105842009-10-08 19:58:31 +0100154 const uint8_t *data,
155 size_t size)
156{
157 ssize_t ret = -1;
Yang Hongyangfefe2a72015-10-07 11:52:16 +0800158 struct iovec iov = {
159 .iov_base = (void *)data,
160 .iov_len = size
161 };
Mark McLoughlinf7105842009-10-08 19:58:31 +0100162
163 queue->delivering = 1;
Yang Hongyang3e033a42015-10-07 11:52:17 +0800164 ret = queue->deliver(sender, flags, &iov, 1, queue->opaque);
Mark McLoughlinf7105842009-10-08 19:58:31 +0100165 queue->delivering = 0;
166
167 return ret;
168}
169
170static ssize_t qemu_net_queue_deliver_iov(NetQueue *queue,
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +0100171 NetClientState *sender,
Mark McLoughlinc0b8e492009-10-22 17:43:40 +0100172 unsigned flags,
Mark McLoughlinf7105842009-10-08 19:58:31 +0100173 const struct iovec *iov,
174 int iovcnt)
175{
176 ssize_t ret = -1;
177
178 queue->delivering = 1;
Yang Hongyang3e033a42015-10-07 11:52:17 +0800179 ret = queue->deliver(sender, flags, iov, iovcnt, queue->opaque);
Mark McLoughlinf7105842009-10-08 19:58:31 +0100180 queue->delivering = 0;
181
182 return ret;
183}
184
185ssize_t qemu_net_queue_send(NetQueue *queue,
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +0100186 NetClientState *sender,
Mark McLoughlinc0b8e492009-10-22 17:43:40 +0100187 unsigned flags,
Mark McLoughlinf7105842009-10-08 19:58:31 +0100188 const uint8_t *data,
189 size_t size,
190 NetPacketSent *sent_cb)
191{
192 ssize_t ret;
193
Zhi Yong Wu691a4f32012-07-24 16:35:18 +0100194 if (queue->delivering || !qemu_can_send_packet(sender)) {
Stefan Hajnoczi06b5f362012-08-20 13:35:23 +0100195 qemu_net_queue_append(queue, sender, flags, data, size, sent_cb);
196 return 0;
Mark McLoughlinf7105842009-10-08 19:58:31 +0100197 }
198
Mark McLoughlinc0b8e492009-10-22 17:43:40 +0100199 ret = qemu_net_queue_deliver(queue, sender, flags, data, size);
Mark McLoughlin839f3682009-10-27 18:16:37 +0000200 if (ret == 0) {
Mark McLoughlinc0b8e492009-10-22 17:43:40 +0100201 qemu_net_queue_append(queue, sender, flags, data, size, sent_cb);
Mark McLoughlinf7105842009-10-08 19:58:31 +0100202 return 0;
203 }
204
205 qemu_net_queue_flush(queue);
206
207 return ret;
208}
209
210ssize_t qemu_net_queue_send_iov(NetQueue *queue,
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +0100211 NetClientState *sender,
Mark McLoughlinc0b8e492009-10-22 17:43:40 +0100212 unsigned flags,
Mark McLoughlinf7105842009-10-08 19:58:31 +0100213 const struct iovec *iov,
214 int iovcnt,
215 NetPacketSent *sent_cb)
216{
217 ssize_t ret;
218
Zhi Yong Wu691a4f32012-07-24 16:35:18 +0100219 if (queue->delivering || !qemu_can_send_packet(sender)) {
Stefan Hajnoczi06b5f362012-08-20 13:35:23 +0100220 qemu_net_queue_append_iov(queue, sender, flags, iov, iovcnt, sent_cb);
221 return 0;
Mark McLoughlinf7105842009-10-08 19:58:31 +0100222 }
223
Mark McLoughlinc0b8e492009-10-22 17:43:40 +0100224 ret = qemu_net_queue_deliver_iov(queue, sender, flags, iov, iovcnt);
Mark McLoughlin839f3682009-10-27 18:16:37 +0000225 if (ret == 0) {
Mark McLoughlinc0b8e492009-10-22 17:43:40 +0100226 qemu_net_queue_append_iov(queue, sender, flags, iov, iovcnt, sent_cb);
Mark McLoughlinf7105842009-10-08 19:58:31 +0100227 return 0;
228 }
229
230 qemu_net_queue_flush(queue);
231
232 return ret;
233}
234
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +0100235void qemu_net_queue_purge(NetQueue *queue, NetClientState *from)
Mark McLoughlinf7105842009-10-08 19:58:31 +0100236{
237 NetPacket *packet, *next;
238
239 QTAILQ_FOREACH_SAFE(packet, &queue->packets, entry, next) {
240 if (packet->sender == from) {
241 QTAILQ_REMOVE(&queue->packets, packet, entry);
Luigi Rizzo7d91ddd2013-02-05 18:29:09 +0100242 queue->nq_count--;
Michael S. Tsirkin07d80842014-09-04 11:39:10 +0300243 if (packet->sent_cb) {
244 packet->sent_cb(packet->sender, 0);
245 }
Anthony Liguori7267c092011-08-20 22:09:37 -0500246 g_free(packet);
Mark McLoughlinf7105842009-10-08 19:58:31 +0100247 }
248 }
249}
250
Paolo Bonzini987a9b42012-08-09 16:45:55 +0200251bool qemu_net_queue_flush(NetQueue *queue)
Mark McLoughlinf7105842009-10-08 19:58:31 +0100252{
253 while (!QTAILQ_EMPTY(&queue->packets)) {
254 NetPacket *packet;
255 int ret;
256
257 packet = QTAILQ_FIRST(&queue->packets);
258 QTAILQ_REMOVE(&queue->packets, packet, entry);
Luigi Rizzo7d91ddd2013-02-05 18:29:09 +0100259 queue->nq_count--;
Mark McLoughlinf7105842009-10-08 19:58:31 +0100260
261 ret = qemu_net_queue_deliver(queue,
262 packet->sender,
Mark McLoughlinc0b8e492009-10-22 17:43:40 +0100263 packet->flags,
Mark McLoughlinf7105842009-10-08 19:58:31 +0100264 packet->data,
265 packet->size);
Mark McLoughlin839f3682009-10-27 18:16:37 +0000266 if (ret == 0) {
Luigi Rizzo7d91ddd2013-02-05 18:29:09 +0100267 queue->nq_count++;
Mark McLoughlinf7105842009-10-08 19:58:31 +0100268 QTAILQ_INSERT_HEAD(&queue->packets, packet, entry);
Paolo Bonzini987a9b42012-08-09 16:45:55 +0200269 return false;
Mark McLoughlinf7105842009-10-08 19:58:31 +0100270 }
271
272 if (packet->sent_cb) {
273 packet->sent_cb(packet->sender, ret);
274 }
275
Anthony Liguori7267c092011-08-20 22:09:37 -0500276 g_free(packet);
Mark McLoughlinf7105842009-10-08 19:58:31 +0100277 }
Paolo Bonzini987a9b42012-08-09 16:45:55 +0200278 return true;
Mark McLoughlinf7105842009-10-08 19:58:31 +0100279}