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
);