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_send_packet(NetClientState
*sender
)
534 int vm_running
= runstate_is_running();
544 if (sender
->peer
->receive_disabled
) {
546 } else if (sender
->peer
->info
->can_receive
&&
547 !sender
->peer
->info
->can_receive(sender
->peer
)) {
553 static ssize_t
filter_receive_iov(NetClientState
*nc
,
554 NetFilterDirection direction
,
555 NetClientState
*sender
,
557 const struct iovec
*iov
,
559 NetPacketSent
*sent_cb
)
562 NetFilterState
*nf
= NULL
;
564 if (direction
== NET_FILTER_DIRECTION_TX
) {
565 QTAILQ_FOREACH(nf
, &nc
->filters
, next
) {
566 ret
= qemu_netfilter_receive(nf
, direction
, sender
, flags
, iov
,
573 QTAILQ_FOREACH_REVERSE(nf
, &nc
->filters
, next
) {
574 ret
= qemu_netfilter_receive(nf
, direction
, sender
, flags
, iov
,
585 static ssize_t
filter_receive(NetClientState
*nc
,
586 NetFilterDirection direction
,
587 NetClientState
*sender
,
591 NetPacketSent
*sent_cb
)
594 .iov_base
= (void *)data
,
598 return filter_receive_iov(nc
, direction
, sender
, flags
, &iov
, 1, sent_cb
);
601 void qemu_purge_queued_packets(NetClientState
*nc
)
607 qemu_net_queue_purge(nc
->peer
->incoming_queue
, nc
);
610 void qemu_flush_or_purge_queued_packets(NetClientState
*nc
, bool purge
)
612 nc
->receive_disabled
= 0;
614 if (nc
->peer
&& nc
->peer
->info
->type
== NET_CLIENT_DRIVER_HUBPORT
) {
615 if (net_hub_flush(nc
->peer
)) {
619 if (qemu_net_queue_flush(nc
->incoming_queue
)) {
620 /* We emptied the queue successfully, signal to the IO thread to repoll
621 * the file descriptor (for tap, for example).
625 /* Unable to empty the queue, purge remaining packets */
626 qemu_net_queue_purge(nc
->incoming_queue
, nc
->peer
);
630 void qemu_flush_queued_packets(NetClientState
*nc
)
632 qemu_flush_or_purge_queued_packets(nc
, false);
635 static ssize_t
qemu_send_packet_async_with_flags(NetClientState
*sender
,
637 const uint8_t *buf
, int size
,
638 NetPacketSent
*sent_cb
)
644 printf("qemu_send_packet_async:\n");
645 qemu_hexdump(stdout
, "net", buf
, size
);
648 if (sender
->link_down
|| !sender
->peer
) {
652 /* Let filters handle the packet first */
653 ret
= filter_receive(sender
, NET_FILTER_DIRECTION_TX
,
654 sender
, flags
, buf
, size
, sent_cb
);
659 ret
= filter_receive(sender
->peer
, NET_FILTER_DIRECTION_RX
,
660 sender
, flags
, buf
, size
, sent_cb
);
665 queue
= sender
->peer
->incoming_queue
;
667 return qemu_net_queue_send(queue
, sender
, flags
, buf
, size
, sent_cb
);
670 ssize_t
qemu_send_packet_async(NetClientState
*sender
,
671 const uint8_t *buf
, int size
,
672 NetPacketSent
*sent_cb
)
674 return qemu_send_packet_async_with_flags(sender
, QEMU_NET_PACKET_FLAG_NONE
,
678 ssize_t
qemu_send_packet(NetClientState
*nc
, const uint8_t *buf
, int size
)
680 return qemu_send_packet_async(nc
, buf
, size
, NULL
);
683 ssize_t
qemu_send_packet_raw(NetClientState
*nc
, const uint8_t *buf
, int size
)
685 return qemu_send_packet_async_with_flags(nc
, QEMU_NET_PACKET_FLAG_RAW
,
689 static ssize_t
nc_sendv_compat(NetClientState
*nc
, const struct iovec
*iov
,
690 int iovcnt
, unsigned flags
)
698 buffer
= iov
[0].iov_base
;
699 offset
= iov
[0].iov_len
;
701 offset
= iov_size(iov
, iovcnt
);
702 if (offset
> NET_BUFSIZE
) {
705 buf
= g_malloc(offset
);
707 offset
= iov_to_buf(iov
, iovcnt
, 0, buf
, offset
);
710 if (flags
& QEMU_NET_PACKET_FLAG_RAW
&& nc
->info
->receive_raw
) {
711 ret
= nc
->info
->receive_raw(nc
, buffer
, offset
);
713 ret
= nc
->info
->receive(nc
, buffer
, offset
);
720 static ssize_t
qemu_deliver_packet_iov(NetClientState
*sender
,
722 const struct iovec
*iov
,
726 NetClientState
*nc
= opaque
;
731 return iov_size(iov
, iovcnt
);
734 if (nc
->receive_disabled
) {
738 if (nc
->info
->receive_iov
&& !(flags
& QEMU_NET_PACKET_FLAG_RAW
)) {
739 ret
= nc
->info
->receive_iov(nc
, iov
, iovcnt
);
741 ret
= nc_sendv_compat(nc
, iov
, iovcnt
, flags
);
745 nc
->receive_disabled
= 1;
751 ssize_t
qemu_sendv_packet_async(NetClientState
*sender
,
752 const struct iovec
*iov
, int iovcnt
,
753 NetPacketSent
*sent_cb
)
756 size_t size
= iov_size(iov
, iovcnt
);
759 if (size
> NET_BUFSIZE
) {
763 if (sender
->link_down
|| !sender
->peer
) {
767 /* Let filters handle the packet first */
768 ret
= filter_receive_iov(sender
, NET_FILTER_DIRECTION_TX
, sender
,
769 QEMU_NET_PACKET_FLAG_NONE
, iov
, iovcnt
, sent_cb
);
774 ret
= filter_receive_iov(sender
->peer
, NET_FILTER_DIRECTION_RX
, sender
,
775 QEMU_NET_PACKET_FLAG_NONE
, iov
, iovcnt
, sent_cb
);
780 queue
= sender
->peer
->incoming_queue
;
782 return qemu_net_queue_send_iov(queue
, sender
,
783 QEMU_NET_PACKET_FLAG_NONE
,
784 iov
, iovcnt
, sent_cb
);
788 qemu_sendv_packet(NetClientState
*nc
, const struct iovec
*iov
, int iovcnt
)
790 return qemu_sendv_packet_async(nc
, iov
, iovcnt
, NULL
);
793 NetClientState
*qemu_find_netdev(const char *id
)
797 QTAILQ_FOREACH(nc
, &net_clients
, next
) {
798 if (nc
->info
->type
== NET_CLIENT_DRIVER_NIC
)
800 if (!strcmp(nc
->name
, id
)) {
808 int qemu_find_net_clients_except(const char *id
, NetClientState
**ncs
,
809 NetClientDriver type
, int max
)
814 QTAILQ_FOREACH(nc
, &net_clients
, next
) {
815 if (nc
->info
->type
== type
) {
818 if (!id
|| !strcmp(nc
->name
, id
)) {
829 static int nic_get_free_idx(void)
833 for (index
= 0; index
< MAX_NICS
; index
++)
834 if (!nd_table
[index
].used
)
839 int qemu_show_nic_models(const char *arg
, const char *const *models
)
843 if (!arg
|| !is_help_option(arg
)) {
847 printf("Supported NIC models:\n");
848 for (i
= 0 ; models
[i
]; i
++) {
849 printf("%s\n", models
[i
]);
854 void qemu_check_nic_model(NICInfo
*nd
, const char *model
)
856 const char *models
[2];
861 if (qemu_show_nic_models(nd
->model
, models
))
863 if (qemu_find_nic_model(nd
, models
, model
) < 0)
867 int qemu_find_nic_model(NICInfo
*nd
, const char * const *models
,
868 const char *default_model
)
873 nd
->model
= g_strdup(default_model
);
875 for (i
= 0 ; models
[i
]; i
++) {
876 if (strcmp(nd
->model
, models
[i
]) == 0)
880 error_report("Unsupported NIC model: %s", nd
->model
);
884 static int net_init_nic(const Netdev
*netdev
, const char *name
,
885 NetClientState
*peer
, Error
**errp
)
889 const NetLegacyNicOptions
*nic
;
891 assert(netdev
->type
== NET_CLIENT_DRIVER_NIC
);
892 nic
= &netdev
->u
.nic
;
894 idx
= nic_get_free_idx();
895 if (idx
== -1 || nb_nics
>= MAX_NICS
) {
896 error_setg(errp
, "too many NICs");
902 memset(nd
, 0, sizeof(*nd
));
904 if (nic
->has_netdev
) {
905 nd
->netdev
= qemu_find_netdev(nic
->netdev
);
907 error_setg(errp
, "netdev '%s' not found", nic
->netdev
);
914 nd
->name
= g_strdup(name
);
915 if (nic
->has_model
) {
916 nd
->model
= g_strdup(nic
->model
);
919 nd
->devaddr
= g_strdup(nic
->addr
);
922 if (nic
->has_macaddr
&&
923 net_parse_macaddr(nd
->macaddr
.a
, nic
->macaddr
) < 0) {
924 error_setg(errp
, "invalid syntax for ethernet address");
927 if (nic
->has_macaddr
&&
928 is_multicast_ether_addr(nd
->macaddr
.a
)) {
930 "NIC cannot have multicast MAC address (odd 1st byte)");
933 qemu_macaddr_default_if_unset(&nd
->macaddr
);
935 if (nic
->has_vectors
) {
936 if (nic
->vectors
> 0x7ffffff) {
937 error_setg(errp
, "invalid # of vectors: %"PRIu32
, nic
->vectors
);
940 nd
->nvectors
= nic
->vectors
;
942 nd
->nvectors
= DEV_NVECTORS_UNSPECIFIED
;
952 static int (* const net_client_init_fun
[NET_CLIENT_DRIVER__MAX
])(
953 const Netdev
*netdev
,
955 NetClientState
*peer
, Error
**errp
) = {
956 [NET_CLIENT_DRIVER_NIC
] = net_init_nic
,
958 [NET_CLIENT_DRIVER_USER
] = net_init_slirp
,
960 [NET_CLIENT_DRIVER_TAP
] = net_init_tap
,
961 [NET_CLIENT_DRIVER_SOCKET
] = net_init_socket
,
963 [NET_CLIENT_DRIVER_VDE
] = net_init_vde
,
966 [NET_CLIENT_DRIVER_NETMAP
] = net_init_netmap
,
968 #ifdef CONFIG_NET_BRIDGE
969 [NET_CLIENT_DRIVER_BRIDGE
] = net_init_bridge
,
971 [NET_CLIENT_DRIVER_HUBPORT
] = net_init_hubport
,
972 #ifdef CONFIG_VHOST_NET_USER
973 [NET_CLIENT_DRIVER_VHOST_USER
] = net_init_vhost_user
,
975 #ifdef CONFIG_VHOST_NET_VDPA
976 [NET_CLIENT_DRIVER_VHOST_VDPA
] = net_init_vhost_vdpa
,
979 [NET_CLIENT_DRIVER_L2TPV3
] = net_init_l2tpv3
,
984 static int net_client_init1(const Netdev
*netdev
, bool is_netdev
, Error
**errp
)
986 NetClientState
*peer
= NULL
;
990 if (netdev
->type
== NET_CLIENT_DRIVER_NIC
||
991 !net_client_init_fun
[netdev
->type
]) {
992 error_setg(errp
, QERR_INVALID_PARAMETER_VALUE
, "type",
993 "a netdev backend type");
997 if (netdev
->type
== NET_CLIENT_DRIVER_NONE
) {
998 return 0; /* nothing to do */
1000 if (netdev
->type
== NET_CLIENT_DRIVER_HUBPORT
||
1001 !net_client_init_fun
[netdev
->type
]) {
1002 error_setg(errp
, QERR_INVALID_PARAMETER_VALUE
, "type",
1003 "a net backend type (maybe it is not compiled "
1004 "into this binary)");
1008 /* Do not add to a hub if it's a nic with a netdev= parameter. */
1009 if (netdev
->type
!= NET_CLIENT_DRIVER_NIC
||
1010 !netdev
->u
.nic
.has_netdev
) {
1011 peer
= net_hub_add_port(0, NULL
, NULL
);
1015 nc
= qemu_find_netdev(netdev
->id
);
1017 error_setg(errp
, "Duplicate ID '%s'", netdev
->id
);
1021 if (net_client_init_fun
[netdev
->type
](netdev
, netdev
->id
, peer
, errp
) < 0) {
1022 /* FIXME drop when all init functions store an Error */
1023 if (errp
&& !*errp
) {
1024 error_setg(errp
, "Device '%s' could not be initialized",
1025 NetClientDriver_str(netdev
->type
));
1031 nc
= qemu_find_netdev(netdev
->id
);
1033 nc
->is_netdev
= true;
1039 void show_netdevs(void)
1042 const char *available_netdevs
[] = {
1049 #ifdef CONFIG_L2TPV3
1055 #ifdef CONFIG_NET_BRIDGE
1058 #ifdef CONFIG_NETMAP
1064 #ifdef CONFIG_VHOST_VDPA
1069 qemu_printf("Available netdev backend types:\n");
1070 for (idx
= 0; idx
< ARRAY_SIZE(available_netdevs
); idx
++) {
1071 qemu_printf("%s\n", available_netdevs
[idx
]);
1075 static int net_client_init(QemuOpts
*opts
, bool is_netdev
, Error
**errp
)
1077 gchar
**substrings
= NULL
;
1078 Netdev
*object
= NULL
;
1080 Visitor
*v
= opts_visitor_new(opts
);
1082 /* Parse convenience option format ip6-net=fec0::0[/64] */
1083 const char *ip6_net
= qemu_opt_get(opts
, "ipv6-net");
1087 unsigned long prefix_len
= 64; /* Default 64bit prefix length. */
1089 substrings
= g_strsplit(ip6_net
, "/", 2);
1090 if (!substrings
|| !substrings
[0]) {
1091 error_setg(errp
, QERR_INVALID_PARAMETER_VALUE
, "ipv6-net",
1092 "a valid IPv6 prefix");
1096 prefix_addr
= substrings
[0];
1098 /* Handle user-specified prefix length. */
1099 if (substrings
[1] &&
1100 qemu_strtoul(substrings
[1], NULL
, 10, &prefix_len
))
1102 error_setg(errp
, QERR_INVALID_PARAMETER_VALUE
,
1103 "ipv6-prefixlen", "a number");
1107 qemu_opt_set(opts
, "ipv6-prefix", prefix_addr
, &error_abort
);
1108 qemu_opt_set_number(opts
, "ipv6-prefixlen", prefix_len
,
1110 qemu_opt_unset(opts
, "ipv6-net");
1113 /* Create an ID for -net if the user did not specify one */
1114 if (!is_netdev
&& !qemu_opts_id(opts
)) {
1115 qemu_opts_set_id(opts
, id_generate(ID_NET
));
1118 if (visit_type_Netdev(v
, NULL
, &object
, errp
)) {
1119 ret
= net_client_init1(object
, is_netdev
, errp
);
1122 qapi_free_Netdev(object
);
1125 g_strfreev(substrings
);
1130 void netdev_add(QemuOpts
*opts
, Error
**errp
)
1132 net_client_init(opts
, true, errp
);
1135 void qmp_netdev_add(Netdev
*netdev
, Error
**errp
)
1137 if (!id_wellformed(netdev
->id
)) {
1138 error_setg(errp
, QERR_INVALID_PARAMETER_VALUE
, "id", "an identifier");
1142 net_client_init1(netdev
, true, errp
);
1145 void qmp_netdev_del(const char *id
, Error
**errp
)
1150 nc
= qemu_find_netdev(id
);
1152 error_set(errp
, ERROR_CLASS_DEVICE_NOT_FOUND
,
1153 "Device '%s' not found", id
);
1157 if (!nc
->is_netdev
) {
1158 error_setg(errp
, "Device '%s' is not a netdev", id
);
1162 qemu_del_net_client(nc
);
1165 * Wart: we need to delete the QemuOpts associated with netdevs
1166 * created via CLI or HMP, to avoid bogus "Duplicate ID" errors in
1169 opts
= qemu_opts_find(qemu_find_opts("netdev"), id
);
1171 qemu_opts_del(opts
);
1175 static void netfilter_print_info(Monitor
*mon
, NetFilterState
*nf
)
1178 ObjectProperty
*prop
;
1179 ObjectPropertyIterator iter
;
1182 /* generate info str */
1183 object_property_iter_init(&iter
, OBJECT(nf
));
1184 while ((prop
= object_property_iter_next(&iter
))) {
1185 if (!strcmp(prop
->name
, "type")) {
1188 v
= string_output_visitor_new(false, &str
);
1189 object_property_get(OBJECT(nf
), prop
->name
, v
, NULL
);
1190 visit_complete(v
, &str
);
1192 monitor_printf(mon
, ",%s=%s", prop
->name
, str
);
1195 monitor_printf(mon
, "\n");
1198 void print_net_client(Monitor
*mon
, NetClientState
*nc
)
1202 monitor_printf(mon
, "%s: index=%d,type=%s,%s\n", nc
->name
,
1204 NetClientDriver_str(nc
->info
->type
),
1206 if (!QTAILQ_EMPTY(&nc
->filters
)) {
1207 monitor_printf(mon
, "filters:\n");
1209 QTAILQ_FOREACH(nf
, &nc
->filters
, next
) {
1210 monitor_printf(mon
, " - %s: type=%s",
1211 object_get_canonical_path_component(OBJECT(nf
)),
1212 object_get_typename(OBJECT(nf
)));
1213 netfilter_print_info(mon
, nf
);
1217 RxFilterInfoList
*qmp_query_rx_filter(bool has_name
, const char *name
,
1221 RxFilterInfoList
*filter_list
= NULL
, **tail
= &filter_list
;
1223 QTAILQ_FOREACH(nc
, &net_clients
, next
) {
1226 if (has_name
&& strcmp(nc
->name
, name
) != 0) {
1230 /* only query rx-filter information of NIC */
1231 if (nc
->info
->type
!= NET_CLIENT_DRIVER_NIC
) {
1233 error_setg(errp
, "net client(%s) isn't a NIC", name
);
1234 assert(!filter_list
);
1240 /* only query information on queue 0 since the info is per nic,
1243 if (nc
->queue_index
!= 0)
1246 if (nc
->info
->query_rx_filter
) {
1247 info
= nc
->info
->query_rx_filter(nc
);
1248 QAPI_LIST_APPEND(tail
, info
);
1249 } else if (has_name
) {
1250 error_setg(errp
, "net client(%s) doesn't support"
1251 " rx-filter querying", name
);
1252 assert(!filter_list
);
1261 if (filter_list
== NULL
&& has_name
) {
1262 error_setg(errp
, "invalid net client name: %s", name
);
1268 void hmp_info_network(Monitor
*mon
, const QDict
*qdict
)
1270 NetClientState
*nc
, *peer
;
1271 NetClientDriver type
;
1275 QTAILQ_FOREACH(nc
, &net_clients
, next
) {
1277 type
= nc
->info
->type
;
1279 /* Skip if already printed in hub info */
1280 if (net_hub_id_for_client(nc
, NULL
) == 0) {
1284 if (!peer
|| type
== NET_CLIENT_DRIVER_NIC
) {
1285 print_net_client(mon
, nc
);
1286 } /* else it's a netdev connected to a NIC, printed with the NIC */
1287 if (peer
&& type
== NET_CLIENT_DRIVER_NIC
) {
1288 monitor_printf(mon
, " \\ ");
1289 print_net_client(mon
, peer
);
1294 void colo_notify_filters_event(int event
, Error
**errp
)
1298 NetFilterClass
*nfc
= NULL
;
1299 Error
*local_err
= NULL
;
1301 QTAILQ_FOREACH(nc
, &net_clients
, next
) {
1302 QTAILQ_FOREACH(nf
, &nc
->filters
, next
) {
1303 nfc
= NETFILTER_GET_CLASS(OBJECT(nf
));
1304 nfc
->handle_event(nf
, event
, &local_err
);
1306 error_propagate(errp
, local_err
);
1313 void qmp_set_link(const char *name
, bool up
, Error
**errp
)
1315 NetClientState
*ncs
[MAX_QUEUE_NUM
];
1319 queues
= qemu_find_net_clients_except(name
, ncs
,
1320 NET_CLIENT_DRIVER__MAX
,
1324 error_set(errp
, ERROR_CLASS_DEVICE_NOT_FOUND
,
1325 "Device '%s' not found", name
);
1330 for (i
= 0; i
< queues
; i
++) {
1331 ncs
[i
]->link_down
= !up
;
1334 if (nc
->info
->link_status_changed
) {
1335 nc
->info
->link_status_changed(nc
);
1339 /* Change peer link only if the peer is NIC and then notify peer.
1340 * If the peer is a HUBPORT or a backend, we do not change the
1343 * This behavior is compatible with qemu hubs where there could be
1344 * multiple clients that can still communicate with each other in
1345 * disconnected mode. For now maintain this compatibility.
1347 if (nc
->peer
->info
->type
== NET_CLIENT_DRIVER_NIC
) {
1348 for (i
= 0; i
< queues
; i
++) {
1349 ncs
[i
]->peer
->link_down
= !up
;
1352 if (nc
->peer
->info
->link_status_changed
) {
1353 nc
->peer
->info
->link_status_changed(nc
->peer
);
1358 static void net_vm_change_state_handler(void *opaque
, bool running
,
1362 NetClientState
*tmp
;
1364 QTAILQ_FOREACH_SAFE(nc
, &net_clients
, next
, tmp
) {
1366 /* Flush queued packets and wake up backends. */
1367 if (nc
->peer
&& qemu_can_send_packet(nc
)) {
1368 qemu_flush_queued_packets(nc
->peer
);
1371 /* Complete all queued packets, to guarantee we don't modify
1372 * state later when VM is not running.
1374 qemu_flush_or_purge_queued_packets(nc
, true);
1379 void net_cleanup(void)
1383 /* We may del multiple entries during qemu_del_net_client(),
1384 * so QTAILQ_FOREACH_SAFE() is also not safe here.
1386 while (!QTAILQ_EMPTY(&net_clients
)) {
1387 nc
= QTAILQ_FIRST(&net_clients
);
1388 if (nc
->info
->type
== NET_CLIENT_DRIVER_NIC
) {
1389 qemu_del_nic(qemu_get_nic(nc
));
1391 qemu_del_net_client(nc
);
1395 qemu_del_vm_change_state_handler(net_change_state_entry
);
1398 void net_check_clients(void)
1403 net_hub_check_clients();
1405 QTAILQ_FOREACH(nc
, &net_clients
, next
) {
1407 warn_report("%s %s has no peer",
1408 nc
->info
->type
== NET_CLIENT_DRIVER_NIC
1414 /* Check that all NICs requested via -net nic actually got created.
1415 * NICs created via -device don't need to be checked here because
1416 * they are always instantiated.
1418 for (i
= 0; i
< MAX_NICS
; i
++) {
1419 NICInfo
*nd
= &nd_table
[i
];
1420 if (nd
->used
&& !nd
->instantiated
) {
1421 warn_report("requested NIC (%s, model %s) "
1422 "was not created (not supported by this machine?)",
1423 nd
->name
? nd
->name
: "anonymous",
1424 nd
->model
? nd
->model
: "unspecified");
1429 static int net_init_client(void *dummy
, QemuOpts
*opts
, Error
**errp
)
1431 return net_client_init(opts
, false, errp
);
1434 static int net_init_netdev(void *dummy
, QemuOpts
*opts
, Error
**errp
)
1436 const char *type
= qemu_opt_get(opts
, "type");
1438 if (type
&& is_help_option(type
)) {
1442 return net_client_init(opts
, true, errp
);
1445 /* For the convenience "--nic" parameter */
1446 static int net_param_nic(void *dummy
, QemuOpts
*opts
, Error
**errp
)
1453 type
= qemu_opt_get(opts
, "type");
1454 if (type
&& g_str_equal(type
, "none")) {
1455 return 0; /* Nothing to do, default_net is cleared in vl.c */
1458 idx
= nic_get_free_idx();
1459 if (idx
== -1 || nb_nics
>= MAX_NICS
) {
1460 error_setg(errp
, "no more on-board/default NIC slots available");
1465 qemu_opt_set(opts
, "type", "user", &error_abort
);
1468 ni
= &nd_table
[idx
];
1469 memset(ni
, 0, sizeof(*ni
));
1470 ni
->model
= qemu_opt_get_del(opts
, "model");
1472 /* Create an ID if the user did not specify one */
1473 nd_id
= g_strdup(qemu_opts_id(opts
));
1475 nd_id
= id_generate(ID_NET
);
1476 qemu_opts_set_id(opts
, nd_id
);
1479 /* Handle MAC address */
1480 mac
= qemu_opt_get_del(opts
, "mac");
1482 ret
= net_parse_macaddr(ni
->macaddr
.a
, mac
);
1485 error_setg(errp
, "invalid syntax for ethernet address");
1488 if (is_multicast_ether_addr(ni
->macaddr
.a
)) {
1489 error_setg(errp
, "NIC cannot have multicast MAC address");
1494 qemu_macaddr_default_if_unset(&ni
->macaddr
);
1496 ret
= net_client_init(opts
, true, errp
);
1498 ni
->netdev
= qemu_find_netdev(nd_id
);
1508 int net_init_clients(Error
**errp
)
1510 net_change_state_entry
=
1511 qemu_add_vm_change_state_handler(net_vm_change_state_handler
, NULL
);
1513 QTAILQ_INIT(&net_clients
);
1515 if (qemu_opts_foreach(qemu_find_opts("netdev"),
1516 net_init_netdev
, NULL
, errp
)) {
1520 if (qemu_opts_foreach(qemu_find_opts("nic"), net_param_nic
, NULL
, errp
)) {
1524 if (qemu_opts_foreach(qemu_find_opts("net"), net_init_client
, NULL
, errp
)) {
1531 int net_client_parse(QemuOptsList
*opts_list
, const char *optarg
)
1533 if (!qemu_opts_parse_noisily(opts_list
, optarg
, true)) {
1542 uint32_t net_crc32(const uint8_t *p
, int len
)
1549 for (i
= 0; i
< len
; i
++) {
1551 for (j
= 0; j
< 8; j
++) {
1552 carry
= ((crc
& 0x80000000L
) ? 1 : 0) ^ (b
& 0x01);
1556 crc
= ((crc
^ POLYNOMIAL_BE
) | carry
);
1564 uint32_t net_crc32_le(const uint8_t *p
, int len
)
1571 for (i
= 0; i
< len
; i
++) {
1573 for (j
= 0; j
< 8; j
++) {
1574 carry
= (crc
& 0x1) ^ (b
& 0x01);
1578 crc
^= POLYNOMIAL_LE
;
1586 QemuOptsList qemu_netdev_opts
= {
1588 .implied_opt_name
= "type",
1589 .head
= QTAILQ_HEAD_INITIALIZER(qemu_netdev_opts
.head
),
1592 * no elements => accept any params
1593 * validation will happen later
1595 { /* end of list */ }
1599 QemuOptsList qemu_nic_opts
= {
1601 .implied_opt_name
= "type",
1602 .head
= QTAILQ_HEAD_INITIALIZER(qemu_nic_opts
.head
),
1605 * no elements => accept any params
1606 * validation will happen later
1608 { /* end of list */ }
1612 QemuOptsList qemu_net_opts
= {
1614 .implied_opt_name
= "type",
1615 .head
= QTAILQ_HEAD_INITIALIZER(qemu_net_opts
.head
),
1618 * no elements => accept any params
1619 * validation will happen later
1621 { /* end of list */ }
1625 void net_socket_rs_init(SocketReadState
*rs
,
1626 SocketReadStateFinalize
*finalize
,
1630 rs
->vnet_hdr
= vnet_hdr
;
1633 rs
->vnet_hdr_len
= 0;
1634 memset(rs
->buf
, 0, sizeof(rs
->buf
));
1635 rs
->finalize
= finalize
;
1643 int net_fill_rstate(SocketReadState
*rs
, const uint8_t *buf
, int size
)
1648 /* Reassemble a packet from the network.
1649 * 0 = getting length.
1650 * 1 = getting vnet header length.
1653 switch (rs
->state
) {
1659 memcpy(rs
->buf
+ rs
->index
, buf
, l
);
1663 if (rs
->index
== 4) {
1665 rs
->packet_len
= ntohl(*(uint32_t *)rs
->buf
);
1671 rs
->vnet_hdr_len
= 0;
1680 memcpy(rs
->buf
+ rs
->index
, buf
, l
);
1684 if (rs
->index
== 4) {
1685 /* got vnet header length */
1686 rs
->vnet_hdr_len
= ntohl(*(uint32_t *)rs
->buf
);
1692 l
= rs
->packet_len
- rs
->index
;
1696 if (rs
->index
+ l
<= sizeof(rs
->buf
)) {
1697 memcpy(rs
->buf
+ rs
->index
, buf
, l
);
1699 fprintf(stderr
, "serious error: oversized packet received,"
1700 "connection terminated.\n");
1701 rs
->index
= rs
->state
= 0;
1708 if (rs
->index
>= rs
->packet_len
) {
1711 assert(rs
->finalize
);