blob: d312b9c83c7f2ede40116dd9b20d40e107adf510 [file] [log] [blame]
aliguorifbe78f42008-12-17 19:13:11 +00001/*
2 * Virtio Network Device
3 *
4 * Copyright IBM, Corp. 2007
5 *
6 * Authors:
7 * Anthony Liguori <aliguori@us.ibm.com>
8 *
9 * This work is licensed under the terms of the GNU GPL, version 2. See
10 * the COPYING file in the top-level directory.
11 *
12 */
13
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010014#include "qemu/iov.h"
Paolo Bonzini0d09e412013-02-05 17:06:20 +010015#include "hw/virtio/virtio.h"
Paolo Bonzini1422e322012-10-24 08:43:34 +020016#include "net/net.h"
Mark McLoughlin7200ac32009-10-22 17:49:03 +010017#include "net/checksum.h"
Mark McLoughlina8ed73f2009-10-22 17:49:05 +010018#include "net/tap.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010019#include "qemu/error-report.h"
20#include "qemu/timer.h"
Paolo Bonzini0d09e412013-02-05 17:06:20 +010021#include "hw/virtio/virtio-net.h"
22#include "net/vhost_net.h"
KONRAD Frederic17ec5a82013-04-11 16:29:57 +020023#include "hw/virtio/virtio-bus.h"
Amos Kongb1be4282013-06-14 15:45:52 +080024#include "qapi/qmp/qjson.h"
25#include "monitor/monitor.h"
aliguorifbe78f42008-12-17 19:13:11 +000026
Mark McLoughlin0ce0e8f2009-10-22 17:43:50 +010027#define VIRTIO_NET_VM_VERSION 11
aliguorib6503ed2009-02-05 22:36:28 +000028
Alex Williamson4ffb17f2009-06-05 14:47:23 -060029#define MAC_TABLE_ENTRIES 64
aliguorif21c0ed2009-02-05 22:36:32 +000030#define MAX_VLAN (1 << 12) /* Per 802.1Q definition */
aliguori9d6271b2009-02-05 22:36:04 +000031
Jesse Larrew14f9b662013-02-05 17:47:16 -060032/*
33 * Calculate the number of bytes up to and including the given 'field' of
34 * 'container'.
35 */
36#define endof(container, field) \
37 (offsetof(container, field) + sizeof(((container *)0)->field))
38
39typedef struct VirtIOFeature {
40 uint32_t flags;
41 size_t end;
42} VirtIOFeature;
43
44static VirtIOFeature feature_sizes[] = {
45 {.flags = 1 << VIRTIO_NET_F_MAC,
46 .end = endof(struct virtio_net_config, mac)},
47 {.flags = 1 << VIRTIO_NET_F_STATUS,
48 .end = endof(struct virtio_net_config, status)},
49 {.flags = 1 << VIRTIO_NET_F_MQ,
50 .end = endof(struct virtio_net_config, max_virtqueue_pairs)},
51 {}
52};
53
Jason Wangfed699f2013-01-30 19:12:39 +080054static VirtIONetQueue *virtio_net_get_subqueue(NetClientState *nc)
Jason Wang0c87e932013-01-30 19:12:38 +080055{
56 VirtIONet *n = qemu_get_nic_opaque(nc);
57
Jason Wangfed699f2013-01-30 19:12:39 +080058 return &n->vqs[nc->queue_index];
Jason Wang0c87e932013-01-30 19:12:38 +080059}
Jason Wangfed699f2013-01-30 19:12:39 +080060
61static int vq2q(int queue_index)
62{
63 return queue_index / 2;
64}
65
aliguorifbe78f42008-12-17 19:13:11 +000066/* TODO
67 * - we could suppress RX interrupt if we were so inclined.
68 */
69
aliguori0f03eca2009-02-05 22:36:08 +000070static void virtio_net_get_config(VirtIODevice *vdev, uint8_t *config)
aliguorifbe78f42008-12-17 19:13:11 +000071{
KONRAD Frederic17a0ca52013-04-11 16:30:01 +020072 VirtIONet *n = VIRTIO_NET(vdev);
aliguorifbe78f42008-12-17 19:13:11 +000073 struct virtio_net_config netcfg;
74
Stefan Hajnoczib46d97f2011-03-03 21:42:28 +000075 stw_p(&netcfg.status, n->status);
Jason Wangfed699f2013-01-30 19:12:39 +080076 stw_p(&netcfg.max_virtqueue_pairs, n->max_queues);
aliguori79674062009-02-05 22:36:12 +000077 memcpy(netcfg.mac, n->mac, ETH_ALEN);
Jesse Larrew14f9b662013-02-05 17:47:16 -060078 memcpy(config, &netcfg, n->config_size);
aliguorifbe78f42008-12-17 19:13:11 +000079}
80
aliguori0f03eca2009-02-05 22:36:08 +000081static void virtio_net_set_config(VirtIODevice *vdev, const uint8_t *config)
82{
KONRAD Frederic17a0ca52013-04-11 16:30:01 +020083 VirtIONet *n = VIRTIO_NET(vdev);
Jesse Larrew14f9b662013-02-05 17:47:16 -060084 struct virtio_net_config netcfg = {};
aliguori0f03eca2009-02-05 22:36:08 +000085
Jesse Larrew14f9b662013-02-05 17:47:16 -060086 memcpy(&netcfg, config, n->config_size);
aliguori0f03eca2009-02-05 22:36:08 +000087
KONRAD Frederic17a0ca52013-04-11 16:30:01 +020088 if (!(vdev->guest_features >> VIRTIO_NET_F_CTRL_MAC_ADDR & 1) &&
Amos Kongc1943a32013-01-22 23:44:45 +080089 memcmp(netcfg.mac, n->mac, ETH_ALEN)) {
aliguori79674062009-02-05 22:36:12 +000090 memcpy(n->mac, netcfg.mac, ETH_ALEN);
Jason Wangb356f762013-01-30 19:12:22 +080091 qemu_format_nic_info_str(qemu_get_queue(n->nic), n->mac);
aliguori0f03eca2009-02-05 22:36:08 +000092 }
93}
94
Michael S. Tsirkin783e7702010-11-22 19:52:30 +020095static bool virtio_net_started(VirtIONet *n, uint8_t status)
Michael S. Tsirkinafbaa7b2010-09-27 18:41:30 +020096{
KONRAD Frederic17a0ca52013-04-11 16:30:01 +020097 VirtIODevice *vdev = VIRTIO_DEVICE(n);
Michael S. Tsirkin783e7702010-11-22 19:52:30 +020098 return (status & VIRTIO_CONFIG_S_DRIVER_OK) &&
KONRAD Frederic17a0ca52013-04-11 16:30:01 +020099 (n->status & VIRTIO_NET_S_LINK_UP) && vdev->vm_running;
Michael S. Tsirkin783e7702010-11-22 19:52:30 +0200100}
101
102static void virtio_net_vhost_status(VirtIONet *n, uint8_t status)
103{
KONRAD Frederic17a0ca52013-04-11 16:30:01 +0200104 VirtIODevice *vdev = VIRTIO_DEVICE(n);
Jason Wangb356f762013-01-30 19:12:22 +0800105 NetClientState *nc = qemu_get_queue(n->nic);
Jason Wangfed699f2013-01-30 19:12:39 +0800106 int queues = n->multiqueue ? n->max_queues : 1;
Jason Wangb356f762013-01-30 19:12:22 +0800107
108 if (!nc->peer) {
Michael S. Tsirkinafbaa7b2010-09-27 18:41:30 +0200109 return;
110 }
Jason Wangb356f762013-01-30 19:12:22 +0800111 if (nc->peer->info->type != NET_CLIENT_OPTIONS_KIND_TAP) {
Michael S. Tsirkinafbaa7b2010-09-27 18:41:30 +0200112 return;
113 }
114
Jason Wangb356f762013-01-30 19:12:22 +0800115 if (!tap_get_vhost_net(nc->peer)) {
Michael S. Tsirkinafbaa7b2010-09-27 18:41:30 +0200116 return;
117 }
Jason Wangfed699f2013-01-30 19:12:39 +0800118
Jason Wangd7108d92013-04-26 18:27:40 +0800119 if (!!n->vhost_started ==
120 (virtio_net_started(n, status) && !nc->peer->link_down)) {
Michael S. Tsirkinafbaa7b2010-09-27 18:41:30 +0200121 return;
122 }
123 if (!n->vhost_started) {
mst@redhat.com5430a282011-02-01 22:13:42 +0200124 int r;
KONRAD Frederic17a0ca52013-04-11 16:30:01 +0200125 if (!vhost_net_query(tap_get_vhost_net(nc->peer), vdev)) {
mst@redhat.com5430a282011-02-01 22:13:42 +0200126 return;
127 }
Michael S. Tsirkin1830b802012-12-25 17:38:59 +0200128 n->vhost_started = 1;
KONRAD Frederic17a0ca52013-04-11 16:30:01 +0200129 r = vhost_net_start(vdev, n->nic->ncs, queues);
Michael S. Tsirkinafbaa7b2010-09-27 18:41:30 +0200130 if (r < 0) {
Stefan Hajnoczie7b43f72010-11-15 20:44:37 +0000131 error_report("unable to start vhost net: %d: "
132 "falling back on userspace virtio", -r);
Michael S. Tsirkin1830b802012-12-25 17:38:59 +0200133 n->vhost_started = 0;
Michael S. Tsirkinafbaa7b2010-09-27 18:41:30 +0200134 }
135 } else {
KONRAD Frederic17a0ca52013-04-11 16:30:01 +0200136 vhost_net_stop(vdev, n->nic->ncs, queues);
Michael S. Tsirkinafbaa7b2010-09-27 18:41:30 +0200137 n->vhost_started = 0;
138 }
139}
140
Michael S. Tsirkin783e7702010-11-22 19:52:30 +0200141static void virtio_net_set_status(struct VirtIODevice *vdev, uint8_t status)
142{
KONRAD Frederic17a0ca52013-04-11 16:30:01 +0200143 VirtIONet *n = VIRTIO_NET(vdev);
Jason Wangfed699f2013-01-30 19:12:39 +0800144 VirtIONetQueue *q;
145 int i;
146 uint8_t queue_status;
Michael S. Tsirkin783e7702010-11-22 19:52:30 +0200147
148 virtio_net_vhost_status(n, status);
149
Jason Wangfed699f2013-01-30 19:12:39 +0800150 for (i = 0; i < n->max_queues; i++) {
151 q = &n->vqs[i];
Michael S. Tsirkin783e7702010-11-22 19:52:30 +0200152
Jason Wangfed699f2013-01-30 19:12:39 +0800153 if ((!n->multiqueue && i != 0) || i >= n->curr_queues) {
154 queue_status = 0;
Michael S. Tsirkin783e7702010-11-22 19:52:30 +0200155 } else {
Jason Wangfed699f2013-01-30 19:12:39 +0800156 queue_status = status;
Michael S. Tsirkin783e7702010-11-22 19:52:30 +0200157 }
Jason Wangfed699f2013-01-30 19:12:39 +0800158
159 if (!q->tx_waiting) {
160 continue;
161 }
162
163 if (virtio_net_started(n, queue_status) && !n->vhost_started) {
164 if (q->tx_timer) {
Alex Blighbc72ad62013-08-21 16:03:08 +0100165 timer_mod(q->tx_timer,
166 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + n->tx_timeout);
Jason Wangfed699f2013-01-30 19:12:39 +0800167 } else {
168 qemu_bh_schedule(q->tx_bh);
169 }
Michael S. Tsirkin783e7702010-11-22 19:52:30 +0200170 } else {
Jason Wangfed699f2013-01-30 19:12:39 +0800171 if (q->tx_timer) {
Alex Blighbc72ad62013-08-21 16:03:08 +0100172 timer_del(q->tx_timer);
Jason Wangfed699f2013-01-30 19:12:39 +0800173 } else {
174 qemu_bh_cancel(q->tx_bh);
175 }
Michael S. Tsirkin783e7702010-11-22 19:52:30 +0200176 }
177 }
178}
179
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +0100180static void virtio_net_set_link_status(NetClientState *nc)
aliguori554c97d2009-01-08 19:46:33 +0000181{
Jason Wangcc1f0f42013-01-30 19:12:23 +0800182 VirtIONet *n = qemu_get_nic_opaque(nc);
KONRAD Frederic17a0ca52013-04-11 16:30:01 +0200183 VirtIODevice *vdev = VIRTIO_DEVICE(n);
aliguori554c97d2009-01-08 19:46:33 +0000184 uint16_t old_status = n->status;
185
Mark McLoughlineb6b6c12009-11-25 18:49:11 +0000186 if (nc->link_down)
aliguori554c97d2009-01-08 19:46:33 +0000187 n->status &= ~VIRTIO_NET_S_LINK_UP;
188 else
189 n->status |= VIRTIO_NET_S_LINK_UP;
190
191 if (n->status != old_status)
KONRAD Frederic17a0ca52013-04-11 16:30:01 +0200192 virtio_notify_config(vdev);
Michael S. Tsirkinafbaa7b2010-09-27 18:41:30 +0200193
KONRAD Frederic17a0ca52013-04-11 16:30:01 +0200194 virtio_net_set_status(vdev, vdev->status);
aliguori554c97d2009-01-08 19:46:33 +0000195}
196
Amos Kongb1be4282013-06-14 15:45:52 +0800197static void rxfilter_notify(NetClientState *nc)
198{
199 QObject *event_data;
200 VirtIONet *n = qemu_get_nic_opaque(nc);
201
202 if (nc->rxfilter_notify_enabled) {
Amos Kong96e35042013-11-18 23:32:17 +0800203 gchar *path = object_get_canonical_path(OBJECT(n->qdev));
Amos Kongb1be4282013-06-14 15:45:52 +0800204 if (n->netclient_name) {
205 event_data = qobject_from_jsonf("{ 'name': %s, 'path': %s }",
Amos Kong96e35042013-11-18 23:32:17 +0800206 n->netclient_name, path);
Amos Kongb1be4282013-06-14 15:45:52 +0800207 } else {
Amos Kong96e35042013-11-18 23:32:17 +0800208 event_data = qobject_from_jsonf("{ 'path': %s }", path);
Amos Kongb1be4282013-06-14 15:45:52 +0800209 }
210 monitor_protocol_event(QEVENT_NIC_RX_FILTER_CHANGED, event_data);
211 qobject_decref(event_data);
Amos Kong96e35042013-11-18 23:32:17 +0800212 g_free(path);
Amos Kongb1be4282013-06-14 15:45:52 +0800213
214 /* disable event notification to avoid events flooding */
215 nc->rxfilter_notify_enabled = 0;
216 }
217}
218
219static char *mac_strdup_printf(const uint8_t *mac)
220{
221 return g_strdup_printf("%.2x:%.2x:%.2x:%.2x:%.2x:%.2x", mac[0],
222 mac[1], mac[2], mac[3], mac[4], mac[5]);
223}
224
225static RxFilterInfo *virtio_net_query_rxfilter(NetClientState *nc)
226{
227 VirtIONet *n = qemu_get_nic_opaque(nc);
228 RxFilterInfo *info;
229 strList *str_list, *entry;
230 intList *int_list, *int_entry;
231 int i, j;
232
233 info = g_malloc0(sizeof(*info));
234 info->name = g_strdup(nc->name);
235 info->promiscuous = n->promisc;
236
237 if (n->nouni) {
238 info->unicast = RX_STATE_NONE;
239 } else if (n->alluni) {
240 info->unicast = RX_STATE_ALL;
241 } else {
242 info->unicast = RX_STATE_NORMAL;
243 }
244
245 if (n->nomulti) {
246 info->multicast = RX_STATE_NONE;
247 } else if (n->allmulti) {
248 info->multicast = RX_STATE_ALL;
249 } else {
250 info->multicast = RX_STATE_NORMAL;
251 }
252
253 info->broadcast_allowed = n->nobcast;
254 info->multicast_overflow = n->mac_table.multi_overflow;
255 info->unicast_overflow = n->mac_table.uni_overflow;
256
257 info->main_mac = mac_strdup_printf(n->mac);
258
259 str_list = NULL;
260 for (i = 0; i < n->mac_table.first_multi; i++) {
261 entry = g_malloc0(sizeof(*entry));
262 entry->value = mac_strdup_printf(n->mac_table.macs + i * ETH_ALEN);
263 entry->next = str_list;
264 str_list = entry;
265 }
266 info->unicast_table = str_list;
267
268 str_list = NULL;
269 for (i = n->mac_table.first_multi; i < n->mac_table.in_use; i++) {
270 entry = g_malloc0(sizeof(*entry));
271 entry->value = mac_strdup_printf(n->mac_table.macs + i * ETH_ALEN);
272 entry->next = str_list;
273 str_list = entry;
274 }
275 info->multicast_table = str_list;
276
277 int_list = NULL;
278 for (i = 0; i < MAX_VLAN >> 5; i++) {
279 for (j = 0; n->vlans[i] && j < 0x1f; j++) {
280 if (n->vlans[i] & (1U << j)) {
281 int_entry = g_malloc0(sizeof(*int_entry));
282 int_entry->value = (i << 5) + j;
283 int_entry->next = int_list;
284 int_list = int_entry;
285 }
286 }
287 }
288 info->vlan_table = int_list;
289
290 /* enable event notification after query */
291 nc->rxfilter_notify_enabled = 1;
292
293 return info;
294}
295
aliguori002437c2009-02-05 22:36:20 +0000296static void virtio_net_reset(VirtIODevice *vdev)
297{
KONRAD Frederic17a0ca52013-04-11 16:30:01 +0200298 VirtIONet *n = VIRTIO_NET(vdev);
aliguori002437c2009-02-05 22:36:20 +0000299
300 /* Reset back to compatibility mode */
301 n->promisc = 1;
302 n->allmulti = 0;
Alex Williamson015cb162009-06-05 14:47:18 -0600303 n->alluni = 0;
304 n->nomulti = 0;
305 n->nouni = 0;
306 n->nobcast = 0;
Jason Wangfed699f2013-01-30 19:12:39 +0800307 /* multiqueue is disabled by default */
308 n->curr_queues = 1;
aliguorib6503ed2009-02-05 22:36:28 +0000309
aliguorif21c0ed2009-02-05 22:36:32 +0000310 /* Flush any MAC and VLAN filter table state */
aliguorib6503ed2009-02-05 22:36:28 +0000311 n->mac_table.in_use = 0;
Alex Williamson2d9aba32009-06-05 14:47:13 -0600312 n->mac_table.first_multi = 0;
Alex Williamson8fd2a2f2009-06-05 14:47:08 -0600313 n->mac_table.multi_overflow = 0;
314 n->mac_table.uni_overflow = 0;
aliguorib6503ed2009-02-05 22:36:28 +0000315 memset(n->mac_table.macs, 0, MAC_TABLE_ENTRIES * ETH_ALEN);
Michael S. Tsirkin41dc8a62013-01-16 11:37:40 +0200316 memcpy(&n->mac[0], &n->nic->conf->macaddr, sizeof(n->mac));
Michael S. Tsirkin702d66a2013-09-17 11:45:36 +0300317 qemu_format_nic_info_str(qemu_get_queue(n->nic), n->mac);
aliguorif21c0ed2009-02-05 22:36:32 +0000318 memset(n->vlans, 0, MAX_VLAN >> 3);
aliguori002437c2009-02-05 22:36:20 +0000319}
320
Michael S. Tsirkin6e371ab2012-09-24 17:04:21 +0200321static void peer_test_vnet_hdr(VirtIONet *n)
Mark McLoughlin3a330132009-10-22 17:43:45 +0100322{
Jason Wangb356f762013-01-30 19:12:22 +0800323 NetClientState *nc = qemu_get_queue(n->nic);
324 if (!nc->peer) {
Michael S. Tsirkin6e371ab2012-09-24 17:04:21 +0200325 return;
Jason Wangb356f762013-01-30 19:12:22 +0800326 }
Mark McLoughlin3a330132009-10-22 17:43:45 +0100327
Jason Wangb356f762013-01-30 19:12:22 +0800328 if (nc->peer->info->type != NET_CLIENT_OPTIONS_KIND_TAP) {
Michael S. Tsirkin6e371ab2012-09-24 17:04:21 +0200329 return;
Jason Wangb356f762013-01-30 19:12:22 +0800330 }
Mark McLoughlin3a330132009-10-22 17:43:45 +0100331
Jason Wangb356f762013-01-30 19:12:22 +0800332 n->has_vnet_hdr = tap_has_vnet_hdr(nc->peer);
Michael S. Tsirkin6e371ab2012-09-24 17:04:21 +0200333}
Mark McLoughlin3a330132009-10-22 17:43:45 +0100334
Michael S. Tsirkin6e371ab2012-09-24 17:04:21 +0200335static int peer_has_vnet_hdr(VirtIONet *n)
336{
Mark McLoughlin3a330132009-10-22 17:43:45 +0100337 return n->has_vnet_hdr;
338}
339
Mark McLoughlin0ce0e8f2009-10-22 17:43:50 +0100340static int peer_has_ufo(VirtIONet *n)
341{
342 if (!peer_has_vnet_hdr(n))
343 return 0;
344
Jason Wangb356f762013-01-30 19:12:22 +0800345 n->has_ufo = tap_has_ufo(qemu_get_queue(n->nic)->peer);
Mark McLoughlin0ce0e8f2009-10-22 17:43:50 +0100346
347 return n->has_ufo;
348}
349
Michael S. Tsirkinff3a8062012-09-24 21:05:03 +0200350static void virtio_net_set_mrg_rx_bufs(VirtIONet *n, int mergeable_rx_bufs)
351{
Jason Wangfed699f2013-01-30 19:12:39 +0800352 int i;
353 NetClientState *nc;
354
Michael S. Tsirkinff3a8062012-09-24 21:05:03 +0200355 n->mergeable_rx_bufs = mergeable_rx_bufs;
356
357 n->guest_hdr_len = n->mergeable_rx_bufs ?
358 sizeof(struct virtio_net_hdr_mrg_rxbuf) : sizeof(struct virtio_net_hdr);
359
Jason Wangfed699f2013-01-30 19:12:39 +0800360 for (i = 0; i < n->max_queues; i++) {
361 nc = qemu_get_subqueue(n->nic, i);
362
363 if (peer_has_vnet_hdr(n) &&
364 tap_has_vnet_hdr_len(nc->peer, n->guest_hdr_len)) {
365 tap_set_vnet_hdr_len(nc->peer, n->guest_hdr_len);
366 n->host_hdr_len = n->guest_hdr_len;
367 }
Michael S. Tsirkinff3a8062012-09-24 21:05:03 +0200368 }
369}
370
Jason Wangfed699f2013-01-30 19:12:39 +0800371static int peer_attach(VirtIONet *n, int index)
372{
373 NetClientState *nc = qemu_get_subqueue(n->nic, index);
374
375 if (!nc->peer) {
376 return 0;
377 }
378
379 if (nc->peer->info->type != NET_CLIENT_OPTIONS_KIND_TAP) {
380 return 0;
381 }
382
383 return tap_enable(nc->peer);
384}
385
386static int peer_detach(VirtIONet *n, int index)
387{
388 NetClientState *nc = qemu_get_subqueue(n->nic, index);
389
390 if (!nc->peer) {
391 return 0;
392 }
393
394 if (nc->peer->info->type != NET_CLIENT_OPTIONS_KIND_TAP) {
395 return 0;
396 }
397
398 return tap_disable(nc->peer);
399}
400
401static void virtio_net_set_queues(VirtIONet *n)
402{
403 int i;
404
405 for (i = 0; i < n->max_queues; i++) {
406 if (i < n->curr_queues) {
407 assert(!peer_attach(n, i));
408 } else {
409 assert(!peer_detach(n, i));
410 }
411 }
412}
413
Jason Wangec57db12013-04-25 15:24:23 +0800414static void virtio_net_set_multiqueue(VirtIONet *n, int multiqueue);
Jason Wangfed699f2013-01-30 19:12:39 +0800415
Michael S. Tsirkin81725392010-01-10 13:52:53 +0200416static uint32_t virtio_net_get_features(VirtIODevice *vdev, uint32_t features)
aliguorifbe78f42008-12-17 19:13:11 +0000417{
KONRAD Frederic17a0ca52013-04-11 16:30:01 +0200418 VirtIONet *n = VIRTIO_NET(vdev);
Jason Wangb356f762013-01-30 19:12:22 +0800419 NetClientState *nc = qemu_get_queue(n->nic);
aliguorifbe78f42008-12-17 19:13:11 +0000420
Michael S. Tsirkinc9f79a32010-01-12 20:50:17 +0200421 features |= (1 << VIRTIO_NET_F_MAC);
422
Michael S. Tsirkin6e371ab2012-09-24 17:04:21 +0200423 if (!peer_has_vnet_hdr(n)) {
Michael S. Tsirkin81725392010-01-10 13:52:53 +0200424 features &= ~(0x1 << VIRTIO_NET_F_CSUM);
425 features &= ~(0x1 << VIRTIO_NET_F_HOST_TSO4);
426 features &= ~(0x1 << VIRTIO_NET_F_HOST_TSO6);
427 features &= ~(0x1 << VIRTIO_NET_F_HOST_ECN);
Mark McLoughlin3a330132009-10-22 17:43:45 +0100428
Michael S. Tsirkin81725392010-01-10 13:52:53 +0200429 features &= ~(0x1 << VIRTIO_NET_F_GUEST_CSUM);
430 features &= ~(0x1 << VIRTIO_NET_F_GUEST_TSO4);
431 features &= ~(0x1 << VIRTIO_NET_F_GUEST_TSO6);
432 features &= ~(0x1 << VIRTIO_NET_F_GUEST_ECN);
433 }
Mark McLoughlinf5436dd2009-10-22 17:43:47 +0100434
Michael S. Tsirkin81725392010-01-10 13:52:53 +0200435 if (!peer_has_vnet_hdr(n) || !peer_has_ufo(n)) {
436 features &= ~(0x1 << VIRTIO_NET_F_GUEST_UFO);
437 features &= ~(0x1 << VIRTIO_NET_F_HOST_UFO);
Mark McLoughlin3a330132009-10-22 17:43:45 +0100438 }
439
Jason Wangb356f762013-01-30 19:12:22 +0800440 if (!nc->peer || nc->peer->info->type != NET_CLIENT_OPTIONS_KIND_TAP) {
Michael S. Tsirkin9bc63042010-03-17 13:08:42 +0200441 return features;
442 }
Jason Wangb356f762013-01-30 19:12:22 +0800443 if (!tap_get_vhost_net(nc->peer)) {
Michael S. Tsirkin9bc63042010-03-17 13:08:42 +0200444 return features;
445 }
Jason Wangb356f762013-01-30 19:12:22 +0800446 return vhost_net_get_features(tap_get_vhost_net(nc->peer), features);
aliguorifbe78f42008-12-17 19:13:11 +0000447}
448
aliguori8eca6b12009-04-05 17:40:08 +0000449static uint32_t virtio_net_bad_features(VirtIODevice *vdev)
450{
451 uint32_t features = 0;
452
453 /* Linux kernel 2.6.25. It understood MAC (as everyone must),
454 * but also these: */
455 features |= (1 << VIRTIO_NET_F_MAC);
Dustin Kirkland184bd042009-10-29 10:34:15 -0500456 features |= (1 << VIRTIO_NET_F_CSUM);
457 features |= (1 << VIRTIO_NET_F_HOST_TSO4);
458 features |= (1 << VIRTIO_NET_F_HOST_TSO6);
459 features |= (1 << VIRTIO_NET_F_HOST_ECN);
aliguori8eca6b12009-04-05 17:40:08 +0000460
Michael S. Tsirkin81725392010-01-10 13:52:53 +0200461 return features;
aliguori8eca6b12009-04-05 17:40:08 +0000462}
463
Dmitry Fleytman644c9852013-05-20 11:18:14 +0300464static void virtio_net_apply_guest_offloads(VirtIONet *n)
465{
466 tap_set_offload(qemu_get_subqueue(n->nic, 0)->peer,
467 !!(n->curr_guest_offloads & (1ULL << VIRTIO_NET_F_GUEST_CSUM)),
468 !!(n->curr_guest_offloads & (1ULL << VIRTIO_NET_F_GUEST_TSO4)),
469 !!(n->curr_guest_offloads & (1ULL << VIRTIO_NET_F_GUEST_TSO6)),
470 !!(n->curr_guest_offloads & (1ULL << VIRTIO_NET_F_GUEST_ECN)),
471 !!(n->curr_guest_offloads & (1ULL << VIRTIO_NET_F_GUEST_UFO)));
472}
473
474static uint64_t virtio_net_guest_offloads_by_features(uint32_t features)
475{
476 static const uint64_t guest_offloads_mask =
477 (1ULL << VIRTIO_NET_F_GUEST_CSUM) |
478 (1ULL << VIRTIO_NET_F_GUEST_TSO4) |
479 (1ULL << VIRTIO_NET_F_GUEST_TSO6) |
480 (1ULL << VIRTIO_NET_F_GUEST_ECN) |
481 (1ULL << VIRTIO_NET_F_GUEST_UFO);
482
483 return guest_offloads_mask & features;
484}
485
486static inline uint64_t virtio_net_supported_guest_offloads(VirtIONet *n)
487{
488 VirtIODevice *vdev = VIRTIO_DEVICE(n);
489 return virtio_net_guest_offloads_by_features(vdev->guest_features);
490}
491
aliguorifbe78f42008-12-17 19:13:11 +0000492static void virtio_net_set_features(VirtIODevice *vdev, uint32_t features)
493{
KONRAD Frederic17a0ca52013-04-11 16:30:01 +0200494 VirtIONet *n = VIRTIO_NET(vdev);
Jason Wangfed699f2013-01-30 19:12:39 +0800495 int i;
496
Jason Wangec57db12013-04-25 15:24:23 +0800497 virtio_net_set_multiqueue(n, !!(features & (1 << VIRTIO_NET_F_MQ)));
aliguorifbe78f42008-12-17 19:13:11 +0000498
Michael S. Tsirkinff3a8062012-09-24 21:05:03 +0200499 virtio_net_set_mrg_rx_bufs(n, !!(features & (1 << VIRTIO_NET_F_MRG_RXBUF)));
Mark McLoughlinf5436dd2009-10-22 17:43:47 +0100500
501 if (n->has_vnet_hdr) {
Dmitry Fleytman644c9852013-05-20 11:18:14 +0300502 n->curr_guest_offloads =
503 virtio_net_guest_offloads_by_features(features);
504 virtio_net_apply_guest_offloads(n);
Mark McLoughlinf5436dd2009-10-22 17:43:47 +0100505 }
Jason Wangfed699f2013-01-30 19:12:39 +0800506
507 for (i = 0; i < n->max_queues; i++) {
508 NetClientState *nc = qemu_get_subqueue(n->nic, i);
509
510 if (!nc->peer || nc->peer->info->type != NET_CLIENT_OPTIONS_KIND_TAP) {
511 continue;
512 }
513 if (!tap_get_vhost_net(nc->peer)) {
514 continue;
515 }
516 vhost_net_ack_features(tap_get_vhost_net(nc->peer), features);
David L Stevensdc14a392010-03-31 21:20:31 +0300517 }
aliguorifbe78f42008-12-17 19:13:11 +0000518}
519
aliguori002437c2009-02-05 22:36:20 +0000520static int virtio_net_handle_rx_mode(VirtIONet *n, uint8_t cmd,
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800521 struct iovec *iov, unsigned int iov_cnt)
aliguori002437c2009-02-05 22:36:20 +0000522{
523 uint8_t on;
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800524 size_t s;
Amos Kongb1be4282013-06-14 15:45:52 +0800525 NetClientState *nc = qemu_get_queue(n->nic);
aliguori002437c2009-02-05 22:36:20 +0000526
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800527 s = iov_to_buf(iov, iov_cnt, 0, &on, sizeof(on));
528 if (s != sizeof(on)) {
529 return VIRTIO_NET_ERR;
aliguori002437c2009-02-05 22:36:20 +0000530 }
531
Amos Kongdd234542013-01-22 23:44:46 +0800532 if (cmd == VIRTIO_NET_CTRL_RX_PROMISC) {
aliguori002437c2009-02-05 22:36:20 +0000533 n->promisc = on;
Amos Kongdd234542013-01-22 23:44:46 +0800534 } else if (cmd == VIRTIO_NET_CTRL_RX_ALLMULTI) {
aliguori002437c2009-02-05 22:36:20 +0000535 n->allmulti = on;
Amos Kongdd234542013-01-22 23:44:46 +0800536 } else if (cmd == VIRTIO_NET_CTRL_RX_ALLUNI) {
Alex Williamson015cb162009-06-05 14:47:18 -0600537 n->alluni = on;
Amos Kongdd234542013-01-22 23:44:46 +0800538 } else if (cmd == VIRTIO_NET_CTRL_RX_NOMULTI) {
Alex Williamson015cb162009-06-05 14:47:18 -0600539 n->nomulti = on;
Amos Kongdd234542013-01-22 23:44:46 +0800540 } else if (cmd == VIRTIO_NET_CTRL_RX_NOUNI) {
Alex Williamson015cb162009-06-05 14:47:18 -0600541 n->nouni = on;
Amos Kongdd234542013-01-22 23:44:46 +0800542 } else if (cmd == VIRTIO_NET_CTRL_RX_NOBCAST) {
Alex Williamson015cb162009-06-05 14:47:18 -0600543 n->nobcast = on;
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800544 } else {
aliguori002437c2009-02-05 22:36:20 +0000545 return VIRTIO_NET_ERR;
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800546 }
aliguori002437c2009-02-05 22:36:20 +0000547
Amos Kongb1be4282013-06-14 15:45:52 +0800548 rxfilter_notify(nc);
549
aliguori002437c2009-02-05 22:36:20 +0000550 return VIRTIO_NET_OK;
551}
552
Dmitry Fleytman644c9852013-05-20 11:18:14 +0300553static int virtio_net_handle_offloads(VirtIONet *n, uint8_t cmd,
554 struct iovec *iov, unsigned int iov_cnt)
555{
556 VirtIODevice *vdev = VIRTIO_DEVICE(n);
557 uint64_t offloads;
558 size_t s;
559
560 if (!((1 << VIRTIO_NET_F_CTRL_GUEST_OFFLOADS) & vdev->guest_features)) {
561 return VIRTIO_NET_ERR;
562 }
563
564 s = iov_to_buf(iov, iov_cnt, 0, &offloads, sizeof(offloads));
565 if (s != sizeof(offloads)) {
566 return VIRTIO_NET_ERR;
567 }
568
569 if (cmd == VIRTIO_NET_CTRL_GUEST_OFFLOADS_SET) {
570 uint64_t supported_offloads;
571
572 if (!n->has_vnet_hdr) {
573 return VIRTIO_NET_ERR;
574 }
575
576 supported_offloads = virtio_net_supported_guest_offloads(n);
577 if (offloads & ~supported_offloads) {
578 return VIRTIO_NET_ERR;
579 }
580
581 n->curr_guest_offloads = offloads;
582 virtio_net_apply_guest_offloads(n);
583
584 return VIRTIO_NET_OK;
585 } else {
586 return VIRTIO_NET_ERR;
587 }
588}
589
aliguorib6503ed2009-02-05 22:36:28 +0000590static int virtio_net_handle_mac(VirtIONet *n, uint8_t cmd,
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800591 struct iovec *iov, unsigned int iov_cnt)
aliguorib6503ed2009-02-05 22:36:28 +0000592{
593 struct virtio_net_ctrl_mac mac_data;
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800594 size_t s;
Amos Kongb1be4282013-06-14 15:45:52 +0800595 NetClientState *nc = qemu_get_queue(n->nic);
aliguorib6503ed2009-02-05 22:36:28 +0000596
Amos Kongc1943a32013-01-22 23:44:45 +0800597 if (cmd == VIRTIO_NET_CTRL_MAC_ADDR_SET) {
598 if (iov_size(iov, iov_cnt) != sizeof(n->mac)) {
599 return VIRTIO_NET_ERR;
600 }
601 s = iov_to_buf(iov, iov_cnt, 0, &n->mac, sizeof(n->mac));
602 assert(s == sizeof(n->mac));
Jason Wangb356f762013-01-30 19:12:22 +0800603 qemu_format_nic_info_str(qemu_get_queue(n->nic), n->mac);
Amos Kongb1be4282013-06-14 15:45:52 +0800604 rxfilter_notify(nc);
605
Amos Kongc1943a32013-01-22 23:44:45 +0800606 return VIRTIO_NET_OK;
607 }
608
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800609 if (cmd != VIRTIO_NET_CTRL_MAC_TABLE_SET) {
aliguorib6503ed2009-02-05 22:36:28 +0000610 return VIRTIO_NET_ERR;
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800611 }
aliguorib6503ed2009-02-05 22:36:28 +0000612
Amos Kongcae2e552013-11-11 11:48:36 +0800613 int in_use = 0;
614 int first_multi = 0;
615 uint8_t uni_overflow = 0;
616 uint8_t multi_overflow = 0;
617 uint8_t *macs = g_malloc0(MAC_TABLE_ENTRIES * ETH_ALEN);
aliguorib6503ed2009-02-05 22:36:28 +0000618
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800619 s = iov_to_buf(iov, iov_cnt, 0, &mac_data.entries,
620 sizeof(mac_data.entries));
621 mac_data.entries = ldl_p(&mac_data.entries);
622 if (s != sizeof(mac_data.entries)) {
Amos Kongb1be4282013-06-14 15:45:52 +0800623 goto error;
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800624 }
625 iov_discard_front(&iov, &iov_cnt, s);
626
627 if (mac_data.entries * ETH_ALEN > iov_size(iov, iov_cnt)) {
Amos Kongb1be4282013-06-14 15:45:52 +0800628 goto error;
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800629 }
aliguorib6503ed2009-02-05 22:36:28 +0000630
631 if (mac_data.entries <= MAC_TABLE_ENTRIES) {
Amos Kongcae2e552013-11-11 11:48:36 +0800632 s = iov_to_buf(iov, iov_cnt, 0, macs,
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800633 mac_data.entries * ETH_ALEN);
634 if (s != mac_data.entries * ETH_ALEN) {
Amos Kongb1be4282013-06-14 15:45:52 +0800635 goto error;
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800636 }
Amos Kongcae2e552013-11-11 11:48:36 +0800637 in_use += mac_data.entries;
aliguorib6503ed2009-02-05 22:36:28 +0000638 } else {
Amos Kongcae2e552013-11-11 11:48:36 +0800639 uni_overflow = 1;
aliguorib6503ed2009-02-05 22:36:28 +0000640 }
641
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800642 iov_discard_front(&iov, &iov_cnt, mac_data.entries * ETH_ALEN);
643
Amos Kongcae2e552013-11-11 11:48:36 +0800644 first_multi = in_use;
Alex Williamson2d9aba32009-06-05 14:47:13 -0600645
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800646 s = iov_to_buf(iov, iov_cnt, 0, &mac_data.entries,
647 sizeof(mac_data.entries));
648 mac_data.entries = ldl_p(&mac_data.entries);
649 if (s != sizeof(mac_data.entries)) {
Amos Kongb1be4282013-06-14 15:45:52 +0800650 goto error;
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800651 }
aliguorib6503ed2009-02-05 22:36:28 +0000652
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800653 iov_discard_front(&iov, &iov_cnt, s);
654
655 if (mac_data.entries * ETH_ALEN != iov_size(iov, iov_cnt)) {
Amos Kongb1be4282013-06-14 15:45:52 +0800656 goto error;
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800657 }
658
Amos Kongcae2e552013-11-11 11:48:36 +0800659 if (in_use + mac_data.entries <= MAC_TABLE_ENTRIES) {
660 s = iov_to_buf(iov, iov_cnt, 0, &macs[in_use * ETH_ALEN],
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800661 mac_data.entries * ETH_ALEN);
662 if (s != mac_data.entries * ETH_ALEN) {
Amos Kongb1be4282013-06-14 15:45:52 +0800663 goto error;
Alex Williamson8fd2a2f2009-06-05 14:47:08 -0600664 }
Amos Kongcae2e552013-11-11 11:48:36 +0800665 in_use += mac_data.entries;
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800666 } else {
Amos Kongcae2e552013-11-11 11:48:36 +0800667 multi_overflow = 1;
aliguorib6503ed2009-02-05 22:36:28 +0000668 }
669
Amos Kongcae2e552013-11-11 11:48:36 +0800670 n->mac_table.in_use = in_use;
671 n->mac_table.first_multi = first_multi;
672 n->mac_table.uni_overflow = uni_overflow;
673 n->mac_table.multi_overflow = multi_overflow;
674 memcpy(n->mac_table.macs, macs, MAC_TABLE_ENTRIES * ETH_ALEN);
675 g_free(macs);
Amos Kongb1be4282013-06-14 15:45:52 +0800676 rxfilter_notify(nc);
677
aliguorib6503ed2009-02-05 22:36:28 +0000678 return VIRTIO_NET_OK;
Amos Kongb1be4282013-06-14 15:45:52 +0800679
680error:
Amos Kongcae2e552013-11-11 11:48:36 +0800681 g_free(macs);
Amos Kongb1be4282013-06-14 15:45:52 +0800682 return VIRTIO_NET_ERR;
aliguorib6503ed2009-02-05 22:36:28 +0000683}
684
aliguorif21c0ed2009-02-05 22:36:32 +0000685static int virtio_net_handle_vlan_table(VirtIONet *n, uint8_t cmd,
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800686 struct iovec *iov, unsigned int iov_cnt)
aliguorif21c0ed2009-02-05 22:36:32 +0000687{
688 uint16_t vid;
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800689 size_t s;
Amos Kongb1be4282013-06-14 15:45:52 +0800690 NetClientState *nc = qemu_get_queue(n->nic);
aliguorif21c0ed2009-02-05 22:36:32 +0000691
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800692 s = iov_to_buf(iov, iov_cnt, 0, &vid, sizeof(vid));
693 vid = lduw_p(&vid);
694 if (s != sizeof(vid)) {
aliguorif21c0ed2009-02-05 22:36:32 +0000695 return VIRTIO_NET_ERR;
696 }
697
aliguorif21c0ed2009-02-05 22:36:32 +0000698 if (vid >= MAX_VLAN)
699 return VIRTIO_NET_ERR;
700
701 if (cmd == VIRTIO_NET_CTRL_VLAN_ADD)
702 n->vlans[vid >> 5] |= (1U << (vid & 0x1f));
703 else if (cmd == VIRTIO_NET_CTRL_VLAN_DEL)
704 n->vlans[vid >> 5] &= ~(1U << (vid & 0x1f));
705 else
706 return VIRTIO_NET_ERR;
707
Amos Kongb1be4282013-06-14 15:45:52 +0800708 rxfilter_notify(nc);
709
aliguorif21c0ed2009-02-05 22:36:32 +0000710 return VIRTIO_NET_OK;
711}
712
Jason Wangfed699f2013-01-30 19:12:39 +0800713static int virtio_net_handle_mq(VirtIONet *n, uint8_t cmd,
Jason Wangf8f7c532013-03-06 13:50:27 +0800714 struct iovec *iov, unsigned int iov_cnt)
Jason Wangfed699f2013-01-30 19:12:39 +0800715{
KONRAD Frederic17a0ca52013-04-11 16:30:01 +0200716 VirtIODevice *vdev = VIRTIO_DEVICE(n);
Jason Wangf8f7c532013-03-06 13:50:27 +0800717 struct virtio_net_ctrl_mq mq;
718 size_t s;
719 uint16_t queues;
Jason Wangfed699f2013-01-30 19:12:39 +0800720
Jason Wangf8f7c532013-03-06 13:50:27 +0800721 s = iov_to_buf(iov, iov_cnt, 0, &mq, sizeof(mq));
722 if (s != sizeof(mq)) {
Jason Wangfed699f2013-01-30 19:12:39 +0800723 return VIRTIO_NET_ERR;
724 }
725
726 if (cmd != VIRTIO_NET_CTRL_MQ_VQ_PAIRS_SET) {
727 return VIRTIO_NET_ERR;
728 }
729
Jason Wangf8f7c532013-03-06 13:50:27 +0800730 queues = lduw_p(&mq.virtqueue_pairs);
Jason Wangfed699f2013-01-30 19:12:39 +0800731
Jason Wangf8f7c532013-03-06 13:50:27 +0800732 if (queues < VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MIN ||
733 queues > VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MAX ||
734 queues > n->max_queues ||
Jason Wangfed699f2013-01-30 19:12:39 +0800735 !n->multiqueue) {
736 return VIRTIO_NET_ERR;
737 }
738
Jason Wangf8f7c532013-03-06 13:50:27 +0800739 n->curr_queues = queues;
Jason Wangfed699f2013-01-30 19:12:39 +0800740 /* stop the backend before changing the number of queues to avoid handling a
741 * disabled queue */
KONRAD Frederic17a0ca52013-04-11 16:30:01 +0200742 virtio_net_set_status(vdev, vdev->status);
Jason Wangfed699f2013-01-30 19:12:39 +0800743 virtio_net_set_queues(n);
744
745 return VIRTIO_NET_OK;
746}
aliguori3d11d362009-02-05 22:36:16 +0000747static void virtio_net_handle_ctrl(VirtIODevice *vdev, VirtQueue *vq)
748{
KONRAD Frederic17a0ca52013-04-11 16:30:01 +0200749 VirtIONet *n = VIRTIO_NET(vdev);
aliguori3d11d362009-02-05 22:36:16 +0000750 struct virtio_net_ctrl_hdr ctrl;
751 virtio_net_ctrl_ack status = VIRTIO_NET_ERR;
752 VirtQueueElement elem;
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800753 size_t s;
754 struct iovec *iov;
755 unsigned int iov_cnt;
aliguori3d11d362009-02-05 22:36:16 +0000756
757 while (virtqueue_pop(vq, &elem)) {
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800758 if (iov_size(elem.in_sg, elem.in_num) < sizeof(status) ||
759 iov_size(elem.out_sg, elem.out_num) < sizeof(ctrl)) {
Stefan Hajnoczie7b43f72010-11-15 20:44:37 +0000760 error_report("virtio-net ctrl missing headers");
aliguori3d11d362009-02-05 22:36:16 +0000761 exit(1);
762 }
763
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800764 iov = elem.out_sg;
765 iov_cnt = elem.out_num;
766 s = iov_to_buf(iov, iov_cnt, 0, &ctrl, sizeof(ctrl));
767 iov_discard_front(&iov, &iov_cnt, sizeof(ctrl));
768 if (s != sizeof(ctrl)) {
769 status = VIRTIO_NET_ERR;
Amos Kongdd234542013-01-22 23:44:46 +0800770 } else if (ctrl.class == VIRTIO_NET_CTRL_RX) {
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800771 status = virtio_net_handle_rx_mode(n, ctrl.cmd, iov, iov_cnt);
772 } else if (ctrl.class == VIRTIO_NET_CTRL_MAC) {
773 status = virtio_net_handle_mac(n, ctrl.cmd, iov, iov_cnt);
774 } else if (ctrl.class == VIRTIO_NET_CTRL_VLAN) {
775 status = virtio_net_handle_vlan_table(n, ctrl.cmd, iov, iov_cnt);
Jason Wangfed699f2013-01-30 19:12:39 +0800776 } else if (ctrl.class == VIRTIO_NET_CTRL_MQ) {
Jason Wangf8f7c532013-03-06 13:50:27 +0800777 status = virtio_net_handle_mq(n, ctrl.cmd, iov, iov_cnt);
Dmitry Fleytman644c9852013-05-20 11:18:14 +0300778 } else if (ctrl.class == VIRTIO_NET_CTRL_GUEST_OFFLOADS) {
779 status = virtio_net_handle_offloads(n, ctrl.cmd, iov, iov_cnt);
aliguori3d11d362009-02-05 22:36:16 +0000780 }
781
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800782 s = iov_from_buf(elem.in_sg, elem.in_num, 0, &status, sizeof(status));
783 assert(s == sizeof(status));
aliguori3d11d362009-02-05 22:36:16 +0000784
785 virtqueue_push(vq, &elem, sizeof(status));
786 virtio_notify(vdev, vq);
787 }
788}
789
aliguorifbe78f42008-12-17 19:13:11 +0000790/* RX */
791
792static void virtio_net_handle_rx(VirtIODevice *vdev, VirtQueue *vq)
793{
KONRAD Frederic17a0ca52013-04-11 16:30:01 +0200794 VirtIONet *n = VIRTIO_NET(vdev);
Jason Wangfed699f2013-01-30 19:12:39 +0800795 int queue_index = vq2q(virtio_get_queue_index(vq));
Mark McLoughlin8aeff622009-04-29 13:40:02 +0100796
Jason Wangfed699f2013-01-30 19:12:39 +0800797 qemu_flush_queued_packets(qemu_get_subqueue(n->nic, queue_index));
aliguorifbe78f42008-12-17 19:13:11 +0000798}
799
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +0100800static int virtio_net_can_receive(NetClientState *nc)
aliguorifbe78f42008-12-17 19:13:11 +0000801{
Jason Wangcc1f0f42013-01-30 19:12:23 +0800802 VirtIONet *n = qemu_get_nic_opaque(nc);
KONRAD Frederic17a0ca52013-04-11 16:30:01 +0200803 VirtIODevice *vdev = VIRTIO_DEVICE(n);
Jason Wangfed699f2013-01-30 19:12:39 +0800804 VirtIONetQueue *q = virtio_net_get_subqueue(nc);
Jason Wang0c87e932013-01-30 19:12:38 +0800805
KONRAD Frederic17a0ca52013-04-11 16:30:01 +0200806 if (!vdev->vm_running) {
Michael S. Tsirkin95477322010-11-22 19:52:19 +0200807 return 0;
808 }
Mark McLoughlincdd5cc12009-10-27 18:16:38 +0000809
Jason Wangfed699f2013-01-30 19:12:39 +0800810 if (nc->queue_index >= n->curr_queues) {
811 return 0;
812 }
813
Jason Wang0c87e932013-01-30 19:12:38 +0800814 if (!virtio_queue_ready(q->rx_vq) ||
KONRAD Frederic17a0ca52013-04-11 16:30:01 +0200815 !(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK)) {
aliguorifbe78f42008-12-17 19:13:11 +0000816 return 0;
Jason Wang0c87e932013-01-30 19:12:38 +0800817 }
aliguorifbe78f42008-12-17 19:13:11 +0000818
Mark McLoughlincdd5cc12009-10-27 18:16:38 +0000819 return 1;
820}
821
Jason Wang0c87e932013-01-30 19:12:38 +0800822static int virtio_net_has_buffers(VirtIONetQueue *q, int bufsize)
Mark McLoughlincdd5cc12009-10-27 18:16:38 +0000823{
Jason Wang0c87e932013-01-30 19:12:38 +0800824 VirtIONet *n = q->n;
825 if (virtio_queue_empty(q->rx_vq) ||
aliguorifbe78f42008-12-17 19:13:11 +0000826 (n->mergeable_rx_bufs &&
Jason Wang0c87e932013-01-30 19:12:38 +0800827 !virtqueue_avail_bytes(q->rx_vq, bufsize, 0))) {
828 virtio_queue_set_notification(q->rx_vq, 1);
Tom Lendacky06b12972010-02-08 10:10:01 -0600829
830 /* To avoid a race condition where the guest has made some buffers
831 * available after the above check but before notification was
832 * enabled, check for available buffers again.
833 */
Jason Wang0c87e932013-01-30 19:12:38 +0800834 if (virtio_queue_empty(q->rx_vq) ||
Tom Lendacky06b12972010-02-08 10:10:01 -0600835 (n->mergeable_rx_bufs &&
Jason Wang0c87e932013-01-30 19:12:38 +0800836 !virtqueue_avail_bytes(q->rx_vq, bufsize, 0))) {
Tom Lendacky06b12972010-02-08 10:10:01 -0600837 return 0;
Jason Wang0c87e932013-01-30 19:12:38 +0800838 }
aliguorifbe78f42008-12-17 19:13:11 +0000839 }
840
Jason Wang0c87e932013-01-30 19:12:38 +0800841 virtio_queue_set_notification(q->rx_vq, 0);
aliguorifbe78f42008-12-17 19:13:11 +0000842 return 1;
843}
844
Anthony Liguori1d41b0c2009-10-22 17:43:48 +0100845/* dhclient uses AF_PACKET but doesn't pass auxdata to the kernel so
846 * it never finds out that the packets don't have valid checksums. This
847 * causes dhclient to get upset. Fedora's carried a patch for ages to
848 * fix this with Xen but it hasn't appeared in an upstream release of
849 * dhclient yet.
850 *
851 * To avoid breaking existing guests, we catch udp packets and add
852 * checksums. This is terrible but it's better than hacking the guest
853 * kernels.
854 *
855 * N.B. if we introduce a zero-copy API, this operation is no longer free so
856 * we should provide a mechanism to disable it to avoid polluting the host
857 * cache.
858 */
859static void work_around_broken_dhclient(struct virtio_net_hdr *hdr,
Michael S. Tsirkin22cc84d2012-09-24 13:14:16 +0200860 uint8_t *buf, size_t size)
Anthony Liguori1d41b0c2009-10-22 17:43:48 +0100861{
862 if ((hdr->flags & VIRTIO_NET_HDR_F_NEEDS_CSUM) && /* missing csum */
863 (size > 27 && size < 1500) && /* normal sized MTU */
864 (buf[12] == 0x08 && buf[13] == 0x00) && /* ethertype == IPv4 */
865 (buf[23] == 17) && /* ip.protocol == UDP */
866 (buf[34] == 0 && buf[35] == 67)) { /* udp.srcport == bootps */
Michael S. Tsirkin22cc84d2012-09-24 13:14:16 +0200867 net_checksum_calculate(buf, size);
Anthony Liguori1d41b0c2009-10-22 17:43:48 +0100868 hdr->flags &= ~VIRTIO_NET_HDR_F_NEEDS_CSUM;
869 }
870}
871
Michael S. Tsirkin280598b2012-09-24 13:24:17 +0200872static void receive_header(VirtIONet *n, const struct iovec *iov, int iov_cnt,
873 const void *buf, size_t size)
aliguorifbe78f42008-12-17 19:13:11 +0000874{
Mark McLoughlin3a330132009-10-22 17:43:45 +0100875 if (n->has_vnet_hdr) {
Michael S. Tsirkin22cc84d2012-09-24 13:14:16 +0200876 /* FIXME this cast is evil */
877 void *wbuf = (void *)buf;
Michael S. Tsirkin280598b2012-09-24 13:24:17 +0200878 work_around_broken_dhclient(wbuf, wbuf + n->host_hdr_len,
879 size - n->host_hdr_len);
880 iov_from_buf(iov, iov_cnt, 0, buf, sizeof(struct virtio_net_hdr));
Michael S. Tsirkin22cc84d2012-09-24 13:14:16 +0200881 } else {
882 struct virtio_net_hdr hdr = {
883 .flags = 0,
884 .gso_type = VIRTIO_NET_HDR_GSO_NONE
885 };
886 iov_from_buf(iov, iov_cnt, 0, &hdr, sizeof hdr);
Mark McLoughlin3a330132009-10-22 17:43:45 +0100887 }
aliguorifbe78f42008-12-17 19:13:11 +0000888}
889
aliguori3831ab22009-02-05 22:36:24 +0000890static int receive_filter(VirtIONet *n, const uint8_t *buf, int size)
891{
892 static const uint8_t bcast[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
aliguorif21c0ed2009-02-05 22:36:32 +0000893 static const uint8_t vlan[] = {0x81, 0x00};
aliguori3831ab22009-02-05 22:36:24 +0000894 uint8_t *ptr = (uint8_t *)buf;
aliguorib6503ed2009-02-05 22:36:28 +0000895 int i;
aliguori3831ab22009-02-05 22:36:24 +0000896
897 if (n->promisc)
898 return 1;
899
Michael S. Tsirkine043ebc2012-09-24 16:27:27 +0200900 ptr += n->host_hdr_len;
Mark McLoughlin3a330132009-10-22 17:43:45 +0100901
aliguorif21c0ed2009-02-05 22:36:32 +0000902 if (!memcmp(&ptr[12], vlan, sizeof(vlan))) {
903 int vid = be16_to_cpup((uint16_t *)(ptr + 14)) & 0xfff;
904 if (!(n->vlans[vid >> 5] & (1U << (vid & 0x1f))))
905 return 0;
906 }
907
Alex Williamsonbbe2f392009-06-05 14:47:02 -0600908 if (ptr[0] & 1) { // multicast
909 if (!memcmp(ptr, bcast, sizeof(bcast))) {
Alex Williamson015cb162009-06-05 14:47:18 -0600910 return !n->nobcast;
911 } else if (n->nomulti) {
912 return 0;
Alex Williamson8fd2a2f2009-06-05 14:47:08 -0600913 } else if (n->allmulti || n->mac_table.multi_overflow) {
Alex Williamsonbbe2f392009-06-05 14:47:02 -0600914 return 1;
915 }
Alex Williamson2d9aba32009-06-05 14:47:13 -0600916
917 for (i = n->mac_table.first_multi; i < n->mac_table.in_use; i++) {
918 if (!memcmp(ptr, &n->mac_table.macs[i * ETH_ALEN], ETH_ALEN)) {
919 return 1;
920 }
921 }
Alex Williamsonbbe2f392009-06-05 14:47:02 -0600922 } else { // unicast
Alex Williamson015cb162009-06-05 14:47:18 -0600923 if (n->nouni) {
924 return 0;
925 } else if (n->alluni || n->mac_table.uni_overflow) {
Alex Williamson8fd2a2f2009-06-05 14:47:08 -0600926 return 1;
927 } else if (!memcmp(ptr, n->mac, ETH_ALEN)) {
Alex Williamsonbbe2f392009-06-05 14:47:02 -0600928 return 1;
929 }
aliguori3831ab22009-02-05 22:36:24 +0000930
Alex Williamson2d9aba32009-06-05 14:47:13 -0600931 for (i = 0; i < n->mac_table.first_multi; i++) {
932 if (!memcmp(ptr, &n->mac_table.macs[i * ETH_ALEN], ETH_ALEN)) {
933 return 1;
934 }
935 }
aliguorib6503ed2009-02-05 22:36:28 +0000936 }
937
aliguori3831ab22009-02-05 22:36:24 +0000938 return 0;
939}
940
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +0100941static ssize_t virtio_net_receive(NetClientState *nc, const uint8_t *buf, size_t size)
aliguorifbe78f42008-12-17 19:13:11 +0000942{
Jason Wangcc1f0f42013-01-30 19:12:23 +0800943 VirtIONet *n = qemu_get_nic_opaque(nc);
Jason Wangfed699f2013-01-30 19:12:39 +0800944 VirtIONetQueue *q = virtio_net_get_subqueue(nc);
KONRAD Frederic17a0ca52013-04-11 16:30:01 +0200945 VirtIODevice *vdev = VIRTIO_DEVICE(n);
Michael S. Tsirkin63c58722012-09-24 13:17:13 +0200946 struct iovec mhdr_sg[VIRTQUEUE_MAX_SIZE];
947 struct virtio_net_hdr_mrg_rxbuf mhdr;
948 unsigned mhdr_cnt = 0;
Michael S. Tsirkin22cc84d2012-09-24 13:14:16 +0200949 size_t offset, i, guest_offset;
aliguorifbe78f42008-12-17 19:13:11 +0000950
Jason Wangfed699f2013-01-30 19:12:39 +0800951 if (!virtio_net_can_receive(nc)) {
Mark McLoughlincdd5cc12009-10-27 18:16:38 +0000952 return -1;
Jason Wangb356f762013-01-30 19:12:22 +0800953 }
Mark McLoughlincdd5cc12009-10-27 18:16:38 +0000954
Michael S. Tsirkin940cda92010-06-06 18:53:10 +0300955 /* hdr_len refers to the header we supply to the guest */
Jason Wang0c87e932013-01-30 19:12:38 +0800956 if (!virtio_net_has_buffers(q, size + n->guest_hdr_len - n->host_hdr_len)) {
Mark McLoughlin8aeff622009-04-29 13:40:02 +0100957 return 0;
Jason Wang0c87e932013-01-30 19:12:38 +0800958 }
aliguorifbe78f42008-12-17 19:13:11 +0000959
aliguori3831ab22009-02-05 22:36:24 +0000960 if (!receive_filter(n, buf, size))
Mark McLoughlin4f1c9422009-05-18 13:40:55 +0100961 return size;
aliguori3831ab22009-02-05 22:36:24 +0000962
aliguorifbe78f42008-12-17 19:13:11 +0000963 offset = i = 0;
964
965 while (offset < size) {
966 VirtQueueElement elem;
967 int len, total;
Michael S. Tsirkin22cc84d2012-09-24 13:14:16 +0200968 const struct iovec *sg = elem.in_sg;
aliguorifbe78f42008-12-17 19:13:11 +0000969
Amit Shah22c253d2010-01-13 16:24:43 +0530970 total = 0;
aliguorifbe78f42008-12-17 19:13:11 +0000971
Jason Wang0c87e932013-01-30 19:12:38 +0800972 if (virtqueue_pop(q->rx_vq, &elem) == 0) {
aliguorifbe78f42008-12-17 19:13:11 +0000973 if (i == 0)
Mark McLoughlin4f1c9422009-05-18 13:40:55 +0100974 return -1;
Stefan Hajnoczie7b43f72010-11-15 20:44:37 +0000975 error_report("virtio-net unexpected empty queue: "
Michael S. Tsirkin279a4252010-06-22 16:22:49 +0300976 "i %zd mergeable %d offset %zd, size %zd, "
Stefan Hajnoczie7b43f72010-11-15 20:44:37 +0000977 "guest hdr len %zd, host hdr len %zd guest features 0x%x",
Michael S. Tsirkin279a4252010-06-22 16:22:49 +0300978 i, n->mergeable_rx_bufs, offset, size,
KONRAD Frederic17a0ca52013-04-11 16:30:01 +0200979 n->guest_hdr_len, n->host_hdr_len, vdev->guest_features);
aliguorifbe78f42008-12-17 19:13:11 +0000980 exit(1);
981 }
982
983 if (elem.in_num < 1) {
Stefan Hajnoczie7b43f72010-11-15 20:44:37 +0000984 error_report("virtio-net receive queue contains no in buffers");
aliguorifbe78f42008-12-17 19:13:11 +0000985 exit(1);
986 }
987
aliguorifbe78f42008-12-17 19:13:11 +0000988 if (i == 0) {
Michael S. Tsirkinc8d28e72012-09-24 13:26:55 +0200989 assert(offset == 0);
Michael S. Tsirkin63c58722012-09-24 13:17:13 +0200990 if (n->mergeable_rx_bufs) {
991 mhdr_cnt = iov_copy(mhdr_sg, ARRAY_SIZE(mhdr_sg),
992 sg, elem.in_num,
993 offsetof(typeof(mhdr), num_buffers),
994 sizeof(mhdr.num_buffers));
995 }
aliguorifbe78f42008-12-17 19:13:11 +0000996
Michael S. Tsirkinc8d28e72012-09-24 13:26:55 +0200997 receive_header(n, sg, elem.in_num, buf, size);
998 offset = n->host_hdr_len;
Michael S. Tsirkine35e23f2012-09-24 12:12:25 +0200999 total += n->guest_hdr_len;
Michael S. Tsirkin22cc84d2012-09-24 13:14:16 +02001000 guest_offset = n->guest_hdr_len;
1001 } else {
1002 guest_offset = 0;
aliguorifbe78f42008-12-17 19:13:11 +00001003 }
1004
1005 /* copy in packet. ugh */
Michael S. Tsirkin22cc84d2012-09-24 13:14:16 +02001006 len = iov_from_buf(sg, elem.in_num, guest_offset,
Michael Tokarevdcf6f5e2012-03-11 18:05:12 +04001007 buf + offset, size - offset);
aliguorifbe78f42008-12-17 19:13:11 +00001008 total += len;
Michael S. Tsirkin279a4252010-06-22 16:22:49 +03001009 offset += len;
1010 /* If buffers can't be merged, at this point we
1011 * must have consumed the complete packet.
1012 * Otherwise, drop it. */
1013 if (!n->mergeable_rx_bufs && offset < size) {
1014#if 0
Stefan Hajnoczie7b43f72010-11-15 20:44:37 +00001015 error_report("virtio-net truncated non-mergeable packet: "
1016 "i %zd mergeable %d offset %zd, size %zd, "
1017 "guest hdr len %zd, host hdr len %zd",
1018 i, n->mergeable_rx_bufs,
Michael S. Tsirkine35e23f2012-09-24 12:12:25 +02001019 offset, size, n->guest_hdr_len, n->host_hdr_len);
Michael S. Tsirkin279a4252010-06-22 16:22:49 +03001020#endif
1021 return size;
1022 }
aliguorifbe78f42008-12-17 19:13:11 +00001023
1024 /* signal other side */
Jason Wang0c87e932013-01-30 19:12:38 +08001025 virtqueue_fill(q->rx_vq, &elem, total, i++);
aliguorifbe78f42008-12-17 19:13:11 +00001026 }
1027
Michael S. Tsirkin63c58722012-09-24 13:17:13 +02001028 if (mhdr_cnt) {
1029 stw_p(&mhdr.num_buffers, i);
1030 iov_from_buf(mhdr_sg, mhdr_cnt,
1031 0,
1032 &mhdr.num_buffers, sizeof mhdr.num_buffers);
Aurelien Jarno44b15bc2011-01-25 11:55:14 +01001033 }
aliguorifbe78f42008-12-17 19:13:11 +00001034
Jason Wang0c87e932013-01-30 19:12:38 +08001035 virtqueue_flush(q->rx_vq, i);
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001036 virtio_notify(vdev, q->rx_vq);
Mark McLoughlin4f1c9422009-05-18 13:40:55 +01001037
1038 return size;
aliguorifbe78f42008-12-17 19:13:11 +00001039}
1040
Jason Wang0c87e932013-01-30 19:12:38 +08001041static int32_t virtio_net_flush_tx(VirtIONetQueue *q);
Mark McLoughlin62433752009-06-18 18:21:36 +01001042
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +01001043static void virtio_net_tx_complete(NetClientState *nc, ssize_t len)
Mark McLoughlin62433752009-06-18 18:21:36 +01001044{
Jason Wangcc1f0f42013-01-30 19:12:23 +08001045 VirtIONet *n = qemu_get_nic_opaque(nc);
Jason Wangfed699f2013-01-30 19:12:39 +08001046 VirtIONetQueue *q = virtio_net_get_subqueue(nc);
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001047 VirtIODevice *vdev = VIRTIO_DEVICE(n);
Mark McLoughlin62433752009-06-18 18:21:36 +01001048
Jason Wang0c87e932013-01-30 19:12:38 +08001049 virtqueue_push(q->tx_vq, &q->async_tx.elem, 0);
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001050 virtio_notify(vdev, q->tx_vq);
Mark McLoughlin62433752009-06-18 18:21:36 +01001051
Jason Wang0c87e932013-01-30 19:12:38 +08001052 q->async_tx.elem.out_num = q->async_tx.len = 0;
Mark McLoughlin62433752009-06-18 18:21:36 +01001053
Jason Wang0c87e932013-01-30 19:12:38 +08001054 virtio_queue_set_notification(q->tx_vq, 1);
1055 virtio_net_flush_tx(q);
Mark McLoughlin62433752009-06-18 18:21:36 +01001056}
1057
aliguorifbe78f42008-12-17 19:13:11 +00001058/* TX */
Jason Wang0c87e932013-01-30 19:12:38 +08001059static int32_t virtio_net_flush_tx(VirtIONetQueue *q)
aliguorifbe78f42008-12-17 19:13:11 +00001060{
Jason Wang0c87e932013-01-30 19:12:38 +08001061 VirtIONet *n = q->n;
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001062 VirtIODevice *vdev = VIRTIO_DEVICE(n);
aliguorifbe78f42008-12-17 19:13:11 +00001063 VirtQueueElement elem;
Alex Williamsone3f30482010-09-02 09:00:57 -06001064 int32_t num_packets = 0;
Jason Wangfed699f2013-01-30 19:12:39 +08001065 int queue_index = vq2q(virtio_get_queue_index(q->tx_vq));
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001066 if (!(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK)) {
Alex Williamsone3f30482010-09-02 09:00:57 -06001067 return num_packets;
1068 }
aliguorifbe78f42008-12-17 19:13:11 +00001069
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001070 assert(vdev->vm_running);
Michael S. Tsirkin783e7702010-11-22 19:52:30 +02001071
Jason Wang0c87e932013-01-30 19:12:38 +08001072 if (q->async_tx.elem.out_num) {
1073 virtio_queue_set_notification(q->tx_vq, 0);
Alex Williamsone3f30482010-09-02 09:00:57 -06001074 return num_packets;
Mark McLoughlin62433752009-06-18 18:21:36 +01001075 }
1076
Jason Wang0c87e932013-01-30 19:12:38 +08001077 while (virtqueue_pop(q->tx_vq, &elem)) {
Michael S. Tsirkin14761f92012-09-24 14:52:28 +02001078 ssize_t ret, len;
aliguorifbe78f42008-12-17 19:13:11 +00001079 unsigned int out_num = elem.out_num;
1080 struct iovec *out_sg = &elem.out_sg[0];
Michael S. Tsirkin14761f92012-09-24 14:52:28 +02001081 struct iovec sg[VIRTQUEUE_MAX_SIZE];
aliguorifbe78f42008-12-17 19:13:11 +00001082
Michael S. Tsirkin7b80d082012-09-24 14:54:44 +02001083 if (out_num < 1) {
Stefan Hajnoczie7b43f72010-11-15 20:44:37 +00001084 error_report("virtio-net header not in first element");
aliguorifbe78f42008-12-17 19:13:11 +00001085 exit(1);
1086 }
1087
Michael S. Tsirkin14761f92012-09-24 14:52:28 +02001088 /*
1089 * If host wants to see the guest header as is, we can
1090 * pass it on unchanged. Otherwise, copy just the parts
1091 * that host is interested in.
1092 */
1093 assert(n->host_hdr_len <= n->guest_hdr_len);
1094 if (n->host_hdr_len != n->guest_hdr_len) {
1095 unsigned sg_num = iov_copy(sg, ARRAY_SIZE(sg),
1096 out_sg, out_num,
1097 0, n->host_hdr_len);
1098 sg_num += iov_copy(sg + sg_num, ARRAY_SIZE(sg) - sg_num,
1099 out_sg, out_num,
1100 n->guest_hdr_len, -1);
1101 out_num = sg_num;
1102 out_sg = sg;
aliguorifbe78f42008-12-17 19:13:11 +00001103 }
1104
Michael S. Tsirkin7b80d082012-09-24 14:54:44 +02001105 len = n->guest_hdr_len;
Michael S. Tsirkin14761f92012-09-24 14:52:28 +02001106
Jason Wangfed699f2013-01-30 19:12:39 +08001107 ret = qemu_sendv_packet_async(qemu_get_subqueue(n->nic, queue_index),
1108 out_sg, out_num, virtio_net_tx_complete);
Mark McLoughlin62433752009-06-18 18:21:36 +01001109 if (ret == 0) {
Jason Wang0c87e932013-01-30 19:12:38 +08001110 virtio_queue_set_notification(q->tx_vq, 0);
1111 q->async_tx.elem = elem;
1112 q->async_tx.len = len;
Alex Williamsone3f30482010-09-02 09:00:57 -06001113 return -EBUSY;
Mark McLoughlin62433752009-06-18 18:21:36 +01001114 }
1115
1116 len += ret;
aliguorifbe78f42008-12-17 19:13:11 +00001117
Jason Wang0c87e932013-01-30 19:12:38 +08001118 virtqueue_push(q->tx_vq, &elem, 0);
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001119 virtio_notify(vdev, q->tx_vq);
Alex Williamsone3f30482010-09-02 09:00:57 -06001120
1121 if (++num_packets >= n->tx_burst) {
1122 break;
1123 }
aliguorifbe78f42008-12-17 19:13:11 +00001124 }
Alex Williamsone3f30482010-09-02 09:00:57 -06001125 return num_packets;
aliguorifbe78f42008-12-17 19:13:11 +00001126}
1127
Alex Williamsona697a332010-09-02 09:01:10 -06001128static void virtio_net_handle_tx_timer(VirtIODevice *vdev, VirtQueue *vq)
aliguorifbe78f42008-12-17 19:13:11 +00001129{
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001130 VirtIONet *n = VIRTIO_NET(vdev);
Jason Wangfed699f2013-01-30 19:12:39 +08001131 VirtIONetQueue *q = &n->vqs[vq2q(virtio_get_queue_index(vq))];
aliguorifbe78f42008-12-17 19:13:11 +00001132
Michael S. Tsirkin783e7702010-11-22 19:52:30 +02001133 /* This happens when device was stopped but VCPU wasn't. */
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001134 if (!vdev->vm_running) {
Jason Wang0c87e932013-01-30 19:12:38 +08001135 q->tx_waiting = 1;
Michael S. Tsirkin783e7702010-11-22 19:52:30 +02001136 return;
1137 }
1138
Jason Wang0c87e932013-01-30 19:12:38 +08001139 if (q->tx_waiting) {
aliguorifbe78f42008-12-17 19:13:11 +00001140 virtio_queue_set_notification(vq, 1);
Alex Blighbc72ad62013-08-21 16:03:08 +01001141 timer_del(q->tx_timer);
Jason Wang0c87e932013-01-30 19:12:38 +08001142 q->tx_waiting = 0;
1143 virtio_net_flush_tx(q);
aliguorifbe78f42008-12-17 19:13:11 +00001144 } else {
Alex Blighbc72ad62013-08-21 16:03:08 +01001145 timer_mod(q->tx_timer,
1146 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + n->tx_timeout);
Jason Wang0c87e932013-01-30 19:12:38 +08001147 q->tx_waiting = 1;
aliguorifbe78f42008-12-17 19:13:11 +00001148 virtio_queue_set_notification(vq, 0);
1149 }
1150}
1151
Alex Williamsona697a332010-09-02 09:01:10 -06001152static void virtio_net_handle_tx_bh(VirtIODevice *vdev, VirtQueue *vq)
1153{
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001154 VirtIONet *n = VIRTIO_NET(vdev);
Jason Wangfed699f2013-01-30 19:12:39 +08001155 VirtIONetQueue *q = &n->vqs[vq2q(virtio_get_queue_index(vq))];
Alex Williamsona697a332010-09-02 09:01:10 -06001156
Jason Wang0c87e932013-01-30 19:12:38 +08001157 if (unlikely(q->tx_waiting)) {
Alex Williamsona697a332010-09-02 09:01:10 -06001158 return;
1159 }
Jason Wang0c87e932013-01-30 19:12:38 +08001160 q->tx_waiting = 1;
Michael S. Tsirkin783e7702010-11-22 19:52:30 +02001161 /* This happens when device was stopped but VCPU wasn't. */
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001162 if (!vdev->vm_running) {
Michael S. Tsirkin783e7702010-11-22 19:52:30 +02001163 return;
1164 }
Alex Williamsona697a332010-09-02 09:01:10 -06001165 virtio_queue_set_notification(vq, 0);
Jason Wang0c87e932013-01-30 19:12:38 +08001166 qemu_bh_schedule(q->tx_bh);
Alex Williamsona697a332010-09-02 09:01:10 -06001167}
1168
aliguorifbe78f42008-12-17 19:13:11 +00001169static void virtio_net_tx_timer(void *opaque)
1170{
Jason Wang0c87e932013-01-30 19:12:38 +08001171 VirtIONetQueue *q = opaque;
1172 VirtIONet *n = q->n;
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001173 VirtIODevice *vdev = VIRTIO_DEVICE(n);
1174 assert(vdev->vm_running);
aliguorifbe78f42008-12-17 19:13:11 +00001175
Jason Wang0c87e932013-01-30 19:12:38 +08001176 q->tx_waiting = 0;
aliguorifbe78f42008-12-17 19:13:11 +00001177
1178 /* Just in case the driver is not ready on more */
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001179 if (!(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK)) {
aliguorifbe78f42008-12-17 19:13:11 +00001180 return;
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001181 }
aliguorifbe78f42008-12-17 19:13:11 +00001182
Jason Wang0c87e932013-01-30 19:12:38 +08001183 virtio_queue_set_notification(q->tx_vq, 1);
1184 virtio_net_flush_tx(q);
aliguorifbe78f42008-12-17 19:13:11 +00001185}
1186
Alex Williamsona697a332010-09-02 09:01:10 -06001187static void virtio_net_tx_bh(void *opaque)
1188{
Jason Wang0c87e932013-01-30 19:12:38 +08001189 VirtIONetQueue *q = opaque;
1190 VirtIONet *n = q->n;
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001191 VirtIODevice *vdev = VIRTIO_DEVICE(n);
Alex Williamsona697a332010-09-02 09:01:10 -06001192 int32_t ret;
1193
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001194 assert(vdev->vm_running);
Michael S. Tsirkin783e7702010-11-22 19:52:30 +02001195
Jason Wang0c87e932013-01-30 19:12:38 +08001196 q->tx_waiting = 0;
Alex Williamsona697a332010-09-02 09:01:10 -06001197
1198 /* Just in case the driver is not ready on more */
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001199 if (unlikely(!(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK))) {
Alex Williamsona697a332010-09-02 09:01:10 -06001200 return;
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001201 }
Alex Williamsona697a332010-09-02 09:01:10 -06001202
Jason Wang0c87e932013-01-30 19:12:38 +08001203 ret = virtio_net_flush_tx(q);
Alex Williamsona697a332010-09-02 09:01:10 -06001204 if (ret == -EBUSY) {
1205 return; /* Notification re-enable handled by tx_complete */
1206 }
1207
1208 /* If we flush a full burst of packets, assume there are
1209 * more coming and immediately reschedule */
1210 if (ret >= n->tx_burst) {
Jason Wang0c87e932013-01-30 19:12:38 +08001211 qemu_bh_schedule(q->tx_bh);
1212 q->tx_waiting = 1;
Alex Williamsona697a332010-09-02 09:01:10 -06001213 return;
1214 }
1215
1216 /* If less than a full burst, re-enable notification and flush
1217 * anything that may have come in while we weren't looking. If
1218 * we find something, assume the guest is still active and reschedule */
Jason Wang0c87e932013-01-30 19:12:38 +08001219 virtio_queue_set_notification(q->tx_vq, 1);
1220 if (virtio_net_flush_tx(q) > 0) {
1221 virtio_queue_set_notification(q->tx_vq, 0);
1222 qemu_bh_schedule(q->tx_bh);
1223 q->tx_waiting = 1;
Alex Williamsona697a332010-09-02 09:01:10 -06001224 }
1225}
1226
Jason Wangec57db12013-04-25 15:24:23 +08001227static void virtio_net_set_multiqueue(VirtIONet *n, int multiqueue)
Jason Wangfed699f2013-01-30 19:12:39 +08001228{
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001229 VirtIODevice *vdev = VIRTIO_DEVICE(n);
Jason Wangfed699f2013-01-30 19:12:39 +08001230 int i, max = multiqueue ? n->max_queues : 1;
1231
1232 n->multiqueue = multiqueue;
1233
1234 for (i = 2; i <= n->max_queues * 2 + 1; i++) {
1235 virtio_del_queue(vdev, i);
1236 }
1237
1238 for (i = 1; i < max; i++) {
1239 n->vqs[i].rx_vq = virtio_add_queue(vdev, 256, virtio_net_handle_rx);
1240 if (n->vqs[i].tx_timer) {
1241 n->vqs[i].tx_vq =
1242 virtio_add_queue(vdev, 256, virtio_net_handle_tx_timer);
Alex Blighbc72ad62013-08-21 16:03:08 +01001243 n->vqs[i].tx_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL,
Jason Wangfed699f2013-01-30 19:12:39 +08001244 virtio_net_tx_timer,
1245 &n->vqs[i]);
1246 } else {
1247 n->vqs[i].tx_vq =
1248 virtio_add_queue(vdev, 256, virtio_net_handle_tx_bh);
1249 n->vqs[i].tx_bh = qemu_bh_new(virtio_net_tx_bh, &n->vqs[i]);
1250 }
1251
1252 n->vqs[i].tx_waiting = 0;
1253 n->vqs[i].n = n;
1254 }
1255
Jason Wangec57db12013-04-25 15:24:23 +08001256 /* Note: Minux Guests (version 3.2.1) use ctrl vq but don't ack
1257 * VIRTIO_NET_F_CTRL_VQ. Create ctrl vq unconditionally to avoid
1258 * breaking them.
1259 */
1260 n->ctrl_vq = virtio_add_queue(vdev, 64, virtio_net_handle_ctrl);
Jason Wangfed699f2013-01-30 19:12:39 +08001261
1262 virtio_net_set_queues(n);
1263}
1264
aliguorifbe78f42008-12-17 19:13:11 +00001265static void virtio_net_save(QEMUFile *f, void *opaque)
1266{
Jason Wang5f800802013-01-30 19:12:40 +08001267 int i;
aliguorifbe78f42008-12-17 19:13:11 +00001268 VirtIONet *n = opaque;
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001269 VirtIODevice *vdev = VIRTIO_DEVICE(n);
aliguorifbe78f42008-12-17 19:13:11 +00001270
Michael S. Tsirkinafbaa7b2010-09-27 18:41:30 +02001271 /* At this point, backend must be stopped, otherwise
1272 * it might keep writing to memory. */
1273 assert(!n->vhost_started);
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001274 virtio_save(vdev, f);
aliguorifbe78f42008-12-17 19:13:11 +00001275
aliguori79674062009-02-05 22:36:12 +00001276 qemu_put_buffer(f, n->mac, ETH_ALEN);
Jason Wang5f800802013-01-30 19:12:40 +08001277 qemu_put_be32(f, n->vqs[0].tx_waiting);
aliguorie46cb382009-01-07 17:50:45 +00001278 qemu_put_be32(f, n->mergeable_rx_bufs);
aliguori9d6271b2009-02-05 22:36:04 +00001279 qemu_put_be16(f, n->status);
Alex Williamsonf10c5922009-06-05 14:46:57 -06001280 qemu_put_byte(f, n->promisc);
1281 qemu_put_byte(f, n->allmulti);
aliguorib6503ed2009-02-05 22:36:28 +00001282 qemu_put_be32(f, n->mac_table.in_use);
1283 qemu_put_buffer(f, n->mac_table.macs, n->mac_table.in_use * ETH_ALEN);
aliguorif21c0ed2009-02-05 22:36:32 +00001284 qemu_put_buffer(f, (uint8_t *)n->vlans, MAX_VLAN >> 3);
Mark McLoughlin3a330132009-10-22 17:43:45 +01001285 qemu_put_be32(f, n->has_vnet_hdr);
Alex Williamson8fd2a2f2009-06-05 14:47:08 -06001286 qemu_put_byte(f, n->mac_table.multi_overflow);
1287 qemu_put_byte(f, n->mac_table.uni_overflow);
Alex Williamson015cb162009-06-05 14:47:18 -06001288 qemu_put_byte(f, n->alluni);
1289 qemu_put_byte(f, n->nomulti);
1290 qemu_put_byte(f, n->nouni);
1291 qemu_put_byte(f, n->nobcast);
Mark McLoughlin0ce0e8f2009-10-22 17:43:50 +01001292 qemu_put_byte(f, n->has_ufo);
Jason Wang5f800802013-01-30 19:12:40 +08001293 if (n->max_queues > 1) {
1294 qemu_put_be16(f, n->max_queues);
1295 qemu_put_be16(f, n->curr_queues);
1296 for (i = 1; i < n->curr_queues; i++) {
1297 qemu_put_be32(f, n->vqs[i].tx_waiting);
1298 }
1299 }
Dmitry Fleytman644c9852013-05-20 11:18:14 +03001300
1301 if ((1 << VIRTIO_NET_F_CTRL_GUEST_OFFLOADS) & vdev->guest_features) {
1302 qemu_put_be64(f, n->curr_guest_offloads);
1303 }
aliguorifbe78f42008-12-17 19:13:11 +00001304}
1305
1306static int virtio_net_load(QEMUFile *f, void *opaque, int version_id)
1307{
1308 VirtIONet *n = opaque;
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001309 VirtIODevice *vdev = VIRTIO_DEVICE(n);
Jason Wang5f800802013-01-30 19:12:40 +08001310 int ret, i, link_down;
aliguorifbe78f42008-12-17 19:13:11 +00001311
aliguori9d6271b2009-02-05 22:36:04 +00001312 if (version_id < 2 || version_id > VIRTIO_NET_VM_VERSION)
aliguorifbe78f42008-12-17 19:13:11 +00001313 return -EINVAL;
1314
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001315 ret = virtio_load(vdev, f);
Orit Wassermann2a633c42012-05-16 12:21:35 +02001316 if (ret) {
1317 return ret;
1318 }
aliguorifbe78f42008-12-17 19:13:11 +00001319
aliguori79674062009-02-05 22:36:12 +00001320 qemu_get_buffer(f, n->mac, ETH_ALEN);
Jason Wang5f800802013-01-30 19:12:40 +08001321 n->vqs[0].tx_waiting = qemu_get_be32(f);
Michael S. Tsirkinff3a8062012-09-24 21:05:03 +02001322
1323 virtio_net_set_mrg_rx_bufs(n, qemu_get_be32(f));
aliguorifbe78f42008-12-17 19:13:11 +00001324
aliguori9d6271b2009-02-05 22:36:04 +00001325 if (version_id >= 3)
1326 n->status = qemu_get_be16(f);
1327
aliguori002437c2009-02-05 22:36:20 +00001328 if (version_id >= 4) {
Alex Williamsonf10c5922009-06-05 14:46:57 -06001329 if (version_id < 8) {
1330 n->promisc = qemu_get_be32(f);
1331 n->allmulti = qemu_get_be32(f);
1332 } else {
1333 n->promisc = qemu_get_byte(f);
1334 n->allmulti = qemu_get_byte(f);
1335 }
aliguori002437c2009-02-05 22:36:20 +00001336 }
1337
aliguorib6503ed2009-02-05 22:36:28 +00001338 if (version_id >= 5) {
1339 n->mac_table.in_use = qemu_get_be32(f);
1340 /* MAC_TABLE_ENTRIES may be different from the saved image */
1341 if (n->mac_table.in_use <= MAC_TABLE_ENTRIES) {
1342 qemu_get_buffer(f, n->mac_table.macs,
1343 n->mac_table.in_use * ETH_ALEN);
1344 } else if (n->mac_table.in_use) {
Juan Quintelae398d612012-08-29 19:03:09 +02001345 uint8_t *buf = g_malloc0(n->mac_table.in_use);
1346 qemu_get_buffer(f, buf, n->mac_table.in_use * ETH_ALEN);
1347 g_free(buf);
Alex Williamson8fd2a2f2009-06-05 14:47:08 -06001348 n->mac_table.multi_overflow = n->mac_table.uni_overflow = 1;
aliguorib6503ed2009-02-05 22:36:28 +00001349 n->mac_table.in_use = 0;
1350 }
1351 }
1352
aliguorif21c0ed2009-02-05 22:36:32 +00001353 if (version_id >= 6)
1354 qemu_get_buffer(f, (uint8_t *)n->vlans, MAX_VLAN >> 3);
1355
Mark McLoughlin3a330132009-10-22 17:43:45 +01001356 if (version_id >= 7) {
1357 if (qemu_get_be32(f) && !peer_has_vnet_hdr(n)) {
Markus Armbruster1ecda022010-02-18 17:25:24 +01001358 error_report("virtio-net: saved image requires vnet_hdr=on");
Mark McLoughlin3a330132009-10-22 17:43:45 +01001359 return -1;
1360 }
Alex Williamson6c042c12009-06-05 14:46:52 -06001361 }
1362
Alex Williamson8fd2a2f2009-06-05 14:47:08 -06001363 if (version_id >= 9) {
1364 n->mac_table.multi_overflow = qemu_get_byte(f);
1365 n->mac_table.uni_overflow = qemu_get_byte(f);
1366 }
1367
Alex Williamson015cb162009-06-05 14:47:18 -06001368 if (version_id >= 10) {
1369 n->alluni = qemu_get_byte(f);
1370 n->nomulti = qemu_get_byte(f);
1371 n->nouni = qemu_get_byte(f);
1372 n->nobcast = qemu_get_byte(f);
1373 }
1374
Mark McLoughlin0ce0e8f2009-10-22 17:43:50 +01001375 if (version_id >= 11) {
1376 if (qemu_get_byte(f) && !peer_has_ufo(n)) {
Markus Armbruster1ecda022010-02-18 17:25:24 +01001377 error_report("virtio-net: saved image requires TUN_F_UFO support");
Mark McLoughlin0ce0e8f2009-10-22 17:43:50 +01001378 return -1;
1379 }
1380 }
1381
Jason Wang5f800802013-01-30 19:12:40 +08001382 if (n->max_queues > 1) {
1383 if (n->max_queues != qemu_get_be16(f)) {
1384 error_report("virtio-net: different max_queues ");
1385 return -1;
1386 }
1387
1388 n->curr_queues = qemu_get_be16(f);
1389 for (i = 1; i < n->curr_queues; i++) {
1390 n->vqs[i].tx_waiting = qemu_get_be32(f);
1391 }
1392 }
1393
Dmitry Fleytman644c9852013-05-20 11:18:14 +03001394 if ((1 << VIRTIO_NET_F_CTRL_GUEST_OFFLOADS) & vdev->guest_features) {
1395 n->curr_guest_offloads = qemu_get_be64(f);
1396 } else {
1397 n->curr_guest_offloads = virtio_net_supported_guest_offloads(n);
1398 }
1399
1400 if (peer_has_vnet_hdr(n)) {
1401 virtio_net_apply_guest_offloads(n);
1402 }
1403
Jason Wang5f800802013-01-30 19:12:40 +08001404 virtio_net_set_queues(n);
1405
Alex Williamson2d9aba32009-06-05 14:47:13 -06001406 /* Find the first multicast entry in the saved MAC filter */
1407 for (i = 0; i < n->mac_table.in_use; i++) {
1408 if (n->mac_table.macs[i * ETH_ALEN] & 1) {
1409 break;
1410 }
1411 }
1412 n->mac_table.first_multi = i;
Amos Kong98991482012-09-28 10:06:02 +08001413
1414 /* nc.link_down can't be migrated, so infer link_down according
1415 * to link status bit in n->status */
Jason Wang5f800802013-01-30 19:12:40 +08001416 link_down = (n->status & VIRTIO_NET_S_LINK_UP) == 0;
1417 for (i = 0; i < n->max_queues; i++) {
1418 qemu_get_subqueue(n->nic, i)->link_down = link_down;
1419 }
Amos Kong98991482012-09-28 10:06:02 +08001420
aliguorifbe78f42008-12-17 19:13:11 +00001421 return 0;
1422}
1423
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +01001424static void virtio_net_cleanup(NetClientState *nc)
aliguorib946a152009-04-17 17:11:08 +00001425{
Jason Wangcc1f0f42013-01-30 19:12:23 +08001426 VirtIONet *n = qemu_get_nic_opaque(nc);
aliguorib946a152009-04-17 17:11:08 +00001427
Mark McLoughlineb6b6c12009-11-25 18:49:11 +00001428 n->nic = NULL;
aliguorib946a152009-04-17 17:11:08 +00001429}
1430
Mark McLoughlineb6b6c12009-11-25 18:49:11 +00001431static NetClientInfo net_virtio_info = {
Laszlo Ersek2be64a62012-07-17 16:17:12 +02001432 .type = NET_CLIENT_OPTIONS_KIND_NIC,
Mark McLoughlineb6b6c12009-11-25 18:49:11 +00001433 .size = sizeof(NICState),
1434 .can_receive = virtio_net_can_receive,
1435 .receive = virtio_net_receive,
Zhi Yong Wucb77e352013-11-27 15:35:26 +08001436 .cleanup = virtio_net_cleanup,
Mark McLoughlineb6b6c12009-11-25 18:49:11 +00001437 .link_status_changed = virtio_net_set_link_status,
Amos Kongb1be4282013-06-14 15:45:52 +08001438 .query_rx_filter = virtio_net_query_rxfilter,
Mark McLoughlineb6b6c12009-11-25 18:49:11 +00001439};
1440
Michael S. Tsirkinf56a1242012-12-24 17:37:01 +02001441static bool virtio_net_guest_notifier_pending(VirtIODevice *vdev, int idx)
1442{
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001443 VirtIONet *n = VIRTIO_NET(vdev);
Jason Wangfed699f2013-01-30 19:12:39 +08001444 NetClientState *nc = qemu_get_subqueue(n->nic, vq2q(idx));
Michael S. Tsirkinf56a1242012-12-24 17:37:01 +02001445 assert(n->vhost_started);
Jason Wangb356f762013-01-30 19:12:22 +08001446 return vhost_net_virtqueue_pending(tap_get_vhost_net(nc->peer), idx);
Michael S. Tsirkinf56a1242012-12-24 17:37:01 +02001447}
1448
1449static void virtio_net_guest_notifier_mask(VirtIODevice *vdev, int idx,
1450 bool mask)
1451{
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001452 VirtIONet *n = VIRTIO_NET(vdev);
Jason Wangfed699f2013-01-30 19:12:39 +08001453 NetClientState *nc = qemu_get_subqueue(n->nic, vq2q(idx));
Michael S. Tsirkinf56a1242012-12-24 17:37:01 +02001454 assert(n->vhost_started);
Jason Wangb356f762013-01-30 19:12:22 +08001455 vhost_net_virtqueue_mask(tap_get_vhost_net(nc->peer),
Michael S. Tsirkinf56a1242012-12-24 17:37:01 +02001456 vdev, idx, mask);
1457}
1458
KONRAD Frederic17ec5a82013-04-11 16:29:57 +02001459void virtio_net_set_config_size(VirtIONet *n, uint32_t host_features)
aliguorifbe78f42008-12-17 19:13:11 +00001460{
Jesse Larrew14f9b662013-02-05 17:47:16 -06001461 int i, config_size = 0;
Jason Wange9016ee2013-04-25 15:26:54 +08001462 host_features |= (1 << VIRTIO_NET_F_MAC);
Jesse Larrew14f9b662013-02-05 17:47:16 -06001463 for (i = 0; feature_sizes[i].flags != 0; i++) {
1464 if (host_features & feature_sizes[i].flags) {
1465 config_size = MAX(feature_sizes[i].end, config_size);
1466 }
1467 }
Jesse Larrew14f9b662013-02-05 17:47:16 -06001468 n->config_size = config_size;
KONRAD Frederic17ec5a82013-04-11 16:29:57 +02001469}
1470
KONRAD Frederic8a253ec2013-05-15 14:12:49 +02001471void virtio_net_set_netclient_name(VirtIONet *n, const char *name,
1472 const char *type)
1473{
1474 /*
1475 * The name can be NULL, the netclient name will be type.x.
1476 */
1477 assert(type != NULL);
1478
1479 if (n->netclient_name) {
1480 g_free(n->netclient_name);
1481 n->netclient_name = NULL;
1482 }
1483 if (n->netclient_type) {
1484 g_free(n->netclient_type);
1485 n->netclient_type = NULL;
1486 }
1487
1488 if (name != NULL) {
1489 n->netclient_name = g_strdup(name);
1490 }
1491 n->netclient_type = g_strdup(type);
1492}
1493
KONRAD Frederic1773d9e2013-04-11 16:30:02 +02001494static int virtio_net_device_init(VirtIODevice *vdev)
KONRAD Frederic17ec5a82013-04-11 16:29:57 +02001495{
KONRAD Frederic1773d9e2013-04-11 16:30:02 +02001496 int i;
KONRAD Frederic17ec5a82013-04-11 16:29:57 +02001497
KONRAD Frederic1773d9e2013-04-11 16:30:02 +02001498 DeviceState *qdev = DEVICE(vdev);
1499 VirtIONet *n = VIRTIO_NET(vdev);
Amos Kongb1be4282013-06-14 15:45:52 +08001500 NetClientState *nc;
KONRAD Frederic1773d9e2013-04-11 16:30:02 +02001501
1502 virtio_init(VIRTIO_DEVICE(n), "virtio-net", VIRTIO_ID_NET,
1503 n->config_size);
KONRAD Frederic17ec5a82013-04-11 16:29:57 +02001504
KONRAD Frederic1773d9e2013-04-11 16:30:02 +02001505 n->max_queues = MAX(n->nic_conf.queues, 1);
Jason Wangf6b26cf2013-02-22 23:15:06 +08001506 n->vqs = g_malloc0(sizeof(VirtIONetQueue) * n->max_queues);
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001507 n->vqs[0].rx_vq = virtio_add_queue(vdev, 256, virtio_net_handle_rx);
Jason Wangfed699f2013-01-30 19:12:39 +08001508 n->curr_queues = 1;
1509 n->vqs[0].n = n;
KONRAD Frederic1773d9e2013-04-11 16:30:02 +02001510 n->tx_timeout = n->net_conf.txtimer;
Alex Williamsona697a332010-09-02 09:01:10 -06001511
KONRAD Frederic1773d9e2013-04-11 16:30:02 +02001512 if (n->net_conf.tx && strcmp(n->net_conf.tx, "timer")
1513 && strcmp(n->net_conf.tx, "bh")) {
Stefan Hajnoczie7b43f72010-11-15 20:44:37 +00001514 error_report("virtio-net: "
1515 "Unknown option tx=%s, valid options: \"timer\" \"bh\"",
KONRAD Frederic1773d9e2013-04-11 16:30:02 +02001516 n->net_conf.tx);
Stefan Hajnoczie7b43f72010-11-15 20:44:37 +00001517 error_report("Defaulting to \"bh\"");
Alex Williamsona697a332010-09-02 09:01:10 -06001518 }
1519
KONRAD Frederic1773d9e2013-04-11 16:30:02 +02001520 if (n->net_conf.tx && !strcmp(n->net_conf.tx, "timer")) {
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001521 n->vqs[0].tx_vq = virtio_add_queue(vdev, 256,
Jason Wangfed699f2013-01-30 19:12:39 +08001522 virtio_net_handle_tx_timer);
Alex Blighbc72ad62013-08-21 16:03:08 +01001523 n->vqs[0].tx_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, virtio_net_tx_timer,
Jason Wangfed699f2013-01-30 19:12:39 +08001524 &n->vqs[0]);
Alex Williamsona697a332010-09-02 09:01:10 -06001525 } else {
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001526 n->vqs[0].tx_vq = virtio_add_queue(vdev, 256,
Jason Wangfed699f2013-01-30 19:12:39 +08001527 virtio_net_handle_tx_bh);
1528 n->vqs[0].tx_bh = qemu_bh_new(virtio_net_tx_bh, &n->vqs[0]);
Alex Williamsona697a332010-09-02 09:01:10 -06001529 }
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001530 n->ctrl_vq = virtio_add_queue(vdev, 64, virtio_net_handle_ctrl);
KONRAD Frederic1773d9e2013-04-11 16:30:02 +02001531 qemu_macaddr_default_if_unset(&n->nic_conf.macaddr);
1532 memcpy(&n->mac[0], &n->nic_conf.macaddr, sizeof(n->mac));
aliguori554c97d2009-01-08 19:46:33 +00001533 n->status = VIRTIO_NET_S_LINK_UP;
aliguorifbe78f42008-12-17 19:13:11 +00001534
KONRAD Frederic8a253ec2013-05-15 14:12:49 +02001535 if (n->netclient_type) {
1536 /*
1537 * Happen when virtio_net_set_netclient_name has been called.
1538 */
1539 n->nic = qemu_new_nic(&net_virtio_info, &n->nic_conf,
1540 n->netclient_type, n->netclient_name, n);
1541 } else {
1542 n->nic = qemu_new_nic(&net_virtio_info, &n->nic_conf,
1543 object_get_typename(OBJECT(qdev)), qdev->id, n);
1544 }
1545
Michael S. Tsirkin6e371ab2012-09-24 17:04:21 +02001546 peer_test_vnet_hdr(n);
1547 if (peer_has_vnet_hdr(n)) {
Jason Wangfed699f2013-01-30 19:12:39 +08001548 for (i = 0; i < n->max_queues; i++) {
1549 tap_using_vnet_hdr(qemu_get_subqueue(n->nic, i)->peer, true);
1550 }
Michael S. Tsirkin6e371ab2012-09-24 17:04:21 +02001551 n->host_hdr_len = sizeof(struct virtio_net_hdr);
1552 } else {
1553 n->host_hdr_len = 0;
1554 }
Mark McLoughlineb6b6c12009-11-25 18:49:11 +00001555
KONRAD Frederic1773d9e2013-04-11 16:30:02 +02001556 qemu_format_nic_info_str(qemu_get_queue(n->nic), n->nic_conf.macaddr.a);
aliguori96d5e202009-01-07 17:47:15 +00001557
Jason Wangfed699f2013-01-30 19:12:39 +08001558 n->vqs[0].tx_waiting = 0;
KONRAD Frederic1773d9e2013-04-11 16:30:02 +02001559 n->tx_burst = n->net_conf.txburst;
Michael S. Tsirkinff3a8062012-09-24 21:05:03 +02001560 virtio_net_set_mrg_rx_bufs(n, 0);
aliguori002437c2009-02-05 22:36:20 +00001561 n->promisc = 1; /* for compatibility */
aliguorifbe78f42008-12-17 19:13:11 +00001562
Anthony Liguori7267c092011-08-20 22:09:37 -05001563 n->mac_table.macs = g_malloc0(MAC_TABLE_ENTRIES * ETH_ALEN);
aliguorib6503ed2009-02-05 22:36:28 +00001564
Anthony Liguori7267c092011-08-20 22:09:37 -05001565 n->vlans = g_malloc0(MAX_VLAN >> 3);
aliguorif21c0ed2009-02-05 22:36:32 +00001566
Amos Kongb1be4282013-06-14 15:45:52 +08001567 nc = qemu_get_queue(n->nic);
1568 nc->rxfilter_notify_enabled = 1;
1569
KONRAD Frederic1773d9e2013-04-11 16:30:02 +02001570 n->qdev = qdev;
1571 register_savevm(qdev, "virtio-net", -1, VIRTIO_NET_VM_VERSION,
aliguorifbe78f42008-12-17 19:13:11 +00001572 virtio_net_save, virtio_net_load, n);
Paul Brookcf21e102009-05-14 22:35:07 +01001573
KONRAD Frederic1773d9e2013-04-11 16:30:02 +02001574 add_boot_device_path(n->nic_conf.bootindex, qdev, "/ethernet-phy@0");
KONRAD Frederic17ec5a82013-04-11 16:29:57 +02001575 return 0;
1576}
1577
1578static int virtio_net_device_exit(DeviceState *qdev)
1579{
1580 VirtIONet *n = VIRTIO_NET(qdev);
1581 VirtIODevice *vdev = VIRTIO_DEVICE(qdev);
1582 int i;
1583
1584 /* This will stop vhost backend if appropriate. */
1585 virtio_net_set_status(vdev, 0);
1586
1587 unregister_savevm(qdev, "virtio-net", n);
1588
KONRAD Frederic8a253ec2013-05-15 14:12:49 +02001589 if (n->netclient_name) {
1590 g_free(n->netclient_name);
1591 n->netclient_name = NULL;
1592 }
1593 if (n->netclient_type) {
1594 g_free(n->netclient_type);
1595 n->netclient_type = NULL;
1596 }
1597
KONRAD Frederic17ec5a82013-04-11 16:29:57 +02001598 g_free(n->mac_table.macs);
1599 g_free(n->vlans);
1600
1601 for (i = 0; i < n->max_queues; i++) {
1602 VirtIONetQueue *q = &n->vqs[i];
1603 NetClientState *nc = qemu_get_subqueue(n->nic, i);
1604
1605 qemu_purge_queued_packets(nc);
1606
1607 if (q->tx_timer) {
Alex Blighbc72ad62013-08-21 16:03:08 +01001608 timer_del(q->tx_timer);
1609 timer_free(q->tx_timer);
Jason Wangfe2dafa2013-11-06 16:58:08 +08001610 } else if (q->tx_bh) {
KONRAD Frederic17ec5a82013-04-11 16:29:57 +02001611 qemu_bh_delete(q->tx_bh);
1612 }
1613 }
1614
1615 g_free(n->vqs);
1616 qemu_del_nic(n->nic);
KONRAD Frederic6a1a8cc2013-04-24 10:21:22 +02001617 virtio_cleanup(vdev);
KONRAD Frederic17ec5a82013-04-11 16:29:57 +02001618
1619 return 0;
1620}
1621
1622static void virtio_net_instance_init(Object *obj)
1623{
1624 VirtIONet *n = VIRTIO_NET(obj);
1625
1626 /*
1627 * The default config_size is sizeof(struct virtio_net_config).
1628 * Can be overriden with virtio_net_set_config_size.
1629 */
1630 n->config_size = sizeof(struct virtio_net_config);
1631}
1632
1633static Property virtio_net_properties[] = {
1634 DEFINE_NIC_PROPERTIES(VirtIONet, nic_conf),
1635 DEFINE_PROP_UINT32("x-txtimer", VirtIONet, net_conf.txtimer,
1636 TX_TIMER_INTERVAL),
1637 DEFINE_PROP_INT32("x-txburst", VirtIONet, net_conf.txburst, TX_BURST),
1638 DEFINE_PROP_STRING("tx", VirtIONet, net_conf.tx),
1639 DEFINE_PROP_END_OF_LIST(),
1640};
1641
1642static void virtio_net_class_init(ObjectClass *klass, void *data)
1643{
1644 DeviceClass *dc = DEVICE_CLASS(klass);
1645 VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
1646 dc->exit = virtio_net_device_exit;
1647 dc->props = virtio_net_properties;
Marcel Apfelbaum125ee0e2013-07-29 17:17:45 +03001648 set_bit(DEVICE_CATEGORY_NETWORK, dc->categories);
KONRAD Frederic17ec5a82013-04-11 16:29:57 +02001649 vdc->init = virtio_net_device_init;
1650 vdc->get_config = virtio_net_get_config;
1651 vdc->set_config = virtio_net_set_config;
1652 vdc->get_features = virtio_net_get_features;
1653 vdc->set_features = virtio_net_set_features;
1654 vdc->bad_features = virtio_net_bad_features;
1655 vdc->reset = virtio_net_reset;
1656 vdc->set_status = virtio_net_set_status;
1657 vdc->guest_notifier_mask = virtio_net_guest_notifier_mask;
1658 vdc->guest_notifier_pending = virtio_net_guest_notifier_pending;
1659}
1660
1661static const TypeInfo virtio_net_info = {
1662 .name = TYPE_VIRTIO_NET,
1663 .parent = TYPE_VIRTIO_DEVICE,
1664 .instance_size = sizeof(VirtIONet),
1665 .instance_init = virtio_net_instance_init,
1666 .class_init = virtio_net_class_init,
1667};
1668
1669static void virtio_register_types(void)
1670{
1671 type_register_static(&virtio_net_info);
1672}
1673
1674type_init(virtio_register_types)