mirror of
https://github.com/edk2-porting/linux-next.git
synced 2024-12-15 08:44:14 +08:00
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
commit
cb3f09f9af
@ -28,6 +28,7 @@
|
||||
#include <linux/syscore_ops.h>
|
||||
#include <clocksource/hyperv_timer.h>
|
||||
#include <linux/highmem.h>
|
||||
#include <linux/swiotlb.h>
|
||||
|
||||
int hyperv_init_cpuhp;
|
||||
u64 hv_current_partition_id = ~0ull;
|
||||
@ -36,7 +37,7 @@ EXPORT_SYMBOL_GPL(hv_current_partition_id);
|
||||
void *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 */
|
||||
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. */
|
||||
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;
|
||||
|
||||
clean_guest_os_id:
|
||||
|
||||
@ -287,3 +287,31 @@ int hv_set_mem_host_visibility(unsigned long kbuffer, int pagecount, bool visibl
|
||||
kfree(pfn_array);
|
||||
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);
|
||||
}
|
||||
|
||||
@ -68,15 +68,6 @@ static void hyperv_flush_tlb_multi(const struct cpumask *cpus,
|
||||
|
||||
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 **)
|
||||
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
|
||||
* 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;
|
||||
|
||||
for_each_cpu(cpu, cpus) {
|
||||
@ -131,6 +124,12 @@ static void hyperv_flush_tlb_multi(const struct cpumask *cpus,
|
||||
__set_bit(vcpu, (unsigned long *)
|
||||
&flush->processor_mask);
|
||||
}
|
||||
|
||||
/* nothing to flush if 'processor_mask' ends up being empty */
|
||||
if (!flush->processor_mask) {
|
||||
local_irq_restore(flags);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
|
||||
@ -30,7 +30,7 @@ extern void *hv_hypercall_pg;
|
||||
|
||||
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_add_logical_proc(int node, u32 lp_index, u32 acpi_id);
|
||||
|
||||
@ -11,6 +11,7 @@
|
||||
#include <linux/cc_platform.h>
|
||||
#include <linux/mem_encrypt.h>
|
||||
|
||||
#include <asm/mshyperv.h>
|
||||
#include <asm/processor.h>
|
||||
|
||||
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
|
||||
}
|
||||
|
||||
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)
|
||||
{
|
||||
if (sme_me_mask)
|
||||
return amd_cc_platform_has(attr);
|
||||
|
||||
if (hv_is_isolation_supported())
|
||||
return hyperv_cc_platform_has(attr);
|
||||
|
||||
return false;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(cc_platform_has);
|
||||
|
||||
@ -18,6 +18,7 @@
|
||||
#include <linux/kexec.h>
|
||||
#include <linux/i8253.h>
|
||||
#include <linux/random.h>
|
||||
#include <linux/swiotlb.h>
|
||||
#include <asm/processor.h>
|
||||
#include <asm/hypervisor.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",
|
||||
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);
|
||||
#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) {
|
||||
|
||||
@ -1554,7 +1554,7 @@ int vmbus_request_offers(void)
|
||||
struct vmbus_channel_msginfo *msginfo;
|
||||
int ret;
|
||||
|
||||
msginfo = kmalloc(sizeof(*msginfo) +
|
||||
msginfo = kzalloc(sizeof(*msginfo) +
|
||||
sizeof(struct vmbus_channel_message_header),
|
||||
GFP_KERNEL);
|
||||
if (!msginfo)
|
||||
|
||||
@ -44,10 +44,10 @@ EXPORT_SYMBOL_GPL(hv_vp_index);
|
||||
u32 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);
|
||||
|
||||
void __percpu **hyperv_pcpu_output_arg;
|
||||
void * __percpu *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;
|
||||
}
|
||||
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);
|
||||
|
||||
@ -33,6 +33,7 @@
|
||||
#include <linux/random.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/syscore_ops.h>
|
||||
#include <linux/dma-map-ops.h>
|
||||
#include <clocksource/hyperv_timer.h>
|
||||
#include "hyperv_vmbus.h"
|
||||
|
||||
@ -2078,6 +2079,7 @@ struct hv_device *vmbus_device_create(const guid_t *type,
|
||||
return child_device_obj;
|
||||
}
|
||||
|
||||
static u64 vmbus_dma_mask = DMA_BIT_MASK(64);
|
||||
/*
|
||||
* 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);
|
||||
|
||||
child_device_obj->device.dma_mask = &vmbus_dma_mask;
|
||||
child_device_obj->device.dma_parms = &child_device_obj->dma_parms;
|
||||
return 0;
|
||||
|
||||
err_kset_unregister:
|
||||
|
||||
@ -164,6 +164,7 @@ struct hv_netvsc_packet {
|
||||
u32 total_bytes;
|
||||
u32 send_buf_index;
|
||||
u32 total_data_buflen;
|
||||
struct hv_dma_range *dma_range;
|
||||
};
|
||||
|
||||
#define NETVSC_HASH_KEYLEN 40
|
||||
@ -1074,6 +1075,7 @@ struct netvsc_device {
|
||||
|
||||
/* Receive buffer allocated by us but manages by NetVSP */
|
||||
void *recv_buf;
|
||||
void *recv_original_buf;
|
||||
u32 recv_buf_size; /* allocated bytes */
|
||||
struct vmbus_gpadl recv_buf_gpadl_handle;
|
||||
u32 recv_section_cnt;
|
||||
@ -1082,6 +1084,7 @@ struct netvsc_device {
|
||||
|
||||
/* Send buffer allocated by us */
|
||||
void *send_buf;
|
||||
void *send_original_buf;
|
||||
u32 send_buf_size;
|
||||
struct vmbus_gpadl send_buf_gpadl_handle;
|
||||
u32 send_section_cnt;
|
||||
@ -1731,4 +1734,6 @@ struct rndis_message {
|
||||
#define RETRY_US_HI 10000
|
||||
#define RETRY_MAX 2000 /* >10 sec */
|
||||
|
||||
void netvsc_dma_unmap(struct hv_device *hv_dev,
|
||||
struct hv_netvsc_packet *packet);
|
||||
#endif /* _HYPERV_NET_H */
|
||||
|
||||
@ -153,8 +153,21 @@ static void free_netvsc_device(struct rcu_head *head)
|
||||
int i;
|
||||
|
||||
kfree(nvdev->extension);
|
||||
|
||||
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);
|
||||
|
||||
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;
|
||||
unsigned int buf_size;
|
||||
int i, ret = 0;
|
||||
void *vaddr;
|
||||
|
||||
/* Get receive buffer area. */
|
||||
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;
|
||||
}
|
||||
|
||||
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 */
|
||||
init_packet = &net_device->channel_init_pkt;
|
||||
memset(init_packet, 0, sizeof(struct nvsp_message));
|
||||
@ -475,6 +500,17 @@ static int netvsc_init_buf(struct hv_device *device,
|
||||
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 */
|
||||
init_packet = &net_device->channel_init_pkt;
|
||||
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 */
|
||||
if (likely(skb)) {
|
||||
const struct hv_netvsc_packet *packet
|
||||
struct hv_netvsc_packet *packet
|
||||
= (struct hv_netvsc_packet *)skb->cb;
|
||||
u32 send_index = packet->send_buf_index;
|
||||
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;
|
||||
u64_stats_update_end(&tx_stats->syncp);
|
||||
|
||||
netvsc_dma_unmap(ndev_ctx->device_ctx, packet);
|
||||
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);
|
||||
}
|
||||
|
||||
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(
|
||||
struct hv_device *device,
|
||||
struct hv_netvsc_packet *packet,
|
||||
@ -984,14 +1103,24 @@ static inline int netvsc_send_pkt(
|
||||
|
||||
trace_nvsp_send_pkt(ndev, out_channel, rpkt);
|
||||
|
||||
packet->dma_range = NULL;
|
||||
if (packet->page_buf_cnt) {
|
||||
if (packet->cp_partial)
|
||||
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,
|
||||
pb, packet->page_buf_cnt,
|
||||
&nvmsg, sizeof(nvmsg),
|
||||
req_id);
|
||||
|
||||
if (ret)
|
||||
netvsc_dma_unmap(ndev_ctx->device_ctx, packet);
|
||||
} else {
|
||||
ret = vmbus_sendpacket(out_channel,
|
||||
&nvmsg, sizeof(nvmsg),
|
||||
@ -999,6 +1128,7 @@ static inline int netvsc_send_pkt(
|
||||
VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
|
||||
}
|
||||
|
||||
exit:
|
||||
if (ret == 0) {
|
||||
atomic_inc_return(&nvchan->queue_sends);
|
||||
|
||||
|
||||
@ -2516,6 +2516,7 @@ static int netvsc_probe(struct hv_device *dev,
|
||||
net->netdev_ops = &device_ops;
|
||||
net->ethtool_ops = ðtool_ops;
|
||||
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 */
|
||||
net->needed_headroom = RNDIS_AND_PPI_SIZE;
|
||||
|
||||
@ -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);
|
||||
} else {
|
||||
netdev_err(ndev,
|
||||
|
||||
@ -21,6 +21,8 @@
|
||||
#include <linux/device.h>
|
||||
#include <linux/hyperv.h>
|
||||
#include <linux/blkdev.h>
|
||||
#include <linux/dma-mapping.h>
|
||||
|
||||
#include <scsi/scsi.h>
|
||||
#include <scsi/scsi_cmnd.h>
|
||||
#include <scsi/scsi_host.h>
|
||||
@ -1336,6 +1338,7 @@ static void storvsc_on_channel_callback(void *context)
|
||||
continue;
|
||||
}
|
||||
request = (struct storvsc_cmd_request *)scsi_cmd_priv(scmnd);
|
||||
scsi_dma_unmap(scmnd);
|
||||
}
|
||||
|
||||
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_device *dev = host_dev->dev;
|
||||
struct storvsc_cmd_request *cmd_request = scsi_cmd_priv(scmnd);
|
||||
int i;
|
||||
struct scatterlist *sgl;
|
||||
unsigned int sg_count;
|
||||
struct vmscsi_request *vm_srb;
|
||||
struct vmbus_packet_mpb_array *payload;
|
||||
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);
|
||||
|
||||
sgl = (struct scatterlist *)scsi_sglist(scmnd);
|
||||
sg_count = scsi_sg_count(scmnd);
|
||||
|
||||
length = scsi_bufflen(scmnd);
|
||||
payload = (struct vmbus_packet_mpb_array *)&cmd_request->mpb;
|
||||
payload_sz = sizeof(cmd_request->mpb);
|
||||
|
||||
if (sg_count) {
|
||||
unsigned int hvpgoff, hvpfns_to_add;
|
||||
if (scsi_sg_count(scmnd)) {
|
||||
unsigned long offset_in_hvpg = offset_in_hvpage(sgl->offset);
|
||||
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) {
|
||||
|
||||
@ -1848,21 +1849,24 @@ static int storvsc_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *scmnd)
|
||||
payload->range.len = length;
|
||||
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
|
||||
* and hvpfns_to_add are in units of Hyper-V size
|
||||
* pages. Handling the PAGE_SIZE != HV_HYP_PAGE_SIZE
|
||||
* case also handles values of sgl->offset that are
|
||||
* larger than PAGE_SIZE. Such offsets are handled
|
||||
* even on other than the first sgl entry, provided
|
||||
* they are a multiple of PAGE_SIZE.
|
||||
* Init values for the current sgl entry. hvpfns_to_add
|
||||
* is in units of Hyper-V size pages. Handling the
|
||||
* PAGE_SIZE != HV_HYP_PAGE_SIZE case also handles
|
||||
* values of sgl->offset that are larger than PAGE_SIZE.
|
||||
* Such offsets are handled even on other than the first
|
||||
* sgl entry, provided they are a multiple of PAGE_SIZE.
|
||||
*/
|
||||
hvpgoff = HVPFN_DOWN(sgl->offset);
|
||||
hvpfn = page_to_hvpfn(sg_page(sgl)) + hvpgoff;
|
||||
hvpfns_to_add = HVPFN_UP(sgl->offset + sgl->length) -
|
||||
hvpgoff;
|
||||
hvpfn = HVPFN_DOWN(sg_dma_address(sg));
|
||||
hvpfns_to_add = HVPFN_UP(sg_dma_address(sg) +
|
||||
sg_dma_len(sg)) - hvpfn;
|
||||
|
||||
/*
|
||||
* Fill the next portion of the PFN array with
|
||||
@ -1884,13 +1888,18 @@ static int storvsc_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *scmnd)
|
||||
put_cpu();
|
||||
|
||||
if (ret == -EAGAIN) {
|
||||
if (payload_sz > sizeof(cmd_request->mpb))
|
||||
kfree(payload);
|
||||
/* no more space */
|
||||
return SCSI_MLQUEUE_DEVICE_BUSY;
|
||||
ret = SCSI_MLQUEUE_DEVICE_BUSY;
|
||||
goto err_free_payload;
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
err_free_payload:
|
||||
if (payload_sz > sizeof(cmd_request->mpb))
|
||||
kfree(payload);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
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);
|
||||
spin_lock_init(&stor_device->lock);
|
||||
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;
|
||||
ret = storvsc_connect_to_vsp(device, storvsc_ringbuffer_size, is_fc);
|
||||
|
||||
@ -49,8 +49,8 @@ struct ms_hyperv_info {
|
||||
};
|
||||
extern struct ms_hyperv_info ms_hyperv;
|
||||
|
||||
extern void __percpu **hyperv_pcpu_input_arg;
|
||||
extern void __percpu **hyperv_pcpu_output_arg;
|
||||
extern void * __percpu *hyperv_pcpu_input_arg;
|
||||
extern void * __percpu *hyperv_pcpu_output_arg;
|
||||
|
||||
extern u64 hv_do_hypercall(u64 control, void *inputaddr, void *outputaddr);
|
||||
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);
|
||||
void hyperv_cleanup(void);
|
||||
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 */
|
||||
static inline bool hv_is_hyperv_initialized(void) { return false; }
|
||||
static inline bool hv_is_hibernation_supported(void) { return false; }
|
||||
|
||||
@ -1261,6 +1261,7 @@ struct hv_device {
|
||||
|
||||
struct vmbus_channel *channel;
|
||||
struct kset *channels_kset;
|
||||
struct device_dma_parameters dma_parms;
|
||||
|
||||
/* place holder to keep track of the dir for hv device in debugfs */
|
||||
struct dentry *debug_dir;
|
||||
@ -1583,6 +1584,11 @@ struct hyperv_service_callback {
|
||||
void (*callback)(void *context);
|
||||
};
|
||||
|
||||
struct hv_dma_range {
|
||||
dma_addr_t dma;
|
||||
u32 mapping_size;
|
||||
};
|
||||
|
||||
#define MAX_SRV_VER 0x7ffffff
|
||||
extern bool vmbus_prep_negotiate_resp(struct icmsg_hdr *icmsghdrp, u8 *buf, u32 buflen,
|
||||
const int *fw_version, int fw_vercnt,
|
||||
|
||||
@ -73,6 +73,9 @@ extern enum swiotlb_force swiotlb_force;
|
||||
* @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
|
||||
* 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
|
||||
* @end. For default swiotlb, this is command line adjustable via
|
||||
* setup_io_tlb_npages.
|
||||
@ -92,6 +95,7 @@ extern enum swiotlb_force swiotlb_force;
|
||||
struct io_tlb_mem {
|
||||
phys_addr_t start;
|
||||
phys_addr_t end;
|
||||
void *vaddr;
|
||||
unsigned long nslabs;
|
||||
unsigned long used;
|
||||
unsigned int index;
|
||||
@ -186,4 +190,6 @@ static inline bool is_swiotlb_for_alloc(struct device *dev)
|
||||
}
|
||||
#endif /* CONFIG_DMA_RESTRICTED_POOL */
|
||||
|
||||
extern phys_addr_t swiotlb_unencrypted_base;
|
||||
|
||||
#endif /* __LINUX_SWIOTLB_H */
|
||||
|
||||
@ -50,6 +50,7 @@
|
||||
#include <asm/io.h>
|
||||
#include <asm/dma.h>
|
||||
|
||||
#include <linux/io.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/memblock.h>
|
||||
#include <linux/iommu-helper.h>
|
||||
@ -72,6 +73,8 @@ enum swiotlb_force swiotlb_force;
|
||||
|
||||
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
|
||||
* 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);
|
||||
}
|
||||
|
||||
/*
|
||||
* 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
|
||||
* 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);
|
||||
bytes = PAGE_ALIGN(mem->nslabs << IO_TLB_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,
|
||||
@ -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].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);
|
||||
mem->vaddr = vaddr;
|
||||
return;
|
||||
}
|
||||
|
||||
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;
|
||||
size_t alloc_size = mem->slots[index].alloc_size;
|
||||
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;
|
||||
|
||||
if (orig_addr == INVALID_PHYS_ADDR)
|
||||
|
||||
Loading…
Reference in New Issue
Block a user