4 * Copyright (c) 2003-2008 Fabrice Bellard
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25 #include "qemu/osdep.h"
30 #include "hw/qdev-properties.h"
31 #include "net/slirp.h"
35 #include "monitor/monitor.h"
36 #include "qemu/help_option.h"
37 #include "qapi/qapi-commands-net.h"
38 #include "qapi/qapi-visit-net.h"
39 #include "qapi/qmp/qdict.h"
40 #include "qapi/qmp/qerror.h"
41 #include "qemu/error-report.h"
42 #include "qemu/sockets.h"
43 #include "qemu/cutils.h"
44 #include "qemu/config-file.h"
45 #include "qemu/ctype.h"
48 #include "qemu/qemu-print.h"
49 #include "qemu/main-loop.h"
50 #include "qemu/option.h"
51 #include "qemu/keyval.h"
52 #include "qapi/error.h"
53 #include "qapi/opts-visitor.h"
54 #include "sysemu/runstate.h"
55 #include "net/colo-compare.h"
56 #include "net/filter.h"
57 #include "qapi/string-output-visitor.h"
58 #include "qapi/qobject-input-visitor.h"
60 /* Net bridge is currently not supported for W32. */
62 # define CONFIG_NET_BRIDGE
65 static VMChangeStateEntry *net_change_state_entry;
66 NetClientStateList net_clients;
68 typedef struct NetdevQueueEntry {
71 QSIMPLEQ_ENTRY(NetdevQueueEntry) entry;
74 typedef QSIMPLEQ_HEAD(, NetdevQueueEntry) NetdevQueue;
76 static NetdevQueue nd_queue = QSIMPLEQ_HEAD_INITIALIZER(nd_queue);
78 /***********************************************************/
79 /* network device redirectors */
81 int convert_host_port(struct sockaddr_in *saddr, const char *host,
82 const char *port, Error **errp)
88 memset(saddr, 0, sizeof(*saddr));
90 saddr->sin_family = AF_INET;
91 if (host[0] == '\0') {
92 saddr->sin_addr.s_addr = 0;
94 if (qemu_isdigit(host[0])) {
95 if (!inet_aton(host, &saddr->sin_addr)) {
96 error_setg(errp, "host address '%s' is not a valid "
97 "IPv4 address", host);
101 he = gethostbyname(host);
103 error_setg(errp, "can't resolve host address '%s'", host);
106 saddr->sin_addr = *(struct in_addr *)he->h_addr;
109 if (qemu_strtol(port, &r, 0, &p) != 0) {
110 error_setg(errp, "port number '%s' is invalid", port);
113 saddr->sin_port = htons(p);
117 int parse_host_port(struct sockaddr_in *saddr, const char *str,
123 substrings = g_strsplit(str, ":", 2);
124 if (!substrings || !substrings[0] || !substrings[1]) {
125 error_setg(errp, "host address '%s' doesn't contain ':' "
126 "separating host from port", str);
131 ret = convert_host_port(saddr, substrings[0], substrings[1], errp);
134 g_strfreev(substrings);
138 char *qemu_mac_strdup_printf(const uint8_t *macaddr)
140 return g_strdup_printf("%.2x:%.2x:%.2x:%.2x:%.2x:%.2x",
141 macaddr[0], macaddr[1], macaddr[2],
142 macaddr[3], macaddr[4], macaddr[5]);
145 void qemu_set_info_str(NetClientState *nc, const char *fmt, ...)
150 vsnprintf(nc->info_str, sizeof(nc->info_str), fmt, ap);
154 void qemu_format_nic_info_str(NetClientState *nc, uint8_t macaddr[6])
156 qemu_set_info_str(nc, "model=%s,macaddr=%02x:%02x:%02x:%02x:%02x:%02x",
157 nc->model, macaddr[0], macaddr[1], macaddr[2],
158 macaddr[3], macaddr[4], macaddr[5]);
161 static int mac_table[256] = {0};
163 static void qemu_macaddr_set_used(MACAddr *macaddr)
167 for (index = 0x56; index < 0xFF; index++) {
168 if (macaddr->a[5] == index) {
174 static void qemu_macaddr_set_free(MACAddr *macaddr)
177 static const MACAddr base = { .a = { 0x52, 0x54, 0x00, 0x12, 0x34, 0 } };
179 if (memcmp(macaddr->a, &base.a, (sizeof(base.a) - 1)) != 0) {
182 for (index = 0x56; index < 0xFF; index++) {
183 if (macaddr->a[5] == index) {
189 static int qemu_macaddr_get_free(void)
193 for (index = 0x56; index < 0xFF; index++) {
194 if (mac_table[index] == 0) {
202 void qemu_macaddr_default_if_unset(MACAddr *macaddr)
204 static const MACAddr zero = { .a = { 0,0,0,0,0,0 } };
205 static const MACAddr base = { .a = { 0x52, 0x54, 0x00, 0x12, 0x34, 0 } };
207 if (memcmp(macaddr, &zero, sizeof(zero)) != 0) {
208 if (memcmp(macaddr->a, &base.a, (sizeof(base.a) - 1)) != 0) {
211 qemu_macaddr_set_used(macaddr);
216 macaddr->a[0] = 0x52;
217 macaddr->a[1] = 0x54;
218 macaddr->a[2] = 0x00;
219 macaddr->a[3] = 0x12;
220 macaddr->a[4] = 0x34;
221 macaddr->a[5] = qemu_macaddr_get_free();
222 qemu_macaddr_set_used(macaddr);
226 * Generate a name for net client
228 * Only net clients created with the legacy -net option and NICs need this.
230 static char *assign_name(NetClientState *nc1, const char *model)
235 QTAILQ_FOREACH(nc, &net_clients, next) {
239 if (strcmp(nc->model, model) == 0) {
244 return g_strdup_printf("%s.%d", model, id);
247 static void qemu_net_client_destructor(NetClientState *nc)
251 static ssize_t qemu_deliver_packet_iov(NetClientState *sender,
253 const struct iovec *iov,
257 static void qemu_net_client_setup(NetClientState *nc,
259 NetClientState *peer,
262 NetClientDestructor *destructor,
266 nc->model = g_strdup(model);
268 nc->name = g_strdup(name);
270 nc->name = assign_name(nc, model);
278 QTAILQ_INSERT_TAIL(&net_clients, nc, next);
280 nc->incoming_queue = qemu_new_net_queue(qemu_deliver_packet_iov, nc);
281 nc->destructor = destructor;
282 nc->is_datapath = is_datapath;
283 QTAILQ_INIT(&nc->filters);
286 NetClientState *qemu_new_net_client(NetClientInfo *info,
287 NetClientState *peer,
293 assert(info->size >= sizeof(NetClientState));
295 nc = g_malloc0(info->size);
296 qemu_net_client_setup(nc, info, peer, model, name,
297 qemu_net_client_destructor, true);
302 NetClientState *qemu_new_net_control_client(NetClientInfo *info,
303 NetClientState *peer,
309 assert(info->size >= sizeof(NetClientState));
311 nc = g_malloc0(info->size);
312 qemu_net_client_setup(nc, info, peer, model, name,
313 qemu_net_client_destructor, false);
318 NICState *qemu_new_nic(NetClientInfo *info,
324 NetClientState **peers = conf->peers.ncs;
326 int i, queues = MAX(1, conf->peers.queues);
328 assert(info->type == NET_CLIENT_DRIVER_NIC);
329 assert(info->size >= sizeof(NICState));
331 nic = g_malloc0(info->size + sizeof(NetClientState) * queues);
332 nic->ncs = (void *)nic + info->size;
334 nic->opaque = opaque;
336 for (i = 0; i < queues; i++) {
337 qemu_net_client_setup(&nic->ncs[i], info, peers[i], model, name,
339 nic->ncs[i].queue_index = i;
345 NetClientState *qemu_get_subqueue(NICState *nic, int queue_index)
347 return nic->ncs + queue_index;
350 NetClientState *qemu_get_queue(NICState *nic)
352 return qemu_get_subqueue(nic, 0);
355 NICState *qemu_get_nic(NetClientState *nc)
357 NetClientState *nc0 = nc - nc->queue_index;
359 return (NICState *)((void *)nc0 - nc->info->size);
362 void *qemu_get_nic_opaque(NetClientState *nc)
364 NICState *nic = qemu_get_nic(nc);
369 NetClientState *qemu_get_peer(NetClientState *nc, int queue_index)
372 NetClientState *ncs = nc + queue_index;
376 static void qemu_cleanup_net_client(NetClientState *nc)
378 QTAILQ_REMOVE(&net_clients, nc, next);
380 if (nc->info->cleanup) {
381 nc->info->cleanup(nc);
385 static void qemu_free_net_client(NetClientState *nc)
387 if (nc->incoming_queue) {
388 qemu_del_net_queue(nc->incoming_queue);
391 nc->peer->peer = NULL;
395 if (nc->destructor) {
400 void qemu_del_net_client(NetClientState *nc)
402 NetClientState *ncs[MAX_QUEUE_NUM];
404 NetFilterState *nf, *next;
406 assert(nc->info->type != NET_CLIENT_DRIVER_NIC);
408 /* If the NetClientState belongs to a multiqueue backend, we will change all
409 * other NetClientStates also.
411 queues = qemu_find_net_clients_except(nc->name, ncs,
412 NET_CLIENT_DRIVER_NIC,
416 QTAILQ_FOREACH_SAFE(nf, &nc->filters, next, next) {
417 object_unparent(OBJECT(nf));
420 /* If there is a peer NIC, delete and cleanup client, but do not free. */
421 if (nc->peer && nc->peer->info->type == NET_CLIENT_DRIVER_NIC) {
422 NICState *nic = qemu_get_nic(nc->peer);
423 if (nic->peer_deleted) {
426 nic->peer_deleted = true;
428 for (i = 0; i < queues; i++) {
429 ncs[i]->peer->link_down = true;
432 if (nc->peer->info->link_status_changed) {
433 nc->peer->info->link_status_changed(nc->peer);
436 for (i = 0; i < queues; i++) {
437 qemu_cleanup_net_client(ncs[i]);
443 for (i = 0; i < queues; i++) {
444 qemu_cleanup_net_client(ncs[i]);
445 qemu_free_net_client(ncs[i]);
449 void qemu_del_nic(NICState *nic)
451 int i, queues = MAX(nic->conf->peers.queues, 1);
453 qemu_macaddr_set_free(&nic->conf->macaddr);
455 for (i = 0; i < queues; i++) {
456 NetClientState *nc = qemu_get_subqueue(nic, i);
457 /* If this is a peer NIC and peer has already been deleted, free it now. */
458 if (nic->peer_deleted) {
459 qemu_free_net_client(nc->peer);
460 } else if (nc->peer) {
461 /* if there are RX packets pending, complete them */
462 qemu_purge_queued_packets(nc->peer);
466 for (i = queues - 1; i >= 0; i--) {
467 NetClientState *nc = qemu_get_subqueue(nic, i);
469 qemu_cleanup_net_client(nc);
470 qemu_free_net_client(nc);
476 void qemu_foreach_nic(qemu_nic_foreach func, void *opaque)
480 QTAILQ_FOREACH(nc, &net_clients, next) {
481 if (nc->info->type == NET_CLIENT_DRIVER_NIC) {
482 if (nc->queue_index == 0) {
483 func(qemu_get_nic(nc), opaque);
489 bool qemu_has_ufo(NetClientState *nc)
491 if (!nc || !nc->info->has_ufo) {
495 return nc->info->has_ufo(nc);
498 bool qemu_has_vnet_hdr(NetClientState *nc)
500 if (!nc || !nc->info->has_vnet_hdr) {
504 return nc->info->has_vnet_hdr(nc);
507 bool qemu_has_vnet_hdr_len(NetClientState *nc, int len)
509 if (!nc || !nc->info->has_vnet_hdr_len) {
513 return nc->info->has_vnet_hdr_len(nc, len);
516 void qemu_using_vnet_hdr(NetClientState *nc, bool enable)
518 if (!nc || !nc->info->using_vnet_hdr) {
522 nc->info->using_vnet_hdr(nc, enable);
525 void qemu_set_offload(NetClientState *nc, int csum, int tso4, int tso6,
528 if (!nc || !nc->info->set_offload) {
532 nc->info->set_offload(nc, csum, tso4, tso6, ecn, ufo);
535 void qemu_set_vnet_hdr_len(NetClientState *nc, int len)
537 if (!nc || !nc->info->set_vnet_hdr_len) {
541 nc->vnet_hdr_len = len;
542 nc->info->set_vnet_hdr_len(nc, len);
545 int qemu_set_vnet_le(NetClientState *nc, bool is_le)
548 if (!nc || !nc->info->set_vnet_le) {
552 return nc->info->set_vnet_le(nc, is_le);
558 int qemu_set_vnet_be(NetClientState *nc, bool is_be)
563 if (!nc || !nc->info->set_vnet_be) {
567 return nc->info->set_vnet_be(nc, is_be);
571 int qemu_can_receive_packet(NetClientState *nc)
573 if (nc->receive_disabled) {
575 } else if (nc->info->can_receive &&
576 !nc->info->can_receive(nc)) {
582 int qemu_can_send_packet(NetClientState *sender)
584 int vm_running = runstate_is_running();
594 return qemu_can_receive_packet(sender->peer);
597 static ssize_t filter_receive_iov(NetClientState *nc,
598 NetFilterDirection direction,
599 NetClientState *sender,
601 const struct iovec *iov,
603 NetPacketSent *sent_cb)
606 NetFilterState *nf = NULL;
608 if (direction == NET_FILTER_DIRECTION_TX) {
609 QTAILQ_FOREACH(nf, &nc->filters, next) {
610 ret = qemu_netfilter_receive(nf, direction, sender, flags, iov,
617 QTAILQ_FOREACH_REVERSE(nf, &nc->filters, next) {
618 ret = qemu_netfilter_receive(nf, direction, sender, flags, iov,
629 static ssize_t filter_receive(NetClientState *nc,
630 NetFilterDirection direction,
631 NetClientState *sender,
635 NetPacketSent *sent_cb)
638 .iov_base = (void *)data,
642 return filter_receive_iov(nc, direction, sender, flags, &iov, 1, sent_cb);
645 void qemu_purge_queued_packets(NetClientState *nc)
651 qemu_net_queue_purge(nc->peer->incoming_queue, nc);
654 void qemu_flush_or_purge_queued_packets(NetClientState *nc, bool purge)
656 nc->receive_disabled = 0;
658 if (nc->peer && nc->peer->info->type == NET_CLIENT_DRIVER_HUBPORT) {
659 if (net_hub_flush(nc->peer)) {
663 if (qemu_net_queue_flush(nc->incoming_queue)) {
664 /* We emptied the queue successfully, signal to the IO thread to repoll
665 * the file descriptor (for tap, for example).
669 /* Unable to empty the queue, purge remaining packets */
670 qemu_net_queue_purge(nc->incoming_queue, nc->peer);
674 void qemu_flush_queued_packets(NetClientState *nc)
676 qemu_flush_or_purge_queued_packets(nc, false);
679 static ssize_t qemu_send_packet_async_with_flags(NetClientState *sender,
681 const uint8_t *buf, int size,
682 NetPacketSent *sent_cb)
688 printf("qemu_send_packet_async:\n");
689 qemu_hexdump(stdout, "net", buf, size);
692 if (sender->link_down || !sender->peer) {
696 /* Let filters handle the packet first */
697 ret = filter_receive(sender, NET_FILTER_DIRECTION_TX,
698 sender, flags, buf, size, sent_cb);
703 ret = filter_receive(sender->peer, NET_FILTER_DIRECTION_RX,
704 sender, flags, buf, size, sent_cb);
709 queue = sender->peer->incoming_queue;
711 return qemu_net_queue_send(queue, sender, flags, buf, size, sent_cb);
714 ssize_t qemu_send_packet_async(NetClientState *sender,
715 const uint8_t *buf, int size,
716 NetPacketSent *sent_cb)
718 return qemu_send_packet_async_with_flags(sender, QEMU_NET_PACKET_FLAG_NONE,
722 ssize_t qemu_send_packet(NetClientState *nc, const uint8_t *buf, int size)
724 return qemu_send_packet_async(nc, buf, size, NULL);
727 ssize_t qemu_receive_packet(NetClientState *nc, const uint8_t *buf, int size)
729 if (!qemu_can_receive_packet(nc)) {
733 return qemu_net_queue_receive(nc->incoming_queue, buf, size);
736 ssize_t qemu_receive_packet_iov(NetClientState *nc, const struct iovec *iov,
739 if (!qemu_can_receive_packet(nc)) {
743 return qemu_net_queue_receive_iov(nc->incoming_queue, iov, iovcnt);
746 ssize_t qemu_send_packet_raw(NetClientState *nc, const uint8_t *buf, int size)
748 return qemu_send_packet_async_with_flags(nc, QEMU_NET_PACKET_FLAG_RAW,
752 static ssize_t nc_sendv_compat(NetClientState *nc, const struct iovec *iov,
753 int iovcnt, unsigned flags)
761 buffer = iov[0].iov_base;
762 offset = iov[0].iov_len;
764 offset = iov_size(iov, iovcnt);
765 if (offset > NET_BUFSIZE) {
768 buf = g_malloc(offset);
770 offset = iov_to_buf(iov, iovcnt, 0, buf, offset);
773 if (flags & QEMU_NET_PACKET_FLAG_RAW && nc->info->receive_raw) {
774 ret = nc->info->receive_raw(nc, buffer, offset);
776 ret = nc->info->receive(nc, buffer, offset);
783 static ssize_t qemu_deliver_packet_iov(NetClientState *sender,
785 const struct iovec *iov,
789 NetClientState *nc = opaque;
794 return iov_size(iov, iovcnt);
797 if (nc->receive_disabled) {
801 if (nc->info->receive_iov && !(flags & QEMU_NET_PACKET_FLAG_RAW)) {
802 ret = nc->info->receive_iov(nc, iov, iovcnt);
804 ret = nc_sendv_compat(nc, iov, iovcnt, flags);
808 nc->receive_disabled = 1;
814 ssize_t qemu_sendv_packet_async(NetClientState *sender,
815 const struct iovec *iov, int iovcnt,
816 NetPacketSent *sent_cb)
819 size_t size = iov_size(iov, iovcnt);
822 if (size > NET_BUFSIZE) {
826 if (sender->link_down || !sender->peer) {
830 /* Let filters handle the packet first */
831 ret = filter_receive_iov(sender, NET_FILTER_DIRECTION_TX, sender,
832 QEMU_NET_PACKET_FLAG_NONE, iov, iovcnt, sent_cb);
837 ret = filter_receive_iov(sender->peer, NET_FILTER_DIRECTION_RX, sender,
838 QEMU_NET_PACKET_FLAG_NONE, iov, iovcnt, sent_cb);
843 queue = sender->peer->incoming_queue;
845 return qemu_net_queue_send_iov(queue, sender,
846 QEMU_NET_PACKET_FLAG_NONE,
847 iov, iovcnt, sent_cb);
851 qemu_sendv_packet(NetClientState *nc, const struct iovec *iov, int iovcnt)
853 return qemu_sendv_packet_async(nc, iov, iovcnt, NULL);
856 NetClientState *qemu_find_netdev(const char *id)
860 QTAILQ_FOREACH(nc, &net_clients, next) {
861 if (nc->info->type == NET_CLIENT_DRIVER_NIC)
863 if (!strcmp(nc->name, id)) {
871 int qemu_find_net_clients_except(const char *id, NetClientState **ncs,
872 NetClientDriver type, int max)
877 QTAILQ_FOREACH(nc, &net_clients, next) {
878 if (nc->info->type == type) {
881 if (!id || !strcmp(nc->name, id)) {
892 static int nic_get_free_idx(void)
896 for (index = 0; index < MAX_NICS; index++)
897 if (!nd_table[index].used)
902 GPtrArray *qemu_get_nic_models(const char *device_type)
904 GPtrArray *nic_models = g_ptr_array_new();
905 GSList *list = object_class_get_list_sorted(device_type, false);
908 DeviceClass *dc = OBJECT_CLASS_CHECK(DeviceClass, list->data,
911 if (test_bit(DEVICE_CATEGORY_NETWORK, dc->categories) &&
912 dc->user_creatable) {
913 const char *name = object_class_get_name(list->data);
915 * A network device might also be something else than a NIC, see
916 * e.g. the "rocker" device. Thus we have to look for the "netdev"
917 * property, too. Unfortunately, some devices like virtio-net only
918 * create this property during instance_init, so we have to create
919 * a temporary instance here to be able to check it.
921 Object *obj = object_new_with_class(OBJECT_CLASS(dc));
922 if (object_property_find(obj, "netdev")) {
923 g_ptr_array_add(nic_models, (gpointer)name);
928 g_slist_free_1(list);
931 g_ptr_array_add(nic_models, NULL);
936 int qemu_show_nic_models(const char *arg, const char *const *models)
940 if (!arg || !is_help_option(arg)) {
944 printf("Supported NIC models:\n");
945 for (i = 0 ; models[i]; i++) {
946 printf("%s\n", models[i]);
951 void qemu_check_nic_model(NICInfo *nd, const char *model)
953 const char *models[2];
958 if (qemu_show_nic_models(nd->model, models))
960 if (qemu_find_nic_model(nd, models, model) < 0)
964 int qemu_find_nic_model(NICInfo *nd, const char * const *models,
965 const char *default_model)
970 nd->model = g_strdup(default_model);
972 for (i = 0 ; models[i]; i++) {
973 if (strcmp(nd->model, models[i]) == 0)
977 error_report("Unsupported NIC model: %s", nd->model);
981 static int net_init_nic(const Netdev *netdev, const char *name,
982 NetClientState *peer, Error **errp)
986 const NetLegacyNicOptions *nic;
988 assert(netdev->type == NET_CLIENT_DRIVER_NIC);
989 nic = &netdev->u.nic;
991 idx = nic_get_free_idx();
992 if (idx == -1 || nb_nics >= MAX_NICS) {
993 error_setg(errp, "too many NICs");
999 memset(nd, 0, sizeof(*nd));
1002 nd->netdev = qemu_find_netdev(nic->netdev);
1004 error_setg(errp, "netdev '%s' not found", nic->netdev);
1011 nd->name = g_strdup(name);
1013 nd->model = g_strdup(nic->model);
1016 nd->devaddr = g_strdup(nic->addr);
1020 net_parse_macaddr(nd->macaddr.a, nic->macaddr) < 0) {
1021 error_setg(errp, "invalid syntax for ethernet address");
1025 is_multicast_ether_addr(nd->macaddr.a)) {
1027 "NIC cannot have multicast MAC address (odd 1st byte)");
1030 qemu_macaddr_default_if_unset(&nd->macaddr);
1032 if (nic->has_vectors) {
1033 if (nic->vectors > 0x7ffffff) {
1034 error_setg(errp, "invalid # of vectors: %"PRIu32, nic->vectors);
1037 nd->nvectors = nic->vectors;
1039 nd->nvectors = DEV_NVECTORS_UNSPECIFIED;
1049 static int (* const net_client_init_fun[NET_CLIENT_DRIVER__MAX])(
1050 const Netdev *netdev,
1052 NetClientState *peer, Error **errp) = {
1053 [NET_CLIENT_DRIVER_NIC] = net_init_nic,
1055 [NET_CLIENT_DRIVER_USER] = net_init_slirp,
1057 [NET_CLIENT_DRIVER_TAP] = net_init_tap,
1058 [NET_CLIENT_DRIVER_SOCKET] = net_init_socket,
1059 [NET_CLIENT_DRIVER_STREAM] = net_init_stream,
1060 [NET_CLIENT_DRIVER_DGRAM] = net_init_dgram,
1062 [NET_CLIENT_DRIVER_VDE] = net_init_vde,
1064 #ifdef CONFIG_NETMAP
1065 [NET_CLIENT_DRIVER_NETMAP] = net_init_netmap,
1067 #ifdef CONFIG_NET_BRIDGE
1068 [NET_CLIENT_DRIVER_BRIDGE] = net_init_bridge,
1070 [NET_CLIENT_DRIVER_HUBPORT] = net_init_hubport,
1071 #ifdef CONFIG_VHOST_NET_USER
1072 [NET_CLIENT_DRIVER_VHOST_USER] = net_init_vhost_user,
1074 #ifdef CONFIG_VHOST_NET_VDPA
1075 [NET_CLIENT_DRIVER_VHOST_VDPA] = net_init_vhost_vdpa,
1077 #ifdef CONFIG_L2TPV3
1078 [NET_CLIENT_DRIVER_L2TPV3] = net_init_l2tpv3,
1081 [NET_CLIENT_DRIVER_VMNET_HOST] = net_init_vmnet_host,
1082 [NET_CLIENT_DRIVER_VMNET_SHARED] = net_init_vmnet_shared,
1083 [NET_CLIENT_DRIVER_VMNET_BRIDGED] = net_init_vmnet_bridged,
1084 #endif /* CONFIG_VMNET */
1088 static int net_client_init1(const Netdev *netdev, bool is_netdev, Error **errp)
1090 NetClientState *peer = NULL;
1094 if (netdev->type == NET_CLIENT_DRIVER_NIC ||
1095 !net_client_init_fun[netdev->type]) {
1096 error_setg(errp, "network backend '%s' is not compiled into this binary",
1097 NetClientDriver_str(netdev->type));
1101 if (netdev->type == NET_CLIENT_DRIVER_NONE) {
1102 return 0; /* nothing to do */
1104 if (netdev->type == NET_CLIENT_DRIVER_HUBPORT) {
1105 error_setg(errp, "network backend '%s' is only supported with -netdev/-nic",
1106 NetClientDriver_str(netdev->type));
1110 if (!net_client_init_fun[netdev->type]) {
1111 error_setg(errp, "network backend '%s' is not compiled into this binary",
1112 NetClientDriver_str(netdev->type));
1116 /* Do not add to a hub if it's a nic with a netdev= parameter. */
1117 if (netdev->type != NET_CLIENT_DRIVER_NIC ||
1118 !netdev->u.nic.netdev) {
1119 peer = net_hub_add_port(0, NULL, NULL);
1123 nc = qemu_find_netdev(netdev->id);
1125 error_setg(errp, "Duplicate ID '%s'", netdev->id);
1129 if (net_client_init_fun[netdev->type](netdev, netdev->id, peer, errp) < 0) {
1130 /* FIXME drop when all init functions store an Error */
1131 if (errp && !*errp) {
1132 error_setg(errp, "Device '%s' could not be initialized",
1133 NetClientDriver_str(netdev->type));
1139 nc = qemu_find_netdev(netdev->id);
1141 nc->is_netdev = true;
1147 void show_netdevs(void)
1150 const char *available_netdevs[] = {
1159 #ifdef CONFIG_L2TPV3
1165 #ifdef CONFIG_NET_BRIDGE
1168 #ifdef CONFIG_NETMAP
1174 #ifdef CONFIG_VHOST_VDPA
1184 qemu_printf("Available netdev backend types:\n");
1185 for (idx = 0; idx < ARRAY_SIZE(available_netdevs); idx++) {
1186 qemu_printf("%s\n", available_netdevs[idx]);
1190 static int net_client_init(QemuOpts *opts, bool is_netdev, Error **errp)
1192 gchar **substrings = NULL;
1193 Netdev *object = NULL;
1195 Visitor *v = opts_visitor_new(opts);
1197 /* Parse convenience option format ip6-net=fec0::0[/64] */
1198 const char *ip6_net = qemu_opt_get(opts, "ipv6-net");
1202 unsigned long prefix_len = 64; /* Default 64bit prefix length. */
1204 substrings = g_strsplit(ip6_net, "/", 2);
1205 if (!substrings || !substrings[0]) {
1206 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "ipv6-net",
1207 "a valid IPv6 prefix");
1211 prefix_addr = substrings[0];
1213 /* Handle user-specified prefix length. */
1214 if (substrings[1] &&
1215 qemu_strtoul(substrings[1], NULL, 10, &prefix_len))
1217 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
1218 "ipv6-prefixlen", "a number");
1222 qemu_opt_set(opts, "ipv6-prefix", prefix_addr, &error_abort);
1223 qemu_opt_set_number(opts, "ipv6-prefixlen", prefix_len,
1225 qemu_opt_unset(opts, "ipv6-net");
1228 /* Create an ID for -net if the user did not specify one */
1229 if (!is_netdev && !qemu_opts_id(opts)) {
1230 qemu_opts_set_id(opts, id_generate(ID_NET));
1233 if (visit_type_Netdev(v, NULL, &object, errp)) {
1234 ret = net_client_init1(object, is_netdev, errp);
1237 qapi_free_Netdev(object);
1240 g_strfreev(substrings);
1245 void netdev_add(QemuOpts *opts, Error **errp)
1247 net_client_init(opts, true, errp);
1250 void qmp_netdev_add(Netdev *netdev, Error **errp)
1252 if (!id_wellformed(netdev->id)) {
1253 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "id", "an identifier");
1257 net_client_init1(netdev, true, errp);
1260 void qmp_netdev_del(const char *id, Error **errp)
1265 nc = qemu_find_netdev(id);
1267 error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
1268 "Device '%s' not found", id);
1272 if (!nc->is_netdev) {
1273 error_setg(errp, "Device '%s' is not a netdev", id);
1277 qemu_del_net_client(nc);
1280 * Wart: we need to delete the QemuOpts associated with netdevs
1281 * created via CLI or HMP, to avoid bogus "Duplicate ID" errors in
1284 opts = qemu_opts_find(qemu_find_opts("netdev"), id);
1286 qemu_opts_del(opts);
1290 static void netfilter_print_info(Monitor *mon, NetFilterState *nf)
1293 ObjectProperty *prop;
1294 ObjectPropertyIterator iter;
1297 /* generate info str */
1298 object_property_iter_init(&iter, OBJECT(nf));
1299 while ((prop = object_property_iter_next(&iter))) {
1300 if (!strcmp(prop->name, "type")) {
1303 v = string_output_visitor_new(false, &str);
1304 object_property_get(OBJECT(nf), prop->name, v, NULL);
1305 visit_complete(v, &str);
1307 monitor_printf(mon, ",%s=%s", prop->name, str);
1310 monitor_printf(mon, "\n");
1313 void print_net_client(Monitor *mon, NetClientState *nc)
1317 monitor_printf(mon, "%s: index=%d,type=%s,%s\n", nc->name,
1319 NetClientDriver_str(nc->info->type),
1321 if (!QTAILQ_EMPTY(&nc->filters)) {
1322 monitor_printf(mon, "filters:\n");
1324 QTAILQ_FOREACH(nf, &nc->filters, next) {
1325 monitor_printf(mon, " - %s: type=%s",
1326 object_get_canonical_path_component(OBJECT(nf)),
1327 object_get_typename(OBJECT(nf)));
1328 netfilter_print_info(mon, nf);
1332 RxFilterInfoList *qmp_query_rx_filter(const char *name, Error **errp)
1335 RxFilterInfoList *filter_list = NULL, **tail = &filter_list;
1337 QTAILQ_FOREACH(nc, &net_clients, next) {
1340 if (name && strcmp(nc->name, name) != 0) {
1344 /* only query rx-filter information of NIC */
1345 if (nc->info->type != NET_CLIENT_DRIVER_NIC) {
1347 error_setg(errp, "net client(%s) isn't a NIC", name);
1348 assert(!filter_list);
1354 /* only query information on queue 0 since the info is per nic,
1357 if (nc->queue_index != 0)
1360 if (nc->info->query_rx_filter) {
1361 info = nc->info->query_rx_filter(nc);
1362 QAPI_LIST_APPEND(tail, info);
1364 error_setg(errp, "net client(%s) doesn't support"
1365 " rx-filter querying", name);
1366 assert(!filter_list);
1375 if (filter_list == NULL && name) {
1376 error_setg(errp, "invalid net client name: %s", name);
1382 void colo_notify_filters_event(int event, Error **errp)
1386 NetFilterClass *nfc = NULL;
1387 Error *local_err = NULL;
1389 QTAILQ_FOREACH(nc, &net_clients, next) {
1390 QTAILQ_FOREACH(nf, &nc->filters, next) {
1391 nfc = NETFILTER_GET_CLASS(OBJECT(nf));
1392 nfc->handle_event(nf, event, &local_err);
1394 error_propagate(errp, local_err);
1401 void qmp_set_link(const char *name, bool up, Error **errp)
1403 NetClientState *ncs[MAX_QUEUE_NUM];
1407 queues = qemu_find_net_clients_except(name, ncs,
1408 NET_CLIENT_DRIVER__MAX,
1412 error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
1413 "Device '%s' not found", name);
1418 for (i = 0; i < queues; i++) {
1419 ncs[i]->link_down = !up;
1422 if (nc->info->link_status_changed) {
1423 nc->info->link_status_changed(nc);
1427 /* Change peer link only if the peer is NIC and then notify peer.
1428 * If the peer is a HUBPORT or a backend, we do not change the
1431 * This behavior is compatible with qemu hubs where there could be
1432 * multiple clients that can still communicate with each other in
1433 * disconnected mode. For now maintain this compatibility.
1435 if (nc->peer->info->type == NET_CLIENT_DRIVER_NIC) {
1436 for (i = 0; i < queues; i++) {
1437 ncs[i]->peer->link_down = !up;
1440 if (nc->peer->info->link_status_changed) {
1441 nc->peer->info->link_status_changed(nc->peer);
1446 static void net_vm_change_state_handler(void *opaque, bool running,
1450 NetClientState *tmp;
1452 QTAILQ_FOREACH_SAFE(nc, &net_clients, next, tmp) {
1454 /* Flush queued packets and wake up backends. */
1455 if (nc->peer && qemu_can_send_packet(nc)) {
1456 qemu_flush_queued_packets(nc->peer);
1459 /* Complete all queued packets, to guarantee we don't modify
1460 * state later when VM is not running.
1462 qemu_flush_or_purge_queued_packets(nc, true);
1467 void net_cleanup(void)
1471 /*cleanup colo compare module for COLO*/
1472 colo_compare_cleanup();
1474 /* We may del multiple entries during qemu_del_net_client(),
1475 * so QTAILQ_FOREACH_SAFE() is also not safe here.
1477 while (!QTAILQ_EMPTY(&net_clients)) {
1478 nc = QTAILQ_FIRST(&net_clients);
1479 if (nc->info->type == NET_CLIENT_DRIVER_NIC) {
1480 qemu_del_nic(qemu_get_nic(nc));
1482 qemu_del_net_client(nc);
1486 qemu_del_vm_change_state_handler(net_change_state_entry);
1489 void net_check_clients(void)
1494 net_hub_check_clients();
1496 QTAILQ_FOREACH(nc, &net_clients, next) {
1498 warn_report("%s %s has no peer",
1499 nc->info->type == NET_CLIENT_DRIVER_NIC
1505 /* Check that all NICs requested via -net nic actually got created.
1506 * NICs created via -device don't need to be checked here because
1507 * they are always instantiated.
1509 for (i = 0; i < MAX_NICS; i++) {
1510 NICInfo *nd = &nd_table[i];
1511 if (nd->used && !nd->instantiated) {
1512 warn_report("requested NIC (%s, model %s) "
1513 "was not created (not supported by this machine?)",
1514 nd->name ? nd->name : "anonymous",
1515 nd->model ? nd->model : "unspecified");
1520 static int net_init_client(void *dummy, QemuOpts *opts, Error **errp)
1522 return net_client_init(opts, false, errp);
1525 static int net_init_netdev(void *dummy, QemuOpts *opts, Error **errp)
1527 const char *type = qemu_opt_get(opts, "type");
1529 if (type && is_help_option(type)) {
1533 return net_client_init(opts, true, errp);
1536 /* For the convenience "--nic" parameter */
1537 static int net_param_nic(void *dummy, QemuOpts *opts, Error **errp)
1544 type = qemu_opt_get(opts, "type");
1545 if (type && g_str_equal(type, "none")) {
1546 return 0; /* Nothing to do, default_net is cleared in vl.c */
1549 idx = nic_get_free_idx();
1550 if (idx == -1 || nb_nics >= MAX_NICS) {
1551 error_setg(errp, "no more on-board/default NIC slots available");
1556 qemu_opt_set(opts, "type", "user", &error_abort);
1559 ni = &nd_table[idx];
1560 memset(ni, 0, sizeof(*ni));
1561 ni->model = qemu_opt_get_del(opts, "model");
1563 /* Create an ID if the user did not specify one */
1564 nd_id = g_strdup(qemu_opts_id(opts));
1566 nd_id = id_generate(ID_NET);
1567 qemu_opts_set_id(opts, nd_id);
1570 /* Handle MAC address */
1571 mac = qemu_opt_get_del(opts, "mac");
1573 ret = net_parse_macaddr(ni->macaddr.a, mac);
1576 error_setg(errp, "invalid syntax for ethernet address");
1579 if (is_multicast_ether_addr(ni->macaddr.a)) {
1580 error_setg(errp, "NIC cannot have multicast MAC address");
1585 qemu_macaddr_default_if_unset(&ni->macaddr);
1587 ret = net_client_init(opts, true, errp);
1589 ni->netdev = qemu_find_netdev(nd_id);
1599 static void netdev_init_modern(void)
1601 while (!QSIMPLEQ_EMPTY(&nd_queue)) {
1602 NetdevQueueEntry *nd = QSIMPLEQ_FIRST(&nd_queue);
1604 QSIMPLEQ_REMOVE_HEAD(&nd_queue, entry);
1605 loc_push_restore(&nd->loc);
1606 net_client_init1(nd->nd, true, &error_fatal);
1608 qapi_free_Netdev(nd->nd);
1613 void net_init_clients(void)
1615 net_change_state_entry =
1616 qemu_add_vm_change_state_handler(net_vm_change_state_handler, NULL);
1618 QTAILQ_INIT(&net_clients);
1620 netdev_init_modern();
1622 qemu_opts_foreach(qemu_find_opts("netdev"), net_init_netdev, NULL,
1625 qemu_opts_foreach(qemu_find_opts("nic"), net_param_nic, NULL,
1628 qemu_opts_foreach(qemu_find_opts("net"), net_init_client, NULL,
1633 * Does this -netdev argument use modern rather than traditional syntax?
1634 * Modern syntax is to be parsed with netdev_parse_modern().
1635 * Traditional syntax is to be parsed with net_client_parse().
1637 bool netdev_is_modern(const char *optarg)
1642 static QemuOptsList dummy_opts = {
1644 .implied_opt_name = "type",
1645 .head = QTAILQ_HEAD_INITIALIZER(dummy_opts.head),
1649 if (optarg[0] == '{') {
1650 /* This is JSON, which means it's modern syntax */
1654 opts = qemu_opts_create(&dummy_opts, NULL, false, &error_abort);
1655 qemu_opts_do_parse(opts, optarg, dummy_opts.implied_opt_name,
1657 type = qemu_opt_get(opts, "type");
1658 is_modern = !g_strcmp0(type, "stream") || !g_strcmp0(type, "dgram");
1660 qemu_opts_reset(&dummy_opts);
1666 * netdev_parse_modern() uses modern, more expressive syntax than
1667 * net_client_parse(), but supports only the -netdev option.
1668 * netdev_parse_modern() appends to @nd_queue, whereas net_client_parse()
1669 * appends to @qemu_netdev_opts.
1671 void netdev_parse_modern(const char *optarg)
1674 NetdevQueueEntry *nd;
1676 v = qobject_input_visitor_new_str(optarg, "type", &error_fatal);
1677 nd = g_new(NetdevQueueEntry, 1);
1678 visit_type_Netdev(v, NULL, &nd->nd, &error_fatal);
1682 QSIMPLEQ_INSERT_TAIL(&nd_queue, nd, entry);
1685 void net_client_parse(QemuOptsList *opts_list, const char *optarg)
1687 if (!qemu_opts_parse_noisily(opts_list, optarg, true)) {
1694 uint32_t net_crc32(const uint8_t *p, int len)
1701 for (i = 0; i < len; i++) {
1703 for (j = 0; j < 8; j++) {
1704 carry = ((crc & 0x80000000L) ? 1 : 0) ^ (b & 0x01);
1708 crc = ((crc ^ POLYNOMIAL_BE) | carry);
1716 uint32_t net_crc32_le(const uint8_t *p, int len)
1723 for (i = 0; i < len; i++) {
1725 for (j = 0; j < 8; j++) {
1726 carry = (crc & 0x1) ^ (b & 0x01);
1730 crc ^= POLYNOMIAL_LE;
1738 QemuOptsList qemu_netdev_opts = {
1740 .implied_opt_name = "type",
1741 .head = QTAILQ_HEAD_INITIALIZER(qemu_netdev_opts.head),
1744 * no elements => accept any params
1745 * validation will happen later
1747 { /* end of list */ }
1751 QemuOptsList qemu_nic_opts = {
1753 .implied_opt_name = "type",
1754 .head = QTAILQ_HEAD_INITIALIZER(qemu_nic_opts.head),
1757 * no elements => accept any params
1758 * validation will happen later
1760 { /* end of list */ }
1764 QemuOptsList qemu_net_opts = {
1766 .implied_opt_name = "type",
1767 .head = QTAILQ_HEAD_INITIALIZER(qemu_net_opts.head),
1770 * no elements => accept any params
1771 * validation will happen later
1773 { /* end of list */ }
1777 void net_socket_rs_init(SocketReadState *rs,
1778 SocketReadStateFinalize *finalize,
1782 rs->vnet_hdr = vnet_hdr;
1785 rs->vnet_hdr_len = 0;
1786 memset(rs->buf, 0, sizeof(rs->buf));
1787 rs->finalize = finalize;
1795 int net_fill_rstate(SocketReadState *rs, const uint8_t *buf, int size)
1800 /* Reassemble a packet from the network.
1801 * 0 = getting length.
1802 * 1 = getting vnet header length.
1805 switch (rs->state) {
1811 memcpy(rs->buf + rs->index, buf, l);
1815 if (rs->index == 4) {
1817 rs->packet_len = ntohl(*(uint32_t *)rs->buf);
1823 rs->vnet_hdr_len = 0;
1832 memcpy(rs->buf + rs->index, buf, l);
1836 if (rs->index == 4) {
1837 /* got vnet header length */
1838 rs->vnet_hdr_len = ntohl(*(uint32_t *)rs->buf);
1844 l = rs->packet_len - rs->index;
1848 if (rs->index + l <= sizeof(rs->buf)) {
1849 memcpy(rs->buf + rs->index, buf, l);
1851 fprintf(stderr, "serious error: oversized packet received,"
1852 "connection terminated.\n");
1853 rs->index = rs->state = 0;
1860 if (rs->index >= rs->packet_len) {
1863 assert(rs->finalize);