blob: 1187ab813bbfc216fe20eb9c6538cd0ec0976285 [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"
Wenchao Xia06150272014-06-18 08:43:48 +020025#include "qapi-event.h"
Rusty Russell1399c602014-06-24 19:42:54 +020026#include "hw/virtio/virtio-access.h"
aliguorifbe78f42008-12-17 19:13:11 +000027
Mark McLoughlin0ce0e8f2009-10-22 17:43:50 +010028#define VIRTIO_NET_VM_VERSION 11
aliguorib6503ed2009-02-05 22:36:28 +000029
Alex Williamson4ffb17f2009-06-05 14:47:23 -060030#define MAC_TABLE_ENTRIES 64
aliguorif21c0ed2009-02-05 22:36:32 +000031#define MAX_VLAN (1 << 12) /* Per 802.1Q definition */
aliguori9d6271b2009-02-05 22:36:04 +000032
Jesse Larrew14f9b662013-02-05 17:47:16 -060033/*
34 * Calculate the number of bytes up to and including the given 'field' of
35 * 'container'.
36 */
37#define endof(container, field) \
38 (offsetof(container, field) + sizeof(((container *)0)->field))
39
40typedef struct VirtIOFeature {
41 uint32_t flags;
42 size_t end;
43} VirtIOFeature;
44
45static VirtIOFeature feature_sizes[] = {
46 {.flags = 1 << VIRTIO_NET_F_MAC,
47 .end = endof(struct virtio_net_config, mac)},
48 {.flags = 1 << VIRTIO_NET_F_STATUS,
49 .end = endof(struct virtio_net_config, status)},
50 {.flags = 1 << VIRTIO_NET_F_MQ,
51 .end = endof(struct virtio_net_config, max_virtqueue_pairs)},
52 {}
53};
54
Jason Wangfed699f2013-01-30 19:12:39 +080055static VirtIONetQueue *virtio_net_get_subqueue(NetClientState *nc)
Jason Wang0c87e932013-01-30 19:12:38 +080056{
57 VirtIONet *n = qemu_get_nic_opaque(nc);
58
Jason Wangfed699f2013-01-30 19:12:39 +080059 return &n->vqs[nc->queue_index];
Jason Wang0c87e932013-01-30 19:12:38 +080060}
Jason Wangfed699f2013-01-30 19:12:39 +080061
62static int vq2q(int queue_index)
63{
64 return queue_index / 2;
65}
66
aliguorifbe78f42008-12-17 19:13:11 +000067/* TODO
68 * - we could suppress RX interrupt if we were so inclined.
69 */
70
aliguori0f03eca2009-02-05 22:36:08 +000071static void virtio_net_get_config(VirtIODevice *vdev, uint8_t *config)
aliguorifbe78f42008-12-17 19:13:11 +000072{
KONRAD Frederic17a0ca52013-04-11 16:30:01 +020073 VirtIONet *n = VIRTIO_NET(vdev);
aliguorifbe78f42008-12-17 19:13:11 +000074 struct virtio_net_config netcfg;
75
Rusty Russell1399c602014-06-24 19:42:54 +020076 virtio_stw_p(vdev, &netcfg.status, n->status);
77 virtio_stw_p(vdev, &netcfg.max_virtqueue_pairs, n->max_queues);
aliguori79674062009-02-05 22:36:12 +000078 memcpy(netcfg.mac, n->mac, ETH_ALEN);
Jesse Larrew14f9b662013-02-05 17:47:16 -060079 memcpy(config, &netcfg, n->config_size);
aliguorifbe78f42008-12-17 19:13:11 +000080}
81
aliguori0f03eca2009-02-05 22:36:08 +000082static void virtio_net_set_config(VirtIODevice *vdev, const uint8_t *config)
83{
KONRAD Frederic17a0ca52013-04-11 16:30:01 +020084 VirtIONet *n = VIRTIO_NET(vdev);
Jesse Larrew14f9b662013-02-05 17:47:16 -060085 struct virtio_net_config netcfg = {};
aliguori0f03eca2009-02-05 22:36:08 +000086
Jesse Larrew14f9b662013-02-05 17:47:16 -060087 memcpy(&netcfg, config, n->config_size);
aliguori0f03eca2009-02-05 22:36:08 +000088
Cornelia Huckef546f12014-12-11 14:25:06 +010089 if (!virtio_has_feature(vdev, VIRTIO_NET_F_CTRL_MAC_ADDR) &&
Amos Kongc1943a32013-01-22 23:44:45 +080090 memcmp(netcfg.mac, n->mac, ETH_ALEN)) {
aliguori79674062009-02-05 22:36:12 +000091 memcpy(n->mac, netcfg.mac, ETH_ALEN);
Jason Wangb356f762013-01-30 19:12:22 +080092 qemu_format_nic_info_str(qemu_get_queue(n->nic), n->mac);
aliguori0f03eca2009-02-05 22:36:08 +000093 }
94}
95
Michael S. Tsirkin783e7702010-11-22 19:52:30 +020096static bool virtio_net_started(VirtIONet *n, uint8_t status)
Michael S. Tsirkinafbaa7b2010-09-27 18:41:30 +020097{
KONRAD Frederic17a0ca52013-04-11 16:30:01 +020098 VirtIODevice *vdev = VIRTIO_DEVICE(n);
Michael S. Tsirkin783e7702010-11-22 19:52:30 +020099 return (status & VIRTIO_CONFIG_S_DRIVER_OK) &&
KONRAD Frederic17a0ca52013-04-11 16:30:01 +0200100 (n->status & VIRTIO_NET_S_LINK_UP) && vdev->vm_running;
Michael S. Tsirkin783e7702010-11-22 19:52:30 +0200101}
102
Jason Wangf57fcf72014-05-20 14:01:44 +0800103static void virtio_net_announce_timer(void *opaque)
104{
105 VirtIONet *n = opaque;
106 VirtIODevice *vdev = VIRTIO_DEVICE(n);
107
108 n->announce_counter--;
109 n->status |= VIRTIO_NET_S_ANNOUNCE;
110 virtio_notify_config(vdev);
111}
112
Michael S. Tsirkin783e7702010-11-22 19:52:30 +0200113static void virtio_net_vhost_status(VirtIONet *n, uint8_t status)
114{
KONRAD Frederic17a0ca52013-04-11 16:30:01 +0200115 VirtIODevice *vdev = VIRTIO_DEVICE(n);
Jason Wangb356f762013-01-30 19:12:22 +0800116 NetClientState *nc = qemu_get_queue(n->nic);
Jason Wangfed699f2013-01-30 19:12:39 +0800117 int queues = n->multiqueue ? n->max_queues : 1;
Jason Wangb356f762013-01-30 19:12:22 +0800118
Nikolay Nikolaeved8b4af2014-05-27 15:05:08 +0300119 if (!get_vhost_net(nc->peer)) {
Michael S. Tsirkinafbaa7b2010-09-27 18:41:30 +0200120 return;
121 }
Jason Wangfed699f2013-01-30 19:12:39 +0800122
Jason Wangd7108d92013-04-26 18:27:40 +0800123 if (!!n->vhost_started ==
124 (virtio_net_started(n, status) && !nc->peer->link_down)) {
Michael S. Tsirkinafbaa7b2010-09-27 18:41:30 +0200125 return;
126 }
127 if (!n->vhost_started) {
Michael S. Tsirkin086abc12014-09-04 11:39:17 +0300128 int r, i;
129
Nikolay Nikolaeved8b4af2014-05-27 15:05:08 +0300130 if (!vhost_net_query(get_vhost_net(nc->peer), vdev)) {
mst@redhat.com5430a282011-02-01 22:13:42 +0200131 return;
132 }
Michael S. Tsirkin086abc12014-09-04 11:39:17 +0300133
134 /* Any packets outstanding? Purge them to avoid touching rings
135 * when vhost is running.
136 */
137 for (i = 0; i < queues; i++) {
138 NetClientState *qnc = qemu_get_subqueue(n->nic, i);
139
140 /* Purge both directions: TX and RX. */
141 qemu_net_queue_purge(qnc->peer->incoming_queue, qnc);
142 qemu_net_queue_purge(qnc->incoming_queue, qnc->peer);
143 }
144
Michael S. Tsirkin1830b802012-12-25 17:38:59 +0200145 n->vhost_started = 1;
KONRAD Frederic17a0ca52013-04-11 16:30:01 +0200146 r = vhost_net_start(vdev, n->nic->ncs, queues);
Michael S. Tsirkinafbaa7b2010-09-27 18:41:30 +0200147 if (r < 0) {
Stefan Hajnoczie7b43f72010-11-15 20:44:37 +0000148 error_report("unable to start vhost net: %d: "
149 "falling back on userspace virtio", -r);
Michael S. Tsirkin1830b802012-12-25 17:38:59 +0200150 n->vhost_started = 0;
Michael S. Tsirkinafbaa7b2010-09-27 18:41:30 +0200151 }
152 } else {
KONRAD Frederic17a0ca52013-04-11 16:30:01 +0200153 vhost_net_stop(vdev, n->nic->ncs, queues);
Michael S. Tsirkinafbaa7b2010-09-27 18:41:30 +0200154 n->vhost_started = 0;
155 }
156}
157
Michael S. Tsirkin783e7702010-11-22 19:52:30 +0200158static void virtio_net_set_status(struct VirtIODevice *vdev, uint8_t status)
159{
KONRAD Frederic17a0ca52013-04-11 16:30:01 +0200160 VirtIONet *n = VIRTIO_NET(vdev);
Jason Wangfed699f2013-01-30 19:12:39 +0800161 VirtIONetQueue *q;
162 int i;
163 uint8_t queue_status;
Michael S. Tsirkin783e7702010-11-22 19:52:30 +0200164
165 virtio_net_vhost_status(n, status);
166
Jason Wangfed699f2013-01-30 19:12:39 +0800167 for (i = 0; i < n->max_queues; i++) {
168 q = &n->vqs[i];
Michael S. Tsirkin783e7702010-11-22 19:52:30 +0200169
Jason Wangfed699f2013-01-30 19:12:39 +0800170 if ((!n->multiqueue && i != 0) || i >= n->curr_queues) {
171 queue_status = 0;
Michael S. Tsirkin783e7702010-11-22 19:52:30 +0200172 } else {
Jason Wangfed699f2013-01-30 19:12:39 +0800173 queue_status = status;
Michael S. Tsirkin783e7702010-11-22 19:52:30 +0200174 }
Jason Wangfed699f2013-01-30 19:12:39 +0800175
176 if (!q->tx_waiting) {
177 continue;
178 }
179
180 if (virtio_net_started(n, queue_status) && !n->vhost_started) {
181 if (q->tx_timer) {
Alex Blighbc72ad62013-08-21 16:03:08 +0100182 timer_mod(q->tx_timer,
183 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + n->tx_timeout);
Jason Wangfed699f2013-01-30 19:12:39 +0800184 } else {
185 qemu_bh_schedule(q->tx_bh);
186 }
Michael S. Tsirkin783e7702010-11-22 19:52:30 +0200187 } else {
Jason Wangfed699f2013-01-30 19:12:39 +0800188 if (q->tx_timer) {
Alex Blighbc72ad62013-08-21 16:03:08 +0100189 timer_del(q->tx_timer);
Jason Wangfed699f2013-01-30 19:12:39 +0800190 } else {
191 qemu_bh_cancel(q->tx_bh);
192 }
Michael S. Tsirkin783e7702010-11-22 19:52:30 +0200193 }
194 }
195}
196
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +0100197static void virtio_net_set_link_status(NetClientState *nc)
aliguori554c97d2009-01-08 19:46:33 +0000198{
Jason Wangcc1f0f42013-01-30 19:12:23 +0800199 VirtIONet *n = qemu_get_nic_opaque(nc);
KONRAD Frederic17a0ca52013-04-11 16:30:01 +0200200 VirtIODevice *vdev = VIRTIO_DEVICE(n);
aliguori554c97d2009-01-08 19:46:33 +0000201 uint16_t old_status = n->status;
202
Mark McLoughlineb6b6c12009-11-25 18:49:11 +0000203 if (nc->link_down)
aliguori554c97d2009-01-08 19:46:33 +0000204 n->status &= ~VIRTIO_NET_S_LINK_UP;
205 else
206 n->status |= VIRTIO_NET_S_LINK_UP;
207
208 if (n->status != old_status)
KONRAD Frederic17a0ca52013-04-11 16:30:01 +0200209 virtio_notify_config(vdev);
Michael S. Tsirkinafbaa7b2010-09-27 18:41:30 +0200210
KONRAD Frederic17a0ca52013-04-11 16:30:01 +0200211 virtio_net_set_status(vdev, vdev->status);
aliguori554c97d2009-01-08 19:46:33 +0000212}
213
Amos Kongb1be4282013-06-14 15:45:52 +0800214static void rxfilter_notify(NetClientState *nc)
215{
Amos Kongb1be4282013-06-14 15:45:52 +0800216 VirtIONet *n = qemu_get_nic_opaque(nc);
217
218 if (nc->rxfilter_notify_enabled) {
Amos Kong96e35042013-11-18 23:32:17 +0800219 gchar *path = object_get_canonical_path(OBJECT(n->qdev));
Wenchao Xia06150272014-06-18 08:43:48 +0200220 qapi_event_send_nic_rx_filter_changed(!!n->netclient_name,
221 n->netclient_name, path, &error_abort);
Amos Kong96e35042013-11-18 23:32:17 +0800222 g_free(path);
Amos Kongb1be4282013-06-14 15:45:52 +0800223
224 /* disable event notification to avoid events flooding */
225 nc->rxfilter_notify_enabled = 0;
226 }
227}
228
229static char *mac_strdup_printf(const uint8_t *mac)
230{
231 return g_strdup_printf("%.2x:%.2x:%.2x:%.2x:%.2x:%.2x", mac[0],
232 mac[1], mac[2], mac[3], mac[4], mac[5]);
233}
234
Amos Kongf7bc8ef2014-03-26 08:19:43 +0800235static intList *get_vlan_table(VirtIONet *n)
236{
237 intList *list, *entry;
238 int i, j;
239
240 list = NULL;
241 for (i = 0; i < MAX_VLAN >> 5; i++) {
242 for (j = 0; n->vlans[i] && j <= 0x1f; j++) {
243 if (n->vlans[i] & (1U << j)) {
244 entry = g_malloc0(sizeof(*entry));
245 entry->value = (i << 5) + j;
246 entry->next = list;
247 list = entry;
248 }
249 }
250 }
251
252 return list;
253}
254
Amos Kongb1be4282013-06-14 15:45:52 +0800255static RxFilterInfo *virtio_net_query_rxfilter(NetClientState *nc)
256{
257 VirtIONet *n = qemu_get_nic_opaque(nc);
Amos Kongf7bc8ef2014-03-26 08:19:43 +0800258 VirtIODevice *vdev = VIRTIO_DEVICE(n);
Amos Kongb1be4282013-06-14 15:45:52 +0800259 RxFilterInfo *info;
260 strList *str_list, *entry;
Amos Kongf7bc8ef2014-03-26 08:19:43 +0800261 int i;
Amos Kongb1be4282013-06-14 15:45:52 +0800262
263 info = g_malloc0(sizeof(*info));
264 info->name = g_strdup(nc->name);
265 info->promiscuous = n->promisc;
266
267 if (n->nouni) {
268 info->unicast = RX_STATE_NONE;
269 } else if (n->alluni) {
270 info->unicast = RX_STATE_ALL;
271 } else {
272 info->unicast = RX_STATE_NORMAL;
273 }
274
275 if (n->nomulti) {
276 info->multicast = RX_STATE_NONE;
277 } else if (n->allmulti) {
278 info->multicast = RX_STATE_ALL;
279 } else {
280 info->multicast = RX_STATE_NORMAL;
281 }
282
283 info->broadcast_allowed = n->nobcast;
284 info->multicast_overflow = n->mac_table.multi_overflow;
285 info->unicast_overflow = n->mac_table.uni_overflow;
286
287 info->main_mac = mac_strdup_printf(n->mac);
288
289 str_list = NULL;
290 for (i = 0; i < n->mac_table.first_multi; i++) {
291 entry = g_malloc0(sizeof(*entry));
292 entry->value = mac_strdup_printf(n->mac_table.macs + i * ETH_ALEN);
293 entry->next = str_list;
294 str_list = entry;
295 }
296 info->unicast_table = str_list;
297
298 str_list = NULL;
299 for (i = n->mac_table.first_multi; i < n->mac_table.in_use; i++) {
300 entry = g_malloc0(sizeof(*entry));
301 entry->value = mac_strdup_printf(n->mac_table.macs + i * ETH_ALEN);
302 entry->next = str_list;
303 str_list = entry;
304 }
305 info->multicast_table = str_list;
Amos Kongf7bc8ef2014-03-26 08:19:43 +0800306 info->vlan_table = get_vlan_table(n);
Amos Kongb1be4282013-06-14 15:45:52 +0800307
Cornelia Huckef546f12014-12-11 14:25:06 +0100308 if (!virtio_has_feature(vdev, VIRTIO_NET_F_CTRL_VLAN)) {
Amos Kongf7bc8ef2014-03-26 08:19:43 +0800309 info->vlan = RX_STATE_ALL;
310 } else if (!info->vlan_table) {
311 info->vlan = RX_STATE_NONE;
312 } else {
313 info->vlan = RX_STATE_NORMAL;
Amos Kongb1be4282013-06-14 15:45:52 +0800314 }
Amos Kongb1be4282013-06-14 15:45:52 +0800315
316 /* enable event notification after query */
317 nc->rxfilter_notify_enabled = 1;
318
319 return info;
320}
321
aliguori002437c2009-02-05 22:36:20 +0000322static void virtio_net_reset(VirtIODevice *vdev)
323{
KONRAD Frederic17a0ca52013-04-11 16:30:01 +0200324 VirtIONet *n = VIRTIO_NET(vdev);
aliguori002437c2009-02-05 22:36:20 +0000325
326 /* Reset back to compatibility mode */
327 n->promisc = 1;
328 n->allmulti = 0;
Alex Williamson015cb162009-06-05 14:47:18 -0600329 n->alluni = 0;
330 n->nomulti = 0;
331 n->nouni = 0;
332 n->nobcast = 0;
Jason Wangfed699f2013-01-30 19:12:39 +0800333 /* multiqueue is disabled by default */
334 n->curr_queues = 1;
Jason Wangf57fcf72014-05-20 14:01:44 +0800335 timer_del(n->announce_timer);
336 n->announce_counter = 0;
337 n->status &= ~VIRTIO_NET_S_ANNOUNCE;
aliguorib6503ed2009-02-05 22:36:28 +0000338
aliguorif21c0ed2009-02-05 22:36:32 +0000339 /* Flush any MAC and VLAN filter table state */
aliguorib6503ed2009-02-05 22:36:28 +0000340 n->mac_table.in_use = 0;
Alex Williamson2d9aba32009-06-05 14:47:13 -0600341 n->mac_table.first_multi = 0;
Alex Williamson8fd2a2f2009-06-05 14:47:08 -0600342 n->mac_table.multi_overflow = 0;
343 n->mac_table.uni_overflow = 0;
aliguorib6503ed2009-02-05 22:36:28 +0000344 memset(n->mac_table.macs, 0, MAC_TABLE_ENTRIES * ETH_ALEN);
Michael S. Tsirkin41dc8a62013-01-16 11:37:40 +0200345 memcpy(&n->mac[0], &n->nic->conf->macaddr, sizeof(n->mac));
Michael S. Tsirkin702d66a2013-09-17 11:45:36 +0300346 qemu_format_nic_info_str(qemu_get_queue(n->nic), n->mac);
aliguorif21c0ed2009-02-05 22:36:32 +0000347 memset(n->vlans, 0, MAX_VLAN >> 3);
aliguori002437c2009-02-05 22:36:20 +0000348}
349
Michael S. Tsirkin6e371ab2012-09-24 17:04:21 +0200350static void peer_test_vnet_hdr(VirtIONet *n)
Mark McLoughlin3a330132009-10-22 17:43:45 +0100351{
Jason Wangb356f762013-01-30 19:12:22 +0800352 NetClientState *nc = qemu_get_queue(n->nic);
353 if (!nc->peer) {
Michael S. Tsirkin6e371ab2012-09-24 17:04:21 +0200354 return;
Jason Wangb356f762013-01-30 19:12:22 +0800355 }
Mark McLoughlin3a330132009-10-22 17:43:45 +0100356
Stefan Hajnoczid6085e32014-02-20 12:14:07 +0100357 n->has_vnet_hdr = qemu_has_vnet_hdr(nc->peer);
Michael S. Tsirkin6e371ab2012-09-24 17:04:21 +0200358}
Mark McLoughlin3a330132009-10-22 17:43:45 +0100359
Michael S. Tsirkin6e371ab2012-09-24 17:04:21 +0200360static int peer_has_vnet_hdr(VirtIONet *n)
361{
Mark McLoughlin3a330132009-10-22 17:43:45 +0100362 return n->has_vnet_hdr;
363}
364
Mark McLoughlin0ce0e8f2009-10-22 17:43:50 +0100365static int peer_has_ufo(VirtIONet *n)
366{
367 if (!peer_has_vnet_hdr(n))
368 return 0;
369
Stefan Hajnoczid6085e32014-02-20 12:14:07 +0100370 n->has_ufo = qemu_has_ufo(qemu_get_queue(n->nic)->peer);
Mark McLoughlin0ce0e8f2009-10-22 17:43:50 +0100371
372 return n->has_ufo;
373}
374
Michael S. Tsirkinff3a8062012-09-24 21:05:03 +0200375static void virtio_net_set_mrg_rx_bufs(VirtIONet *n, int mergeable_rx_bufs)
376{
Jason Wangfed699f2013-01-30 19:12:39 +0800377 int i;
378 NetClientState *nc;
379
Michael S. Tsirkinff3a8062012-09-24 21:05:03 +0200380 n->mergeable_rx_bufs = mergeable_rx_bufs;
381
382 n->guest_hdr_len = n->mergeable_rx_bufs ?
383 sizeof(struct virtio_net_hdr_mrg_rxbuf) : sizeof(struct virtio_net_hdr);
384
Jason Wangfed699f2013-01-30 19:12:39 +0800385 for (i = 0; i < n->max_queues; i++) {
386 nc = qemu_get_subqueue(n->nic, i);
387
388 if (peer_has_vnet_hdr(n) &&
Stefan Hajnoczid6085e32014-02-20 12:14:07 +0100389 qemu_has_vnet_hdr_len(nc->peer, n->guest_hdr_len)) {
390 qemu_set_vnet_hdr_len(nc->peer, n->guest_hdr_len);
Jason Wangfed699f2013-01-30 19:12:39 +0800391 n->host_hdr_len = n->guest_hdr_len;
392 }
Michael S. Tsirkinff3a8062012-09-24 21:05:03 +0200393 }
394}
395
Jason Wangfed699f2013-01-30 19:12:39 +0800396static int peer_attach(VirtIONet *n, int index)
397{
398 NetClientState *nc = qemu_get_subqueue(n->nic, index);
399
400 if (!nc->peer) {
401 return 0;
402 }
403
404 if (nc->peer->info->type != NET_CLIENT_OPTIONS_KIND_TAP) {
405 return 0;
406 }
407
408 return tap_enable(nc->peer);
409}
410
411static int peer_detach(VirtIONet *n, int index)
412{
413 NetClientState *nc = qemu_get_subqueue(n->nic, index);
414
415 if (!nc->peer) {
416 return 0;
417 }
418
419 if (nc->peer->info->type != NET_CLIENT_OPTIONS_KIND_TAP) {
420 return 0;
421 }
422
423 return tap_disable(nc->peer);
424}
425
426static void virtio_net_set_queues(VirtIONet *n)
427{
428 int i;
Joel Stanleyddfa83e2014-02-11 10:42:02 +1030429 int r;
Jason Wangfed699f2013-01-30 19:12:39 +0800430
431 for (i = 0; i < n->max_queues; i++) {
432 if (i < n->curr_queues) {
Joel Stanleyddfa83e2014-02-11 10:42:02 +1030433 r = peer_attach(n, i);
434 assert(!r);
Jason Wangfed699f2013-01-30 19:12:39 +0800435 } else {
Joel Stanleyddfa83e2014-02-11 10:42:02 +1030436 r = peer_detach(n, i);
437 assert(!r);
Jason Wangfed699f2013-01-30 19:12:39 +0800438 }
439 }
440}
441
Jason Wangec57db12013-04-25 15:24:23 +0800442static void virtio_net_set_multiqueue(VirtIONet *n, int multiqueue);
Jason Wangfed699f2013-01-30 19:12:39 +0800443
Michael S. Tsirkin81725392010-01-10 13:52:53 +0200444static uint32_t virtio_net_get_features(VirtIODevice *vdev, uint32_t features)
aliguorifbe78f42008-12-17 19:13:11 +0000445{
KONRAD Frederic17a0ca52013-04-11 16:30:01 +0200446 VirtIONet *n = VIRTIO_NET(vdev);
Jason Wangb356f762013-01-30 19:12:22 +0800447 NetClientState *nc = qemu_get_queue(n->nic);
aliguorifbe78f42008-12-17 19:13:11 +0000448
Cornelia Huck0cd09c32014-12-11 14:25:05 +0100449 virtio_add_feature(&features, VIRTIO_NET_F_MAC);
Michael S. Tsirkinc9f79a32010-01-12 20:50:17 +0200450
Michael S. Tsirkin6e371ab2012-09-24 17:04:21 +0200451 if (!peer_has_vnet_hdr(n)) {
Cornelia Huck0cd09c32014-12-11 14:25:05 +0100452 virtio_clear_feature(&features, VIRTIO_NET_F_CSUM);
453 virtio_clear_feature(&features, VIRTIO_NET_F_HOST_TSO4);
454 virtio_clear_feature(&features, VIRTIO_NET_F_HOST_TSO6);
455 virtio_clear_feature(&features, VIRTIO_NET_F_HOST_ECN);
Mark McLoughlin3a330132009-10-22 17:43:45 +0100456
Cornelia Huck0cd09c32014-12-11 14:25:05 +0100457 virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_CSUM);
458 virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_TSO4);
459 virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_TSO6);
460 virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_ECN);
Michael S. Tsirkin81725392010-01-10 13:52:53 +0200461 }
Mark McLoughlinf5436dd2009-10-22 17:43:47 +0100462
Michael S. Tsirkin81725392010-01-10 13:52:53 +0200463 if (!peer_has_vnet_hdr(n) || !peer_has_ufo(n)) {
Cornelia Huck0cd09c32014-12-11 14:25:05 +0100464 virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_UFO);
465 virtio_clear_feature(&features, VIRTIO_NET_F_HOST_UFO);
Mark McLoughlin3a330132009-10-22 17:43:45 +0100466 }
467
Nikolay Nikolaeved8b4af2014-05-27 15:05:08 +0300468 if (!get_vhost_net(nc->peer)) {
Michael S. Tsirkin9bc63042010-03-17 13:08:42 +0200469 return features;
470 }
Nikolay Nikolaeved8b4af2014-05-27 15:05:08 +0300471 return vhost_net_get_features(get_vhost_net(nc->peer), features);
aliguorifbe78f42008-12-17 19:13:11 +0000472}
473
aliguori8eca6b12009-04-05 17:40:08 +0000474static uint32_t virtio_net_bad_features(VirtIODevice *vdev)
475{
476 uint32_t features = 0;
477
478 /* Linux kernel 2.6.25. It understood MAC (as everyone must),
479 * but also these: */
Cornelia Huck0cd09c32014-12-11 14:25:05 +0100480 virtio_add_feature(&features, VIRTIO_NET_F_MAC);
481 virtio_add_feature(&features, VIRTIO_NET_F_CSUM);
482 virtio_add_feature(&features, VIRTIO_NET_F_HOST_TSO4);
483 virtio_add_feature(&features, VIRTIO_NET_F_HOST_TSO6);
484 virtio_add_feature(&features, VIRTIO_NET_F_HOST_ECN);
aliguori8eca6b12009-04-05 17:40:08 +0000485
Michael S. Tsirkin81725392010-01-10 13:52:53 +0200486 return features;
aliguori8eca6b12009-04-05 17:40:08 +0000487}
488
Dmitry Fleytman644c9852013-05-20 11:18:14 +0300489static void virtio_net_apply_guest_offloads(VirtIONet *n)
490{
Stefan Hajnocziad37bb32014-02-20 12:14:09 +0100491 qemu_set_offload(qemu_get_queue(n->nic)->peer,
Dmitry Fleytman644c9852013-05-20 11:18:14 +0300492 !!(n->curr_guest_offloads & (1ULL << VIRTIO_NET_F_GUEST_CSUM)),
493 !!(n->curr_guest_offloads & (1ULL << VIRTIO_NET_F_GUEST_TSO4)),
494 !!(n->curr_guest_offloads & (1ULL << VIRTIO_NET_F_GUEST_TSO6)),
495 !!(n->curr_guest_offloads & (1ULL << VIRTIO_NET_F_GUEST_ECN)),
496 !!(n->curr_guest_offloads & (1ULL << VIRTIO_NET_F_GUEST_UFO)));
497}
498
499static uint64_t virtio_net_guest_offloads_by_features(uint32_t features)
500{
501 static const uint64_t guest_offloads_mask =
502 (1ULL << VIRTIO_NET_F_GUEST_CSUM) |
503 (1ULL << VIRTIO_NET_F_GUEST_TSO4) |
504 (1ULL << VIRTIO_NET_F_GUEST_TSO6) |
505 (1ULL << VIRTIO_NET_F_GUEST_ECN) |
506 (1ULL << VIRTIO_NET_F_GUEST_UFO);
507
508 return guest_offloads_mask & features;
509}
510
511static inline uint64_t virtio_net_supported_guest_offloads(VirtIONet *n)
512{
513 VirtIODevice *vdev = VIRTIO_DEVICE(n);
514 return virtio_net_guest_offloads_by_features(vdev->guest_features);
515}
516
aliguorifbe78f42008-12-17 19:13:11 +0000517static void virtio_net_set_features(VirtIODevice *vdev, uint32_t features)
518{
KONRAD Frederic17a0ca52013-04-11 16:30:01 +0200519 VirtIONet *n = VIRTIO_NET(vdev);
Jason Wangfed699f2013-01-30 19:12:39 +0800520 int i;
521
Cornelia Huckef546f12014-12-11 14:25:06 +0100522 virtio_net_set_multiqueue(n,
523 __virtio_has_feature(features, VIRTIO_NET_F_MQ));
aliguorifbe78f42008-12-17 19:13:11 +0000524
Cornelia Huckef546f12014-12-11 14:25:06 +0100525 virtio_net_set_mrg_rx_bufs(n,
526 __virtio_has_feature(features,
527 VIRTIO_NET_F_MRG_RXBUF));
Mark McLoughlinf5436dd2009-10-22 17:43:47 +0100528
529 if (n->has_vnet_hdr) {
Dmitry Fleytman644c9852013-05-20 11:18:14 +0300530 n->curr_guest_offloads =
531 virtio_net_guest_offloads_by_features(features);
532 virtio_net_apply_guest_offloads(n);
Mark McLoughlinf5436dd2009-10-22 17:43:47 +0100533 }
Jason Wangfed699f2013-01-30 19:12:39 +0800534
535 for (i = 0; i < n->max_queues; i++) {
536 NetClientState *nc = qemu_get_subqueue(n->nic, i);
537
Nikolay Nikolaeved8b4af2014-05-27 15:05:08 +0300538 if (!get_vhost_net(nc->peer)) {
Jason Wangfed699f2013-01-30 19:12:39 +0800539 continue;
540 }
Nikolay Nikolaeved8b4af2014-05-27 15:05:08 +0300541 vhost_net_ack_features(get_vhost_net(nc->peer), features);
David L Stevensdc14a392010-03-31 21:20:31 +0300542 }
Stefan Fritsch0b1eaa82014-03-26 18:29:52 +0800543
Cornelia Huckef546f12014-12-11 14:25:06 +0100544 if (__virtio_has_feature(features, VIRTIO_NET_F_CTRL_VLAN)) {
Stefan Fritsch0b1eaa82014-03-26 18:29:52 +0800545 memset(n->vlans, 0, MAX_VLAN >> 3);
546 } else {
547 memset(n->vlans, 0xff, MAX_VLAN >> 3);
548 }
aliguorifbe78f42008-12-17 19:13:11 +0000549}
550
aliguori002437c2009-02-05 22:36:20 +0000551static int virtio_net_handle_rx_mode(VirtIONet *n, uint8_t cmd,
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800552 struct iovec *iov, unsigned int iov_cnt)
aliguori002437c2009-02-05 22:36:20 +0000553{
554 uint8_t on;
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800555 size_t s;
Amos Kongb1be4282013-06-14 15:45:52 +0800556 NetClientState *nc = qemu_get_queue(n->nic);
aliguori002437c2009-02-05 22:36:20 +0000557
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800558 s = iov_to_buf(iov, iov_cnt, 0, &on, sizeof(on));
559 if (s != sizeof(on)) {
560 return VIRTIO_NET_ERR;
aliguori002437c2009-02-05 22:36:20 +0000561 }
562
Amos Kongdd234542013-01-22 23:44:46 +0800563 if (cmd == VIRTIO_NET_CTRL_RX_PROMISC) {
aliguori002437c2009-02-05 22:36:20 +0000564 n->promisc = on;
Amos Kongdd234542013-01-22 23:44:46 +0800565 } else if (cmd == VIRTIO_NET_CTRL_RX_ALLMULTI) {
aliguori002437c2009-02-05 22:36:20 +0000566 n->allmulti = on;
Amos Kongdd234542013-01-22 23:44:46 +0800567 } else if (cmd == VIRTIO_NET_CTRL_RX_ALLUNI) {
Alex Williamson015cb162009-06-05 14:47:18 -0600568 n->alluni = on;
Amos Kongdd234542013-01-22 23:44:46 +0800569 } else if (cmd == VIRTIO_NET_CTRL_RX_NOMULTI) {
Alex Williamson015cb162009-06-05 14:47:18 -0600570 n->nomulti = on;
Amos Kongdd234542013-01-22 23:44:46 +0800571 } else if (cmd == VIRTIO_NET_CTRL_RX_NOUNI) {
Alex Williamson015cb162009-06-05 14:47:18 -0600572 n->nouni = on;
Amos Kongdd234542013-01-22 23:44:46 +0800573 } else if (cmd == VIRTIO_NET_CTRL_RX_NOBCAST) {
Alex Williamson015cb162009-06-05 14:47:18 -0600574 n->nobcast = on;
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800575 } else {
aliguori002437c2009-02-05 22:36:20 +0000576 return VIRTIO_NET_ERR;
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800577 }
aliguori002437c2009-02-05 22:36:20 +0000578
Amos Kongb1be4282013-06-14 15:45:52 +0800579 rxfilter_notify(nc);
580
aliguori002437c2009-02-05 22:36:20 +0000581 return VIRTIO_NET_OK;
582}
583
Dmitry Fleytman644c9852013-05-20 11:18:14 +0300584static int virtio_net_handle_offloads(VirtIONet *n, uint8_t cmd,
585 struct iovec *iov, unsigned int iov_cnt)
586{
587 VirtIODevice *vdev = VIRTIO_DEVICE(n);
588 uint64_t offloads;
589 size_t s;
590
Cornelia Huckef546f12014-12-11 14:25:06 +0100591 if (!virtio_has_feature(vdev, VIRTIO_NET_F_CTRL_GUEST_OFFLOADS)) {
Dmitry Fleytman644c9852013-05-20 11:18:14 +0300592 return VIRTIO_NET_ERR;
593 }
594
595 s = iov_to_buf(iov, iov_cnt, 0, &offloads, sizeof(offloads));
596 if (s != sizeof(offloads)) {
597 return VIRTIO_NET_ERR;
598 }
599
600 if (cmd == VIRTIO_NET_CTRL_GUEST_OFFLOADS_SET) {
601 uint64_t supported_offloads;
602
603 if (!n->has_vnet_hdr) {
604 return VIRTIO_NET_ERR;
605 }
606
607 supported_offloads = virtio_net_supported_guest_offloads(n);
608 if (offloads & ~supported_offloads) {
609 return VIRTIO_NET_ERR;
610 }
611
612 n->curr_guest_offloads = offloads;
613 virtio_net_apply_guest_offloads(n);
614
615 return VIRTIO_NET_OK;
616 } else {
617 return VIRTIO_NET_ERR;
618 }
619}
620
aliguorib6503ed2009-02-05 22:36:28 +0000621static int virtio_net_handle_mac(VirtIONet *n, uint8_t cmd,
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800622 struct iovec *iov, unsigned int iov_cnt)
aliguorib6503ed2009-02-05 22:36:28 +0000623{
Rusty Russell1399c602014-06-24 19:42:54 +0200624 VirtIODevice *vdev = VIRTIO_DEVICE(n);
aliguorib6503ed2009-02-05 22:36:28 +0000625 struct virtio_net_ctrl_mac mac_data;
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800626 size_t s;
Amos Kongb1be4282013-06-14 15:45:52 +0800627 NetClientState *nc = qemu_get_queue(n->nic);
aliguorib6503ed2009-02-05 22:36:28 +0000628
Amos Kongc1943a32013-01-22 23:44:45 +0800629 if (cmd == VIRTIO_NET_CTRL_MAC_ADDR_SET) {
630 if (iov_size(iov, iov_cnt) != sizeof(n->mac)) {
631 return VIRTIO_NET_ERR;
632 }
633 s = iov_to_buf(iov, iov_cnt, 0, &n->mac, sizeof(n->mac));
634 assert(s == sizeof(n->mac));
Jason Wangb356f762013-01-30 19:12:22 +0800635 qemu_format_nic_info_str(qemu_get_queue(n->nic), n->mac);
Amos Kongb1be4282013-06-14 15:45:52 +0800636 rxfilter_notify(nc);
637
Amos Kongc1943a32013-01-22 23:44:45 +0800638 return VIRTIO_NET_OK;
639 }
640
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800641 if (cmd != VIRTIO_NET_CTRL_MAC_TABLE_SET) {
aliguorib6503ed2009-02-05 22:36:28 +0000642 return VIRTIO_NET_ERR;
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800643 }
aliguorib6503ed2009-02-05 22:36:28 +0000644
Amos Kongcae2e552013-11-11 11:48:36 +0800645 int in_use = 0;
646 int first_multi = 0;
647 uint8_t uni_overflow = 0;
648 uint8_t multi_overflow = 0;
649 uint8_t *macs = g_malloc0(MAC_TABLE_ENTRIES * ETH_ALEN);
aliguorib6503ed2009-02-05 22:36:28 +0000650
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800651 s = iov_to_buf(iov, iov_cnt, 0, &mac_data.entries,
652 sizeof(mac_data.entries));
Rusty Russell1399c602014-06-24 19:42:54 +0200653 mac_data.entries = virtio_ldl_p(vdev, &mac_data.entries);
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800654 if (s != sizeof(mac_data.entries)) {
Amos Kongb1be4282013-06-14 15:45:52 +0800655 goto error;
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800656 }
657 iov_discard_front(&iov, &iov_cnt, s);
658
659 if (mac_data.entries * ETH_ALEN > iov_size(iov, iov_cnt)) {
Amos Kongb1be4282013-06-14 15:45:52 +0800660 goto error;
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800661 }
aliguorib6503ed2009-02-05 22:36:28 +0000662
663 if (mac_data.entries <= MAC_TABLE_ENTRIES) {
Amos Kongcae2e552013-11-11 11:48:36 +0800664 s = iov_to_buf(iov, iov_cnt, 0, macs,
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800665 mac_data.entries * ETH_ALEN);
666 if (s != mac_data.entries * ETH_ALEN) {
Amos Kongb1be4282013-06-14 15:45:52 +0800667 goto error;
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800668 }
Amos Kongcae2e552013-11-11 11:48:36 +0800669 in_use += mac_data.entries;
aliguorib6503ed2009-02-05 22:36:28 +0000670 } else {
Amos Kongcae2e552013-11-11 11:48:36 +0800671 uni_overflow = 1;
aliguorib6503ed2009-02-05 22:36:28 +0000672 }
673
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800674 iov_discard_front(&iov, &iov_cnt, mac_data.entries * ETH_ALEN);
675
Amos Kongcae2e552013-11-11 11:48:36 +0800676 first_multi = in_use;
Alex Williamson2d9aba32009-06-05 14:47:13 -0600677
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800678 s = iov_to_buf(iov, iov_cnt, 0, &mac_data.entries,
679 sizeof(mac_data.entries));
Rusty Russell1399c602014-06-24 19:42:54 +0200680 mac_data.entries = virtio_ldl_p(vdev, &mac_data.entries);
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800681 if (s != sizeof(mac_data.entries)) {
Amos Kongb1be4282013-06-14 15:45:52 +0800682 goto error;
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800683 }
aliguorib6503ed2009-02-05 22:36:28 +0000684
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800685 iov_discard_front(&iov, &iov_cnt, s);
686
687 if (mac_data.entries * ETH_ALEN != iov_size(iov, iov_cnt)) {
Amos Kongb1be4282013-06-14 15:45:52 +0800688 goto error;
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800689 }
690
Michael S. Tsirkinedc24382014-04-11 15:18:08 +0300691 if (mac_data.entries <= MAC_TABLE_ENTRIES - in_use) {
Amos Kongcae2e552013-11-11 11:48:36 +0800692 s = iov_to_buf(iov, iov_cnt, 0, &macs[in_use * ETH_ALEN],
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800693 mac_data.entries * ETH_ALEN);
694 if (s != mac_data.entries * ETH_ALEN) {
Amos Kongb1be4282013-06-14 15:45:52 +0800695 goto error;
Alex Williamson8fd2a2f2009-06-05 14:47:08 -0600696 }
Amos Kongcae2e552013-11-11 11:48:36 +0800697 in_use += mac_data.entries;
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800698 } else {
Amos Kongcae2e552013-11-11 11:48:36 +0800699 multi_overflow = 1;
aliguorib6503ed2009-02-05 22:36:28 +0000700 }
701
Amos Kongcae2e552013-11-11 11:48:36 +0800702 n->mac_table.in_use = in_use;
703 n->mac_table.first_multi = first_multi;
704 n->mac_table.uni_overflow = uni_overflow;
705 n->mac_table.multi_overflow = multi_overflow;
706 memcpy(n->mac_table.macs, macs, MAC_TABLE_ENTRIES * ETH_ALEN);
707 g_free(macs);
Amos Kongb1be4282013-06-14 15:45:52 +0800708 rxfilter_notify(nc);
709
aliguorib6503ed2009-02-05 22:36:28 +0000710 return VIRTIO_NET_OK;
Amos Kongb1be4282013-06-14 15:45:52 +0800711
712error:
Amos Kongcae2e552013-11-11 11:48:36 +0800713 g_free(macs);
Amos Kongb1be4282013-06-14 15:45:52 +0800714 return VIRTIO_NET_ERR;
aliguorib6503ed2009-02-05 22:36:28 +0000715}
716
aliguorif21c0ed2009-02-05 22:36:32 +0000717static int virtio_net_handle_vlan_table(VirtIONet *n, uint8_t cmd,
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800718 struct iovec *iov, unsigned int iov_cnt)
aliguorif21c0ed2009-02-05 22:36:32 +0000719{
Rusty Russell1399c602014-06-24 19:42:54 +0200720 VirtIODevice *vdev = VIRTIO_DEVICE(n);
aliguorif21c0ed2009-02-05 22:36:32 +0000721 uint16_t vid;
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800722 size_t s;
Amos Kongb1be4282013-06-14 15:45:52 +0800723 NetClientState *nc = qemu_get_queue(n->nic);
aliguorif21c0ed2009-02-05 22:36:32 +0000724
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800725 s = iov_to_buf(iov, iov_cnt, 0, &vid, sizeof(vid));
Rusty Russell1399c602014-06-24 19:42:54 +0200726 vid = virtio_lduw_p(vdev, &vid);
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800727 if (s != sizeof(vid)) {
aliguorif21c0ed2009-02-05 22:36:32 +0000728 return VIRTIO_NET_ERR;
729 }
730
aliguorif21c0ed2009-02-05 22:36:32 +0000731 if (vid >= MAX_VLAN)
732 return VIRTIO_NET_ERR;
733
734 if (cmd == VIRTIO_NET_CTRL_VLAN_ADD)
735 n->vlans[vid >> 5] |= (1U << (vid & 0x1f));
736 else if (cmd == VIRTIO_NET_CTRL_VLAN_DEL)
737 n->vlans[vid >> 5] &= ~(1U << (vid & 0x1f));
738 else
739 return VIRTIO_NET_ERR;
740
Amos Kongb1be4282013-06-14 15:45:52 +0800741 rxfilter_notify(nc);
742
aliguorif21c0ed2009-02-05 22:36:32 +0000743 return VIRTIO_NET_OK;
744}
745
Jason Wangf57fcf72014-05-20 14:01:44 +0800746static int virtio_net_handle_announce(VirtIONet *n, uint8_t cmd,
747 struct iovec *iov, unsigned int iov_cnt)
748{
749 if (cmd == VIRTIO_NET_CTRL_ANNOUNCE_ACK &&
750 n->status & VIRTIO_NET_S_ANNOUNCE) {
751 n->status &= ~VIRTIO_NET_S_ANNOUNCE;
752 if (n->announce_counter) {
753 timer_mod(n->announce_timer,
754 qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) +
755 self_announce_delay(n->announce_counter));
756 }
757 return VIRTIO_NET_OK;
758 } else {
759 return VIRTIO_NET_ERR;
760 }
761}
762
Jason Wangfed699f2013-01-30 19:12:39 +0800763static int virtio_net_handle_mq(VirtIONet *n, uint8_t cmd,
Jason Wangf8f7c532013-03-06 13:50:27 +0800764 struct iovec *iov, unsigned int iov_cnt)
Jason Wangfed699f2013-01-30 19:12:39 +0800765{
KONRAD Frederic17a0ca52013-04-11 16:30:01 +0200766 VirtIODevice *vdev = VIRTIO_DEVICE(n);
Jason Wangf8f7c532013-03-06 13:50:27 +0800767 struct virtio_net_ctrl_mq mq;
768 size_t s;
769 uint16_t queues;
Jason Wangfed699f2013-01-30 19:12:39 +0800770
Jason Wangf8f7c532013-03-06 13:50:27 +0800771 s = iov_to_buf(iov, iov_cnt, 0, &mq, sizeof(mq));
772 if (s != sizeof(mq)) {
Jason Wangfed699f2013-01-30 19:12:39 +0800773 return VIRTIO_NET_ERR;
774 }
775
776 if (cmd != VIRTIO_NET_CTRL_MQ_VQ_PAIRS_SET) {
777 return VIRTIO_NET_ERR;
778 }
779
Rusty Russell1399c602014-06-24 19:42:54 +0200780 queues = virtio_lduw_p(vdev, &mq.virtqueue_pairs);
Jason Wangfed699f2013-01-30 19:12:39 +0800781
Jason Wangf8f7c532013-03-06 13:50:27 +0800782 if (queues < VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MIN ||
783 queues > VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MAX ||
784 queues > n->max_queues ||
Jason Wangfed699f2013-01-30 19:12:39 +0800785 !n->multiqueue) {
786 return VIRTIO_NET_ERR;
787 }
788
Jason Wangf8f7c532013-03-06 13:50:27 +0800789 n->curr_queues = queues;
Jason Wangfed699f2013-01-30 19:12:39 +0800790 /* stop the backend before changing the number of queues to avoid handling a
791 * disabled queue */
KONRAD Frederic17a0ca52013-04-11 16:30:01 +0200792 virtio_net_set_status(vdev, vdev->status);
Jason Wangfed699f2013-01-30 19:12:39 +0800793 virtio_net_set_queues(n);
794
795 return VIRTIO_NET_OK;
796}
aliguori3d11d362009-02-05 22:36:16 +0000797static void virtio_net_handle_ctrl(VirtIODevice *vdev, VirtQueue *vq)
798{
KONRAD Frederic17a0ca52013-04-11 16:30:01 +0200799 VirtIONet *n = VIRTIO_NET(vdev);
aliguori3d11d362009-02-05 22:36:16 +0000800 struct virtio_net_ctrl_hdr ctrl;
801 virtio_net_ctrl_ack status = VIRTIO_NET_ERR;
802 VirtQueueElement elem;
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800803 size_t s;
Jason Wang771b6ed2014-11-27 18:04:03 +0800804 struct iovec *iov, *iov2;
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800805 unsigned int iov_cnt;
aliguori3d11d362009-02-05 22:36:16 +0000806
807 while (virtqueue_pop(vq, &elem)) {
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800808 if (iov_size(elem.in_sg, elem.in_num) < sizeof(status) ||
809 iov_size(elem.out_sg, elem.out_num) < sizeof(ctrl)) {
Stefan Hajnoczie7b43f72010-11-15 20:44:37 +0000810 error_report("virtio-net ctrl missing headers");
aliguori3d11d362009-02-05 22:36:16 +0000811 exit(1);
812 }
813
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800814 iov_cnt = elem.out_num;
Jason Wang771b6ed2014-11-27 18:04:03 +0800815 iov2 = iov = g_memdup(elem.out_sg, sizeof(struct iovec) * elem.out_num);
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800816 s = iov_to_buf(iov, iov_cnt, 0, &ctrl, sizeof(ctrl));
817 iov_discard_front(&iov, &iov_cnt, sizeof(ctrl));
818 if (s != sizeof(ctrl)) {
819 status = VIRTIO_NET_ERR;
Amos Kongdd234542013-01-22 23:44:46 +0800820 } else if (ctrl.class == VIRTIO_NET_CTRL_RX) {
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800821 status = virtio_net_handle_rx_mode(n, ctrl.cmd, iov, iov_cnt);
822 } else if (ctrl.class == VIRTIO_NET_CTRL_MAC) {
823 status = virtio_net_handle_mac(n, ctrl.cmd, iov, iov_cnt);
824 } else if (ctrl.class == VIRTIO_NET_CTRL_VLAN) {
825 status = virtio_net_handle_vlan_table(n, ctrl.cmd, iov, iov_cnt);
Jason Wangf57fcf72014-05-20 14:01:44 +0800826 } else if (ctrl.class == VIRTIO_NET_CTRL_ANNOUNCE) {
827 status = virtio_net_handle_announce(n, ctrl.cmd, iov, iov_cnt);
Jason Wangfed699f2013-01-30 19:12:39 +0800828 } else if (ctrl.class == VIRTIO_NET_CTRL_MQ) {
Jason Wangf8f7c532013-03-06 13:50:27 +0800829 status = virtio_net_handle_mq(n, ctrl.cmd, iov, iov_cnt);
Dmitry Fleytman644c9852013-05-20 11:18:14 +0300830 } else if (ctrl.class == VIRTIO_NET_CTRL_GUEST_OFFLOADS) {
831 status = virtio_net_handle_offloads(n, ctrl.cmd, iov, iov_cnt);
aliguori3d11d362009-02-05 22:36:16 +0000832 }
833
Michael S. Tsirkin921ac5d2013-01-22 23:44:44 +0800834 s = iov_from_buf(elem.in_sg, elem.in_num, 0, &status, sizeof(status));
835 assert(s == sizeof(status));
aliguori3d11d362009-02-05 22:36:16 +0000836
837 virtqueue_push(vq, &elem, sizeof(status));
838 virtio_notify(vdev, vq);
Jason Wang771b6ed2014-11-27 18:04:03 +0800839 g_free(iov2);
aliguori3d11d362009-02-05 22:36:16 +0000840 }
841}
842
aliguorifbe78f42008-12-17 19:13:11 +0000843/* RX */
844
845static void virtio_net_handle_rx(VirtIODevice *vdev, VirtQueue *vq)
846{
KONRAD Frederic17a0ca52013-04-11 16:30:01 +0200847 VirtIONet *n = VIRTIO_NET(vdev);
Jason Wangfed699f2013-01-30 19:12:39 +0800848 int queue_index = vq2q(virtio_get_queue_index(vq));
Mark McLoughlin8aeff622009-04-29 13:40:02 +0100849
Jason Wangfed699f2013-01-30 19:12:39 +0800850 qemu_flush_queued_packets(qemu_get_subqueue(n->nic, queue_index));
aliguorifbe78f42008-12-17 19:13:11 +0000851}
852
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +0100853static int virtio_net_can_receive(NetClientState *nc)
aliguorifbe78f42008-12-17 19:13:11 +0000854{
Jason Wangcc1f0f42013-01-30 19:12:23 +0800855 VirtIONet *n = qemu_get_nic_opaque(nc);
KONRAD Frederic17a0ca52013-04-11 16:30:01 +0200856 VirtIODevice *vdev = VIRTIO_DEVICE(n);
Jason Wangfed699f2013-01-30 19:12:39 +0800857 VirtIONetQueue *q = virtio_net_get_subqueue(nc);
Jason Wang0c87e932013-01-30 19:12:38 +0800858
KONRAD Frederic17a0ca52013-04-11 16:30:01 +0200859 if (!vdev->vm_running) {
Michael S. Tsirkin95477322010-11-22 19:52:19 +0200860 return 0;
861 }
Mark McLoughlincdd5cc12009-10-27 18:16:38 +0000862
Jason Wangfed699f2013-01-30 19:12:39 +0800863 if (nc->queue_index >= n->curr_queues) {
864 return 0;
865 }
866
Jason Wang0c87e932013-01-30 19:12:38 +0800867 if (!virtio_queue_ready(q->rx_vq) ||
KONRAD Frederic17a0ca52013-04-11 16:30:01 +0200868 !(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK)) {
aliguorifbe78f42008-12-17 19:13:11 +0000869 return 0;
Jason Wang0c87e932013-01-30 19:12:38 +0800870 }
aliguorifbe78f42008-12-17 19:13:11 +0000871
Mark McLoughlincdd5cc12009-10-27 18:16:38 +0000872 return 1;
873}
874
Jason Wang0c87e932013-01-30 19:12:38 +0800875static int virtio_net_has_buffers(VirtIONetQueue *q, int bufsize)
Mark McLoughlincdd5cc12009-10-27 18:16:38 +0000876{
Jason Wang0c87e932013-01-30 19:12:38 +0800877 VirtIONet *n = q->n;
878 if (virtio_queue_empty(q->rx_vq) ||
aliguorifbe78f42008-12-17 19:13:11 +0000879 (n->mergeable_rx_bufs &&
Jason Wang0c87e932013-01-30 19:12:38 +0800880 !virtqueue_avail_bytes(q->rx_vq, bufsize, 0))) {
881 virtio_queue_set_notification(q->rx_vq, 1);
Tom Lendacky06b12972010-02-08 10:10:01 -0600882
883 /* To avoid a race condition where the guest has made some buffers
884 * available after the above check but before notification was
885 * enabled, check for available buffers again.
886 */
Jason Wang0c87e932013-01-30 19:12:38 +0800887 if (virtio_queue_empty(q->rx_vq) ||
Tom Lendacky06b12972010-02-08 10:10:01 -0600888 (n->mergeable_rx_bufs &&
Jason Wang0c87e932013-01-30 19:12:38 +0800889 !virtqueue_avail_bytes(q->rx_vq, bufsize, 0))) {
Tom Lendacky06b12972010-02-08 10:10:01 -0600890 return 0;
Jason Wang0c87e932013-01-30 19:12:38 +0800891 }
aliguorifbe78f42008-12-17 19:13:11 +0000892 }
893
Jason Wang0c87e932013-01-30 19:12:38 +0800894 virtio_queue_set_notification(q->rx_vq, 0);
aliguorifbe78f42008-12-17 19:13:11 +0000895 return 1;
896}
897
Rusty Russell1399c602014-06-24 19:42:54 +0200898static void virtio_net_hdr_swap(VirtIODevice *vdev, struct virtio_net_hdr *hdr)
Cédric Le Goater032a74a2014-06-24 19:11:32 +0200899{
Rusty Russell1399c602014-06-24 19:42:54 +0200900 virtio_tswap16s(vdev, &hdr->hdr_len);
901 virtio_tswap16s(vdev, &hdr->gso_size);
902 virtio_tswap16s(vdev, &hdr->csum_start);
903 virtio_tswap16s(vdev, &hdr->csum_offset);
Cédric Le Goater032a74a2014-06-24 19:11:32 +0200904}
905
Anthony Liguori1d41b0c2009-10-22 17:43:48 +0100906/* dhclient uses AF_PACKET but doesn't pass auxdata to the kernel so
907 * it never finds out that the packets don't have valid checksums. This
908 * causes dhclient to get upset. Fedora's carried a patch for ages to
909 * fix this with Xen but it hasn't appeared in an upstream release of
910 * dhclient yet.
911 *
912 * To avoid breaking existing guests, we catch udp packets and add
913 * checksums. This is terrible but it's better than hacking the guest
914 * kernels.
915 *
916 * N.B. if we introduce a zero-copy API, this operation is no longer free so
917 * we should provide a mechanism to disable it to avoid polluting the host
918 * cache.
919 */
920static void work_around_broken_dhclient(struct virtio_net_hdr *hdr,
Michael S. Tsirkin22cc84d2012-09-24 13:14:16 +0200921 uint8_t *buf, size_t size)
Anthony Liguori1d41b0c2009-10-22 17:43:48 +0100922{
923 if ((hdr->flags & VIRTIO_NET_HDR_F_NEEDS_CSUM) && /* missing csum */
924 (size > 27 && size < 1500) && /* normal sized MTU */
925 (buf[12] == 0x08 && buf[13] == 0x00) && /* ethertype == IPv4 */
926 (buf[23] == 17) && /* ip.protocol == UDP */
927 (buf[34] == 0 && buf[35] == 67)) { /* udp.srcport == bootps */
Michael S. Tsirkin22cc84d2012-09-24 13:14:16 +0200928 net_checksum_calculate(buf, size);
Anthony Liguori1d41b0c2009-10-22 17:43:48 +0100929 hdr->flags &= ~VIRTIO_NET_HDR_F_NEEDS_CSUM;
930 }
931}
932
Michael S. Tsirkin280598b2012-09-24 13:24:17 +0200933static void receive_header(VirtIONet *n, const struct iovec *iov, int iov_cnt,
934 const void *buf, size_t size)
aliguorifbe78f42008-12-17 19:13:11 +0000935{
Mark McLoughlin3a330132009-10-22 17:43:45 +0100936 if (n->has_vnet_hdr) {
Michael S. Tsirkin22cc84d2012-09-24 13:14:16 +0200937 /* FIXME this cast is evil */
938 void *wbuf = (void *)buf;
Michael S. Tsirkin280598b2012-09-24 13:24:17 +0200939 work_around_broken_dhclient(wbuf, wbuf + n->host_hdr_len,
940 size - n->host_hdr_len);
Rusty Russell1399c602014-06-24 19:42:54 +0200941 virtio_net_hdr_swap(VIRTIO_DEVICE(n), wbuf);
Michael S. Tsirkin280598b2012-09-24 13:24:17 +0200942 iov_from_buf(iov, iov_cnt, 0, buf, sizeof(struct virtio_net_hdr));
Michael S. Tsirkin22cc84d2012-09-24 13:14:16 +0200943 } else {
944 struct virtio_net_hdr hdr = {
945 .flags = 0,
946 .gso_type = VIRTIO_NET_HDR_GSO_NONE
947 };
948 iov_from_buf(iov, iov_cnt, 0, &hdr, sizeof hdr);
Mark McLoughlin3a330132009-10-22 17:43:45 +0100949 }
aliguorifbe78f42008-12-17 19:13:11 +0000950}
951
aliguori3831ab22009-02-05 22:36:24 +0000952static int receive_filter(VirtIONet *n, const uint8_t *buf, int size)
953{
954 static const uint8_t bcast[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
aliguorif21c0ed2009-02-05 22:36:32 +0000955 static const uint8_t vlan[] = {0x81, 0x00};
aliguori3831ab22009-02-05 22:36:24 +0000956 uint8_t *ptr = (uint8_t *)buf;
aliguorib6503ed2009-02-05 22:36:28 +0000957 int i;
aliguori3831ab22009-02-05 22:36:24 +0000958
959 if (n->promisc)
960 return 1;
961
Michael S. Tsirkine043ebc2012-09-24 16:27:27 +0200962 ptr += n->host_hdr_len;
Mark McLoughlin3a330132009-10-22 17:43:45 +0100963
aliguorif21c0ed2009-02-05 22:36:32 +0000964 if (!memcmp(&ptr[12], vlan, sizeof(vlan))) {
965 int vid = be16_to_cpup((uint16_t *)(ptr + 14)) & 0xfff;
966 if (!(n->vlans[vid >> 5] & (1U << (vid & 0x1f))))
967 return 0;
968 }
969
Alex Williamsonbbe2f392009-06-05 14:47:02 -0600970 if (ptr[0] & 1) { // multicast
971 if (!memcmp(ptr, bcast, sizeof(bcast))) {
Alex Williamson015cb162009-06-05 14:47:18 -0600972 return !n->nobcast;
973 } else if (n->nomulti) {
974 return 0;
Alex Williamson8fd2a2f2009-06-05 14:47:08 -0600975 } else if (n->allmulti || n->mac_table.multi_overflow) {
Alex Williamsonbbe2f392009-06-05 14:47:02 -0600976 return 1;
977 }
Alex Williamson2d9aba32009-06-05 14:47:13 -0600978
979 for (i = n->mac_table.first_multi; i < n->mac_table.in_use; i++) {
980 if (!memcmp(ptr, &n->mac_table.macs[i * ETH_ALEN], ETH_ALEN)) {
981 return 1;
982 }
983 }
Alex Williamsonbbe2f392009-06-05 14:47:02 -0600984 } else { // unicast
Alex Williamson015cb162009-06-05 14:47:18 -0600985 if (n->nouni) {
986 return 0;
987 } else if (n->alluni || n->mac_table.uni_overflow) {
Alex Williamson8fd2a2f2009-06-05 14:47:08 -0600988 return 1;
989 } else if (!memcmp(ptr, n->mac, ETH_ALEN)) {
Alex Williamsonbbe2f392009-06-05 14:47:02 -0600990 return 1;
991 }
aliguori3831ab22009-02-05 22:36:24 +0000992
Alex Williamson2d9aba32009-06-05 14:47:13 -0600993 for (i = 0; i < n->mac_table.first_multi; i++) {
994 if (!memcmp(ptr, &n->mac_table.macs[i * ETH_ALEN], ETH_ALEN)) {
995 return 1;
996 }
997 }
aliguorib6503ed2009-02-05 22:36:28 +0000998 }
999
aliguori3831ab22009-02-05 22:36:24 +00001000 return 0;
1001}
1002
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +01001003static ssize_t virtio_net_receive(NetClientState *nc, const uint8_t *buf, size_t size)
aliguorifbe78f42008-12-17 19:13:11 +00001004{
Jason Wangcc1f0f42013-01-30 19:12:23 +08001005 VirtIONet *n = qemu_get_nic_opaque(nc);
Jason Wangfed699f2013-01-30 19:12:39 +08001006 VirtIONetQueue *q = virtio_net_get_subqueue(nc);
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001007 VirtIODevice *vdev = VIRTIO_DEVICE(n);
Michael S. Tsirkin63c58722012-09-24 13:17:13 +02001008 struct iovec mhdr_sg[VIRTQUEUE_MAX_SIZE];
1009 struct virtio_net_hdr_mrg_rxbuf mhdr;
1010 unsigned mhdr_cnt = 0;
Michael S. Tsirkin22cc84d2012-09-24 13:14:16 +02001011 size_t offset, i, guest_offset;
aliguorifbe78f42008-12-17 19:13:11 +00001012
Jason Wangfed699f2013-01-30 19:12:39 +08001013 if (!virtio_net_can_receive(nc)) {
Mark McLoughlincdd5cc12009-10-27 18:16:38 +00001014 return -1;
Jason Wangb356f762013-01-30 19:12:22 +08001015 }
Mark McLoughlincdd5cc12009-10-27 18:16:38 +00001016
Michael S. Tsirkin940cda92010-06-06 18:53:10 +03001017 /* hdr_len refers to the header we supply to the guest */
Jason Wang0c87e932013-01-30 19:12:38 +08001018 if (!virtio_net_has_buffers(q, size + n->guest_hdr_len - n->host_hdr_len)) {
Mark McLoughlin8aeff622009-04-29 13:40:02 +01001019 return 0;
Jason Wang0c87e932013-01-30 19:12:38 +08001020 }
aliguorifbe78f42008-12-17 19:13:11 +00001021
aliguori3831ab22009-02-05 22:36:24 +00001022 if (!receive_filter(n, buf, size))
Mark McLoughlin4f1c9422009-05-18 13:40:55 +01001023 return size;
aliguori3831ab22009-02-05 22:36:24 +00001024
aliguorifbe78f42008-12-17 19:13:11 +00001025 offset = i = 0;
1026
1027 while (offset < size) {
1028 VirtQueueElement elem;
1029 int len, total;
Michael S. Tsirkin22cc84d2012-09-24 13:14:16 +02001030 const struct iovec *sg = elem.in_sg;
aliguorifbe78f42008-12-17 19:13:11 +00001031
Amit Shah22c253d2010-01-13 16:24:43 +05301032 total = 0;
aliguorifbe78f42008-12-17 19:13:11 +00001033
Jason Wang0c87e932013-01-30 19:12:38 +08001034 if (virtqueue_pop(q->rx_vq, &elem) == 0) {
aliguorifbe78f42008-12-17 19:13:11 +00001035 if (i == 0)
Mark McLoughlin4f1c9422009-05-18 13:40:55 +01001036 return -1;
Stefan Hajnoczie7b43f72010-11-15 20:44:37 +00001037 error_report("virtio-net unexpected empty queue: "
Michael S. Tsirkin279a4252010-06-22 16:22:49 +03001038 "i %zd mergeable %d offset %zd, size %zd, "
Stefan Hajnoczie7b43f72010-11-15 20:44:37 +00001039 "guest hdr len %zd, host hdr len %zd guest features 0x%x",
Michael S. Tsirkin279a4252010-06-22 16:22:49 +03001040 i, n->mergeable_rx_bufs, offset, size,
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001041 n->guest_hdr_len, n->host_hdr_len, vdev->guest_features);
aliguorifbe78f42008-12-17 19:13:11 +00001042 exit(1);
1043 }
1044
1045 if (elem.in_num < 1) {
Stefan Hajnoczie7b43f72010-11-15 20:44:37 +00001046 error_report("virtio-net receive queue contains no in buffers");
aliguorifbe78f42008-12-17 19:13:11 +00001047 exit(1);
1048 }
1049
aliguorifbe78f42008-12-17 19:13:11 +00001050 if (i == 0) {
Michael S. Tsirkinc8d28e72012-09-24 13:26:55 +02001051 assert(offset == 0);
Michael S. Tsirkin63c58722012-09-24 13:17:13 +02001052 if (n->mergeable_rx_bufs) {
1053 mhdr_cnt = iov_copy(mhdr_sg, ARRAY_SIZE(mhdr_sg),
1054 sg, elem.in_num,
1055 offsetof(typeof(mhdr), num_buffers),
1056 sizeof(mhdr.num_buffers));
1057 }
aliguorifbe78f42008-12-17 19:13:11 +00001058
Michael S. Tsirkinc8d28e72012-09-24 13:26:55 +02001059 receive_header(n, sg, elem.in_num, buf, size);
1060 offset = n->host_hdr_len;
Michael S. Tsirkine35e23f2012-09-24 12:12:25 +02001061 total += n->guest_hdr_len;
Michael S. Tsirkin22cc84d2012-09-24 13:14:16 +02001062 guest_offset = n->guest_hdr_len;
1063 } else {
1064 guest_offset = 0;
aliguorifbe78f42008-12-17 19:13:11 +00001065 }
1066
1067 /* copy in packet. ugh */
Michael S. Tsirkin22cc84d2012-09-24 13:14:16 +02001068 len = iov_from_buf(sg, elem.in_num, guest_offset,
Michael Tokarevdcf6f5e2012-03-11 18:05:12 +04001069 buf + offset, size - offset);
aliguorifbe78f42008-12-17 19:13:11 +00001070 total += len;
Michael S. Tsirkin279a4252010-06-22 16:22:49 +03001071 offset += len;
1072 /* If buffers can't be merged, at this point we
1073 * must have consumed the complete packet.
1074 * Otherwise, drop it. */
1075 if (!n->mergeable_rx_bufs && offset < size) {
1076#if 0
Stefan Hajnoczie7b43f72010-11-15 20:44:37 +00001077 error_report("virtio-net truncated non-mergeable packet: "
1078 "i %zd mergeable %d offset %zd, size %zd, "
1079 "guest hdr len %zd, host hdr len %zd",
1080 i, n->mergeable_rx_bufs,
Michael S. Tsirkine35e23f2012-09-24 12:12:25 +02001081 offset, size, n->guest_hdr_len, n->host_hdr_len);
Michael S. Tsirkin279a4252010-06-22 16:22:49 +03001082#endif
1083 return size;
1084 }
aliguorifbe78f42008-12-17 19:13:11 +00001085
1086 /* signal other side */
Jason Wang0c87e932013-01-30 19:12:38 +08001087 virtqueue_fill(q->rx_vq, &elem, total, i++);
aliguorifbe78f42008-12-17 19:13:11 +00001088 }
1089
Michael S. Tsirkin63c58722012-09-24 13:17:13 +02001090 if (mhdr_cnt) {
Rusty Russell1399c602014-06-24 19:42:54 +02001091 virtio_stw_p(vdev, &mhdr.num_buffers, i);
Michael S. Tsirkin63c58722012-09-24 13:17:13 +02001092 iov_from_buf(mhdr_sg, mhdr_cnt,
1093 0,
1094 &mhdr.num_buffers, sizeof mhdr.num_buffers);
Aurelien Jarno44b15bc2011-01-25 11:55:14 +01001095 }
aliguorifbe78f42008-12-17 19:13:11 +00001096
Jason Wang0c87e932013-01-30 19:12:38 +08001097 virtqueue_flush(q->rx_vq, i);
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001098 virtio_notify(vdev, q->rx_vq);
Mark McLoughlin4f1c9422009-05-18 13:40:55 +01001099
1100 return size;
aliguorifbe78f42008-12-17 19:13:11 +00001101}
1102
Jason Wang0c87e932013-01-30 19:12:38 +08001103static int32_t virtio_net_flush_tx(VirtIONetQueue *q);
Mark McLoughlin62433752009-06-18 18:21:36 +01001104
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +01001105static void virtio_net_tx_complete(NetClientState *nc, ssize_t len)
Mark McLoughlin62433752009-06-18 18:21:36 +01001106{
Jason Wangcc1f0f42013-01-30 19:12:23 +08001107 VirtIONet *n = qemu_get_nic_opaque(nc);
Jason Wangfed699f2013-01-30 19:12:39 +08001108 VirtIONetQueue *q = virtio_net_get_subqueue(nc);
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001109 VirtIODevice *vdev = VIRTIO_DEVICE(n);
Mark McLoughlin62433752009-06-18 18:21:36 +01001110
Jason Wang0c87e932013-01-30 19:12:38 +08001111 virtqueue_push(q->tx_vq, &q->async_tx.elem, 0);
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001112 virtio_notify(vdev, q->tx_vq);
Mark McLoughlin62433752009-06-18 18:21:36 +01001113
Jason Wang0c87e932013-01-30 19:12:38 +08001114 q->async_tx.elem.out_num = q->async_tx.len = 0;
Mark McLoughlin62433752009-06-18 18:21:36 +01001115
Jason Wang0c87e932013-01-30 19:12:38 +08001116 virtio_queue_set_notification(q->tx_vq, 1);
1117 virtio_net_flush_tx(q);
Mark McLoughlin62433752009-06-18 18:21:36 +01001118}
1119
aliguorifbe78f42008-12-17 19:13:11 +00001120/* TX */
Jason Wang0c87e932013-01-30 19:12:38 +08001121static int32_t virtio_net_flush_tx(VirtIONetQueue *q)
aliguorifbe78f42008-12-17 19:13:11 +00001122{
Jason Wang0c87e932013-01-30 19:12:38 +08001123 VirtIONet *n = q->n;
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001124 VirtIODevice *vdev = VIRTIO_DEVICE(n);
aliguorifbe78f42008-12-17 19:13:11 +00001125 VirtQueueElement elem;
Alex Williamsone3f30482010-09-02 09:00:57 -06001126 int32_t num_packets = 0;
Jason Wangfed699f2013-01-30 19:12:39 +08001127 int queue_index = vq2q(virtio_get_queue_index(q->tx_vq));
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001128 if (!(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK)) {
Alex Williamsone3f30482010-09-02 09:00:57 -06001129 return num_packets;
1130 }
aliguorifbe78f42008-12-17 19:13:11 +00001131
Jason Wang0c87e932013-01-30 19:12:38 +08001132 if (q->async_tx.elem.out_num) {
1133 virtio_queue_set_notification(q->tx_vq, 0);
Alex Williamsone3f30482010-09-02 09:00:57 -06001134 return num_packets;
Mark McLoughlin62433752009-06-18 18:21:36 +01001135 }
1136
Jason Wang0c87e932013-01-30 19:12:38 +08001137 while (virtqueue_pop(q->tx_vq, &elem)) {
Michael S. Tsirkin14761f92012-09-24 14:52:28 +02001138 ssize_t ret, len;
aliguorifbe78f42008-12-17 19:13:11 +00001139 unsigned int out_num = elem.out_num;
1140 struct iovec *out_sg = &elem.out_sg[0];
Michael S. Tsirkin14761f92012-09-24 14:52:28 +02001141 struct iovec sg[VIRTQUEUE_MAX_SIZE];
aliguorifbe78f42008-12-17 19:13:11 +00001142
Michael S. Tsirkin7b80d082012-09-24 14:54:44 +02001143 if (out_num < 1) {
Stefan Hajnoczie7b43f72010-11-15 20:44:37 +00001144 error_report("virtio-net header not in first element");
aliguorifbe78f42008-12-17 19:13:11 +00001145 exit(1);
1146 }
1147
Cédric Le Goater032a74a2014-06-24 19:11:32 +02001148 if (n->has_vnet_hdr) {
1149 if (out_sg[0].iov_len < n->guest_hdr_len) {
1150 error_report("virtio-net header incorrect");
1151 exit(1);
1152 }
Rusty Russell1399c602014-06-24 19:42:54 +02001153 virtio_net_hdr_swap(vdev, (void *) out_sg[0].iov_base);
Cédric Le Goater032a74a2014-06-24 19:11:32 +02001154 }
1155
Michael S. Tsirkin14761f92012-09-24 14:52:28 +02001156 /*
1157 * If host wants to see the guest header as is, we can
1158 * pass it on unchanged. Otherwise, copy just the parts
1159 * that host is interested in.
1160 */
1161 assert(n->host_hdr_len <= n->guest_hdr_len);
1162 if (n->host_hdr_len != n->guest_hdr_len) {
1163 unsigned sg_num = iov_copy(sg, ARRAY_SIZE(sg),
1164 out_sg, out_num,
1165 0, n->host_hdr_len);
1166 sg_num += iov_copy(sg + sg_num, ARRAY_SIZE(sg) - sg_num,
1167 out_sg, out_num,
1168 n->guest_hdr_len, -1);
1169 out_num = sg_num;
1170 out_sg = sg;
aliguorifbe78f42008-12-17 19:13:11 +00001171 }
1172
Michael S. Tsirkin7b80d082012-09-24 14:54:44 +02001173 len = n->guest_hdr_len;
Michael S. Tsirkin14761f92012-09-24 14:52:28 +02001174
Jason Wangfed699f2013-01-30 19:12:39 +08001175 ret = qemu_sendv_packet_async(qemu_get_subqueue(n->nic, queue_index),
1176 out_sg, out_num, virtio_net_tx_complete);
Mark McLoughlin62433752009-06-18 18:21:36 +01001177 if (ret == 0) {
Jason Wang0c87e932013-01-30 19:12:38 +08001178 virtio_queue_set_notification(q->tx_vq, 0);
1179 q->async_tx.elem = elem;
1180 q->async_tx.len = len;
Alex Williamsone3f30482010-09-02 09:00:57 -06001181 return -EBUSY;
Mark McLoughlin62433752009-06-18 18:21:36 +01001182 }
1183
1184 len += ret;
aliguorifbe78f42008-12-17 19:13:11 +00001185
Jason Wang0c87e932013-01-30 19:12:38 +08001186 virtqueue_push(q->tx_vq, &elem, 0);
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001187 virtio_notify(vdev, q->tx_vq);
Alex Williamsone3f30482010-09-02 09:00:57 -06001188
1189 if (++num_packets >= n->tx_burst) {
1190 break;
1191 }
aliguorifbe78f42008-12-17 19:13:11 +00001192 }
Alex Williamsone3f30482010-09-02 09:00:57 -06001193 return num_packets;
aliguorifbe78f42008-12-17 19:13:11 +00001194}
1195
Alex Williamsona697a332010-09-02 09:01:10 -06001196static void virtio_net_handle_tx_timer(VirtIODevice *vdev, VirtQueue *vq)
aliguorifbe78f42008-12-17 19:13:11 +00001197{
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001198 VirtIONet *n = VIRTIO_NET(vdev);
Jason Wangfed699f2013-01-30 19:12:39 +08001199 VirtIONetQueue *q = &n->vqs[vq2q(virtio_get_queue_index(vq))];
aliguorifbe78f42008-12-17 19:13:11 +00001200
Michael S. Tsirkin783e7702010-11-22 19:52:30 +02001201 /* This happens when device was stopped but VCPU wasn't. */
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001202 if (!vdev->vm_running) {
Jason Wang0c87e932013-01-30 19:12:38 +08001203 q->tx_waiting = 1;
Michael S. Tsirkin783e7702010-11-22 19:52:30 +02001204 return;
1205 }
1206
Jason Wang0c87e932013-01-30 19:12:38 +08001207 if (q->tx_waiting) {
aliguorifbe78f42008-12-17 19:13:11 +00001208 virtio_queue_set_notification(vq, 1);
Alex Blighbc72ad62013-08-21 16:03:08 +01001209 timer_del(q->tx_timer);
Jason Wang0c87e932013-01-30 19:12:38 +08001210 q->tx_waiting = 0;
1211 virtio_net_flush_tx(q);
aliguorifbe78f42008-12-17 19:13:11 +00001212 } else {
Alex Blighbc72ad62013-08-21 16:03:08 +01001213 timer_mod(q->tx_timer,
1214 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + n->tx_timeout);
Jason Wang0c87e932013-01-30 19:12:38 +08001215 q->tx_waiting = 1;
aliguorifbe78f42008-12-17 19:13:11 +00001216 virtio_queue_set_notification(vq, 0);
1217 }
1218}
1219
Alex Williamsona697a332010-09-02 09:01:10 -06001220static void virtio_net_handle_tx_bh(VirtIODevice *vdev, VirtQueue *vq)
1221{
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001222 VirtIONet *n = VIRTIO_NET(vdev);
Jason Wangfed699f2013-01-30 19:12:39 +08001223 VirtIONetQueue *q = &n->vqs[vq2q(virtio_get_queue_index(vq))];
Alex Williamsona697a332010-09-02 09:01:10 -06001224
Jason Wang0c87e932013-01-30 19:12:38 +08001225 if (unlikely(q->tx_waiting)) {
Alex Williamsona697a332010-09-02 09:01:10 -06001226 return;
1227 }
Jason Wang0c87e932013-01-30 19:12:38 +08001228 q->tx_waiting = 1;
Michael S. Tsirkin783e7702010-11-22 19:52:30 +02001229 /* This happens when device was stopped but VCPU wasn't. */
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001230 if (!vdev->vm_running) {
Michael S. Tsirkin783e7702010-11-22 19:52:30 +02001231 return;
1232 }
Alex Williamsona697a332010-09-02 09:01:10 -06001233 virtio_queue_set_notification(vq, 0);
Jason Wang0c87e932013-01-30 19:12:38 +08001234 qemu_bh_schedule(q->tx_bh);
Alex Williamsona697a332010-09-02 09:01:10 -06001235}
1236
aliguorifbe78f42008-12-17 19:13:11 +00001237static void virtio_net_tx_timer(void *opaque)
1238{
Jason Wang0c87e932013-01-30 19:12:38 +08001239 VirtIONetQueue *q = opaque;
1240 VirtIONet *n = q->n;
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001241 VirtIODevice *vdev = VIRTIO_DEVICE(n);
Michael S. Tsirkine8bcf842014-09-02 17:26:12 +03001242 /* This happens when device was stopped but BH wasn't. */
1243 if (!vdev->vm_running) {
1244 /* Make sure tx waiting is set, so we'll run when restarted. */
1245 assert(q->tx_waiting);
1246 return;
1247 }
aliguorifbe78f42008-12-17 19:13:11 +00001248
Jason Wang0c87e932013-01-30 19:12:38 +08001249 q->tx_waiting = 0;
aliguorifbe78f42008-12-17 19:13:11 +00001250
1251 /* Just in case the driver is not ready on more */
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001252 if (!(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK)) {
aliguorifbe78f42008-12-17 19:13:11 +00001253 return;
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001254 }
aliguorifbe78f42008-12-17 19:13:11 +00001255
Jason Wang0c87e932013-01-30 19:12:38 +08001256 virtio_queue_set_notification(q->tx_vq, 1);
1257 virtio_net_flush_tx(q);
aliguorifbe78f42008-12-17 19:13:11 +00001258}
1259
Alex Williamsona697a332010-09-02 09:01:10 -06001260static void virtio_net_tx_bh(void *opaque)
1261{
Jason Wang0c87e932013-01-30 19:12:38 +08001262 VirtIONetQueue *q = opaque;
1263 VirtIONet *n = q->n;
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001264 VirtIODevice *vdev = VIRTIO_DEVICE(n);
Alex Williamsona697a332010-09-02 09:01:10 -06001265 int32_t ret;
1266
Michael S. Tsirkine8bcf842014-09-02 17:26:12 +03001267 /* This happens when device was stopped but BH wasn't. */
1268 if (!vdev->vm_running) {
1269 /* Make sure tx waiting is set, so we'll run when restarted. */
1270 assert(q->tx_waiting);
1271 return;
1272 }
Michael S. Tsirkin783e7702010-11-22 19:52:30 +02001273
Jason Wang0c87e932013-01-30 19:12:38 +08001274 q->tx_waiting = 0;
Alex Williamsona697a332010-09-02 09:01:10 -06001275
1276 /* Just in case the driver is not ready on more */
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001277 if (unlikely(!(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK))) {
Alex Williamsona697a332010-09-02 09:01:10 -06001278 return;
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001279 }
Alex Williamsona697a332010-09-02 09:01:10 -06001280
Jason Wang0c87e932013-01-30 19:12:38 +08001281 ret = virtio_net_flush_tx(q);
Alex Williamsona697a332010-09-02 09:01:10 -06001282 if (ret == -EBUSY) {
1283 return; /* Notification re-enable handled by tx_complete */
1284 }
1285
1286 /* If we flush a full burst of packets, assume there are
1287 * more coming and immediately reschedule */
1288 if (ret >= n->tx_burst) {
Jason Wang0c87e932013-01-30 19:12:38 +08001289 qemu_bh_schedule(q->tx_bh);
1290 q->tx_waiting = 1;
Alex Williamsona697a332010-09-02 09:01:10 -06001291 return;
1292 }
1293
1294 /* If less than a full burst, re-enable notification and flush
1295 * anything that may have come in while we weren't looking. If
1296 * we find something, assume the guest is still active and reschedule */
Jason Wang0c87e932013-01-30 19:12:38 +08001297 virtio_queue_set_notification(q->tx_vq, 1);
1298 if (virtio_net_flush_tx(q) > 0) {
1299 virtio_queue_set_notification(q->tx_vq, 0);
1300 qemu_bh_schedule(q->tx_bh);
1301 q->tx_waiting = 1;
Alex Williamsona697a332010-09-02 09:01:10 -06001302 }
1303}
1304
Jason Wangec57db12013-04-25 15:24:23 +08001305static void virtio_net_set_multiqueue(VirtIONet *n, int multiqueue)
Jason Wangfed699f2013-01-30 19:12:39 +08001306{
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001307 VirtIODevice *vdev = VIRTIO_DEVICE(n);
Jason Wangfed699f2013-01-30 19:12:39 +08001308 int i, max = multiqueue ? n->max_queues : 1;
1309
1310 n->multiqueue = multiqueue;
1311
1312 for (i = 2; i <= n->max_queues * 2 + 1; i++) {
1313 virtio_del_queue(vdev, i);
1314 }
1315
1316 for (i = 1; i < max; i++) {
1317 n->vqs[i].rx_vq = virtio_add_queue(vdev, 256, virtio_net_handle_rx);
1318 if (n->vqs[i].tx_timer) {
1319 n->vqs[i].tx_vq =
1320 virtio_add_queue(vdev, 256, virtio_net_handle_tx_timer);
Alex Blighbc72ad62013-08-21 16:03:08 +01001321 n->vqs[i].tx_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL,
Jason Wangfed699f2013-01-30 19:12:39 +08001322 virtio_net_tx_timer,
1323 &n->vqs[i]);
1324 } else {
1325 n->vqs[i].tx_vq =
1326 virtio_add_queue(vdev, 256, virtio_net_handle_tx_bh);
1327 n->vqs[i].tx_bh = qemu_bh_new(virtio_net_tx_bh, &n->vqs[i]);
1328 }
1329
1330 n->vqs[i].tx_waiting = 0;
1331 n->vqs[i].n = n;
1332 }
1333
Jason Wangec57db12013-04-25 15:24:23 +08001334 /* Note: Minux Guests (version 3.2.1) use ctrl vq but don't ack
1335 * VIRTIO_NET_F_CTRL_VQ. Create ctrl vq unconditionally to avoid
1336 * breaking them.
1337 */
1338 n->ctrl_vq = virtio_add_queue(vdev, 64, virtio_net_handle_ctrl);
Jason Wangfed699f2013-01-30 19:12:39 +08001339
1340 virtio_net_set_queues(n);
1341}
1342
aliguorifbe78f42008-12-17 19:13:11 +00001343static void virtio_net_save(QEMUFile *f, void *opaque)
1344{
1345 VirtIONet *n = opaque;
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001346 VirtIODevice *vdev = VIRTIO_DEVICE(n);
aliguorifbe78f42008-12-17 19:13:11 +00001347
Michael S. Tsirkinafbaa7b2010-09-27 18:41:30 +02001348 /* At this point, backend must be stopped, otherwise
1349 * it might keep writing to memory. */
1350 assert(!n->vhost_started);
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001351 virtio_save(vdev, f);
Greg Kurz037dab22014-06-24 19:19:03 +02001352}
1353
1354static void virtio_net_save_device(VirtIODevice *vdev, QEMUFile *f)
1355{
1356 VirtIONet *n = VIRTIO_NET(vdev);
1357 int i;
aliguorifbe78f42008-12-17 19:13:11 +00001358
aliguori79674062009-02-05 22:36:12 +00001359 qemu_put_buffer(f, n->mac, ETH_ALEN);
Jason Wang5f800802013-01-30 19:12:40 +08001360 qemu_put_be32(f, n->vqs[0].tx_waiting);
aliguorie46cb382009-01-07 17:50:45 +00001361 qemu_put_be32(f, n->mergeable_rx_bufs);
aliguori9d6271b2009-02-05 22:36:04 +00001362 qemu_put_be16(f, n->status);
Alex Williamsonf10c5922009-06-05 14:46:57 -06001363 qemu_put_byte(f, n->promisc);
1364 qemu_put_byte(f, n->allmulti);
aliguorib6503ed2009-02-05 22:36:28 +00001365 qemu_put_be32(f, n->mac_table.in_use);
1366 qemu_put_buffer(f, n->mac_table.macs, n->mac_table.in_use * ETH_ALEN);
aliguorif21c0ed2009-02-05 22:36:32 +00001367 qemu_put_buffer(f, (uint8_t *)n->vlans, MAX_VLAN >> 3);
Mark McLoughlin3a330132009-10-22 17:43:45 +01001368 qemu_put_be32(f, n->has_vnet_hdr);
Alex Williamson8fd2a2f2009-06-05 14:47:08 -06001369 qemu_put_byte(f, n->mac_table.multi_overflow);
1370 qemu_put_byte(f, n->mac_table.uni_overflow);
Alex Williamson015cb162009-06-05 14:47:18 -06001371 qemu_put_byte(f, n->alluni);
1372 qemu_put_byte(f, n->nomulti);
1373 qemu_put_byte(f, n->nouni);
1374 qemu_put_byte(f, n->nobcast);
Mark McLoughlin0ce0e8f2009-10-22 17:43:50 +01001375 qemu_put_byte(f, n->has_ufo);
Jason Wang5f800802013-01-30 19:12:40 +08001376 if (n->max_queues > 1) {
1377 qemu_put_be16(f, n->max_queues);
1378 qemu_put_be16(f, n->curr_queues);
1379 for (i = 1; i < n->curr_queues; i++) {
1380 qemu_put_be32(f, n->vqs[i].tx_waiting);
1381 }
1382 }
Dmitry Fleytman644c9852013-05-20 11:18:14 +03001383
Cornelia Huckef546f12014-12-11 14:25:06 +01001384 if (virtio_has_feature(vdev, VIRTIO_NET_F_CTRL_GUEST_OFFLOADS)) {
Dmitry Fleytman644c9852013-05-20 11:18:14 +03001385 qemu_put_be64(f, n->curr_guest_offloads);
1386 }
aliguorifbe78f42008-12-17 19:13:11 +00001387}
1388
1389static int virtio_net_load(QEMUFile *f, void *opaque, int version_id)
1390{
1391 VirtIONet *n = opaque;
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001392 VirtIODevice *vdev = VIRTIO_DEVICE(n);
aliguorifbe78f42008-12-17 19:13:11 +00001393
aliguori9d6271b2009-02-05 22:36:04 +00001394 if (version_id < 2 || version_id > VIRTIO_NET_VM_VERSION)
aliguorifbe78f42008-12-17 19:13:11 +00001395 return -EINVAL;
1396
Greg Kurz037dab22014-06-24 19:19:03 +02001397 return virtio_load(vdev, f, version_id);
1398}
1399
1400static int virtio_net_load_device(VirtIODevice *vdev, QEMUFile *f,
1401 int version_id)
1402{
1403 VirtIONet *n = VIRTIO_NET(vdev);
1404 int i, link_down;
aliguorifbe78f42008-12-17 19:13:11 +00001405
aliguori79674062009-02-05 22:36:12 +00001406 qemu_get_buffer(f, n->mac, ETH_ALEN);
Jason Wang5f800802013-01-30 19:12:40 +08001407 n->vqs[0].tx_waiting = qemu_get_be32(f);
Michael S. Tsirkinff3a8062012-09-24 21:05:03 +02001408
1409 virtio_net_set_mrg_rx_bufs(n, qemu_get_be32(f));
aliguorifbe78f42008-12-17 19:13:11 +00001410
aliguori9d6271b2009-02-05 22:36:04 +00001411 if (version_id >= 3)
1412 n->status = qemu_get_be16(f);
1413
aliguori002437c2009-02-05 22:36:20 +00001414 if (version_id >= 4) {
Alex Williamsonf10c5922009-06-05 14:46:57 -06001415 if (version_id < 8) {
1416 n->promisc = qemu_get_be32(f);
1417 n->allmulti = qemu_get_be32(f);
1418 } else {
1419 n->promisc = qemu_get_byte(f);
1420 n->allmulti = qemu_get_byte(f);
1421 }
aliguori002437c2009-02-05 22:36:20 +00001422 }
1423
aliguorib6503ed2009-02-05 22:36:28 +00001424 if (version_id >= 5) {
1425 n->mac_table.in_use = qemu_get_be32(f);
1426 /* MAC_TABLE_ENTRIES may be different from the saved image */
1427 if (n->mac_table.in_use <= MAC_TABLE_ENTRIES) {
1428 qemu_get_buffer(f, n->mac_table.macs,
1429 n->mac_table.in_use * ETH_ALEN);
Michael S. Tsirkin98f93dd2014-04-28 16:08:21 +03001430 } else {
1431 int64_t i;
1432
1433 /* Overflow detected - can happen if source has a larger MAC table.
1434 * We simply set overflow flag so there's no need to maintain the
1435 * table of addresses, discard them all.
1436 * Note: 64 bit math to avoid integer overflow.
1437 */
1438 for (i = 0; i < (int64_t)n->mac_table.in_use * ETH_ALEN; ++i) {
1439 qemu_get_byte(f);
1440 }
Alex Williamson8fd2a2f2009-06-05 14:47:08 -06001441 n->mac_table.multi_overflow = n->mac_table.uni_overflow = 1;
aliguorib6503ed2009-02-05 22:36:28 +00001442 n->mac_table.in_use = 0;
1443 }
1444 }
1445
aliguorif21c0ed2009-02-05 22:36:32 +00001446 if (version_id >= 6)
1447 qemu_get_buffer(f, (uint8_t *)n->vlans, MAX_VLAN >> 3);
1448
Mark McLoughlin3a330132009-10-22 17:43:45 +01001449 if (version_id >= 7) {
1450 if (qemu_get_be32(f) && !peer_has_vnet_hdr(n)) {
Markus Armbruster1ecda022010-02-18 17:25:24 +01001451 error_report("virtio-net: saved image requires vnet_hdr=on");
Mark McLoughlin3a330132009-10-22 17:43:45 +01001452 return -1;
1453 }
Alex Williamson6c042c12009-06-05 14:46:52 -06001454 }
1455
Alex Williamson8fd2a2f2009-06-05 14:47:08 -06001456 if (version_id >= 9) {
1457 n->mac_table.multi_overflow = qemu_get_byte(f);
1458 n->mac_table.uni_overflow = qemu_get_byte(f);
1459 }
1460
Alex Williamson015cb162009-06-05 14:47:18 -06001461 if (version_id >= 10) {
1462 n->alluni = qemu_get_byte(f);
1463 n->nomulti = qemu_get_byte(f);
1464 n->nouni = qemu_get_byte(f);
1465 n->nobcast = qemu_get_byte(f);
1466 }
1467
Mark McLoughlin0ce0e8f2009-10-22 17:43:50 +01001468 if (version_id >= 11) {
1469 if (qemu_get_byte(f) && !peer_has_ufo(n)) {
Markus Armbruster1ecda022010-02-18 17:25:24 +01001470 error_report("virtio-net: saved image requires TUN_F_UFO support");
Mark McLoughlin0ce0e8f2009-10-22 17:43:50 +01001471 return -1;
1472 }
1473 }
1474
Jason Wang5f800802013-01-30 19:12:40 +08001475 if (n->max_queues > 1) {
1476 if (n->max_queues != qemu_get_be16(f)) {
1477 error_report("virtio-net: different max_queues ");
1478 return -1;
1479 }
1480
1481 n->curr_queues = qemu_get_be16(f);
Michael S. Tsirkineea750a2014-04-03 19:50:56 +03001482 if (n->curr_queues > n->max_queues) {
1483 error_report("virtio-net: curr_queues %x > max_queues %x",
1484 n->curr_queues, n->max_queues);
1485 return -1;
1486 }
Jason Wang5f800802013-01-30 19:12:40 +08001487 for (i = 1; i < n->curr_queues; i++) {
1488 n->vqs[i].tx_waiting = qemu_get_be32(f);
1489 }
1490 }
1491
Cornelia Huckef546f12014-12-11 14:25:06 +01001492 if (virtio_has_feature(vdev, VIRTIO_NET_F_CTRL_GUEST_OFFLOADS)) {
Dmitry Fleytman644c9852013-05-20 11:18:14 +03001493 n->curr_guest_offloads = qemu_get_be64(f);
1494 } else {
1495 n->curr_guest_offloads = virtio_net_supported_guest_offloads(n);
1496 }
1497
1498 if (peer_has_vnet_hdr(n)) {
1499 virtio_net_apply_guest_offloads(n);
1500 }
1501
Jason Wang5f800802013-01-30 19:12:40 +08001502 virtio_net_set_queues(n);
1503
Alex Williamson2d9aba32009-06-05 14:47:13 -06001504 /* Find the first multicast entry in the saved MAC filter */
1505 for (i = 0; i < n->mac_table.in_use; i++) {
1506 if (n->mac_table.macs[i * ETH_ALEN] & 1) {
1507 break;
1508 }
1509 }
1510 n->mac_table.first_multi = i;
Amos Kong98991482012-09-28 10:06:02 +08001511
1512 /* nc.link_down can't be migrated, so infer link_down according
1513 * to link status bit in n->status */
Jason Wang5f800802013-01-30 19:12:40 +08001514 link_down = (n->status & VIRTIO_NET_S_LINK_UP) == 0;
1515 for (i = 0; i < n->max_queues; i++) {
1516 qemu_get_subqueue(n->nic, i)->link_down = link_down;
1517 }
Amos Kong98991482012-09-28 10:06:02 +08001518
Cornelia Huckef546f12014-12-11 14:25:06 +01001519 if (virtio_has_feature(vdev, VIRTIO_NET_F_GUEST_ANNOUNCE) &&
1520 virtio_has_feature(vdev, VIRTIO_NET_F_CTRL_VQ)) {
Jason Wangf57fcf72014-05-20 14:01:44 +08001521 n->announce_counter = SELF_ANNOUNCE_ROUNDS;
1522 timer_mod(n->announce_timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL));
1523 }
1524
aliguorifbe78f42008-12-17 19:13:11 +00001525 return 0;
1526}
1527
Mark McLoughlineb6b6c12009-11-25 18:49:11 +00001528static NetClientInfo net_virtio_info = {
Laszlo Ersek2be64a62012-07-17 16:17:12 +02001529 .type = NET_CLIENT_OPTIONS_KIND_NIC,
Mark McLoughlineb6b6c12009-11-25 18:49:11 +00001530 .size = sizeof(NICState),
1531 .can_receive = virtio_net_can_receive,
1532 .receive = virtio_net_receive,
Mark McLoughlineb6b6c12009-11-25 18:49:11 +00001533 .link_status_changed = virtio_net_set_link_status,
Amos Kongb1be4282013-06-14 15:45:52 +08001534 .query_rx_filter = virtio_net_query_rxfilter,
Mark McLoughlineb6b6c12009-11-25 18:49:11 +00001535};
1536
Michael S. Tsirkinf56a1242012-12-24 17:37:01 +02001537static bool virtio_net_guest_notifier_pending(VirtIODevice *vdev, int idx)
1538{
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001539 VirtIONet *n = VIRTIO_NET(vdev);
Jason Wangfed699f2013-01-30 19:12:39 +08001540 NetClientState *nc = qemu_get_subqueue(n->nic, vq2q(idx));
Michael S. Tsirkinf56a1242012-12-24 17:37:01 +02001541 assert(n->vhost_started);
Nikolay Nikolaeved8b4af2014-05-27 15:05:08 +03001542 return vhost_net_virtqueue_pending(get_vhost_net(nc->peer), idx);
Michael S. Tsirkinf56a1242012-12-24 17:37:01 +02001543}
1544
1545static void virtio_net_guest_notifier_mask(VirtIODevice *vdev, int idx,
1546 bool mask)
1547{
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001548 VirtIONet *n = VIRTIO_NET(vdev);
Jason Wangfed699f2013-01-30 19:12:39 +08001549 NetClientState *nc = qemu_get_subqueue(n->nic, vq2q(idx));
Michael S. Tsirkinf56a1242012-12-24 17:37:01 +02001550 assert(n->vhost_started);
Nikolay Nikolaeved8b4af2014-05-27 15:05:08 +03001551 vhost_net_virtqueue_mask(get_vhost_net(nc->peer),
Michael S. Tsirkinf56a1242012-12-24 17:37:01 +02001552 vdev, idx, mask);
1553}
1554
KONRAD Frederic17ec5a82013-04-11 16:29:57 +02001555void virtio_net_set_config_size(VirtIONet *n, uint32_t host_features)
aliguorifbe78f42008-12-17 19:13:11 +00001556{
Jesse Larrew14f9b662013-02-05 17:47:16 -06001557 int i, config_size = 0;
Cornelia Huck0cd09c32014-12-11 14:25:05 +01001558 virtio_add_feature(&host_features, VIRTIO_NET_F_MAC);
Jesse Larrew14f9b662013-02-05 17:47:16 -06001559 for (i = 0; feature_sizes[i].flags != 0; i++) {
1560 if (host_features & feature_sizes[i].flags) {
1561 config_size = MAX(feature_sizes[i].end, config_size);
1562 }
1563 }
Jesse Larrew14f9b662013-02-05 17:47:16 -06001564 n->config_size = config_size;
KONRAD Frederic17ec5a82013-04-11 16:29:57 +02001565}
1566
KONRAD Frederic8a253ec2013-05-15 14:12:49 +02001567void virtio_net_set_netclient_name(VirtIONet *n, const char *name,
1568 const char *type)
1569{
1570 /*
1571 * The name can be NULL, the netclient name will be type.x.
1572 */
1573 assert(type != NULL);
1574
Markus Armbruster9e288402014-06-06 18:43:29 +02001575 g_free(n->netclient_name);
Markus Armbruster9e288402014-06-06 18:43:29 +02001576 g_free(n->netclient_type);
Markus Armbruster80e00902014-06-06 18:43:30 +02001577 n->netclient_name = g_strdup(name);
KONRAD Frederic8a253ec2013-05-15 14:12:49 +02001578 n->netclient_type = g_strdup(type);
1579}
1580
Andreas Färbere6f746b2013-07-30 02:36:06 +02001581static void virtio_net_device_realize(DeviceState *dev, Error **errp)
KONRAD Frederic17ec5a82013-04-11 16:29:57 +02001582{
Andreas Färbere6f746b2013-07-30 02:36:06 +02001583 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
Andreas Färber284a32f2013-07-30 05:02:48 +02001584 VirtIONet *n = VIRTIO_NET(dev);
1585 NetClientState *nc;
KONRAD Frederic1773d9e2013-04-11 16:30:02 +02001586 int i;
KONRAD Frederic17ec5a82013-04-11 16:29:57 +02001587
Andreas Färber284a32f2013-07-30 05:02:48 +02001588 virtio_init(vdev, "virtio-net", VIRTIO_ID_NET, n->config_size);
KONRAD Frederic17ec5a82013-04-11 16:29:57 +02001589
Jiri Pirko575a1c02014-05-26 12:04:08 +02001590 n->max_queues = MAX(n->nic_conf.peers.queues, 1);
Jason Wangf6b26cf2013-02-22 23:15:06 +08001591 n->vqs = g_malloc0(sizeof(VirtIONetQueue) * n->max_queues);
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001592 n->vqs[0].rx_vq = virtio_add_queue(vdev, 256, virtio_net_handle_rx);
Jason Wangfed699f2013-01-30 19:12:39 +08001593 n->curr_queues = 1;
1594 n->vqs[0].n = n;
KONRAD Frederic1773d9e2013-04-11 16:30:02 +02001595 n->tx_timeout = n->net_conf.txtimer;
Alex Williamsona697a332010-09-02 09:01:10 -06001596
KONRAD Frederic1773d9e2013-04-11 16:30:02 +02001597 if (n->net_conf.tx && strcmp(n->net_conf.tx, "timer")
1598 && strcmp(n->net_conf.tx, "bh")) {
Stefan Hajnoczie7b43f72010-11-15 20:44:37 +00001599 error_report("virtio-net: "
1600 "Unknown option tx=%s, valid options: \"timer\" \"bh\"",
KONRAD Frederic1773d9e2013-04-11 16:30:02 +02001601 n->net_conf.tx);
Stefan Hajnoczie7b43f72010-11-15 20:44:37 +00001602 error_report("Defaulting to \"bh\"");
Alex Williamsona697a332010-09-02 09:01:10 -06001603 }
1604
KONRAD Frederic1773d9e2013-04-11 16:30:02 +02001605 if (n->net_conf.tx && !strcmp(n->net_conf.tx, "timer")) {
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001606 n->vqs[0].tx_vq = virtio_add_queue(vdev, 256,
Jason Wangfed699f2013-01-30 19:12:39 +08001607 virtio_net_handle_tx_timer);
Alex Blighbc72ad62013-08-21 16:03:08 +01001608 n->vqs[0].tx_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, virtio_net_tx_timer,
Jason Wangfed699f2013-01-30 19:12:39 +08001609 &n->vqs[0]);
Alex Williamsona697a332010-09-02 09:01:10 -06001610 } else {
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001611 n->vqs[0].tx_vq = virtio_add_queue(vdev, 256,
Jason Wangfed699f2013-01-30 19:12:39 +08001612 virtio_net_handle_tx_bh);
1613 n->vqs[0].tx_bh = qemu_bh_new(virtio_net_tx_bh, &n->vqs[0]);
Alex Williamsona697a332010-09-02 09:01:10 -06001614 }
KONRAD Frederic17a0ca52013-04-11 16:30:01 +02001615 n->ctrl_vq = virtio_add_queue(vdev, 64, virtio_net_handle_ctrl);
KONRAD Frederic1773d9e2013-04-11 16:30:02 +02001616 qemu_macaddr_default_if_unset(&n->nic_conf.macaddr);
1617 memcpy(&n->mac[0], &n->nic_conf.macaddr, sizeof(n->mac));
aliguori554c97d2009-01-08 19:46:33 +00001618 n->status = VIRTIO_NET_S_LINK_UP;
Jason Wangf57fcf72014-05-20 14:01:44 +08001619 n->announce_timer = timer_new_ms(QEMU_CLOCK_VIRTUAL,
1620 virtio_net_announce_timer, n);
aliguorifbe78f42008-12-17 19:13:11 +00001621
KONRAD Frederic8a253ec2013-05-15 14:12:49 +02001622 if (n->netclient_type) {
1623 /*
1624 * Happen when virtio_net_set_netclient_name has been called.
1625 */
1626 n->nic = qemu_new_nic(&net_virtio_info, &n->nic_conf,
1627 n->netclient_type, n->netclient_name, n);
1628 } else {
1629 n->nic = qemu_new_nic(&net_virtio_info, &n->nic_conf,
Andreas Färber284a32f2013-07-30 05:02:48 +02001630 object_get_typename(OBJECT(dev)), dev->id, n);
KONRAD Frederic8a253ec2013-05-15 14:12:49 +02001631 }
1632
Michael S. Tsirkin6e371ab2012-09-24 17:04:21 +02001633 peer_test_vnet_hdr(n);
1634 if (peer_has_vnet_hdr(n)) {
Jason Wangfed699f2013-01-30 19:12:39 +08001635 for (i = 0; i < n->max_queues; i++) {
Stefan Hajnoczid6085e32014-02-20 12:14:07 +01001636 qemu_using_vnet_hdr(qemu_get_subqueue(n->nic, i)->peer, true);
Jason Wangfed699f2013-01-30 19:12:39 +08001637 }
Michael S. Tsirkin6e371ab2012-09-24 17:04:21 +02001638 n->host_hdr_len = sizeof(struct virtio_net_hdr);
1639 } else {
1640 n->host_hdr_len = 0;
1641 }
Mark McLoughlineb6b6c12009-11-25 18:49:11 +00001642
KONRAD Frederic1773d9e2013-04-11 16:30:02 +02001643 qemu_format_nic_info_str(qemu_get_queue(n->nic), n->nic_conf.macaddr.a);
aliguori96d5e202009-01-07 17:47:15 +00001644
Jason Wangfed699f2013-01-30 19:12:39 +08001645 n->vqs[0].tx_waiting = 0;
KONRAD Frederic1773d9e2013-04-11 16:30:02 +02001646 n->tx_burst = n->net_conf.txburst;
Michael S. Tsirkinff3a8062012-09-24 21:05:03 +02001647 virtio_net_set_mrg_rx_bufs(n, 0);
aliguori002437c2009-02-05 22:36:20 +00001648 n->promisc = 1; /* for compatibility */
aliguorifbe78f42008-12-17 19:13:11 +00001649
Anthony Liguori7267c092011-08-20 22:09:37 -05001650 n->mac_table.macs = g_malloc0(MAC_TABLE_ENTRIES * ETH_ALEN);
aliguorib6503ed2009-02-05 22:36:28 +00001651
Anthony Liguori7267c092011-08-20 22:09:37 -05001652 n->vlans = g_malloc0(MAX_VLAN >> 3);
aliguorif21c0ed2009-02-05 22:36:32 +00001653
Amos Kongb1be4282013-06-14 15:45:52 +08001654 nc = qemu_get_queue(n->nic);
1655 nc->rxfilter_notify_enabled = 1;
1656
Andreas Färber284a32f2013-07-30 05:02:48 +02001657 n->qdev = dev;
1658 register_savevm(dev, "virtio-net", -1, VIRTIO_NET_VM_VERSION,
aliguorifbe78f42008-12-17 19:13:11 +00001659 virtio_net_save, virtio_net_load, n);
KONRAD Frederic17ec5a82013-04-11 16:29:57 +02001660}
1661
Andreas Färber306ec6c2013-07-30 03:50:44 +02001662static void virtio_net_device_unrealize(DeviceState *dev, Error **errp)
KONRAD Frederic17ec5a82013-04-11 16:29:57 +02001663{
Andreas Färber306ec6c2013-07-30 03:50:44 +02001664 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
1665 VirtIONet *n = VIRTIO_NET(dev);
KONRAD Frederic17ec5a82013-04-11 16:29:57 +02001666 int i;
1667
1668 /* This will stop vhost backend if appropriate. */
1669 virtio_net_set_status(vdev, 0);
1670
Andreas Färber306ec6c2013-07-30 03:50:44 +02001671 unregister_savevm(dev, "virtio-net", n);
KONRAD Frederic17ec5a82013-04-11 16:29:57 +02001672
Markus Armbruster9e288402014-06-06 18:43:29 +02001673 g_free(n->netclient_name);
1674 n->netclient_name = NULL;
1675 g_free(n->netclient_type);
1676 n->netclient_type = NULL;
KONRAD Frederic8a253ec2013-05-15 14:12:49 +02001677
KONRAD Frederic17ec5a82013-04-11 16:29:57 +02001678 g_free(n->mac_table.macs);
1679 g_free(n->vlans);
1680
1681 for (i = 0; i < n->max_queues; i++) {
1682 VirtIONetQueue *q = &n->vqs[i];
1683 NetClientState *nc = qemu_get_subqueue(n->nic, i);
1684
1685 qemu_purge_queued_packets(nc);
1686
1687 if (q->tx_timer) {
Alex Blighbc72ad62013-08-21 16:03:08 +01001688 timer_del(q->tx_timer);
1689 timer_free(q->tx_timer);
Jason Wangfe2dafa2013-11-06 16:58:08 +08001690 } else if (q->tx_bh) {
KONRAD Frederic17ec5a82013-04-11 16:29:57 +02001691 qemu_bh_delete(q->tx_bh);
1692 }
1693 }
1694
Jason Wangf57fcf72014-05-20 14:01:44 +08001695 timer_del(n->announce_timer);
1696 timer_free(n->announce_timer);
KONRAD Frederic17ec5a82013-04-11 16:29:57 +02001697 g_free(n->vqs);
1698 qemu_del_nic(n->nic);
KONRAD Frederic6a1a8cc2013-04-24 10:21:22 +02001699 virtio_cleanup(vdev);
KONRAD Frederic17ec5a82013-04-11 16:29:57 +02001700}
1701
1702static void virtio_net_instance_init(Object *obj)
1703{
1704 VirtIONet *n = VIRTIO_NET(obj);
1705
1706 /*
1707 * The default config_size is sizeof(struct virtio_net_config).
1708 * Can be overriden with virtio_net_set_config_size.
1709 */
1710 n->config_size = sizeof(struct virtio_net_config);
Gongleiaa4197c2014-10-07 16:00:12 +08001711 device_add_bootindex_property(obj, &n->nic_conf.bootindex,
1712 "bootindex", "/ethernet-phy@0",
1713 DEVICE(n), NULL);
KONRAD Frederic17ec5a82013-04-11 16:29:57 +02001714}
1715
1716static Property virtio_net_properties[] = {
1717 DEFINE_NIC_PROPERTIES(VirtIONet, nic_conf),
1718 DEFINE_PROP_UINT32("x-txtimer", VirtIONet, net_conf.txtimer,
1719 TX_TIMER_INTERVAL),
1720 DEFINE_PROP_INT32("x-txburst", VirtIONet, net_conf.txburst, TX_BURST),
1721 DEFINE_PROP_STRING("tx", VirtIONet, net_conf.tx),
1722 DEFINE_PROP_END_OF_LIST(),
1723};
1724
1725static void virtio_net_class_init(ObjectClass *klass, void *data)
1726{
1727 DeviceClass *dc = DEVICE_CLASS(klass);
1728 VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
Andreas Färbere6f746b2013-07-30 02:36:06 +02001729
KONRAD Frederic17ec5a82013-04-11 16:29:57 +02001730 dc->props = virtio_net_properties;
Marcel Apfelbaum125ee0e2013-07-29 17:17:45 +03001731 set_bit(DEVICE_CATEGORY_NETWORK, dc->categories);
Andreas Färbere6f746b2013-07-30 02:36:06 +02001732 vdc->realize = virtio_net_device_realize;
Andreas Färber306ec6c2013-07-30 03:50:44 +02001733 vdc->unrealize = virtio_net_device_unrealize;
KONRAD Frederic17ec5a82013-04-11 16:29:57 +02001734 vdc->get_config = virtio_net_get_config;
1735 vdc->set_config = virtio_net_set_config;
1736 vdc->get_features = virtio_net_get_features;
1737 vdc->set_features = virtio_net_set_features;
1738 vdc->bad_features = virtio_net_bad_features;
1739 vdc->reset = virtio_net_reset;
1740 vdc->set_status = virtio_net_set_status;
1741 vdc->guest_notifier_mask = virtio_net_guest_notifier_mask;
1742 vdc->guest_notifier_pending = virtio_net_guest_notifier_pending;
Greg Kurz037dab22014-06-24 19:19:03 +02001743 vdc->load = virtio_net_load_device;
1744 vdc->save = virtio_net_save_device;
KONRAD Frederic17ec5a82013-04-11 16:29:57 +02001745}
1746
1747static const TypeInfo virtio_net_info = {
1748 .name = TYPE_VIRTIO_NET,
1749 .parent = TYPE_VIRTIO_DEVICE,
1750 .instance_size = sizeof(VirtIONet),
1751 .instance_init = virtio_net_instance_init,
1752 .class_init = virtio_net_class_init,
1753};
1754
1755static void virtio_register_types(void)
1756{
1757 type_register_static(&virtio_net_info);
1758}
1759
1760type_init(virtio_register_types)