Low speed Hyper-V devices support
v3 cover Low speed Hyper-V devices support
Hyper-V is adding multiple low speed "speciality" synthetic devices. Instead of writing a new kernel-level VMBus driver for each device, make the devices accessible to user space through UIO-based uio_hv_generic driver. Each device can then be supported by a user space driver. This approach optimizes the development process and provides flexibility to user space applications to control the key interactions with the VMBus ring buffer.
The new synthetic devices are low speed devices that don't support VMBus monitor bits, and so they must use vmbus_setevent() to notify the host of ring buffer updates. These new devices also have smaller ring buffer sizes which requires to add support for variable ring buffer sizes.
Moreover, this patch series adds a new implementation of the fcopy application that uses the new UIO driver. The older fcopy driver and application will be phased out gradually. Development of other similar userspace drivers is still underway.
Efforts have been made previously to implement this solution earlier.
Here are the discussions related to those attempts:
Attempt 1: Upgrade uio_hv_generic to cater to Hyper-V slow devices. But this was rejected due to use of module parameters.
https://lore.kernel.org/lkml/[email protected]/
Attempt 2: Enable interrupt for low speed VMBus devices in uio_hv_generic and was rejected due to unavailability of userspace driver for it.
https://lore.kernel.org/lkml/[email protected]/
Attempt 3: Wrote a new UIO driver but was rejected due to its complexity.
https://lore.kernel.org/lkml/[email protected]/
[V3]
- Put a check in tools Makefile to avoid compilation of vmbus_bufring library on ARM64 platform.
[V2]
- Went through internal review, got few reviewed-by from Long Li.
- Added more details in cover letter for previous attempts.
- Added more details in commit messages.
- Added comments for preferred ring sizes and there values.
- Removed need_sign arg from vmbus_txbr_write
- Change (4 * 4096) to 0x4000 for ring buffer size.
- Removed some unnecessary type casting.
- Removed rte_smp_rwmb as its duplicate of rte_compiler_barrier.
- Added more comment for rte_compiler_barrierx.
- Mentioned in file copyright header that this code is copied.
- Changed the print from "Registration failed" to "Signal to host failed".
- Fixed mask for rx buffer interrupt to 0 before waiting for interrupt.
Saurabh Sengar (7):
Drivers: hv: vmbus: Add utility function for querying ring size
uio_hv_generic: Query the ringbuffer size for device
uio_hv_generic: Enable interrupt for low speed VMBus devices
tools: hv: Add vmbus_bufring
tools: hv: Add new fcopy application based on uio driver
Drivers: hv: Remove fcopy driver
uio_hv_generic: Remove use of PAGE_SIZE
drivers/hv/Makefile | 2 +- drivers/hv/channel_mgmt.c | 15 +- drivers/hv/hv_fcopy.c | 427 ---------------------------- drivers/hv/hv_util.c | 12 - drivers/hv/hyperv_vmbus.h | 5 + drivers/uio/uio_hv_generic.c | 19 +- include/linux/hyperv.h | 2 + tools/hv/Build | 3 +- tools/hv/Makefile | 14 +- tools/hv/hv_fcopy_daemon.c | 266 ------------------ tools/hv/hv_fcopy_uio_daemon.c | 490 +++++++++++++++++++++++++++++++++ tools/hv/vmbus_bufring.c | 318 +++++++++++++++++++++ tools/hv/vmbus_bufring.h | 158 +++++++++++ 13 files changed, 1006 insertions(+), 725 deletions(-) delete mode 100644 drivers/hv/hv_fcopy.c delete mode 100644 tools/hv/hv_fcopy_daemon.c create mode 100644 tools/hv/hv_fcopy_uio_daemon.c create mode 100644 tools/hv/vmbus_bufring.c create mode 100644 tools/hv/vmbus_bufring.h
Signature · 1 line
2.34.1
PATCH v3 1/7 Drivers: hv: vmbus: Add utility function for querying ring size
Add a function to query for the preferred ring buffer size of VMBus device. This will allow the drivers (eg. UIO) to allocate the most optimized ring buffer size for devices.
---
[V2]
- Added more details in commit message.
- Added comments for preferred ring sizes and there values.
- Added reviewed-by from Long Li.
drivers/hv/channel_mgmt.c | 15 ++++++++++++--- drivers/hv/hyperv_vmbus.h | 5 +++++ include/linux/hyperv.h | 2 ++ 3 files changed, 19 insertions(+), 3 deletions(-)
drivers/hv/channel_mgmt.c +12 -3
@@ -120,7 +120,9 @@ const struct vmbus_device vmbus_devs[] = { },/* File copy */ - { .dev_type = HV_FCOPY, +/* fcopy always uses 16KB ring buffer size and is working well for last many years */ + { .pref_ring_size = 0x4000, + .dev_type =HV_FCOPY ,HV_FCOPY_GUID , .perf_device = false, .allowed_in_isolated = false,
@@ -140,12 +142,19 @@ const struct vmbus_device vmbus_devs[] = { .allowed_in_isolated = false, }, -/* Unknown GUID */ - { .dev_type = HV_UNKNOWN, +/* +* Unknown GUID +* 64 KB ring buffer + 4 KB header should be sufficient size for any Hyper-V device apart +* from HV_NIC and HV_SCSI. This case avoid the fallback for unknown devices to allocate +* much bigger (2 MB) of ring size. +*/ + { .pref_ring_size = 0x11000, + .dev_type = HV_UNKNOWN, .perf_device = false, .allowed_in_isolated = false, }, }; +EXPORT_SYMBOL_GPL (vmbus_devs); static const struct { guid_t guid;
drivers/hv/hyperv_vmbus.h +5 -0
@@ -417,6 +417,11 @@ static inline bool hv_is_perf_channel(struct vmbus_channel *channel)return vmbus_devs[channel->device_id].perf_device; } +static inline size_t hv_dev_ring_size (struct vmbus_channel *channel) +{ +return vmbus_devs[channel->device_id].pref_ring_size; +} +static inline bool hv_is_allocated_cpu (unsigned int cpu) {struct vmbus_channel *channel, *sc;
include/linux/hyperv.h +2 -0
@@ -820,6 +820,8 @@ struct vmbus_requestor {#define VMBUS_RQST_RESET (U64_MAX - 3)struct vmbus_device { +/* preferred ring buffer size in KB, 0 means no preferred size for this device */ +size_t pref_ring_size;u16 dev_type;guid_t guid;bool perf_device;
Signature · 1 line
2.34.1
PATCH v3 2/7 uio_hv_generic: Query the ringbuffer size for device
In reply to Saurabh SengarQuery the ring buffer size from pre defined table per device and use that value for allocating the ring buffer for that device. Keep the size as current default which is 2 MB if the device doesn't have any preferred ring size.
---
[V2]
- Improve commit message.
- Added Reviewed-by from Long Li.
drivers/uio/uio_hv_generic.c | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-)
drivers/uio/uio_hv_generic.c +5 -2
@@ -238,6 +238,7 @@ hv_uio_probe(struct hv_device *dev,struct hv_uio_private_data *pdata;void *ring_buffer;int ret; +size_t ring_size =hv_dev_ring_size (channel);/* Communicating with host has to be via shared memory not hypercall */ if (!channel->offermsg.monitor_allocated) {
@@ -245,12 +246,14 @@ hv_uio_probe(struct hv_device *dev,return -ENOTSUPP ; } +if (!ring_size) + ring_size =HV_RING_SIZE *PAGE_SIZE ; + pdata =devm_kzalloc (&dev->device,sizeof (*pdata),GFP_KERNEL );if (!pdata)return -ENOMEM ; - ret =vmbus_alloc_ring (channel,HV_RING_SIZE *PAGE_SIZE , -HV_RING_SIZE *PAGE_SIZE ); + ret =vmbus_alloc_ring (channel, ring_size, ring_size);if (ret)return ret;
Signature · 1 line
2.34.1
PATCH v3 3/7 uio_hv_generic: Enable interrupt for low speed VMBus devices
In reply to Saurabh SengarHyper-V is adding some "specialty" synthetic devices. Instead of writing new kernel-level VMBus drivers for these devices, the devices will be presented to user space via this existing Hyper-V generic UIO driver, so that a user space driver can handle the device. Since these new synthetic devices are low speed devices, they don't support monitor bits and we must use vmbus_setevent() to enable interrupts from the host.
---
[V2]
- Added Reviewed-by form Long Li
drivers/uio/uio_hv_generic.c | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-)
drivers/uio/uio_hv_generic.c +3 -6
@@ -84,6 +84,9 @@ hv_uio_irqcontrol(struct uio_info *info, s32 irq_state) dev->channel->inbound.ring_buffer->interrupt_mask = !irq_state;virt_mb (); +if (!dev->channel->offermsg.monitor_allocated && irq_state) +vmbus_setevent (dev->channel); +return 0 ; }
@@ -240,12 +243,6 @@ hv_uio_probe(struct hv_device *dev,int ret;size_t ring_size =hv_dev_ring_size (channel); -/* Communicating with host has to be via shared memory not hypercall */ -if (!channel->offermsg.monitor_allocated) { -dev_err (&dev->device,"vmbus channel requires hypercall\n" ); -return -ENOTSUPP ; - } -if (!ring_size) ring_size =HV_RING_SIZE *PAGE_SIZE ;
Signature · 1 line
2.34.1
PATCH v3 4/7 tools: hv: Add vmbus_bufring
In reply to Saurabh SengarCommon userspace interface for read/write from VMBus ringbuffer. This implementation is open for use by any userspace driver or application seeking direct control over VMBus ring buffers. A significant part of this code is borrowed from DPDK.
Currently this library is not supported for ARM64.
---
[V3]
- Added a comment in commit for its supported arch.
[V2]
- Removed need_sign arg from vmbus_txbr_write
- Removed rte_smp_rwmb as its duplicate of rte_compiler_barrier
- Added more comment for rte_compiler_barrierx
- Added Reviewed-by form Long Li
tools/hv/vmbus_bufring.c | 318 +++++++++++++++++++++++++++++++++++++++ tools/hv/vmbus_bufring.h | 158 +++++++++++++++++++ 2 files changed, 476 insertions(+) create mode 100644 tools/hv/vmbus_bufring.c create mode 100644 tools/hv/vmbus_bufring.h
tools/hv/vmbus_bufring.c new file +318 -0
@@ -0,0 +1,318 @@ +// SPDX-License-Identifier: BSD-3-Clause +/* +* Copyright (c) 2009-2012,2016,2023 Microsoft Corp. +* Copyright (c) 2012 NetApp Inc. +* Copyright (c) 2012 Citrix Inc. +* All rights reserved. +*/ + +#include <errno.h> +#include <fcntl.h> +#include <emmintrin.h> +#include <linux/limits.h> +#include <stdbool.h> +#include <stdint.h> +#include <stdio.h> +#include <string.h> +#include <sys/mman.h> +#include <sys/uio.h> +#include <unistd.h> +#include "vmbus_bufring.h" + +/** +* Compiler barrier. +* +* Guarantees that operation reordering does not occur at compile time +* for operations directly before and after the barrier. +*/ +#define rte_compiler_barrier () ({ asm volatile ("" : : : "memory"); }) + +#define VMBUS_RQST_ERROR 0xFFFFFFFFFFFFFFFF +#define ALIGN (val, align) ((typeof(val))((val) & (~((typeof(val))((align) - 1))))) + +void *vmbus_uio_map (int *fd,int size) +{ +void *map; + + map =mmap (NULL ,2 * size,PROT_READ |PROT_WRITE ,MAP_SHARED , *fd,0 ); +if (map ==MAP_FAILED ) +return NULL ; + +return map; +} + +/* Increase bufring index by inc with wraparound */ +static inline uint32_t vmbus_br_idxinc (uint32_t idx,uint32_t inc,uint32_t sz) +{ + idx += inc; +if (idx >= sz) + idx -= sz; + +return idx; +} + +void vmbus_br_setup (struct vmbus_br *br,void *buf,unsigned int blen) +{ + br->vbr = buf; + br->windex = br->vbr->windex; + br->dsize = blen -sizeof (struct vmbus_bufring ); +} + +static inline __always_inline void +rte_smp_mb (void ) +{ + asmvolatile ("lock addl $0, -128(%%rsp); " :::"memory" ); +} + +static inline int +rte_atomic32_cmpset (volatile uint32_t *dst,uint32_t exp,uint32_t src) +{ +uint8_t res; + + asmvolatile ("lock ; " +"cmpxchgl %[src], %[dst];" +"sete %[res];" + : [res]"=a" (res),/* output */ + [dst]"=m" (*dst) + : [src]"r" (src),/* input */ +"a" (exp), +"m" (*dst) + :"memory" );/* no-clobber list */ +return res; +} + +static inline uint32_t +vmbus_txbr_copyto (const struct vmbus_br *tbr,uint32_t windex, +const void *src0,uint32_t cplen) +{ +uint8_t *br_data = tbr->vbr->data; +uint32_t br_dsize = tbr->dsize; +const uint8_t *src = src0; + +/* XXX use double mapping like Linux kernel? */ +if (cplen > br_dsize - windex) { +uint32_t fraglen = br_dsize - windex; + +/* Wrap-around detected */ +memcpy (br_data + windex, src, fraglen); +memcpy (br_data, src + fraglen, cplen - fraglen); + }else { +memcpy (br_data + windex, src, cplen); + } + +return vmbus_br_idxinc (windex, cplen, br_dsize); +} + +/* +* Write scattered channel packet to TX bufring. +* +* The offset of this channel packet is written as a 64bits value +* immediately after this channel packet. +* +* The write goes through three stages: +* 1. Reserve space in ring buffer for the new data. +* Writer atomically moves priv_write_index. +* 2. Copy the new data into the ring. +* 3. Update the tail of the ring (visible to host) that indicates +* next read location. Writer updates write_index +*/ +static int +vmbus_txbr_write (struct vmbus_br *tbr,const struct iovec iov[],int iovlen) +{ +struct vmbus_bufring *vbr = tbr->vbr; +uint32_t ring_size = tbr->dsize; +uint32_t old_windex, next_windex, windex, total; +uint64_t save_windex; +int i; + + total =0 ; +for (i =0 ; i < iovlen; i++) + total += iov[i].iov_len; + total +=sizeof (save_windex); + +/* Reserve space in ring */ +do { +uint32_t avail; + +/* Get current free location */ + old_windex = tbr->windex; + +/* Prevent compiler reordering this with calculation */ +rte_compiler_barrier (); + + avail =vmbus_br_availwrite (tbr, old_windex); + +/* If not enough space in ring, then tell caller. */ +if (avail <= total) +return -EAGAIN ; + + next_windex =vmbus_br_idxinc (old_windex, total, ring_size); + +/* Atomic update of next write_index for other threads */ + }while (!rte_atomic32_cmpset (&tbr->windex, old_windex, next_windex)); + +/* Space from old..new is now reserved */ + windex = old_windex; +for (i =0 ; i < iovlen; i++) + windex =vmbus_txbr_copyto (tbr, windex, iov[i].iov_base, iov[i].iov_len); + +/* Set the offset of the current channel packet. */ + save_windex = ((uint64_t )old_windex) <<32 ; + windex =vmbus_txbr_copyto (tbr, windex, &save_windex, +sizeof (save_windex)); + +/* The region reserved should match region used */ +if (windex != next_windex) +return -EINVAL ; + +/* Ensure that data is available before updating host index */ +rte_compiler_barrier (); + +/* Checkin for our reservation. wait for our turn to update host */ +while (!rte_atomic32_cmpset (&vbr->windex, old_windex, next_windex)) +_mm_pause (); + +return 0 ; +} + +int rte_vmbus_chan_send (struct vmbus_br *txbr,uint16_t type,void *data, +uint32_t dlen,uint32_t flags) +{ +struct vmbus_chanpkt pkt; +unsigned int pktlen, pad_pktlen; +const uint32_t hlen =sizeof (pkt); +uint64_t pad =0 ; +struct iovec iov[3 ]; +int error; + + pktlen = hlen + dlen; + pad_pktlen =ALIGN (pktlen,sizeof (uint64_t )); + + pkt.hdr.type = type; + pkt.hdr.flags = flags; + pkt.hdr.hlen = hlen >>VMBUS_CHANPKT_SIZE_SHIFT ; + pkt.hdr.tlen = pad_pktlen >>VMBUS_CHANPKT_SIZE_SHIFT ; + pkt.hdr.xactid =VMBUS_RQST_ERROR ; + + iov[0 ].iov_base = &pkt; + iov[0 ].iov_len = hlen; + iov[1 ].iov_base = data; + iov[1 ].iov_len = dlen; + iov[2 ].iov_base = &pad; + iov[2 ].iov_len = pad_pktlen - pktlen; + + error =vmbus_txbr_write (txbr, iov,3 ); + +return error; +} + +static inline uint32_t +vmbus_rxbr_copyfrom (const struct vmbus_br *rbr,uint32_t rindex, +void *dst0,size_t cplen) +{ +const uint8_t *br_data = rbr->vbr->data; +uint32_t br_dsize = rbr->dsize; +uint8_t *dst = dst0; + +if (cplen > br_dsize - rindex) { +uint32_t fraglen = br_dsize - rindex; + +/* Wrap-around detected. */ +memcpy (dst, br_data + rindex, fraglen); +memcpy (dst + fraglen, br_data, cplen - fraglen); + }else { +memcpy (dst, br_data + rindex, cplen); + } + +return vmbus_br_idxinc (rindex, cplen, br_dsize); +} + +/* Copy data from receive ring but don't change index */ +static int +vmbus_rxbr_peek (const struct vmbus_br *rbr,void *data,size_t dlen) +{ +uint32_t avail; + +/* +* The requested data and the 64bits channel packet +* offset should be there at least. +*/ + avail =vmbus_br_availread (rbr); +if (avail < dlen +sizeof (uint64_t )) +return -EAGAIN ; + +vmbus_rxbr_copyfrom (rbr, rbr->vbr->rindex, data, dlen); +return 0 ; +} + +/* +* Copy data from receive ring and change index +* NOTE: +* We assume (dlen + skip) == sizeof(channel packet). +*/ +static int +vmbus_rxbr_read (struct vmbus_br *rbr,void *data,size_t dlen,size_t skip) +{ +struct vmbus_bufring *vbr = rbr->vbr; +uint32_t br_dsize = rbr->dsize; +uint32_t rindex; + +if (vmbus_br_availread (rbr) < dlen + skip +sizeof (uint64_t )) +return -EAGAIN ; + +/* Record where host was when we started read (for debug) */ + rbr->windex = rbr->vbr->windex; + +/* +* Copy channel packet from RX bufring. +*/ + rindex =vmbus_br_idxinc (rbr->vbr->rindex, skip, br_dsize); + rindex =vmbus_rxbr_copyfrom (rbr, rindex, data, dlen); + +/* +* Discard this channel packet's 64bits offset, which is useless to us. +*/ + rindex =vmbus_br_idxinc (rindex,sizeof (uint64_t ), br_dsize); + +/* Update the read index _after_ the channel packet is fetched. */ +rte_compiler_barrier (); + + vbr->rindex = rindex; + +return 0 ; +} + +int rte_vmbus_chan_recv_raw (struct vmbus_br *rxbr, +void *data,uint32_t *len) +{ +struct vmbus_chanpkt_hdr pkt; +uint32_t dlen, bufferlen = *len; +int error; + + error =vmbus_rxbr_peek (rxbr, &pkt,sizeof (pkt)); +if (error) +return error; + +if (unlikely (pkt.hlen <VMBUS_CHANPKT_HLEN_MIN )) +/* XXX this channel is dead actually. */ +return -EIO ; + +if (unlikely (pkt.hlen > pkt.tlen)) +return -EIO ; + +/* Length are in quad words */ + dlen = pkt.tlen <<VMBUS_CHANPKT_SIZE_SHIFT ; + *len = dlen; + +/* If caller buffer is not large enough */ +if (unlikely (dlen > bufferlen)) +return -ENOBUFS ; + +/* Read data and skip packet header */ + error =vmbus_rxbr_read (rxbr, data, dlen,0 ); +if (error) +return error; + +/* Return the number of bytes read */ +return dlen +sizeof (uint64_t ); +}
tools/hv/vmbus_bufring.h new file +158 -0
158 lines not on this page · raw message
Signature · 1 line
2.34.1
PATCH v3 5/7 tools: hv: Add new fcopy application based on uio driver
In reply to Saurabh SengarNew fcopy application using uio_hv_generic driver. This application copies file from Hyper-V host to guest VM.
A big part of this code is copied from tools/hv/hv_fcopy_daemon.c which this new application is replacing.
---
[V3]
- Restricted Makefile to x86.
[V2]
- Improve commit message.
- Change (4 * 4096) to 0x4000 for ring buffer size
- Removed some unnecessary type casting.
- Mentioned in file copy right header that this code is copied.
- Changed the print from "Registration failed" to "Signal to host failed".
- Fixed mask for rx buffer interrupt to 0 before waiting for interrupt.
tools/hv/Build | 3 +- tools/hv/Makefile | 14 +- tools/hv/hv_fcopy_uio_daemon.c | 490 +++++++++++++++++++++++++++++++++ 3 files changed, 501 insertions(+), 6 deletions(-) create mode 100644 tools/hv/hv_fcopy_uio_daemon.c
tools/hv/Build +2 -1
@@ -1,3 +1,4 @@ hv_kvp_daemon-y += hv_kvp_daemon.o hv_vss_daemon-y += hv_vss_daemon.o -hv_fcopy_daemon-y += hv_fcopy_daemon.o +hv_fcopy_uio_daemon-y += hv_fcopy_uio_daemon.o +hv_fcopy_uio_daemon-y += vmbus_bufring.o
tools/hv/Makefile +9 -5
@@ -2,6 +2,7 @@ # Makefile for Hyper-V tools include ../scripts/Makefile.include +ARCH := $(shell uname -m 2>/dev/null) sbindir ?= /usr/sbin libexecdir ?= /usr/libexec sharedstatedir ?= /var/lib
@@ -17,7 +18,10 @@ MAKEFLAGS += -r override CFLAGS += -O2 -Wall -g -D_GNU_SOURCE -I$(OUTPUT)include -ALL_TARGETS := hv_kvp_daemon hv_vss_daemon hv_fcopy_daemon +ALL_TARGETS := hv_kvp_daemon hv_vss_daemon +ifneq ($(ARCH), aarch64) +ALL_TARGETS += hv_fcopy_uio_daemon +endif ALL_PROGRAMS := $(patsubst %,$(OUTPUT)%,$(ALL_TARGETS)) ALL_SCRIPTS := hv_get_dhcp_info.sh hv_get_dns_info.sh hv_set_ifconfig.sh
@@ -39,10 +43,10 @@ $(HV_VSS_DAEMON_IN): FORCE $(OUTPUT)hv_vss_daemon: $(HV_VSS_DAEMON_IN) $(QUIET_LINK)$(CC) $(CFLAGS) $(LDFLAGS) $< -o $@ -HV_FCOPY_DAEMON_IN := $(OUTPUT)hv_fcopy_daemon-in.o -$(HV_FCOPY_DAEMON_IN): FORCE - $(Q)$(MAKE) $(build)=hv_fcopy_daemon -$(OUTPUT)hv_fcopy_daemon: $(HV_FCOPY_DAEMON_IN) +HV_FCOPY_UIO_DAEMON_IN := $(OUTPUT)hv_fcopy_uio_daemon-in.o +$(HV_FCOPY_UIO_DAEMON_IN): FORCE + $(Q)$(MAKE) $(build)=hv_fcopy_uio_daemon +$(OUTPUT)hv_fcopy_uio_daemon: $(HV_FCOPY_UIO_DAEMON_IN) $(QUIET_LINK)$(CC) $(CFLAGS) $(LDFLAGS) $< -o $@ clean:
tools/hv/hv_fcopy_uio_daemon.c new file +490 -0
490 lines not on this page · raw message
Signature · 1 line
2.34.1
PATCH v3 6/7 Drivers: hv: Remove fcopy driver
In reply to Saurabh SengarAs the new fcopy driver using uio is introduced, remove obsolete driver and application.
---
[V2]
- Added Reviewed-by form Long Li
drivers/hv/Makefile | 2 +- drivers/hv/hv_fcopy.c | 427 ------------------------------------- drivers/hv/hv_util.c | 12 -- tools/hv/hv_fcopy_daemon.c | 266 ----------------------- 4 files changed, 1 insertion(+), 706 deletions(-) delete mode 100644 drivers/hv/hv_fcopy.c delete mode 100644 tools/hv/hv_fcopy_daemon.c
drivers/hv/Makefile +1 -1
@@ -10,7 +10,7 @@ hv_vmbus-y := vmbus_drv.o \ hv.o connection.o channel.o \ channel_mgmt.o ring_buffer.o hv_trace.o hv_vmbus-$(CONFIG_HYPERV_TESTING) += hv_debugfs.o -hv_utils-y := hv_util.o hv_kvp.o hv_snapshot.o hv_fcopy.o hv_utils_transport.o +hv_utils-y := hv_util.o hv_kvp.o hv_snapshot.o hv_utils_transport.o # Code that must be built-in obj-$(subst m,y,$(CONFIG_HYPERV)) += hv_common.o
drivers/hv/hv_fcopy.c deleted +0 -427
427 lines not on this page · raw message
drivers/hv/hv_util.c +0 -12
@@ -154,14 +154,6 @@ static struct hv_util_service util_vss = { .util_deinit = hv_vss_deinit, }; -static struct hv_util_service util_fcopy = { - .util_cb = hv_fcopy_onchannelcallback, - .util_init = hv_fcopy_init, - .util_pre_suspend = hv_fcopy_pre_suspend, - .util_pre_resume = hv_fcopy_pre_resume, - .util_deinit = hv_fcopy_deinit, -}; -static void perform_shutdown (struct work_struct *dummy) {orderly_poweroff (true);
@@ -700,10 +692,6 @@ static const struct hv_vmbus_device_id id_table[] = { { HV_VSS_GUID, .driver_data = (unsigned long )&util_vss }, - /* File copy GUID */ - { HV_FCOPY_GUID, - .driver_data = (unsigned long )&util_fcopy - }, { }, };
tools/hv/hv_fcopy_daemon.c deleted +0 -266
266 lines not on this page · raw message
Signature · 1 line
2.34.1
PATCH v3 7/7 uio_hv_generic: Remove use of PAGE_SIZE
In reply to Saurabh SengarRemove use of PAGE_SIZE for device ring buffer size calculation, as there is no dependency on device ring buffer size for linux kernel's PAGE_SIZE. Use the absolute value of 2 MB instead.
--- drivers/uio/uio_hv_generic.c | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-)
drivers/uio/uio_hv_generic.c +3 -4
@@ -36,7 +36,6 @@#define DRIVER_AUTHOR "Stephen Hemminger <sthemmin at microsoft.com>"#define DRIVER_DESC "Generic UIO driver for VMBus devices" -#define HV_RING_SIZE 512/* pages */ #define SEND_BUFFER_SIZE (16 * 1024 * 1024)#define RECV_BUFFER_SIZE (31 * 1024 * 1024)
@@ -146,7 +145,7 @@ static const struct bin_attribute ring_buffer_bin_attr = { .name = "ring", .mode = 0600, }, - .size = 2 * HV_RING_SIZE * PAGE_SIZE, + .size = 2 * SZ_2M, .mmap = hv_uio_ring_mmap, };
@@ -156,7 +155,7 @@ hv_uio_new_channel(struct vmbus_channel *new_sc) {struct hv_device *hv_dev = new_sc->primary_channel->device_obj;struct device *device = &hv_dev->device; -const size_t ring_bytes =HV_RING_SIZE *PAGE_SIZE ; +const size_t ring_bytes =SZ_2M ;int ret;/* Create host communication ring */
@@ -244,7 +243,7 @@ hv_uio_probe(struct hv_device *dev,size_t ring_size =hv_dev_ring_size (channel);if (!ring_size) - ring_size =HV_RING_SIZE *PAGE_SIZE ; + ring_size =SZ_2M ; pdata =devm_kzalloc (&dev->device,sizeof (*pdata),GFP_KERNEL );if (!pdata)
Signature · 1 line
2.34.1
RE: [PATCH v3 5/7] tools: hv: Add new fcopy application based on uio driver
In reply to Saurabh SengarQuoted 9 lines
Subject: [PATCH v3 5/7] tools: hv: Add new fcopy application based on uio driver
New fcopy application using
uio_hv_genericdriver. This application copies file from Hyper-V host to guest VM.A big part of this code is copied from
tools/hv/hv_fcopy_daemon.cwhich this new application is replacing.Signed-off-by Saurabh Sengar <[email protected]>
Quoted 11 lines
---
[V3]
- RestrictedMakefileto x86.[V2]
- Improve commit message.
- Change (4 * 4096) to0x4000for ring buffer size
- Removed some unnecessary type casting.
- Mentioned in file copy right header that this code is copied.
- Changed the print from "Registration failed" to "Signal to host failed".
- Fixed mask for rx buffer interrupt to 0 before waiting for interrupt.