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