1 /* 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 24 #include "qemu/osdep.h" 25 #include "net/queue.h" 26 #include "qemu/queue.h" 27 #include "net/net.h" 28 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 43 struct NetPacket { 44 QTAILQ_ENTRY(NetPacket) entry; 45 NetClientState *sender; 46 unsigned flags; 47 int size; 48 NetPacketSent *sent_cb; 49 uint8_t data[]; 50 }; 51 52 struct NetQueue { 53 void *opaque; 54 uint32_t nq_maxlen; 55 uint32_t nq_count; 56 NetQueueDeliverFunc *deliver; 57 58 QTAILQ_HEAD(, NetPacket) packets; 59 60 unsigned delivering : 1; 61 }; 62 63 NetQueue *qemu_new_net_queue(NetQueueDeliverFunc *deliver, void *opaque) 64 { 65 NetQueue *queue; 66 67 queue = g_new0(NetQueue, 1); 68 69 queue->opaque = opaque; 70 queue->nq_maxlen = 10000; 71 queue->nq_count = 0; 72 queue->deliver = deliver; 73 74 QTAILQ_INIT(&queue->packets); 75 76 queue->delivering = 0; 77 78 return queue; 79 } 80 81 void 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); 87 g_free(packet); 88 } 89 90 g_free(queue); 91 } 92 93 static 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) 99 { 100 NetPacket *packet; 101 102 if (queue->nq_count >= queue->nq_maxlen && !sent_cb) { 103 return; /* drop if queue full and no callback */ 104 } 105 packet = g_malloc(sizeof(NetPacket) + size); 106 packet->sender = sender; 107 packet->flags = flags; 108 packet->size = size; 109 packet->sent_cb = sent_cb; 110 memcpy(packet->data, buf, size); 111 112 queue->nq_count++; 113 QTAILQ_INSERT_TAIL(&queue->packets, packet, entry); 114 } 115 116 void 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) 122 { 123 NetPacket *packet; 124 size_t max_len = 0; 125 int i; 126 127 if (queue->nq_count >= queue->nq_maxlen && !sent_cb) { 128 return; /* drop if queue full and no callback */ 129 } 130 for (i = 0; i < iovcnt; i++) { 131 max_len += iov[i].iov_len; 132 } 133 134 packet = g_malloc(sizeof(NetPacket) + max_len); 135 packet->sender = sender; 136 packet->sent_cb = sent_cb; 137 packet->flags = flags; 138 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 147 queue->nq_count++; 148 QTAILQ_INSERT_TAIL(&queue->packets, packet, entry); 149 } 150 151 static ssize_t qemu_net_queue_deliver(NetQueue *queue, 152 NetClientState *sender, 153 unsigned flags, 154 const uint8_t *data, 155 size_t size) 156 { 157 ssize_t ret = -1; 158 struct iovec iov = { 159 .iov_base = (void *)data, 160 .iov_len = size 161 }; 162 163 queue->delivering = 1; 164 ret = queue->deliver(sender, flags, &iov, 1, queue->opaque); 165 queue->delivering = 0; 166 167 return ret; 168 } 169 170 static ssize_t qemu_net_queue_deliver_iov(NetQueue *queue, 171 NetClientState *sender, 172 unsigned flags, 173 const struct iovec *iov, 174 int iovcnt) 175 { 176 ssize_t ret = -1; 177 178 queue->delivering = 1; 179 ret = queue->deliver(sender, flags, iov, iovcnt, queue->opaque); 180 queue->delivering = 0; 181 182 return ret; 183 } 184 185 ssize_t qemu_net_queue_receive(NetQueue *queue, 186 const uint8_t *data, 187 size_t size) 188 { 189 if (queue->delivering) { 190 return 0; 191 } 192 193 return qemu_net_queue_deliver(queue, NULL, 0, data, size); 194 } 195 196 ssize_t qemu_net_queue_receive_iov(NetQueue *queue, 197 const struct iovec *iov, 198 int iovcnt) 199 { 200 if (queue->delivering) { 201 return 0; 202 } 203 204 return qemu_net_queue_deliver_iov(queue, NULL, 0, iov, iovcnt); 205 } 206 207 ssize_t qemu_net_queue_send(NetQueue *queue, 208 NetClientState *sender, 209 unsigned flags, 210 const uint8_t *data, 211 size_t size, 212 NetPacketSent *sent_cb) 213 { 214 ssize_t ret; 215 216 if (queue->delivering || !qemu_can_send_packet(sender)) { 217 qemu_net_queue_append(queue, sender, flags, data, size, sent_cb); 218 return 0; 219 } 220 221 ret = qemu_net_queue_deliver(queue, sender, flags, data, size); 222 if (ret == 0) { 223 qemu_net_queue_append(queue, sender, flags, data, size, sent_cb); 224 return 0; 225 } 226 227 qemu_net_queue_flush(queue); 228 229 return ret; 230 } 231 232 ssize_t qemu_net_queue_send_iov(NetQueue *queue, 233 NetClientState *sender, 234 unsigned flags, 235 const struct iovec *iov, 236 int iovcnt, 237 NetPacketSent *sent_cb) 238 { 239 ssize_t ret; 240 241 if (queue->delivering || !qemu_can_send_packet(sender)) { 242 qemu_net_queue_append_iov(queue, sender, flags, iov, iovcnt, sent_cb); 243 return 0; 244 } 245 246 ret = qemu_net_queue_deliver_iov(queue, sender, flags, iov, iovcnt); 247 if (ret == 0) { 248 qemu_net_queue_append_iov(queue, sender, flags, iov, iovcnt, sent_cb); 249 return 0; 250 } 251 252 qemu_net_queue_flush(queue); 253 254 return ret; 255 } 256 257 void qemu_net_queue_purge(NetQueue *queue, NetClientState *from) 258 { 259 NetPacket *packet, *next; 260 261 QTAILQ_FOREACH_SAFE(packet, &queue->packets, entry, next) { 262 if (packet->sender == from) { 263 QTAILQ_REMOVE(&queue->packets, packet, entry); 264 queue->nq_count--; 265 if (packet->sent_cb) { 266 packet->sent_cb(packet->sender, 0); 267 } 268 g_free(packet); 269 } 270 } 271 } 272 273 bool qemu_net_queue_flush(NetQueue *queue) 274 { 275 if (queue->delivering) 276 return false; 277 278 while (!QTAILQ_EMPTY(&queue->packets)) { 279 NetPacket *packet; 280 int ret; 281 282 packet = QTAILQ_FIRST(&queue->packets); 283 QTAILQ_REMOVE(&queue->packets, packet, entry); 284 queue->nq_count--; 285 286 ret = qemu_net_queue_deliver(queue, 287 packet->sender, 288 packet->flags, 289 packet->data, 290 packet->size); 291 if (ret == 0) { 292 queue->nq_count++; 293 QTAILQ_INSERT_HEAD(&queue->packets, packet, entry); 294 return false; 295 } 296 297 if (packet->sent_cb) { 298 packet->sent_cb(packet->sender, ret); 299 } 300 301 g_free(packet); 302 } 303 return true; 304 } 305