Hyper-V: Support PAGE_SIZE larger than 4K
Subsystems (7)
v4 cover Hyper-V: Support PAGE_SIZE larger than 4K
This patchset add the necessary changes to support guests whose page size is larger than 4K. And the main architecture which we develop this for is ARM64 (also it's the architecture that I use to test this feature).
Previous version:
v1: https://lore.kernel.org/lkml/[email protected]/
v2: https://lore.kernel.org/lkml/[email protected]
v3: https://lore.kernel.org/lkml/[email protected]/
Changes since v3:
* Fix a bug that ringbuffer sizes are not page-aligned when
PAGE_SIZE = 16k. Drop the Acked-by and Reviewed-by tags for those patches accordingly.
* Code improvement as per suggestion from Michael Kelley.
I've done some tests with PAGE_SIZE=64k and PAGE_SIZE=16k configurations on ARM64 guests (with Michael's patchset[1] for ARM64 Hyper-V guest support), everything worked fine ;-)
Looking forwards to comments and suggestions!
Regards,
Boqun
[1]: https://lore.kernel.org/lkml/[email protected]/
Boqun Feng (11):
Drivers: hv: vmbus: Always use HV_HYP_PAGE_SIZE for gpadl
Drivers: hv: vmbus: Move __vmbus_open()
Drivers: hv: vmbus: Introduce types of GPADL
Drivers: hv: Use HV_HYP_PAGE in hv_synic_enable_regs()
Drivers: hv: vmbus: Move virt_to_hvpfn() to hyperv header
hv: hyperv.h: Introduce some hvpfn helper functions
hv_netvsc: Use HV_HYP_PAGE_SIZE for Hyper-V communication
Input: hyperv-keyboard: Use VMBUS_RING_SIZE() for ringbuffer sizes
HID: hyperv: Use VMBUS_RING_SIZE() for ringbuffer sizes
Driver: hv: util: Use VMBUS_RING_SIZE() for ringbuffer sizes
scsi: storvsc: Support PAGE_SIZE larger than 4K
drivers/hid/hid-hyperv.c | 4 +- drivers/hv/channel.c | 461 ++++++++++++++++---------- drivers/hv/hv.c | 4 +- drivers/hv/hv_util.c | 11 +- drivers/input/serio/hyperv-keyboard.c | 4 +- drivers/net/hyperv/netvsc.c | 2 +- drivers/net/hyperv/netvsc_drv.c | 46 +-- drivers/net/hyperv/rndis_filter.c | 13 +- drivers/scsi/storvsc_drv.c | 56 +++- include/linux/hyperv.h | 68 +++- 10 files changed, 442 insertions(+), 227 deletions(-)
Signature · 1 line
2.28.0
PATCH v4 1/11 Drivers: hv: vmbus: Always use HV_HYP_PAGE_SIZE for gpadl
Since the hypervisor always uses 4K as its page size, the size of PFNs used for gpadl should be HV_HYP_PAGE_SIZE rather than PAGE_SIZE, so adjust this accordingly as the preparation for supporting 16K/64K page size guests. No functional changes on x86, since PAGE_SIZE is always 4k (equals to HV_HYP_PAGE_SIZE).
--- drivers/hv/channel.c | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-)
drivers/hv/channel.c +5 -8
@@ -22,9 +22,6 @@#include "hyperv_vmbus.h" -#define NUM_PAGES_SPANNED (addr, len) \ -((PAGE_ALIGN(addr + len) >> PAGE_SHIFT) - (addr >> PAGE_SHIFT)) -static unsigned long virt_to_hvpfn (void *addr) {phys_addr_t paddr;
@@ -35,7 +32,7 @@ static unsigned long virt_to_hvpfn(void *addr)else paddr =__pa (addr); -return paddr >>PAGE_SHIFT ; +return paddr >>HV_HYP_PAGE_SHIFT ; }/*
@@ -330,7 +327,7 @@ static int create_gpadl_header(void *kbuffer, u32 size,int pfnsum, pfncount, pfnleft, pfncurr, pfnsize; - pagecount = size >>PAGE_SHIFT ; + pagecount = size >>HV_HYP_PAGE_SHIFT ;/* do we need a gpadl body msg */ pfnsize = MAX_SIZE_CHANNEL_MESSAGE -
@@ -360,7 +357,7 @@ static int create_gpadl_header(void *kbuffer, u32 size, gpadl_header->range[0 ].byte_count = size;for (i =0 ; i < pfncount; i++) gpadl_header->range[0 ].pfn_array[i] =virt_to_hvpfn ( - kbuffer +PAGE_SIZE * i); + kbuffer +HV_HYP_PAGE_SIZE * i); *msginfo = msgheader; pfnsum = pfncount;
@@ -412,7 +409,7 @@ static int create_gpadl_header(void *kbuffer, u32 size,*/ for (i =0 ; i < pfncurr; i++) gpadl_body->pfn[i] =virt_to_hvpfn ( - kbuffer +PAGE_SIZE * (pfnsum + i)); + kbuffer +HV_HYP_PAGE_SIZE * (pfnsum + i));/* add to msg header */ list_add_tail(&msgbody->msglistentry,
@@ -441,7 +438,7 @@ static int create_gpadl_header(void *kbuffer, u32 size, gpadl_header->range[0 ].byte_count = size;for (i =0 ; i < pagecount; i++) gpadl_header->range[0 ].pfn_array[i] =virt_to_hvpfn ( - kbuffer +PAGE_SIZE * i); + kbuffer +HV_HYP_PAGE_SIZE * i); *msginfo = msgheader; }
Signature · 7 lines
2.28.0 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
PATCH v4 2/11 Drivers: hv: vmbus: Move __vmbus_open()
In reply to Boqun FengPure function movement, no functional changes. The move is made, because in a later change, __vmbus_open() will rely on some static functions afterwards, so we separate the move and the modification of __vmbus_open() in two patches to make it easy to review.
--- drivers/hv/channel.c | 309 ++++++++++++++++++++++--------------------- 1 file changed, 155 insertions(+), 154 deletions(-)
drivers/hv/channel.c +155 -154
@@ -109,160 +109,6 @@ int vmbus_alloc_ring(struct vmbus_channel *newchannel, }EXPORT_SYMBOL_GPL (vmbus_alloc_ring); -static int __vmbus_open (struct vmbus_channel *newchannel, -void *userdata,u32 userdatalen, -void (*onchannelcallback)(void *context),void *context) -{ -struct vmbus_channel_open_channel *open_msg; -struct vmbus_channel_msginfo *open_info =NULL ; -struct page *page = newchannel->ringbuffer_page; -u32 send_pages, recv_pages; -unsigned long flags; -int err; - -if (userdatalen >MAX_USER_DEFINED_BYTES ) -return -EINVAL ; - - send_pages = newchannel->ringbuffer_send_offset; - recv_pages = newchannel->ringbuffer_pagecount - send_pages; - -if (newchannel->state !=CHANNEL_OPEN_STATE ) -return -EINVAL ; - - newchannel->state =CHANNEL_OPENING_STATE ; - newchannel->onchannel_callback = onchannelcallback; - newchannel->channel_callback_context = context; - - err =hv_ringbuffer_init (&newchannel->outbound, page, send_pages); -if (err) - goto error_clean_ring; - - err =hv_ringbuffer_init (&newchannel->inbound, - &page[send_pages], recv_pages); -if (err) - goto error_clean_ring; - -/* Establish the gpadl for the ring buffer */ - newchannel->ringbuffer_gpadlhandle =0 ; - - err =vmbus_establish_gpadl (newchannel, -page_address (newchannel->ringbuffer_page), - (send_pages + recv_pages) <<PAGE_SHIFT , - &newchannel->ringbuffer_gpadlhandle); -if (err) - goto error_clean_ring; - -/* Create and init the channel open message */ - open_info =kmalloc (sizeof (*open_info) + -sizeof (struct vmbus_channel_open_channel ), -GFP_KERNEL ); -if (!open_info) { - err = -ENOMEM ; - goto error_free_gpadl; - } - -init_completion (&open_info->waitevent); - open_info->waiting_channel = newchannel; - - open_msg = (struct vmbus_channel_open_channel *)open_info->msg; - open_msg->header.msgtype =CHANNELMSG_OPENCHANNEL ; - open_msg->openid = newchannel->offermsg.child_relid; - open_msg->child_relid = newchannel->offermsg.child_relid; - open_msg->ringbuffer_gpadlhandle = newchannel->ringbuffer_gpadlhandle; - open_msg->downstream_ringbuffer_pageoffset = newchannel->ringbuffer_send_offset; - open_msg->target_vp =hv_cpu_number_to_vp_number (newchannel->target_cpu); - -if (userdatalen) -memcpy (open_msg->userdata, userdata, userdatalen); - -spin_lock_irqsave (&vmbus_connection.channelmsg_lock, flags); -list_add_tail (&open_info->msglistentry, - &vmbus_connection.chn_msg_list); -spin_unlock_irqrestore (&vmbus_connection.channelmsg_lock, flags); - -if (newchannel->rescind) { - err = -ENODEV ; - goto error_free_info; - } - - err =vmbus_post_msg (open_msg, -sizeof (struct vmbus_channel_open_channel ), true); - -trace_vmbus_open (open_msg, err); - -if (err !=0 ) - goto error_clean_msglist; - -wait_for_completion (&open_info->waitevent); - -spin_lock_irqsave (&vmbus_connection.channelmsg_lock, flags); -list_del (&open_info->msglistentry); -spin_unlock_irqrestore (&vmbus_connection.channelmsg_lock, flags); - -if (newchannel->rescind) { - err = -ENODEV ; - goto error_free_info; - } - -if (open_info->response.open_result.status) { - err = -EAGAIN ; - goto error_free_info; - } - - newchannel->state =CHANNEL_OPENED_STATE ; -kfree (open_info); -return 0 ; - -error_clean_msglist: -spin_lock_irqsave (&vmbus_connection.channelmsg_lock, flags); -list_del (&open_info->msglistentry); -spin_unlock_irqrestore (&vmbus_connection.channelmsg_lock, flags); -error_free_info: -kfree (open_info); -error_free_gpadl: -vmbus_teardown_gpadl (newchannel, newchannel->ringbuffer_gpadlhandle); - newchannel->ringbuffer_gpadlhandle =0 ; -error_clean_ring: -hv_ringbuffer_cleanup (&newchannel->outbound); -hv_ringbuffer_cleanup (&newchannel->inbound); - newchannel->state =CHANNEL_OPEN_STATE ; -return err; -} - -/* -* vmbus_connect_ring - Open the channel but reuse ring buffer -*/ -int vmbus_connect_ring (struct vmbus_channel *newchannel, -void (*onchannelcallback)(void *context),void *context) -{ -return __vmbus_open (newchannel,NULL ,0 , onchannelcallback, context); -} -EXPORT_SYMBOL_GPL (vmbus_connect_ring); - -/* -* vmbus_open - Open the specified channel. -*/ -int vmbus_open (struct vmbus_channel *newchannel, -u32 send_ringbuffer_size,u32 recv_ringbuffer_size, -void *userdata,u32 userdatalen, -void (*onchannelcallback)(void *context),void *context) -{ -int err; - - err =vmbus_alloc_ring (newchannel, send_ringbuffer_size, - recv_ringbuffer_size); -if (err) -return err; - - err =__vmbus_open (newchannel, userdata, userdatalen, - onchannelcallback, context); -if (err) -vmbus_free_ring (newchannel); - -return err; -} -EXPORT_SYMBOL_GPL (vmbus_open); -/* Used for Hyper-V Socket: a guest client's connect() to the host */ int vmbus_send_tl_connect_request (const guid_t *shv_guest_servie_id,const guid_t *shv_host_servie_id)
@@ -556,6 +402,161 @@ int vmbus_establish_gpadl(struct vmbus_channel *channel, void *kbuffer, }EXPORT_SYMBOL_GPL (vmbus_establish_gpadl); +static int __vmbus_open (struct vmbus_channel *newchannel, +void *userdata,u32 userdatalen, +void (*onchannelcallback)(void *context),void *context) +{ +struct vmbus_channel_open_channel *open_msg; +struct vmbus_channel_msginfo *open_info =NULL ; +struct page *page = newchannel->ringbuffer_page; +u32 send_pages, recv_pages; +unsigned long flags; +int err; + +if (userdatalen >MAX_USER_DEFINED_BYTES ) +return -EINVAL ; + + send_pages = newchannel->ringbuffer_send_offset; + recv_pages = newchannel->ringbuffer_pagecount - send_pages; + +if (newchannel->state !=CHANNEL_OPEN_STATE ) +return -EINVAL ; + + newchannel->state =CHANNEL_OPENING_STATE ; + newchannel->onchannel_callback = onchannelcallback; + newchannel->channel_callback_context = context; + + err =hv_ringbuffer_init (&newchannel->outbound, page, send_pages); +if (err) + goto error_clean_ring; + + err =hv_ringbuffer_init (&newchannel->inbound, + &page[send_pages], recv_pages); +if (err) + goto error_clean_ring; + +/* Establish the gpadl for the ring buffer */ + newchannel->ringbuffer_gpadlhandle =0 ; + + err =vmbus_establish_gpadl (newchannel, +page_address (newchannel->ringbuffer_page), + (send_pages + recv_pages) <<PAGE_SHIFT , + &newchannel->ringbuffer_gpadlhandle); +if (err) + goto error_clean_ring; + +/* Create and init the channel open message */ + open_info =kmalloc (sizeof (*open_info) + +sizeof (struct vmbus_channel_open_channel ), +GFP_KERNEL ); +if (!open_info) { + err = -ENOMEM ; + goto error_free_gpadl; + } + +init_completion (&open_info->waitevent); + open_info->waiting_channel = newchannel; + + open_msg = (struct vmbus_channel_open_channel *)open_info->msg; + open_msg->header.msgtype =CHANNELMSG_OPENCHANNEL ; + open_msg->openid = newchannel->offermsg.child_relid; + open_msg->child_relid = newchannel->offermsg.child_relid; + open_msg->ringbuffer_gpadlhandle = newchannel->ringbuffer_gpadlhandle; + open_msg->downstream_ringbuffer_pageoffset = newchannel->ringbuffer_send_offset; + open_msg->target_vp =hv_cpu_number_to_vp_number (newchannel->target_cpu); + +if (userdatalen) +memcpy (open_msg->userdata, userdata, userdatalen); + +spin_lock_irqsave (&vmbus_connection.channelmsg_lock, flags); +list_add_tail (&open_info->msglistentry, + &vmbus_connection.chn_msg_list); +spin_unlock_irqrestore (&vmbus_connection.channelmsg_lock, flags); + +if (newchannel->rescind) { + err = -ENODEV ; + goto error_free_info; + } + + err =vmbus_post_msg (open_msg, +sizeof (struct vmbus_channel_open_channel ), true); + +trace_vmbus_open (open_msg, err); + +if (err !=0 ) + goto error_clean_msglist; + +wait_for_completion (&open_info->waitevent); + +spin_lock_irqsave (&vmbus_connection.channelmsg_lock, flags); +list_del (&open_info->msglistentry); +spin_unlock_irqrestore (&vmbus_connection.channelmsg_lock, flags); + +if (newchannel->rescind) { + err = -ENODEV ; + goto error_free_info; + } + +if (open_info->response.open_result.status) { + err = -EAGAIN ; + goto error_free_info; + } + + newchannel->state =CHANNEL_OPENED_STATE ; +kfree (open_info); +return 0 ; + +error_clean_msglist: +spin_lock_irqsave (&vmbus_connection.channelmsg_lock, flags); +list_del (&open_info->msglistentry); +spin_unlock_irqrestore (&vmbus_connection.channelmsg_lock, flags); +error_free_info: +kfree (open_info); +error_free_gpadl: +vmbus_teardown_gpadl (newchannel, newchannel->ringbuffer_gpadlhandle); + newchannel->ringbuffer_gpadlhandle =0 ; +error_clean_ring: +hv_ringbuffer_cleanup (&newchannel->outbound); +hv_ringbuffer_cleanup (&newchannel->inbound); + newchannel->state =CHANNEL_OPEN_STATE ; +return err; +} + +/* +* vmbus_connect_ring - Open the channel but reuse ring buffer +*/ +int vmbus_connect_ring (struct vmbus_channel *newchannel, +void (*onchannelcallback)(void *context),void *context) +{ +return __vmbus_open (newchannel,NULL ,0 , onchannelcallback, context); +} +EXPORT_SYMBOL_GPL (vmbus_connect_ring); + +/* +* vmbus_open - Open the specified channel. +*/ +int vmbus_open (struct vmbus_channel *newchannel, +u32 send_ringbuffer_size,u32 recv_ringbuffer_size, +void *userdata,u32 userdatalen, +void (*onchannelcallback)(void *context),void *context) +{ +int err; + + err =vmbus_alloc_ring (newchannel, send_ringbuffer_size, + recv_ringbuffer_size); +if (err) +return err; + + err =__vmbus_open (newchannel, userdata, userdatalen, + onchannelcallback, context); +if (err) +vmbus_free_ring (newchannel); + +return err; +} +EXPORT_SYMBOL_GPL (vmbus_open); + +/* * vmbus_teardown_gpadl -Teardown the specified GPADL handle */
Signature · 1 line
2.28.0
PATCH v4 3/11 Drivers: hv: vmbus: Introduce types of GPADL
In reply to Boqun FengThis patch introduces two types of GPADL: HV_GPADL_{BUFFER, RING}. The types of GPADL are purely the concept in the guest, IOW the hypervisor treat them as the same.
The reason of introducing the types for GPADL is to support guests whose page size is not 4k (the page size of Hyper-V hypervisor). In these guests, both the headers and the data parts of the ringbuffers need to be aligned to the PAGE_SIZE, because 1) some of the ringbuffers will be mapped into userspace and 2) we use "double mapping" mechanism to support fast wrap-around, and "double mapping" relies on ringbuffers being page-aligned. However, the Hyper-V hypervisor only uses 4k (HV_HYP_PAGE_SIZE) headers. Our solution to this is that we always make the headers of ringbuffers take one guest page and when GPADL is established between the guest and hypervisor, the only first 4k of header is used. To handle this special case, we need the types of GPADL to differ different guest memory usage for GPADL.
Type enum is introduced along with several general interfaces to describe the differences between normal buffer GPADL and ringbuffer GPADL.
--- drivers/hv/channel.c | 160 +++++++++++++++++++++++++++++++++++------ include/linux/hyperv.h | 48 ++++++++++++- 2 files changed, 187 insertions(+), 21 deletions(-)
drivers/hv/channel.c +140 -20
@@ -35,6 +35,99 @@ static unsigned long virt_to_hvpfn(void *addr)return paddr >>HV_HYP_PAGE_SHIFT ; } +/* +* hv_gpadl_size - Return the real size of a gpadl, the size that Hyper-V uses +* +* For BUFFER gpadl, Hyper-V uses the exact same size as the guest does. +* +* For RING gpadl, in each ring, the guest uses one PAGE_SIZE as the header +* (because of the alignment requirement), however, the hypervisor only +* uses the first HV_HYP_PAGE_SIZE as the header, therefore leaving a +* (PAGE_SIZE - HV_HYP_PAGE_SIZE) gap. And since there are two rings in a +* ringbuffer, the total size for a RING gpadl that Hyper-V uses is the +* total size that the guest uses minus twice of the gap size. +*/ +static inline u32 hv_gpadl_size (enum hv_gpadl_type type,u32 size) +{ +switch (type) { +case HV_GPADL_BUFFER : +return size; +case HV_GPADL_RING : +/* The size of a ringbuffer must be page-aligned */ +BUG_ON (size %PAGE_SIZE ); +/* +* Two things to notice here: +* 1) We're processing two ring buffers as a unit +* 2) We're skipping any space larger than HV_HYP_PAGE_SIZE in +* the first guest-size page of each of the two ring buffers. +* So we effectively subtract out two guest-size pages, and add +* back two Hyper-V size pages. +*/ +return size -2 * (PAGE_SIZE -HV_HYP_PAGE_SIZE ); + } +BUG (); +return 0 ; +} + +/* +* hv_ring_gpadl_send_hvpgoffset - Calculate the send offset (in unit of +* HV_HYP_PAGE) in a ring gpadl based on the +* offset in the guest +* +* @offset: the offset (in bytes) where the send ringbuffer starts in the +* virtual address space of the guest +*/ +static inline u32 hv_ring_gpadl_send_hvpgoffset (u32 offset) +{ + +/* +* For RING gpadl, in each ring, the guest uses one PAGE_SIZE as the +* header (because of the alignment requirement), however, the +* hypervisor only uses the first HV_HYP_PAGE_SIZE as the header, +* therefore leaving a (PAGE_SIZE - HV_HYP_PAGE_SIZE) gap. +* +* And to calculate the effective send offset in gpadl, we need to +* substract this gap. +*/ +return (offset - (PAGE_SIZE -HV_HYP_PAGE_SIZE )) >>HV_HYP_PAGE_SHIFT ; +} + +/* +* hv_gpadl_hvpfn - Return the Hyper-V page PFN of the @i th Hyper-V page in +* the gpadl +* +* @type: the type of the gpadl +* @kbuffer: the pointer to the gpadl in the guest +* @size: the total size (in bytes) of the gpadl +* @send_offset: the offset (in bytes) where the send ringbuffer starts in the +* virtual address space of the guest +* @i: the index +*/ +static inline u64 hv_gpadl_hvpfn (enum hv_gpadl_type type,void *kbuffer, +u32 size,u32 send_offset,int i) +{ +int send_idx =hv_ring_gpadl_send_hvpgoffset (send_offset); +unsigned long delta =0UL ; + +switch (type) { +case HV_GPADL_BUFFER : +break ; +case HV_GPADL_RING : +if (i ==0 ) + delta =0 ; +else if (i <= send_idx) + delta =PAGE_SIZE -HV_HYP_PAGE_SIZE ; +else + delta =2 * (PAGE_SIZE -HV_HYP_PAGE_SIZE ); +break ; +default : +BUG (); +break ; + } + +return virt_to_hvpfn (kbuffer + delta + (HV_HYP_PAGE_SIZE * i)); +} +/* * vmbus_setevent- Trigger an event notification on the specified * channel.
@@ -160,7 +253,8 @@ EXPORT_SYMBOL_GPL(vmbus_send_modifychannel);/* * create_gpadl_header - Creates a gpadl for the specified buffer */ -static int create_gpadl_header (void *kbuffer,u32 size, +static int create_gpadl_header (enum hv_gpadl_type type,void *kbuffer, +u32 size,u32 send_offset,struct vmbus_channel_msginfo **msginfo) {int i;
@@ -173,7 +267,7 @@ static int create_gpadl_header(void *kbuffer, u32 size,int pfnsum, pfncount, pfnleft, pfncurr, pfnsize; - pagecount = size >>HV_HYP_PAGE_SHIFT ; + pagecount =hv_gpadl_size (type, size) >>HV_HYP_PAGE_SHIFT ;/* do we need a gpadl body msg */ pfnsize = MAX_SIZE_CHANNEL_MESSAGE -
@@ -200,10 +294,10 @@ static int create_gpadl_header(void *kbuffer, u32 size, gpadl_header->range_buflen =sizeof (struct gpa_range ) + pagecount *sizeof (u64); gpadl_header->range[0 ].byte_offset =0 ; - gpadl_header->range[0 ].byte_count = size; + gpadl_header->range[0 ].byte_count =hv_gpadl_size (type, size);for (i =0 ; i < pfncount; i++) - gpadl_header->range[0 ].pfn_array[i] =virt_to_hvpfn ( - kbuffer +HV_HYP_PAGE_SIZE * i); + gpadl_header->range[0 ].pfn_array[i] =hv_gpadl_hvpfn ( + type, kbuffer, size, send_offset, i); *msginfo = msgheader; pfnsum = pfncount;
@@ -254,8 +348,8 @@ static int create_gpadl_header(void *kbuffer, u32 size,* so the hypervisor guarantees that this is ok. */ for (i =0 ; i < pfncurr; i++) - gpadl_body->pfn[i] =virt_to_hvpfn ( - kbuffer +HV_HYP_PAGE_SIZE * (pfnsum + i)); + gpadl_body->pfn[i] =hv_gpadl_hvpfn (type, + kbuffer, size, send_offset, pfnsum + i);/* add to msg header */ list_add_tail(&msgbody->msglistentry,
@@ -281,10 +375,10 @@ static int create_gpadl_header(void *kbuffer, u32 size, gpadl_header->range_buflen =sizeof (struct gpa_range ) + pagecount *sizeof (u64); gpadl_header->range[0 ].byte_offset =0 ; - gpadl_header->range[0 ].byte_count = size; + gpadl_header->range[0 ].byte_count =hv_gpadl_size (type, size);for (i =0 ; i < pagecount; i++) - gpadl_header->range[0 ].pfn_array[i] =virt_to_hvpfn ( - kbuffer +HV_HYP_PAGE_SIZE * i); + gpadl_header->range[0 ].pfn_array[i] =hv_gpadl_hvpfn ( + type, kbuffer, size, send_offset, i); *msginfo = msgheader; }
@@ -297,15 +391,20 @@ static int create_gpadl_header(void *kbuffer, u32 size, }/* -* vmbus_establish_gpadl - Establish a GPADL for the specified buffer +* __vmbus_establish_gpadl - Establish a GPADL for a buffer or ringbuffer * * @channel: a channel +* @type: the type of the corresponding GPADL, only meaningful for the guest. * @kbuffer: from kmalloc or vmalloc * @size: page-size multiple +* @send_offset: the offset (in bytes) where the send ring buffer starts, +* should be 0 for BUFFER type gpadl * @gpadl_handle: some funky thing */ -int vmbus_establish_gpadl (struct vmbus_channel *channel,void *kbuffer, -u32 size,u32 *gpadl_handle) +static int __vmbus_establish_gpadl (struct vmbus_channel *channel, +enum hv_gpadl_type type,void *kbuffer, +u32 size,u32 send_offset, +u32 *gpadl_handle) {struct vmbus_channel_gpadl_header *gpadlmsg;struct vmbus_channel_gpadl_body *gpadl_body;
@@ -319,7 +418,7 @@ int vmbus_establish_gpadl(struct vmbus_channel *channel, void *kbuffer, next_gpadl_handle = (atomic_inc_return (&vmbus_connection.next_gpadl_handle) -1 ); - ret =create_gpadl_header (kbuffer, size, &msginfo); + ret =create_gpadl_header (type, kbuffer, size, send_offset, &msginfo);if (ret)return ret;
@@ -400,6 +499,21 @@ int vmbus_establish_gpadl(struct vmbus_channel *channel, void *kbuffer,kfree (msginfo);return ret; } + +/* +* vmbus_establish_gpadl - Establish a GPADL for the specified buffer +* +* @channel: a channel +* @kbuffer: from kmalloc or vmalloc +* @size: page-size multiple +* @gpadl_handle: some funky thing +*/ +int vmbus_establish_gpadl (struct vmbus_channel *channel,void *kbuffer, +u32 size,u32 *gpadl_handle) +{ +return __vmbus_establish_gpadl (channel,HV_GPADL_BUFFER , kbuffer, size, +0U , gpadl_handle); +}EXPORT_SYMBOL_GPL (vmbus_establish_gpadl); static int __vmbus_open(struct vmbus_channel *newchannel,
@@ -438,10 +552,11 @@ static int __vmbus_open(struct vmbus_channel *newchannel,/* Establish the gpadl for the ring buffer */ newchannel->ringbuffer_gpadlhandle =0 ; - err =vmbus_establish_gpadl (newchannel, -page_address (newchannel->ringbuffer_page), - (send_pages + recv_pages) <<PAGE_SHIFT , - &newchannel->ringbuffer_gpadlhandle); + err =__vmbus_establish_gpadl (newchannel,HV_GPADL_RING , +page_address (newchannel->ringbuffer_page), + (send_pages + recv_pages) <<PAGE_SHIFT , + newchannel->ringbuffer_send_offset <<PAGE_SHIFT , + &newchannel->ringbuffer_gpadlhandle);if (err) goto error_clean_ring;
@@ -462,7 +577,13 @@ static int __vmbus_open(struct vmbus_channel *newchannel, open_msg->openid = newchannel->offermsg.child_relid; open_msg->child_relid = newchannel->offermsg.child_relid; open_msg->ringbuffer_gpadlhandle = newchannel->ringbuffer_gpadlhandle; - open_msg->downstream_ringbuffer_pageoffset = newchannel->ringbuffer_send_offset; +/* +* The unit of ->downstream_ringbuffer_pageoffset is HV_HYP_PAGE and +* the unit of ->ringbuffer_send_offset (i.e. send_pages) is PAGE, so +* here we calculate it into HV_HYP_PAGE. +*/ + open_msg->downstream_ringbuffer_pageoffset = +hv_ring_gpadl_send_hvpgoffset (send_pages <<PAGE_SHIFT ); open_msg->target_vp =hv_cpu_number_to_vp_number (newchannel->target_cpu);if (userdatalen)
@@ -556,7 +677,6 @@ int vmbus_open(struct vmbus_channel *newchannel, }EXPORT_SYMBOL_GPL (vmbus_open); -/* * vmbus_teardown_gpadl -Teardown the specified GPADL handle */
include/linux/hyperv.h +47 -1
66 lines not on this page · raw message
Signature · 1 line
2.28.0
PATCH v4 4/11 Drivers: hv: Use HV_HYP_PAGE in hv_synic_enable_regs()
In reply to Boqun FengBoth the base_*_gpa should use the guest page number in Hyper-V page, so use HV_HYP_PAGE instead of PAGE.
--- drivers/hv/hv.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/hv/hv.c +2 -2
@@ -165,7 +165,7 @@ void hv_synic_enable_regs(unsigned int cpu)hv_get_simp (simp.as_uint64); simp.simp_enabled =1 ; simp.base_simp_gpa =virt_to_phys (hv_cpu->synic_message_page) - >>PAGE_SHIFT ; + >>HV_HYP_PAGE_SHIFT ;hv_set_simp (simp.as_uint64);
@@ -173,7 +173,7 @@ void hv_synic_enable_regs(unsigned int cpu)hv_get_siefp (siefp.as_uint64); siefp.siefp_enabled =1 ; siefp.base_siefp_gpa =virt_to_phys (hv_cpu->synic_event_page) - >>PAGE_SHIFT ; + >>HV_HYP_PAGE_SHIFT ;hv_set_siefp (siefp.as_uint64);
Signature · 1 line
2.28.0
PATCH v4 5/11 Drivers: hv: vmbus: Move virt_to_hvpfn() to hyperv header
In reply to Boqun FengThere will be more places other than vmbus where we need to calculate the Hyper-V page PFN from a virtual address, so move virt_to_hvpfn() to hyperv generic header.
--- drivers/hv/channel.c | 13 ------------- include/linux/hyperv.h | 15 +++++++++++++++ 2 files changed, 15 insertions(+), 13 deletions(-)
drivers/hv/channel.c +0 -13
@@ -22,19 +22,6 @@#include "hyperv_vmbus.h" -static unsigned long virt_to_hvpfn (void *addr) -{ -phys_addr_t paddr; - -if (is_vmalloc_addr (addr)) - paddr =page_to_phys (vmalloc_to_page (addr)) + -offset_in_page (addr); -else - paddr =__pa (addr); - -return paddr >>HV_HYP_PAGE_SHIFT ; -} -/* * hv_gpadl_size - Return the real size of a gpadl, the size that Hyper-V uses *
include/linux/hyperv.h +15 -0
@@ -14,6 +14,7 @@#include <uapi/linux/hyperv.h> +#include <linux/mm.h> #include <linux/types.h> #include <linux/scatterlist.h> #include <linux/list.h>
@@ -23,6 +24,7 @@#include <linux/mod_devicetable.h> #include <linux/interrupt.h> #include <linux/reciprocal_div.h> +#include <asm/hyperv-tlfs.h> #define MAX_PAGE_BUFFER_COUNT 32#define MAX_MULTIPAGE_BUFFER_COUNT 32/* 128K */
@@ -1676,4 +1678,17 @@ struct hyperv_pci_block_ops {extern struct hyperv_pci_block_ops hvpci_block_ops; +static inline unsigned long virt_to_hvpfn (void *addr) +{ +phys_addr_t paddr; + +if (is_vmalloc_addr (addr)) + paddr =page_to_phys (vmalloc_to_page (addr)) + +offset_in_page (addr); +else + paddr =__pa (addr); + +return paddr >>HV_HYP_PAGE_SHIFT ; +} +#endif /* _HYPERV_H */
Signature · 7 lines
2.28.0 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
PATCH v4 6/11 hv: hyperv.h: Introduce some hvpfn helper functions
In reply to Boqun FengWhen a guest communicate with the hypervisor, it must use HV_HYP_PAGE to calculate PFN, so introduce a few hvpfn helper functions as the counterpart of the page helper functions. This is the preparation for supporting guest whose PAGE_SIZE is not 4k.
--- include/linux/hyperv.h | 5 +++++ 1 file changed, 5 insertions(+)
include/linux/hyperv.h +5 -0
@@ -1691,4 +1691,9 @@ static inline unsigned long virt_to_hvpfn(void *addr) return paddr >> HV_HYP_PAGE_SHIFT; } +#define NR_HV_HYP_PAGES_IN_PAGE (PAGE_SIZE / HV_HYP_PAGE_SIZE) +#define offset_in_hvpage (ptr) ((unsigned long)(ptr) & ~HV_HYP_PAGE_MASK) +#define HVPFN_UP (x) (((x) + HV_HYP_PAGE_SIZE-1) >> HV_HYP_PAGE_SHIFT) +#define page_to_hvpfn (page) (page_to_pfn(page) * NR_HV_HYP_PAGES_IN_PAGE) +#endif /* _HYPERV_H */
Signature · 7 lines
2.28.0 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
PATCH v4 7/11 hv_netvsc: Use HV_HYP_PAGE_SIZE for Hyper-V communication
In reply to Boqun FengWhen communicating with Hyper-V, HV_HYP_PAGE_SIZE should be used since that's the page size used by Hyper-V and Hyper-V expects all page-related data using the unit of HY_HYP_PAGE_SIZE, for example, the "pfn" in hv_page_buffer is actually the HV_HYP_PAGE (i.e. the Hyper-V page) number.
In order to support guest whose page size is not 4k, we need to make hv_netvsc always use HV_HYP_PAGE_SIZE for Hyper-V communication.
--- drivers/net/hyperv/netvsc.c | 2 +- drivers/net/hyperv/netvsc_drv.c | 46 +++++++++++++++---------------- drivers/net/hyperv/rndis_filter.c | 13 ++++----- 3 files changed, 30 insertions(+), 31 deletions(-)
drivers/net/hyperv/netvsc.c +1 -1
@@ -794,7 +794,7 @@ static void netvsc_copy_to_send_buf(struct netvsc_device *net_device, }for (i =0 ; i < page_count; i++) { -char *src =phys_to_virt (pb[i].pfn <<PAGE_SHIFT ); +char *src =phys_to_virt (pb[i].pfn <<HV_HYP_PAGE_SHIFT );u32 offset = pb[i].offset;u32 len = pb[i].len;
drivers/net/hyperv/netvsc_drv.c +23 -23
98 lines not on this page · raw message
drivers/net/hyperv/rndis_filter.c +6 -7
@@ -25,7 +25,7 @@static void rndis_set_multicast (struct work_struct *w); -#define RNDIS_EXT_LEN PAGE_SIZE +#define RNDIS_EXT_LEN HV_HYP_PAGE_SIZEstruct rndis_request {struct list_head list_ent;struct completion wait_event;
@@ -215,18 +215,17 @@ static int rndis_filter_send_request(struct rndis_device *dev, packet->page_buf_cnt =1 ; pb[0 ].pfn =virt_to_phys (&req->request_msg) >> -PAGE_SHIFT ; +HV_HYP_PAGE_SHIFT ; pb[0 ].len = req->request_msg.msg_len; - pb[0 ].offset = - (unsigned long )&req->request_msg & (PAGE_SIZE -1 ); + pb[0 ].offset =offset_in_hvpage (&req->request_msg);/* Add one page_buf when request_msg crossing page boundary */ -if (pb[0 ].offset + pb[0 ].len >PAGE_SIZE ) { +if (pb[0 ].offset + pb[0 ].len >HV_HYP_PAGE_SIZE ) { packet->page_buf_cnt++; - pb[0 ].len =PAGE_SIZE - + pb[0 ].len =HV_HYP_PAGE_SIZE - pb[0 ].offset; pb[1 ].pfn =virt_to_phys ((void *)&req->request_msg - + pb[0 ].len) >>PAGE_SHIFT ; + + pb[0 ].len) >>HV_HYP_PAGE_SHIFT ; pb[1 ].offset =0 ; pb[1 ].len = req->request_msg.msg_len - pb[0 ].len;
Signature · 1 line
2.28.0
PATCH v4 8/11 Input: hyperv-keyboard: Use VMBUS_RING_SIZE() for ringbuffer sizes
In reply to Boqun FengFor a Hyper-V vmbus, the size of the ringbuffer has two requirements:
1) it has to take one PAGE_SIZE for the header
2) it has to be PAGE_SIZE aligned so that double-mapping can work
VMBUS_RING_SIZE() could calculate a correct ringbuffer size which fulfills both requirements, therefore use it to make sure vmbus work when PAGE_SIZE != HV_HYP_PAGE_SIZE (4K).
Note that since the argument for VMBUS_RING_SIZE() is the size of payload (data part), so it will be minus 4k (the size of header when PAGE_SIZE = 4k) than the original value to keep the ringbuffer total size unchanged when PAGE_SIZE = 4k.
---
Michael and Dmitry,
I change the code because of a problem I found:
https://lore.kernel.org/lkml/20200914084600.GA45838@debian-boqun.qqnc3lrjykvubdpftowmye0fmh.lx.internal.cloudapp.net/
, so I drop your Reviewed-by or Acked-by tag. If the update version looks good to you, may I add your tag again? Thanks in advance, and apologies for the inconvenience.
Regards,
Boqun
drivers/input/serio/hyperv-keyboard.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/input/serio/hyperv-keyboard.c +2 -2
@@ -75,8 +75,8 @@ struct synth_kbd_keystroke {#define HK_MAXIMUM_MESSAGE_SIZE 256 -#define KBD_VSC_SEND_RING_BUFFER_SIZE (40 * 1024) -#define KBD_VSC_RECV_RING_BUFFER_SIZE (40 * 1024) +#define KBD_VSC_SEND_RING_BUFFER_SIZE VMBUS_RING_SIZE(36 * 1024) +#define KBD_VSC_RECV_RING_BUFFER_SIZE VMBUS_RING_SIZE(36 * 1024)#define XTKBD_EMUL0 0xe0#define XTKBD_EMUL1 0xe1
Signature · 1 line
2.28.0
Re: [PATCH v4 08/11] Input: hyperv-keyboard: Use VMBUS_RING_SIZE() for ringbuffer sizes
Quoted 10 lines · Boqun Feng
For a Hyper-V vmbus, the size of the ringbuffer has two requirements:
1) it has to take one
PAGE_SIZEfor the header2) it has to be
PAGE_SIZEaligned so that double-mapping can work
VMBUS_RING_SIZE()could calculate a correct ringbuffer size which fulfills both requirements, therefore use it to make sure vmbus work whenPAGE_SIZE!=HV_HYP_PAGE_SIZE(4K).
Quoted 8 lines
Note that since the argument for
VMBUS_RING_SIZE()is the size of payload (data part), so it will be minus 4k (the size of header whenPAGE_SIZE= 4k) than the original value to keep the ringbuffer total size unchanged whenPAGE_SIZE= 4k.Signed-off-by Boqun Feng <[email protected]>Cc Michael Kelley <[email protected]>Cc Dmitry Torokhov <[email protected]>
Please feel free to merge through whatever tree the rest of the patches will go.
Thanks.
Signature · 1 line
Dmitry
RE: [PATCH v4 08/11] Input: hyperv-keyboard: Use VMBUS_RING_SIZE() for ringbuffer sizes
In reply to Boqun FengFrom: Boqun Feng <[email protected]> Sent: Tuesday, September 15, 2020 8:48 PM
Quoted 52 lines
For a Hyper-V vmbus, the size of the ringbuffer has two requirements:
1) it has to take one
PAGE_SIZEfor the header2) it has to be
PAGE_SIZEaligned so that double-mapping can work
VMBUS_RING_SIZE()could calculate a correct ringbuffer size which fulfills both requirements, therefore use it to make sure vmbus work whenPAGE_SIZE!=HV_HYP_PAGE_SIZE(4K).Note that since the argument for
VMBUS_RING_SIZE()is the size of payload (data part), so it will be minus 4k (the size of header whenPAGE_SIZE= 4k) than the original value to keep the ringbuffer total size unchanged whenPAGE_SIZE= 4k.Signed-off-by Boqun Feng <[email protected]>Cc Michael Kelley <[email protected]>Cc Dmitry Torokhov <[email protected]>---
Michael and Dmitry,I change the code because of a problem I found:
https://lore.kernel.org/lkml/20200914084600.GA45838@debian-boqun.qqnc3lrjykvubdpftowmye0fmh.lx.internal.cloudapp.net/, so I drop your Reviewed-by or Acked-by tag. If the update version looks good to you, may I add your tag again? Thanks in advance, and apologies for the inconvenience.
Regards,
Boqundrivers/input/serio/hyperv-keyboard.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)drivers/input/serio/hyperv-keyboard.c +2
-3@@ -75,8 +75,8 @@ struct synth_kbd_keystroke {#define HK_MAXIMUM_MESSAGE_SIZE 256 -#define KBD_VSC_SEND_RING_BUFFER_SIZE (40 * 1024) -#define KBD_VSC_RECV_RING_BUFFER_SIZE (40 * 1024) +#define KBD_VSC_SEND_RING_BUFFER_SIZE VMBUS_RING_SIZE(36 * 1024) +#define KBD_VSC_RECV_RING_BUFFER_SIZE VMBUS_RING_SIZE(36 * 1024)#define XTKBD_EMUL0 0xe0#define XTKBD_EMUL1 0xe1 --
Quoted 1 line
2.28.0
PATCH v4 9/11 HID: hyperv: Use VMBUS_RING_SIZE() for ringbuffer sizes
In reply to Boqun FengFor a Hyper-V vmbus, the size of the ringbuffer has two requirements:
1) it has to take one PAGE_SIZE for the header
2) it has to be PAGE_SIZE aligned so that double-mapping can work
VMBUS_RING_SIZE() could calculate a correct ringbuffer size which fulfills both requirements, therefore use it to make sure vmbus work when PAGE_SIZE != HV_HYP_PAGE_SIZE (4K).
Note that since the argument for VMBUS_RING_SIZE() is the size of payload (data part), so it will be minus 4k (the size of header when PAGE_SIZE = 4k) than the original value to keep the ringbuffer total size unchanged when PAGE_SIZE = 4k.
---
Michael and Jiri,
I change the code because of a problem I found:
https://lore.kernel.org/lkml/20200914084600.GA45838@debian-boqun.qqnc3lrjykvubdpftowmye0fmh.lx.internal.cloudapp.net/
, so I drop your Reviewed-by or Acked-by tag. If the update version looks good to you, may I add your tag again? Thanks in advance, and apologies for the inconvenience.
Regards,
Boqun
drivers/hid/hid-hyperv.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/hid/hid-hyperv.c +2 -2
@@ -104,8 +104,8 @@ struct synthhid_input_report {#pragma pack(pop) -#define INPUTVSC_SEND_RING_BUFFER_SIZE (40 * 1024) -#define INPUTVSC_RECV_RING_BUFFER_SIZE (40 * 1024) +#define INPUTVSC_SEND_RING_BUFFER_SIZE VMBUS_RING_SIZE(36 * 1024) +#define INPUTVSC_RECV_RING_BUFFER_SIZE VMBUS_RING_SIZE(36 * 1024)enum pipe_prot_msg_type {
Signature · 1 line
2.28.0
RE: [PATCH v4 09/11] HID: hyperv: Use VMBUS_RING_SIZE() for ringbuffer sizes
From: Boqun Feng <[email protected]> Sent: Tuesday, September 15, 2020 8:48 PM
Quoted 52 lines
For a Hyper-V vmbus, the size of the ringbuffer has two requirements:
1) it has to take one
PAGE_SIZEfor the header2) it has to be
PAGE_SIZEaligned so that double-mapping can work
VMBUS_RING_SIZE()could calculate a correct ringbuffer size which fulfills both requirements, therefore use it to make sure vmbus work whenPAGE_SIZE!=HV_HYP_PAGE_SIZE(4K).Note that since the argument for
VMBUS_RING_SIZE()is the size of payload (data part), so it will be minus 4k (the size of header whenPAGE_SIZE= 4k) than the original value to keep the ringbuffer total size unchanged whenPAGE_SIZE= 4k.Signed-off-by Boqun Feng <[email protected]>Cc Jiri Kosina <[email protected]>Cc Michael Kelley <[email protected]>---
Michael and Jiri,I change the code because of a problem I found:
https://lore.kernel.org/lkml/20200914084600.GA45838@debian-boqun.qqnc3lrjykvubdpftowmye0fmh.lx.internal.cloudapp.net/, so I drop your Reviewed-by or Acked-by tag. If the update version looks good to you, may I add your tag again? Thanks in advance, and apologies for the inconvenience.
Regards,
Boqundrivers/hid/hid-hyperv.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)drivers/hid/hid-hyperv.c +2
-3@@ -104,8 +104,8 @@ struct synthhid_input_report {#pragma pack(pop) -#define INPUTVSC_SEND_RING_BUFFER_SIZE (40 * 1024) -#define INPUTVSC_RECV_RING_BUFFER_SIZE (40 * 1024) +#define INPUTVSC_SEND_RING_BUFFER_SIZE VMBUS_RING_SIZE(36 * 1024) +#define INPUTVSC_RECV_RING_BUFFER_SIZE VMBUS_RING_SIZE(36 * 1024)enum pipe_prot_msg_type { --
Quoted 1 line
2.28.0
PATCH v4 10/11 Driver: hv: util: Use VMBUS_RING_SIZE() for ringbuffer sizes
In reply to Boqun FengFor a Hyper-V vmbus, the size of the ringbuffer has two requirements:
1) it has to take one PAGE_SIZE for the header
2) it has to be PAGE_SIZE aligned so that double-mapping can work
VMBUS_RING_SIZE() could calculate a correct ringbuffer size which fulfills both requirements, therefore use it to make sure vmbus work when PAGE_SIZE != HV_HYP_PAGE_SIZE (4K).
Note that since the argument for VMBUS_RING_SIZE() is the size of payload (data part), so it will be minus 4k (the size of header when PAGE_SIZE = 4k) than the original value to keep the ringbuffer total size unchanged when PAGE_SIZE = 4k.
---
Michael,
I drop your Reviewed-by tag because of the page align issue. Could you review this updated version? Thanks!
Regards,
Boqun
drivers/hv/hv_util.c | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-)
drivers/hv/hv_util.c +7 -4
@@ -500,6 +500,9 @@ static void heartbeat_onchannelcallback(void *context) } } +#define HV_UTIL_RING_SEND_SIZE VMBUS_RING_SIZE(3 * HV_HYP_PAGE_SIZE) +#define HV_UTIL_RING_RECV_SIZE VMBUS_RING_SIZE(3 * HV_HYP_PAGE_SIZE) +static int util_probe (struct hv_device *dev,const struct hv_vmbus_device_id *dev_id) {
@@ -530,8 +533,8 @@ static int util_probe(struct hv_device *dev,hv_set_drvdata (dev, srv); - ret =vmbus_open (dev->channel,4 *HV_HYP_PAGE_SIZE , -4 *HV_HYP_PAGE_SIZE ,NULL ,0 , srv->util_cb, + ret =vmbus_open (dev->channel,HV_UTIL_RING_SEND_SIZE , +HV_UTIL_RING_RECV_SIZE ,NULL ,0 , srv->util_cb, dev->channel);if (ret) goto error;
@@ -590,8 +593,8 @@ static int util_resume(struct hv_device *dev)return ret; } - ret =vmbus_open (dev->channel,4 *HV_HYP_PAGE_SIZE , -4 *HV_HYP_PAGE_SIZE ,NULL ,0 , srv->util_cb, + ret =vmbus_open (dev->channel,HV_UTIL_RING_SEND_SIZE , +HV_UTIL_RING_RECV_SIZE ,NULL ,0 , srv->util_cb, dev->channel);return ret; }
Signature · 1 line
2.28.0
RE: [PATCH v4 10/11] Driver: hv: util: Use VMBUS_RING_SIZE() for ringbuffer sizes
From: Boqun Feng <[email protected]> Sent: Tuesday, September 15, 2020 8:48 PM
Quoted 69 lines
For a Hyper-V vmbus, the size of the ringbuffer has two requirements:
1) it has to take one
PAGE_SIZEfor the header2) it has to be
PAGE_SIZEaligned so that double-mapping can work
VMBUS_RING_SIZE()could calculate a correct ringbuffer size which fulfills both requirements, therefore use it to make sure vmbus work whenPAGE_SIZE!=HV_HYP_PAGE_SIZE(4K).Note that since the argument for
VMBUS_RING_SIZE()is the size of payload (data part), so it will be minus 4k (the size of header whenPAGE_SIZE= 4k) than the original value to keep the ringbuffer total size unchanged whenPAGE_SIZE= 4k.Signed-off-by Boqun Feng <[email protected]>Cc Michael Kelley <[email protected]>---
Michael,I drop your Reviewed-by tag because of the page align issue. Could you review this updated version? Thanks!
Regards,
Boqundrivers/hv/hv_util.c | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-)drivers/hv/hv_util.c +7
-5@@ -500,6 +500,9 @@ static void heartbeat_onchannelcallback(void *context) } } +#define HV_UTIL_RING_SEND_SIZE VMBUS_RING_SIZE(3 * HV_HYP_PAGE_SIZE) +#define HV_UTIL_RING_RECV_SIZE VMBUS_RING_SIZE(3 * HV_HYP_PAGE_SIZE) +static int util_probe (struct hv_device *dev,const struct hv_vmbus_device_id *dev_id) {@@ -530,8 +533,8 @@ static int util_probe(struct hv_device *dev,hv_set_drvdata (dev, srv); - ret =vmbus_open (dev->channel,4 *HV_HYP_PAGE_SIZE , -4 *HV_HYP_PAGE_SIZE ,NULL ,0 , srv->util_cb, + ret =vmbus_open (dev->channel,HV_UTIL_RING_SEND_SIZE , +HV_UTIL_RING_RECV_SIZE ,NULL ,0 , srv->util_cb, dev->channel);if (ret) goto error;@@ -590,8 +593,8 @@ static int util_resume(struct hv_device *dev)return ret; } - ret =vmbus_open (dev->channel,4 *HV_HYP_PAGE_SIZE , -4 *HV_HYP_PAGE_SIZE ,NULL ,0 , srv->util_cb, + ret =vmbus_open (dev->channel,HV_UTIL_RING_SEND_SIZE , +HV_UTIL_RING_RECV_SIZE ,NULL ,0 , srv->util_cb, dev->channel);return ret; } --
Quoted 1 line
2.28.0
PATCH v4 11/11 scsi: storvsc: Support PAGE_SIZE larger than 4K
In reply to Boqun FengHyper-V always use 4k page size (HV_HYP_PAGE_SIZE), so when communicating with Hyper-V, a guest should always use HV_HYP_PAGE_SIZE as the unit for page related data. For storvsc, the data is vmbus_packet_mpb_array. And since in scsi_cmnd, sglist of pages (in unit of PAGE_SIZE) is used, we need convert pages in the sglist of scsi_cmnd into Hyper-V pages in vmbus_packet_mpb_array.
This patch does the conversion by dividing pages in sglist into Hyper-V pages, offset and indexes in vmbus_packet_mpb_array are recalculated accordingly.
--- drivers/scsi/storvsc_drv.c | 56 +++++++++++++++++++++++++++++++++----- 1 file changed, 49 insertions(+), 7 deletions(-)
drivers/scsi/storvsc_drv.c +49 -7
@@ -1739,23 +1739,65 @@ static int storvsc_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *scmnd) payload_sz =sizeof (cmd_request->mpb);if (sg_count) { -if (sg_count >MAX_PAGE_BUFFER_COUNT ) { +unsigned int hvpgoff =0 ; +unsigned long offset_in_hvpg = sgl->offset & ~HV_HYP_PAGE_MASK ; +unsigned int hvpg_count =HVPFN_UP (offset_in_hvpg + length); +u64 hvpfn; - payload_sz = (sg_count *sizeof (u64) + +if (hvpg_count >MAX_PAGE_BUFFER_COUNT ) { + + payload_sz = (hvpg_count *sizeof (u64) +sizeof (struct vmbus_packet_mpb_array )); payload =kzalloc (payload_sz,GFP_ATOMIC );if (!payload)return SCSI_MLQUEUE_DEVICE_BUSY ; } +/* +* sgl is a list of PAGEs, and payload->range.pfn_array +* expects the page number in the unit of HV_HYP_PAGE_SIZE (the +* page size that Hyper-V uses, so here we need to divide PAGEs +* into HV_HYP_PAGE in case that PAGE_SIZE > HV_HYP_PAGE_SIZE. +* Besides, payload->range.offset should be the offset in one +* HV_HYP_PAGE. +*/ payload->range.len = length; - payload->range.offset = sgl[0 ].offset; + payload->range.offset = offset_in_hvpg; + hvpgoff = sgl->offset >>HV_HYP_PAGE_SHIFT ; cur_sgl = sgl; -for (i =0 ; i < sg_count; i++) { - payload->range.pfn_array[i] = -page_to_pfn (sg_page ((cur_sgl))); - cur_sgl =sg_next (cur_sgl); +for (i =0 ; i < hvpg_count; i++) { +/* +* 'i' is the index of hv pages in the payload and +* 'hvpgoff' is the offset (in hv pages) of the first +* hv page in the the first page. The relationship +* between the sum of 'i' and 'hvpgoff' and the offset +* (in hv pages) in a payload page ('hvpgoff_in_page') +* is as follow: +* +* |------------------ PAGE -------------------| +* | NR_HV_HYP_PAGES_IN_PAGE hvpgs in total | +* |hvpg|hvpg| ... |hvpg|... |hvpg| +* ^ ^ ^ ^ +* +-hvpgoff-+ +-hvpgoff_in_page-+ +* ^ | +* +--------------------- i ---------------------------+ +*/ +unsigned int hvpgoff_in_page = + (i + hvpgoff) %NR_HV_HYP_PAGES_IN_PAGE ; + +/* +* Two cases that we need to fetch a page: +* 1) i == 0, the first step or +* 2) hvpgoff_in_page == 0, when we reach the boundary +* of a page. +*/ +if (hvpgoff_in_page ==0 || i ==0 ) { + hvpfn =page_to_hvpfn (sg_page (cur_sgl)); + cur_sgl =sg_next (cur_sgl); + } + + payload->range.pfn_array[i] = hvpfn + hvpgoff_in_page; } }
Signature · 1 line
2.28.0
Wei Liu
maintainerQuoted 29 lines · Boqun Feng
This patchset add the necessary changes to support guests whose page size is larger than 4K. And the main architecture which we develop this for is ARM64 (also it's the architecture that I use to test this feature).
Previous version:
v1: https://lore.kernel.org/lkml/[email protected]/
v2: https://lore.kernel.org/lkml/[email protected]
v3: https://lore.kernel.org/lkml/[email protected]/Changes since v3:
* Fix a bug that ringbuffer sizes are not page-aligned when
PAGE_SIZE= 16k. Drop the Acked-by and Reviewed-by tags for those patches accordingly.* Code improvement as per suggestion from Michael Kelley.
I've done some tests with PAGE_SIZE=64k and PAGE_SIZE=16k configurations on ARM64 guests (with Michael's patchset[1] for ARM64 Hyper-V guest support), everything worked fine ;-)
Looking forwards to comments and suggestions!
Regards,
Boqun
Quoted 12 lines
Boqun Feng (11):
Drivers: hv: vmbus: Always useHV_HYP_PAGE_SIZEfor gpadl
Drivers: hv: vmbus: Move__vmbus_open()
Drivers: hv: vmbus: Introduce types of GPADL
Drivers: hv: UseHV_HYP_PAGEinhv_synic_enable_regs()
Drivers: hv: vmbus: Movevirt_to_hvpfn()to hyperv header
hv:hyperv.h: Introduce some hvpfn helper functions
hv_netvsc: UseHV_HYP_PAGE_SIZEfor Hyper-V communication
Input: hyperv-keyboard: UseVMBUS_RING_SIZE()for ringbuffer sizes
HID: hyperv: UseVMBUS_RING_SIZE()for ringbuffer sizes
Driver: hv: util: UseVMBUS_RING_SIZE()for ringbuffer sizes
scsi: storvsc: SupportPAGE_SIZElarger than 4K
Series applied to hyperv-next.
I also replaced the tabs with spaces in the commit messages of patch 8 through patch 10.
Wei.