1

hyperv-next for 5.17

-----BEGIN PGP SIGNATURE-----
 
 iQFHBAABCAAxFiEEIbPD0id6easf0xsudhRwX5BBoF4FAmHhw7oTHHdlaS5saXVA
 a2VybmVsLm9yZwAKCRB2FHBfkEGgXrjSB/979LV4Dn1PMcFYsSdlFEMeHcjzJdw/
 kFnLPXMaPJyfg6QPuf83jxzw9uxw8fcePMdVq/FFBtmVV9fJMAv62B8jaGS1p58c
 WnAg+7zsTN+xEoJn+tskSSon8BNMWVrl41zP3K4Ged+5j8UEBk62GB8Orz1qkpwL
 fTh3/+xAvczJeD4zZb1dAm4WnmcQJ4vhg45p07jX6owvnwQAikMFl45aSW54I5o8
 vAxGzFgdsZ2NtExnRNKh3b3DozA8JUE89KckBSZnDtq4rH8Fyy6Wij56Hc6v6Cml
 SUohiNbHX7hsNwit/lxL8wuF97IiA0pQSABobEg3rxfTghTUep51LlaN
 =/m4A
 -----END PGP SIGNATURE-----

Merge tag 'hyperv-next-signed-20220114' of git://git.kernel.org/pub/scm/linux/kernel/git/hyperv/linux

Pull hyperv updates from Wei Liu:

 - More patches for Hyper-V isolation VM support (Tianyu Lan)

 - Bug fixes and clean-up patches from various people

* tag 'hyperv-next-signed-20220114' of git://git.kernel.org/pub/scm/linux/kernel/git/hyperv/linux:
  scsi: storvsc: Fix storvsc_queuecommand() memory leak
  x86/hyperv: Properly deal with empty cpumasks in hyperv_flush_tlb_multi()
  Drivers: hv: vmbus: Initialize request offers message for Isolation VM
  scsi: storvsc: Fix unsigned comparison to zero
  swiotlb: Add CONFIG_HAS_IOMEM check around swiotlb_mem_remap()
  x86/hyperv: Fix definition of hv_ghcb_pg variable
  Drivers: hv: Fix definition of hypercall input & output arg variables
  net: netvsc: Add Isolation VM support for netvsc driver
  scsi: storvsc: Add Isolation VM support for storvsc driver
  hyper-v: Enable swiotlb bounce buffer for Isolation VM
  x86/hyper-v: Add hyperv Isolation VM check in the cc_platform_has()
  swiotlb: Add swiotlb bounce buffer remap function for HV IVM
This commit is contained in:
Linus Torvalds 2022-01-16 15:53:00 +02:00
commit cb3f09f9af
18 changed files with 328 additions and 45 deletions

View File

@ -28,6 +28,7 @@
#include <linux/syscore_ops.h> #include <linux/syscore_ops.h>
#include <clocksource/hyperv_timer.h> #include <clocksource/hyperv_timer.h>
#include <linux/highmem.h> #include <linux/highmem.h>
#include <linux/swiotlb.h>
int hyperv_init_cpuhp; int hyperv_init_cpuhp;
u64 hv_current_partition_id = ~0ull; u64 hv_current_partition_id = ~0ull;
@ -36,7 +37,7 @@ EXPORT_SYMBOL_GPL(hv_current_partition_id);
void *hv_hypercall_pg; void *hv_hypercall_pg;
EXPORT_SYMBOL_GPL(hv_hypercall_pg); EXPORT_SYMBOL_GPL(hv_hypercall_pg);
union hv_ghcb __percpu **hv_ghcb_pg; union hv_ghcb * __percpu *hv_ghcb_pg;
/* Storage to save the hypercall page temporarily for hibernation */ /* Storage to save the hypercall page temporarily for hibernation */
static void *hv_hypercall_pg_saved; static void *hv_hypercall_pg_saved;
@ -498,6 +499,17 @@ void __init hyperv_init(void)
/* Query the VMs extended capability once, so that it can be cached. */ /* Query the VMs extended capability once, so that it can be cached. */
hv_query_ext_cap(0); hv_query_ext_cap(0);
#ifdef CONFIG_SWIOTLB
/*
* Swiotlb bounce buffer needs to be mapped in extra address
* space. Map function doesn't work in the early place and so
* call swiotlb_update_mem_attributes() here.
*/
if (hv_is_isolation_supported())
swiotlb_update_mem_attributes();
#endif
return; return;
clean_guest_os_id: clean_guest_os_id:

View File

@ -287,3 +287,31 @@ int hv_set_mem_host_visibility(unsigned long kbuffer, int pagecount, bool visibl
kfree(pfn_array); kfree(pfn_array);
return ret; return ret;
} }
/*
* hv_map_memory - map memory to extra space in the AMD SEV-SNP Isolation VM.
*/
void *hv_map_memory(void *addr, unsigned long size)
{
unsigned long *pfns = kcalloc(size / PAGE_SIZE,
sizeof(unsigned long), GFP_KERNEL);
void *vaddr;
int i;
if (!pfns)
return NULL;
for (i = 0; i < size / PAGE_SIZE; i++)
pfns[i] = vmalloc_to_pfn(addr + i * PAGE_SIZE) +
(ms_hyperv.shared_gpa_boundary >> PAGE_SHIFT);
vaddr = vmap_pfn(pfns, size / PAGE_SIZE, PAGE_KERNEL_IO);
kfree(pfns);
return vaddr;
}
void hv_unmap_memory(void *addr)
{
vunmap(addr);
}

View File

@ -68,15 +68,6 @@ static void hyperv_flush_tlb_multi(const struct cpumask *cpus,
local_irq_save(flags); local_irq_save(flags);
/*
* Only check the mask _after_ interrupt has been disabled to avoid the
* mask changing under our feet.
*/
if (cpumask_empty(cpus)) {
local_irq_restore(flags);
return;
}
flush_pcpu = (struct hv_tlb_flush **) flush_pcpu = (struct hv_tlb_flush **)
this_cpu_ptr(hyperv_pcpu_input_arg); this_cpu_ptr(hyperv_pcpu_input_arg);
@ -115,7 +106,9 @@ static void hyperv_flush_tlb_multi(const struct cpumask *cpus,
* must. We will also check all VP numbers when walking the * must. We will also check all VP numbers when walking the
* supplied CPU set to remain correct in all cases. * supplied CPU set to remain correct in all cases.
*/ */
if (hv_cpu_number_to_vp_number(cpumask_last(cpus)) >= 64) cpu = cpumask_last(cpus);
if (cpu < nr_cpumask_bits && hv_cpu_number_to_vp_number(cpu) >= 64)
goto do_ex_hypercall; goto do_ex_hypercall;
for_each_cpu(cpu, cpus) { for_each_cpu(cpu, cpus) {
@ -131,6 +124,12 @@ static void hyperv_flush_tlb_multi(const struct cpumask *cpus,
__set_bit(vcpu, (unsigned long *) __set_bit(vcpu, (unsigned long *)
&flush->processor_mask); &flush->processor_mask);
} }
/* nothing to flush if 'processor_mask' ends up being empty */
if (!flush->processor_mask) {
local_irq_restore(flags);
return;
}
} }
/* /*

View File

@ -30,7 +30,7 @@ extern void *hv_hypercall_pg;
extern u64 hv_current_partition_id; extern u64 hv_current_partition_id;
extern union hv_ghcb __percpu **hv_ghcb_pg; extern union hv_ghcb * __percpu *hv_ghcb_pg;
int hv_call_deposit_pages(int node, u64 partition_id, u32 num_pages); int hv_call_deposit_pages(int node, u64 partition_id, u32 num_pages);
int hv_call_add_logical_proc(int node, u32 lp_index, u32 acpi_id); int hv_call_add_logical_proc(int node, u32 lp_index, u32 acpi_id);

View File

@ -11,6 +11,7 @@
#include <linux/cc_platform.h> #include <linux/cc_platform.h>
#include <linux/mem_encrypt.h> #include <linux/mem_encrypt.h>
#include <asm/mshyperv.h>
#include <asm/processor.h> #include <asm/processor.h>
static bool __maybe_unused intel_cc_platform_has(enum cc_attr attr) static bool __maybe_unused intel_cc_platform_has(enum cc_attr attr)
@ -66,12 +67,19 @@ static bool amd_cc_platform_has(enum cc_attr attr)
#endif #endif
} }
static bool hyperv_cc_platform_has(enum cc_attr attr)
{
return attr == CC_ATTR_GUEST_MEM_ENCRYPT;
}
bool cc_platform_has(enum cc_attr attr) bool cc_platform_has(enum cc_attr attr)
{ {
if (sme_me_mask) if (sme_me_mask)
return amd_cc_platform_has(attr); return amd_cc_platform_has(attr);
if (hv_is_isolation_supported())
return hyperv_cc_platform_has(attr);
return false; return false;
} }
EXPORT_SYMBOL_GPL(cc_platform_has); EXPORT_SYMBOL_GPL(cc_platform_has);

View File

@ -18,6 +18,7 @@
#include <linux/kexec.h> #include <linux/kexec.h>
#include <linux/i8253.h> #include <linux/i8253.h>
#include <linux/random.h> #include <linux/random.h>
#include <linux/swiotlb.h>
#include <asm/processor.h> #include <asm/processor.h>
#include <asm/hypervisor.h> #include <asm/hypervisor.h>
#include <asm/hyperv-tlfs.h> #include <asm/hyperv-tlfs.h>
@ -329,8 +330,20 @@ static void __init ms_hyperv_init_platform(void)
pr_info("Hyper-V: Isolation Config: Group A 0x%x, Group B 0x%x\n", pr_info("Hyper-V: Isolation Config: Group A 0x%x, Group B 0x%x\n",
ms_hyperv.isolation_config_a, ms_hyperv.isolation_config_b); ms_hyperv.isolation_config_a, ms_hyperv.isolation_config_b);
if (hv_get_isolation_type() == HV_ISOLATION_TYPE_SNP) if (hv_get_isolation_type() == HV_ISOLATION_TYPE_SNP) {
static_branch_enable(&isolation_type_snp); static_branch_enable(&isolation_type_snp);
#ifdef CONFIG_SWIOTLB
swiotlb_unencrypted_base = ms_hyperv.shared_gpa_boundary;
#endif
}
#ifdef CONFIG_SWIOTLB
/*
* Enable swiotlb force mode in Isolation VM to
* use swiotlb bounce buffer for dma transaction.
*/
swiotlb_force = SWIOTLB_FORCE;
#endif
} }
if (hv_max_functions_eax >= HYPERV_CPUID_NESTED_FEATURES) { if (hv_max_functions_eax >= HYPERV_CPUID_NESTED_FEATURES) {

View File

@ -1554,7 +1554,7 @@ int vmbus_request_offers(void)
struct vmbus_channel_msginfo *msginfo; struct vmbus_channel_msginfo *msginfo;
int ret; int ret;
msginfo = kmalloc(sizeof(*msginfo) + msginfo = kzalloc(sizeof(*msginfo) +
sizeof(struct vmbus_channel_message_header), sizeof(struct vmbus_channel_message_header),
GFP_KERNEL); GFP_KERNEL);
if (!msginfo) if (!msginfo)

View File

@ -44,10 +44,10 @@ EXPORT_SYMBOL_GPL(hv_vp_index);
u32 hv_max_vp_index; u32 hv_max_vp_index;
EXPORT_SYMBOL_GPL(hv_max_vp_index); EXPORT_SYMBOL_GPL(hv_max_vp_index);
void __percpu **hyperv_pcpu_input_arg; void * __percpu *hyperv_pcpu_input_arg;
EXPORT_SYMBOL_GPL(hyperv_pcpu_input_arg); EXPORT_SYMBOL_GPL(hyperv_pcpu_input_arg);
void __percpu **hyperv_pcpu_output_arg; void * __percpu *hyperv_pcpu_output_arg;
EXPORT_SYMBOL_GPL(hyperv_pcpu_output_arg); EXPORT_SYMBOL_GPL(hyperv_pcpu_output_arg);
/* /*
@ -295,3 +295,14 @@ u64 __weak hv_ghcb_hypercall(u64 control, void *input, void *output, u32 input_s
return HV_STATUS_INVALID_PARAMETER; return HV_STATUS_INVALID_PARAMETER;
} }
EXPORT_SYMBOL_GPL(hv_ghcb_hypercall); EXPORT_SYMBOL_GPL(hv_ghcb_hypercall);
void __weak *hv_map_memory(void *addr, unsigned long size)
{
return NULL;
}
EXPORT_SYMBOL_GPL(hv_map_memory);
void __weak hv_unmap_memory(void *addr)
{
}
EXPORT_SYMBOL_GPL(hv_unmap_memory);

View File

@ -33,6 +33,7 @@
#include <linux/random.h> #include <linux/random.h>
#include <linux/kernel.h> #include <linux/kernel.h>
#include <linux/syscore_ops.h> #include <linux/syscore_ops.h>
#include <linux/dma-map-ops.h>
#include <clocksource/hyperv_timer.h> #include <clocksource/hyperv_timer.h>
#include "hyperv_vmbus.h" #include "hyperv_vmbus.h"
@ -2078,6 +2079,7 @@ struct hv_device *vmbus_device_create(const guid_t *type,
return child_device_obj; return child_device_obj;
} }
static u64 vmbus_dma_mask = DMA_BIT_MASK(64);
/* /*
* vmbus_device_register - Register the child device * vmbus_device_register - Register the child device
*/ */
@ -2118,6 +2120,8 @@ int vmbus_device_register(struct hv_device *child_device_obj)
} }
hv_debug_add_dev_dir(child_device_obj); hv_debug_add_dev_dir(child_device_obj);
child_device_obj->device.dma_mask = &vmbus_dma_mask;
child_device_obj->device.dma_parms = &child_device_obj->dma_parms;
return 0; return 0;
err_kset_unregister: err_kset_unregister:

View File

@ -164,6 +164,7 @@ struct hv_netvsc_packet {
u32 total_bytes; u32 total_bytes;
u32 send_buf_index; u32 send_buf_index;
u32 total_data_buflen; u32 total_data_buflen;
struct hv_dma_range *dma_range;
}; };
#define NETVSC_HASH_KEYLEN 40 #define NETVSC_HASH_KEYLEN 40
@ -1074,6 +1075,7 @@ struct netvsc_device {
/* Receive buffer allocated by us but manages by NetVSP */ /* Receive buffer allocated by us but manages by NetVSP */
void *recv_buf; void *recv_buf;
void *recv_original_buf;
u32 recv_buf_size; /* allocated bytes */ u32 recv_buf_size; /* allocated bytes */
struct vmbus_gpadl recv_buf_gpadl_handle; struct vmbus_gpadl recv_buf_gpadl_handle;
u32 recv_section_cnt; u32 recv_section_cnt;
@ -1082,6 +1084,7 @@ struct netvsc_device {
/* Send buffer allocated by us */ /* Send buffer allocated by us */
void *send_buf; void *send_buf;
void *send_original_buf;
u32 send_buf_size; u32 send_buf_size;
struct vmbus_gpadl send_buf_gpadl_handle; struct vmbus_gpadl send_buf_gpadl_handle;
u32 send_section_cnt; u32 send_section_cnt;
@ -1731,4 +1734,6 @@ struct rndis_message {
#define RETRY_US_HI 10000 #define RETRY_US_HI 10000
#define RETRY_MAX 2000 /* >10 sec */ #define RETRY_MAX 2000 /* >10 sec */
void netvsc_dma_unmap(struct hv_device *hv_dev,
struct hv_netvsc_packet *packet);
#endif /* _HYPERV_NET_H */ #endif /* _HYPERV_NET_H */

View File

@ -153,8 +153,21 @@ static void free_netvsc_device(struct rcu_head *head)
int i; int i;
kfree(nvdev->extension); kfree(nvdev->extension);
vfree(nvdev->recv_buf);
vfree(nvdev->send_buf); if (nvdev->recv_original_buf) {
hv_unmap_memory(nvdev->recv_buf);
vfree(nvdev->recv_original_buf);
} else {
vfree(nvdev->recv_buf);
}
if (nvdev->send_original_buf) {
hv_unmap_memory(nvdev->send_buf);
vfree(nvdev->send_original_buf);
} else {
vfree(nvdev->send_buf);
}
bitmap_free(nvdev->send_section_map); bitmap_free(nvdev->send_section_map);
for (i = 0; i < VRSS_CHANNEL_MAX; i++) { for (i = 0; i < VRSS_CHANNEL_MAX; i++) {
@ -337,6 +350,7 @@ static int netvsc_init_buf(struct hv_device *device,
struct nvsp_message *init_packet; struct nvsp_message *init_packet;
unsigned int buf_size; unsigned int buf_size;
int i, ret = 0; int i, ret = 0;
void *vaddr;
/* Get receive buffer area. */ /* Get receive buffer area. */
buf_size = device_info->recv_sections * device_info->recv_section_size; buf_size = device_info->recv_sections * device_info->recv_section_size;
@ -372,6 +386,17 @@ static int netvsc_init_buf(struct hv_device *device,
goto cleanup; goto cleanup;
} }
if (hv_isolation_type_snp()) {
vaddr = hv_map_memory(net_device->recv_buf, buf_size);
if (!vaddr) {
ret = -ENOMEM;
goto cleanup;
}
net_device->recv_original_buf = net_device->recv_buf;
net_device->recv_buf = vaddr;
}
/* Notify the NetVsp of the gpadl handle */ /* Notify the NetVsp of the gpadl handle */
init_packet = &net_device->channel_init_pkt; init_packet = &net_device->channel_init_pkt;
memset(init_packet, 0, sizeof(struct nvsp_message)); memset(init_packet, 0, sizeof(struct nvsp_message));
@ -475,6 +500,17 @@ static int netvsc_init_buf(struct hv_device *device,
goto cleanup; goto cleanup;
} }
if (hv_isolation_type_snp()) {
vaddr = hv_map_memory(net_device->send_buf, buf_size);
if (!vaddr) {
ret = -ENOMEM;
goto cleanup;
}
net_device->send_original_buf = net_device->send_buf;
net_device->send_buf = vaddr;
}
/* Notify the NetVsp of the gpadl handle */ /* Notify the NetVsp of the gpadl handle */
init_packet = &net_device->channel_init_pkt; init_packet = &net_device->channel_init_pkt;
memset(init_packet, 0, sizeof(struct nvsp_message)); memset(init_packet, 0, sizeof(struct nvsp_message));
@ -764,7 +800,7 @@ static void netvsc_send_tx_complete(struct net_device *ndev,
/* Notify the layer above us */ /* Notify the layer above us */
if (likely(skb)) { if (likely(skb)) {
const struct hv_netvsc_packet *packet struct hv_netvsc_packet *packet
= (struct hv_netvsc_packet *)skb->cb; = (struct hv_netvsc_packet *)skb->cb;
u32 send_index = packet->send_buf_index; u32 send_index = packet->send_buf_index;
struct netvsc_stats *tx_stats; struct netvsc_stats *tx_stats;
@ -780,6 +816,7 @@ static void netvsc_send_tx_complete(struct net_device *ndev,
tx_stats->bytes += packet->total_bytes; tx_stats->bytes += packet->total_bytes;
u64_stats_update_end(&tx_stats->syncp); u64_stats_update_end(&tx_stats->syncp);
netvsc_dma_unmap(ndev_ctx->device_ctx, packet);
napi_consume_skb(skb, budget); napi_consume_skb(skb, budget);
} }
@ -944,6 +981,88 @@ static void netvsc_copy_to_send_buf(struct netvsc_device *net_device,
memset(dest, 0, padding); memset(dest, 0, padding);
} }
void netvsc_dma_unmap(struct hv_device *hv_dev,
struct hv_netvsc_packet *packet)
{
u32 page_count = packet->cp_partial ?
packet->page_buf_cnt - packet->rmsg_pgcnt :
packet->page_buf_cnt;
int i;
if (!hv_is_isolation_supported())
return;
if (!packet->dma_range)
return;
for (i = 0; i < page_count; i++)
dma_unmap_single(&hv_dev->device, packet->dma_range[i].dma,
packet->dma_range[i].mapping_size,
DMA_TO_DEVICE);
kfree(packet->dma_range);
}
/* netvsc_dma_map - Map swiotlb bounce buffer with data page of
* packet sent by vmbus_sendpacket_pagebuffer() in the Isolation
* VM.
*
* In isolation VM, netvsc send buffer has been marked visible to
* host and so the data copied to send buffer doesn't need to use
* bounce buffer. The data pages handled by vmbus_sendpacket_pagebuffer()
* may not be copied to send buffer and so these pages need to be
* mapped with swiotlb bounce buffer. netvsc_dma_map() is to do
* that. The pfns in the struct hv_page_buffer need to be converted
* to bounce buffer's pfn. The loop here is necessary because the
* entries in the page buffer array are not necessarily full
* pages of data. Each entry in the array has a separate offset and
* len that may be non-zero, even for entries in the middle of the
* array. And the entries are not physically contiguous. So each
* entry must be individually mapped rather than as a contiguous unit.
* So not use dma_map_sg() here.
*/
static int netvsc_dma_map(struct hv_device *hv_dev,
struct hv_netvsc_packet *packet,
struct hv_page_buffer *pb)
{
u32 page_count = packet->cp_partial ?
packet->page_buf_cnt - packet->rmsg_pgcnt :
packet->page_buf_cnt;
dma_addr_t dma;
int i;
if (!hv_is_isolation_supported())
return 0;
packet->dma_range = kcalloc(page_count,
sizeof(*packet->dma_range),
GFP_KERNEL);
if (!packet->dma_range)
return -ENOMEM;
for (i = 0; i < page_count; i++) {
char *src = phys_to_virt((pb[i].pfn << HV_HYP_PAGE_SHIFT)
+ pb[i].offset);
u32 len = pb[i].len;
dma = dma_map_single(&hv_dev->device, src, len,
DMA_TO_DEVICE);
if (dma_mapping_error(&hv_dev->device, dma)) {
kfree(packet->dma_range);
return -ENOMEM;
}
/* pb[].offset and pb[].len are not changed during dma mapping
* and so not reassign.
*/
packet->dma_range[i].dma = dma;
packet->dma_range[i].mapping_size = len;
pb[i].pfn = dma >> HV_HYP_PAGE_SHIFT;
}
return 0;
}
static inline int netvsc_send_pkt( static inline int netvsc_send_pkt(
struct hv_device *device, struct hv_device *device,
struct hv_netvsc_packet *packet, struct hv_netvsc_packet *packet,
@ -984,14 +1103,24 @@ static inline int netvsc_send_pkt(
trace_nvsp_send_pkt(ndev, out_channel, rpkt); trace_nvsp_send_pkt(ndev, out_channel, rpkt);
packet->dma_range = NULL;
if (packet->page_buf_cnt) { if (packet->page_buf_cnt) {
if (packet->cp_partial) if (packet->cp_partial)
pb += packet->rmsg_pgcnt; pb += packet->rmsg_pgcnt;
ret = netvsc_dma_map(ndev_ctx->device_ctx, packet, pb);
if (ret) {
ret = -EAGAIN;
goto exit;
}
ret = vmbus_sendpacket_pagebuffer(out_channel, ret = vmbus_sendpacket_pagebuffer(out_channel,
pb, packet->page_buf_cnt, pb, packet->page_buf_cnt,
&nvmsg, sizeof(nvmsg), &nvmsg, sizeof(nvmsg),
req_id); req_id);
if (ret)
netvsc_dma_unmap(ndev_ctx->device_ctx, packet);
} else { } else {
ret = vmbus_sendpacket(out_channel, ret = vmbus_sendpacket(out_channel,
&nvmsg, sizeof(nvmsg), &nvmsg, sizeof(nvmsg),
@ -999,6 +1128,7 @@ static inline int netvsc_send_pkt(
VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED); VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
} }
exit:
if (ret == 0) { if (ret == 0) {
atomic_inc_return(&nvchan->queue_sends); atomic_inc_return(&nvchan->queue_sends);

View File

@ -2516,6 +2516,7 @@ static int netvsc_probe(struct hv_device *dev,
net->netdev_ops = &device_ops; net->netdev_ops = &device_ops;
net->ethtool_ops = &ethtool_ops; net->ethtool_ops = &ethtool_ops;
SET_NETDEV_DEV(net, &dev->device); SET_NETDEV_DEV(net, &dev->device);
dma_set_min_align_mask(&dev->device, HV_HYP_PAGE_SIZE - 1);
/* We always need headroom for rndis header */ /* We always need headroom for rndis header */
net->needed_headroom = RNDIS_AND_PPI_SIZE; net->needed_headroom = RNDIS_AND_PPI_SIZE;

View File

@ -361,6 +361,8 @@ static void rndis_filter_receive_response(struct net_device *ndev,
} }
} }
netvsc_dma_unmap(((struct net_device_context *)
netdev_priv(ndev))->device_ctx, &request->pkt);
complete(&request->wait_event); complete(&request->wait_event);
} else { } else {
netdev_err(ndev, netdev_err(ndev,

View File

@ -21,6 +21,8 @@
#include <linux/device.h> #include <linux/device.h>
#include <linux/hyperv.h> #include <linux/hyperv.h>
#include <linux/blkdev.h> #include <linux/blkdev.h>
#include <linux/dma-mapping.h>
#include <scsi/scsi.h> #include <scsi/scsi.h>
#include <scsi/scsi_cmnd.h> #include <scsi/scsi_cmnd.h>
#include <scsi/scsi_host.h> #include <scsi/scsi_host.h>
@ -1336,6 +1338,7 @@ static void storvsc_on_channel_callback(void *context)
continue; continue;
} }
request = (struct storvsc_cmd_request *)scsi_cmd_priv(scmnd); request = (struct storvsc_cmd_request *)scsi_cmd_priv(scmnd);
scsi_dma_unmap(scmnd);
} }
storvsc_on_receive(stor_device, packet, request); storvsc_on_receive(stor_device, packet, request);
@ -1749,9 +1752,7 @@ static int storvsc_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *scmnd)
struct hv_host_device *host_dev = shost_priv(host); struct hv_host_device *host_dev = shost_priv(host);
struct hv_device *dev = host_dev->dev; struct hv_device *dev = host_dev->dev;
struct storvsc_cmd_request *cmd_request = scsi_cmd_priv(scmnd); struct storvsc_cmd_request *cmd_request = scsi_cmd_priv(scmnd);
int i;
struct scatterlist *sgl; struct scatterlist *sgl;
unsigned int sg_count;
struct vmscsi_request *vm_srb; struct vmscsi_request *vm_srb;
struct vmbus_packet_mpb_array *payload; struct vmbus_packet_mpb_array *payload;
u32 payload_sz; u32 payload_sz;
@ -1824,17 +1825,17 @@ static int storvsc_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *scmnd)
memcpy(vm_srb->cdb, scmnd->cmnd, vm_srb->cdb_length); memcpy(vm_srb->cdb, scmnd->cmnd, vm_srb->cdb_length);
sgl = (struct scatterlist *)scsi_sglist(scmnd); sgl = (struct scatterlist *)scsi_sglist(scmnd);
sg_count = scsi_sg_count(scmnd);
length = scsi_bufflen(scmnd); length = scsi_bufflen(scmnd);
payload = (struct vmbus_packet_mpb_array *)&cmd_request->mpb; payload = (struct vmbus_packet_mpb_array *)&cmd_request->mpb;
payload_sz = sizeof(cmd_request->mpb); payload_sz = sizeof(cmd_request->mpb);
if (sg_count) { if (scsi_sg_count(scmnd)) {
unsigned int hvpgoff, hvpfns_to_add;
unsigned long offset_in_hvpg = offset_in_hvpage(sgl->offset); unsigned long offset_in_hvpg = offset_in_hvpage(sgl->offset);
unsigned int hvpg_count = HVPFN_UP(offset_in_hvpg + length); unsigned int hvpg_count = HVPFN_UP(offset_in_hvpg + length);
u64 hvpfn; struct scatterlist *sg;
unsigned long hvpfn, hvpfns_to_add;
int j, i = 0, sg_count;
if (hvpg_count > MAX_PAGE_BUFFER_COUNT) { if (hvpg_count > MAX_PAGE_BUFFER_COUNT) {
@ -1848,21 +1849,24 @@ static int storvsc_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *scmnd)
payload->range.len = length; payload->range.len = length;
payload->range.offset = offset_in_hvpg; payload->range.offset = offset_in_hvpg;
sg_count = scsi_dma_map(scmnd);
if (sg_count < 0) {
ret = SCSI_MLQUEUE_DEVICE_BUSY;
goto err_free_payload;
}
for (i = 0; sgl != NULL; sgl = sg_next(sgl)) { for_each_sg(sgl, sg, sg_count, j) {
/* /*
* Init values for the current sgl entry. hvpgoff * Init values for the current sgl entry. hvpfns_to_add
* and hvpfns_to_add are in units of Hyper-V size * is in units of Hyper-V size pages. Handling the
* pages. Handling the PAGE_SIZE != HV_HYP_PAGE_SIZE * PAGE_SIZE != HV_HYP_PAGE_SIZE case also handles
* case also handles values of sgl->offset that are * values of sgl->offset that are larger than PAGE_SIZE.
* larger than PAGE_SIZE. Such offsets are handled * Such offsets are handled even on other than the first
* even on other than the first sgl entry, provided * sgl entry, provided they are a multiple of PAGE_SIZE.
* they are a multiple of PAGE_SIZE.
*/ */
hvpgoff = HVPFN_DOWN(sgl->offset); hvpfn = HVPFN_DOWN(sg_dma_address(sg));
hvpfn = page_to_hvpfn(sg_page(sgl)) + hvpgoff; hvpfns_to_add = HVPFN_UP(sg_dma_address(sg) +
hvpfns_to_add = HVPFN_UP(sgl->offset + sgl->length) - sg_dma_len(sg)) - hvpfn;
hvpgoff;
/* /*
* Fill the next portion of the PFN array with * Fill the next portion of the PFN array with
@ -1872,7 +1876,7 @@ static int storvsc_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *scmnd)
* the PFN array is filled. * the PFN array is filled.
*/ */
while (hvpfns_to_add--) while (hvpfns_to_add--)
payload->range.pfn_array[i++] = hvpfn++; payload->range.pfn_array[i++] = hvpfn++;
} }
} }
@ -1884,13 +1888,18 @@ static int storvsc_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *scmnd)
put_cpu(); put_cpu();
if (ret == -EAGAIN) { if (ret == -EAGAIN) {
if (payload_sz > sizeof(cmd_request->mpb))
kfree(payload);
/* no more space */ /* no more space */
return SCSI_MLQUEUE_DEVICE_BUSY; ret = SCSI_MLQUEUE_DEVICE_BUSY;
goto err_free_payload;
} }
return 0; return 0;
err_free_payload:
if (payload_sz > sizeof(cmd_request->mpb))
kfree(payload);
return ret;
} }
static struct scsi_host_template scsi_driver = { static struct scsi_host_template scsi_driver = {
@ -2016,6 +2025,7 @@ static int storvsc_probe(struct hv_device *device,
stor_device->vmscsi_size_delta = sizeof(struct vmscsi_win8_extension); stor_device->vmscsi_size_delta = sizeof(struct vmscsi_win8_extension);
spin_lock_init(&stor_device->lock); spin_lock_init(&stor_device->lock);
hv_set_drvdata(device, stor_device); hv_set_drvdata(device, stor_device);
dma_set_min_align_mask(&device->device, HV_HYP_PAGE_SIZE - 1);
stor_device->port_number = host->host_no; stor_device->port_number = host->host_no;
ret = storvsc_connect_to_vsp(device, storvsc_ringbuffer_size, is_fc); ret = storvsc_connect_to_vsp(device, storvsc_ringbuffer_size, is_fc);

View File

@ -49,8 +49,8 @@ struct ms_hyperv_info {
}; };
extern struct ms_hyperv_info ms_hyperv; extern struct ms_hyperv_info ms_hyperv;
extern void __percpu **hyperv_pcpu_input_arg; extern void * __percpu *hyperv_pcpu_input_arg;
extern void __percpu **hyperv_pcpu_output_arg; extern void * __percpu *hyperv_pcpu_output_arg;
extern u64 hv_do_hypercall(u64 control, void *inputaddr, void *outputaddr); extern u64 hv_do_hypercall(u64 control, void *inputaddr, void *outputaddr);
extern u64 hv_do_fast_hypercall8(u16 control, u64 input8); extern u64 hv_do_fast_hypercall8(u16 control, u64 input8);
@ -269,6 +269,8 @@ bool hv_isolation_type_snp(void);
u64 hv_ghcb_hypercall(u64 control, void *input, void *output, u32 input_size); u64 hv_ghcb_hypercall(u64 control, void *input, void *output, u32 input_size);
void hyperv_cleanup(void); void hyperv_cleanup(void);
bool hv_query_ext_cap(u64 cap_query); bool hv_query_ext_cap(u64 cap_query);
void *hv_map_memory(void *addr, unsigned long size);
void hv_unmap_memory(void *addr);
#else /* CONFIG_HYPERV */ #else /* CONFIG_HYPERV */
static inline bool hv_is_hyperv_initialized(void) { return false; } static inline bool hv_is_hyperv_initialized(void) { return false; }
static inline bool hv_is_hibernation_supported(void) { return false; } static inline bool hv_is_hibernation_supported(void) { return false; }

View File

@ -1261,6 +1261,7 @@ struct hv_device {
struct vmbus_channel *channel; struct vmbus_channel *channel;
struct kset *channels_kset; struct kset *channels_kset;
struct device_dma_parameters dma_parms;
/* place holder to keep track of the dir for hv device in debugfs */ /* place holder to keep track of the dir for hv device in debugfs */
struct dentry *debug_dir; struct dentry *debug_dir;
@ -1583,6 +1584,11 @@ struct hyperv_service_callback {
void (*callback)(void *context); void (*callback)(void *context);
}; };
struct hv_dma_range {
dma_addr_t dma;
u32 mapping_size;
};
#define MAX_SRV_VER 0x7ffffff #define MAX_SRV_VER 0x7ffffff
extern bool vmbus_prep_negotiate_resp(struct icmsg_hdr *icmsghdrp, u8 *buf, u32 buflen, extern bool vmbus_prep_negotiate_resp(struct icmsg_hdr *icmsghdrp, u8 *buf, u32 buflen,
const int *fw_version, int fw_vercnt, const int *fw_version, int fw_vercnt,

View File

@ -73,6 +73,9 @@ extern enum swiotlb_force swiotlb_force;
* @end: The end address of the swiotlb memory pool. Used to do a quick * @end: The end address of the swiotlb memory pool. Used to do a quick
* range check to see if the memory was in fact allocated by this * range check to see if the memory was in fact allocated by this
* API. * API.
* @vaddr: The vaddr of the swiotlb memory pool. The swiotlb memory pool
* may be remapped in the memory encrypted case and store virtual
* address for bounce buffer operation.
* @nslabs: The number of IO TLB blocks (in groups of 64) between @start and * @nslabs: The number of IO TLB blocks (in groups of 64) between @start and
* @end. For default swiotlb, this is command line adjustable via * @end. For default swiotlb, this is command line adjustable via
* setup_io_tlb_npages. * setup_io_tlb_npages.
@ -92,6 +95,7 @@ extern enum swiotlb_force swiotlb_force;
struct io_tlb_mem { struct io_tlb_mem {
phys_addr_t start; phys_addr_t start;
phys_addr_t end; phys_addr_t end;
void *vaddr;
unsigned long nslabs; unsigned long nslabs;
unsigned long used; unsigned long used;
unsigned int index; unsigned int index;
@ -186,4 +190,6 @@ static inline bool is_swiotlb_for_alloc(struct device *dev)
} }
#endif /* CONFIG_DMA_RESTRICTED_POOL */ #endif /* CONFIG_DMA_RESTRICTED_POOL */
extern phys_addr_t swiotlb_unencrypted_base;
#endif /* __LINUX_SWIOTLB_H */ #endif /* __LINUX_SWIOTLB_H */

View File

@ -50,6 +50,7 @@
#include <asm/io.h> #include <asm/io.h>
#include <asm/dma.h> #include <asm/dma.h>
#include <linux/io.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/memblock.h> #include <linux/memblock.h>
#include <linux/iommu-helper.h> #include <linux/iommu-helper.h>
@ -72,6 +73,8 @@ enum swiotlb_force swiotlb_force;
struct io_tlb_mem io_tlb_default_mem; struct io_tlb_mem io_tlb_default_mem;
phys_addr_t swiotlb_unencrypted_base;
/* /*
* Max segment that we can provide which (if pages are contingous) will * Max segment that we can provide which (if pages are contingous) will
* not be bounced (unless SWIOTLB_FORCE is set). * not be bounced (unless SWIOTLB_FORCE is set).
@ -155,6 +158,34 @@ static inline unsigned long nr_slots(u64 val)
return DIV_ROUND_UP(val, IO_TLB_SIZE); return DIV_ROUND_UP(val, IO_TLB_SIZE);
} }
/*
* Remap swioltb memory in the unencrypted physical address space
* when swiotlb_unencrypted_base is set. (e.g. for Hyper-V AMD SEV-SNP
* Isolation VMs).
*/
#ifdef CONFIG_HAS_IOMEM
static void *swiotlb_mem_remap(struct io_tlb_mem *mem, unsigned long bytes)
{
void *vaddr = NULL;
if (swiotlb_unencrypted_base) {
phys_addr_t paddr = mem->start + swiotlb_unencrypted_base;
vaddr = memremap(paddr, bytes, MEMREMAP_WB);
if (!vaddr)
pr_err("Failed to map the unencrypted memory %pa size %lx.\n",
&paddr, bytes);
}
return vaddr;
}
#else
static void *swiotlb_mem_remap(struct io_tlb_mem *mem, unsigned long bytes)
{
return NULL;
}
#endif
/* /*
* Early SWIOTLB allocation may be too early to allow an architecture to * Early SWIOTLB allocation may be too early to allow an architecture to
* perform the desired operations. This function allows the architecture to * perform the desired operations. This function allows the architecture to
@ -172,7 +203,12 @@ void __init swiotlb_update_mem_attributes(void)
vaddr = phys_to_virt(mem->start); vaddr = phys_to_virt(mem->start);
bytes = PAGE_ALIGN(mem->nslabs << IO_TLB_SHIFT); bytes = PAGE_ALIGN(mem->nslabs << IO_TLB_SHIFT);
set_memory_decrypted((unsigned long)vaddr, bytes >> PAGE_SHIFT); set_memory_decrypted((unsigned long)vaddr, bytes >> PAGE_SHIFT);
memset(vaddr, 0, bytes);
mem->vaddr = swiotlb_mem_remap(mem, bytes);
if (!mem->vaddr)
mem->vaddr = vaddr;
memset(mem->vaddr, 0, bytes);
} }
static void swiotlb_init_io_tlb_mem(struct io_tlb_mem *mem, phys_addr_t start, static void swiotlb_init_io_tlb_mem(struct io_tlb_mem *mem, phys_addr_t start,
@ -196,7 +232,17 @@ static void swiotlb_init_io_tlb_mem(struct io_tlb_mem *mem, phys_addr_t start,
mem->slots[i].orig_addr = INVALID_PHYS_ADDR; mem->slots[i].orig_addr = INVALID_PHYS_ADDR;
mem->slots[i].alloc_size = 0; mem->slots[i].alloc_size = 0;
} }
/*
* If swiotlb_unencrypted_base is set, the bounce buffer memory will
* be remapped and cleared in swiotlb_update_mem_attributes.
*/
if (swiotlb_unencrypted_base)
return;
memset(vaddr, 0, bytes); memset(vaddr, 0, bytes);
mem->vaddr = vaddr;
return;
} }
int __init swiotlb_init_with_tbl(char *tlb, unsigned long nslabs, int verbose) int __init swiotlb_init_with_tbl(char *tlb, unsigned long nslabs, int verbose)
@ -371,7 +417,7 @@ static void swiotlb_bounce(struct device *dev, phys_addr_t tlb_addr, size_t size
phys_addr_t orig_addr = mem->slots[index].orig_addr; phys_addr_t orig_addr = mem->slots[index].orig_addr;
size_t alloc_size = mem->slots[index].alloc_size; size_t alloc_size = mem->slots[index].alloc_size;
unsigned long pfn = PFN_DOWN(orig_addr); unsigned long pfn = PFN_DOWN(orig_addr);
unsigned char *vaddr = phys_to_virt(tlb_addr); unsigned char *vaddr = mem->vaddr + tlb_addr - mem->start;
unsigned int tlb_offset, orig_addr_offset; unsigned int tlb_offset, orig_addr_offset;
if (orig_addr == INVALID_PHYS_ADDR) if (orig_addr == INVALID_PHYS_ADDR)