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
24 #include "qemu/osdep.h"
29 #include "net/slirp.h"
33 #include "monitor/monitor.h"
34 #include "qemu-common.h"
35 #include "qemu/help_option.h"
36 #include "qapi/qmp/qerror.h"
37 #include "qemu/error-report.h"
38 #include "qemu/sockets.h"
39 #include "qemu/cutils.h"
40 #include "qemu/config-file.h"
41 #include "qmp-commands.h"
44 #include "qemu/main-loop.h"
45 #include "qapi-visit.h"
46 #include "qapi/opts-visitor.h"
47 #include "sysemu/sysemu.h"
48 #include "sysemu/qtest.h"
49 #include "net/filter.h"
50 #include "qapi/string-output-visitor.h"
52 /* Net bridge is currently not supported for W32. */
54 # define CONFIG_NET_BRIDGE
57 static VMChangeStateEntry
*net_change_state_entry
;
58 static QTAILQ_HEAD(, NetClientState
) net_clients
;
60 const char *host_net_devices
[] = {
64 #ifdef CONFIG_NET_BRIDGE
80 /***********************************************************/
81 /* network device redirectors */
83 static int get_str_sep(char *buf
, int buf_size
, const char **pp
, int sep
)
94 if (len
> buf_size
- 1)
103 int parse_host_port(struct sockaddr_in
*saddr
, const char *str
,
112 if (get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0) {
113 error_setg(errp
, "host address '%s' doesn't contain ':' "
114 "separating host from port", str
);
117 saddr
->sin_family
= AF_INET
;
118 if (buf
[0] == '\0') {
119 saddr
->sin_addr
.s_addr
= 0;
121 if (qemu_isdigit(buf
[0])) {
122 if (!inet_aton(buf
, &saddr
->sin_addr
)) {
123 error_setg(errp
, "host address '%s' is not a valid "
124 "IPv4 address", buf
);
128 he
= gethostbyname(buf
);
130 error_setg(errp
, "can't resolve host address '%s'", buf
);
133 saddr
->sin_addr
= *(struct in_addr
*)he
->h_addr
;
136 port
= strtol(p
, (char **)&r
, 0);
138 error_setg(errp
, "port number '%s' is invalid", p
);
141 saddr
->sin_port
= htons(port
);
145 char *qemu_mac_strdup_printf(const uint8_t *macaddr
)
147 return g_strdup_printf("%.2x:%.2x:%.2x:%.2x:%.2x:%.2x",
148 macaddr
[0], macaddr
[1], macaddr
[2],
149 macaddr
[3], macaddr
[4], macaddr
[5]);
152 void qemu_format_nic_info_str(NetClientState
*nc
, uint8_t macaddr
[6])
154 snprintf(nc
->info_str
, sizeof(nc
->info_str
),
155 "model=%s,macaddr=%02x:%02x:%02x:%02x:%02x:%02x",
157 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
)
252 static void qemu_net_client_setup(NetClientState
*nc
,
254 NetClientState
*peer
,
257 NetClientDestructor
*destructor
)
260 nc
->model
= g_strdup(model
);
262 nc
->name
= g_strdup(name
);
264 nc
->name
= assign_name(nc
, model
);
272 QTAILQ_INSERT_TAIL(&net_clients
, nc
, next
);
274 nc
->incoming_queue
= qemu_new_net_queue(qemu_deliver_packet_iov
, nc
);
275 nc
->destructor
= destructor
;
276 QTAILQ_INIT(&nc
->filters
);
279 NetClientState
*qemu_new_net_client(NetClientInfo
*info
,
280 NetClientState
*peer
,
286 assert(info
->size
>= sizeof(NetClientState
));
288 nc
= g_malloc0(info
->size
);
289 qemu_net_client_setup(nc
, info
, peer
, model
, name
,
290 qemu_net_client_destructor
);
295 NICState
*qemu_new_nic(NetClientInfo
*info
,
301 NetClientState
**peers
= conf
->peers
.ncs
;
303 int i
, queues
= MAX(1, conf
->peers
.queues
);
305 assert(info
->type
== NET_CLIENT_DRIVER_NIC
);
306 assert(info
->size
>= sizeof(NICState
));
308 nic
= g_malloc0(info
->size
+ sizeof(NetClientState
) * queues
);
309 nic
->ncs
= (void *)nic
+ info
->size
;
311 nic
->opaque
= opaque
;
313 for (i
= 0; i
< queues
; i
++) {
314 qemu_net_client_setup(&nic
->ncs
[i
], info
, peers
[i
], model
, name
,
316 nic
->ncs
[i
].queue_index
= i
;
322 NetClientState
*qemu_get_subqueue(NICState
*nic
, int queue_index
)
324 return nic
->ncs
+ queue_index
;
327 NetClientState
*qemu_get_queue(NICState
*nic
)
329 return qemu_get_subqueue(nic
, 0);
332 NICState
*qemu_get_nic(NetClientState
*nc
)
334 NetClientState
*nc0
= nc
- nc
->queue_index
;
336 return (NICState
*)((void *)nc0
- nc
->info
->size
);
339 void *qemu_get_nic_opaque(NetClientState
*nc
)
341 NICState
*nic
= qemu_get_nic(nc
);
346 static void qemu_cleanup_net_client(NetClientState
*nc
)
348 QTAILQ_REMOVE(&net_clients
, nc
, next
);
350 if (nc
->info
->cleanup
) {
351 nc
->info
->cleanup(nc
);
355 static void qemu_free_net_client(NetClientState
*nc
)
357 if (nc
->incoming_queue
) {
358 qemu_del_net_queue(nc
->incoming_queue
);
361 nc
->peer
->peer
= NULL
;
365 if (nc
->destructor
) {
370 void qemu_del_net_client(NetClientState
*nc
)
372 NetClientState
*ncs
[MAX_QUEUE_NUM
];
374 NetFilterState
*nf
, *next
;
376 assert(nc
->info
->type
!= NET_CLIENT_DRIVER_NIC
);
378 /* If the NetClientState belongs to a multiqueue backend, we will change all
379 * other NetClientStates also.
381 queues
= qemu_find_net_clients_except(nc
->name
, ncs
,
382 NET_CLIENT_DRIVER_NIC
,
386 QTAILQ_FOREACH_SAFE(nf
, &nc
->filters
, next
, next
) {
387 object_unparent(OBJECT(nf
));
390 /* If there is a peer NIC, delete and cleanup client, but do not free. */
391 if (nc
->peer
&& nc
->peer
->info
->type
== NET_CLIENT_DRIVER_NIC
) {
392 NICState
*nic
= qemu_get_nic(nc
->peer
);
393 if (nic
->peer_deleted
) {
396 nic
->peer_deleted
= true;
398 for (i
= 0; i
< queues
; i
++) {
399 ncs
[i
]->peer
->link_down
= true;
402 if (nc
->peer
->info
->link_status_changed
) {
403 nc
->peer
->info
->link_status_changed(nc
->peer
);
406 for (i
= 0; i
< queues
; i
++) {
407 qemu_cleanup_net_client(ncs
[i
]);
413 for (i
= 0; i
< queues
; i
++) {
414 qemu_cleanup_net_client(ncs
[i
]);
415 qemu_free_net_client(ncs
[i
]);
419 void qemu_del_nic(NICState
*nic
)
421 int i
, queues
= MAX(nic
->conf
->peers
.queues
, 1);
423 qemu_macaddr_set_free(&nic
->conf
->macaddr
);
425 /* If this is a peer NIC and peer has already been deleted, free it now. */
426 if (nic
->peer_deleted
) {
427 for (i
= 0; i
< queues
; i
++) {
428 qemu_free_net_client(qemu_get_subqueue(nic
, i
)->peer
);
432 for (i
= queues
- 1; i
>= 0; i
--) {
433 NetClientState
*nc
= qemu_get_subqueue(nic
, i
);
435 qemu_cleanup_net_client(nc
);
436 qemu_free_net_client(nc
);
442 void qemu_foreach_nic(qemu_nic_foreach func
, void *opaque
)
446 QTAILQ_FOREACH(nc
, &net_clients
, next
) {
447 if (nc
->info
->type
== NET_CLIENT_DRIVER_NIC
) {
448 if (nc
->queue_index
== 0) {
449 func(qemu_get_nic(nc
), opaque
);
455 bool qemu_has_ufo(NetClientState
*nc
)
457 if (!nc
|| !nc
->info
->has_ufo
) {
461 return nc
->info
->has_ufo(nc
);
464 bool qemu_has_vnet_hdr(NetClientState
*nc
)
466 if (!nc
|| !nc
->info
->has_vnet_hdr
) {
470 return nc
->info
->has_vnet_hdr(nc
);
473 bool qemu_has_vnet_hdr_len(NetClientState
*nc
, int len
)
475 if (!nc
|| !nc
->info
->has_vnet_hdr_len
) {
479 return nc
->info
->has_vnet_hdr_len(nc
, len
);
482 void qemu_using_vnet_hdr(NetClientState
*nc
, bool enable
)
484 if (!nc
|| !nc
->info
->using_vnet_hdr
) {
488 nc
->info
->using_vnet_hdr(nc
, enable
);
491 void qemu_set_offload(NetClientState
*nc
, int csum
, int tso4
, int tso6
,
494 if (!nc
|| !nc
->info
->set_offload
) {
498 nc
->info
->set_offload(nc
, csum
, tso4
, tso6
, ecn
, ufo
);
501 void qemu_set_vnet_hdr_len(NetClientState
*nc
, int len
)
503 if (!nc
|| !nc
->info
->set_vnet_hdr_len
) {
507 nc
->vnet_hdr_len
= len
;
508 nc
->info
->set_vnet_hdr_len(nc
, len
);
511 int qemu_set_vnet_le(NetClientState
*nc
, bool is_le
)
513 #ifdef HOST_WORDS_BIGENDIAN
514 if (!nc
|| !nc
->info
->set_vnet_le
) {
518 return nc
->info
->set_vnet_le(nc
, is_le
);
524 int qemu_set_vnet_be(NetClientState
*nc
, bool is_be
)
526 #ifdef HOST_WORDS_BIGENDIAN
529 if (!nc
|| !nc
->info
->set_vnet_be
) {
533 return nc
->info
->set_vnet_be(nc
, is_be
);
537 int qemu_can_send_packet(NetClientState
*sender
)
539 int vm_running
= runstate_is_running();
549 if (sender
->peer
->receive_disabled
) {
551 } else if (sender
->peer
->info
->can_receive
&&
552 !sender
->peer
->info
->can_receive(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
, NetFilterHead
, 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
);
616 void qemu_flush_or_purge_queued_packets(NetClientState
*nc
, bool purge
)
618 nc
->receive_disabled
= 0;
620 if (nc
->peer
&& nc
->peer
->info
->type
== NET_CLIENT_DRIVER_HUBPORT
) {
621 if (net_hub_flush(nc
->peer
)) {
625 if (qemu_net_queue_flush(nc
->incoming_queue
)) {
626 /* We emptied the queue successfully, signal to the IO thread to repoll
627 * the file descriptor (for tap, for example).
631 /* Unable to empty the queue, purge remaining packets */
632 qemu_net_queue_purge(nc
->incoming_queue
, nc
);
636 void qemu_flush_queued_packets(NetClientState
*nc
)
638 qemu_flush_or_purge_queued_packets(nc
, false);
641 static ssize_t
qemu_send_packet_async_with_flags(NetClientState
*sender
,
643 const uint8_t *buf
, int size
,
644 NetPacketSent
*sent_cb
)
650 printf("qemu_send_packet_async:\n");
651 qemu_hexdump((const char *)buf
, stdout
, "net", size
);
654 if (sender
->link_down
|| !sender
->peer
) {
658 /* Let filters handle the packet first */
659 ret
= filter_receive(sender
, NET_FILTER_DIRECTION_TX
,
660 sender
, flags
, buf
, size
, sent_cb
);
665 ret
= filter_receive(sender
->peer
, NET_FILTER_DIRECTION_RX
,
666 sender
, flags
, buf
, size
, sent_cb
);
671 queue
= sender
->peer
->incoming_queue
;
673 return qemu_net_queue_send(queue
, sender
, flags
, buf
, size
, sent_cb
);
676 ssize_t
qemu_send_packet_async(NetClientState
*sender
,
677 const uint8_t *buf
, int size
,
678 NetPacketSent
*sent_cb
)
680 return qemu_send_packet_async_with_flags(sender
, QEMU_NET_PACKET_FLAG_NONE
,
684 void qemu_send_packet(NetClientState
*nc
, const uint8_t *buf
, int size
)
686 qemu_send_packet_async(nc
, buf
, size
, NULL
);
689 ssize_t
qemu_send_packet_raw(NetClientState
*nc
, const uint8_t *buf
, int size
)
691 return qemu_send_packet_async_with_flags(nc
, QEMU_NET_PACKET_FLAG_RAW
,
695 static ssize_t
nc_sendv_compat(NetClientState
*nc
, const struct iovec
*iov
,
696 int iovcnt
, unsigned flags
)
704 buffer
= iov
[0].iov_base
;
705 offset
= iov
[0].iov_len
;
707 offset
= iov_size(iov
, iovcnt
);
708 if (offset
> NET_BUFSIZE
) {
711 buf
= g_malloc(offset
);
713 offset
= iov_to_buf(iov
, iovcnt
, 0, buf
, offset
);
716 if (flags
& QEMU_NET_PACKET_FLAG_RAW
&& nc
->info
->receive_raw
) {
717 ret
= nc
->info
->receive_raw(nc
, buffer
, offset
);
719 ret
= nc
->info
->receive(nc
, buffer
, offset
);
726 ssize_t
qemu_deliver_packet_iov(NetClientState
*sender
,
728 const struct iovec
*iov
,
732 NetClientState
*nc
= opaque
;
736 return iov_size(iov
, iovcnt
);
739 if (nc
->receive_disabled
) {
743 if (nc
->info
->receive_iov
&& !(flags
& QEMU_NET_PACKET_FLAG_RAW
)) {
744 ret
= nc
->info
->receive_iov(nc
, iov
, iovcnt
);
746 ret
= nc_sendv_compat(nc
, iov
, iovcnt
, flags
);
750 nc
->receive_disabled
= 1;
756 ssize_t
qemu_sendv_packet_async(NetClientState
*sender
,
757 const struct iovec
*iov
, int iovcnt
,
758 NetPacketSent
*sent_cb
)
763 if (sender
->link_down
|| !sender
->peer
) {
764 return iov_size(iov
, iovcnt
);
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 fprintf(stderr
, "qemu: Supported NIC models: ");
848 for (i
= 0 ; models
[i
]; i
++)
849 fprintf(stderr
, "%s%c", models
[i
], models
[i
+1] ? ',' : '\n');
853 void qemu_check_nic_model(NICInfo
*nd
, const char *model
)
855 const char *models
[2];
860 if (qemu_show_nic_models(nd
->model
, models
))
862 if (qemu_find_nic_model(nd
, models
, model
) < 0)
866 int qemu_find_nic_model(NICInfo
*nd
, const char * const *models
,
867 const char *default_model
)
872 nd
->model
= g_strdup(default_model
);
874 for (i
= 0 ; models
[i
]; i
++) {
875 if (strcmp(nd
->model
, models
[i
]) == 0)
879 error_report("Unsupported NIC model: %s", nd
->model
);
883 static int net_init_nic(const Netdev
*netdev
, const char *name
,
884 NetClientState
*peer
, Error
**errp
)
888 const NetLegacyNicOptions
*nic
;
890 assert(netdev
->type
== NET_CLIENT_DRIVER_NIC
);
891 nic
= &netdev
->u
.nic
;
893 idx
= nic_get_free_idx();
894 if (idx
== -1 || nb_nics
>= MAX_NICS
) {
895 error_setg(errp
, "too many NICs");
901 memset(nd
, 0, sizeof(*nd
));
903 if (nic
->has_netdev
) {
904 nd
->netdev
= qemu_find_netdev(nic
->netdev
);
906 error_setg(errp
, "netdev '%s' not found", nic
->netdev
);
913 nd
->name
= g_strdup(name
);
914 if (nic
->has_model
) {
915 nd
->model
= g_strdup(nic
->model
);
918 nd
->devaddr
= g_strdup(nic
->addr
);
921 if (nic
->has_macaddr
&&
922 net_parse_macaddr(nd
->macaddr
.a
, nic
->macaddr
) < 0) {
923 error_setg(errp
, "invalid syntax for ethernet address");
926 if (nic
->has_macaddr
&&
927 is_multicast_ether_addr(nd
->macaddr
.a
)) {
929 "NIC cannot have multicast MAC address (odd 1st byte)");
932 qemu_macaddr_default_if_unset(&nd
->macaddr
);
934 if (nic
->has_vectors
) {
935 if (nic
->vectors
> 0x7ffffff) {
936 error_setg(errp
, "invalid # of vectors: %"PRIu32
, nic
->vectors
);
939 nd
->nvectors
= nic
->vectors
;
941 nd
->nvectors
= DEV_NVECTORS_UNSPECIFIED
;
951 static int (* const net_client_init_fun
[NET_CLIENT_DRIVER__MAX
])(
952 const Netdev
*netdev
,
954 NetClientState
*peer
, Error
**errp
) = {
955 [NET_CLIENT_DRIVER_NIC
] = net_init_nic
,
957 [NET_CLIENT_DRIVER_USER
] = net_init_slirp
,
959 [NET_CLIENT_DRIVER_TAP
] = net_init_tap
,
960 [NET_CLIENT_DRIVER_SOCKET
] = net_init_socket
,
962 [NET_CLIENT_DRIVER_VDE
] = net_init_vde
,
965 [NET_CLIENT_DRIVER_NETMAP
] = net_init_netmap
,
967 [NET_CLIENT_DRIVER_DUMP
] = net_init_dump
,
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_USED
973 [NET_CLIENT_DRIVER_VHOST_USER
] = net_init_vhost_user
,
976 [NET_CLIENT_DRIVER_L2TPV3
] = net_init_l2tpv3
,
981 static int net_client_init1(const void *object
, bool is_netdev
, Error
**errp
)
984 const Netdev
*netdev
;
986 NetClientState
*peer
= NULL
;
987 static bool vlan_warned
;
993 if (netdev
->type
== NET_CLIENT_DRIVER_DUMP
||
994 netdev
->type
== NET_CLIENT_DRIVER_NIC
||
995 !net_client_init_fun
[netdev
->type
]) {
996 error_setg(errp
, QERR_INVALID_PARAMETER_VALUE
, "type",
997 "a netdev backend type");
1001 const NetLegacy
*net
= object
;
1002 const NetLegacyOptions
*opts
= net
->opts
;
1003 legacy
.id
= net
->id
;
1005 /* missing optional values have been initialized to "all bits zero" */
1006 name
= net
->has_id
? net
->id
: net
->name
;
1008 /* Map the old options to the new flat type */
1009 switch (opts
->type
) {
1010 case NET_LEGACY_OPTIONS_TYPE_NONE
:
1011 return 0; /* nothing to do */
1012 case NET_LEGACY_OPTIONS_TYPE_NIC
:
1013 legacy
.type
= NET_CLIENT_DRIVER_NIC
;
1014 legacy
.u
.nic
= opts
->u
.nic
;
1016 case NET_LEGACY_OPTIONS_TYPE_USER
:
1017 legacy
.type
= NET_CLIENT_DRIVER_USER
;
1018 legacy
.u
.user
= opts
->u
.user
;
1020 case NET_LEGACY_OPTIONS_TYPE_TAP
:
1021 legacy
.type
= NET_CLIENT_DRIVER_TAP
;
1022 legacy
.u
.tap
= opts
->u
.tap
;
1024 case NET_LEGACY_OPTIONS_TYPE_L2TPV3
:
1025 legacy
.type
= NET_CLIENT_DRIVER_L2TPV3
;
1026 legacy
.u
.l2tpv3
= opts
->u
.l2tpv3
;
1028 case NET_LEGACY_OPTIONS_TYPE_SOCKET
:
1029 legacy
.type
= NET_CLIENT_DRIVER_SOCKET
;
1030 legacy
.u
.socket
= opts
->u
.socket
;
1032 case NET_LEGACY_OPTIONS_TYPE_VDE
:
1033 legacy
.type
= NET_CLIENT_DRIVER_VDE
;
1034 legacy
.u
.vde
= opts
->u
.vde
;
1036 case NET_LEGACY_OPTIONS_TYPE_DUMP
:
1037 legacy
.type
= NET_CLIENT_DRIVER_DUMP
;
1038 legacy
.u
.dump
= opts
->u
.dump
;
1040 case NET_LEGACY_OPTIONS_TYPE_BRIDGE
:
1041 legacy
.type
= NET_CLIENT_DRIVER_BRIDGE
;
1042 legacy
.u
.bridge
= opts
->u
.bridge
;
1044 case NET_LEGACY_OPTIONS_TYPE_NETMAP
:
1045 legacy
.type
= NET_CLIENT_DRIVER_NETMAP
;
1046 legacy
.u
.netmap
= opts
->u
.netmap
;
1048 case NET_LEGACY_OPTIONS_TYPE_VHOST_USER
:
1049 legacy
.type
= NET_CLIENT_DRIVER_VHOST_USER
;
1050 legacy
.u
.vhost_user
= opts
->u
.vhost_user
;
1056 if (!net_client_init_fun
[netdev
->type
]) {
1057 error_setg(errp
, QERR_INVALID_PARAMETER_VALUE
, "type",
1058 "a net backend type (maybe it is not compiled "
1059 "into this binary)");
1063 /* Do not add to a vlan if it's a nic with a netdev= parameter. */
1064 if (netdev
->type
!= NET_CLIENT_DRIVER_NIC
||
1065 !opts
->u
.nic
.has_netdev
) {
1066 peer
= net_hub_add_port(net
->has_vlan
? net
->vlan
: 0, NULL
);
1069 if (net
->has_vlan
&& !vlan_warned
) {
1070 error_report("'vlan' is deprecated. Please use 'netdev' instead.");
1075 if (net_client_init_fun
[netdev
->type
](netdev
, name
, peer
, errp
) < 0) {
1076 /* FIXME drop when all init functions store an Error */
1077 if (errp
&& !*errp
) {
1078 error_setg(errp
, QERR_DEVICE_INIT_FAILED
,
1079 NetClientDriver_str(netdev
->type
));
1087 int net_client_init(QemuOpts
*opts
, bool is_netdev
, Error
**errp
)
1089 void *object
= NULL
;
1092 Visitor
*v
= opts_visitor_new(opts
);
1095 /* Parse convenience option format ip6-net=fec0::0[/64] */
1096 const char *ip6_net
= qemu_opt_get(opts
, "ipv6-net");
1099 char buf
[strlen(ip6_net
) + 1];
1101 if (get_str_sep(buf
, sizeof(buf
), &ip6_net
, '/') < 0) {
1102 /* Default 64bit prefix length. */
1103 qemu_opt_set(opts
, "ipv6-prefix", ip6_net
, &error_abort
);
1104 qemu_opt_set_number(opts
, "ipv6-prefixlen", 64, &error_abort
);
1106 /* User-specified prefix length. */
1110 qemu_opt_set(opts
, "ipv6-prefix", buf
, &error_abort
);
1111 err
= qemu_strtoul(ip6_net
, NULL
, 10, &len
);
1114 error_setg(errp
, QERR_INVALID_PARAMETER_VALUE
,
1115 "ipv6-prefix", "a number");
1117 qemu_opt_set_number(opts
, "ipv6-prefixlen", len
,
1121 qemu_opt_unset(opts
, "ipv6-net");
1126 visit_type_Netdev(v
, NULL
, (Netdev
**)&object
, &err
);
1128 visit_type_NetLegacy(v
, NULL
, (NetLegacy
**)&object
, &err
);
1132 ret
= net_client_init1(object
, is_netdev
, &err
);
1136 qapi_free_Netdev(object
);
1138 qapi_free_NetLegacy(object
);
1141 error_propagate(errp
, err
);
1147 static int net_host_check_device(const char *device
)
1150 for (i
= 0; host_net_devices
[i
]; i
++) {
1151 if (!strncmp(host_net_devices
[i
], device
,
1152 strlen(host_net_devices
[i
]))) {
1160 void hmp_host_net_add(Monitor
*mon
, const QDict
*qdict
)
1162 const char *device
= qdict_get_str(qdict
, "device");
1163 const char *opts_str
= qdict_get_try_str(qdict
, "opts");
1164 Error
*local_err
= NULL
;
1168 if (!warned
&& !qtest_enabled()) {
1169 error_report("host_net_add is deprecated, use netdev_add instead");
1173 if (!net_host_check_device(device
)) {
1174 monitor_printf(mon
, "invalid host network device %s\n", device
);
1178 opts
= qemu_opts_parse_noisily(qemu_find_opts("net"),
1179 opts_str
? opts_str
: "", false);
1184 qemu_opt_set(opts
, "type", device
, &error_abort
);
1186 net_client_init(opts
, false, &local_err
);
1188 error_report_err(local_err
);
1189 monitor_printf(mon
, "adding host network device %s failed\n", device
);
1193 void hmp_host_net_remove(Monitor
*mon
, const QDict
*qdict
)
1196 int vlan_id
= qdict_get_int(qdict
, "vlan_id");
1197 const char *device
= qdict_get_str(qdict
, "device");
1200 if (!warned
&& !qtest_enabled()) {
1201 error_report("host_net_remove is deprecated, use netdev_del instead");
1205 nc
= net_hub_find_client_by_name(vlan_id
, device
);
1207 error_report("Host network device '%s' on hub '%d' not found",
1211 if (nc
->info
->type
== NET_CLIENT_DRIVER_NIC
) {
1212 error_report("invalid host network device '%s'", device
);
1216 qemu_del_net_client(nc
->peer
);
1217 qemu_del_net_client(nc
);
1218 qemu_opts_del(qemu_opts_find(qemu_find_opts("net"), device
));
1221 void netdev_add(QemuOpts
*opts
, Error
**errp
)
1223 net_client_init(opts
, true, errp
);
1226 void qmp_netdev_add(QDict
*qdict
, QObject
**ret
, Error
**errp
)
1228 Error
*local_err
= NULL
;
1229 QemuOptsList
*opts_list
;
1232 opts_list
= qemu_find_opts_err("netdev", &local_err
);
1237 opts
= qemu_opts_from_qdict(opts_list
, qdict
, &local_err
);
1242 netdev_add(opts
, &local_err
);
1244 qemu_opts_del(opts
);
1249 error_propagate(errp
, local_err
);
1252 void qmp_netdev_del(const char *id
, Error
**errp
)
1257 nc
= qemu_find_netdev(id
);
1259 error_set(errp
, ERROR_CLASS_DEVICE_NOT_FOUND
,
1260 "Device '%s' not found", id
);
1264 opts
= qemu_opts_find(qemu_find_opts_err("netdev", NULL
), id
);
1266 error_setg(errp
, "Device '%s' is not a netdev", id
);
1270 qemu_del_net_client(nc
);
1271 qemu_opts_del(opts
);
1274 static void netfilter_print_info(Monitor
*mon
, NetFilterState
*nf
)
1277 ObjectProperty
*prop
;
1278 ObjectPropertyIterator iter
;
1281 /* generate info str */
1282 object_property_iter_init(&iter
, OBJECT(nf
));
1283 while ((prop
= object_property_iter_next(&iter
))) {
1284 if (!strcmp(prop
->name
, "type")) {
1287 v
= string_output_visitor_new(false, &str
);
1288 object_property_get(OBJECT(nf
), v
, prop
->name
, NULL
);
1289 visit_complete(v
, &str
);
1291 monitor_printf(mon
, ",%s=%s", prop
->name
, str
);
1294 monitor_printf(mon
, "\n");
1297 void print_net_client(Monitor
*mon
, NetClientState
*nc
)
1301 monitor_printf(mon
, "%s: index=%d,type=%s,%s\n", nc
->name
,
1303 NetClientDriver_str(nc
->info
->type
),
1305 if (!QTAILQ_EMPTY(&nc
->filters
)) {
1306 monitor_printf(mon
, "filters:\n");
1308 QTAILQ_FOREACH(nf
, &nc
->filters
, next
) {
1309 char *path
= object_get_canonical_path_component(OBJECT(nf
));
1311 monitor_printf(mon
, " - %s: type=%s", path
,
1312 object_get_typename(OBJECT(nf
)));
1313 netfilter_print_info(mon
, nf
);
1318 RxFilterInfoList
*qmp_query_rx_filter(bool has_name
, const char *name
,
1322 RxFilterInfoList
*filter_list
= NULL
, *last_entry
= NULL
;
1324 QTAILQ_FOREACH(nc
, &net_clients
, next
) {
1325 RxFilterInfoList
*entry
;
1328 if (has_name
&& strcmp(nc
->name
, name
) != 0) {
1332 /* only query rx-filter information of NIC */
1333 if (nc
->info
->type
!= NET_CLIENT_DRIVER_NIC
) {
1335 error_setg(errp
, "net client(%s) isn't a NIC", name
);
1341 /* only query information on queue 0 since the info is per nic,
1344 if (nc
->queue_index
!= 0)
1347 if (nc
->info
->query_rx_filter
) {
1348 info
= nc
->info
->query_rx_filter(nc
);
1349 entry
= g_malloc0(sizeof(*entry
));
1350 entry
->value
= info
;
1353 filter_list
= entry
;
1355 last_entry
->next
= entry
;
1358 } else if (has_name
) {
1359 error_setg(errp
, "net client(%s) doesn't support"
1360 " rx-filter querying", name
);
1369 if (filter_list
== NULL
&& has_name
) {
1370 error_setg(errp
, "invalid net client name: %s", name
);
1376 void hmp_info_network(Monitor
*mon
, const QDict
*qdict
)
1378 NetClientState
*nc
, *peer
;
1379 NetClientDriver type
;
1383 QTAILQ_FOREACH(nc
, &net_clients
, next
) {
1385 type
= nc
->info
->type
;
1387 /* Skip if already printed in hub info */
1388 if (net_hub_id_for_client(nc
, NULL
) == 0) {
1392 if (!peer
|| type
== NET_CLIENT_DRIVER_NIC
) {
1393 print_net_client(mon
, nc
);
1394 } /* else it's a netdev connected to a NIC, printed with the NIC */
1395 if (peer
&& type
== NET_CLIENT_DRIVER_NIC
) {
1396 monitor_printf(mon
, " \\ ");
1397 print_net_client(mon
, peer
);
1402 void qmp_set_link(const char *name
, bool up
, Error
**errp
)
1404 NetClientState
*ncs
[MAX_QUEUE_NUM
];
1408 queues
= qemu_find_net_clients_except(name
, ncs
,
1409 NET_CLIENT_DRIVER__MAX
,
1413 error_set(errp
, ERROR_CLASS_DEVICE_NOT_FOUND
,
1414 "Device '%s' not found", name
);
1419 for (i
= 0; i
< queues
; i
++) {
1420 ncs
[i
]->link_down
= !up
;
1423 if (nc
->info
->link_status_changed
) {
1424 nc
->info
->link_status_changed(nc
);
1428 /* Change peer link only if the peer is NIC and then notify peer.
1429 * If the peer is a HUBPORT or a backend, we do not change the
1432 * This behavior is compatible with qemu vlans where there could be
1433 * multiple clients that can still communicate with each other in
1434 * disconnected mode. For now maintain this compatibility.
1436 if (nc
->peer
->info
->type
== NET_CLIENT_DRIVER_NIC
) {
1437 for (i
= 0; i
< queues
; i
++) {
1438 ncs
[i
]->peer
->link_down
= !up
;
1441 if (nc
->peer
->info
->link_status_changed
) {
1442 nc
->peer
->info
->link_status_changed(nc
->peer
);
1447 static void net_vm_change_state_handler(void *opaque
, int running
,
1451 NetClientState
*tmp
;
1453 QTAILQ_FOREACH_SAFE(nc
, &net_clients
, next
, tmp
) {
1455 /* Flush queued packets and wake up backends. */
1456 if (nc
->peer
&& qemu_can_send_packet(nc
)) {
1457 qemu_flush_queued_packets(nc
->peer
);
1460 /* Complete all queued packets, to guarantee we don't modify
1461 * state later when VM is not running.
1463 qemu_flush_or_purge_queued_packets(nc
, true);
1468 void net_cleanup(void)
1472 /* We may del multiple entries during qemu_del_net_client(),
1473 * so QTAILQ_FOREACH_SAFE() is also not safe here.
1475 while (!QTAILQ_EMPTY(&net_clients
)) {
1476 nc
= QTAILQ_FIRST(&net_clients
);
1477 if (nc
->info
->type
== NET_CLIENT_DRIVER_NIC
) {
1478 qemu_del_nic(qemu_get_nic(nc
));
1480 qemu_del_net_client(nc
);
1484 qemu_del_vm_change_state_handler(net_change_state_entry
);
1487 void net_check_clients(void)
1492 net_hub_check_clients();
1494 QTAILQ_FOREACH(nc
, &net_clients
, next
) {
1496 warn_report("%s %s has no peer",
1497 nc
->info
->type
== NET_CLIENT_DRIVER_NIC
1503 /* Check that all NICs requested via -net nic actually got created.
1504 * NICs created via -device don't need to be checked here because
1505 * they are always instantiated.
1507 for (i
= 0; i
< MAX_NICS
; i
++) {
1508 NICInfo
*nd
= &nd_table
[i
];
1509 if (nd
->used
&& !nd
->instantiated
) {
1510 warn_report("requested NIC (%s, model %s) "
1511 "was not created (not supported by this machine?)",
1512 nd
->name
? nd
->name
: "anonymous",
1513 nd
->model
? nd
->model
: "unspecified");
1518 static int net_init_client(void *dummy
, QemuOpts
*opts
, Error
**errp
)
1520 Error
*local_err
= NULL
;
1522 net_client_init(opts
, false, &local_err
);
1524 error_report_err(local_err
);
1531 static int net_init_netdev(void *dummy
, QemuOpts
*opts
, Error
**errp
)
1533 Error
*local_err
= NULL
;
1536 ret
= net_client_init(opts
, true, &local_err
);
1538 error_report_err(local_err
);
1545 int net_init_clients(void)
1547 QemuOptsList
*net
= qemu_find_opts("net");
1549 net_change_state_entry
=
1550 qemu_add_vm_change_state_handler(net_vm_change_state_handler
, NULL
);
1552 QTAILQ_INIT(&net_clients
);
1554 if (qemu_opts_foreach(qemu_find_opts("netdev"),
1555 net_init_netdev
, NULL
, NULL
)) {
1559 if (qemu_opts_foreach(net
, net_init_client
, NULL
, NULL
)) {
1566 int net_client_parse(QemuOptsList
*opts_list
, const char *optarg
)
1568 if (!qemu_opts_parse_noisily(opts_list
, optarg
, true)) {
1577 uint32_t net_crc32(const uint8_t *p
, int len
)
1584 for (i
= 0; i
< len
; i
++) {
1586 for (j
= 0; j
< 8; j
++) {
1587 carry
= ((crc
& 0x80000000L
) ? 1 : 0) ^ (b
& 0x01);
1591 crc
= ((crc
^ POLYNOMIAL_BE
) | carry
);
1599 uint32_t net_crc32_le(const uint8_t *p
, int len
)
1606 for (i
= 0; i
< len
; i
++) {
1608 for (j
= 0; j
< 8; j
++) {
1609 carry
= (crc
& 0x1) ^ (b
& 0x01);
1613 crc
^= POLYNOMIAL_LE
;
1621 QemuOptsList qemu_netdev_opts
= {
1623 .implied_opt_name
= "type",
1624 .head
= QTAILQ_HEAD_INITIALIZER(qemu_netdev_opts
.head
),
1627 * no elements => accept any params
1628 * validation will happen later
1630 { /* end of list */ }
1634 QemuOptsList qemu_net_opts
= {
1636 .implied_opt_name
= "type",
1637 .head
= QTAILQ_HEAD_INITIALIZER(qemu_net_opts
.head
),
1640 * no elements => accept any params
1641 * validation will happen later
1643 { /* end of list */ }
1647 void net_socket_rs_init(SocketReadState
*rs
,
1648 SocketReadStateFinalize
*finalize
,
1652 rs
->vnet_hdr
= vnet_hdr
;
1655 rs
->vnet_hdr_len
= 0;
1656 memset(rs
->buf
, 0, sizeof(rs
->buf
));
1657 rs
->finalize
= finalize
;
1665 int net_fill_rstate(SocketReadState
*rs
, const uint8_t *buf
, int size
)
1670 /* Reassemble a packet from the network.
1671 * 0 = getting length.
1672 * 1 = getting vnet header length.
1675 switch (rs
->state
) {
1681 memcpy(rs
->buf
+ rs
->index
, buf
, l
);
1685 if (rs
->index
== 4) {
1687 rs
->packet_len
= ntohl(*(uint32_t *)rs
->buf
);
1693 rs
->vnet_hdr_len
= 0;
1702 memcpy(rs
->buf
+ rs
->index
, buf
, l
);
1706 if (rs
->index
== 4) {
1707 /* got vnet header length */
1708 rs
->vnet_hdr_len
= ntohl(*(uint32_t *)rs
->buf
);
1714 l
= rs
->packet_len
- rs
->index
;
1718 if (rs
->index
+ l
<= sizeof(rs
->buf
)) {
1719 memcpy(rs
->buf
+ rs
->index
, buf
, l
);
1721 fprintf(stderr
, "serious error: oversized packet received,"
1722 "connection terminated.\n");
1723 rs
->index
= rs
->state
= 0;
1730 if (rs
->index
>= rs
->packet_len
) {
1733 assert(rs
->finalize
);