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"
47 #include "qemu/qemu-print.h"
48 #include "qemu/main-loop.h"
49 #include "qemu/option.h"
50 #include "qapi/error.h"
51 #include "qapi/opts-visitor.h"
52 #include "sysemu/sysemu.h"
53 #include "sysemu/qtest.h"
54 #include "sysemu/runstate.h"
55 #include "sysemu/sysemu.h"
56 #include "net/filter.h"
57 #include "qapi/string-output-visitor.h"
59 /* Net bridge is currently not supported for W32. */
61 # define CONFIG_NET_BRIDGE
64 static VMChangeStateEntry
*net_change_state_entry
;
65 static QTAILQ_HEAD(, NetClientState
) net_clients
;
67 /***********************************************************/
68 /* network device redirectors */
70 int parse_host_port(struct sockaddr_in
*saddr
, const char *str
,
75 const char *addr
, *p
, *r
;
78 substrings
= g_strsplit(str
, ":", 2);
79 if (!substrings
|| !substrings
[0] || !substrings
[1]) {
80 error_setg(errp
, "host address '%s' doesn't contain ':' "
81 "separating host from port", str
);
89 saddr
->sin_family
= AF_INET
;
90 if (addr
[0] == '\0') {
91 saddr
->sin_addr
.s_addr
= 0;
93 if (qemu_isdigit(addr
[0])) {
94 if (!inet_aton(addr
, &saddr
->sin_addr
)) {
95 error_setg(errp
, "host address '%s' is not a valid "
96 "IPv4 address", addr
);
101 he
= gethostbyname(addr
);
103 error_setg(errp
, "can't resolve host address '%s'", addr
);
107 saddr
->sin_addr
= *(struct in_addr
*)he
->h_addr
;
110 port
= strtol(p
, (char **)&r
, 0);
112 error_setg(errp
, "port number '%s' is invalid", p
);
116 saddr
->sin_port
= htons(port
);
119 g_strfreev(substrings
);
123 char *qemu_mac_strdup_printf(const uint8_t *macaddr
)
125 return g_strdup_printf("%.2x:%.2x:%.2x:%.2x:%.2x:%.2x",
126 macaddr
[0], macaddr
[1], macaddr
[2],
127 macaddr
[3], macaddr
[4], macaddr
[5]);
130 void qemu_format_nic_info_str(NetClientState
*nc
, uint8_t macaddr
[6])
132 snprintf(nc
->info_str
, sizeof(nc
->info_str
),
133 "model=%s,macaddr=%02x:%02x:%02x:%02x:%02x:%02x",
135 macaddr
[0], macaddr
[1], macaddr
[2],
136 macaddr
[3], macaddr
[4], macaddr
[5]);
139 static int mac_table
[256] = {0};
141 static void qemu_macaddr_set_used(MACAddr
*macaddr
)
145 for (index
= 0x56; index
< 0xFF; index
++) {
146 if (macaddr
->a
[5] == index
) {
152 static void qemu_macaddr_set_free(MACAddr
*macaddr
)
155 static const MACAddr base
= { .a
= { 0x52, 0x54, 0x00, 0x12, 0x34, 0 } };
157 if (memcmp(macaddr
->a
, &base
.a
, (sizeof(base
.a
) - 1)) != 0) {
160 for (index
= 0x56; index
< 0xFF; index
++) {
161 if (macaddr
->a
[5] == index
) {
167 static int qemu_macaddr_get_free(void)
171 for (index
= 0x56; index
< 0xFF; index
++) {
172 if (mac_table
[index
] == 0) {
180 void qemu_macaddr_default_if_unset(MACAddr
*macaddr
)
182 static const MACAddr zero
= { .a
= { 0,0,0,0,0,0 } };
183 static const MACAddr base
= { .a
= { 0x52, 0x54, 0x00, 0x12, 0x34, 0 } };
185 if (memcmp(macaddr
, &zero
, sizeof(zero
)) != 0) {
186 if (memcmp(macaddr
->a
, &base
.a
, (sizeof(base
.a
) - 1)) != 0) {
189 qemu_macaddr_set_used(macaddr
);
194 macaddr
->a
[0] = 0x52;
195 macaddr
->a
[1] = 0x54;
196 macaddr
->a
[2] = 0x00;
197 macaddr
->a
[3] = 0x12;
198 macaddr
->a
[4] = 0x34;
199 macaddr
->a
[5] = qemu_macaddr_get_free();
200 qemu_macaddr_set_used(macaddr
);
204 * Generate a name for net client
206 * Only net clients created with the legacy -net option and NICs need this.
208 static char *assign_name(NetClientState
*nc1
, const char *model
)
213 QTAILQ_FOREACH(nc
, &net_clients
, next
) {
217 if (strcmp(nc
->model
, model
) == 0) {
222 return g_strdup_printf("%s.%d", model
, id
);
225 static void qemu_net_client_destructor(NetClientState
*nc
)
229 static ssize_t
qemu_deliver_packet_iov(NetClientState
*sender
,
231 const struct iovec
*iov
,
235 static void qemu_net_client_setup(NetClientState
*nc
,
237 NetClientState
*peer
,
240 NetClientDestructor
*destructor
)
243 nc
->model
= g_strdup(model
);
245 nc
->name
= g_strdup(name
);
247 nc
->name
= assign_name(nc
, model
);
255 QTAILQ_INSERT_TAIL(&net_clients
, nc
, next
);
257 nc
->incoming_queue
= qemu_new_net_queue(qemu_deliver_packet_iov
, nc
);
258 nc
->destructor
= destructor
;
259 QTAILQ_INIT(&nc
->filters
);
262 NetClientState
*qemu_new_net_client(NetClientInfo
*info
,
263 NetClientState
*peer
,
269 assert(info
->size
>= sizeof(NetClientState
));
271 nc
= g_malloc0(info
->size
);
272 qemu_net_client_setup(nc
, info
, peer
, model
, name
,
273 qemu_net_client_destructor
);
278 NICState
*qemu_new_nic(NetClientInfo
*info
,
284 NetClientState
**peers
= conf
->peers
.ncs
;
286 int i
, queues
= MAX(1, conf
->peers
.queues
);
288 assert(info
->type
== NET_CLIENT_DRIVER_NIC
);
289 assert(info
->size
>= sizeof(NICState
));
291 nic
= g_malloc0(info
->size
+ sizeof(NetClientState
) * queues
);
292 nic
->ncs
= (void *)nic
+ info
->size
;
294 nic
->opaque
= opaque
;
296 for (i
= 0; i
< queues
; i
++) {
297 qemu_net_client_setup(&nic
->ncs
[i
], info
, peers
[i
], model
, name
,
299 nic
->ncs
[i
].queue_index
= i
;
305 NetClientState
*qemu_get_subqueue(NICState
*nic
, int queue_index
)
307 return nic
->ncs
+ queue_index
;
310 NetClientState
*qemu_get_queue(NICState
*nic
)
312 return qemu_get_subqueue(nic
, 0);
315 NICState
*qemu_get_nic(NetClientState
*nc
)
317 NetClientState
*nc0
= nc
- nc
->queue_index
;
319 return (NICState
*)((void *)nc0
- nc
->info
->size
);
322 void *qemu_get_nic_opaque(NetClientState
*nc
)
324 NICState
*nic
= qemu_get_nic(nc
);
329 NetClientState
*qemu_get_peer(NetClientState
*nc
, int queue_index
)
332 NetClientState
*ncs
= nc
+ queue_index
;
336 static void qemu_cleanup_net_client(NetClientState
*nc
)
338 QTAILQ_REMOVE(&net_clients
, nc
, next
);
340 if (nc
->info
->cleanup
) {
341 nc
->info
->cleanup(nc
);
345 static void qemu_free_net_client(NetClientState
*nc
)
347 if (nc
->incoming_queue
) {
348 qemu_del_net_queue(nc
->incoming_queue
);
351 nc
->peer
->peer
= NULL
;
355 if (nc
->destructor
) {
360 void qemu_del_net_client(NetClientState
*nc
)
362 NetClientState
*ncs
[MAX_QUEUE_NUM
];
364 NetFilterState
*nf
, *next
;
366 assert(nc
->info
->type
!= NET_CLIENT_DRIVER_NIC
);
368 /* If the NetClientState belongs to a multiqueue backend, we will change all
369 * other NetClientStates also.
371 queues
= qemu_find_net_clients_except(nc
->name
, ncs
,
372 NET_CLIENT_DRIVER_NIC
,
376 QTAILQ_FOREACH_SAFE(nf
, &nc
->filters
, next
, next
) {
377 object_unparent(OBJECT(nf
));
380 /* If there is a peer NIC, delete and cleanup client, but do not free. */
381 if (nc
->peer
&& nc
->peer
->info
->type
== NET_CLIENT_DRIVER_NIC
) {
382 NICState
*nic
= qemu_get_nic(nc
->peer
);
383 if (nic
->peer_deleted
) {
386 nic
->peer_deleted
= true;
388 for (i
= 0; i
< queues
; i
++) {
389 ncs
[i
]->peer
->link_down
= true;
392 if (nc
->peer
->info
->link_status_changed
) {
393 nc
->peer
->info
->link_status_changed(nc
->peer
);
396 for (i
= 0; i
< queues
; i
++) {
397 qemu_cleanup_net_client(ncs
[i
]);
403 for (i
= 0; i
< queues
; i
++) {
404 qemu_cleanup_net_client(ncs
[i
]);
405 qemu_free_net_client(ncs
[i
]);
409 void qemu_del_nic(NICState
*nic
)
411 int i
, queues
= MAX(nic
->conf
->peers
.queues
, 1);
413 qemu_macaddr_set_free(&nic
->conf
->macaddr
);
415 /* If this is a peer NIC and peer has already been deleted, free it now. */
416 if (nic
->peer_deleted
) {
417 for (i
= 0; i
< queues
; i
++) {
418 qemu_free_net_client(qemu_get_subqueue(nic
, i
)->peer
);
422 for (i
= queues
- 1; i
>= 0; i
--) {
423 NetClientState
*nc
= qemu_get_subqueue(nic
, i
);
425 qemu_cleanup_net_client(nc
);
426 qemu_free_net_client(nc
);
432 void qemu_foreach_nic(qemu_nic_foreach func
, void *opaque
)
436 QTAILQ_FOREACH(nc
, &net_clients
, next
) {
437 if (nc
->info
->type
== NET_CLIENT_DRIVER_NIC
) {
438 if (nc
->queue_index
== 0) {
439 func(qemu_get_nic(nc
), opaque
);
445 bool qemu_has_ufo(NetClientState
*nc
)
447 if (!nc
|| !nc
->info
->has_ufo
) {
451 return nc
->info
->has_ufo(nc
);
454 bool qemu_has_vnet_hdr(NetClientState
*nc
)
456 if (!nc
|| !nc
->info
->has_vnet_hdr
) {
460 return nc
->info
->has_vnet_hdr(nc
);
463 bool qemu_has_vnet_hdr_len(NetClientState
*nc
, int len
)
465 if (!nc
|| !nc
->info
->has_vnet_hdr_len
) {
469 return nc
->info
->has_vnet_hdr_len(nc
, len
);
472 void qemu_using_vnet_hdr(NetClientState
*nc
, bool enable
)
474 if (!nc
|| !nc
->info
->using_vnet_hdr
) {
478 nc
->info
->using_vnet_hdr(nc
, enable
);
481 void qemu_set_offload(NetClientState
*nc
, int csum
, int tso4
, int tso6
,
484 if (!nc
|| !nc
->info
->set_offload
) {
488 nc
->info
->set_offload(nc
, csum
, tso4
, tso6
, ecn
, ufo
);
491 void qemu_set_vnet_hdr_len(NetClientState
*nc
, int len
)
493 if (!nc
|| !nc
->info
->set_vnet_hdr_len
) {
497 nc
->vnet_hdr_len
= len
;
498 nc
->info
->set_vnet_hdr_len(nc
, len
);
501 int qemu_set_vnet_le(NetClientState
*nc
, bool is_le
)
503 #ifdef HOST_WORDS_BIGENDIAN
504 if (!nc
|| !nc
->info
->set_vnet_le
) {
508 return nc
->info
->set_vnet_le(nc
, is_le
);
514 int qemu_set_vnet_be(NetClientState
*nc
, bool is_be
)
516 #ifdef HOST_WORDS_BIGENDIAN
519 if (!nc
|| !nc
->info
->set_vnet_be
) {
523 return nc
->info
->set_vnet_be(nc
, is_be
);
527 int qemu_can_send_packet(NetClientState
*sender
)
529 int vm_running
= runstate_is_running();
539 if (sender
->peer
->receive_disabled
) {
541 } else if (sender
->peer
->info
->can_receive
&&
542 !sender
->peer
->info
->can_receive(sender
->peer
)) {
548 static ssize_t
filter_receive_iov(NetClientState
*nc
,
549 NetFilterDirection direction
,
550 NetClientState
*sender
,
552 const struct iovec
*iov
,
554 NetPacketSent
*sent_cb
)
557 NetFilterState
*nf
= NULL
;
559 if (direction
== NET_FILTER_DIRECTION_TX
) {
560 QTAILQ_FOREACH(nf
, &nc
->filters
, next
) {
561 ret
= qemu_netfilter_receive(nf
, direction
, sender
, flags
, iov
,
568 QTAILQ_FOREACH_REVERSE(nf
, &nc
->filters
, next
) {
569 ret
= qemu_netfilter_receive(nf
, direction
, sender
, flags
, iov
,
580 static ssize_t
filter_receive(NetClientState
*nc
,
581 NetFilterDirection direction
,
582 NetClientState
*sender
,
586 NetPacketSent
*sent_cb
)
589 .iov_base
= (void *)data
,
593 return filter_receive_iov(nc
, direction
, sender
, flags
, &iov
, 1, sent_cb
);
596 void qemu_purge_queued_packets(NetClientState
*nc
)
602 qemu_net_queue_purge(nc
->peer
->incoming_queue
, nc
);
605 void qemu_flush_or_purge_queued_packets(NetClientState
*nc
, bool purge
)
607 nc
->receive_disabled
= 0;
609 if (nc
->peer
&& nc
->peer
->info
->type
== NET_CLIENT_DRIVER_HUBPORT
) {
610 if (net_hub_flush(nc
->peer
)) {
614 if (qemu_net_queue_flush(nc
->incoming_queue
)) {
615 /* We emptied the queue successfully, signal to the IO thread to repoll
616 * the file descriptor (for tap, for example).
620 /* Unable to empty the queue, purge remaining packets */
621 qemu_net_queue_purge(nc
->incoming_queue
, nc
->peer
);
625 void qemu_flush_queued_packets(NetClientState
*nc
)
627 qemu_flush_or_purge_queued_packets(nc
, false);
630 static ssize_t
qemu_send_packet_async_with_flags(NetClientState
*sender
,
632 const uint8_t *buf
, int size
,
633 NetPacketSent
*sent_cb
)
639 printf("qemu_send_packet_async:\n");
640 qemu_hexdump(stdout
, "net", buf
, size
);
643 if (sender
->link_down
|| !sender
->peer
) {
647 /* Let filters handle the packet first */
648 ret
= filter_receive(sender
, NET_FILTER_DIRECTION_TX
,
649 sender
, flags
, buf
, size
, sent_cb
);
654 ret
= filter_receive(sender
->peer
, NET_FILTER_DIRECTION_RX
,
655 sender
, flags
, buf
, size
, sent_cb
);
660 queue
= sender
->peer
->incoming_queue
;
662 return qemu_net_queue_send(queue
, sender
, flags
, buf
, size
, sent_cb
);
665 ssize_t
qemu_send_packet_async(NetClientState
*sender
,
666 const uint8_t *buf
, int size
,
667 NetPacketSent
*sent_cb
)
669 return qemu_send_packet_async_with_flags(sender
, QEMU_NET_PACKET_FLAG_NONE
,
673 ssize_t
qemu_send_packet(NetClientState
*nc
, const uint8_t *buf
, int size
)
675 return qemu_send_packet_async(nc
, buf
, size
, NULL
);
678 ssize_t
qemu_send_packet_raw(NetClientState
*nc
, const uint8_t *buf
, int size
)
680 return qemu_send_packet_async_with_flags(nc
, QEMU_NET_PACKET_FLAG_RAW
,
684 static ssize_t
nc_sendv_compat(NetClientState
*nc
, const struct iovec
*iov
,
685 int iovcnt
, unsigned flags
)
693 buffer
= iov
[0].iov_base
;
694 offset
= iov
[0].iov_len
;
696 offset
= iov_size(iov
, iovcnt
);
697 if (offset
> NET_BUFSIZE
) {
700 buf
= g_malloc(offset
);
702 offset
= iov_to_buf(iov
, iovcnt
, 0, buf
, offset
);
705 if (flags
& QEMU_NET_PACKET_FLAG_RAW
&& nc
->info
->receive_raw
) {
706 ret
= nc
->info
->receive_raw(nc
, buffer
, offset
);
708 ret
= nc
->info
->receive(nc
, buffer
, offset
);
715 static ssize_t
qemu_deliver_packet_iov(NetClientState
*sender
,
717 const struct iovec
*iov
,
721 NetClientState
*nc
= opaque
;
726 return iov_size(iov
, iovcnt
);
729 if (nc
->receive_disabled
) {
733 if (nc
->info
->receive_iov
&& !(flags
& QEMU_NET_PACKET_FLAG_RAW
)) {
734 ret
= nc
->info
->receive_iov(nc
, iov
, iovcnt
);
736 ret
= nc_sendv_compat(nc
, iov
, iovcnt
, flags
);
740 nc
->receive_disabled
= 1;
746 ssize_t
qemu_sendv_packet_async(NetClientState
*sender
,
747 const struct iovec
*iov
, int iovcnt
,
748 NetPacketSent
*sent_cb
)
751 size_t size
= iov_size(iov
, iovcnt
);
754 if (size
> NET_BUFSIZE
) {
758 if (sender
->link_down
|| !sender
->peer
) {
762 /* Let filters handle the packet first */
763 ret
= filter_receive_iov(sender
, NET_FILTER_DIRECTION_TX
, sender
,
764 QEMU_NET_PACKET_FLAG_NONE
, iov
, iovcnt
, sent_cb
);
769 ret
= filter_receive_iov(sender
->peer
, NET_FILTER_DIRECTION_RX
, sender
,
770 QEMU_NET_PACKET_FLAG_NONE
, iov
, iovcnt
, sent_cb
);
775 queue
= sender
->peer
->incoming_queue
;
777 return qemu_net_queue_send_iov(queue
, sender
,
778 QEMU_NET_PACKET_FLAG_NONE
,
779 iov
, iovcnt
, sent_cb
);
783 qemu_sendv_packet(NetClientState
*nc
, const struct iovec
*iov
, int iovcnt
)
785 return qemu_sendv_packet_async(nc
, iov
, iovcnt
, NULL
);
788 NetClientState
*qemu_find_netdev(const char *id
)
792 QTAILQ_FOREACH(nc
, &net_clients
, next
) {
793 if (nc
->info
->type
== NET_CLIENT_DRIVER_NIC
)
795 if (!strcmp(nc
->name
, id
)) {
803 int qemu_find_net_clients_except(const char *id
, NetClientState
**ncs
,
804 NetClientDriver type
, int max
)
809 QTAILQ_FOREACH(nc
, &net_clients
, next
) {
810 if (nc
->info
->type
== type
) {
813 if (!id
|| !strcmp(nc
->name
, id
)) {
824 static int nic_get_free_idx(void)
828 for (index
= 0; index
< MAX_NICS
; index
++)
829 if (!nd_table
[index
].used
)
834 int qemu_show_nic_models(const char *arg
, const char *const *models
)
838 if (!arg
|| !is_help_option(arg
)) {
842 printf("Supported NIC models:\n");
843 for (i
= 0 ; models
[i
]; i
++) {
844 printf("%s\n", models
[i
]);
849 void qemu_check_nic_model(NICInfo
*nd
, const char *model
)
851 const char *models
[2];
856 if (qemu_show_nic_models(nd
->model
, models
))
858 if (qemu_find_nic_model(nd
, models
, model
) < 0)
862 int qemu_find_nic_model(NICInfo
*nd
, const char * const *models
,
863 const char *default_model
)
868 nd
->model
= g_strdup(default_model
);
870 for (i
= 0 ; models
[i
]; i
++) {
871 if (strcmp(nd
->model
, models
[i
]) == 0)
875 error_report("Unsupported NIC model: %s", nd
->model
);
879 static int net_init_nic(const Netdev
*netdev
, const char *name
,
880 NetClientState
*peer
, Error
**errp
)
884 const NetLegacyNicOptions
*nic
;
886 assert(netdev
->type
== NET_CLIENT_DRIVER_NIC
);
887 nic
= &netdev
->u
.nic
;
889 idx
= nic_get_free_idx();
890 if (idx
== -1 || nb_nics
>= MAX_NICS
) {
891 error_setg(errp
, "too many NICs");
897 memset(nd
, 0, sizeof(*nd
));
899 if (nic
->has_netdev
) {
900 nd
->netdev
= qemu_find_netdev(nic
->netdev
);
902 error_setg(errp
, "netdev '%s' not found", nic
->netdev
);
909 nd
->name
= g_strdup(name
);
910 if (nic
->has_model
) {
911 nd
->model
= g_strdup(nic
->model
);
914 nd
->devaddr
= g_strdup(nic
->addr
);
917 if (nic
->has_macaddr
&&
918 net_parse_macaddr(nd
->macaddr
.a
, nic
->macaddr
) < 0) {
919 error_setg(errp
, "invalid syntax for ethernet address");
922 if (nic
->has_macaddr
&&
923 is_multicast_ether_addr(nd
->macaddr
.a
)) {
925 "NIC cannot have multicast MAC address (odd 1st byte)");
928 qemu_macaddr_default_if_unset(&nd
->macaddr
);
930 if (nic
->has_vectors
) {
931 if (nic
->vectors
> 0x7ffffff) {
932 error_setg(errp
, "invalid # of vectors: %"PRIu32
, nic
->vectors
);
935 nd
->nvectors
= nic
->vectors
;
937 nd
->nvectors
= DEV_NVECTORS_UNSPECIFIED
;
947 static int (* const net_client_init_fun
[NET_CLIENT_DRIVER__MAX
])(
948 const Netdev
*netdev
,
950 NetClientState
*peer
, Error
**errp
) = {
951 [NET_CLIENT_DRIVER_NIC
] = net_init_nic
,
953 [NET_CLIENT_DRIVER_USER
] = net_init_slirp
,
955 [NET_CLIENT_DRIVER_TAP
] = net_init_tap
,
956 [NET_CLIENT_DRIVER_SOCKET
] = net_init_socket
,
958 [NET_CLIENT_DRIVER_VDE
] = net_init_vde
,
961 [NET_CLIENT_DRIVER_NETMAP
] = net_init_netmap
,
963 #ifdef CONFIG_NET_BRIDGE
964 [NET_CLIENT_DRIVER_BRIDGE
] = net_init_bridge
,
966 [NET_CLIENT_DRIVER_HUBPORT
] = net_init_hubport
,
967 #ifdef CONFIG_VHOST_NET_USER
968 [NET_CLIENT_DRIVER_VHOST_USER
] = net_init_vhost_user
,
970 #ifdef CONFIG_VHOST_NET_VDPA
971 [NET_CLIENT_DRIVER_VHOST_VDPA
] = net_init_vhost_vdpa
,
974 [NET_CLIENT_DRIVER_L2TPV3
] = net_init_l2tpv3
,
979 static int net_client_init1(const Netdev
*netdev
, bool is_netdev
, Error
**errp
)
981 NetClientState
*peer
= NULL
;
984 if (netdev
->type
== NET_CLIENT_DRIVER_NIC
||
985 !net_client_init_fun
[netdev
->type
]) {
986 error_setg(errp
, QERR_INVALID_PARAMETER_VALUE
, "type",
987 "a netdev backend type");
991 if (netdev
->type
== NET_CLIENT_DRIVER_NONE
) {
992 return 0; /* nothing to do */
994 if (netdev
->type
== NET_CLIENT_DRIVER_HUBPORT
||
995 !net_client_init_fun
[netdev
->type
]) {
996 error_setg(errp
, QERR_INVALID_PARAMETER_VALUE
, "type",
997 "a net backend type (maybe it is not compiled "
998 "into this binary)");
1002 /* Do not add to a hub if it's a nic with a netdev= parameter. */
1003 if (netdev
->type
!= NET_CLIENT_DRIVER_NIC
||
1004 !netdev
->u
.nic
.has_netdev
) {
1005 peer
= net_hub_add_port(0, NULL
, NULL
);
1009 if (net_client_init_fun
[netdev
->type
](netdev
, netdev
->id
, peer
, errp
) < 0) {
1010 /* FIXME drop when all init functions store an Error */
1011 if (errp
&& !*errp
) {
1012 error_setg(errp
, QERR_DEVICE_INIT_FAILED
,
1013 NetClientDriver_str(netdev
->type
));
1021 nc
= qemu_find_netdev(netdev
->id
);
1023 nc
->is_netdev
= true;
1029 void show_netdevs(void)
1032 const char *available_netdevs
[] = {
1039 #ifdef CONFIG_L2TPV3
1045 #ifdef CONFIG_NET_BRIDGE
1048 #ifdef CONFIG_NETMAP
1054 #ifdef CONFIG_VHOST_VDPA
1059 qemu_printf("Available netdev backend types:\n");
1060 for (idx
= 0; idx
< ARRAY_SIZE(available_netdevs
); idx
++) {
1061 qemu_printf("%s\n", available_netdevs
[idx
]);
1065 static int net_client_init(QemuOpts
*opts
, bool is_netdev
, Error
**errp
)
1067 gchar
**substrings
= NULL
;
1068 Netdev
*object
= NULL
;
1070 Visitor
*v
= opts_visitor_new(opts
);
1072 /* Parse convenience option format ip6-net=fec0::0[/64] */
1073 const char *ip6_net
= qemu_opt_get(opts
, "ipv6-net");
1077 unsigned long prefix_len
= 64; /* Default 64bit prefix length. */
1079 substrings
= g_strsplit(ip6_net
, "/", 2);
1080 if (!substrings
|| !substrings
[0]) {
1081 error_setg(errp
, QERR_INVALID_PARAMETER_VALUE
, "ipv6-net",
1082 "a valid IPv6 prefix");
1086 prefix_addr
= substrings
[0];
1088 /* Handle user-specified prefix length. */
1089 if (substrings
[1] &&
1090 qemu_strtoul(substrings
[1], NULL
, 10, &prefix_len
))
1092 error_setg(errp
, QERR_INVALID_PARAMETER_VALUE
,
1093 "ipv6-prefixlen", "a number");
1097 qemu_opt_set(opts
, "ipv6-prefix", prefix_addr
, &error_abort
);
1098 qemu_opt_set_number(opts
, "ipv6-prefixlen", prefix_len
,
1100 qemu_opt_unset(opts
, "ipv6-net");
1103 /* Create an ID for -net if the user did not specify one */
1104 if (!is_netdev
&& !qemu_opts_id(opts
)) {
1106 qemu_opts_set_id(opts
, g_strdup_printf("__org.qemu.net%i", idx
++));
1109 if (visit_type_Netdev(v
, NULL
, &object
, errp
)) {
1110 ret
= net_client_init1(object
, is_netdev
, errp
);
1113 qapi_free_Netdev(object
);
1116 g_strfreev(substrings
);
1121 void netdev_add(QemuOpts
*opts
, Error
**errp
)
1123 net_client_init(opts
, true, errp
);
1126 void qmp_netdev_add(Netdev
*netdev
, Error
**errp
)
1128 net_client_init1(netdev
, true, errp
);
1131 void qmp_netdev_del(const char *id
, Error
**errp
)
1135 nc
= qemu_find_netdev(id
);
1137 error_set(errp
, ERROR_CLASS_DEVICE_NOT_FOUND
,
1138 "Device '%s' not found", id
);
1142 if (!nc
->is_netdev
) {
1143 error_setg(errp
, "Device '%s' is not a netdev", id
);
1147 qemu_del_net_client(nc
);
1150 static void netfilter_print_info(Monitor
*mon
, NetFilterState
*nf
)
1153 ObjectProperty
*prop
;
1154 ObjectPropertyIterator iter
;
1157 /* generate info str */
1158 object_property_iter_init(&iter
, OBJECT(nf
));
1159 while ((prop
= object_property_iter_next(&iter
))) {
1160 if (!strcmp(prop
->name
, "type")) {
1163 v
= string_output_visitor_new(false, &str
);
1164 object_property_get(OBJECT(nf
), prop
->name
, v
, NULL
);
1165 visit_complete(v
, &str
);
1167 monitor_printf(mon
, ",%s=%s", prop
->name
, str
);
1170 monitor_printf(mon
, "\n");
1173 void print_net_client(Monitor
*mon
, NetClientState
*nc
)
1177 monitor_printf(mon
, "%s: index=%d,type=%s,%s\n", nc
->name
,
1179 NetClientDriver_str(nc
->info
->type
),
1181 if (!QTAILQ_EMPTY(&nc
->filters
)) {
1182 monitor_printf(mon
, "filters:\n");
1184 QTAILQ_FOREACH(nf
, &nc
->filters
, next
) {
1185 monitor_printf(mon
, " - %s: type=%s",
1186 object_get_canonical_path_component(OBJECT(nf
)),
1187 object_get_typename(OBJECT(nf
)));
1188 netfilter_print_info(mon
, nf
);
1192 RxFilterInfoList
*qmp_query_rx_filter(bool has_name
, const char *name
,
1196 RxFilterInfoList
*filter_list
= NULL
, *last_entry
= NULL
;
1198 QTAILQ_FOREACH(nc
, &net_clients
, next
) {
1199 RxFilterInfoList
*entry
;
1202 if (has_name
&& strcmp(nc
->name
, name
) != 0) {
1206 /* only query rx-filter information of NIC */
1207 if (nc
->info
->type
!= NET_CLIENT_DRIVER_NIC
) {
1209 error_setg(errp
, "net client(%s) isn't a NIC", name
);
1215 /* only query information on queue 0 since the info is per nic,
1218 if (nc
->queue_index
!= 0)
1221 if (nc
->info
->query_rx_filter
) {
1222 info
= nc
->info
->query_rx_filter(nc
);
1223 entry
= g_malloc0(sizeof(*entry
));
1224 entry
->value
= info
;
1227 filter_list
= entry
;
1229 last_entry
->next
= entry
;
1232 } else if (has_name
) {
1233 error_setg(errp
, "net client(%s) doesn't support"
1234 " rx-filter querying", name
);
1243 if (filter_list
== NULL
&& has_name
) {
1244 error_setg(errp
, "invalid net client name: %s", name
);
1250 void hmp_info_network(Monitor
*mon
, const QDict
*qdict
)
1252 NetClientState
*nc
, *peer
;
1253 NetClientDriver type
;
1257 QTAILQ_FOREACH(nc
, &net_clients
, next
) {
1259 type
= nc
->info
->type
;
1261 /* Skip if already printed in hub info */
1262 if (net_hub_id_for_client(nc
, NULL
) == 0) {
1266 if (!peer
|| type
== NET_CLIENT_DRIVER_NIC
) {
1267 print_net_client(mon
, nc
);
1268 } /* else it's a netdev connected to a NIC, printed with the NIC */
1269 if (peer
&& type
== NET_CLIENT_DRIVER_NIC
) {
1270 monitor_printf(mon
, " \\ ");
1271 print_net_client(mon
, peer
);
1276 void colo_notify_filters_event(int event
, Error
**errp
)
1280 NetFilterClass
*nfc
= NULL
;
1281 Error
*local_err
= NULL
;
1283 QTAILQ_FOREACH(nc
, &net_clients
, next
) {
1284 QTAILQ_FOREACH(nf
, &nc
->filters
, next
) {
1285 nfc
= NETFILTER_GET_CLASS(OBJECT(nf
));
1286 nfc
->handle_event(nf
, event
, &local_err
);
1288 error_propagate(errp
, local_err
);
1295 void qmp_set_link(const char *name
, bool up
, Error
**errp
)
1297 NetClientState
*ncs
[MAX_QUEUE_NUM
];
1301 queues
= qemu_find_net_clients_except(name
, ncs
,
1302 NET_CLIENT_DRIVER__MAX
,
1306 error_set(errp
, ERROR_CLASS_DEVICE_NOT_FOUND
,
1307 "Device '%s' not found", name
);
1312 for (i
= 0; i
< queues
; i
++) {
1313 ncs
[i
]->link_down
= !up
;
1316 if (nc
->info
->link_status_changed
) {
1317 nc
->info
->link_status_changed(nc
);
1321 /* Change peer link only if the peer is NIC and then notify peer.
1322 * If the peer is a HUBPORT or a backend, we do not change the
1325 * This behavior is compatible with qemu hubs where there could be
1326 * multiple clients that can still communicate with each other in
1327 * disconnected mode. For now maintain this compatibility.
1329 if (nc
->peer
->info
->type
== NET_CLIENT_DRIVER_NIC
) {
1330 for (i
= 0; i
< queues
; i
++) {
1331 ncs
[i
]->peer
->link_down
= !up
;
1334 if (nc
->peer
->info
->link_status_changed
) {
1335 nc
->peer
->info
->link_status_changed(nc
->peer
);
1340 static void net_vm_change_state_handler(void *opaque
, int running
,
1344 NetClientState
*tmp
;
1346 QTAILQ_FOREACH_SAFE(nc
, &net_clients
, next
, tmp
) {
1348 /* Flush queued packets and wake up backends. */
1349 if (nc
->peer
&& qemu_can_send_packet(nc
)) {
1350 qemu_flush_queued_packets(nc
->peer
);
1353 /* Complete all queued packets, to guarantee we don't modify
1354 * state later when VM is not running.
1356 qemu_flush_or_purge_queued_packets(nc
, true);
1361 void net_cleanup(void)
1365 /* We may del multiple entries during qemu_del_net_client(),
1366 * so QTAILQ_FOREACH_SAFE() is also not safe here.
1368 while (!QTAILQ_EMPTY(&net_clients
)) {
1369 nc
= QTAILQ_FIRST(&net_clients
);
1370 if (nc
->info
->type
== NET_CLIENT_DRIVER_NIC
) {
1371 qemu_del_nic(qemu_get_nic(nc
));
1373 qemu_del_net_client(nc
);
1377 qemu_del_vm_change_state_handler(net_change_state_entry
);
1380 void net_check_clients(void)
1385 net_hub_check_clients();
1387 QTAILQ_FOREACH(nc
, &net_clients
, next
) {
1389 warn_report("%s %s has no peer",
1390 nc
->info
->type
== NET_CLIENT_DRIVER_NIC
1396 /* Check that all NICs requested via -net nic actually got created.
1397 * NICs created via -device don't need to be checked here because
1398 * they are always instantiated.
1400 for (i
= 0; i
< MAX_NICS
; i
++) {
1401 NICInfo
*nd
= &nd_table
[i
];
1402 if (nd
->used
&& !nd
->instantiated
) {
1403 warn_report("requested NIC (%s, model %s) "
1404 "was not created (not supported by this machine?)",
1405 nd
->name
? nd
->name
: "anonymous",
1406 nd
->model
? nd
->model
: "unspecified");
1411 static int net_init_client(void *dummy
, QemuOpts
*opts
, Error
**errp
)
1413 return net_client_init(opts
, false, errp
);
1416 static int net_init_netdev(void *dummy
, QemuOpts
*opts
, Error
**errp
)
1418 const char *type
= qemu_opt_get(opts
, "type");
1420 if (type
&& is_help_option(type
)) {
1424 return net_client_init(opts
, true, errp
);
1427 /* For the convenience "--nic" parameter */
1428 static int net_param_nic(void *dummy
, QemuOpts
*opts
, Error
**errp
)
1435 type
= qemu_opt_get(opts
, "type");
1436 if (type
&& g_str_equal(type
, "none")) {
1437 return 0; /* Nothing to do, default_net is cleared in vl.c */
1440 idx
= nic_get_free_idx();
1441 if (idx
== -1 || nb_nics
>= MAX_NICS
) {
1442 error_setg(errp
, "no more on-board/default NIC slots available");
1447 qemu_opt_set(opts
, "type", "user", &error_abort
);
1450 ni
= &nd_table
[idx
];
1451 memset(ni
, 0, sizeof(*ni
));
1452 ni
->model
= qemu_opt_get_del(opts
, "model");
1454 /* Create an ID if the user did not specify one */
1455 nd_id
= g_strdup(qemu_opts_id(opts
));
1457 nd_id
= g_strdup_printf("__org.qemu.nic%i", idx
);
1458 qemu_opts_set_id(opts
, nd_id
);
1461 /* Handle MAC address */
1462 mac
= qemu_opt_get_del(opts
, "mac");
1464 ret
= net_parse_macaddr(ni
->macaddr
.a
, mac
);
1467 error_setg(errp
, "invalid syntax for ethernet address");
1470 if (is_multicast_ether_addr(ni
->macaddr
.a
)) {
1471 error_setg(errp
, "NIC cannot have multicast MAC address");
1476 qemu_macaddr_default_if_unset(&ni
->macaddr
);
1478 ret
= net_client_init(opts
, true, errp
);
1480 ni
->netdev
= qemu_find_netdev(nd_id
);
1490 int net_init_clients(Error
**errp
)
1492 net_change_state_entry
=
1493 qemu_add_vm_change_state_handler(net_vm_change_state_handler
, NULL
);
1495 QTAILQ_INIT(&net_clients
);
1497 if (qemu_opts_foreach(qemu_find_opts("netdev"),
1498 net_init_netdev
, NULL
, errp
)) {
1502 if (qemu_opts_foreach(qemu_find_opts("nic"), net_param_nic
, NULL
, errp
)) {
1506 if (qemu_opts_foreach(qemu_find_opts("net"), net_init_client
, NULL
, errp
)) {
1513 int net_client_parse(QemuOptsList
*opts_list
, const char *optarg
)
1515 if (!qemu_opts_parse_noisily(opts_list
, optarg
, true)) {
1524 uint32_t net_crc32(const uint8_t *p
, int len
)
1531 for (i
= 0; i
< len
; i
++) {
1533 for (j
= 0; j
< 8; j
++) {
1534 carry
= ((crc
& 0x80000000L
) ? 1 : 0) ^ (b
& 0x01);
1538 crc
= ((crc
^ POLYNOMIAL_BE
) | carry
);
1546 uint32_t net_crc32_le(const uint8_t *p
, int len
)
1553 for (i
= 0; i
< len
; i
++) {
1555 for (j
= 0; j
< 8; j
++) {
1556 carry
= (crc
& 0x1) ^ (b
& 0x01);
1560 crc
^= POLYNOMIAL_LE
;
1568 QemuOptsList qemu_netdev_opts
= {
1570 .implied_opt_name
= "type",
1571 .head
= QTAILQ_HEAD_INITIALIZER(qemu_netdev_opts
.head
),
1574 * no elements => accept any params
1575 * validation will happen later
1577 { /* end of list */ }
1581 QemuOptsList qemu_nic_opts
= {
1583 .implied_opt_name
= "type",
1584 .head
= QTAILQ_HEAD_INITIALIZER(qemu_nic_opts
.head
),
1587 * no elements => accept any params
1588 * validation will happen later
1590 { /* end of list */ }
1594 QemuOptsList qemu_net_opts
= {
1596 .implied_opt_name
= "type",
1597 .head
= QTAILQ_HEAD_INITIALIZER(qemu_net_opts
.head
),
1600 * no elements => accept any params
1601 * validation will happen later
1603 { /* end of list */ }
1607 void net_socket_rs_init(SocketReadState
*rs
,
1608 SocketReadStateFinalize
*finalize
,
1612 rs
->vnet_hdr
= vnet_hdr
;
1615 rs
->vnet_hdr_len
= 0;
1616 memset(rs
->buf
, 0, sizeof(rs
->buf
));
1617 rs
->finalize
= finalize
;
1625 int net_fill_rstate(SocketReadState
*rs
, const uint8_t *buf
, int size
)
1630 /* Reassemble a packet from the network.
1631 * 0 = getting length.
1632 * 1 = getting vnet header length.
1635 switch (rs
->state
) {
1641 memcpy(rs
->buf
+ rs
->index
, buf
, l
);
1645 if (rs
->index
== 4) {
1647 rs
->packet_len
= ntohl(*(uint32_t *)rs
->buf
);
1653 rs
->vnet_hdr_len
= 0;
1662 memcpy(rs
->buf
+ rs
->index
, buf
, l
);
1666 if (rs
->index
== 4) {
1667 /* got vnet header length */
1668 rs
->vnet_hdr_len
= ntohl(*(uint32_t *)rs
->buf
);
1674 l
= rs
->packet_len
- rs
->index
;
1678 if (rs
->index
+ l
<= sizeof(rs
->buf
)) {
1679 memcpy(rs
->buf
+ rs
->index
, buf
, l
);
1681 fprintf(stderr
, "serious error: oversized packet received,"
1682 "connection terminated.\n");
1683 rs
->index
= rs
->state
= 0;
1690 if (rs
->index
>= rs
->packet_len
) {
1693 assert(rs
->finalize
);