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_uso(NetClientState
*nc
)
500 if (!nc
|| !nc
->info
->has_uso
) {
504 return nc
->info
->has_uso(nc
);
507 bool qemu_has_vnet_hdr(NetClientState
*nc
)
509 if (!nc
|| !nc
->info
->has_vnet_hdr
) {
513 return nc
->info
->has_vnet_hdr(nc
);
516 bool qemu_has_vnet_hdr_len(NetClientState
*nc
, int len
)
518 if (!nc
|| !nc
->info
->has_vnet_hdr_len
) {
522 return nc
->info
->has_vnet_hdr_len(nc
, len
);
525 bool qemu_get_using_vnet_hdr(NetClientState
*nc
)
527 if (!nc
|| !nc
->info
->get_using_vnet_hdr
) {
531 return nc
->info
->get_using_vnet_hdr(nc
);
534 void qemu_using_vnet_hdr(NetClientState
*nc
, bool enable
)
536 if (!nc
|| !nc
->info
->using_vnet_hdr
) {
540 nc
->info
->using_vnet_hdr(nc
, enable
);
543 void qemu_set_offload(NetClientState
*nc
, int csum
, int tso4
, int tso6
,
544 int ecn
, int ufo
, int uso4
, int uso6
)
546 if (!nc
|| !nc
->info
->set_offload
) {
550 nc
->info
->set_offload(nc
, csum
, tso4
, tso6
, ecn
, ufo
, uso4
, uso6
);
553 int qemu_get_vnet_hdr_len(NetClientState
*nc
)
555 if (!nc
|| !nc
->info
->get_vnet_hdr_len
) {
559 return nc
->info
->get_vnet_hdr_len(nc
);
562 void qemu_set_vnet_hdr_len(NetClientState
*nc
, int len
)
564 if (!nc
|| !nc
->info
->set_vnet_hdr_len
) {
568 nc
->vnet_hdr_len
= len
;
569 nc
->info
->set_vnet_hdr_len(nc
, len
);
572 int qemu_set_vnet_le(NetClientState
*nc
, bool is_le
)
575 if (!nc
|| !nc
->info
->set_vnet_le
) {
579 return nc
->info
->set_vnet_le(nc
, is_le
);
585 int qemu_set_vnet_be(NetClientState
*nc
, bool is_be
)
590 if (!nc
|| !nc
->info
->set_vnet_be
) {
594 return nc
->info
->set_vnet_be(nc
, is_be
);
598 int qemu_can_receive_packet(NetClientState
*nc
)
600 if (nc
->receive_disabled
) {
602 } else if (nc
->info
->can_receive
&&
603 !nc
->info
->can_receive(nc
)) {
609 int qemu_can_send_packet(NetClientState
*sender
)
611 int vm_running
= runstate_is_running();
621 return qemu_can_receive_packet(sender
->peer
);
624 static ssize_t
filter_receive_iov(NetClientState
*nc
,
625 NetFilterDirection direction
,
626 NetClientState
*sender
,
628 const struct iovec
*iov
,
630 NetPacketSent
*sent_cb
)
633 NetFilterState
*nf
= NULL
;
635 if (direction
== NET_FILTER_DIRECTION_TX
) {
636 QTAILQ_FOREACH(nf
, &nc
->filters
, next
) {
637 ret
= qemu_netfilter_receive(nf
, direction
, sender
, flags
, iov
,
644 QTAILQ_FOREACH_REVERSE(nf
, &nc
->filters
, next
) {
645 ret
= qemu_netfilter_receive(nf
, direction
, sender
, flags
, iov
,
656 static ssize_t
filter_receive(NetClientState
*nc
,
657 NetFilterDirection direction
,
658 NetClientState
*sender
,
662 NetPacketSent
*sent_cb
)
665 .iov_base
= (void *)data
,
669 return filter_receive_iov(nc
, direction
, sender
, flags
, &iov
, 1, sent_cb
);
672 void qemu_purge_queued_packets(NetClientState
*nc
)
678 qemu_net_queue_purge(nc
->peer
->incoming_queue
, nc
);
681 void qemu_flush_or_purge_queued_packets(NetClientState
*nc
, bool purge
)
683 nc
->receive_disabled
= 0;
685 if (nc
->peer
&& nc
->peer
->info
->type
== NET_CLIENT_DRIVER_HUBPORT
) {
686 if (net_hub_flush(nc
->peer
)) {
690 if (qemu_net_queue_flush(nc
->incoming_queue
)) {
691 /* We emptied the queue successfully, signal to the IO thread to repoll
692 * the file descriptor (for tap, for example).
696 /* Unable to empty the queue, purge remaining packets */
697 qemu_net_queue_purge(nc
->incoming_queue
, nc
->peer
);
701 void qemu_flush_queued_packets(NetClientState
*nc
)
703 qemu_flush_or_purge_queued_packets(nc
, false);
706 static ssize_t
qemu_send_packet_async_with_flags(NetClientState
*sender
,
708 const uint8_t *buf
, int size
,
709 NetPacketSent
*sent_cb
)
715 printf("qemu_send_packet_async:\n");
716 qemu_hexdump(stdout
, "net", buf
, size
);
719 if (sender
->link_down
|| !sender
->peer
) {
723 /* Let filters handle the packet first */
724 ret
= filter_receive(sender
, NET_FILTER_DIRECTION_TX
,
725 sender
, flags
, buf
, size
, sent_cb
);
730 ret
= filter_receive(sender
->peer
, NET_FILTER_DIRECTION_RX
,
731 sender
, flags
, buf
, size
, sent_cb
);
736 queue
= sender
->peer
->incoming_queue
;
738 return qemu_net_queue_send(queue
, sender
, flags
, buf
, size
, sent_cb
);
741 ssize_t
qemu_send_packet_async(NetClientState
*sender
,
742 const uint8_t *buf
, int size
,
743 NetPacketSent
*sent_cb
)
745 return qemu_send_packet_async_with_flags(sender
, QEMU_NET_PACKET_FLAG_NONE
,
749 ssize_t
qemu_send_packet(NetClientState
*nc
, const uint8_t *buf
, int size
)
751 return qemu_send_packet_async(nc
, buf
, size
, NULL
);
754 ssize_t
qemu_receive_packet(NetClientState
*nc
, const uint8_t *buf
, int size
)
756 if (!qemu_can_receive_packet(nc
)) {
760 return qemu_net_queue_receive(nc
->incoming_queue
, buf
, size
);
763 ssize_t
qemu_receive_packet_iov(NetClientState
*nc
, const struct iovec
*iov
,
766 if (!qemu_can_receive_packet(nc
)) {
770 return qemu_net_queue_receive_iov(nc
->incoming_queue
, iov
, iovcnt
);
773 ssize_t
qemu_send_packet_raw(NetClientState
*nc
, const uint8_t *buf
, int size
)
775 return qemu_send_packet_async_with_flags(nc
, QEMU_NET_PACKET_FLAG_RAW
,
779 static ssize_t
nc_sendv_compat(NetClientState
*nc
, const struct iovec
*iov
,
780 int iovcnt
, unsigned flags
)
788 buffer
= iov
[0].iov_base
;
789 offset
= iov
[0].iov_len
;
791 offset
= iov_size(iov
, iovcnt
);
792 if (offset
> NET_BUFSIZE
) {
795 buf
= g_malloc(offset
);
797 offset
= iov_to_buf(iov
, iovcnt
, 0, buf
, offset
);
800 if (flags
& QEMU_NET_PACKET_FLAG_RAW
&& nc
->info
->receive_raw
) {
801 ret
= nc
->info
->receive_raw(nc
, buffer
, offset
);
803 ret
= nc
->info
->receive(nc
, buffer
, offset
);
810 static ssize_t
qemu_deliver_packet_iov(NetClientState
*sender
,
812 const struct iovec
*iov
,
816 NetClientState
*nc
= opaque
;
821 return iov_size(iov
, iovcnt
);
824 if (nc
->receive_disabled
) {
828 if (nc
->info
->receive_iov
&& !(flags
& QEMU_NET_PACKET_FLAG_RAW
)) {
829 ret
= nc
->info
->receive_iov(nc
, iov
, iovcnt
);
831 ret
= nc_sendv_compat(nc
, iov
, iovcnt
, flags
);
835 nc
->receive_disabled
= 1;
841 ssize_t
qemu_sendv_packet_async(NetClientState
*sender
,
842 const struct iovec
*iov
, int iovcnt
,
843 NetPacketSent
*sent_cb
)
846 size_t size
= iov_size(iov
, iovcnt
);
849 if (size
> NET_BUFSIZE
) {
853 if (sender
->link_down
|| !sender
->peer
) {
857 /* Let filters handle the packet first */
858 ret
= filter_receive_iov(sender
, NET_FILTER_DIRECTION_TX
, sender
,
859 QEMU_NET_PACKET_FLAG_NONE
, iov
, iovcnt
, sent_cb
);
864 ret
= filter_receive_iov(sender
->peer
, NET_FILTER_DIRECTION_RX
, sender
,
865 QEMU_NET_PACKET_FLAG_NONE
, iov
, iovcnt
, sent_cb
);
870 queue
= sender
->peer
->incoming_queue
;
872 return qemu_net_queue_send_iov(queue
, sender
,
873 QEMU_NET_PACKET_FLAG_NONE
,
874 iov
, iovcnt
, sent_cb
);
878 qemu_sendv_packet(NetClientState
*nc
, const struct iovec
*iov
, int iovcnt
)
880 return qemu_sendv_packet_async(nc
, iov
, iovcnt
, NULL
);
883 NetClientState
*qemu_find_netdev(const char *id
)
887 QTAILQ_FOREACH(nc
, &net_clients
, next
) {
888 if (nc
->info
->type
== NET_CLIENT_DRIVER_NIC
)
890 if (!strcmp(nc
->name
, id
)) {
898 int qemu_find_net_clients_except(const char *id
, NetClientState
**ncs
,
899 NetClientDriver type
, int max
)
904 QTAILQ_FOREACH(nc
, &net_clients
, next
) {
905 if (nc
->info
->type
== type
) {
908 if (!id
|| !strcmp(nc
->name
, id
)) {
919 static int nic_get_free_idx(void)
923 for (index
= 0; index
< MAX_NICS
; index
++)
924 if (!nd_table
[index
].used
)
929 GPtrArray
*qemu_get_nic_models(const char *device_type
)
931 GPtrArray
*nic_models
= g_ptr_array_new();
932 GSList
*list
= object_class_get_list_sorted(device_type
, false);
935 DeviceClass
*dc
= OBJECT_CLASS_CHECK(DeviceClass
, list
->data
,
938 if (test_bit(DEVICE_CATEGORY_NETWORK
, dc
->categories
) &&
939 dc
->user_creatable
) {
940 const char *name
= object_class_get_name(list
->data
);
942 * A network device might also be something else than a NIC, see
943 * e.g. the "rocker" device. Thus we have to look for the "netdev"
944 * property, too. Unfortunately, some devices like virtio-net only
945 * create this property during instance_init, so we have to create
946 * a temporary instance here to be able to check it.
948 Object
*obj
= object_new_with_class(OBJECT_CLASS(dc
));
949 if (object_property_find(obj
, "netdev")) {
950 g_ptr_array_add(nic_models
, (gpointer
)name
);
955 g_slist_free_1(list
);
958 g_ptr_array_add(nic_models
, NULL
);
963 int qemu_show_nic_models(const char *arg
, const char *const *models
)
967 if (!arg
|| !is_help_option(arg
)) {
971 printf("Available NIC models:\n");
972 for (i
= 0 ; models
[i
]; i
++) {
973 printf("%s\n", models
[i
]);
978 void qemu_check_nic_model(NICInfo
*nd
, const char *model
)
980 const char *models
[2];
985 if (qemu_show_nic_models(nd
->model
, models
))
987 if (qemu_find_nic_model(nd
, models
, model
) < 0)
991 int qemu_find_nic_model(NICInfo
*nd
, const char * const *models
,
992 const char *default_model
)
997 nd
->model
= g_strdup(default_model
);
999 for (i
= 0 ; models
[i
]; i
++) {
1000 if (strcmp(nd
->model
, models
[i
]) == 0)
1004 error_report("Unsupported NIC model: %s", nd
->model
);
1008 static int net_init_nic(const Netdev
*netdev
, const char *name
,
1009 NetClientState
*peer
, Error
**errp
)
1013 const NetLegacyNicOptions
*nic
;
1015 assert(netdev
->type
== NET_CLIENT_DRIVER_NIC
);
1016 nic
= &netdev
->u
.nic
;
1018 idx
= nic_get_free_idx();
1019 if (idx
== -1 || nb_nics
>= MAX_NICS
) {
1020 error_setg(errp
, "too many NICs");
1024 nd
= &nd_table
[idx
];
1026 memset(nd
, 0, sizeof(*nd
));
1029 nd
->netdev
= qemu_find_netdev(nic
->netdev
);
1031 error_setg(errp
, "netdev '%s' not found", nic
->netdev
);
1038 nd
->name
= g_strdup(name
);
1040 nd
->model
= g_strdup(nic
->model
);
1043 nd
->devaddr
= g_strdup(nic
->addr
);
1047 net_parse_macaddr(nd
->macaddr
.a
, nic
->macaddr
) < 0) {
1048 error_setg(errp
, "invalid syntax for ethernet address");
1052 is_multicast_ether_addr(nd
->macaddr
.a
)) {
1054 "NIC cannot have multicast MAC address (odd 1st byte)");
1057 qemu_macaddr_default_if_unset(&nd
->macaddr
);
1059 if (nic
->has_vectors
) {
1060 if (nic
->vectors
> 0x7ffffff) {
1061 error_setg(errp
, "invalid # of vectors: %"PRIu32
, nic
->vectors
);
1064 nd
->nvectors
= nic
->vectors
;
1066 nd
->nvectors
= DEV_NVECTORS_UNSPECIFIED
;
1076 static int (* const net_client_init_fun
[NET_CLIENT_DRIVER__MAX
])(
1077 const Netdev
*netdev
,
1079 NetClientState
*peer
, Error
**errp
) = {
1080 [NET_CLIENT_DRIVER_NIC
] = net_init_nic
,
1082 [NET_CLIENT_DRIVER_USER
] = net_init_slirp
,
1084 [NET_CLIENT_DRIVER_TAP
] = net_init_tap
,
1085 [NET_CLIENT_DRIVER_SOCKET
] = net_init_socket
,
1086 [NET_CLIENT_DRIVER_STREAM
] = net_init_stream
,
1087 [NET_CLIENT_DRIVER_DGRAM
] = net_init_dgram
,
1089 [NET_CLIENT_DRIVER_VDE
] = net_init_vde
,
1091 #ifdef CONFIG_NETMAP
1092 [NET_CLIENT_DRIVER_NETMAP
] = net_init_netmap
,
1094 #ifdef CONFIG_NET_BRIDGE
1095 [NET_CLIENT_DRIVER_BRIDGE
] = net_init_bridge
,
1097 [NET_CLIENT_DRIVER_HUBPORT
] = net_init_hubport
,
1098 #ifdef CONFIG_VHOST_NET_USER
1099 [NET_CLIENT_DRIVER_VHOST_USER
] = net_init_vhost_user
,
1101 #ifdef CONFIG_VHOST_NET_VDPA
1102 [NET_CLIENT_DRIVER_VHOST_VDPA
] = net_init_vhost_vdpa
,
1104 #ifdef CONFIG_L2TPV3
1105 [NET_CLIENT_DRIVER_L2TPV3
] = net_init_l2tpv3
,
1108 [NET_CLIENT_DRIVER_VMNET_HOST
] = net_init_vmnet_host
,
1109 [NET_CLIENT_DRIVER_VMNET_SHARED
] = net_init_vmnet_shared
,
1110 [NET_CLIENT_DRIVER_VMNET_BRIDGED
] = net_init_vmnet_bridged
,
1111 #endif /* CONFIG_VMNET */
1115 static int net_client_init1(const Netdev
*netdev
, bool is_netdev
, Error
**errp
)
1117 NetClientState
*peer
= NULL
;
1121 if (netdev
->type
== NET_CLIENT_DRIVER_NIC
||
1122 !net_client_init_fun
[netdev
->type
]) {
1123 error_setg(errp
, "network backend '%s' is not compiled into this binary",
1124 NetClientDriver_str(netdev
->type
));
1128 if (netdev
->type
== NET_CLIENT_DRIVER_NONE
) {
1129 return 0; /* nothing to do */
1131 if (netdev
->type
== NET_CLIENT_DRIVER_HUBPORT
) {
1132 error_setg(errp
, "network backend '%s' is only supported with -netdev/-nic",
1133 NetClientDriver_str(netdev
->type
));
1137 if (!net_client_init_fun
[netdev
->type
]) {
1138 error_setg(errp
, "network backend '%s' is not compiled into this binary",
1139 NetClientDriver_str(netdev
->type
));
1143 /* Do not add to a hub if it's a nic with a netdev= parameter. */
1144 if (netdev
->type
!= NET_CLIENT_DRIVER_NIC
||
1145 !netdev
->u
.nic
.netdev
) {
1146 peer
= net_hub_add_port(0, NULL
, NULL
);
1150 nc
= qemu_find_netdev(netdev
->id
);
1152 error_setg(errp
, "Duplicate ID '%s'", netdev
->id
);
1156 if (net_client_init_fun
[netdev
->type
](netdev
, netdev
->id
, peer
, errp
) < 0) {
1157 /* FIXME drop when all init functions store an Error */
1158 if (errp
&& !*errp
) {
1159 error_setg(errp
, "Device '%s' could not be initialized",
1160 NetClientDriver_str(netdev
->type
));
1166 nc
= qemu_find_netdev(netdev
->id
);
1168 nc
->is_netdev
= true;
1174 void show_netdevs(void)
1177 const char *available_netdevs
[] = {
1186 #ifdef CONFIG_L2TPV3
1192 #ifdef CONFIG_NET_BRIDGE
1195 #ifdef CONFIG_NETMAP
1201 #ifdef CONFIG_VHOST_VDPA
1211 qemu_printf("Available netdev backend types:\n");
1212 for (idx
= 0; idx
< ARRAY_SIZE(available_netdevs
); idx
++) {
1213 qemu_printf("%s\n", available_netdevs
[idx
]);
1217 static int net_client_init(QemuOpts
*opts
, bool is_netdev
, Error
**errp
)
1219 gchar
**substrings
= NULL
;
1220 Netdev
*object
= NULL
;
1222 Visitor
*v
= opts_visitor_new(opts
);
1224 /* Parse convenience option format ip6-net=fec0::0[/64] */
1225 const char *ip6_net
= qemu_opt_get(opts
, "ipv6-net");
1229 unsigned long prefix_len
= 64; /* Default 64bit prefix length. */
1231 substrings
= g_strsplit(ip6_net
, "/", 2);
1232 if (!substrings
|| !substrings
[0]) {
1233 error_setg(errp
, QERR_INVALID_PARAMETER_VALUE
, "ipv6-net",
1234 "a valid IPv6 prefix");
1238 prefix_addr
= substrings
[0];
1240 /* Handle user-specified prefix length. */
1241 if (substrings
[1] &&
1242 qemu_strtoul(substrings
[1], NULL
, 10, &prefix_len
))
1244 error_setg(errp
, QERR_INVALID_PARAMETER_VALUE
,
1245 "ipv6-prefixlen", "a number");
1249 qemu_opt_set(opts
, "ipv6-prefix", prefix_addr
, &error_abort
);
1250 qemu_opt_set_number(opts
, "ipv6-prefixlen", prefix_len
,
1252 qemu_opt_unset(opts
, "ipv6-net");
1255 /* Create an ID for -net if the user did not specify one */
1256 if (!is_netdev
&& !qemu_opts_id(opts
)) {
1257 qemu_opts_set_id(opts
, id_generate(ID_NET
));
1260 if (visit_type_Netdev(v
, NULL
, &object
, errp
)) {
1261 ret
= net_client_init1(object
, is_netdev
, errp
);
1264 qapi_free_Netdev(object
);
1267 g_strfreev(substrings
);
1272 void netdev_add(QemuOpts
*opts
, Error
**errp
)
1274 net_client_init(opts
, true, errp
);
1277 void qmp_netdev_add(Netdev
*netdev
, Error
**errp
)
1279 if (!id_wellformed(netdev
->id
)) {
1280 error_setg(errp
, QERR_INVALID_PARAMETER_VALUE
, "id", "an identifier");
1284 net_client_init1(netdev
, true, errp
);
1287 void qmp_netdev_del(const char *id
, Error
**errp
)
1292 nc
= qemu_find_netdev(id
);
1294 error_set(errp
, ERROR_CLASS_DEVICE_NOT_FOUND
,
1295 "Device '%s' not found", id
);
1299 if (!nc
->is_netdev
) {
1300 error_setg(errp
, "Device '%s' is not a netdev", id
);
1304 qemu_del_net_client(nc
);
1307 * Wart: we need to delete the QemuOpts associated with netdevs
1308 * created via CLI or HMP, to avoid bogus "Duplicate ID" errors in
1311 opts
= qemu_opts_find(qemu_find_opts("netdev"), id
);
1313 qemu_opts_del(opts
);
1317 static void netfilter_print_info(Monitor
*mon
, NetFilterState
*nf
)
1320 ObjectProperty
*prop
;
1321 ObjectPropertyIterator iter
;
1324 /* generate info str */
1325 object_property_iter_init(&iter
, OBJECT(nf
));
1326 while ((prop
= object_property_iter_next(&iter
))) {
1327 if (!strcmp(prop
->name
, "type")) {
1330 v
= string_output_visitor_new(false, &str
);
1331 object_property_get(OBJECT(nf
), prop
->name
, v
, NULL
);
1332 visit_complete(v
, &str
);
1334 monitor_printf(mon
, ",%s=%s", prop
->name
, str
);
1337 monitor_printf(mon
, "\n");
1340 void print_net_client(Monitor
*mon
, NetClientState
*nc
)
1344 monitor_printf(mon
, "%s: index=%d,type=%s,%s\n", nc
->name
,
1346 NetClientDriver_str(nc
->info
->type
),
1348 if (!QTAILQ_EMPTY(&nc
->filters
)) {
1349 monitor_printf(mon
, "filters:\n");
1351 QTAILQ_FOREACH(nf
, &nc
->filters
, next
) {
1352 monitor_printf(mon
, " - %s: type=%s",
1353 object_get_canonical_path_component(OBJECT(nf
)),
1354 object_get_typename(OBJECT(nf
)));
1355 netfilter_print_info(mon
, nf
);
1359 RxFilterInfoList
*qmp_query_rx_filter(const char *name
, Error
**errp
)
1362 RxFilterInfoList
*filter_list
= NULL
, **tail
= &filter_list
;
1364 QTAILQ_FOREACH(nc
, &net_clients
, next
) {
1367 if (name
&& strcmp(nc
->name
, name
) != 0) {
1371 /* only query rx-filter information of NIC */
1372 if (nc
->info
->type
!= NET_CLIENT_DRIVER_NIC
) {
1374 error_setg(errp
, "net client(%s) isn't a NIC", name
);
1375 assert(!filter_list
);
1381 /* only query information on queue 0 since the info is per nic,
1384 if (nc
->queue_index
!= 0)
1387 if (nc
->info
->query_rx_filter
) {
1388 info
= nc
->info
->query_rx_filter(nc
);
1389 QAPI_LIST_APPEND(tail
, info
);
1391 error_setg(errp
, "net client(%s) doesn't support"
1392 " rx-filter querying", name
);
1393 assert(!filter_list
);
1402 if (filter_list
== NULL
&& name
) {
1403 error_setg(errp
, "invalid net client name: %s", name
);
1409 void colo_notify_filters_event(int event
, Error
**errp
)
1413 NetFilterClass
*nfc
= NULL
;
1414 Error
*local_err
= NULL
;
1416 QTAILQ_FOREACH(nc
, &net_clients
, next
) {
1417 QTAILQ_FOREACH(nf
, &nc
->filters
, next
) {
1418 nfc
= NETFILTER_GET_CLASS(OBJECT(nf
));
1419 nfc
->handle_event(nf
, event
, &local_err
);
1421 error_propagate(errp
, local_err
);
1428 void qmp_set_link(const char *name
, bool up
, Error
**errp
)
1430 NetClientState
*ncs
[MAX_QUEUE_NUM
];
1434 queues
= qemu_find_net_clients_except(name
, ncs
,
1435 NET_CLIENT_DRIVER__MAX
,
1439 error_set(errp
, ERROR_CLASS_DEVICE_NOT_FOUND
,
1440 "Device '%s' not found", name
);
1445 for (i
= 0; i
< queues
; i
++) {
1446 ncs
[i
]->link_down
= !up
;
1449 if (nc
->info
->link_status_changed
) {
1450 nc
->info
->link_status_changed(nc
);
1454 /* Change peer link only if the peer is NIC and then notify peer.
1455 * If the peer is a HUBPORT or a backend, we do not change the
1458 * This behavior is compatible with qemu hubs where there could be
1459 * multiple clients that can still communicate with each other in
1460 * disconnected mode. For now maintain this compatibility.
1462 if (nc
->peer
->info
->type
== NET_CLIENT_DRIVER_NIC
) {
1463 for (i
= 0; i
< queues
; i
++) {
1464 ncs
[i
]->peer
->link_down
= !up
;
1467 if (nc
->peer
->info
->link_status_changed
) {
1468 nc
->peer
->info
->link_status_changed(nc
->peer
);
1473 static void net_vm_change_state_handler(void *opaque
, bool running
,
1477 NetClientState
*tmp
;
1479 QTAILQ_FOREACH_SAFE(nc
, &net_clients
, next
, tmp
) {
1481 /* Flush queued packets and wake up backends. */
1482 if (nc
->peer
&& qemu_can_send_packet(nc
)) {
1483 qemu_flush_queued_packets(nc
->peer
);
1486 /* Complete all queued packets, to guarantee we don't modify
1487 * state later when VM is not running.
1489 qemu_flush_or_purge_queued_packets(nc
, true);
1494 void net_cleanup(void)
1498 /*cleanup colo compare module for COLO*/
1499 colo_compare_cleanup();
1501 /* We may del multiple entries during qemu_del_net_client(),
1502 * so QTAILQ_FOREACH_SAFE() is also not safe here.
1504 while (!QTAILQ_EMPTY(&net_clients
)) {
1505 nc
= QTAILQ_FIRST(&net_clients
);
1506 if (nc
->info
->type
== NET_CLIENT_DRIVER_NIC
) {
1507 qemu_del_nic(qemu_get_nic(nc
));
1509 qemu_del_net_client(nc
);
1513 qemu_del_vm_change_state_handler(net_change_state_entry
);
1516 void net_check_clients(void)
1521 net_hub_check_clients();
1523 QTAILQ_FOREACH(nc
, &net_clients
, next
) {
1525 warn_report("%s %s has no peer",
1526 nc
->info
->type
== NET_CLIENT_DRIVER_NIC
1532 /* Check that all NICs requested via -net nic actually got created.
1533 * NICs created via -device don't need to be checked here because
1534 * they are always instantiated.
1536 for (i
= 0; i
< MAX_NICS
; i
++) {
1537 NICInfo
*nd
= &nd_table
[i
];
1538 if (nd
->used
&& !nd
->instantiated
) {
1539 warn_report("requested NIC (%s, model %s) "
1540 "was not created (not supported by this machine?)",
1541 nd
->name
? nd
->name
: "anonymous",
1542 nd
->model
? nd
->model
: "unspecified");
1547 static int net_init_client(void *dummy
, QemuOpts
*opts
, Error
**errp
)
1549 return net_client_init(opts
, false, errp
);
1552 static int net_init_netdev(void *dummy
, QemuOpts
*opts
, Error
**errp
)
1554 const char *type
= qemu_opt_get(opts
, "type");
1556 if (type
&& is_help_option(type
)) {
1560 return net_client_init(opts
, true, errp
);
1563 /* For the convenience "--nic" parameter */
1564 static int net_param_nic(void *dummy
, QemuOpts
*opts
, Error
**errp
)
1571 type
= qemu_opt_get(opts
, "type");
1573 if (g_str_equal(type
, "none")) {
1574 return 0; /* Nothing to do, default_net is cleared in vl.c */
1576 if (is_help_option(type
)) {
1577 GPtrArray
*nic_models
= qemu_get_nic_models(TYPE_DEVICE
);
1580 qemu_show_nic_models(type
, (const char **)nic_models
->pdata
);
1581 g_ptr_array_free(nic_models
, true);
1586 idx
= nic_get_free_idx();
1587 if (idx
== -1 || nb_nics
>= MAX_NICS
) {
1588 error_setg(errp
, "no more on-board/default NIC slots available");
1593 qemu_opt_set(opts
, "type", "user", &error_abort
);
1596 ni
= &nd_table
[idx
];
1597 memset(ni
, 0, sizeof(*ni
));
1598 ni
->model
= qemu_opt_get_del(opts
, "model");
1600 /* Create an ID if the user did not specify one */
1601 nd_id
= g_strdup(qemu_opts_id(opts
));
1603 nd_id
= id_generate(ID_NET
);
1604 qemu_opts_set_id(opts
, nd_id
);
1607 /* Handle MAC address */
1608 mac
= qemu_opt_get_del(opts
, "mac");
1610 ret
= net_parse_macaddr(ni
->macaddr
.a
, mac
);
1613 error_setg(errp
, "invalid syntax for ethernet address");
1616 if (is_multicast_ether_addr(ni
->macaddr
.a
)) {
1617 error_setg(errp
, "NIC cannot have multicast MAC address");
1622 qemu_macaddr_default_if_unset(&ni
->macaddr
);
1624 ret
= net_client_init(opts
, true, errp
);
1626 ni
->netdev
= qemu_find_netdev(nd_id
);
1636 static void netdev_init_modern(void)
1638 while (!QSIMPLEQ_EMPTY(&nd_queue
)) {
1639 NetdevQueueEntry
*nd
= QSIMPLEQ_FIRST(&nd_queue
);
1641 QSIMPLEQ_REMOVE_HEAD(&nd_queue
, entry
);
1642 loc_push_restore(&nd
->loc
);
1643 net_client_init1(nd
->nd
, true, &error_fatal
);
1645 qapi_free_Netdev(nd
->nd
);
1650 void net_init_clients(void)
1652 net_change_state_entry
=
1653 qemu_add_vm_change_state_handler(net_vm_change_state_handler
, NULL
);
1655 QTAILQ_INIT(&net_clients
);
1657 netdev_init_modern();
1659 qemu_opts_foreach(qemu_find_opts("netdev"), net_init_netdev
, NULL
,
1662 qemu_opts_foreach(qemu_find_opts("nic"), net_param_nic
, NULL
,
1665 qemu_opts_foreach(qemu_find_opts("net"), net_init_client
, NULL
,
1670 * Does this -netdev argument use modern rather than traditional syntax?
1671 * Modern syntax is to be parsed with netdev_parse_modern().
1672 * Traditional syntax is to be parsed with net_client_parse().
1674 bool netdev_is_modern(const char *optarg
)
1679 static QemuOptsList dummy_opts
= {
1681 .implied_opt_name
= "type",
1682 .head
= QTAILQ_HEAD_INITIALIZER(dummy_opts
.head
),
1686 if (optarg
[0] == '{') {
1687 /* This is JSON, which means it's modern syntax */
1691 opts
= qemu_opts_create(&dummy_opts
, NULL
, false, &error_abort
);
1692 qemu_opts_do_parse(opts
, optarg
, dummy_opts
.implied_opt_name
,
1694 type
= qemu_opt_get(opts
, "type");
1695 is_modern
= !g_strcmp0(type
, "stream") || !g_strcmp0(type
, "dgram");
1697 qemu_opts_reset(&dummy_opts
);
1703 * netdev_parse_modern() uses modern, more expressive syntax than
1704 * net_client_parse(), but supports only the -netdev option.
1705 * netdev_parse_modern() appends to @nd_queue, whereas net_client_parse()
1706 * appends to @qemu_netdev_opts.
1708 void netdev_parse_modern(const char *optarg
)
1711 NetdevQueueEntry
*nd
;
1713 v
= qobject_input_visitor_new_str(optarg
, "type", &error_fatal
);
1714 nd
= g_new(NetdevQueueEntry
, 1);
1715 visit_type_Netdev(v
, NULL
, &nd
->nd
, &error_fatal
);
1719 QSIMPLEQ_INSERT_TAIL(&nd_queue
, nd
, entry
);
1722 void net_client_parse(QemuOptsList
*opts_list
, const char *optarg
)
1724 if (!qemu_opts_parse_noisily(opts_list
, optarg
, true)) {
1731 uint32_t net_crc32(const uint8_t *p
, int len
)
1738 for (i
= 0; i
< len
; i
++) {
1740 for (j
= 0; j
< 8; j
++) {
1741 carry
= ((crc
& 0x80000000L
) ? 1 : 0) ^ (b
& 0x01);
1745 crc
= ((crc
^ POLYNOMIAL_BE
) | carry
);
1753 uint32_t net_crc32_le(const uint8_t *p
, int len
)
1760 for (i
= 0; i
< len
; i
++) {
1762 for (j
= 0; j
< 8; j
++) {
1763 carry
= (crc
& 0x1) ^ (b
& 0x01);
1767 crc
^= POLYNOMIAL_LE
;
1775 QemuOptsList qemu_netdev_opts
= {
1777 .implied_opt_name
= "type",
1778 .head
= QTAILQ_HEAD_INITIALIZER(qemu_netdev_opts
.head
),
1781 * no elements => accept any params
1782 * validation will happen later
1784 { /* end of list */ }
1788 QemuOptsList qemu_nic_opts
= {
1790 .implied_opt_name
= "type",
1791 .head
= QTAILQ_HEAD_INITIALIZER(qemu_nic_opts
.head
),
1794 * no elements => accept any params
1795 * validation will happen later
1797 { /* end of list */ }
1801 QemuOptsList qemu_net_opts
= {
1803 .implied_opt_name
= "type",
1804 .head
= QTAILQ_HEAD_INITIALIZER(qemu_net_opts
.head
),
1807 * no elements => accept any params
1808 * validation will happen later
1810 { /* end of list */ }
1814 void net_socket_rs_init(SocketReadState
*rs
,
1815 SocketReadStateFinalize
*finalize
,
1819 rs
->vnet_hdr
= vnet_hdr
;
1822 rs
->vnet_hdr_len
= 0;
1823 memset(rs
->buf
, 0, sizeof(rs
->buf
));
1824 rs
->finalize
= finalize
;
1832 int net_fill_rstate(SocketReadState
*rs
, const uint8_t *buf
, int size
)
1837 /* Reassemble a packet from the network.
1838 * 0 = getting length.
1839 * 1 = getting vnet header length.
1842 switch (rs
->state
) {
1848 memcpy(rs
->buf
+ rs
->index
, buf
, l
);
1852 if (rs
->index
== 4) {
1854 rs
->packet_len
= ntohl(*(uint32_t *)rs
->buf
);
1860 rs
->vnet_hdr_len
= 0;
1869 memcpy(rs
->buf
+ rs
->index
, buf
, l
);
1873 if (rs
->index
== 4) {
1874 /* got vnet header length */
1875 rs
->vnet_hdr_len
= ntohl(*(uint32_t *)rs
->buf
);
1881 l
= rs
->packet_len
- rs
->index
;
1885 if (rs
->index
+ l
<= sizeof(rs
->buf
)) {
1886 memcpy(rs
->buf
+ rs
->index
, buf
, l
);
1888 fprintf(stderr
, "serious error: oversized packet received,"
1889 "connection terminated.\n");
1890 rs
->index
= rs
->state
= 0;
1897 if (rs
->index
>= rs
->packet_len
) {
1900 assert(rs
->finalize
);