KVM: s390: pci: provide routines for enabling/disabling interrupt forwarding (3c5a1b6f) · Commits · EulixOS / Software / Kernel

arch/s390/kvm/pci.c

+247 −0

Original line number	Diff line number	Diff line
		@@ -11,6 +11,7 @@
		#include <linux/pci.h>
		#include <asm/pci.h>
		#include <asm/pci_insn.h>
		#include <asm/pci_io.h>
		#include "pci.h"

		struct zpci_aift *aift;
		@@ -152,6 +153,252 @@ int kvm_s390_pci_aen_init(u8 nisc)
		return rc;
		}

		/* Modify PCI: Register floating adapter interruption forwarding */
		static int kvm_zpci_set_airq(struct zpci_dev *zdev)
		{
		u64 req = ZPCI_CREATE_REQ(zdev->fh, 0, ZPCI_MOD_FC_REG_INT);
		struct zpci_fib fib = {};
		u8 status;

		fib.fmt0.isc = zdev->kzdev->fib.fmt0.isc;
		fib.fmt0.sum = 1; /* enable summary notifications */
		fib.fmt0.noi = airq_iv_end(zdev->aibv);
		fib.fmt0.aibv = virt_to_phys(zdev->aibv->vector);
		fib.fmt0.aibvo = 0;
		fib.fmt0.aisb = virt_to_phys(aift->sbv->vector + (zdev->aisb / 64) * 8);
		fib.fmt0.aisbo = zdev->aisb & 63;
		fib.gd = zdev->gisa;

		return zpci_mod_fc(req, &fib, &status) ? -EIO : 0;
		}

		/* Modify PCI: Unregister floating adapter interruption forwarding */
		static int kvm_zpci_clear_airq(struct zpci_dev *zdev)
		{
		u64 req = ZPCI_CREATE_REQ(zdev->fh, 0, ZPCI_MOD_FC_DEREG_INT);
		struct zpci_fib fib = {};
		u8 cc, status;

		fib.gd = zdev->gisa;

		cc = zpci_mod_fc(req, &fib, &status);
		if (cc == 3 \|\| (cc == 1 && status == 24))
		/* Function already gone or IRQs already deregistered. */
		cc = 0;

		return cc ? -EIO : 0;
		}

		static inline void unaccount_mem(unsigned long nr_pages)
		{
		struct user_struct *user = get_uid(current_user());

		if (user)
		atomic_long_sub(nr_pages, &user->locked_vm);
		if (current->mm)
		atomic64_sub(nr_pages, &current->mm->pinned_vm);
		}

		static inline int account_mem(unsigned long nr_pages)
		{
		struct user_struct *user = get_uid(current_user());
		unsigned long page_limit, cur_pages, new_pages;

		page_limit = rlimit(RLIMIT_MEMLOCK) >> PAGE_SHIFT;

		do {
		cur_pages = atomic_long_read(&user->locked_vm);
		new_pages = cur_pages + nr_pages;
		if (new_pages > page_limit)
		return -ENOMEM;
		} while (atomic_long_cmpxchg(&user->locked_vm, cur_pages,
		new_pages) != cur_pages);

		atomic64_add(nr_pages, &current->mm->pinned_vm);

		return 0;
		}

		static int kvm_s390_pci_aif_enable(struct zpci_dev zdev, struct zpci_fib fib,
		bool assist)
		{
		struct page pages[1], aibv_page, *aisb_page = NULL;
		unsigned int msi_vecs, idx;
		struct zpci_gaite *gaite;
		unsigned long hva, bit;
		struct kvm *kvm;
		phys_addr_t gaddr;
		int rc = 0, gisc, npages, pcount = 0;

		/*
		* Interrupt forwarding is only applicable if the device is already
		* enabled for interpretation
		*/
		if (zdev->gisa == 0)
		return -EINVAL;

		kvm = zdev->kzdev->kvm;
		msi_vecs = min_t(unsigned int, fib->fmt0.noi, zdev->max_msi);

		/* Get the associated forwarding ISC - if invalid, return the error */
		gisc = kvm_s390_gisc_register(kvm, fib->fmt0.isc);
		if (gisc < 0)
		return gisc;

		/* Replace AIBV address */
		idx = srcu_read_lock(&kvm->srcu);
		hva = gfn_to_hva(kvm, gpa_to_gfn((gpa_t)fib->fmt0.aibv));
		npages = pin_user_pages_fast(hva, 1, FOLL_WRITE \| FOLL_LONGTERM, pages);
		srcu_read_unlock(&kvm->srcu, idx);
		if (npages < 1) {
		rc = -EIO;
		goto out;
		}
		aibv_page = pages[0];
		pcount++;
		gaddr = page_to_phys(aibv_page) + (fib->fmt0.aibv & ~PAGE_MASK);
		fib->fmt0.aibv = gaddr;

		/* Pin the guest AISB if one was specified */
		if (fib->fmt0.sum == 1) {
		idx = srcu_read_lock(&kvm->srcu);
		hva = gfn_to_hva(kvm, gpa_to_gfn((gpa_t)fib->fmt0.aisb));
		npages = pin_user_pages_fast(hva, 1, FOLL_WRITE \| FOLL_LONGTERM,
		pages);
		srcu_read_unlock(&kvm->srcu, idx);
		if (npages < 1) {
		rc = -EIO;
		goto unpin1;
		}
		aisb_page = pages[0];
		pcount++;
		}

		/* Account for pinned pages, roll back on failure */
		if (account_mem(pcount))
		goto unpin2;

		/* AISB must be allocated before we can fill in GAITE */
		mutex_lock(&aift->aift_lock);
		bit = airq_iv_alloc_bit(aift->sbv);
		if (bit == -1UL)
		goto unlock;
		zdev->aisb = bit; /* store the summary bit number */
		zdev->aibv = airq_iv_create(msi_vecs, AIRQ_IV_DATA \|
		AIRQ_IV_BITLOCK \|
		AIRQ_IV_GUESTVEC,
		phys_to_virt(fib->fmt0.aibv));

		spin_lock_irq(&aift->gait_lock);
		gaite = (struct zpci_gaite )aift->gait + (zdev->aisb
		sizeof(struct zpci_gaite));

		/* If assist not requested, host will get all alerts */
		if (assist)
		gaite->gisa = (u32)virt_to_phys(&kvm->arch.sie_page2->gisa);
		else
		gaite->gisa = 0;

		gaite->gisc = fib->fmt0.isc;
		gaite->count++;
		gaite->aisbo = fib->fmt0.aisbo;
		gaite->aisb = virt_to_phys(page_address(aisb_page) + (fib->fmt0.aisb &
		~PAGE_MASK));
		aift->kzdev[zdev->aisb] = zdev->kzdev;
		spin_unlock_irq(&aift->gait_lock);

		/* Update guest FIB for re-issue */
		fib->fmt0.aisbo = zdev->aisb & 63;
		fib->fmt0.aisb = virt_to_phys(aift->sbv->vector + (zdev->aisb / 64) * 8);
		fib->fmt0.isc = gisc;

		/* Save some guest fib values in the host for later use */
		zdev->kzdev->fib.fmt0.isc = fib->fmt0.isc;
		zdev->kzdev->fib.fmt0.aibv = fib->fmt0.aibv;
		mutex_unlock(&aift->aift_lock);

		/* Issue the clp to setup the irq now */
		rc = kvm_zpci_set_airq(zdev);
		return rc;

		unlock:
		mutex_unlock(&aift->aift_lock);
		unpin2:
		if (fib->fmt0.sum == 1)
		unpin_user_page(aisb_page);
		unpin1:
		unpin_user_page(aibv_page);
		out:
		return rc;
		}

		static int kvm_s390_pci_aif_disable(struct zpci_dev *zdev, bool force)
		{
		struct kvm_zdev *kzdev = zdev->kzdev;
		struct zpci_gaite *gaite;
		struct page vpage = NULL, spage = NULL;
		int rc, pcount = 0;
		u8 isc;

		if (zdev->gisa == 0)
		return -EINVAL;

		mutex_lock(&aift->aift_lock);

		/*
		* If the clear fails due to an error, leave now unless we know this
		* device is about to go away (force) -- In that case clear the GAITE
		* regardless.
		*/
		rc = kvm_zpci_clear_airq(zdev);
		if (rc && !force)
		goto out;

		if (zdev->kzdev->fib.fmt0.aibv == 0)
		goto out;
		spin_lock_irq(&aift->gait_lock);
		gaite = (struct zpci_gaite )aift->gait + (zdev->aisb
		sizeof(struct zpci_gaite));
		isc = gaite->gisc;
		gaite->count--;
		if (gaite->count == 0) {
		/* Release guest AIBV and AISB */
		vpage = phys_to_page(kzdev->fib.fmt0.aibv);
		if (gaite->aisb != 0)
		spage = phys_to_page(gaite->aisb);
		/* Clear the GAIT entry */
		gaite->aisb = 0;
		gaite->gisc = 0;
		gaite->aisbo = 0;
		gaite->gisa = 0;
		aift->kzdev[zdev->aisb] = 0;
		/* Clear zdev info */
		airq_iv_free_bit(aift->sbv, zdev->aisb);
		airq_iv_release(zdev->aibv);
		zdev->aisb = 0;
		zdev->aibv = NULL;
		}
		spin_unlock_irq(&aift->gait_lock);
		kvm_s390_gisc_unregister(kzdev->kvm, isc);
		kzdev->fib.fmt0.isc = 0;
		kzdev->fib.fmt0.aibv = 0;

		if (vpage) {
		unpin_user_page(vpage);
		pcount++;
		}
		if (spage) {
		unpin_user_page(spage);
		pcount++;
		}
		if (pcount > 0)
		unaccount_mem(pcount);
		out:
		mutex_unlock(&aift->aift_lock);

		return rc;
		}

		static int kvm_s390_pci_dev_open(struct zpci_dev *zdev)
		{
		struct kvm_zdev *kzdev;

arch/s390/kvm/pci.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -20,6 +20,7 @@
		struct kvm_zdev {
		struct zpci_dev *zdev;
		struct kvm *kvm;
		struct zpci_fib fib;
		};

		struct zpci_gaite {

arch/s390/pci/pci_insn.c

+1 −0

Original line number	Diff line number	Diff line
		@@ -92,6 +92,7 @@ u8 zpci_mod_fc(u64 req, struct zpci_fib fib, u8 status)

		return cc;
		}
		EXPORT_SYMBOL_GPL(zpci_mod_fc);

		/* Refresh PCI Translations */
		static inline u8 __rpcit(u64 fn, u64 addr, u64 range, u8 *status)

include/linux/sched/user.h

+2 −1

Original line number	Diff line number	Diff line
		@@ -24,7 +24,8 @@ struct user_struct {
		kuid_t uid;

		#if defined(CONFIG_PERF_EVENTS) \|\| defined(CONFIG_BPF_SYSCALL) \|\| \
		defined(CONFIG_NET) \|\| defined(CONFIG_IO_URING)
		defined(CONFIG_NET) \|\| defined(CONFIG_IO_URING) \|\| \
		defined(CONFIG_VFIO_PCI_ZDEV_KVM)
		atomic_long_t locked_vm;
		#endif
		#ifdef CONFIG_WATCH_QUEUE