x86/hv/mshv_vtl: Implement MAP_REDIRECTED_DEVICE_INTERRUPT

The MAP_REDIRECTED_DEVICE_INTERRUPT IOCTL maps an interrupt of a VTL0
guest to a hadware vector interrupt in the VTL2 kernel.

On x86, we reserve a block of 32 vectors starting at FIRST_HV_VTL_
REDIRECTED_VECTOR for this mapping.

Keep track of this redirection using an array hardware interrupt vectors
and their mapping to a proxy interrupt, if any. Note that the array starts
at zero but the first hardware vector is FIRST_HV_VTL_REDIRECTED_VECTOR.
Account for this offset as needed.

The array of mapped proxy interrupts is only updated when processing the
IOCTL. It is only read during interrupts. Serialize access using a
seqcount. This allows lockless read access for cases in which multiple
CPUs want to access the mapping data structures.

Since we are using a seqcount, writers cannot be preempted. Protect write
access using a spinlock.

Signed-off-by: Ricardo Neri <[email protected]>
---
Changes since v1:
 * Used a seqcount for serialization.

Author: ricardon

arch/x86/kernel/cpu/mshyperv.c

@@ -17,6 +17,7 @@
 #include <linux/irq.h>
 #include <linux/kexec.h>
 #include <linux/random.h>
+#include <linux/seqlock.h>
 #include <asm/processor.h>
 #include <asm/hypervisor.h>
 #include <asm/hyperv-tlfs.h>
@@ -166,6 +167,15 @@ DEFINE_IDTENTRY_SYSVEC(sysvec_hyperv_stimer0)
 }
 
 #ifdef CONFIG_HYPERV_VTL_MODE
+#define REDIRECTED_VECTOR_UNDEF 0xffff
+static u32 redirected_proxy_intr[NR_HV_VTL_REDIRECTED_VECTORS] = {
+	[0 ... NR_HV_VTL_REDIRECTED_VECTORS - 1] = REDIRECTED_VECTOR_UNDEF };
+
+static DEFINE_RAW_SPINLOCK(redirected_proxy_intr_lock);
+static seqcount_raw_spinlock_t redirected_proxy_intr_seq =
+	SEQCNT_RAW_SPINLOCK_ZERO(redirected_proxy_intr_seq,
+				 &redirected_proxy_intr_lock);
+
 DEFINE_IDTENTRY_IRQ(hv_vtl_redirected_interrupt)
 {
 	apic_eoi();
@@ -715,6 +725,83 @@ static bool hv_sev_es_hcall_finish(struct ghcb *ghcb, struct pt_regs *regs)
 }
 #endif
 
+#ifdef CONFIG_HYPERV_VTL_MODE
+static int find_redirected_proxy_intr(u32 vector)
+{
+	int v;
+
+	for (v = 0; v < ARRAY_SIZE(redirected_proxy_intr); v++) {
+		if (redirected_proxy_intr[v] == vector)
+			return v;
+	}
+
+	return -ENOENT;
+}
+
+static void redirected_proxy_intr_write_lock(unsigned long *flags)
+{
+	raw_spin_lock_irqsave(&redirected_proxy_intr_lock, *flags);
+	write_seqcount_begin(&redirected_proxy_intr_seq);
+}
+
+static void redirected_proxy_intr_write_unlock(unsigned long *flags)
+{
+	write_seqcount_end(&redirected_proxy_intr_seq);
+	raw_spin_unlock_irqrestore(&redirected_proxy_intr_lock, *flags);
+}
+
+int mshv_vtl_map_redirected_intr(u32 proxy_vector)
+{
+	int vec_idx;
+	unsigned long flags;
+
+	if (proxy_vector >= NR_VECTORS)
+		return -EINVAL;
+
+	redirected_proxy_intr_write_lock(&flags);
+
+	/* Check if the vector is already redirected. */
+	vec_idx = find_redirected_proxy_intr(proxy_vector);
+	if (vec_idx >= 0) {
+		redirected_proxy_intr_write_unlock(&flags);
+		/* Caller expects the hardware vector, not the array index. */
+		return vec_idx + FIRST_HV_VTL_REDIRECTED_VECTOR;
+	}
+
+	/* Now that we know it is not redirected, find a free slot. */
+	vec_idx = find_redirected_proxy_intr(REDIRECTED_VECTOR_UNDEF);
+	if (vec_idx < 0) {
+		redirected_proxy_intr_write_unlock(&flags);
+		return -EBUSY;
+	}
+
+	redirected_proxy_intr[vec_idx] = proxy_vector;
+
+	redirected_proxy_intr_write_unlock(&flags);
+
+	/* Caller expects the hardware vector, not the array index. */
+	return vec_idx + FIRST_HV_VTL_REDIRECTED_VECTOR;
+}
+
+int mshv_vtl_unmap_redirected_intr(u32 hw_vector)
+{
+	unsigned long flags;
+	int vec_idx = hw_vector - FIRST_HV_VTL_REDIRECTED_VECTOR;
+
+	if (vec_idx < 0 || vec_idx >= ARRAY_SIZE(redirected_proxy_intr))
+		return -EINVAL;
+
+	if (redirected_proxy_intr[vec_idx] == REDIRECTED_VECTOR_UNDEF)
+		return -ENOENT;
+
+	redirected_proxy_intr_write_lock(&flags);
+	redirected_proxy_intr[vec_idx] = REDIRECTED_VECTOR_UNDEF;
+	redirected_proxy_intr_write_unlock(&flags);
+
+	return 0;
+}
+#endif /* CONFIG_HYPERV_VTL_MODE */
+
 const __initconst struct hypervisor_x86 x86_hyper_ms_hyperv = {
 	.name			= "Microsoft Hyper-V",
 	.detect			= ms_hyperv_platform,