4 * Copyright (c) 2003-2008 Fabrice Bellard
5 * Copyright (c) 2009 Red Hat, Inc.
7 * Permission is hereby granted, free of charge, to any person obtaining a copy
8 * of this software and associated documentation files (the "Software"), to deal
9 * in the Software without restriction, including without limitation the rights
10 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 * copies of the Software, and to permit persons to whom the Software is
12 * furnished to do so, subject to the following conditions:
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
28 #include "config-host.h"
30 #include <sys/ioctl.h>
33 #include <sys/socket.h>
38 #include "monitor/monitor.h"
39 #include "sysemu/sysemu.h"
40 #include "qemu-common.h"
41 #include "qemu/error-report.h"
45 #include "net/vhost_net.h"
47 typedef struct TAPState
{
50 char down_script
[1024];
51 char down_script_arg
[128];
52 uint8_t buf
[NET_BUFSIZE
];
58 VHostNetState
*vhost_net
;
59 unsigned host_vnet_hdr_len
;
62 static void launch_script(const char *setup_script
, const char *ifname
,
63 int fd
, Error
**errp
);
65 static int tap_can_send(void *opaque
);
66 static void tap_send(void *opaque
);
67 static void tap_writable(void *opaque
);
69 static void tap_update_fd_handler(TAPState
*s
)
71 qemu_set_fd_handler2(s
->fd
,
72 s
->read_poll
&& s
->enabled
? tap_can_send
: NULL
,
73 s
->read_poll
&& s
->enabled
? tap_send
: NULL
,
74 s
->write_poll
&& s
->enabled
? tap_writable
: NULL
,
78 static void tap_read_poll(TAPState
*s
, bool enable
)
80 s
->read_poll
= enable
;
81 tap_update_fd_handler(s
);
84 static void tap_write_poll(TAPState
*s
, bool enable
)
86 s
->write_poll
= enable
;
87 tap_update_fd_handler(s
);
90 static void tap_writable(void *opaque
)
94 tap_write_poll(s
, false);
96 qemu_flush_queued_packets(&s
->nc
);
99 static ssize_t
tap_write_packet(TAPState
*s
, const struct iovec
*iov
, int iovcnt
)
104 len
= writev(s
->fd
, iov
, iovcnt
);
105 } while (len
== -1 && errno
== EINTR
);
107 if (len
== -1 && errno
== EAGAIN
) {
108 tap_write_poll(s
, true);
115 static ssize_t
tap_receive_iov(NetClientState
*nc
, const struct iovec
*iov
,
118 TAPState
*s
= DO_UPCAST(TAPState
, nc
, nc
);
119 const struct iovec
*iovp
= iov
;
120 struct iovec iov_copy
[iovcnt
+ 1];
121 struct virtio_net_hdr_mrg_rxbuf hdr
= { };
123 if (s
->host_vnet_hdr_len
&& !s
->using_vnet_hdr
) {
124 iov_copy
[0].iov_base
= &hdr
;
125 iov_copy
[0].iov_len
= s
->host_vnet_hdr_len
;
126 memcpy(&iov_copy
[1], iov
, iovcnt
* sizeof(*iov
));
131 return tap_write_packet(s
, iovp
, iovcnt
);
134 static ssize_t
tap_receive_raw(NetClientState
*nc
, const uint8_t *buf
, size_t size
)
136 TAPState
*s
= DO_UPCAST(TAPState
, nc
, nc
);
139 struct virtio_net_hdr_mrg_rxbuf hdr
= { };
141 if (s
->host_vnet_hdr_len
) {
142 iov
[iovcnt
].iov_base
= &hdr
;
143 iov
[iovcnt
].iov_len
= s
->host_vnet_hdr_len
;
147 iov
[iovcnt
].iov_base
= (char *)buf
;
148 iov
[iovcnt
].iov_len
= size
;
151 return tap_write_packet(s
, iov
, iovcnt
);
154 static ssize_t
tap_receive(NetClientState
*nc
, const uint8_t *buf
, size_t size
)
156 TAPState
*s
= DO_UPCAST(TAPState
, nc
, nc
);
159 if (s
->host_vnet_hdr_len
&& !s
->using_vnet_hdr
) {
160 return tap_receive_raw(nc
, buf
, size
);
163 iov
[0].iov_base
= (char *)buf
;
164 iov
[0].iov_len
= size
;
166 return tap_write_packet(s
, iov
, 1);
169 static int tap_can_send(void *opaque
)
171 TAPState
*s
= opaque
;
173 return qemu_can_send_packet(&s
->nc
);
177 ssize_t
tap_read_packet(int tapfd
, uint8_t *buf
, int maxlen
)
179 return read(tapfd
, buf
, maxlen
);
183 static void tap_send_completed(NetClientState
*nc
, ssize_t len
)
185 TAPState
*s
= DO_UPCAST(TAPState
, nc
, nc
);
186 tap_read_poll(s
, true);
189 static void tap_send(void *opaque
)
191 TAPState
*s
= opaque
;
195 while (qemu_can_send_packet(&s
->nc
)) {
196 uint8_t *buf
= s
->buf
;
198 size
= tap_read_packet(s
->fd
, s
->buf
, sizeof(s
->buf
));
203 if (s
->host_vnet_hdr_len
&& !s
->using_vnet_hdr
) {
204 buf
+= s
->host_vnet_hdr_len
;
205 size
-= s
->host_vnet_hdr_len
;
208 size
= qemu_send_packet_async(&s
->nc
, buf
, size
, tap_send_completed
);
210 tap_read_poll(s
, false);
212 } else if (size
< 0) {
217 * When the host keeps receiving more packets while tap_send() is
218 * running we can hog the QEMU global mutex. Limit the number of
219 * packets that are processed per tap_send() callback to prevent
220 * stalling the guest.
229 static bool tap_has_ufo(NetClientState
*nc
)
231 TAPState
*s
= DO_UPCAST(TAPState
, nc
, nc
);
233 assert(nc
->info
->type
== NET_CLIENT_OPTIONS_KIND_TAP
);
238 static bool tap_has_vnet_hdr(NetClientState
*nc
)
240 TAPState
*s
= DO_UPCAST(TAPState
, nc
, nc
);
242 assert(nc
->info
->type
== NET_CLIENT_OPTIONS_KIND_TAP
);
244 return !!s
->host_vnet_hdr_len
;
247 static bool tap_has_vnet_hdr_len(NetClientState
*nc
, int len
)
249 TAPState
*s
= DO_UPCAST(TAPState
, nc
, nc
);
251 assert(nc
->info
->type
== NET_CLIENT_OPTIONS_KIND_TAP
);
253 return !!tap_probe_vnet_hdr_len(s
->fd
, len
);
256 static void tap_set_vnet_hdr_len(NetClientState
*nc
, int len
)
258 TAPState
*s
= DO_UPCAST(TAPState
, nc
, nc
);
260 assert(nc
->info
->type
== NET_CLIENT_OPTIONS_KIND_TAP
);
261 assert(len
== sizeof(struct virtio_net_hdr_mrg_rxbuf
) ||
262 len
== sizeof(struct virtio_net_hdr
));
264 tap_fd_set_vnet_hdr_len(s
->fd
, len
);
265 s
->host_vnet_hdr_len
= len
;
268 static void tap_using_vnet_hdr(NetClientState
*nc
, bool using_vnet_hdr
)
270 TAPState
*s
= DO_UPCAST(TAPState
, nc
, nc
);
272 assert(nc
->info
->type
== NET_CLIENT_OPTIONS_KIND_TAP
);
273 assert(!!s
->host_vnet_hdr_len
== using_vnet_hdr
);
275 s
->using_vnet_hdr
= using_vnet_hdr
;
278 static void tap_set_offload(NetClientState
*nc
, int csum
, int tso4
,
279 int tso6
, int ecn
, int ufo
)
281 TAPState
*s
= DO_UPCAST(TAPState
, nc
, nc
);
286 tap_fd_set_offload(s
->fd
, csum
, tso4
, tso6
, ecn
, ufo
);
289 static void tap_cleanup(NetClientState
*nc
)
291 TAPState
*s
= DO_UPCAST(TAPState
, nc
, nc
);
295 vhost_net_cleanup(s
->vhost_net
);
299 qemu_purge_queued_packets(nc
);
301 if (s
->down_script
[0]) {
302 launch_script(s
->down_script
, s
->down_script_arg
, s
->fd
, &err
);
304 error_report_err(err
);
308 tap_read_poll(s
, false);
309 tap_write_poll(s
, false);
314 static void tap_poll(NetClientState
*nc
, bool enable
)
316 TAPState
*s
= DO_UPCAST(TAPState
, nc
, nc
);
317 tap_read_poll(s
, enable
);
318 tap_write_poll(s
, enable
);
321 int tap_get_fd(NetClientState
*nc
)
323 TAPState
*s
= DO_UPCAST(TAPState
, nc
, nc
);
324 assert(nc
->info
->type
== NET_CLIENT_OPTIONS_KIND_TAP
);
330 static NetClientInfo net_tap_info
= {
331 .type
= NET_CLIENT_OPTIONS_KIND_TAP
,
332 .size
= sizeof(TAPState
),
333 .receive
= tap_receive
,
334 .receive_raw
= tap_receive_raw
,
335 .receive_iov
= tap_receive_iov
,
337 .cleanup
= tap_cleanup
,
338 .has_ufo
= tap_has_ufo
,
339 .has_vnet_hdr
= tap_has_vnet_hdr
,
340 .has_vnet_hdr_len
= tap_has_vnet_hdr_len
,
341 .using_vnet_hdr
= tap_using_vnet_hdr
,
342 .set_offload
= tap_set_offload
,
343 .set_vnet_hdr_len
= tap_set_vnet_hdr_len
,
346 static TAPState
*net_tap_fd_init(NetClientState
*peer
,
355 nc
= qemu_new_net_client(&net_tap_info
, peer
, model
, name
);
357 s
= DO_UPCAST(TAPState
, nc
, nc
);
360 s
->host_vnet_hdr_len
= vnet_hdr
? sizeof(struct virtio_net_hdr
) : 0;
361 s
->using_vnet_hdr
= false;
362 s
->has_ufo
= tap_probe_has_ufo(s
->fd
);
364 tap_set_offload(&s
->nc
, 0, 0, 0, 0, 0);
366 * Make sure host header length is set correctly in tap:
367 * it might have been modified by another instance of qemu.
369 if (tap_probe_vnet_hdr_len(s
->fd
, s
->host_vnet_hdr_len
)) {
370 tap_fd_set_vnet_hdr_len(s
->fd
, s
->host_vnet_hdr_len
);
372 tap_read_poll(s
, true);
377 static void launch_script(const char *setup_script
, const char *ifname
,
378 int fd
, Error
**errp
)
384 /* try to launch network script */
387 error_setg_errno(errp
, errno
, "could not launch network script %s",
392 int open_max
= sysconf(_SC_OPEN_MAX
), i
;
394 for (i
= 3; i
< open_max
; i
++) {
400 *parg
++ = (char *)setup_script
;
401 *parg
++ = (char *)ifname
;
403 execv(setup_script
, args
);
406 while (waitpid(pid
, &status
, 0) != pid
) {
410 if (WIFEXITED(status
) && WEXITSTATUS(status
) == 0) {
413 error_setg(errp
, "network script %s failed with status %d",
414 setup_script
, status
);
418 static int recv_fd(int c
)
421 uint8_t msgbuf
[CMSG_SPACE(sizeof(fd
))];
422 struct msghdr msg
= {
423 .msg_control
= msgbuf
,
424 .msg_controllen
= sizeof(msgbuf
),
426 struct cmsghdr
*cmsg
;
431 cmsg
= CMSG_FIRSTHDR(&msg
);
432 cmsg
->cmsg_level
= SOL_SOCKET
;
433 cmsg
->cmsg_type
= SCM_RIGHTS
;
434 cmsg
->cmsg_len
= CMSG_LEN(sizeof(fd
));
435 msg
.msg_controllen
= cmsg
->cmsg_len
;
438 iov
.iov_len
= sizeof(req
);
443 len
= recvmsg(c
, &msg
, 0);
445 memcpy(&fd
, CMSG_DATA(cmsg
), sizeof(fd
));
452 static int net_bridge_run_helper(const char *helper
, const char *bridge
,
455 sigset_t oldmask
, mask
;
462 sigaddset(&mask
, SIGCHLD
);
463 sigprocmask(SIG_BLOCK
, &mask
, &oldmask
);
465 if (socketpair(PF_UNIX
, SOCK_STREAM
, 0, sv
) == -1) {
466 error_setg_errno(errp
, errno
, "socketpair() failed");
470 /* try to launch bridge helper */
473 error_setg_errno(errp
, errno
, "Can't fork bridge helper");
477 int open_max
= sysconf(_SC_OPEN_MAX
), i
;
479 char br_buf
[6+IFNAMSIZ
] = {0};
480 char helper_cmd
[PATH_MAX
+ sizeof(fd_buf
) + sizeof(br_buf
) + 15];
482 for (i
= 3; i
< open_max
; i
++) {
488 snprintf(fd_buf
, sizeof(fd_buf
), "%s%d", "--fd=", sv
[1]);
490 if (strrchr(helper
, ' ') || strrchr(helper
, '\t')) {
491 /* assume helper is a command */
493 if (strstr(helper
, "--br=") == NULL
) {
494 snprintf(br_buf
, sizeof(br_buf
), "%s%s", "--br=", bridge
);
497 snprintf(helper_cmd
, sizeof(helper_cmd
), "%s %s %s %s",
498 helper
, "--use-vnet", fd_buf
, br_buf
);
501 *parg
++ = (char *)"sh";
502 *parg
++ = (char *)"-c";
503 *parg
++ = helper_cmd
;
506 execv("/bin/sh", args
);
508 /* assume helper is just the executable path name */
510 snprintf(br_buf
, sizeof(br_buf
), "%s%s", "--br=", bridge
);
513 *parg
++ = (char *)helper
;
514 *parg
++ = (char *)"--use-vnet";
531 } while (fd
== -1 && errno
== EINTR
);
536 while (waitpid(pid
, &status
, 0) != pid
) {
539 sigprocmask(SIG_SETMASK
, &oldmask
, NULL
);
541 error_setg_errno(errp
, saved_errno
,
542 "failed to recv file descriptor");
545 if (!WIFEXITED(status
) || WEXITSTATUS(status
) != 0) {
546 error_setg(errp
, "bridge helper failed");
553 int net_init_bridge(const NetClientOptions
*opts
, const char *name
,
554 NetClientState
*peer
, Error
**errp
)
556 const NetdevBridgeOptions
*bridge
;
557 const char *helper
, *br
;
561 assert(opts
->kind
== NET_CLIENT_OPTIONS_KIND_BRIDGE
);
562 bridge
= opts
->bridge
;
564 helper
= bridge
->has_helper
? bridge
->helper
: DEFAULT_BRIDGE_HELPER
;
565 br
= bridge
->has_br
? bridge
->br
: DEFAULT_BRIDGE_INTERFACE
;
567 fd
= net_bridge_run_helper(helper
, br
, errp
);
572 fcntl(fd
, F_SETFL
, O_NONBLOCK
);
573 vnet_hdr
= tap_probe_vnet_hdr(fd
);
574 s
= net_tap_fd_init(peer
, "bridge", name
, fd
, vnet_hdr
);
576 snprintf(s
->nc
.info_str
, sizeof(s
->nc
.info_str
), "helper=%s,br=%s", helper
,
582 static int net_tap_init(const NetdevTapOptions
*tap
, int *vnet_hdr
,
583 const char *setup_script
, char *ifname
,
584 size_t ifname_sz
, int mq_required
, Error
**errp
)
587 int fd
, vnet_hdr_required
;
589 if (tap
->has_vnet_hdr
) {
590 *vnet_hdr
= tap
->vnet_hdr
;
591 vnet_hdr_required
= *vnet_hdr
;
594 vnet_hdr_required
= 0;
597 TFR(fd
= tap_open(ifname
, ifname_sz
, vnet_hdr
, vnet_hdr_required
,
604 setup_script
[0] != '\0' &&
605 strcmp(setup_script
, "no") != 0) {
606 launch_script(setup_script
, ifname
, fd
, &err
);
608 error_propagate(errp
, err
);
617 #define MAX_TAP_QUEUES 1024
619 static void net_init_tap_one(const NetdevTapOptions
*tap
, NetClientState
*peer
,
620 const char *model
, const char *name
,
621 const char *ifname
, const char *script
,
622 const char *downscript
, const char *vhostfdname
,
623 int vnet_hdr
, int fd
, Error
**errp
)
626 TAPState
*s
= net_tap_fd_init(peer
, model
, name
, fd
, vnet_hdr
);
629 tap_set_sndbuf(s
->fd
, tap
, &err
);
631 error_propagate(errp
, err
);
635 if (tap
->has_fd
|| tap
->has_fds
) {
636 snprintf(s
->nc
.info_str
, sizeof(s
->nc
.info_str
), "fd=%d", fd
);
637 } else if (tap
->has_helper
) {
638 snprintf(s
->nc
.info_str
, sizeof(s
->nc
.info_str
), "helper=%s",
641 snprintf(s
->nc
.info_str
, sizeof(s
->nc
.info_str
),
642 "ifname=%s,script=%s,downscript=%s", ifname
, script
,
645 if (strcmp(downscript
, "no") != 0) {
646 snprintf(s
->down_script
, sizeof(s
->down_script
), "%s", downscript
);
647 snprintf(s
->down_script_arg
, sizeof(s
->down_script_arg
),
652 if (tap
->has_vhost
? tap
->vhost
:
653 vhostfdname
|| (tap
->has_vhostforce
&& tap
->vhostforce
)) {
654 VhostNetOptions options
;
656 options
.backend_type
= VHOST_BACKEND_TYPE_KERNEL
;
657 options
.net_backend
= &s
->nc
;
658 options
.force
= tap
->has_vhostforce
&& tap
->vhostforce
;
660 if (tap
->has_vhostfd
|| tap
->has_vhostfds
) {
661 vhostfd
= monitor_fd_param(cur_mon
, vhostfdname
, &err
);
663 error_propagate(errp
, err
);
667 vhostfd
= open("/dev/vhost-net", O_RDWR
);
669 error_setg_errno(errp
, errno
,
670 "tap: open vhost char device failed");
674 options
.opaque
= (void *)(uintptr_t)vhostfd
;
676 s
->vhost_net
= vhost_net_init(&options
);
679 "vhost-net requested but could not be initialized");
682 } else if (tap
->has_vhostfd
|| tap
->has_vhostfds
) {
683 error_setg(errp
, "vhostfd= is not valid without vhost");
687 static int get_fds(char *str
, char *fds
[], int max
)
689 char *ptr
= str
, *this;
690 size_t len
= strlen(str
);
693 while (i
< max
&& ptr
< str
+ len
) {
694 this = strchr(ptr
, ':');
697 fds
[i
] = g_strdup(ptr
);
699 fds
[i
] = g_strndup(ptr
, this - ptr
);
713 int net_init_tap(const NetClientOptions
*opts
, const char *name
,
714 NetClientState
*peer
, Error
**errp
)
716 const NetdevTapOptions
*tap
;
717 int fd
, vnet_hdr
= 0, i
= 0, queues
;
718 /* for the no-fd, no-helper case */
719 const char *script
= NULL
; /* suppress wrong "uninit'd use" gcc warning */
720 const char *downscript
= NULL
;
722 const char *vhostfdname
;
725 assert(opts
->kind
== NET_CLIENT_OPTIONS_KIND_TAP
);
727 queues
= tap
->has_queues
? tap
->queues
: 1;
728 vhostfdname
= tap
->has_vhostfd
? tap
->vhostfd
: NULL
;
730 /* QEMU vlans does not support multiqueue tap, in this case peer is set.
731 * For -netdev, peer is always NULL. */
732 if (peer
&& (tap
->has_queues
|| tap
->has_fds
|| tap
->has_vhostfds
)) {
733 error_setg(errp
, "Multiqueue tap cannot be used with QEMU vlans");
738 if (tap
->has_ifname
|| tap
->has_script
|| tap
->has_downscript
||
739 tap
->has_vnet_hdr
|| tap
->has_helper
|| tap
->has_queues
||
740 tap
->has_fds
|| tap
->has_vhostfds
) {
741 error_setg(errp
, "ifname=, script=, downscript=, vnet_hdr=, "
742 "helper=, queues=, fds=, and vhostfds= "
743 "are invalid with fd=");
747 fd
= monitor_fd_param(cur_mon
, tap
->fd
, &err
);
749 error_propagate(errp
, err
);
753 fcntl(fd
, F_SETFL
, O_NONBLOCK
);
755 vnet_hdr
= tap_probe_vnet_hdr(fd
);
757 net_init_tap_one(tap
, peer
, "tap", name
, NULL
,
759 vhostfdname
, vnet_hdr
, fd
, &err
);
761 error_propagate(errp
, err
);
764 } else if (tap
->has_fds
) {
765 char *fds
[MAX_TAP_QUEUES
];
766 char *vhost_fds
[MAX_TAP_QUEUES
];
769 if (tap
->has_ifname
|| tap
->has_script
|| tap
->has_downscript
||
770 tap
->has_vnet_hdr
|| tap
->has_helper
|| tap
->has_queues
||
772 error_setg(errp
, "ifname=, script=, downscript=, vnet_hdr=, "
773 "helper=, queues=, and vhostfd= "
774 "are invalid with fds=");
778 nfds
= get_fds(tap
->fds
, fds
, MAX_TAP_QUEUES
);
779 if (tap
->has_vhostfds
) {
780 nvhosts
= get_fds(tap
->vhostfds
, vhost_fds
, MAX_TAP_QUEUES
);
781 if (nfds
!= nvhosts
) {
782 error_setg(errp
, "The number of fds passed does not match "
783 "the number of vhostfds passed");
788 for (i
= 0; i
< nfds
; i
++) {
789 fd
= monitor_fd_param(cur_mon
, fds
[i
], &err
);
791 error_propagate(errp
, err
);
795 fcntl(fd
, F_SETFL
, O_NONBLOCK
);
798 vnet_hdr
= tap_probe_vnet_hdr(fd
);
799 } else if (vnet_hdr
!= tap_probe_vnet_hdr(fd
)) {
801 "vnet_hdr not consistent across given tap fds");
805 net_init_tap_one(tap
, peer
, "tap", name
, ifname
,
807 tap
->has_vhostfds
? vhost_fds
[i
] : NULL
,
810 error_propagate(errp
, err
);
814 } else if (tap
->has_helper
) {
815 if (tap
->has_ifname
|| tap
->has_script
|| tap
->has_downscript
||
816 tap
->has_vnet_hdr
|| tap
->has_queues
|| tap
->has_vhostfds
) {
817 error_setg(errp
, "ifname=, script=, downscript=, vnet_hdr=, "
818 "queues=, and vhostfds= are invalid with helper=");
822 fd
= net_bridge_run_helper(tap
->helper
, DEFAULT_BRIDGE_INTERFACE
,
828 fcntl(fd
, F_SETFL
, O_NONBLOCK
);
829 vnet_hdr
= tap_probe_vnet_hdr(fd
);
831 net_init_tap_one(tap
, peer
, "bridge", name
, ifname
,
832 script
, downscript
, vhostfdname
,
835 error_propagate(errp
, err
);
840 if (tap
->has_vhostfds
) {
841 error_setg(errp
, "vhostfds= is invalid if fds= wasn't specified");
844 script
= tap
->has_script
? tap
->script
: DEFAULT_NETWORK_SCRIPT
;
845 downscript
= tap
->has_downscript
? tap
->downscript
:
846 DEFAULT_NETWORK_DOWN_SCRIPT
;
848 if (tap
->has_ifname
) {
849 pstrcpy(ifname
, sizeof ifname
, tap
->ifname
);
854 for (i
= 0; i
< queues
; i
++) {
855 fd
= net_tap_init(tap
, &vnet_hdr
, i
>= 1 ? "no" : script
,
856 ifname
, sizeof ifname
, queues
> 1, errp
);
861 if (queues
> 1 && i
== 0 && !tap
->has_ifname
) {
862 if (tap_fd_get_ifname(fd
, ifname
)) {
863 error_setg(errp
, "Fail to get ifname");
869 net_init_tap_one(tap
, peer
, "tap", name
, ifname
,
870 i
>= 1 ? "no" : script
,
871 i
>= 1 ? "no" : downscript
,
872 vhostfdname
, vnet_hdr
, fd
, &err
);
874 error_propagate(errp
, err
);
884 VHostNetState
*tap_get_vhost_net(NetClientState
*nc
)
886 TAPState
*s
= DO_UPCAST(TAPState
, nc
, nc
);
887 assert(nc
->info
->type
== NET_CLIENT_OPTIONS_KIND_TAP
);
891 int tap_enable(NetClientState
*nc
)
893 TAPState
*s
= DO_UPCAST(TAPState
, nc
, nc
);
899 ret
= tap_fd_enable(s
->fd
);
902 tap_update_fd_handler(s
);
908 int tap_disable(NetClientState
*nc
)
910 TAPState
*s
= DO_UPCAST(TAPState
, nc
, nc
);
913 if (s
->enabled
== 0) {
916 ret
= tap_fd_disable(s
->fd
);
918 qemu_purge_queued_packets(nc
);
920 tap_update_fd_handler(s
);