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 "config-host.h"
29 #include "net/slirp.h"
33 #include "monitor/monitor.h"
34 #include "qemu-common.h"
35 #include "qemu/sockets.h"
36 #include "qemu/config-file.h"
37 #include "qmp-commands.h"
40 #include "qemu/main-loop.h"
41 #include "qapi-visit.h"
42 #include "qapi/opts-visitor.h"
43 #include "qapi/dealloc-visitor.h"
44 #include "sysemu/sysemu.h"
46 /* Net bridge is currently not supported for W32. */
48 # define CONFIG_NET_BRIDGE
51 static VMChangeStateEntry
*net_change_state_entry
;
52 static QTAILQ_HEAD(, NetClientState
) net_clients
;
54 const char *host_net_devices
[] = {
58 #ifdef CONFIG_NET_BRIDGE
73 /***********************************************************/
74 /* network device redirectors */
76 #if defined(DEBUG_NET)
77 static void hex_dump(FILE *f
, const uint8_t *buf
, int size
)
81 for(i
=0;i
<size
;i
+=16) {
85 fprintf(f
, "%08x ", i
);
88 fprintf(f
, " %02x", buf
[i
+j
]);
95 if (c
< ' ' || c
> '~')
104 static int get_str_sep(char *buf
, int buf_size
, const char **pp
, int sep
)
115 if (len
> buf_size
- 1)
124 int parse_host_port(struct sockaddr_in
*saddr
, const char *str
)
132 if (get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0)
134 saddr
->sin_family
= AF_INET
;
135 if (buf
[0] == '\0') {
136 saddr
->sin_addr
.s_addr
= 0;
138 if (qemu_isdigit(buf
[0])) {
139 if (!inet_aton(buf
, &saddr
->sin_addr
))
142 if ((he
= gethostbyname(buf
)) == NULL
)
144 saddr
->sin_addr
= *(struct in_addr
*)he
->h_addr
;
147 port
= strtol(p
, (char **)&r
, 0);
150 saddr
->sin_port
= htons(port
);
154 char *qemu_mac_strdup_printf(const uint8_t *macaddr
)
156 return g_strdup_printf("%.2x:%.2x:%.2x:%.2x:%.2x:%.2x",
157 macaddr
[0], macaddr
[1], macaddr
[2],
158 macaddr
[3], macaddr
[4], macaddr
[5]);
161 void qemu_format_nic_info_str(NetClientState
*nc
, uint8_t macaddr
[6])
163 snprintf(nc
->info_str
, sizeof(nc
->info_str
),
164 "model=%s,macaddr=%02x:%02x:%02x:%02x:%02x:%02x",
166 macaddr
[0], macaddr
[1], macaddr
[2],
167 macaddr
[3], macaddr
[4], macaddr
[5]);
170 static int mac_table
[256] = {0};
172 static void qemu_macaddr_set_used(MACAddr
*macaddr
)
176 for (index
= 0x56; index
< 0xFF; index
++) {
177 if (macaddr
->a
[5] == index
) {
183 static void qemu_macaddr_set_free(MACAddr
*macaddr
)
186 static const MACAddr base
= { .a
= { 0x52, 0x54, 0x00, 0x12, 0x34, 0 } };
188 if (memcmp(macaddr
->a
, &base
.a
, (sizeof(base
.a
) - 1)) != 0) {
191 for (index
= 0x56; index
< 0xFF; index
++) {
192 if (macaddr
->a
[5] == index
) {
198 static int qemu_macaddr_get_free(void)
202 for (index
= 0x56; index
< 0xFF; index
++) {
203 if (mac_table
[index
] == 0) {
211 void qemu_macaddr_default_if_unset(MACAddr
*macaddr
)
213 static const MACAddr zero
= { .a
= { 0,0,0,0,0,0 } };
214 static const MACAddr base
= { .a
= { 0x52, 0x54, 0x00, 0x12, 0x34, 0 } };
216 if (memcmp(macaddr
, &zero
, sizeof(zero
)) != 0) {
217 if (memcmp(macaddr
->a
, &base
.a
, (sizeof(base
.a
) - 1)) != 0) {
220 qemu_macaddr_set_used(macaddr
);
225 macaddr
->a
[0] = 0x52;
226 macaddr
->a
[1] = 0x54;
227 macaddr
->a
[2] = 0x00;
228 macaddr
->a
[3] = 0x12;
229 macaddr
->a
[4] = 0x34;
230 macaddr
->a
[5] = qemu_macaddr_get_free();
231 qemu_macaddr_set_used(macaddr
);
235 * Generate a name for net client
237 * Only net clients created with the legacy -net option and NICs need this.
239 static char *assign_name(NetClientState
*nc1
, const char *model
)
244 QTAILQ_FOREACH(nc
, &net_clients
, next
) {
248 if (strcmp(nc
->model
, model
) == 0) {
253 return g_strdup_printf("%s.%d", model
, id
);
256 static void qemu_net_client_destructor(NetClientState
*nc
)
261 static void qemu_net_client_setup(NetClientState
*nc
,
263 NetClientState
*peer
,
266 NetClientDestructor
*destructor
)
269 nc
->model
= g_strdup(model
);
271 nc
->name
= g_strdup(name
);
273 nc
->name
= assign_name(nc
, model
);
281 QTAILQ_INSERT_TAIL(&net_clients
, nc
, next
);
283 nc
->incoming_queue
= qemu_new_net_queue(nc
);
284 nc
->destructor
= destructor
;
287 NetClientState
*qemu_new_net_client(NetClientInfo
*info
,
288 NetClientState
*peer
,
294 assert(info
->size
>= sizeof(NetClientState
));
296 nc
= g_malloc0(info
->size
);
297 qemu_net_client_setup(nc
, info
, peer
, model
, name
,
298 qemu_net_client_destructor
);
303 NICState
*qemu_new_nic(NetClientInfo
*info
,
309 NetClientState
**peers
= conf
->peers
.ncs
;
311 int i
, queues
= MAX(1, conf
->peers
.queues
);
313 assert(info
->type
== NET_CLIENT_OPTIONS_KIND_NIC
);
314 assert(info
->size
>= sizeof(NICState
));
316 nic
= g_malloc0(info
->size
+ sizeof(NetClientState
) * queues
);
317 nic
->ncs
= (void *)nic
+ info
->size
;
319 nic
->opaque
= opaque
;
321 for (i
= 0; i
< queues
; i
++) {
322 qemu_net_client_setup(&nic
->ncs
[i
], info
, peers
[i
], model
, name
,
324 nic
->ncs
[i
].queue_index
= i
;
330 NetClientState
*qemu_get_subqueue(NICState
*nic
, int queue_index
)
332 return nic
->ncs
+ queue_index
;
335 NetClientState
*qemu_get_queue(NICState
*nic
)
337 return qemu_get_subqueue(nic
, 0);
340 NICState
*qemu_get_nic(NetClientState
*nc
)
342 NetClientState
*nc0
= nc
- nc
->queue_index
;
344 return (NICState
*)((void *)nc0
- nc
->info
->size
);
347 void *qemu_get_nic_opaque(NetClientState
*nc
)
349 NICState
*nic
= qemu_get_nic(nc
);
354 static void qemu_cleanup_net_client(NetClientState
*nc
)
356 QTAILQ_REMOVE(&net_clients
, nc
, next
);
358 if (nc
->info
->cleanup
) {
359 nc
->info
->cleanup(nc
);
363 static void qemu_free_net_client(NetClientState
*nc
)
365 if (nc
->incoming_queue
) {
366 qemu_del_net_queue(nc
->incoming_queue
);
369 nc
->peer
->peer
= NULL
;
373 if (nc
->destructor
) {
378 void qemu_del_net_client(NetClientState
*nc
)
380 NetClientState
*ncs
[MAX_QUEUE_NUM
];
383 assert(nc
->info
->type
!= NET_CLIENT_OPTIONS_KIND_NIC
);
385 /* If the NetClientState belongs to a multiqueue backend, we will change all
386 * other NetClientStates also.
388 queues
= qemu_find_net_clients_except(nc
->name
, ncs
,
389 NET_CLIENT_OPTIONS_KIND_NIC
,
393 /* If there is a peer NIC, delete and cleanup client, but do not free. */
394 if (nc
->peer
&& nc
->peer
->info
->type
== NET_CLIENT_OPTIONS_KIND_NIC
) {
395 NICState
*nic
= qemu_get_nic(nc
->peer
);
396 if (nic
->peer_deleted
) {
399 nic
->peer_deleted
= true;
401 for (i
= 0; i
< queues
; i
++) {
402 ncs
[i
]->peer
->link_down
= true;
405 if (nc
->peer
->info
->link_status_changed
) {
406 nc
->peer
->info
->link_status_changed(nc
->peer
);
409 for (i
= 0; i
< queues
; i
++) {
410 qemu_cleanup_net_client(ncs
[i
]);
416 for (i
= 0; i
< queues
; i
++) {
417 qemu_cleanup_net_client(ncs
[i
]);
418 qemu_free_net_client(ncs
[i
]);
422 void qemu_del_nic(NICState
*nic
)
424 int i
, queues
= MAX(nic
->conf
->peers
.queues
, 1);
426 qemu_macaddr_set_free(&nic
->conf
->macaddr
);
428 /* If this is a peer NIC and peer has already been deleted, free it now. */
429 if (nic
->peer_deleted
) {
430 for (i
= 0; i
< queues
; i
++) {
431 qemu_free_net_client(qemu_get_subqueue(nic
, i
)->peer
);
435 for (i
= queues
- 1; i
>= 0; i
--) {
436 NetClientState
*nc
= qemu_get_subqueue(nic
, i
);
438 qemu_cleanup_net_client(nc
);
439 qemu_free_net_client(nc
);
445 void qemu_foreach_nic(qemu_nic_foreach func
, void *opaque
)
449 QTAILQ_FOREACH(nc
, &net_clients
, next
) {
450 if (nc
->info
->type
== NET_CLIENT_OPTIONS_KIND_NIC
) {
451 if (nc
->queue_index
== 0) {
452 func(qemu_get_nic(nc
), opaque
);
458 bool qemu_has_ufo(NetClientState
*nc
)
460 if (!nc
|| !nc
->info
->has_ufo
) {
464 return nc
->info
->has_ufo(nc
);
467 bool qemu_has_vnet_hdr(NetClientState
*nc
)
469 if (!nc
|| !nc
->info
->has_vnet_hdr
) {
473 return nc
->info
->has_vnet_hdr(nc
);
476 bool qemu_has_vnet_hdr_len(NetClientState
*nc
, int len
)
478 if (!nc
|| !nc
->info
->has_vnet_hdr_len
) {
482 return nc
->info
->has_vnet_hdr_len(nc
, len
);
485 void qemu_using_vnet_hdr(NetClientState
*nc
, bool enable
)
487 if (!nc
|| !nc
->info
->using_vnet_hdr
) {
491 nc
->info
->using_vnet_hdr(nc
, enable
);
494 void qemu_set_offload(NetClientState
*nc
, int csum
, int tso4
, int tso6
,
497 if (!nc
|| !nc
->info
->set_offload
) {
501 nc
->info
->set_offload(nc
, csum
, tso4
, tso6
, ecn
, ufo
);
504 void qemu_set_vnet_hdr_len(NetClientState
*nc
, int len
)
506 if (!nc
|| !nc
->info
->set_vnet_hdr_len
) {
510 nc
->info
->set_vnet_hdr_len(nc
, len
);
513 int qemu_set_vnet_le(NetClientState
*nc
, bool is_le
)
515 if (!nc
|| !nc
->info
->set_vnet_le
) {
519 return nc
->info
->set_vnet_le(nc
, is_le
);
522 int qemu_set_vnet_be(NetClientState
*nc
, bool is_be
)
524 if (!nc
|| !nc
->info
->set_vnet_be
) {
528 return nc
->info
->set_vnet_be(nc
, is_be
);
531 int qemu_can_send_packet(NetClientState
*sender
)
533 int vm_running
= runstate_is_running();
543 if (sender
->peer
->receive_disabled
) {
545 } else if (sender
->peer
->info
->can_receive
&&
546 !sender
->peer
->info
->can_receive(sender
->peer
)) {
552 ssize_t
qemu_deliver_packet(NetClientState
*sender
,
558 NetClientState
*nc
= opaque
;
565 if (nc
->receive_disabled
) {
569 if (flags
& QEMU_NET_PACKET_FLAG_RAW
&& nc
->info
->receive_raw
) {
570 ret
= nc
->info
->receive_raw(nc
, data
, size
);
572 ret
= nc
->info
->receive(nc
, data
, size
);
576 nc
->receive_disabled
= 1;
582 void qemu_purge_queued_packets(NetClientState
*nc
)
588 qemu_net_queue_purge(nc
->peer
->incoming_queue
, nc
);
592 void qemu_flush_or_purge_queued_packets(NetClientState
*nc
, bool purge
)
594 nc
->receive_disabled
= 0;
596 if (nc
->peer
&& nc
->peer
->info
->type
== NET_CLIENT_OPTIONS_KIND_HUBPORT
) {
597 if (net_hub_flush(nc
->peer
)) {
601 if (qemu_net_queue_flush(nc
->incoming_queue
)) {
602 /* We emptied the queue successfully, signal to the IO thread to repoll
603 * the file descriptor (for tap, for example).
607 /* Unable to empty the queue, purge remaining packets */
608 qemu_net_queue_purge(nc
->incoming_queue
, nc
);
612 void qemu_flush_queued_packets(NetClientState
*nc
)
614 qemu_flush_or_purge_queued_packets(nc
, false);
617 static ssize_t
qemu_send_packet_async_with_flags(NetClientState
*sender
,
619 const uint8_t *buf
, int size
,
620 NetPacketSent
*sent_cb
)
625 printf("qemu_send_packet_async:\n");
626 hex_dump(stdout
, buf
, size
);
629 if (sender
->link_down
|| !sender
->peer
) {
633 queue
= sender
->peer
->incoming_queue
;
635 return qemu_net_queue_send(queue
, sender
, flags
, buf
, size
, sent_cb
);
638 ssize_t
qemu_send_packet_async(NetClientState
*sender
,
639 const uint8_t *buf
, int size
,
640 NetPacketSent
*sent_cb
)
642 return qemu_send_packet_async_with_flags(sender
, QEMU_NET_PACKET_FLAG_NONE
,
646 void qemu_send_packet(NetClientState
*nc
, const uint8_t *buf
, int size
)
648 qemu_send_packet_async(nc
, buf
, size
, NULL
);
651 ssize_t
qemu_send_packet_raw(NetClientState
*nc
, const uint8_t *buf
, int size
)
653 return qemu_send_packet_async_with_flags(nc
, QEMU_NET_PACKET_FLAG_RAW
,
657 static ssize_t
nc_sendv_compat(NetClientState
*nc
, const struct iovec
*iov
,
660 uint8_t buffer
[NET_BUFSIZE
];
663 offset
= iov_to_buf(iov
, iovcnt
, 0, buffer
, sizeof(buffer
));
665 return nc
->info
->receive(nc
, buffer
, offset
);
668 ssize_t
qemu_deliver_packet_iov(NetClientState
*sender
,
670 const struct iovec
*iov
,
674 NetClientState
*nc
= opaque
;
678 return iov_size(iov
, iovcnt
);
681 if (nc
->receive_disabled
) {
685 if (nc
->info
->receive_iov
) {
686 ret
= nc
->info
->receive_iov(nc
, iov
, iovcnt
);
688 ret
= nc_sendv_compat(nc
, iov
, iovcnt
);
692 nc
->receive_disabled
= 1;
698 ssize_t
qemu_sendv_packet_async(NetClientState
*sender
,
699 const struct iovec
*iov
, int iovcnt
,
700 NetPacketSent
*sent_cb
)
704 if (sender
->link_down
|| !sender
->peer
) {
705 return iov_size(iov
, iovcnt
);
708 queue
= sender
->peer
->incoming_queue
;
710 return qemu_net_queue_send_iov(queue
, sender
,
711 QEMU_NET_PACKET_FLAG_NONE
,
712 iov
, iovcnt
, sent_cb
);
716 qemu_sendv_packet(NetClientState
*nc
, const struct iovec
*iov
, int iovcnt
)
718 return qemu_sendv_packet_async(nc
, iov
, iovcnt
, NULL
);
721 NetClientState
*qemu_find_netdev(const char *id
)
725 QTAILQ_FOREACH(nc
, &net_clients
, next
) {
726 if (nc
->info
->type
== NET_CLIENT_OPTIONS_KIND_NIC
)
728 if (!strcmp(nc
->name
, id
)) {
736 int qemu_find_net_clients_except(const char *id
, NetClientState
**ncs
,
737 NetClientOptionsKind type
, int max
)
742 QTAILQ_FOREACH(nc
, &net_clients
, next
) {
743 if (nc
->info
->type
== type
) {
746 if (!id
|| !strcmp(nc
->name
, id
)) {
757 static int nic_get_free_idx(void)
761 for (index
= 0; index
< MAX_NICS
; index
++)
762 if (!nd_table
[index
].used
)
767 int qemu_show_nic_models(const char *arg
, const char *const *models
)
771 if (!arg
|| !is_help_option(arg
)) {
775 fprintf(stderr
, "qemu: Supported NIC models: ");
776 for (i
= 0 ; models
[i
]; i
++)
777 fprintf(stderr
, "%s%c", models
[i
], models
[i
+1] ? ',' : '\n');
781 void qemu_check_nic_model(NICInfo
*nd
, const char *model
)
783 const char *models
[2];
788 if (qemu_show_nic_models(nd
->model
, models
))
790 if (qemu_find_nic_model(nd
, models
, model
) < 0)
794 int qemu_find_nic_model(NICInfo
*nd
, const char * const *models
,
795 const char *default_model
)
800 nd
->model
= g_strdup(default_model
);
802 for (i
= 0 ; models
[i
]; i
++) {
803 if (strcmp(nd
->model
, models
[i
]) == 0)
807 error_report("Unsupported NIC model: %s", nd
->model
);
811 static int net_init_nic(const NetClientOptions
*opts
, const char *name
,
812 NetClientState
*peer
, Error
**errp
)
816 const NetLegacyNicOptions
*nic
;
818 assert(opts
->kind
== NET_CLIENT_OPTIONS_KIND_NIC
);
821 idx
= nic_get_free_idx();
822 if (idx
== -1 || nb_nics
>= MAX_NICS
) {
823 error_setg(errp
, "too many NICs");
829 memset(nd
, 0, sizeof(*nd
));
831 if (nic
->has_netdev
) {
832 nd
->netdev
= qemu_find_netdev(nic
->netdev
);
834 error_setg(errp
, "netdev '%s' not found", nic
->netdev
);
841 nd
->name
= g_strdup(name
);
842 if (nic
->has_model
) {
843 nd
->model
= g_strdup(nic
->model
);
846 nd
->devaddr
= g_strdup(nic
->addr
);
849 if (nic
->has_macaddr
&&
850 net_parse_macaddr(nd
->macaddr
.a
, nic
->macaddr
) < 0) {
851 error_setg(errp
, "invalid syntax for ethernet address");
854 if (nic
->has_macaddr
&&
855 is_multicast_ether_addr(nd
->macaddr
.a
)) {
857 "NIC cannot have multicast MAC address (odd 1st byte)");
860 qemu_macaddr_default_if_unset(&nd
->macaddr
);
862 if (nic
->has_vectors
) {
863 if (nic
->vectors
> 0x7ffffff) {
864 error_setg(errp
, "invalid # of vectors: %"PRIu32
, nic
->vectors
);
867 nd
->nvectors
= nic
->vectors
;
869 nd
->nvectors
= DEV_NVECTORS_UNSPECIFIED
;
879 static int (* const net_client_init_fun
[NET_CLIENT_OPTIONS_KIND_MAX
])(
880 const NetClientOptions
*opts
,
882 NetClientState
*peer
, Error
**errp
) = {
883 [NET_CLIENT_OPTIONS_KIND_NIC
] = net_init_nic
,
885 [NET_CLIENT_OPTIONS_KIND_USER
] = net_init_slirp
,
887 [NET_CLIENT_OPTIONS_KIND_TAP
] = net_init_tap
,
888 [NET_CLIENT_OPTIONS_KIND_SOCKET
] = net_init_socket
,
890 [NET_CLIENT_OPTIONS_KIND_VDE
] = net_init_vde
,
893 [NET_CLIENT_OPTIONS_KIND_NETMAP
] = net_init_netmap
,
895 [NET_CLIENT_OPTIONS_KIND_DUMP
] = net_init_dump
,
896 #ifdef CONFIG_NET_BRIDGE
897 [NET_CLIENT_OPTIONS_KIND_BRIDGE
] = net_init_bridge
,
899 [NET_CLIENT_OPTIONS_KIND_HUBPORT
] = net_init_hubport
,
900 #ifdef CONFIG_VHOST_NET_USED
901 [NET_CLIENT_OPTIONS_KIND_VHOST_USER
] = net_init_vhost_user
,
904 [NET_CLIENT_OPTIONS_KIND_L2TPV3
] = net_init_l2tpv3
,
909 static int net_client_init1(const void *object
, int is_netdev
, Error
**errp
)
912 const Netdev
*netdev
;
913 const NetLegacy
*net
;
915 const NetClientOptions
*opts
;
920 opts
= u
.netdev
->opts
;
923 switch (opts
->kind
) {
925 case NET_CLIENT_OPTIONS_KIND_USER
:
927 case NET_CLIENT_OPTIONS_KIND_TAP
:
928 case NET_CLIENT_OPTIONS_KIND_SOCKET
:
930 case NET_CLIENT_OPTIONS_KIND_VDE
:
933 case NET_CLIENT_OPTIONS_KIND_NETMAP
:
935 #ifdef CONFIG_NET_BRIDGE
936 case NET_CLIENT_OPTIONS_KIND_BRIDGE
:
938 case NET_CLIENT_OPTIONS_KIND_HUBPORT
:
939 #ifdef CONFIG_VHOST_NET_USED
940 case NET_CLIENT_OPTIONS_KIND_VHOST_USER
:
943 case NET_CLIENT_OPTIONS_KIND_L2TPV3
:
948 error_set(errp
, QERR_INVALID_PARAMETER_VALUE
, "type",
949 "a netdev backend type");
955 if (opts
->kind
== NET_CLIENT_OPTIONS_KIND_HUBPORT
) {
956 error_set(errp
, QERR_INVALID_PARAMETER_VALUE
, "type",
960 /* missing optional values have been initialized to "all bits zero" */
961 name
= u
.net
->has_id
? u
.net
->id
: u
.net
->name
;
964 if (net_client_init_fun
[opts
->kind
]) {
965 NetClientState
*peer
= NULL
;
967 /* Do not add to a vlan if it's a -netdev or a nic with a netdev=
970 (opts
->kind
!= NET_CLIENT_OPTIONS_KIND_NIC
||
971 !opts
->nic
->has_netdev
)) {
972 peer
= net_hub_add_port(u
.net
->has_vlan
? u
.net
->vlan
: 0, NULL
);
975 if (net_client_init_fun
[opts
->kind
](opts
, name
, peer
, errp
) < 0) {
976 /* FIXME drop when all init functions store an Error */
977 if (errp
&& !*errp
) {
978 error_set(errp
, QERR_DEVICE_INIT_FAILED
,
979 NetClientOptionsKind_lookup
[opts
->kind
]);
988 static void net_visit(Visitor
*v
, int is_netdev
, void **object
, Error
**errp
)
991 visit_type_Netdev(v
, (Netdev
**)object
, NULL
, errp
);
993 visit_type_NetLegacy(v
, (NetLegacy
**)object
, NULL
, errp
);
998 int net_client_init(QemuOpts
*opts
, int is_netdev
, Error
**errp
)
1000 void *object
= NULL
;
1005 OptsVisitor
*ov
= opts_visitor_new(opts
);
1007 net_visit(opts_get_visitor(ov
), is_netdev
, &object
, &err
);
1008 opts_visitor_cleanup(ov
);
1012 ret
= net_client_init1(object
, is_netdev
, &err
);
1016 QapiDeallocVisitor
*dv
= qapi_dealloc_visitor_new();
1018 net_visit(qapi_dealloc_get_visitor(dv
), is_netdev
, &object
, NULL
);
1019 qapi_dealloc_visitor_cleanup(dv
);
1022 error_propagate(errp
, err
);
1027 static int net_host_check_device(const char *device
)
1030 for (i
= 0; host_net_devices
[i
]; i
++) {
1031 if (!strncmp(host_net_devices
[i
], device
,
1032 strlen(host_net_devices
[i
]))) {
1040 void hmp_host_net_add(Monitor
*mon
, const QDict
*qdict
)
1042 const char *device
= qdict_get_str(qdict
, "device");
1043 const char *opts_str
= qdict_get_try_str(qdict
, "opts");
1044 Error
*local_err
= NULL
;
1047 if (!net_host_check_device(device
)) {
1048 monitor_printf(mon
, "invalid host network device %s\n", device
);
1052 opts
= qemu_opts_parse(qemu_find_opts("net"), opts_str
? opts_str
: "", 0);
1057 qemu_opt_set(opts
, "type", device
, &error_abort
);
1059 net_client_init(opts
, 0, &local_err
);
1061 error_report_err(local_err
);
1062 monitor_printf(mon
, "adding host network device %s failed\n", device
);
1066 void hmp_host_net_remove(Monitor
*mon
, const QDict
*qdict
)
1069 int vlan_id
= qdict_get_int(qdict
, "vlan_id");
1070 const char *device
= qdict_get_str(qdict
, "device");
1072 nc
= net_hub_find_client_by_name(vlan_id
, device
);
1074 error_report("Host network device '%s' on hub '%d' not found",
1078 if (nc
->info
->type
== NET_CLIENT_OPTIONS_KIND_NIC
) {
1079 error_report("invalid host network device '%s'", device
);
1083 qemu_del_net_client(nc
->peer
);
1084 qemu_del_net_client(nc
);
1087 void netdev_add(QemuOpts
*opts
, Error
**errp
)
1089 net_client_init(opts
, 1, errp
);
1092 int qmp_netdev_add(Monitor
*mon
, const QDict
*qdict
, QObject
**ret
)
1094 Error
*local_err
= NULL
;
1095 QemuOptsList
*opts_list
;
1098 opts_list
= qemu_find_opts_err("netdev", &local_err
);
1103 opts
= qemu_opts_from_qdict(opts_list
, qdict
, &local_err
);
1108 netdev_add(opts
, &local_err
);
1110 qemu_opts_del(opts
);
1117 qerror_report_err(local_err
);
1118 error_free(local_err
);
1122 void qmp_netdev_del(const char *id
, Error
**errp
)
1127 nc
= qemu_find_netdev(id
);
1129 error_set(errp
, QERR_DEVICE_NOT_FOUND
, id
);
1133 opts
= qemu_opts_find(qemu_find_opts_err("netdev", NULL
), id
);
1135 error_setg(errp
, "Device '%s' is not a netdev", id
);
1139 qemu_del_net_client(nc
);
1140 qemu_opts_del(opts
);
1143 void print_net_client(Monitor
*mon
, NetClientState
*nc
)
1145 monitor_printf(mon
, "%s: index=%d,type=%s,%s\n", nc
->name
,
1147 NetClientOptionsKind_lookup
[nc
->info
->type
],
1151 RxFilterInfoList
*qmp_query_rx_filter(bool has_name
, const char *name
,
1155 RxFilterInfoList
*filter_list
= NULL
, *last_entry
= NULL
;
1157 QTAILQ_FOREACH(nc
, &net_clients
, next
) {
1158 RxFilterInfoList
*entry
;
1161 if (has_name
&& strcmp(nc
->name
, name
) != 0) {
1165 /* only query rx-filter information of NIC */
1166 if (nc
->info
->type
!= NET_CLIENT_OPTIONS_KIND_NIC
) {
1168 error_setg(errp
, "net client(%s) isn't a NIC", name
);
1174 if (nc
->info
->query_rx_filter
) {
1175 info
= nc
->info
->query_rx_filter(nc
);
1176 entry
= g_malloc0(sizeof(*entry
));
1177 entry
->value
= info
;
1180 filter_list
= entry
;
1182 last_entry
->next
= entry
;
1185 } else if (has_name
) {
1186 error_setg(errp
, "net client(%s) doesn't support"
1187 " rx-filter querying", name
);
1196 if (filter_list
== NULL
&& has_name
) {
1197 error_setg(errp
, "invalid net client name: %s", name
);
1203 void hmp_info_network(Monitor
*mon
, const QDict
*qdict
)
1205 NetClientState
*nc
, *peer
;
1206 NetClientOptionsKind type
;
1210 QTAILQ_FOREACH(nc
, &net_clients
, next
) {
1212 type
= nc
->info
->type
;
1214 /* Skip if already printed in hub info */
1215 if (net_hub_id_for_client(nc
, NULL
) == 0) {
1219 if (!peer
|| type
== NET_CLIENT_OPTIONS_KIND_NIC
) {
1220 print_net_client(mon
, nc
);
1221 } /* else it's a netdev connected to a NIC, printed with the NIC */
1222 if (peer
&& type
== NET_CLIENT_OPTIONS_KIND_NIC
) {
1223 monitor_printf(mon
, " \\ ");
1224 print_net_client(mon
, peer
);
1229 void qmp_set_link(const char *name
, bool up
, Error
**errp
)
1231 NetClientState
*ncs
[MAX_QUEUE_NUM
];
1235 queues
= qemu_find_net_clients_except(name
, ncs
,
1236 NET_CLIENT_OPTIONS_KIND_MAX
,
1240 error_set(errp
, QERR_DEVICE_NOT_FOUND
, name
);
1245 for (i
= 0; i
< queues
; i
++) {
1246 ncs
[i
]->link_down
= !up
;
1249 if (nc
->info
->link_status_changed
) {
1250 nc
->info
->link_status_changed(nc
);
1254 /* Change peer link only if the peer is NIC and then notify peer.
1255 * If the peer is a HUBPORT or a backend, we do not change the
1258 * This behavior is compatible with qemu vlans where there could be
1259 * multiple clients that can still communicate with each other in
1260 * disconnected mode. For now maintain this compatibility.
1262 if (nc
->peer
->info
->type
== NET_CLIENT_OPTIONS_KIND_NIC
) {
1263 for (i
= 0; i
< queues
; i
++) {
1264 ncs
[i
]->peer
->link_down
= !up
;
1267 if (nc
->peer
->info
->link_status_changed
) {
1268 nc
->peer
->info
->link_status_changed(nc
->peer
);
1273 static void net_vm_change_state_handler(void *opaque
, int running
,
1276 /* Complete all queued packets, to guarantee we don't modify
1277 * state later when VM is not running.
1281 NetClientState
*tmp
;
1283 QTAILQ_FOREACH_SAFE(nc
, &net_clients
, next
, tmp
) {
1284 qemu_flush_or_purge_queued_packets(nc
, true);
1289 void net_cleanup(void)
1293 /* We may del multiple entries during qemu_del_net_client(),
1294 * so QTAILQ_FOREACH_SAFE() is also not safe here.
1296 while (!QTAILQ_EMPTY(&net_clients
)) {
1297 nc
= QTAILQ_FIRST(&net_clients
);
1298 if (nc
->info
->type
== NET_CLIENT_OPTIONS_KIND_NIC
) {
1299 qemu_del_nic(qemu_get_nic(nc
));
1301 qemu_del_net_client(nc
);
1305 qemu_del_vm_change_state_handler(net_change_state_entry
);
1308 void net_check_clients(void)
1313 /* Don't warn about the default network setup that you get if
1314 * no command line -net or -netdev options are specified. There
1315 * are two cases that we would otherwise complain about:
1316 * (1) board doesn't support a NIC but the implicit "-net nic"
1318 * (2) CONFIG_SLIRP not set, in which case the implicit "-net nic"
1319 * sets up a nic that isn't connected to anything.
1325 net_hub_check_clients();
1327 QTAILQ_FOREACH(nc
, &net_clients
, next
) {
1329 fprintf(stderr
, "Warning: %s %s has no peer\n",
1330 nc
->info
->type
== NET_CLIENT_OPTIONS_KIND_NIC
?
1331 "nic" : "netdev", nc
->name
);
1335 /* Check that all NICs requested via -net nic actually got created.
1336 * NICs created via -device don't need to be checked here because
1337 * they are always instantiated.
1339 for (i
= 0; i
< MAX_NICS
; i
++) {
1340 NICInfo
*nd
= &nd_table
[i
];
1341 if (nd
->used
&& !nd
->instantiated
) {
1342 fprintf(stderr
, "Warning: requested NIC (%s, model %s) "
1343 "was not created (not supported by this machine?)\n",
1344 nd
->name
? nd
->name
: "anonymous",
1345 nd
->model
? nd
->model
: "unspecified");
1350 static int net_init_client(void *dummy
, QemuOpts
*opts
, Error
**errp
)
1352 Error
*local_err
= NULL
;
1354 net_client_init(opts
, 0, &local_err
);
1356 error_report_err(local_err
);
1363 static int net_init_netdev(void *dummy
, QemuOpts
*opts
, Error
**errp
)
1365 Error
*local_err
= NULL
;
1368 ret
= net_client_init(opts
, 1, &local_err
);
1370 error_report_err(local_err
);
1377 int net_init_clients(void)
1379 QemuOptsList
*net
= qemu_find_opts("net");
1382 /* if no clients, we use a default config */
1383 qemu_opts_set(net
, NULL
, "type", "nic", &error_abort
);
1385 qemu_opts_set(net
, NULL
, "type", "user", &error_abort
);
1389 net_change_state_entry
=
1390 qemu_add_vm_change_state_handler(net_vm_change_state_handler
, NULL
);
1392 QTAILQ_INIT(&net_clients
);
1394 if (qemu_opts_foreach(qemu_find_opts("netdev"),
1395 net_init_netdev
, NULL
, NULL
)) {
1399 if (qemu_opts_foreach(net
, net_init_client
, NULL
, NULL
)) {
1406 int net_client_parse(QemuOptsList
*opts_list
, const char *optarg
)
1408 #if defined(CONFIG_SLIRP)
1410 if (net_slirp_parse_legacy(opts_list
, optarg
, &ret
)) {
1415 if (!qemu_opts_parse(opts_list
, optarg
, 1)) {
1425 unsigned compute_mcast_idx(const uint8_t *ep
)
1432 for (i
= 0; i
< 6; i
++) {
1434 for (j
= 0; j
< 8; j
++) {
1435 carry
= ((crc
& 0x80000000L
) ? 1 : 0) ^ (b
& 0x01);
1439 crc
= ((crc
^ POLYNOMIAL
) | carry
);
1446 QemuOptsList qemu_netdev_opts
= {
1448 .implied_opt_name
= "type",
1449 .head
= QTAILQ_HEAD_INITIALIZER(qemu_netdev_opts
.head
),
1452 * no elements => accept any params
1453 * validation will happen later
1455 { /* end of list */ }
1459 QemuOptsList qemu_net_opts
= {
1461 .implied_opt_name
= "type",
1462 .head
= QTAILQ_HEAD_INITIALIZER(qemu_net_opts
.head
),
1465 * no elements => accept any params
1466 * validation will happen later
1468 { /* end of list */ }