net-queue.c

   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 "net-queue.h"
  25 #include "qemu-queue.h"
  26
  27 /* The delivery handler may only return zero if it will call
  28  * qemu_net_queue_flush() when it determines that it is once again able
  29  * to deliver packets. It must also call qemu_net_queue_purge() in its
  30  * cleanup path.
  31  *
  32  * If a sent callback is provided to send(), the caller must handle a
  33  * zero return from the delivery handler by not sending any more packets
  34  * until we have invoked the callback. Only in that case will we queue
  35  * the packet.
  36  *
  37  * If a sent callback isn't provided, we just drop the packet to avoid
  38  * unbounded queueing.
  39  */
  40
  41 struct NetPacket {
  42     QTAILQ_ENTRY(NetPacket) entry;
  43     VLANClientState *sender;
  44     int size;
  45     int raw;
  46     NetPacketSent *sent_cb;
  47     uint8_t data[0];
  48 };
  49
  50 struct NetQueue {
  51     NetPacketDeliver *deliver;
  52     NetPacketDeliverIOV *deliver_iov;
  53     void *opaque;
  54
  55     QTAILQ_HEAD(packets, NetPacket) packets;
  56
  57     unsigned delivering : 1;
  58 };
  59
  60 NetQueue *qemu_new_net_queue(NetPacketDeliver *deliver,
  61                              NetPacketDeliverIOV *deliver_iov,
  62                              void *opaque)
  63 {
  64     NetQueue *queue;
  65
  66     queue = qemu_mallocz(sizeof(NetQueue));
  67
  68     queue->deliver = deliver;
  69     queue->deliver_iov = deliver_iov;
  70     queue->opaque = opaque;
  71
  72     QTAILQ_INIT(&queue->packets);
  73
  74     queue->delivering = 0;
  75
  76     return queue;
  77 }
  78
  79 void qemu_del_net_queue(NetQueue *queue)
  80 {
  81     NetPacket *packet, *next;
  82
  83     QTAILQ_FOREACH_SAFE(packet, &queue->packets, entry, next) {
  84         QTAILQ_REMOVE(&queue->packets, packet, entry);
  85         qemu_free(packet);
  86     }
  87
  88     qemu_free(queue);
  89 }
  90
  91 static ssize_t qemu_net_queue_append(NetQueue *queue,
  92                                      VLANClientState *sender,
  93                                      const uint8_t *buf,
  94                                      size_t size,
  95                                      int raw,
  96                                      NetPacketSent *sent_cb)
  97 {
  98     NetPacket *packet;
  99
 100     packet = qemu_malloc(sizeof(NetPacket) + size);
 101     packet->sender = sender;
 102     packet->size = size;
 103     packet->raw = raw;
 104     packet->sent_cb = sent_cb;
 105     memcpy(packet->data, buf, size);
 106
 107     QTAILQ_INSERT_TAIL(&queue->packets, packet, entry);
 108
 109     return size;
 110 }
 111
 112 static ssize_t qemu_net_queue_append_iov(NetQueue *queue,
 113                                          VLANClientState *sender,
 114                                          const struct iovec *iov,
 115                                          int iovcnt,
 116                                          NetPacketSent *sent_cb)
 117 {
 118     NetPacket *packet;
 119     size_t max_len = 0;
 120     int i;
 121
 122     for (i = 0; i < iovcnt; i++) {
 123         max_len += iov[i].iov_len;
 124     }
 125
 126     packet = qemu_malloc(sizeof(NetPacket) + max_len);
 127     packet->sender = sender;
 128     packet->sent_cb = sent_cb;
 129     packet->size = 0;
 130     packet->raw = 0;
 131
 132     for (i = 0; i < iovcnt; i++) {
 133         size_t len = iov[i].iov_len;
 134
 135         memcpy(packet->data + packet->size, iov[i].iov_base, len);
 136         packet->size += len;
 137     }
 138
 139     QTAILQ_INSERT_TAIL(&queue->packets, packet, entry);
 140
 141     return packet->size;
 142 }
 143
 144 static ssize_t qemu_net_queue_deliver(NetQueue *queue,
 145                                       VLANClientState *sender,
 146                                       const uint8_t *data,
 147                                       size_t size,
 148                                       int raw)
 149 {
 150     ssize_t ret = -1;
 151
 152     queue->delivering = 1;
 153     ret = queue->deliver(sender, data, size, raw, queue->opaque);
 154     queue->delivering = 0;
 155
 156     return ret;
 157 }
 158
 159 static ssize_t qemu_net_queue_deliver_iov(NetQueue *queue,
 160                                           VLANClientState *sender,
 161                                           const struct iovec *iov,
 162                                           int iovcnt)
 163 {
 164     ssize_t ret = -1;
 165
 166     queue->delivering = 1;
 167     ret = queue->deliver_iov(sender, iov, iovcnt, queue->opaque);
 168     queue->delivering = 0;
 169
 170     return ret;
 171 }
 172
 173 ssize_t qemu_net_queue_send(NetQueue *queue,
 174                             VLANClientState *sender,
 175                             const uint8_t *data,
 176                             size_t size,
 177                             int raw,
 178                             NetPacketSent *sent_cb)
 179 {
 180     ssize_t ret;
 181
 182     if (queue->delivering) {
 183         return qemu_net_queue_append(queue, sender, data, size, raw, NULL);
 184     }
 185
 186     ret = qemu_net_queue_deliver(queue, sender, data, size, raw);
 187     if (ret == 0 && sent_cb != NULL) {
 188         qemu_net_queue_append(queue, sender, data, size, raw, sent_cb);
 189         return 0;
 190     }
 191
 192     qemu_net_queue_flush(queue);
 193
 194     return ret;
 195 }
 196
 197 ssize_t qemu_net_queue_send_iov(NetQueue *queue,
 198                                 VLANClientState *sender,
 199                                 const struct iovec *iov,
 200                                 int iovcnt,
 201                                 NetPacketSent *sent_cb)
 202 {
 203     ssize_t ret;
 204
 205     if (queue->delivering) {
 206         return qemu_net_queue_append_iov(queue, sender, iov, iovcnt, NULL);
 207     }
 208
 209     ret = qemu_net_queue_deliver_iov(queue, sender, iov, iovcnt);
 210     if (ret == 0 && sent_cb != NULL) {
 211         qemu_net_queue_append_iov(queue, sender, iov, iovcnt, sent_cb);
 212         return 0;
 213     }
 214
 215     qemu_net_queue_flush(queue);
 216
 217     return ret;
 218 }
 219
 220 void qemu_net_queue_purge(NetQueue *queue, VLANClientState *from)
 221 {
 222     NetPacket *packet, *next;
 223
 224     QTAILQ_FOREACH_SAFE(packet, &queue->packets, entry, next) {
 225         if (packet->sender == from) {
 226             QTAILQ_REMOVE(&queue->packets, packet, entry);
 227             qemu_free(packet);
 228         }
 229     }
 230 }
 231
 232 void qemu_net_queue_flush(NetQueue *queue)
 233 {
 234     while (!QTAILQ_EMPTY(&queue->packets)) {
 235         NetPacket *packet;
 236         int ret;
 237
 238         packet = QTAILQ_FIRST(&queue->packets);
 239         QTAILQ_REMOVE(&queue->packets, packet, entry);
 240
 241         ret = qemu_net_queue_deliver(queue,
 242                                      packet->sender,
 243                                      packet->data,
 244                                      packet->size,
 245                                      packet->raw);
 246         if (ret == 0 && packet->sent_cb != NULL) {
 247             QTAILQ_INSERT_HEAD(&queue->packets, packet, entry);
 248             break;
 249         }
 250
 251         if (packet->sent_cb) {
 252             packet->sent_cb(packet->sender, ret);
 253         }
 254
 255         qemu_free(packet);
 256     }
 257 }