From patchwork Wed Aug 1 12:54:44 2012 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Stefan Hajnoczi X-Patchwork-Id: 174448 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from lists.gnu.org (lists.gnu.org [208.118.235.17]) (using TLSv1 with cipher AES256-SHA (256/256 bits)) (Client did not present a certificate) by ozlabs.org (Postfix) with ESMTPS id 585322C008A for ; Wed, 1 Aug 2012 22:57:36 +1000 (EST) Received: from localhost ([::1]:56964 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1SwYUY-0003gF-IE for incoming@patchwork.ozlabs.org; Wed, 01 Aug 2012 08:57:34 -0400 Received: from eggs.gnu.org ([208.118.235.92]:60584) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1SwYSJ-0007Gz-UQ for qemu-devel@nongnu.org; Wed, 01 Aug 2012 08:55:21 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1SwYSD-0007n2-7C for qemu-devel@nongnu.org; Wed, 01 Aug 2012 08:55:15 -0400 Received: from e06smtp10.uk.ibm.com ([195.75.94.106]:33442) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1SwYSC-0007mc-NI for qemu-devel@nongnu.org; Wed, 01 Aug 2012 08:55:09 -0400 Received: from /spool/local by e06smtp10.uk.ibm.com with IBM ESMTP SMTP Gateway: Authorized Use Only! Violators will be prosecuted for from ; Wed, 1 Aug 2012 13:55:07 +0100 Received: from d06nrmr1407.portsmouth.uk.ibm.com (9.149.38.185) by e06smtp10.uk.ibm.com (192.168.101.140) with IBM ESMTP SMTP Gateway: Authorized Use Only! Violators will be prosecuted; Wed, 1 Aug 2012 13:55:06 +0100 Received: from d06av02.portsmouth.uk.ibm.com (d06av02.portsmouth.uk.ibm.com [9.149.37.228]) by d06nrmr1407.portsmouth.uk.ibm.com (8.13.8/8.13.8/NCO v10.0) with ESMTP id q71Ct6rl3084346 for ; Wed, 1 Aug 2012 13:55:06 +0100 Received: from d06av02.portsmouth.uk.ibm.com (loopback [127.0.0.1]) by d06av02.portsmouth.uk.ibm.com (8.14.4/8.13.1/NCO v10.0 AVout) with ESMTP id q71Ct5rO018674 for ; Wed, 1 Aug 2012 06:55:05 -0600 Received: from localhost (sig-9-146-165-117.uk.ibm.com [9.146.165.117]) by d06av02.portsmouth.uk.ibm.com (8.14.4/8.13.1/NCO v10.0 AVin) with ESMTP id q71Ct4RN018663; Wed, 1 Aug 2012 06:55:05 -0600 From: Stefan Hajnoczi To: Anthony Liguori Date: Wed, 1 Aug 2012 13:54:44 +0100 Message-Id: <1343825691-343-13-git-send-email-stefanha@linux.vnet.ibm.com> X-Mailer: git-send-email 1.7.10.4 In-Reply-To: <1343825691-343-1-git-send-email-stefanha@linux.vnet.ibm.com> References: <1343825691-343-1-git-send-email-stefanha@linux.vnet.ibm.com> x-cbid: 12080112-4966-0000-0000-0000031B09B2 X-detected-operating-system: by eggs.gnu.org: Genre and OS details not recognized. X-Received-From: 195.75.94.106 Cc: Zhi Yong Wu , qemu-devel@nongnu.org, Stefan Hajnoczi Subject: [Qemu-devel] [PATCH 12/19] net: Rename vc local variables to nc X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.14 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org Sender: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org Now that VLANClientState has been renamed to NetClientState all 'vc' local variables should be 'nc'. Much of the code already used 'nc' but there are places where 'vc' needs to be renamed. Signed-off-by: Stefan Hajnoczi Signed-off-by: Zhi Yong Wu Reviewed-by: Laszlo Ersek --- hw/ne2000.h | 4 +- hw/vhost_net.c | 18 ++--- net.c | 220 +++++++++++++++++++++++++++---------------------------- net.h | 20 ++--- net/tap-win32.c | 8 +- net/tap.h | 16 ++-- 6 files changed, 143 insertions(+), 143 deletions(-) diff --git a/hw/ne2000.h b/hw/ne2000.h index 6c196a2..1e7ab07 100644 --- a/hw/ne2000.h +++ b/hw/ne2000.h @@ -31,5 +31,5 @@ typedef struct NE2000State { void ne2000_setup_io(NE2000State *s, unsigned size); extern const VMStateDescription vmstate_ne2000; void ne2000_reset(NE2000State *s); -int ne2000_can_receive(NetClientState *vc); -ssize_t ne2000_receive(NetClientState *vc, const uint8_t *buf, size_t size_); +int ne2000_can_receive(NetClientState *nc); +ssize_t ne2000_receive(NetClientState *nc, const uint8_t *buf, size_t size_); diff --git a/hw/vhost_net.c b/hw/vhost_net.c index 85a9a4e..ecaa22d 100644 --- a/hw/vhost_net.c +++ b/hw/vhost_net.c @@ -42,7 +42,7 @@ struct vhost_net { struct vhost_dev dev; struct vhost_virtqueue vqs[2]; int backend; - NetClientState *vc; + NetClientState *nc; }; unsigned vhost_net_get_features(struct vhost_net *net, unsigned features) @@ -104,7 +104,7 @@ struct vhost_net *vhost_net_init(NetClientState *backend, int devfd, if (r < 0) { goto fail; } - net->vc = backend; + net->nc = backend; net->dev.backend_features = tap_has_vnet_hdr(backend) ? 0 : (1 << VHOST_NET_F_VIRTIO_NET_HDR); net->backend = r; @@ -151,7 +151,7 @@ int vhost_net_start(struct vhost_net *net, goto fail_notifiers; } if (net->dev.acked_features & (1 << VIRTIO_NET_F_MRG_RXBUF)) { - tap_set_vnet_hdr_len(net->vc, + tap_set_vnet_hdr_len(net->nc, sizeof(struct virtio_net_hdr_mrg_rxbuf)); } @@ -160,7 +160,7 @@ int vhost_net_start(struct vhost_net *net, goto fail_start; } - net->vc->info->poll(net->vc, false); + net->nc->info->poll(net->nc, false); qemu_set_fd_handler(net->backend, NULL, NULL, NULL); file.fd = net->backend; for (file.index = 0; file.index < net->dev.nvqs; ++file.index) { @@ -177,10 +177,10 @@ fail: int r = ioctl(net->dev.control, VHOST_NET_SET_BACKEND, &file); assert(r >= 0); } - net->vc->info->poll(net->vc, true); + net->nc->info->poll(net->nc, true); vhost_dev_stop(&net->dev, dev); if (net->dev.acked_features & (1 << VIRTIO_NET_F_MRG_RXBUF)) { - tap_set_vnet_hdr_len(net->vc, sizeof(struct virtio_net_hdr)); + tap_set_vnet_hdr_len(net->nc, sizeof(struct virtio_net_hdr)); } fail_start: vhost_dev_disable_notifiers(&net->dev, dev); @@ -197,10 +197,10 @@ void vhost_net_stop(struct vhost_net *net, int r = ioctl(net->dev.control, VHOST_NET_SET_BACKEND, &file); assert(r >= 0); } - net->vc->info->poll(net->vc, true); + net->nc->info->poll(net->nc, true); vhost_dev_stop(&net->dev, dev); if (net->dev.acked_features & (1 << VIRTIO_NET_F_MRG_RXBUF)) { - tap_set_vnet_hdr_len(net->vc, sizeof(struct virtio_net_hdr)); + tap_set_vnet_hdr_len(net->nc, sizeof(struct virtio_net_hdr)); } vhost_dev_disable_notifiers(&net->dev, dev); } @@ -209,7 +209,7 @@ void vhost_net_cleanup(struct vhost_net *net) { vhost_dev_cleanup(&net->dev); if (net->dev.acked_features & (1 << VIRTIO_NET_F_MRG_RXBUF)) { - tap_set_vnet_hdr_len(net->vc, sizeof(struct virtio_net_hdr)); + tap_set_vnet_hdr_len(net->nc, sizeof(struct virtio_net_hdr)); } g_free(net); } diff --git a/net.c b/net.c index 33896fe..8aebf8c 100644 --- a/net.c +++ b/net.c @@ -132,11 +132,11 @@ int parse_host_port(struct sockaddr_in *saddr, const char *str) return 0; } -void qemu_format_nic_info_str(NetClientState *vc, uint8_t macaddr[6]) +void qemu_format_nic_info_str(NetClientState *nc, uint8_t macaddr[6]) { - snprintf(vc->info_str, sizeof(vc->info_str), + snprintf(nc->info_str, sizeof(nc->info_str), "model=%s,macaddr=%02x:%02x:%02x:%02x:%02x:%02x", - vc->model, + nc->model, macaddr[0], macaddr[1], macaddr[2], macaddr[3], macaddr[4], macaddr[5]); } @@ -162,19 +162,19 @@ void qemu_macaddr_default_if_unset(MACAddr *macaddr) * Only net clients created with the legacy -net option need this. Naming is * mandatory for net clients created with -netdev. */ -static char *assign_name(NetClientState *vc1, const char *model) +static char *assign_name(NetClientState *nc1, const char *model) { - NetClientState *vc; + NetClientState *nc; char buf[256]; int id = 0; - QTAILQ_FOREACH(vc, &net_clients, next) { - if (vc == vc1) { + QTAILQ_FOREACH(nc, &net_clients, next) { + if (nc == nc1) { continue; } /* For compatibility only bump id for net clients on a vlan */ - if (strcmp(vc->model, model) == 0 && - net_hub_id_for_client(vc, NULL) == 0) { + if (strcmp(nc->model, model) == 0 && + net_hub_id_for_client(nc, NULL) == 0) { id++; } } @@ -200,32 +200,32 @@ NetClientState *qemu_new_net_client(NetClientInfo *info, const char *model, const char *name) { - NetClientState *vc; + NetClientState *nc; assert(info->size >= sizeof(NetClientState)); - vc = g_malloc0(info->size); + nc = g_malloc0(info->size); - vc->info = info; - vc->model = g_strdup(model); + nc->info = info; + nc->model = g_strdup(model); if (name) { - vc->name = g_strdup(name); + nc->name = g_strdup(name); } else { - vc->name = assign_name(vc, model); + nc->name = assign_name(nc, model); } if (peer) { assert(!peer->peer); - vc->peer = peer; - peer->peer = vc; + nc->peer = peer; + peer->peer = nc; } - QTAILQ_INSERT_TAIL(&net_clients, vc, next); + QTAILQ_INSERT_TAIL(&net_clients, nc, next); - vc->send_queue = qemu_new_net_queue(qemu_deliver_packet, + nc->send_queue = qemu_new_net_queue(qemu_deliver_packet, qemu_deliver_packet_iov, - vc); + nc); - return vc; + return nc; } NICState *qemu_new_nic(NetClientInfo *info, @@ -249,56 +249,56 @@ NICState *qemu_new_nic(NetClientInfo *info, return nic; } -static void qemu_cleanup_vlan_client(NetClientState *vc) +static void qemu_cleanup_vlan_client(NetClientState *nc) { - QTAILQ_REMOVE(&net_clients, vc, next); + QTAILQ_REMOVE(&net_clients, nc, next); - if (vc->info->cleanup) { - vc->info->cleanup(vc); + if (nc->info->cleanup) { + nc->info->cleanup(nc); } } -static void qemu_free_vlan_client(NetClientState *vc) +static void qemu_free_vlan_client(NetClientState *nc) { - if (vc->send_queue) { - qemu_del_net_queue(vc->send_queue); + if (nc->send_queue) { + qemu_del_net_queue(nc->send_queue); } - if (vc->peer) { - vc->peer->peer = NULL; + if (nc->peer) { + nc->peer->peer = NULL; } - g_free(vc->name); - g_free(vc->model); - g_free(vc); + g_free(nc->name); + g_free(nc->model); + g_free(nc); } -void qemu_del_vlan_client(NetClientState *vc) +void qemu_del_vlan_client(NetClientState *nc) { /* If there is a peer NIC, delete and cleanup client, but do not free. */ - if (vc->peer && vc->peer->info->type == NET_CLIENT_OPTIONS_KIND_NIC) { - NICState *nic = DO_UPCAST(NICState, nc, vc->peer); + if (nc->peer && nc->peer->info->type == NET_CLIENT_OPTIONS_KIND_NIC) { + NICState *nic = DO_UPCAST(NICState, nc, nc->peer); if (nic->peer_deleted) { return; } nic->peer_deleted = true; /* Let NIC know peer is gone. */ - vc->peer->link_down = true; - if (vc->peer->info->link_status_changed) { - vc->peer->info->link_status_changed(vc->peer); + nc->peer->link_down = true; + if (nc->peer->info->link_status_changed) { + nc->peer->info->link_status_changed(nc->peer); } - qemu_cleanup_vlan_client(vc); + qemu_cleanup_vlan_client(nc); return; } /* If this is a peer NIC and peer has already been deleted, free it now. */ - if (vc->peer && vc->info->type == NET_CLIENT_OPTIONS_KIND_NIC) { - NICState *nic = DO_UPCAST(NICState, nc, vc); + if (nc->peer && nc->info->type == NET_CLIENT_OPTIONS_KIND_NIC) { + NICState *nic = DO_UPCAST(NICState, nc, nc); if (nic->peer_deleted) { - qemu_free_vlan_client(vc->peer); + qemu_free_vlan_client(nc->peer); } } - qemu_cleanup_vlan_client(vc); - qemu_free_vlan_client(vc); + qemu_cleanup_vlan_client(nc); + qemu_free_vlan_client(nc); } void qemu_foreach_nic(qemu_nic_foreach func, void *opaque) @@ -333,44 +333,44 @@ static ssize_t qemu_deliver_packet(NetClientState *sender, size_t size, void *opaque) { - NetClientState *vc = opaque; + NetClientState *nc = opaque; ssize_t ret; - if (vc->link_down) { + if (nc->link_down) { return size; } - if (vc->receive_disabled) { + if (nc->receive_disabled) { return 0; } - if (flags & QEMU_NET_PACKET_FLAG_RAW && vc->info->receive_raw) { - ret = vc->info->receive_raw(vc, data, size); + if (flags & QEMU_NET_PACKET_FLAG_RAW && nc->info->receive_raw) { + ret = nc->info->receive_raw(nc, data, size); } else { - ret = vc->info->receive(vc, data, size); + ret = nc->info->receive(nc, data, size); } if (ret == 0) { - vc->receive_disabled = 1; + nc->receive_disabled = 1; }; return ret; } -void qemu_purge_queued_packets(NetClientState *vc) +void qemu_purge_queued_packets(NetClientState *nc) { - if (!vc->peer) { + if (!nc->peer) { return; } - qemu_net_queue_purge(vc->peer->send_queue, vc); + qemu_net_queue_purge(nc->peer->send_queue, nc); } -void qemu_flush_queued_packets(NetClientState *vc) +void qemu_flush_queued_packets(NetClientState *nc) { - vc->receive_disabled = 0; + nc->receive_disabled = 0; - qemu_net_queue_flush(vc->send_queue); + qemu_net_queue_flush(nc->send_queue); } static ssize_t qemu_send_packet_async_with_flags(NetClientState *sender, @@ -402,18 +402,18 @@ ssize_t qemu_send_packet_async(NetClientState *sender, buf, size, sent_cb); } -void qemu_send_packet(NetClientState *vc, const uint8_t *buf, int size) +void qemu_send_packet(NetClientState *nc, const uint8_t *buf, int size) { - qemu_send_packet_async(vc, buf, size, NULL); + qemu_send_packet_async(nc, buf, size, NULL); } -ssize_t qemu_send_packet_raw(NetClientState *vc, const uint8_t *buf, int size) +ssize_t qemu_send_packet_raw(NetClientState *nc, const uint8_t *buf, int size) { - return qemu_send_packet_async_with_flags(vc, QEMU_NET_PACKET_FLAG_RAW, + return qemu_send_packet_async_with_flags(nc, QEMU_NET_PACKET_FLAG_RAW, buf, size, NULL); } -static ssize_t vc_sendv_compat(NetClientState *vc, const struct iovec *iov, +static ssize_t nc_sendv_compat(NetClientState *nc, const struct iovec *iov, int iovcnt) { uint8_t buffer[4096]; @@ -421,7 +421,7 @@ static ssize_t vc_sendv_compat(NetClientState *vc, const struct iovec *iov, offset = iov_to_buf(iov, iovcnt, 0, buffer, sizeof(buffer)); - return vc->info->receive(vc, buffer, offset); + return nc->info->receive(nc, buffer, offset); } static ssize_t qemu_deliver_packet_iov(NetClientState *sender, @@ -430,16 +430,16 @@ static ssize_t qemu_deliver_packet_iov(NetClientState *sender, int iovcnt, void *opaque) { - NetClientState *vc = opaque; + NetClientState *nc = opaque; - if (vc->link_down) { + if (nc->link_down) { return iov_size(iov, iovcnt); } - if (vc->info->receive_iov) { - return vc->info->receive_iov(vc, iov, iovcnt); + if (nc->info->receive_iov) { + return nc->info->receive_iov(nc, iov, iovcnt); } else { - return vc_sendv_compat(vc, iov, iovcnt); + return nc_sendv_compat(nc, iov, iovcnt); } } @@ -461,20 +461,20 @@ ssize_t qemu_sendv_packet_async(NetClientState *sender, } ssize_t -qemu_sendv_packet(NetClientState *vc, const struct iovec *iov, int iovcnt) +qemu_sendv_packet(NetClientState *nc, const struct iovec *iov, int iovcnt) { - return qemu_sendv_packet_async(vc, iov, iovcnt, NULL); + return qemu_sendv_packet_async(nc, iov, iovcnt, NULL); } NetClientState *qemu_find_netdev(const char *id) { - NetClientState *vc; + NetClientState *nc; - QTAILQ_FOREACH(vc, &net_clients, next) { - if (vc->info->type == NET_CLIENT_OPTIONS_KIND_NIC) + QTAILQ_FOREACH(nc, &net_clients, next) { + if (nc->info->type == NET_CLIENT_OPTIONS_KIND_NIC) continue; - if (!strcmp(vc->name, id)) { - return vc; + if (!strcmp(nc->name, id)) { + return nc; } } @@ -791,19 +791,19 @@ void net_host_device_add(Monitor *mon, const QDict *qdict) void net_host_device_remove(Monitor *mon, const QDict *qdict) { - NetClientState *vc; + NetClientState *nc; int vlan_id = qdict_get_int(qdict, "vlan_id"); const char *device = qdict_get_str(qdict, "device"); - vc = net_hub_find_client_by_name(vlan_id, device); - if (!vc) { + nc = net_hub_find_client_by_name(vlan_id, device); + if (!nc) { return; } - if (!net_host_check_device(vc->model)) { + if (!net_host_check_device(nc->model)) { monitor_printf(mon, "invalid host network device %s\n", device); return; } - qemu_del_vlan_client(vc); + qemu_del_vlan_client(nc); } void netdev_add(QemuOpts *opts, Error **errp) @@ -843,36 +843,36 @@ exit_err: void qmp_netdev_del(const char *id, Error **errp) { - NetClientState *vc; + NetClientState *nc; - vc = qemu_find_netdev(id); - if (!vc) { + nc = qemu_find_netdev(id); + if (!nc) { error_set(errp, QERR_DEVICE_NOT_FOUND, id); return; } - qemu_del_vlan_client(vc); + qemu_del_vlan_client(nc); qemu_opts_del(qemu_opts_find(qemu_find_opts_err("netdev", errp), id)); } -static void print_net_client(Monitor *mon, NetClientState *vc) +static void print_net_client(Monitor *mon, NetClientState *nc) { - monitor_printf(mon, "%s: type=%s,%s\n", vc->name, - NetClientOptionsKind_lookup[vc->info->type], vc->info_str); + monitor_printf(mon, "%s: type=%s,%s\n", nc->name, + NetClientOptionsKind_lookup[nc->info->type], nc->info_str); } void do_info_network(Monitor *mon) { - NetClientState *vc, *peer; + NetClientState *nc, *peer; NetClientOptionsKind type; monitor_printf(mon, "Devices not on any VLAN:\n"); - QTAILQ_FOREACH(vc, &net_clients, next) { - peer = vc->peer; - type = vc->info->type; + QTAILQ_FOREACH(nc, &net_clients, next) { + peer = nc->peer; + type = nc->info->type; if (!peer || type == NET_CLIENT_OPTIONS_KIND_NIC) { monitor_printf(mon, " "); - print_net_client(mon, vc); + print_net_client(mon, nc); } /* else it's a netdev connected to a NIC, printed with the NIC */ if (peer && type == NET_CLIENT_OPTIONS_KIND_NIC) { monitor_printf(mon, " \\ "); @@ -884,23 +884,23 @@ void do_info_network(Monitor *mon) void qmp_set_link(const char *name, bool up, Error **errp) { - NetClientState *vc = NULL; + NetClientState *nc = NULL; - QTAILQ_FOREACH(vc, &net_clients, next) { - if (!strcmp(vc->name, name)) { + QTAILQ_FOREACH(nc, &net_clients, next) { + if (!strcmp(nc->name, name)) { goto done; } } done: - if (!vc) { + if (!nc) { error_set(errp, QERR_DEVICE_NOT_FOUND, name); return; } - vc->link_down = !up; + nc->link_down = !up; - if (vc->info->link_status_changed) { - vc->info->link_status_changed(vc); + if (nc->info->link_status_changed) { + nc->info->link_status_changed(nc); } /* Notify peer. Don't update peer link status: this makes it possible to @@ -910,23 +910,23 @@ done: * Current behaviour is compatible with qemu vlans where there could be * multiple clients that can still communicate with each other in * disconnected mode. For now maintain this compatibility. */ - if (vc->peer && vc->peer->info->link_status_changed) { - vc->peer->info->link_status_changed(vc->peer); + if (nc->peer && nc->peer->info->link_status_changed) { + nc->peer->info->link_status_changed(nc->peer); } } void net_cleanup(void) { - NetClientState *vc, *next_vc; + NetClientState *nc, *next_vc; - QTAILQ_FOREACH_SAFE(vc, &net_clients, next, next_vc) { - qemu_del_vlan_client(vc); + QTAILQ_FOREACH_SAFE(nc, &net_clients, next, next_vc) { + qemu_del_vlan_client(nc); } } void net_check_clients(void) { - NetClientState *vc; + NetClientState *nc; int i; /* Don't warn about the default network setup that you get if @@ -943,11 +943,11 @@ void net_check_clients(void) net_hub_check_clients(); - QTAILQ_FOREACH(vc, &net_clients, next) { - if (!vc->peer) { + QTAILQ_FOREACH(nc, &net_clients, next) { + if (!nc->peer) { fprintf(stderr, "Warning: %s %s has no peer\n", - vc->info->type == NET_CLIENT_OPTIONS_KIND_NIC ? "nic" : "netdev", - vc->name); + nc->info->type == NET_CLIENT_OPTIONS_KIND_NIC ? + "nic" : "netdev", nc->name); } } diff --git a/net.h b/net.h index 5857e87..d368e24e 100644 --- a/net.h +++ b/net.h @@ -77,23 +77,23 @@ NICState *qemu_new_nic(NetClientInfo *info, const char *model, const char *name, void *opaque); -void qemu_del_vlan_client(NetClientState *vc); +void qemu_del_vlan_client(NetClientState *nc); NetClientState *qemu_find_vlan_client_by_name(Monitor *mon, int vlan_id, const char *client_str); typedef void (*qemu_nic_foreach)(NICState *nic, void *opaque); void qemu_foreach_nic(qemu_nic_foreach func, void *opaque); -int qemu_can_send_packet(NetClientState *vc); -ssize_t qemu_sendv_packet(NetClientState *vc, const struct iovec *iov, +int qemu_can_send_packet(NetClientState *nc); +ssize_t qemu_sendv_packet(NetClientState *nc, const struct iovec *iov, int iovcnt); -ssize_t qemu_sendv_packet_async(NetClientState *vc, const struct iovec *iov, +ssize_t qemu_sendv_packet_async(NetClientState *nc, const struct iovec *iov, int iovcnt, NetPacketSent *sent_cb); -void qemu_send_packet(NetClientState *vc, const uint8_t *buf, int size); -ssize_t qemu_send_packet_raw(NetClientState *vc, const uint8_t *buf, int size); -ssize_t qemu_send_packet_async(NetClientState *vc, const uint8_t *buf, +void qemu_send_packet(NetClientState *nc, const uint8_t *buf, int size); +ssize_t qemu_send_packet_raw(NetClientState *nc, const uint8_t *buf, int size); +ssize_t qemu_send_packet_async(NetClientState *nc, const uint8_t *buf, int size, NetPacketSent *sent_cb); -void qemu_purge_queued_packets(NetClientState *vc); -void qemu_flush_queued_packets(NetClientState *vc); -void qemu_format_nic_info_str(NetClientState *vc, uint8_t macaddr[6]); +void qemu_purge_queued_packets(NetClientState *nc); +void qemu_flush_queued_packets(NetClientState *nc); +void qemu_format_nic_info_str(NetClientState *nc, uint8_t macaddr[6]); void qemu_macaddr_default_if_unset(MACAddr *macaddr); int qemu_show_nic_models(const char *arg, const char *const *models); void qemu_check_nic_model(NICInfo *nd, const char *model); diff --git a/net/tap-win32.c b/net/tap-win32.c index dcc7a64..c0ea954 100644 --- a/net/tap-win32.c +++ b/net/tap-win32.c @@ -719,12 +719,12 @@ int net_init_tap(const NetClientOptions *opts, const char *name, return 0; } -int tap_has_ufo(NetClientState *vc) +int tap_has_ufo(NetClientState *nc) { return 0; } -int tap_has_vnet_hdr(NetClientState *vc) +int tap_has_vnet_hdr(NetClientState *nc) { return 0; } @@ -738,11 +738,11 @@ void tap_fd_set_vnet_hdr_len(int fd, int len) { } -void tap_using_vnet_hdr(NetClientState *vc, int using_vnet_hdr) +void tap_using_vnet_hdr(NetClientState *nc, int using_vnet_hdr) { } -void tap_set_offload(NetClientState *vc, int csum, int tso4, +void tap_set_offload(NetClientState *nc, int csum, int tso4, int tso6, int ecn, int ufo) { } diff --git a/net/tap.h b/net/tap.h index 1257404..0fb018c 100644 --- a/net/tap.h +++ b/net/tap.h @@ -39,12 +39,12 @@ int tap_open(char *ifname, int ifname_size, int *vnet_hdr, int vnet_hdr_required ssize_t tap_read_packet(int tapfd, uint8_t *buf, int maxlen); -int tap_has_ufo(NetClientState *vc); -int tap_has_vnet_hdr(NetClientState *vc); -int tap_has_vnet_hdr_len(NetClientState *vc, int len); -void tap_using_vnet_hdr(NetClientState *vc, int using_vnet_hdr); -void tap_set_offload(NetClientState *vc, int csum, int tso4, int tso6, int ecn, int ufo); -void tap_set_vnet_hdr_len(NetClientState *vc, int len); +int tap_has_ufo(NetClientState *nc); +int tap_has_vnet_hdr(NetClientState *nc); +int tap_has_vnet_hdr_len(NetClientState *nc, int len); +void tap_using_vnet_hdr(NetClientState *nc, int using_vnet_hdr); +void tap_set_offload(NetClientState *nc, int csum, int tso4, int tso6, int ecn, int ufo); +void tap_set_vnet_hdr_len(NetClientState *nc, int len); int tap_set_sndbuf(int fd, const NetdevTapOptions *tap); int tap_probe_vnet_hdr(int fd); @@ -53,10 +53,10 @@ int tap_probe_has_ufo(int fd); void tap_fd_set_offload(int fd, int csum, int tso4, int tso6, int ecn, int ufo); void tap_fd_set_vnet_hdr_len(int fd, int len); -int tap_get_fd(NetClientState *vc); +int tap_get_fd(NetClientState *nc); struct vhost_net; -struct vhost_net *tap_get_vhost_net(NetClientState *vc); +struct vhost_net *tap_get_vhost_net(NetClientState *nc); int net_init_bridge(const NetClientOptions *opts, const char *name, NetClientState *peer);