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/error-report.h"
36 #include "qemu/sockets.h"
37 #include "qemu/config-file.h"
38 #include "qmp-commands.h"
41 #include "qemu/main-loop.h"
42 #include "qapi-visit.h"
43 #include "qapi/opts-visitor.h"
44 #include "qapi/dealloc-visitor.h"
45 #include "sysemu/sysemu.h"
47 /* Net bridge is currently not supported for W32. */
49 # define CONFIG_NET_BRIDGE
52 static VMChangeStateEntry
*net_change_state_entry
;
53 static QTAILQ_HEAD(, NetClientState
) net_clients
;
55 const char *host_net_devices
[] = {
59 #ifdef CONFIG_NET_BRIDGE
74 /***********************************************************/
75 /* network device redirectors */
77 #if defined(DEBUG_NET)
78 static void hex_dump(FILE *f
, const uint8_t *buf
, int size
)
82 for(i
=0;i
<size
;i
+=16) {
86 fprintf(f
, "%08x ", i
);
89 fprintf(f
, " %02x", buf
[i
+j
]);
96 if (c
< ' ' || c
> '~')
105 static int get_str_sep(char *buf
, int buf_size
, const char **pp
, int sep
)
116 if (len
> buf_size
- 1)
125 int parse_host_port(struct sockaddr_in
*saddr
, const char *str
)
133 if (get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0)
135 saddr
->sin_family
= AF_INET
;
136 if (buf
[0] == '\0') {
137 saddr
->sin_addr
.s_addr
= 0;
139 if (qemu_isdigit(buf
[0])) {
140 if (!inet_aton(buf
, &saddr
->sin_addr
))
143 if ((he
= gethostbyname(buf
)) == NULL
)
145 saddr
->sin_addr
= *(struct in_addr
*)he
->h_addr
;
148 port
= strtol(p
, (char **)&r
, 0);
151 saddr
->sin_port
= htons(port
);
155 char *qemu_mac_strdup_printf(const uint8_t *macaddr
)
157 return g_strdup_printf("%.2x:%.2x:%.2x:%.2x:%.2x:%.2x",
158 macaddr
[0], macaddr
[1], macaddr
[2],
159 macaddr
[3], macaddr
[4], macaddr
[5]);
162 void qemu_format_nic_info_str(NetClientState
*nc
, uint8_t macaddr
[6])
164 snprintf(nc
->info_str
, sizeof(nc
->info_str
),
165 "model=%s,macaddr=%02x:%02x:%02x:%02x:%02x:%02x",
167 macaddr
[0], macaddr
[1], macaddr
[2],
168 macaddr
[3], macaddr
[4], macaddr
[5]);
171 static int mac_table
[256] = {0};
173 static void qemu_macaddr_set_used(MACAddr
*macaddr
)
177 for (index
= 0x56; index
< 0xFF; index
++) {
178 if (macaddr
->a
[5] == index
) {
184 static void qemu_macaddr_set_free(MACAddr
*macaddr
)
187 static const MACAddr base
= { .a
= { 0x52, 0x54, 0x00, 0x12, 0x34, 0 } };
189 if (memcmp(macaddr
->a
, &base
.a
, (sizeof(base
.a
) - 1)) != 0) {
192 for (index
= 0x56; index
< 0xFF; index
++) {
193 if (macaddr
->a
[5] == index
) {
199 static int qemu_macaddr_get_free(void)
203 for (index
= 0x56; index
< 0xFF; index
++) {
204 if (mac_table
[index
] == 0) {
212 void qemu_macaddr_default_if_unset(MACAddr
*macaddr
)
214 static const MACAddr zero
= { .a
= { 0,0,0,0,0,0 } };
215 static const MACAddr base
= { .a
= { 0x52, 0x54, 0x00, 0x12, 0x34, 0 } };
217 if (memcmp(macaddr
, &zero
, sizeof(zero
)) != 0) {
218 if (memcmp(macaddr
->a
, &base
.a
, (sizeof(base
.a
) - 1)) != 0) {
221 qemu_macaddr_set_used(macaddr
);
226 macaddr
->a
[0] = 0x52;
227 macaddr
->a
[1] = 0x54;
228 macaddr
->a
[2] = 0x00;
229 macaddr
->a
[3] = 0x12;
230 macaddr
->a
[4] = 0x34;
231 macaddr
->a
[5] = qemu_macaddr_get_free();
232 qemu_macaddr_set_used(macaddr
);
236 * Generate a name for net client
238 * Only net clients created with the legacy -net option and NICs need this.
240 static char *assign_name(NetClientState
*nc1
, const char *model
)
245 QTAILQ_FOREACH(nc
, &net_clients
, next
) {
249 if (strcmp(nc
->model
, model
) == 0) {
254 return g_strdup_printf("%s.%d", model
, id
);
257 static void qemu_net_client_destructor(NetClientState
*nc
)
262 static void qemu_net_client_setup(NetClientState
*nc
,
264 NetClientState
*peer
,
267 NetClientDestructor
*destructor
)
270 nc
->model
= g_strdup(model
);
272 nc
->name
= g_strdup(name
);
274 nc
->name
= assign_name(nc
, model
);
282 QTAILQ_INSERT_TAIL(&net_clients
, nc
, next
);
284 nc
->incoming_queue
= qemu_new_net_queue(nc
);
285 nc
->destructor
= destructor
;
288 NetClientState
*qemu_new_net_client(NetClientInfo
*info
,
289 NetClientState
*peer
,
295 assert(info
->size
>= sizeof(NetClientState
));
297 nc
= g_malloc0(info
->size
);
298 qemu_net_client_setup(nc
, info
, peer
, model
, name
,
299 qemu_net_client_destructor
);
304 NICState
*qemu_new_nic(NetClientInfo
*info
,
310 NetClientState
**peers
= conf
->peers
.ncs
;
312 int i
, queues
= MAX(1, conf
->peers
.queues
);
314 assert(info
->type
== NET_CLIENT_OPTIONS_KIND_NIC
);
315 assert(info
->size
>= sizeof(NICState
));
317 nic
= g_malloc0(info
->size
+ sizeof(NetClientState
) * queues
);
318 nic
->ncs
= (void *)nic
+ info
->size
;
320 nic
->opaque
= opaque
;
322 for (i
= 0; i
< queues
; i
++) {
323 qemu_net_client_setup(&nic
->ncs
[i
], info
, peers
[i
], model
, name
,
325 nic
->ncs
[i
].queue_index
= i
;
331 NetClientState
*qemu_get_subqueue(NICState
*nic
, int queue_index
)
333 return nic
->ncs
+ queue_index
;
336 NetClientState
*qemu_get_queue(NICState
*nic
)
338 return qemu_get_subqueue(nic
, 0);
341 NICState
*qemu_get_nic(NetClientState
*nc
)
343 NetClientState
*nc0
= nc
- nc
->queue_index
;
345 return (NICState
*)((void *)nc0
- nc
->info
->size
);
348 void *qemu_get_nic_opaque(NetClientState
*nc
)
350 NICState
*nic
= qemu_get_nic(nc
);
355 static void qemu_cleanup_net_client(NetClientState
*nc
)
357 QTAILQ_REMOVE(&net_clients
, nc
, next
);
359 if (nc
->info
->cleanup
) {
360 nc
->info
->cleanup(nc
);
364 static void qemu_free_net_client(NetClientState
*nc
)
366 if (nc
->incoming_queue
) {
367 qemu_del_net_queue(nc
->incoming_queue
);
370 nc
->peer
->peer
= NULL
;
374 if (nc
->destructor
) {
379 void qemu_del_net_client(NetClientState
*nc
)
381 NetClientState
*ncs
[MAX_QUEUE_NUM
];
384 assert(nc
->info
->type
!= NET_CLIENT_OPTIONS_KIND_NIC
);
386 /* If the NetClientState belongs to a multiqueue backend, we will change all
387 * other NetClientStates also.
389 queues
= qemu_find_net_clients_except(nc
->name
, ncs
,
390 NET_CLIENT_OPTIONS_KIND_NIC
,
394 /* If there is a peer NIC, delete and cleanup client, but do not free. */
395 if (nc
->peer
&& nc
->peer
->info
->type
== NET_CLIENT_OPTIONS_KIND_NIC
) {
396 NICState
*nic
= qemu_get_nic(nc
->peer
);
397 if (nic
->peer_deleted
) {
400 nic
->peer_deleted
= true;
402 for (i
= 0; i
< queues
; i
++) {
403 ncs
[i
]->peer
->link_down
= true;
406 if (nc
->peer
->info
->link_status_changed
) {
407 nc
->peer
->info
->link_status_changed(nc
->peer
);
410 for (i
= 0; i
< queues
; i
++) {
411 qemu_cleanup_net_client(ncs
[i
]);
417 for (i
= 0; i
< queues
; i
++) {
418 qemu_cleanup_net_client(ncs
[i
]);
419 qemu_free_net_client(ncs
[i
]);
423 void qemu_del_nic(NICState
*nic
)
425 int i
, queues
= MAX(nic
->conf
->peers
.queues
, 1);
427 qemu_macaddr_set_free(&nic
->conf
->macaddr
);
429 /* If this is a peer NIC and peer has already been deleted, free it now. */
430 if (nic
->peer_deleted
) {
431 for (i
= 0; i
< queues
; i
++) {
432 qemu_free_net_client(qemu_get_subqueue(nic
, i
)->peer
);
436 for (i
= queues
- 1; i
>= 0; i
--) {
437 NetClientState
*nc
= qemu_get_subqueue(nic
, i
);
439 qemu_cleanup_net_client(nc
);
440 qemu_free_net_client(nc
);
446 void qemu_foreach_nic(qemu_nic_foreach func
, void *opaque
)
450 QTAILQ_FOREACH(nc
, &net_clients
, next
) {
451 if (nc
->info
->type
== NET_CLIENT_OPTIONS_KIND_NIC
) {
452 if (nc
->queue_index
== 0) {
453 func(qemu_get_nic(nc
), opaque
);
459 bool qemu_has_ufo(NetClientState
*nc
)
461 if (!nc
|| !nc
->info
->has_ufo
) {
465 return nc
->info
->has_ufo(nc
);
468 bool qemu_has_vnet_hdr(NetClientState
*nc
)
470 if (!nc
|| !nc
->info
->has_vnet_hdr
) {
474 return nc
->info
->has_vnet_hdr(nc
);
477 bool qemu_has_vnet_hdr_len(NetClientState
*nc
, int len
)
479 if (!nc
|| !nc
->info
->has_vnet_hdr_len
) {
483 return nc
->info
->has_vnet_hdr_len(nc
, len
);
486 void qemu_using_vnet_hdr(NetClientState
*nc
, bool enable
)
488 if (!nc
|| !nc
->info
->using_vnet_hdr
) {
492 nc
->info
->using_vnet_hdr(nc
, enable
);
495 void qemu_set_offload(NetClientState
*nc
, int csum
, int tso4
, int tso6
,
498 if (!nc
|| !nc
->info
->set_offload
) {
502 nc
->info
->set_offload(nc
, csum
, tso4
, tso6
, ecn
, ufo
);
505 void qemu_set_vnet_hdr_len(NetClientState
*nc
, int len
)
507 if (!nc
|| !nc
->info
->set_vnet_hdr_len
) {
511 nc
->info
->set_vnet_hdr_len(nc
, len
);
514 int qemu_set_vnet_le(NetClientState
*nc
, bool is_le
)
516 if (!nc
|| !nc
->info
->set_vnet_le
) {
520 return nc
->info
->set_vnet_le(nc
, is_le
);
523 int qemu_set_vnet_be(NetClientState
*nc
, bool is_be
)
525 if (!nc
|| !nc
->info
->set_vnet_be
) {
529 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 ssize_t
qemu_deliver_packet(NetClientState
*sender
,
559 NetClientState
*nc
= opaque
;
566 if (nc
->receive_disabled
) {
570 if (flags
& QEMU_NET_PACKET_FLAG_RAW
&& nc
->info
->receive_raw
) {
571 ret
= nc
->info
->receive_raw(nc
, data
, size
);
573 ret
= nc
->info
->receive(nc
, data
, size
);
577 nc
->receive_disabled
= 1;
583 void qemu_purge_queued_packets(NetClientState
*nc
)
589 qemu_net_queue_purge(nc
->peer
->incoming_queue
, nc
);
593 void qemu_flush_or_purge_queued_packets(NetClientState
*nc
, bool purge
)
595 nc
->receive_disabled
= 0;
597 if (nc
->peer
&& nc
->peer
->info
->type
== NET_CLIENT_OPTIONS_KIND_HUBPORT
) {
598 if (net_hub_flush(nc
->peer
)) {
602 if (qemu_net_queue_flush(nc
->incoming_queue
)) {
603 /* We emptied the queue successfully, signal to the IO thread to repoll
604 * the file descriptor (for tap, for example).
608 /* Unable to empty the queue, purge remaining packets */
609 qemu_net_queue_purge(nc
->incoming_queue
, nc
);
613 void qemu_flush_queued_packets(NetClientState
*nc
)
615 qemu_flush_or_purge_queued_packets(nc
, false);
618 static ssize_t
qemu_send_packet_async_with_flags(NetClientState
*sender
,
620 const uint8_t *buf
, int size
,
621 NetPacketSent
*sent_cb
)
626 printf("qemu_send_packet_async:\n");
627 hex_dump(stdout
, buf
, size
);
630 if (sender
->link_down
|| !sender
->peer
) {
634 queue
= sender
->peer
->incoming_queue
;
636 return qemu_net_queue_send(queue
, sender
, flags
, buf
, size
, sent_cb
);
639 ssize_t
qemu_send_packet_async(NetClientState
*sender
,
640 const uint8_t *buf
, int size
,
641 NetPacketSent
*sent_cb
)
643 return qemu_send_packet_async_with_flags(sender
, QEMU_NET_PACKET_FLAG_NONE
,
647 void qemu_send_packet(NetClientState
*nc
, const uint8_t *buf
, int size
)
649 qemu_send_packet_async(nc
, buf
, size
, NULL
);
652 ssize_t
qemu_send_packet_raw(NetClientState
*nc
, const uint8_t *buf
, int size
)
654 return qemu_send_packet_async_with_flags(nc
, QEMU_NET_PACKET_FLAG_RAW
,
658 static ssize_t
nc_sendv_compat(NetClientState
*nc
, const struct iovec
*iov
,
661 uint8_t buffer
[NET_BUFSIZE
];
664 offset
= iov_to_buf(iov
, iovcnt
, 0, buffer
, sizeof(buffer
));
666 return nc
->info
->receive(nc
, buffer
, offset
);
669 ssize_t
qemu_deliver_packet_iov(NetClientState
*sender
,
671 const struct iovec
*iov
,
675 NetClientState
*nc
= opaque
;
679 return iov_size(iov
, iovcnt
);
682 if (nc
->receive_disabled
) {
686 if (nc
->info
->receive_iov
) {
687 ret
= nc
->info
->receive_iov(nc
, iov
, iovcnt
);
689 ret
= nc_sendv_compat(nc
, iov
, iovcnt
);
693 nc
->receive_disabled
= 1;
699 ssize_t
qemu_sendv_packet_async(NetClientState
*sender
,
700 const struct iovec
*iov
, int iovcnt
,
701 NetPacketSent
*sent_cb
)
705 if (sender
->link_down
|| !sender
->peer
) {
706 return iov_size(iov
, iovcnt
);
709 queue
= sender
->peer
->incoming_queue
;
711 return qemu_net_queue_send_iov(queue
, sender
,
712 QEMU_NET_PACKET_FLAG_NONE
,
713 iov
, iovcnt
, sent_cb
);
717 qemu_sendv_packet(NetClientState
*nc
, const struct iovec
*iov
, int iovcnt
)
719 return qemu_sendv_packet_async(nc
, iov
, iovcnt
, NULL
);
722 NetClientState
*qemu_find_netdev(const char *id
)
726 QTAILQ_FOREACH(nc
, &net_clients
, next
) {
727 if (nc
->info
->type
== NET_CLIENT_OPTIONS_KIND_NIC
)
729 if (!strcmp(nc
->name
, id
)) {
737 int qemu_find_net_clients_except(const char *id
, NetClientState
**ncs
,
738 NetClientOptionsKind type
, int max
)
743 QTAILQ_FOREACH(nc
, &net_clients
, next
) {
744 if (nc
->info
->type
== type
) {
747 if (!id
|| !strcmp(nc
->name
, id
)) {
758 static int nic_get_free_idx(void)
762 for (index
= 0; index
< MAX_NICS
; index
++)
763 if (!nd_table
[index
].used
)
768 int qemu_show_nic_models(const char *arg
, const char *const *models
)
772 if (!arg
|| !is_help_option(arg
)) {
776 fprintf(stderr
, "qemu: Supported NIC models: ");
777 for (i
= 0 ; models
[i
]; i
++)
778 fprintf(stderr
, "%s%c", models
[i
], models
[i
+1] ? ',' : '\n');
782 void qemu_check_nic_model(NICInfo
*nd
, const char *model
)
784 const char *models
[2];
789 if (qemu_show_nic_models(nd
->model
, models
))
791 if (qemu_find_nic_model(nd
, models
, model
) < 0)
795 int qemu_find_nic_model(NICInfo
*nd
, const char * const *models
,
796 const char *default_model
)
801 nd
->model
= g_strdup(default_model
);
803 for (i
= 0 ; models
[i
]; i
++) {
804 if (strcmp(nd
->model
, models
[i
]) == 0)
808 error_report("Unsupported NIC model: %s", nd
->model
);
812 static int net_init_nic(const NetClientOptions
*opts
, const char *name
,
813 NetClientState
*peer
, Error
**errp
)
817 const NetLegacyNicOptions
*nic
;
819 assert(opts
->kind
== NET_CLIENT_OPTIONS_KIND_NIC
);
822 idx
= nic_get_free_idx();
823 if (idx
== -1 || nb_nics
>= MAX_NICS
) {
824 error_setg(errp
, "too many NICs");
830 memset(nd
, 0, sizeof(*nd
));
832 if (nic
->has_netdev
) {
833 nd
->netdev
= qemu_find_netdev(nic
->netdev
);
835 error_setg(errp
, "netdev '%s' not found", nic
->netdev
);
842 nd
->name
= g_strdup(name
);
843 if (nic
->has_model
) {
844 nd
->model
= g_strdup(nic
->model
);
847 nd
->devaddr
= g_strdup(nic
->addr
);
850 if (nic
->has_macaddr
&&
851 net_parse_macaddr(nd
->macaddr
.a
, nic
->macaddr
) < 0) {
852 error_setg(errp
, "invalid syntax for ethernet address");
855 if (nic
->has_macaddr
&&
856 is_multicast_ether_addr(nd
->macaddr
.a
)) {
858 "NIC cannot have multicast MAC address (odd 1st byte)");
861 qemu_macaddr_default_if_unset(&nd
->macaddr
);
863 if (nic
->has_vectors
) {
864 if (nic
->vectors
> 0x7ffffff) {
865 error_setg(errp
, "invalid # of vectors: %"PRIu32
, nic
->vectors
);
868 nd
->nvectors
= nic
->vectors
;
870 nd
->nvectors
= DEV_NVECTORS_UNSPECIFIED
;
880 static int (* const net_client_init_fun
[NET_CLIENT_OPTIONS_KIND_MAX
])(
881 const NetClientOptions
*opts
,
883 NetClientState
*peer
, Error
**errp
) = {
884 [NET_CLIENT_OPTIONS_KIND_NIC
] = net_init_nic
,
886 [NET_CLIENT_OPTIONS_KIND_USER
] = net_init_slirp
,
888 [NET_CLIENT_OPTIONS_KIND_TAP
] = net_init_tap
,
889 [NET_CLIENT_OPTIONS_KIND_SOCKET
] = net_init_socket
,
891 [NET_CLIENT_OPTIONS_KIND_VDE
] = net_init_vde
,
894 [NET_CLIENT_OPTIONS_KIND_NETMAP
] = net_init_netmap
,
896 [NET_CLIENT_OPTIONS_KIND_DUMP
] = net_init_dump
,
897 #ifdef CONFIG_NET_BRIDGE
898 [NET_CLIENT_OPTIONS_KIND_BRIDGE
] = net_init_bridge
,
900 [NET_CLIENT_OPTIONS_KIND_HUBPORT
] = net_init_hubport
,
901 #ifdef CONFIG_VHOST_NET_USED
902 [NET_CLIENT_OPTIONS_KIND_VHOST_USER
] = net_init_vhost_user
,
905 [NET_CLIENT_OPTIONS_KIND_L2TPV3
] = net_init_l2tpv3
,
910 static int net_client_init1(const void *object
, int is_netdev
, Error
**errp
)
913 const Netdev
*netdev
;
914 const NetLegacy
*net
;
916 const NetClientOptions
*opts
;
921 opts
= u
.netdev
->opts
;
924 switch (opts
->kind
) {
926 case NET_CLIENT_OPTIONS_KIND_USER
:
928 case NET_CLIENT_OPTIONS_KIND_TAP
:
929 case NET_CLIENT_OPTIONS_KIND_SOCKET
:
931 case NET_CLIENT_OPTIONS_KIND_VDE
:
934 case NET_CLIENT_OPTIONS_KIND_NETMAP
:
936 #ifdef CONFIG_NET_BRIDGE
937 case NET_CLIENT_OPTIONS_KIND_BRIDGE
:
939 case NET_CLIENT_OPTIONS_KIND_HUBPORT
:
940 #ifdef CONFIG_VHOST_NET_USED
941 case NET_CLIENT_OPTIONS_KIND_VHOST_USER
:
944 case NET_CLIENT_OPTIONS_KIND_L2TPV3
:
949 error_setg(errp
, QERR_INVALID_PARAMETER_VALUE
, "type",
950 "a netdev backend type");
956 if (opts
->kind
== NET_CLIENT_OPTIONS_KIND_HUBPORT
) {
957 error_setg(errp
, QERR_INVALID_PARAMETER_VALUE
, "type",
961 /* missing optional values have been initialized to "all bits zero" */
962 name
= u
.net
->has_id
? u
.net
->id
: u
.net
->name
;
965 if (net_client_init_fun
[opts
->kind
]) {
966 NetClientState
*peer
= NULL
;
968 /* Do not add to a vlan if it's a -netdev or a nic with a netdev=
971 (opts
->kind
!= NET_CLIENT_OPTIONS_KIND_NIC
||
972 !opts
->nic
->has_netdev
)) {
973 peer
= net_hub_add_port(u
.net
->has_vlan
? u
.net
->vlan
: 0, NULL
);
976 if (net_client_init_fun
[opts
->kind
](opts
, name
, peer
, errp
) < 0) {
977 /* FIXME drop when all init functions store an Error */
978 if (errp
&& !*errp
) {
979 error_setg(errp
, QERR_DEVICE_INIT_FAILED
,
980 NetClientOptionsKind_lookup
[opts
->kind
]);
989 static void net_visit(Visitor
*v
, int is_netdev
, void **object
, Error
**errp
)
992 visit_type_Netdev(v
, (Netdev
**)object
, NULL
, errp
);
994 visit_type_NetLegacy(v
, (NetLegacy
**)object
, NULL
, errp
);
999 int net_client_init(QemuOpts
*opts
, int is_netdev
, Error
**errp
)
1001 void *object
= NULL
;
1006 OptsVisitor
*ov
= opts_visitor_new(opts
);
1008 net_visit(opts_get_visitor(ov
), is_netdev
, &object
, &err
);
1009 opts_visitor_cleanup(ov
);
1013 ret
= net_client_init1(object
, is_netdev
, &err
);
1017 QapiDeallocVisitor
*dv
= qapi_dealloc_visitor_new();
1019 net_visit(qapi_dealloc_get_visitor(dv
), is_netdev
, &object
, NULL
);
1020 qapi_dealloc_visitor_cleanup(dv
);
1023 error_propagate(errp
, err
);
1028 static int net_host_check_device(const char *device
)
1031 for (i
= 0; host_net_devices
[i
]; i
++) {
1032 if (!strncmp(host_net_devices
[i
], device
,
1033 strlen(host_net_devices
[i
]))) {
1041 void hmp_host_net_add(Monitor
*mon
, const QDict
*qdict
)
1043 const char *device
= qdict_get_str(qdict
, "device");
1044 const char *opts_str
= qdict_get_try_str(qdict
, "opts");
1045 Error
*local_err
= NULL
;
1048 if (!net_host_check_device(device
)) {
1049 monitor_printf(mon
, "invalid host network device %s\n", device
);
1053 opts
= qemu_opts_parse_noisily(qemu_find_opts("net"),
1054 opts_str
? opts_str
: "", false);
1059 qemu_opt_set(opts
, "type", device
, &error_abort
);
1061 net_client_init(opts
, 0, &local_err
);
1063 error_report_err(local_err
);
1064 monitor_printf(mon
, "adding host network device %s failed\n", device
);
1068 void hmp_host_net_remove(Monitor
*mon
, const QDict
*qdict
)
1071 int vlan_id
= qdict_get_int(qdict
, "vlan_id");
1072 const char *device
= qdict_get_str(qdict
, "device");
1074 nc
= net_hub_find_client_by_name(vlan_id
, device
);
1076 error_report("Host network device '%s' on hub '%d' not found",
1080 if (nc
->info
->type
== NET_CLIENT_OPTIONS_KIND_NIC
) {
1081 error_report("invalid host network device '%s'", device
);
1085 qemu_del_net_client(nc
->peer
);
1086 qemu_del_net_client(nc
);
1089 void netdev_add(QemuOpts
*opts
, Error
**errp
)
1091 net_client_init(opts
, 1, errp
);
1094 void qmp_netdev_add(QDict
*qdict
, QObject
**ret
, Error
**errp
)
1096 Error
*local_err
= NULL
;
1097 QemuOptsList
*opts_list
;
1100 opts_list
= qemu_find_opts_err("netdev", &local_err
);
1105 opts
= qemu_opts_from_qdict(opts_list
, qdict
, &local_err
);
1110 netdev_add(opts
, &local_err
);
1112 qemu_opts_del(opts
);
1117 error_propagate(errp
, local_err
);
1120 void qmp_netdev_del(const char *id
, Error
**errp
)
1125 nc
= qemu_find_netdev(id
);
1127 error_set(errp
, ERROR_CLASS_DEVICE_NOT_FOUND
,
1128 "Device '%s' not found", id
);
1132 opts
= qemu_opts_find(qemu_find_opts_err("netdev", NULL
), id
);
1134 error_setg(errp
, "Device '%s' is not a netdev", id
);
1138 qemu_del_net_client(nc
);
1139 qemu_opts_del(opts
);
1142 void print_net_client(Monitor
*mon
, NetClientState
*nc
)
1144 monitor_printf(mon
, "%s: index=%d,type=%s,%s\n", nc
->name
,
1146 NetClientOptionsKind_lookup
[nc
->info
->type
],
1150 RxFilterInfoList
*qmp_query_rx_filter(bool has_name
, const char *name
,
1154 RxFilterInfoList
*filter_list
= NULL
, *last_entry
= NULL
;
1156 QTAILQ_FOREACH(nc
, &net_clients
, next
) {
1157 RxFilterInfoList
*entry
;
1160 if (has_name
&& strcmp(nc
->name
, name
) != 0) {
1164 /* only query rx-filter information of NIC */
1165 if (nc
->info
->type
!= NET_CLIENT_OPTIONS_KIND_NIC
) {
1167 error_setg(errp
, "net client(%s) isn't a NIC", name
);
1173 if (nc
->info
->query_rx_filter
) {
1174 info
= nc
->info
->query_rx_filter(nc
);
1175 entry
= g_malloc0(sizeof(*entry
));
1176 entry
->value
= info
;
1179 filter_list
= entry
;
1181 last_entry
->next
= entry
;
1184 } else if (has_name
) {
1185 error_setg(errp
, "net client(%s) doesn't support"
1186 " rx-filter querying", name
);
1195 if (filter_list
== NULL
&& has_name
) {
1196 error_setg(errp
, "invalid net client name: %s", name
);
1202 void hmp_info_network(Monitor
*mon
, const QDict
*qdict
)
1204 NetClientState
*nc
, *peer
;
1205 NetClientOptionsKind type
;
1209 QTAILQ_FOREACH(nc
, &net_clients
, next
) {
1211 type
= nc
->info
->type
;
1213 /* Skip if already printed in hub info */
1214 if (net_hub_id_for_client(nc
, NULL
) == 0) {
1218 if (!peer
|| type
== NET_CLIENT_OPTIONS_KIND_NIC
) {
1219 print_net_client(mon
, nc
);
1220 } /* else it's a netdev connected to a NIC, printed with the NIC */
1221 if (peer
&& type
== NET_CLIENT_OPTIONS_KIND_NIC
) {
1222 monitor_printf(mon
, " \\ ");
1223 print_net_client(mon
, peer
);
1228 void qmp_set_link(const char *name
, bool up
, Error
**errp
)
1230 NetClientState
*ncs
[MAX_QUEUE_NUM
];
1234 queues
= qemu_find_net_clients_except(name
, ncs
,
1235 NET_CLIENT_OPTIONS_KIND_MAX
,
1239 error_set(errp
, ERROR_CLASS_DEVICE_NOT_FOUND
,
1240 "Device '%s' 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_noisily(opts_list
, optarg
, true)) {
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 */ }