From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mga09.intel.com (mga09.intel.com [134.134.136.24]) by dpdk.org (Postfix) with ESMTP id A8F2E10DE9 for ; Fri, 23 Dec 2016 08:13:57 +0100 (CET) Received: from orsmga005.jf.intel.com ([10.7.209.41]) by orsmga102.jf.intel.com with ESMTP; 22 Dec 2016 23:13:56 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.33,392,1477983600"; d="scan'208";a="45730692" Received: from dpdk06.sh.intel.com ([10.239.129.195]) by orsmga005.jf.intel.com with ESMTP; 22 Dec 2016 23:13:55 -0800 From: Jianfeng Tan To: dev@dpdk.org Cc: yuanhan.liu@linux.intel.com, ferruh.yigit@intel.com, cunming.liang@intel.com, Jianfeng Tan Date: Fri, 23 Dec 2016 07:14:25 +0000 Message-Id: <1482477266-39199-7-git-send-email-jianfeng.tan@intel.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1482477266-39199-1-git-send-email-jianfeng.tan@intel.com> References: <1480689075-66977-1-git-send-email-jianfeng.tan@intel.com> <1482477266-39199-1-git-send-email-jianfeng.tan@intel.com> Subject: [dpdk-dev] [PATCH v2 6/7] net/virtio_user: enable offloading X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Fri, 23 Dec 2016 07:13:58 -0000 When used with vhost kernel backend, we can offload at both directions. - From vhost kernel to virtio_user, the offload is enabled so that DPDK app can trust the flow is checksum-correct; and if DPDK app sends it through another port, the checksum needs to be recalculated or offloaded. It also applies to TSO. - From virtio_user to vhost_kernel, the offload is enabled so that kernel can trust the flow is L4-checksum-correct, no need to verify it; if kernel will consume it, DPDK app should make sure the l3-checksum is correctly set. Signed-off-by: Jianfeng Tan --- drivers/net/virtio/virtio_user/vhost_kernel.c | 61 ++++++++++++++++++++++++++- 1 file changed, 59 insertions(+), 2 deletions(-) diff --git a/drivers/net/virtio/virtio_user/vhost_kernel.c b/drivers/net/virtio/virtio_user/vhost_kernel.c index 8984c5c..fb3c454 100644 --- a/drivers/net/virtio/virtio_user/vhost_kernel.c +++ b/drivers/net/virtio/virtio_user/vhost_kernel.c @@ -91,6 +91,13 @@ struct vhost_memory_kernel { #define IFF_ATTACH_QUEUE 0x0200 #define IFF_DETACH_QUEUE 0x0400 +/* Features for GSO (TUNSETOFFLOAD). */ +#define TUN_F_CSUM 0x01 /* You can hand me unchecksummed packets. */ +#define TUN_F_TSO4 0x02 /* I can handle TSO for IPv4 packets */ +#define TUN_F_TSO6 0x04 /* I can handle TSO for IPv6 packets */ +#define TUN_F_TSO_ECN 0x08 /* I can handle TSO with ECN bits. */ +#define TUN_F_UFO 0x10 /* I can handle UFO packets */ + /* Constants */ #define TUN_DEF_SNDBUF (1ull << 20) #define PATH_NET_TUN "/dev/net/tun" @@ -173,6 +180,28 @@ prepare_vhost_memory_kernel(void) return vm; } +/* with below features, vhost kernel does not need to do the checksum and TSO, + * these info will be passed to virtio_user through virtio net header. + */ +static const uint64_t guest_offloads_mask = + (1ULL << VIRTIO_NET_F_GUEST_CSUM) | + (1ULL << VIRTIO_NET_F_GUEST_TSO4) | + (1ULL << VIRTIO_NET_F_GUEST_TSO6) | + (1ULL << VIRTIO_NET_F_GUEST_ECN) | + (1ULL << VIRTIO_NET_F_GUEST_UFO); + +/* with below features, when flows from virtio_user to vhost kernel + * (1) if flows goes up through the kernel networking stack, it does not need + * to verify checksum, which can save CPU cycles; + * (2) if flows goes through a Linux bridge and outside from an interface + * (kernel driver), checksum and TSO will be done by GSO in kernel or even + * offloaded into real physical device. + */ +static const uint64_t host_offloads_mask = + (1ULL << VIRTIO_NET_F_CSUM) | + (1ULL << VIRTIO_NET_F_HOST_TSO4) | + (1ULL << VIRTIO_NET_F_HOST_TSO6); + static int vhost_kernel_ioctl(struct virtio_user_dev *dev, enum vhost_user_request req, @@ -191,10 +220,15 @@ vhost_kernel_ioctl(struct virtio_user_dev *dev, arg = (void *)vm; } - /* Does not work when VIRTIO_F_IOMMU_PLATFORM now, why? */ - if (req_kernel == VHOST_SET_FEATURES) + if (req_kernel == VHOST_SET_FEATURES) { + /* Does not work when VIRTIO_F_IOMMU_PLATFORM now, why? */ *(uint64_t *)arg &= ~(1ULL << VIRTIO_F_IOMMU_PLATFORM); + /* VHOST kernel does not know about below flags */ + *(uint64_t *)arg &= ~guest_offloads_mask; + *(uint64_t *)arg &= ~host_offloads_mask; + } + for (i = 0; i < VHOST_KERNEL_MAX_QUEUES; ++i) { if (dev->vhostfds[i] < 0) continue; @@ -204,6 +238,15 @@ vhost_kernel_ioctl(struct virtio_user_dev *dev, break; } + if (!ret && req_kernel == VHOST_GET_FEATURES) { + /* with tap as the backend, all these features are supported + * but not claimed by vhost-net, so we add them back when + * reporting to upper layer. + */ + *((uint64_t *)arg) |= guest_offloads_mask; + *((uint64_t *)arg) |= host_offloads_mask; + } + if (vm) free(vm); @@ -271,6 +314,12 @@ vhost_kernel_enable_queue_pair(struct virtio_user_dev *dev, int hdr_size; int vhostfd; int tapfd; + unsigned int offload = + TUN_F_CSUM | + TUN_F_TSO4 | + TUN_F_TSO6 | + TUN_F_TSO_ECN | + TUN_F_UFO; vhostfd = dev->vhostfds[pair_idx]; @@ -345,6 +394,14 @@ vhost_kernel_enable_queue_pair(struct virtio_user_dev *dev, goto error; } + /* TODO: before set the offload capabilities, we'd better (1) check + * negotiated features to see if necessary to offload; (2) query tap + * to see if it supports the offload capabilities. + */ + if (ioctl(tapfd, TUNSETOFFLOAD, offload) != 0) + PMD_DRV_LOG(ERR, "TUNSETOFFLOAD ioctl() failed: %s", + strerror(errno)); + if (vhost_kernel_set_backend(vhostfd, tapfd) < 0) goto error; -- 2.7.4