From 84cb5df859beb99f52b3d3b133ff1f9b5a459558 Mon Sep 17 00:00:00 2001 From: Matthew Rosato Date: Tue, 7 Dec 2021 15:57:34 -0500 Subject: [PATCH] KVM: s390: pci: handle refresh of PCI translations Add a routine that will perform a shadow operation between a guest and host IOAT. A subsequent patch will invoke this in response to an 04 RPCIT instruction intercept. Signed-off-by: Matthew Rosato --- arch/s390/include/asm/kvm_pci.h | 1 + arch/s390/include/asm/pci_dma.h | 1 + arch/s390/kvm/pci.c | 191 ++++++++++++++++++++++++++++++++ arch/s390/kvm/pci.h | 4 +- 4 files changed, 196 insertions(+), 1 deletion(-) diff --git a/arch/s390/include/asm/kvm_pci.h b/arch/s390/include/asm/kvm_pci.h index 254275399f2119..97e3a369135d47 100644 --- a/arch/s390/include/asm/kvm_pci.h +++ b/arch/s390/include/asm/kvm_pci.h @@ -30,6 +30,7 @@ struct kvm_zdev_ioat { struct kvm_zdev { struct zpci_dev *zdev; struct kvm *kvm; + u64 rpcit_count; struct kvm_zdev_ioat ioat; struct zpci_fib fib; }; diff --git a/arch/s390/include/asm/pci_dma.h b/arch/s390/include/asm/pci_dma.h index e1d3c1d3fc8afb..0ca15e5db3d97b 100644 --- a/arch/s390/include/asm/pci_dma.h +++ b/arch/s390/include/asm/pci_dma.h @@ -52,6 +52,7 @@ enum zpci_ioat_dtype { #define ZPCI_TABLE_ENTRIES (ZPCI_TABLE_SIZE / ZPCI_TABLE_ENTRY_SIZE) #define ZPCI_TABLE_PAGES (ZPCI_TABLE_SIZE >> PAGE_SHIFT) #define ZPCI_TABLE_ENTRIES_PAGES (ZPCI_TABLE_ENTRIES * ZPCI_TABLE_PAGES) +#define ZPCI_TABLE_ENTRIES_PER_PAGE (ZPCI_TABLE_ENTRIES / ZPCI_TABLE_PAGES) #define ZPCI_TABLE_BITS 11 #define ZPCI_PT_BITS 8 diff --git a/arch/s390/kvm/pci.c b/arch/s390/kvm/pci.c index a1c0c088133268..858c5ecdc8b98f 100644 --- a/arch/s390/kvm/pci.c +++ b/arch/s390/kvm/pci.c @@ -123,6 +123,195 @@ int kvm_s390_pci_aen_init(u8 nisc) return rc; } +static int dma_shadow_cpu_trans(struct kvm_vcpu *vcpu, unsigned long *entry, + unsigned long *gentry) +{ + unsigned long idx; + struct page *page; + void *gaddr = NULL; + kvm_pfn_t pfn; + gpa_t addr; + int rc = 0; + + if (pt_entry_isvalid(*gentry)) { + /* pin and validate */ + addr = *gentry & ZPCI_PTE_ADDR_MASK; + idx = srcu_read_lock(&vcpu->kvm->srcu); + page = gfn_to_page(vcpu->kvm, gpa_to_gfn(addr)); + srcu_read_unlock(&vcpu->kvm->srcu, idx); + if (is_error_page(page)) + return -EIO; + gaddr = page_to_virt(page) + (addr & ~PAGE_MASK); + } + + if (pt_entry_isvalid(*entry)) { + /* Either we are invalidating, replacing or no-op */ + if (gaddr) { + if ((*entry & ZPCI_PTE_ADDR_MASK) == + (unsigned long)gaddr) { + /* Duplicate */ + kvm_release_pfn_dirty(*entry >> PAGE_SHIFT); + } else { + /* Replace */ + pfn = (*entry >> PAGE_SHIFT); + invalidate_pt_entry(entry); + set_pt_pfaa(entry, gaddr); + validate_pt_entry(entry); + kvm_release_pfn_dirty(pfn); + rc = 1; + } + } else { + /* Invalidate */ + pfn = (*entry >> PAGE_SHIFT); + invalidate_pt_entry(entry); + kvm_release_pfn_dirty(pfn); + rc = 1; + } + } else if (gaddr) { + /* New Entry */ + set_pt_pfaa(entry, gaddr); + validate_pt_entry(entry); + } + + return rc; +} + +unsigned long *dma_walk_guest_cpu_trans(struct kvm_vcpu *vcpu, + struct kvm_zdev_ioat *ioat, + dma_addr_t dma_addr) +{ + unsigned long *rto, *sto, *pto; + unsigned int rtx, rts, sx, px, idx; + struct page *page; + gpa_t addr; + int i; + + /* Pin guest segment table if needed */ + rtx = calc_rtx(dma_addr); + rto = ioat->head[(rtx / ZPCI_TABLE_ENTRIES_PER_PAGE)]; + rts = rtx * ZPCI_TABLE_PAGES; + if (!ioat->seg[rts]) { + if (!reg_entry_isvalid(rto[rtx % ZPCI_TABLE_ENTRIES_PER_PAGE])) + return NULL; + sto = get_rt_sto(rto[rtx % ZPCI_TABLE_ENTRIES_PER_PAGE]); + addr = ((u64)sto & ZPCI_RTE_ADDR_MASK); + idx = srcu_read_lock(&vcpu->kvm->srcu); + for (i = 0; i < ZPCI_TABLE_PAGES; i++) { + page = gfn_to_page(vcpu->kvm, gpa_to_gfn(addr)); + if (is_error_page(page)) { + srcu_read_unlock(&vcpu->kvm->srcu, idx); + return NULL; + } + ioat->seg[rts + i] = page_to_virt(page) + + (addr & ~PAGE_MASK); + addr += PAGE_SIZE; + } + srcu_read_unlock(&vcpu->kvm->srcu, idx); + } + + /* Allocate pin pointers for another segment table if needed */ + if (!ioat->pt[rtx]) { + ioat->pt[rtx] = kcalloc(ZPCI_TABLE_ENTRIES, + (sizeof(unsigned long *)), GFP_KERNEL); + if (!ioat->pt[rtx]) + return NULL; + } + /* Pin guest page table if needed */ + sx = calc_sx(dma_addr); + sto = ioat->seg[(rts + (sx / ZPCI_TABLE_ENTRIES_PER_PAGE))]; + if (!ioat->pt[rtx][sx]) { + if (!reg_entry_isvalid(sto[sx % ZPCI_TABLE_ENTRIES_PER_PAGE])) + return NULL; + pto = get_st_pto(sto[sx % ZPCI_TABLE_ENTRIES_PER_PAGE]); + if (!pto) + return NULL; + addr = ((u64)pto & ZPCI_STE_ADDR_MASK); + idx = srcu_read_lock(&vcpu->kvm->srcu); + page = gfn_to_page(vcpu->kvm, gpa_to_gfn(addr)); + srcu_read_unlock(&vcpu->kvm->srcu, idx); + if (is_error_page(page)) + return NULL; + ioat->pt[rtx][sx] = page_to_virt(page) + (addr & ~PAGE_MASK); + } + pto = ioat->pt[rtx][sx]; + + /* Return guest PTE */ + px = calc_px(dma_addr); + return &pto[px]; +} + + +static int dma_table_shadow(struct kvm_vcpu *vcpu, struct zpci_dev *zdev, + dma_addr_t dma_addr, size_t size) +{ + unsigned int nr_pages = PAGE_ALIGN(size) >> PAGE_SHIFT; + struct kvm_zdev *kzdev = zdev->kzdev; + unsigned long *entry, *gentry; + int i, rc = 0, rc2; + + if (!nr_pages || !kzdev) + return -EINVAL; + + mutex_lock(&kzdev->ioat.lock); + if (!zdev->dma_table || !kzdev->ioat.head[0]) { + rc = -EINVAL; + goto out_unlock; + } + + for (i = 0; i < nr_pages; i++) { + gentry = dma_walk_guest_cpu_trans(vcpu, &kzdev->ioat, dma_addr); + if (!gentry) + continue; + entry = dma_walk_cpu_trans(zdev->dma_table, dma_addr); + + if (!entry) { + rc = -ENOMEM; + goto out_unlock; + } + + rc2 = dma_shadow_cpu_trans(vcpu, entry, gentry); + if (rc2 < 0) { + rc = -EIO; + goto out_unlock; + } + dma_addr += PAGE_SIZE; + rc += rc2; + } + +out_unlock: + mutex_unlock(&kzdev->ioat.lock); + return rc; +} + +int kvm_s390_pci_refresh_trans(struct kvm_vcpu *vcpu, unsigned long req, + unsigned long start, unsigned long size) +{ + struct zpci_dev *zdev; + u32 fh; + int rc; + + /* If the device has a SHM bit on, let userspace take care of this */ + fh = req >> 32; + if ((fh & aift.mdd) != 0) + return -EOPNOTSUPP; + + /* Make sure this is a valid device associated with this guest */ + zdev = get_zdev_by_fh(fh); + if (!zdev || !zdev->kzdev || zdev->kzdev->kvm != vcpu->kvm) + return -EINVAL; + + /* Only proceed if the device is using the assist */ + if (zdev->kzdev->ioat.head[0] == 0) + return -EOPNOTSUPP; + + rc = dma_table_shadow(vcpu, zdev, start, size); + if (rc > 0) + rc = zpci_refresh_trans((u64) zdev->fh << 32, start, size); + zdev->kzdev->rpcit_count++; + + return rc; +} + /* Modify PCI: Register floating adapter interruption forwarding */ static int kvm_zpci_set_airq(struct zpci_dev *zdev) { @@ -590,4 +779,6 @@ void kvm_s390_pci_init(void) { spin_lock_init(&aift.gait_lock); mutex_init(&aift.lock); + + WARN_ON(zpci_get_mdd(&aift.mdd)); } diff --git a/arch/s390/kvm/pci.h b/arch/s390/kvm/pci.h index 3c86888fe1b36c..d252a631b6933d 100644 --- a/arch/s390/kvm/pci.h +++ b/arch/s390/kvm/pci.h @@ -33,6 +33,7 @@ struct zpci_aift { struct kvm_zdev **kzdev; spinlock_t gait_lock; /* Protects the gait, used during AEN forward */ struct mutex lock; /* Protects the other structures in aift */ + u32 mdd; }; static inline struct kvm *kvm_s390_pci_si_to_kvm(struct zpci_aift *aift, @@ -47,7 +48,8 @@ struct zpci_aift *kvm_s390_pci_get_aift(void); int kvm_s390_pci_aen_init(u8 nisc); void kvm_s390_pci_aen_exit(void); - +int kvm_s390_pci_refresh_trans(struct kvm_vcpu *vcpu, unsigned long req, + unsigned long start, unsigned long end); void kvm_s390_pci_init(void); #endif /* __KVM_S390_PCI_H */