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"
26 #include "qemu-common.h"
31 #include "hw/qdev-properties.h"
32 #include "net/slirp.h"
36 #include "monitor/monitor.h"
37 #include "qemu/help_option.h"
38 #include "qapi/qapi-commands-net.h"
39 #include "qapi/qapi-visit-net.h"
40 #include "qapi/qmp/qdict.h"
41 #include "qapi/qmp/qerror.h"
42 #include "qemu/error-report.h"
43 #include "qemu/sockets.h"
44 #include "qemu/cutils.h"
45 #include "qemu/config-file.h"
46 #include "qemu/ctype.h"
49 #include "qemu/qemu-print.h"
50 #include "qemu/main-loop.h"
51 #include "qemu/option.h"
52 #include "qapi/error.h"
53 #include "qapi/opts-visitor.h"
54 #include "sysemu/sysemu.h"
55 #include "sysemu/runstate.h"
56 #include "sysemu/sysemu.h"
57 #include "net/filter.h"
58 #include "qapi/string-output-visitor.h"
60 /* Net bridge is currently not supported for W32. */
62 # define CONFIG_NET_BRIDGE
65 static VMChangeStateEntry *net_change_state_entry;
66 static QTAILQ_HEAD(, NetClientState) net_clients;
68 /***********************************************************/
69 /* network device redirectors */
71 int parse_host_port(struct sockaddr_in *saddr, const char *str,
76 const char *addr, *p, *r;
79 substrings = g_strsplit(str, ":", 2);
80 if (!substrings || !substrings[0] || !substrings[1]) {
81 error_setg(errp, "host address '%s' doesn't contain ':' "
82 "separating host from port", str);
90 saddr->sin_family = AF_INET;
91 if (addr[0] == '\0') {
92 saddr->sin_addr.s_addr = 0;
94 if (qemu_isdigit(addr[0])) {
95 if (!inet_aton(addr, &saddr->sin_addr)) {
96 error_setg(errp, "host address '%s' is not a valid "
97 "IPv4 address", addr);
102 he = gethostbyname(addr);
104 error_setg(errp, "can't resolve host address '%s'", addr);
108 saddr->sin_addr = *(struct in_addr *)he->h_addr;
111 port = strtol(p, (char **)&r, 0);
113 error_setg(errp, "port number '%s' is invalid", p);
117 saddr->sin_port = htons(port);
120 g_strfreev(substrings);
124 char *qemu_mac_strdup_printf(const uint8_t *macaddr)
126 return g_strdup_printf("%.2x:%.2x:%.2x:%.2x:%.2x:%.2x",
127 macaddr[0], macaddr[1], macaddr[2],
128 macaddr[3], macaddr[4], macaddr[5]);
131 void qemu_format_nic_info_str(NetClientState *nc, uint8_t macaddr[6])
133 snprintf(nc->info_str, sizeof(nc->info_str),
134 "model=%s,macaddr=%02x:%02x:%02x:%02x:%02x:%02x",
136 macaddr[0], macaddr[1], macaddr[2],
137 macaddr[3], macaddr[4], macaddr[5]);
140 static int mac_table[256] = {0};
142 static void qemu_macaddr_set_used(MACAddr *macaddr)
146 for (index = 0x56; index < 0xFF; index++) {
147 if (macaddr->a[5] == index) {
153 static void qemu_macaddr_set_free(MACAddr *macaddr)
156 static const MACAddr base = { .a = { 0x52, 0x54, 0x00, 0x12, 0x34, 0 } };
158 if (memcmp(macaddr->a, &base.a, (sizeof(base.a) - 1)) != 0) {
161 for (index = 0x56; index < 0xFF; index++) {
162 if (macaddr->a[5] == index) {
168 static int qemu_macaddr_get_free(void)
172 for (index = 0x56; index < 0xFF; index++) {
173 if (mac_table[index] == 0) {
181 void qemu_macaddr_default_if_unset(MACAddr *macaddr)
183 static const MACAddr zero = { .a = { 0,0,0,0,0,0 } };
184 static const MACAddr base = { .a = { 0x52, 0x54, 0x00, 0x12, 0x34, 0 } };
186 if (memcmp(macaddr, &zero, sizeof(zero)) != 0) {
187 if (memcmp(macaddr->a, &base.a, (sizeof(base.a) - 1)) != 0) {
190 qemu_macaddr_set_used(macaddr);
195 macaddr->a[0] = 0x52;
196 macaddr->a[1] = 0x54;
197 macaddr->a[2] = 0x00;
198 macaddr->a[3] = 0x12;
199 macaddr->a[4] = 0x34;
200 macaddr->a[5] = qemu_macaddr_get_free();
201 qemu_macaddr_set_used(macaddr);
205 * Generate a name for net client
207 * Only net clients created with the legacy -net option and NICs need this.
209 static char *assign_name(NetClientState *nc1, const char *model)
214 QTAILQ_FOREACH(nc, &net_clients, next) {
218 if (strcmp(nc->model, model) == 0) {
223 return g_strdup_printf("%s.%d", model, id);
226 static void qemu_net_client_destructor(NetClientState *nc)
230 static ssize_t qemu_deliver_packet_iov(NetClientState *sender,
232 const struct iovec *iov,
236 static void qemu_net_client_setup(NetClientState *nc,
238 NetClientState *peer,
241 NetClientDestructor *destructor)
244 nc->model = g_strdup(model);
246 nc->name = g_strdup(name);
248 nc->name = assign_name(nc, model);
256 QTAILQ_INSERT_TAIL(&net_clients, nc, next);
258 nc->incoming_queue = qemu_new_net_queue(qemu_deliver_packet_iov, nc);
259 nc->destructor = destructor;
260 QTAILQ_INIT(&nc->filters);
263 NetClientState *qemu_new_net_client(NetClientInfo *info,
264 NetClientState *peer,
270 assert(info->size >= sizeof(NetClientState));
272 nc = g_malloc0(info->size);
273 qemu_net_client_setup(nc, info, peer, model, name,
274 qemu_net_client_destructor);
279 NICState *qemu_new_nic(NetClientInfo *info,
285 NetClientState **peers = conf->peers.ncs;
287 int i, queues = MAX(1, conf->peers.queues);
289 assert(info->type == NET_CLIENT_DRIVER_NIC);
290 assert(info->size >= sizeof(NICState));
292 nic = g_malloc0(info->size + sizeof(NetClientState) * queues);
293 nic->ncs = (void *)nic + info->size;
295 nic->opaque = opaque;
297 for (i = 0; i < queues; i++) {
298 qemu_net_client_setup(&nic->ncs[i], info, peers[i], model, name,
300 nic->ncs[i].queue_index = i;
306 NetClientState *qemu_get_subqueue(NICState *nic, int queue_index)
308 return nic->ncs + queue_index;
311 NetClientState *qemu_get_queue(NICState *nic)
313 return qemu_get_subqueue(nic, 0);
316 NICState *qemu_get_nic(NetClientState *nc)
318 NetClientState *nc0 = nc - nc->queue_index;
320 return (NICState *)((void *)nc0 - nc->info->size);
323 void *qemu_get_nic_opaque(NetClientState *nc)
325 NICState *nic = qemu_get_nic(nc);
330 NetClientState *qemu_get_peer(NetClientState *nc, int queue_index)
333 NetClientState *ncs = nc + queue_index;
337 static void qemu_cleanup_net_client(NetClientState *nc)
339 QTAILQ_REMOVE(&net_clients, nc, next);
341 if (nc->info->cleanup) {
342 nc->info->cleanup(nc);
346 static void qemu_free_net_client(NetClientState *nc)
348 if (nc->incoming_queue) {
349 qemu_del_net_queue(nc->incoming_queue);
352 nc->peer->peer = NULL;
356 if (nc->destructor) {
361 void qemu_del_net_client(NetClientState *nc)
363 NetClientState *ncs[MAX_QUEUE_NUM];
365 NetFilterState *nf, *next;
367 assert(nc->info->type != NET_CLIENT_DRIVER_NIC);
369 /* If the NetClientState belongs to a multiqueue backend, we will change all
370 * other NetClientStates also.
372 queues = qemu_find_net_clients_except(nc->name, ncs,
373 NET_CLIENT_DRIVER_NIC,
377 QTAILQ_FOREACH_SAFE(nf, &nc->filters, next, next) {
378 object_unparent(OBJECT(nf));
381 /* If there is a peer NIC, delete and cleanup client, but do not free. */
382 if (nc->peer && nc->peer->info->type == NET_CLIENT_DRIVER_NIC) {
383 NICState *nic = qemu_get_nic(nc->peer);
384 if (nic->peer_deleted) {
387 nic->peer_deleted = true;
389 for (i = 0; i < queues; i++) {
390 ncs[i]->peer->link_down = true;
393 if (nc->peer->info->link_status_changed) {
394 nc->peer->info->link_status_changed(nc->peer);
397 for (i = 0; i < queues; i++) {
398 qemu_cleanup_net_client(ncs[i]);
404 for (i = 0; i < queues; i++) {
405 qemu_cleanup_net_client(ncs[i]);
406 qemu_free_net_client(ncs[i]);
410 void qemu_del_nic(NICState *nic)
412 int i, queues = MAX(nic->conf->peers.queues, 1);
414 qemu_macaddr_set_free(&nic->conf->macaddr);
416 for (i = 0; i < queues; i++) {
417 NetClientState *nc = qemu_get_subqueue(nic, i);
418 /* If this is a peer NIC and peer has already been deleted, free it now. */
419 if (nic->peer_deleted) {
420 qemu_free_net_client(nc->peer);
421 } else if (nc->peer) {
422 /* if there are RX packets pending, complete them */
423 qemu_purge_queued_packets(nc->peer);
427 for (i = queues - 1; i >= 0; i--) {
428 NetClientState *nc = qemu_get_subqueue(nic, i);
430 qemu_cleanup_net_client(nc);
431 qemu_free_net_client(nc);
437 void qemu_foreach_nic(qemu_nic_foreach func, void *opaque)
441 QTAILQ_FOREACH(nc, &net_clients, next) {
442 if (nc->info->type == NET_CLIENT_DRIVER_NIC) {
443 if (nc->queue_index == 0) {
444 func(qemu_get_nic(nc), opaque);
450 bool qemu_has_ufo(NetClientState *nc)
452 if (!nc || !nc->info->has_ufo) {
456 return nc->info->has_ufo(nc);
459 bool qemu_has_vnet_hdr(NetClientState *nc)
461 if (!nc || !nc->info->has_vnet_hdr) {
465 return nc->info->has_vnet_hdr(nc);
468 bool qemu_has_vnet_hdr_len(NetClientState *nc, int len)
470 if (!nc || !nc->info->has_vnet_hdr_len) {
474 return nc->info->has_vnet_hdr_len(nc, len);
477 void qemu_using_vnet_hdr(NetClientState *nc, bool enable)
479 if (!nc || !nc->info->using_vnet_hdr) {
483 nc->info->using_vnet_hdr(nc, enable);
486 void qemu_set_offload(NetClientState *nc, int csum, int tso4, int tso6,
489 if (!nc || !nc->info->set_offload) {
493 nc->info->set_offload(nc, csum, tso4, tso6, ecn, ufo);
496 void qemu_set_vnet_hdr_len(NetClientState *nc, int len)
498 if (!nc || !nc->info->set_vnet_hdr_len) {
502 nc->vnet_hdr_len = len;
503 nc->info->set_vnet_hdr_len(nc, len);
506 int qemu_set_vnet_le(NetClientState *nc, bool is_le)
508 #ifdef HOST_WORDS_BIGENDIAN
509 if (!nc || !nc->info->set_vnet_le) {
513 return nc->info->set_vnet_le(nc, is_le);
519 int qemu_set_vnet_be(NetClientState *nc, bool is_be)
521 #ifdef HOST_WORDS_BIGENDIAN
524 if (!nc || !nc->info->set_vnet_be) {
528 return nc->info->set_vnet_be(nc, is_be);
532 int qemu_can_receive_packet(NetClientState *nc)
534 if (nc->receive_disabled) {
536 } else if (nc->info->can_receive &&
537 !nc->info->can_receive(nc)) {
543 int qemu_can_send_packet(NetClientState *sender)
545 int vm_running = runstate_is_running();
555 return qemu_can_receive_packet(sender->peer);
558 static ssize_t filter_receive_iov(NetClientState *nc,
559 NetFilterDirection direction,
560 NetClientState *sender,
562 const struct iovec *iov,
564 NetPacketSent *sent_cb)
567 NetFilterState *nf = NULL;
569 if (direction == NET_FILTER_DIRECTION_TX) {
570 QTAILQ_FOREACH(nf, &nc->filters, next) {
571 ret = qemu_netfilter_receive(nf, direction, sender, flags, iov,
578 QTAILQ_FOREACH_REVERSE(nf, &nc->filters, next) {
579 ret = qemu_netfilter_receive(nf, direction, sender, flags, iov,
590 static ssize_t filter_receive(NetClientState *nc,
591 NetFilterDirection direction,
592 NetClientState *sender,
596 NetPacketSent *sent_cb)
599 .iov_base = (void *)data,
603 return filter_receive_iov(nc, direction, sender, flags, &iov, 1, sent_cb);
606 void qemu_purge_queued_packets(NetClientState *nc)
612 qemu_net_queue_purge(nc->peer->incoming_queue, nc);
615 void qemu_flush_or_purge_queued_packets(NetClientState *nc, bool purge)
617 nc->receive_disabled = 0;
619 if (nc->peer && nc->peer->info->type == NET_CLIENT_DRIVER_HUBPORT) {
620 if (net_hub_flush(nc->peer)) {
624 if (qemu_net_queue_flush(nc->incoming_queue)) {
625 /* We emptied the queue successfully, signal to the IO thread to repoll
626 * the file descriptor (for tap, for example).
630 /* Unable to empty the queue, purge remaining packets */
631 qemu_net_queue_purge(nc->incoming_queue, nc->peer);
635 void qemu_flush_queued_packets(NetClientState *nc)
637 qemu_flush_or_purge_queued_packets(nc, false);
640 static ssize_t qemu_send_packet_async_with_flags(NetClientState *sender,
642 const uint8_t *buf, int size,
643 NetPacketSent *sent_cb)
649 printf("qemu_send_packet_async:\n");
650 qemu_hexdump(stdout, "net", buf, size);
653 if (sender->link_down || !sender->peer) {
657 /* Let filters handle the packet first */
658 ret = filter_receive(sender, NET_FILTER_DIRECTION_TX,
659 sender, flags, buf, size, sent_cb);
664 ret = filter_receive(sender->peer, NET_FILTER_DIRECTION_RX,
665 sender, flags, buf, size, sent_cb);
670 queue = sender->peer->incoming_queue;
672 return qemu_net_queue_send(queue, sender, flags, buf, size, sent_cb);
675 ssize_t qemu_send_packet_async(NetClientState *sender,
676 const uint8_t *buf, int size,
677 NetPacketSent *sent_cb)
679 return qemu_send_packet_async_with_flags(sender, QEMU_NET_PACKET_FLAG_NONE,
683 ssize_t qemu_send_packet(NetClientState *nc, const uint8_t *buf, int size)
685 return qemu_send_packet_async(nc, buf, size, NULL);
688 ssize_t qemu_receive_packet(NetClientState *nc, const uint8_t *buf, int size)
690 if (!qemu_can_receive_packet(nc)) {
694 return qemu_net_queue_receive(nc->incoming_queue, buf, size);
697 ssize_t qemu_receive_packet_iov(NetClientState *nc, const struct iovec *iov,
700 if (!qemu_can_receive_packet(nc)) {
704 return qemu_net_queue_receive_iov(nc->incoming_queue, iov, iovcnt);
707 ssize_t qemu_send_packet_raw(NetClientState *nc, const uint8_t *buf, int size)
709 return qemu_send_packet_async_with_flags(nc, QEMU_NET_PACKET_FLAG_RAW,
713 static ssize_t nc_sendv_compat(NetClientState *nc, const struct iovec *iov,
714 int iovcnt, unsigned flags)
722 buffer = iov[0].iov_base;
723 offset = iov[0].iov_len;
725 offset = iov_size(iov, iovcnt);
726 if (offset > NET_BUFSIZE) {
729 buf = g_malloc(offset);
731 offset = iov_to_buf(iov, iovcnt, 0, buf, offset);
734 if (flags & QEMU_NET_PACKET_FLAG_RAW && nc->info->receive_raw) {
735 ret = nc->info->receive_raw(nc, buffer, offset);
737 ret = nc->info->receive(nc, buffer, offset);
744 static ssize_t qemu_deliver_packet_iov(NetClientState *sender,
746 const struct iovec *iov,
750 NetClientState *nc = opaque;
755 return iov_size(iov, iovcnt);
758 if (nc->receive_disabled) {
762 if (nc->info->receive_iov && !(flags & QEMU_NET_PACKET_FLAG_RAW)) {
763 ret = nc->info->receive_iov(nc, iov, iovcnt);
765 ret = nc_sendv_compat(nc, iov, iovcnt, flags);
769 nc->receive_disabled = 1;
775 ssize_t qemu_sendv_packet_async(NetClientState *sender,
776 const struct iovec *iov, int iovcnt,
777 NetPacketSent *sent_cb)
780 size_t size = iov_size(iov, iovcnt);
783 if (size > NET_BUFSIZE) {
787 if (sender->link_down || !sender->peer) {
791 /* Let filters handle the packet first */
792 ret = filter_receive_iov(sender, NET_FILTER_DIRECTION_TX, sender,
793 QEMU_NET_PACKET_FLAG_NONE, iov, iovcnt, sent_cb);
798 ret = filter_receive_iov(sender->peer, NET_FILTER_DIRECTION_RX, sender,
799 QEMU_NET_PACKET_FLAG_NONE, iov, iovcnt, sent_cb);
804 queue = sender->peer->incoming_queue;
806 return qemu_net_queue_send_iov(queue, sender,
807 QEMU_NET_PACKET_FLAG_NONE,
808 iov, iovcnt, sent_cb);
812 qemu_sendv_packet(NetClientState *nc, const struct iovec *iov, int iovcnt)
814 return qemu_sendv_packet_async(nc, iov, iovcnt, NULL);
817 NetClientState *qemu_find_netdev(const char *id)
821 QTAILQ_FOREACH(nc, &net_clients, next) {
822 if (nc->info->type == NET_CLIENT_DRIVER_NIC)
824 if (!strcmp(nc->name, id)) {
832 int qemu_find_net_clients_except(const char *id, NetClientState **ncs,
833 NetClientDriver type, int max)
838 QTAILQ_FOREACH(nc, &net_clients, next) {
839 if (nc->info->type == type) {
842 if (!id || !strcmp(nc->name, id)) {
853 static int nic_get_free_idx(void)
857 for (index = 0; index < MAX_NICS; index++)
858 if (!nd_table[index].used)
863 int qemu_show_nic_models(const char *arg, const char *const *models)
867 if (!arg || !is_help_option(arg)) {
871 printf("Supported NIC models:\n");
872 for (i = 0 ; models[i]; i++) {
873 printf("%s\n", models[i]);
878 void qemu_check_nic_model(NICInfo *nd, const char *model)
880 const char *models[2];
885 if (qemu_show_nic_models(nd->model, models))
887 if (qemu_find_nic_model(nd, models, model) < 0)
891 int qemu_find_nic_model(NICInfo *nd, const char * const *models,
892 const char *default_model)
897 nd->model = g_strdup(default_model);
899 for (i = 0 ; models[i]; i++) {
900 if (strcmp(nd->model, models[i]) == 0)
904 error_report("Unsupported NIC model: %s", nd->model);
908 static int net_init_nic(const Netdev *netdev, const char *name,
909 NetClientState *peer, Error **errp)
913 const NetLegacyNicOptions *nic;
915 assert(netdev->type == NET_CLIENT_DRIVER_NIC);
916 nic = &netdev->u.nic;
918 idx = nic_get_free_idx();
919 if (idx == -1 || nb_nics >= MAX_NICS) {
920 error_setg(errp, "too many NICs");
926 memset(nd, 0, sizeof(*nd));
928 if (nic->has_netdev) {
929 nd->netdev = qemu_find_netdev(nic->netdev);
931 error_setg(errp, "netdev '%s' not found", nic->netdev);
938 nd->name = g_strdup(name);
939 if (nic->has_model) {
940 nd->model = g_strdup(nic->model);
943 nd->devaddr = g_strdup(nic->addr);
946 if (nic->has_macaddr &&
947 net_parse_macaddr(nd->macaddr.a, nic->macaddr) < 0) {
948 error_setg(errp, "invalid syntax for ethernet address");
951 if (nic->has_macaddr &&
952 is_multicast_ether_addr(nd->macaddr.a)) {
954 "NIC cannot have multicast MAC address (odd 1st byte)");
957 qemu_macaddr_default_if_unset(&nd->macaddr);
959 if (nic->has_vectors) {
960 if (nic->vectors > 0x7ffffff) {
961 error_setg(errp, "invalid # of vectors: %"PRIu32, nic->vectors);
964 nd->nvectors = nic->vectors;
966 nd->nvectors = DEV_NVECTORS_UNSPECIFIED;
976 static int (* const net_client_init_fun[NET_CLIENT_DRIVER__MAX])(
977 const Netdev *netdev,
979 NetClientState *peer, Error **errp) = {
980 [NET_CLIENT_DRIVER_NIC] = net_init_nic,
982 [NET_CLIENT_DRIVER_USER] = net_init_slirp,
984 [NET_CLIENT_DRIVER_TAP] = net_init_tap,
985 [NET_CLIENT_DRIVER_SOCKET] = net_init_socket,
987 [NET_CLIENT_DRIVER_VDE] = net_init_vde,
990 [NET_CLIENT_DRIVER_NETMAP] = net_init_netmap,
992 #ifdef CONFIG_NET_BRIDGE
993 [NET_CLIENT_DRIVER_BRIDGE] = net_init_bridge,
995 [NET_CLIENT_DRIVER_HUBPORT] = net_init_hubport,
996 #ifdef CONFIG_VHOST_NET_USER
997 [NET_CLIENT_DRIVER_VHOST_USER] = net_init_vhost_user,
999 #ifdef CONFIG_VHOST_NET_VDPA
1000 [NET_CLIENT_DRIVER_VHOST_VDPA] = net_init_vhost_vdpa,
1002 #ifdef CONFIG_L2TPV3
1003 [NET_CLIENT_DRIVER_L2TPV3] = net_init_l2tpv3,
1008 static int net_client_init1(const Netdev *netdev, bool is_netdev, Error **errp)
1010 NetClientState *peer = NULL;
1014 if (netdev->type == NET_CLIENT_DRIVER_NIC ||
1015 !net_client_init_fun[netdev->type]) {
1016 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "type",
1017 "a netdev backend type");
1021 if (netdev->type == NET_CLIENT_DRIVER_NONE) {
1022 return 0; /* nothing to do */
1024 if (netdev->type == NET_CLIENT_DRIVER_HUBPORT ||
1025 !net_client_init_fun[netdev->type]) {
1026 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "type",
1027 "a net backend type (maybe it is not compiled "
1028 "into this binary)");
1032 /* Do not add to a hub if it's a nic with a netdev= parameter. */
1033 if (netdev->type != NET_CLIENT_DRIVER_NIC ||
1034 !netdev->u.nic.has_netdev) {
1035 peer = net_hub_add_port(0, NULL, NULL);
1039 nc = qemu_find_netdev(netdev->id);
1041 error_setg(errp, "Duplicate ID '%s'", netdev->id);
1045 if (net_client_init_fun[netdev->type](netdev, netdev->id, peer, errp) < 0) {
1046 /* FIXME drop when all init functions store an Error */
1047 if (errp && !*errp) {
1048 error_setg(errp, "Device '%s' could not be initialized",
1049 NetClientDriver_str(netdev->type));
1055 nc = qemu_find_netdev(netdev->id);
1057 nc->is_netdev = true;
1063 void show_netdevs(void)
1066 const char *available_netdevs[] = {
1073 #ifdef CONFIG_L2TPV3
1079 #ifdef CONFIG_NET_BRIDGE
1082 #ifdef CONFIG_NETMAP
1088 #ifdef CONFIG_VHOST_VDPA
1093 qemu_printf("Available netdev backend types:\n");
1094 for (idx = 0; idx < ARRAY_SIZE(available_netdevs); idx++) {
1095 qemu_printf("%s\n", available_netdevs[idx]);
1099 static int net_client_init(QemuOpts *opts, bool is_netdev, Error **errp)
1101 gchar **substrings = NULL;
1102 Netdev *object = NULL;
1104 Visitor *v = opts_visitor_new(opts);
1106 /* Parse convenience option format ip6-net=fec0::0[/64] */
1107 const char *ip6_net = qemu_opt_get(opts, "ipv6-net");
1111 unsigned long prefix_len = 64; /* Default 64bit prefix length. */
1113 substrings = g_strsplit(ip6_net, "/", 2);
1114 if (!substrings || !substrings[0]) {
1115 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "ipv6-net",
1116 "a valid IPv6 prefix");
1120 prefix_addr = substrings[0];
1122 /* Handle user-specified prefix length. */
1123 if (substrings[1] &&
1124 qemu_strtoul(substrings[1], NULL, 10, &prefix_len))
1126 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
1127 "ipv6-prefixlen", "a number");
1131 qemu_opt_set(opts, "ipv6-prefix", prefix_addr, &error_abort);
1132 qemu_opt_set_number(opts, "ipv6-prefixlen", prefix_len,
1134 qemu_opt_unset(opts, "ipv6-net");
1137 /* Create an ID for -net if the user did not specify one */
1138 if (!is_netdev && !qemu_opts_id(opts)) {
1139 qemu_opts_set_id(opts, id_generate(ID_NET));
1142 if (visit_type_Netdev(v, NULL, &object, errp)) {
1143 ret = net_client_init1(object, is_netdev, errp);
1146 qapi_free_Netdev(object);
1149 g_strfreev(substrings);
1154 void netdev_add(QemuOpts *opts, Error **errp)
1156 net_client_init(opts, true, errp);
1159 void qmp_netdev_add(Netdev *netdev, Error **errp)
1161 if (!id_wellformed(netdev->id)) {
1162 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "id", "an identifier");
1166 net_client_init1(netdev, true, errp);
1169 void qmp_netdev_del(const char *id, Error **errp)
1174 nc = qemu_find_netdev(id);
1176 error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
1177 "Device '%s' not found", id);
1181 if (!nc->is_netdev) {
1182 error_setg(errp, "Device '%s' is not a netdev", id);
1186 qemu_del_net_client(nc);
1189 * Wart: we need to delete the QemuOpts associated with netdevs
1190 * created via CLI or HMP, to avoid bogus "Duplicate ID" errors in
1193 opts = qemu_opts_find(qemu_find_opts("netdev"), id);
1195 qemu_opts_del(opts);
1199 static void netfilter_print_info(Monitor *mon, NetFilterState *nf)
1202 ObjectProperty *prop;
1203 ObjectPropertyIterator iter;
1206 /* generate info str */
1207 object_property_iter_init(&iter, OBJECT(nf));
1208 while ((prop = object_property_iter_next(&iter))) {
1209 if (!strcmp(prop->name, "type")) {
1212 v = string_output_visitor_new(false, &str);
1213 object_property_get(OBJECT(nf), prop->name, v, NULL);
1214 visit_complete(v, &str);
1216 monitor_printf(mon, ",%s=%s", prop->name, str);
1219 monitor_printf(mon, "\n");
1222 void print_net_client(Monitor *mon, NetClientState *nc)
1226 monitor_printf(mon, "%s: index=%d,type=%s,%s\n", nc->name,
1228 NetClientDriver_str(nc->info->type),
1230 if (!QTAILQ_EMPTY(&nc->filters)) {
1231 monitor_printf(mon, "filters:\n");
1233 QTAILQ_FOREACH(nf, &nc->filters, next) {
1234 monitor_printf(mon, " - %s: type=%s",
1235 object_get_canonical_path_component(OBJECT(nf)),
1236 object_get_typename(OBJECT(nf)));
1237 netfilter_print_info(mon, nf);
1241 RxFilterInfoList *qmp_query_rx_filter(bool has_name, const char *name,
1245 RxFilterInfoList *filter_list = NULL, **tail = &filter_list;
1247 QTAILQ_FOREACH(nc, &net_clients, next) {
1250 if (has_name && strcmp(nc->name, name) != 0) {
1254 /* only query rx-filter information of NIC */
1255 if (nc->info->type != NET_CLIENT_DRIVER_NIC) {
1257 error_setg(errp, "net client(%s) isn't a NIC", name);
1258 assert(!filter_list);
1264 /* only query information on queue 0 since the info is per nic,
1267 if (nc->queue_index != 0)
1270 if (nc->info->query_rx_filter) {
1271 info = nc->info->query_rx_filter(nc);
1272 QAPI_LIST_APPEND(tail, info);
1273 } else if (has_name) {
1274 error_setg(errp, "net client(%s) doesn't support"
1275 " rx-filter querying", name);
1276 assert(!filter_list);
1285 if (filter_list == NULL && has_name) {
1286 error_setg(errp, "invalid net client name: %s", name);
1292 void hmp_info_network(Monitor *mon, const QDict *qdict)
1294 NetClientState *nc, *peer;
1295 NetClientDriver type;
1299 QTAILQ_FOREACH(nc, &net_clients, next) {
1301 type = nc->info->type;
1303 /* Skip if already printed in hub info */
1304 if (net_hub_id_for_client(nc, NULL) == 0) {
1308 if (!peer || type == NET_CLIENT_DRIVER_NIC) {
1309 print_net_client(mon, nc);
1310 } /* else it's a netdev connected to a NIC, printed with the NIC */
1311 if (peer && type == NET_CLIENT_DRIVER_NIC) {
1312 monitor_printf(mon, " \\ ");
1313 print_net_client(mon, peer);
1318 void colo_notify_filters_event(int event, Error **errp)
1322 NetFilterClass *nfc = NULL;
1323 Error *local_err = NULL;
1325 QTAILQ_FOREACH(nc, &net_clients, next) {
1326 QTAILQ_FOREACH(nf, &nc->filters, next) {
1327 nfc = NETFILTER_GET_CLASS(OBJECT(nf));
1328 nfc->handle_event(nf, event, &local_err);
1330 error_propagate(errp, local_err);
1337 void qmp_set_link(const char *name, bool up, Error **errp)
1339 NetClientState *ncs[MAX_QUEUE_NUM];
1343 queues = qemu_find_net_clients_except(name, ncs,
1344 NET_CLIENT_DRIVER__MAX,
1348 error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
1349 "Device '%s' not found", name);
1354 for (i = 0; i < queues; i++) {
1355 ncs[i]->link_down = !up;
1358 if (nc->info->link_status_changed) {
1359 nc->info->link_status_changed(nc);
1363 /* Change peer link only if the peer is NIC and then notify peer.
1364 * If the peer is a HUBPORT or a backend, we do not change the
1367 * This behavior is compatible with qemu hubs where there could be
1368 * multiple clients that can still communicate with each other in
1369 * disconnected mode. For now maintain this compatibility.
1371 if (nc->peer->info->type == NET_CLIENT_DRIVER_NIC) {
1372 for (i = 0; i < queues; i++) {
1373 ncs[i]->peer->link_down = !up;
1376 if (nc->peer->info->link_status_changed) {
1377 nc->peer->info->link_status_changed(nc->peer);
1382 static void net_vm_change_state_handler(void *opaque, bool running,
1386 NetClientState *tmp;
1388 QTAILQ_FOREACH_SAFE(nc, &net_clients, next, tmp) {
1390 /* Flush queued packets and wake up backends. */
1391 if (nc->peer && qemu_can_send_packet(nc)) {
1392 qemu_flush_queued_packets(nc->peer);
1395 /* Complete all queued packets, to guarantee we don't modify
1396 * state later when VM is not running.
1398 qemu_flush_or_purge_queued_packets(nc, true);
1403 void net_cleanup(void)
1407 /* We may del multiple entries during qemu_del_net_client(),
1408 * so QTAILQ_FOREACH_SAFE() is also not safe here.
1410 while (!QTAILQ_EMPTY(&net_clients)) {
1411 nc = QTAILQ_FIRST(&net_clients);
1412 if (nc->info->type == NET_CLIENT_DRIVER_NIC) {
1413 qemu_del_nic(qemu_get_nic(nc));
1415 qemu_del_net_client(nc);
1419 qemu_del_vm_change_state_handler(net_change_state_entry);
1422 void net_check_clients(void)
1427 net_hub_check_clients();
1429 QTAILQ_FOREACH(nc, &net_clients, next) {
1431 warn_report("%s %s has no peer",
1432 nc->info->type == NET_CLIENT_DRIVER_NIC
1438 /* Check that all NICs requested via -net nic actually got created.
1439 * NICs created via -device don't need to be checked here because
1440 * they are always instantiated.
1442 for (i = 0; i < MAX_NICS; i++) {
1443 NICInfo *nd = &nd_table[i];
1444 if (nd->used && !nd->instantiated) {
1445 warn_report("requested NIC (%s, model %s) "
1446 "was not created (not supported by this machine?)",
1447 nd->name ? nd->name : "anonymous",
1448 nd->model ? nd->model : "unspecified");
1453 static int net_init_client(void *dummy, QemuOpts *opts, Error **errp)
1455 return net_client_init(opts, false, errp);
1458 static int net_init_netdev(void *dummy, QemuOpts *opts, Error **errp)
1460 const char *type = qemu_opt_get(opts, "type");
1462 if (type && is_help_option(type)) {
1466 return net_client_init(opts, true, errp);
1469 /* For the convenience "--nic" parameter */
1470 static int net_param_nic(void *dummy, QemuOpts *opts, Error **errp)
1477 type = qemu_opt_get(opts, "type");
1478 if (type && g_str_equal(type, "none")) {
1479 return 0; /* Nothing to do, default_net is cleared in vl.c */
1482 idx = nic_get_free_idx();
1483 if (idx == -1 || nb_nics >= MAX_NICS) {
1484 error_setg(errp, "no more on-board/default NIC slots available");
1489 qemu_opt_set(opts, "type", "user", &error_abort);
1492 ni = &nd_table[idx];
1493 memset(ni, 0, sizeof(*ni));
1494 ni->model = qemu_opt_get_del(opts, "model");
1496 /* Create an ID if the user did not specify one */
1497 nd_id = g_strdup(qemu_opts_id(opts));
1499 nd_id = id_generate(ID_NET);
1500 qemu_opts_set_id(opts, nd_id);
1503 /* Handle MAC address */
1504 mac = qemu_opt_get_del(opts, "mac");
1506 ret = net_parse_macaddr(ni->macaddr.a, mac);
1509 error_setg(errp, "invalid syntax for ethernet address");
1512 if (is_multicast_ether_addr(ni->macaddr.a)) {
1513 error_setg(errp, "NIC cannot have multicast MAC address");
1518 qemu_macaddr_default_if_unset(&ni->macaddr);
1520 ret = net_client_init(opts, true, errp);
1522 ni->netdev = qemu_find_netdev(nd_id);
1532 int net_init_clients(Error **errp)
1534 net_change_state_entry =
1535 qemu_add_vm_change_state_handler(net_vm_change_state_handler, NULL);
1537 QTAILQ_INIT(&net_clients);
1539 if (qemu_opts_foreach(qemu_find_opts("netdev"),
1540 net_init_netdev, NULL, errp)) {
1544 if (qemu_opts_foreach(qemu_find_opts("nic"), net_param_nic, NULL, errp)) {
1548 if (qemu_opts_foreach(qemu_find_opts("net"), net_init_client, NULL, errp)) {
1555 int net_client_parse(QemuOptsList *opts_list, const char *optarg)
1557 if (!qemu_opts_parse_noisily(opts_list, optarg, true)) {
1566 uint32_t net_crc32(const uint8_t *p, int len)
1573 for (i = 0; i < len; i++) {
1575 for (j = 0; j < 8; j++) {
1576 carry = ((crc & 0x80000000L) ? 1 : 0) ^ (b & 0x01);
1580 crc = ((crc ^ POLYNOMIAL_BE) | carry);
1588 uint32_t net_crc32_le(const uint8_t *p, int len)
1595 for (i = 0; i < len; i++) {
1597 for (j = 0; j < 8; j++) {
1598 carry = (crc & 0x1) ^ (b & 0x01);
1602 crc ^= POLYNOMIAL_LE;
1610 QemuOptsList qemu_netdev_opts = {
1612 .implied_opt_name = "type",
1613 .head = QTAILQ_HEAD_INITIALIZER(qemu_netdev_opts.head),
1616 * no elements => accept any params
1617 * validation will happen later
1619 { /* end of list */ }
1623 QemuOptsList qemu_nic_opts = {
1625 .implied_opt_name = "type",
1626 .head = QTAILQ_HEAD_INITIALIZER(qemu_nic_opts.head),
1629 * no elements => accept any params
1630 * validation will happen later
1632 { /* end of list */ }
1636 QemuOptsList qemu_net_opts = {
1638 .implied_opt_name = "type",
1639 .head = QTAILQ_HEAD_INITIALIZER(qemu_net_opts.head),
1642 * no elements => accept any params
1643 * validation will happen later
1645 { /* end of list */ }
1649 void net_socket_rs_init(SocketReadState *rs,
1650 SocketReadStateFinalize *finalize,
1654 rs->vnet_hdr = vnet_hdr;
1657 rs->vnet_hdr_len = 0;
1658 memset(rs->buf, 0, sizeof(rs->buf));
1659 rs->finalize = finalize;
1667 int net_fill_rstate(SocketReadState *rs, const uint8_t *buf, int size)
1672 /* Reassemble a packet from the network.
1673 * 0 = getting length.
1674 * 1 = getting vnet header length.
1677 switch (rs->state) {
1683 memcpy(rs->buf + rs->index, buf, l);
1687 if (rs->index == 4) {
1689 rs->packet_len = ntohl(*(uint32_t *)rs->buf);
1695 rs->vnet_hdr_len = 0;
1704 memcpy(rs->buf + rs->index, buf, l);
1708 if (rs->index == 4) {
1709 /* got vnet header length */
1710 rs->vnet_hdr_len = ntohl(*(uint32_t *)rs->buf);
1716 l = rs->packet_len - rs->index;
1720 if (rs->index + l <= sizeof(rs->buf)) {
1721 memcpy(rs->buf + rs->index, buf, l);
1723 fprintf(stderr, "serious error: oversized packet received,"
1724 "connection terminated.\n");
1725 rs->index = rs->state = 0;
1732 if (rs->index >= rs->packet_len) {
1735 assert(rs->finalize);