2015-03-24 14:54:56 +00:00
|
|
|
/*
|
|
|
|
* Copyright © 2015 Intel Corporation.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
|
|
* under the terms and conditions of the GNU General Public License,
|
|
|
|
* version 2, as published by the Free Software Foundation.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope it will be useful, but WITHOUT
|
|
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
|
|
|
* more details.
|
|
|
|
*
|
|
|
|
* Authors: David Woodhouse <dwmw2@infradead.org>
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/intel-iommu.h>
|
2015-09-09 10:40:47 +00:00
|
|
|
#include <linux/mmu_notifier.h>
|
|
|
|
#include <linux/sched.h>
|
2017-02-08 17:51:29 +00:00
|
|
|
#include <linux/sched/mm.h>
|
2015-09-09 10:40:47 +00:00
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/intel-svm.h>
|
|
|
|
#include <linux/rculist.h>
|
|
|
|
#include <linux/pci.h>
|
|
|
|
#include <linux/pci-ats.h>
|
2015-10-07 22:35:18 +00:00
|
|
|
#include <linux/dmar.h>
|
|
|
|
#include <linux/interrupt.h>
|
2017-08-08 20:29:27 +00:00
|
|
|
#include <asm/page.h>
|
2015-10-07 22:35:18 +00:00
|
|
|
|
2017-12-20 19:59:27 +00:00
|
|
|
#define PASID_ENTRY_P BIT_ULL(0)
|
|
|
|
#define PASID_ENTRY_FLPM_5LP BIT_ULL(9)
|
|
|
|
#define PASID_ENTRY_SRE BIT_ULL(11)
|
|
|
|
|
2015-10-07 22:35:18 +00:00
|
|
|
static irqreturn_t prq_event_thread(int irq, void *d);
|
2015-09-09 10:40:47 +00:00
|
|
|
|
|
|
|
struct pasid_entry {
|
|
|
|
u64 val;
|
|
|
|
};
|
2015-03-24 14:54:56 +00:00
|
|
|
|
2015-10-13 13:11:13 +00:00
|
|
|
struct pasid_state_entry {
|
|
|
|
u64 val;
|
|
|
|
};
|
|
|
|
|
2015-03-24 14:54:56 +00:00
|
|
|
int intel_svm_alloc_pasid_tables(struct intel_iommu *iommu)
|
|
|
|
{
|
|
|
|
struct page *pages;
|
|
|
|
int order;
|
|
|
|
|
2017-12-20 19:59:25 +00:00
|
|
|
if (cpu_feature_enabled(X86_FEATURE_GBPAGES) &&
|
|
|
|
!cap_fl1gp_support(iommu->cap))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2017-12-20 19:59:26 +00:00
|
|
|
if (cpu_feature_enabled(X86_FEATURE_LA57) &&
|
|
|
|
!cap_5lp_support(iommu->cap))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2016-09-12 02:49:11 +00:00
|
|
|
/* Start at 2 because it's defined as 2^(1+PSS) */
|
|
|
|
iommu->pasid_max = 2 << ecap_pss(iommu->ecap);
|
|
|
|
|
|
|
|
/* Eventually I'm promised we will get a multi-level PASID table
|
|
|
|
* and it won't have to be physically contiguous. Until then,
|
|
|
|
* limit the size because 8MiB contiguous allocations can be hard
|
|
|
|
* to come by. The limit of 0x20000, which is 1MiB for each of
|
|
|
|
* the PASID and PASID-state tables, is somewhat arbitrary. */
|
|
|
|
if (iommu->pasid_max > 0x20000)
|
|
|
|
iommu->pasid_max = 0x20000;
|
|
|
|
|
|
|
|
order = get_order(sizeof(struct pasid_entry) * iommu->pasid_max);
|
2015-03-24 14:54:56 +00:00
|
|
|
pages = alloc_pages(GFP_KERNEL | __GFP_ZERO, order);
|
|
|
|
if (!pages) {
|
|
|
|
pr_warn("IOMMU: %s: Failed to allocate PASID table\n",
|
|
|
|
iommu->name);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
iommu->pasid_table = page_address(pages);
|
|
|
|
pr_info("%s: Allocated order %d PASID table.\n", iommu->name, order);
|
|
|
|
|
|
|
|
if (ecap_dis(iommu->ecap)) {
|
2016-09-12 02:49:11 +00:00
|
|
|
/* Just making it explicit... */
|
|
|
|
BUILD_BUG_ON(sizeof(struct pasid_entry) != sizeof(struct pasid_state_entry));
|
2015-03-24 14:54:56 +00:00
|
|
|
pages = alloc_pages(GFP_KERNEL | __GFP_ZERO, order);
|
|
|
|
if (pages)
|
|
|
|
iommu->pasid_state_table = page_address(pages);
|
|
|
|
else
|
|
|
|
pr_warn("IOMMU: %s: Failed to allocate PASID state table\n",
|
|
|
|
iommu->name);
|
|
|
|
}
|
|
|
|
|
2015-09-09 10:40:47 +00:00
|
|
|
idr_init(&iommu->pasid_idr);
|
|
|
|
|
2015-03-24 14:54:56 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int intel_svm_free_pasid_tables(struct intel_iommu *iommu)
|
|
|
|
{
|
2016-09-12 02:49:11 +00:00
|
|
|
int order = get_order(sizeof(struct pasid_entry) * iommu->pasid_max);
|
2015-03-24 14:54:56 +00:00
|
|
|
|
|
|
|
if (iommu->pasid_table) {
|
|
|
|
free_pages((unsigned long)iommu->pasid_table, order);
|
|
|
|
iommu->pasid_table = NULL;
|
|
|
|
}
|
|
|
|
if (iommu->pasid_state_table) {
|
|
|
|
free_pages((unsigned long)iommu->pasid_state_table, order);
|
|
|
|
iommu->pasid_state_table = NULL;
|
|
|
|
}
|
2015-09-09 10:40:47 +00:00
|
|
|
idr_destroy(&iommu->pasid_idr);
|
2015-03-24 14:54:56 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2015-09-09 10:40:47 +00:00
|
|
|
|
2015-10-07 22:35:18 +00:00
|
|
|
#define PRQ_ORDER 0
|
|
|
|
|
|
|
|
int intel_svm_enable_prq(struct intel_iommu *iommu)
|
|
|
|
{
|
|
|
|
struct page *pages;
|
|
|
|
int irq, ret;
|
|
|
|
|
|
|
|
pages = alloc_pages(GFP_KERNEL | __GFP_ZERO, PRQ_ORDER);
|
|
|
|
if (!pages) {
|
|
|
|
pr_warn("IOMMU: %s: Failed to allocate page request queue\n",
|
|
|
|
iommu->name);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
iommu->prq = page_address(pages);
|
|
|
|
|
|
|
|
irq = dmar_alloc_hwirq(DMAR_UNITS_SUPPORTED + iommu->seq_id, iommu->node, iommu);
|
|
|
|
if (irq <= 0) {
|
|
|
|
pr_err("IOMMU: %s: Failed to create IRQ vector for page request queue\n",
|
|
|
|
iommu->name);
|
|
|
|
ret = -EINVAL;
|
|
|
|
err:
|
|
|
|
free_pages((unsigned long)iommu->prq, PRQ_ORDER);
|
|
|
|
iommu->prq = NULL;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
iommu->pr_irq = irq;
|
|
|
|
|
|
|
|
snprintf(iommu->prq_name, sizeof(iommu->prq_name), "dmar%d-prq", iommu->seq_id);
|
|
|
|
|
|
|
|
ret = request_threaded_irq(irq, NULL, prq_event_thread, IRQF_ONESHOT,
|
|
|
|
iommu->prq_name, iommu);
|
|
|
|
if (ret) {
|
|
|
|
pr_err("IOMMU: %s: Failed to request IRQ for page request queue\n",
|
|
|
|
iommu->name);
|
|
|
|
dmar_free_hwirq(irq);
|
2017-12-20 16:48:56 +00:00
|
|
|
iommu->pr_irq = 0;
|
2015-10-07 22:35:18 +00:00
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
dmar_writeq(iommu->reg + DMAR_PQH_REG, 0ULL);
|
|
|
|
dmar_writeq(iommu->reg + DMAR_PQT_REG, 0ULL);
|
|
|
|
dmar_writeq(iommu->reg + DMAR_PQA_REG, virt_to_phys(iommu->prq) | PRQ_ORDER);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int intel_svm_finish_prq(struct intel_iommu *iommu)
|
|
|
|
{
|
|
|
|
dmar_writeq(iommu->reg + DMAR_PQH_REG, 0ULL);
|
|
|
|
dmar_writeq(iommu->reg + DMAR_PQT_REG, 0ULL);
|
|
|
|
dmar_writeq(iommu->reg + DMAR_PQA_REG, 0ULL);
|
|
|
|
|
2017-12-20 16:48:56 +00:00
|
|
|
if (iommu->pr_irq) {
|
|
|
|
free_irq(iommu->pr_irq, iommu);
|
|
|
|
dmar_free_hwirq(iommu->pr_irq);
|
|
|
|
iommu->pr_irq = 0;
|
|
|
|
}
|
2015-10-07 22:35:18 +00:00
|
|
|
|
|
|
|
free_pages((unsigned long)iommu->prq, PRQ_ORDER);
|
|
|
|
iommu->prq = NULL;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-09-09 10:40:47 +00:00
|
|
|
static void intel_flush_svm_range_dev (struct intel_svm *svm, struct intel_svm_dev *sdev,
|
2015-10-20 14:52:13 +00:00
|
|
|
unsigned long address, unsigned long pages, int ih, int gl)
|
2015-09-09 10:40:47 +00:00
|
|
|
{
|
|
|
|
struct qi_desc desc;
|
|
|
|
|
2015-10-20 14:52:13 +00:00
|
|
|
if (pages == -1) {
|
2015-10-16 18:36:53 +00:00
|
|
|
/* For global kernel pages we have to flush them in *all* PASIDs
|
|
|
|
* because that's the only option the hardware gives us. Despite
|
|
|
|
* the fact that they are actually only accessible through one. */
|
|
|
|
if (gl)
|
|
|
|
desc.low = QI_EIOTLB_PASID(svm->pasid) | QI_EIOTLB_DID(sdev->did) |
|
|
|
|
QI_EIOTLB_GRAN(QI_GRAN_ALL_ALL) | QI_EIOTLB_TYPE;
|
|
|
|
else
|
|
|
|
desc.low = QI_EIOTLB_PASID(svm->pasid) | QI_EIOTLB_DID(sdev->did) |
|
|
|
|
QI_EIOTLB_GRAN(QI_GRAN_NONG_PASID) | QI_EIOTLB_TYPE;
|
2015-09-09 10:40:47 +00:00
|
|
|
desc.high = 0;
|
|
|
|
} else {
|
2015-10-20 14:52:13 +00:00
|
|
|
int mask = ilog2(__roundup_pow_of_two(pages));
|
|
|
|
|
2015-09-09 10:40:47 +00:00
|
|
|
desc.low = QI_EIOTLB_PASID(svm->pasid) | QI_EIOTLB_DID(sdev->did) |
|
|
|
|
QI_EIOTLB_GRAN(QI_GRAN_PSI_PASID) | QI_EIOTLB_TYPE;
|
2015-10-16 18:36:53 +00:00
|
|
|
desc.high = QI_EIOTLB_ADDR(address) | QI_EIOTLB_GL(gl) |
|
2015-09-09 10:40:47 +00:00
|
|
|
QI_EIOTLB_IH(ih) | QI_EIOTLB_AM(mask);
|
|
|
|
}
|
|
|
|
qi_submit_sync(&desc, svm->iommu);
|
|
|
|
|
|
|
|
if (sdev->dev_iotlb) {
|
|
|
|
desc.low = QI_DEV_EIOTLB_PASID(svm->pasid) | QI_DEV_EIOTLB_SID(sdev->sid) |
|
|
|
|
QI_DEV_EIOTLB_QDEP(sdev->qdep) | QI_DEIOTLB_TYPE;
|
2015-10-20 14:52:13 +00:00
|
|
|
if (pages == -1) {
|
|
|
|
desc.high = QI_DEV_EIOTLB_ADDR(-1ULL >> 1) | QI_DEV_EIOTLB_SIZE;
|
|
|
|
} else if (pages > 1) {
|
|
|
|
/* The least significant zero bit indicates the size. So,
|
|
|
|
* for example, an "address" value of 0x12345f000 will
|
|
|
|
* flush from 0x123440000 to 0x12347ffff (256KiB). */
|
|
|
|
unsigned long last = address + ((unsigned long)(pages - 1) << VTD_PAGE_SHIFT);
|
2018-02-22 09:54:55 +00:00
|
|
|
unsigned long mask = __rounddown_pow_of_two(address ^ last);
|
2015-10-20 14:52:13 +00:00
|
|
|
|
|
|
|
desc.high = QI_DEV_EIOTLB_ADDR((address & ~mask) | (mask - 1)) | QI_DEV_EIOTLB_SIZE;
|
2015-09-09 10:40:47 +00:00
|
|
|
} else {
|
|
|
|
desc.high = QI_DEV_EIOTLB_ADDR(address);
|
|
|
|
}
|
|
|
|
qi_submit_sync(&desc, svm->iommu);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void intel_flush_svm_range(struct intel_svm *svm, unsigned long address,
|
2015-10-20 14:52:13 +00:00
|
|
|
unsigned long pages, int ih, int gl)
|
2015-09-09 10:40:47 +00:00
|
|
|
{
|
|
|
|
struct intel_svm_dev *sdev;
|
|
|
|
|
2015-10-13 13:11:13 +00:00
|
|
|
/* Try deferred invalidate if available */
|
|
|
|
if (svm->iommu->pasid_state_table &&
|
|
|
|
!cmpxchg64(&svm->iommu->pasid_state_table[svm->pasid].val, 0, 1ULL << 63))
|
|
|
|
return;
|
|
|
|
|
2015-09-09 10:40:47 +00:00
|
|
|
rcu_read_lock();
|
|
|
|
list_for_each_entry_rcu(sdev, &svm->devs, list)
|
2015-10-16 18:36:53 +00:00
|
|
|
intel_flush_svm_range_dev(svm, sdev, address, pages, ih, gl);
|
2015-09-09 10:40:47 +00:00
|
|
|
rcu_read_unlock();
|
|
|
|
}
|
|
|
|
|
|
|
|
static void intel_change_pte(struct mmu_notifier *mn, struct mm_struct *mm,
|
|
|
|
unsigned long address, pte_t pte)
|
|
|
|
{
|
|
|
|
struct intel_svm *svm = container_of(mn, struct intel_svm, notifier);
|
|
|
|
|
2015-10-16 18:36:53 +00:00
|
|
|
intel_flush_svm_range(svm, address, 1, 1, 0);
|
2015-09-09 10:40:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Pages have been freed at this point */
|
|
|
|
static void intel_invalidate_range(struct mmu_notifier *mn,
|
|
|
|
struct mm_struct *mm,
|
|
|
|
unsigned long start, unsigned long end)
|
|
|
|
{
|
|
|
|
struct intel_svm *svm = container_of(mn, struct intel_svm, notifier);
|
|
|
|
|
|
|
|
intel_flush_svm_range(svm, start,
|
2015-10-16 18:36:53 +00:00
|
|
|
(end - start + PAGE_SIZE - 1) >> VTD_PAGE_SHIFT, 0, 0);
|
2015-09-09 10:40:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-10-24 19:06:39 +00:00
|
|
|
static void intel_flush_pasid_dev(struct intel_svm *svm, struct intel_svm_dev *sdev, int pasid)
|
2015-09-09 10:40:47 +00:00
|
|
|
{
|
|
|
|
struct qi_desc desc;
|
|
|
|
|
|
|
|
desc.high = 0;
|
2015-10-24 19:06:39 +00:00
|
|
|
desc.low = QI_PC_TYPE | QI_PC_DID(sdev->did) | QI_PC_PASID_SEL | QI_PC_PASID(pasid);
|
2015-09-09 10:40:47 +00:00
|
|
|
|
|
|
|
qi_submit_sync(&desc, svm->iommu);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void intel_mm_release(struct mmu_notifier *mn, struct mm_struct *mm)
|
|
|
|
{
|
|
|
|
struct intel_svm *svm = container_of(mn, struct intel_svm, notifier);
|
iommu/vt-d: Fix mm refcounting to hold mm_count not mm_users
Holding mm_users works OK for graphics, which was the first user of SVM
with VT-d. However, it works less well for other devices, where we actually
do a mmap() from the file descriptor to which the SVM PASID state is tied.
In this case on process exit we end up with a recursive reference count:
- The MM remains alive until the file is closed and the driver's release()
call ends up unbinding the PASID.
- The VMA corresponding to the mmap() remains intact until the MM is
destroyed.
- Thus the file isn't closed, even when exit_files() runs, because the
VMA is still holding a reference to it. And the MM remains alive…
To address this issue, we *stop* holding mm_users while the PASID is bound.
We already hold mm_count by virtue of the MMU notifier, and that can be
made to be sufficient.
It means that for a period during process exit, the fun part of mmput()
has happened and exit_mmap() has been called so the MM is basically
defunct. But the PGD still exists and the PASID is still bound to it.
During this period, we have to be very careful — exit_mmap() doesn't use
mm->mmap_sem because it doesn't expect anyone else to be touching the MM
(quite reasonably, since mm_users is zero). So we also need to fix the
fault handler to just report failure if mm_users is already zero, and to
temporarily bump mm_users while handling any faults.
Additionally, exit_mmap() calls mmu_notifier_release() *before* it tears
down the page tables, which is too early for us to flush the IOTLB for
this PASID. And __mmu_notifier_release() removes every notifier from the
list, so when exit_mmap() finally *does* tear down the mappings and
clear the page tables, we don't get notified. So we work around this by
clearing the PASID table entry in our MMU notifier release() callback.
That way, the hardware *can't* get any pages back from the page tables
before they get cleared.
Hardware designers have confirmed that the resulting 'PASID not present'
faults should be handled just as gracefully as 'page not present' faults,
the important criterion being that they don't perturb the operation for
any *other* PASID in the system.
Signed-off-by: David Woodhouse <David.Woodhouse@intel.com>
Cc: stable@vger.kernel.org
2016-01-12 19:18:06 +00:00
|
|
|
struct intel_svm_dev *sdev;
|
2015-09-09 10:40:47 +00:00
|
|
|
|
iommu/vt-d: Fix mm refcounting to hold mm_count not mm_users
Holding mm_users works OK for graphics, which was the first user of SVM
with VT-d. However, it works less well for other devices, where we actually
do a mmap() from the file descriptor to which the SVM PASID state is tied.
In this case on process exit we end up with a recursive reference count:
- The MM remains alive until the file is closed and the driver's release()
call ends up unbinding the PASID.
- The VMA corresponding to the mmap() remains intact until the MM is
destroyed.
- Thus the file isn't closed, even when exit_files() runs, because the
VMA is still holding a reference to it. And the MM remains alive…
To address this issue, we *stop* holding mm_users while the PASID is bound.
We already hold mm_count by virtue of the MMU notifier, and that can be
made to be sufficient.
It means that for a period during process exit, the fun part of mmput()
has happened and exit_mmap() has been called so the MM is basically
defunct. But the PGD still exists and the PASID is still bound to it.
During this period, we have to be very careful — exit_mmap() doesn't use
mm->mmap_sem because it doesn't expect anyone else to be touching the MM
(quite reasonably, since mm_users is zero). So we also need to fix the
fault handler to just report failure if mm_users is already zero, and to
temporarily bump mm_users while handling any faults.
Additionally, exit_mmap() calls mmu_notifier_release() *before* it tears
down the page tables, which is too early for us to flush the IOTLB for
this PASID. And __mmu_notifier_release() removes every notifier from the
list, so when exit_mmap() finally *does* tear down the mappings and
clear the page tables, we don't get notified. So we work around this by
clearing the PASID table entry in our MMU notifier release() callback.
That way, the hardware *can't* get any pages back from the page tables
before they get cleared.
Hardware designers have confirmed that the resulting 'PASID not present'
faults should be handled just as gracefully as 'page not present' faults,
the important criterion being that they don't perturb the operation for
any *other* PASID in the system.
Signed-off-by: David Woodhouse <David.Woodhouse@intel.com>
Cc: stable@vger.kernel.org
2016-01-12 19:18:06 +00:00
|
|
|
/* This might end up being called from exit_mmap(), *before* the page
|
|
|
|
* tables are cleared. And __mmu_notifier_release() will delete us from
|
|
|
|
* the list of notifiers so that our invalidate_range() callback doesn't
|
|
|
|
* get called when the page tables are cleared. So we need to protect
|
|
|
|
* against hardware accessing those page tables.
|
|
|
|
*
|
|
|
|
* We do it by clearing the entry in the PASID table and then flushing
|
|
|
|
* the IOTLB and the PASID table caches. This might upset hardware;
|
|
|
|
* perhaps we'll want to point the PASID to a dummy PGD (like the zero
|
|
|
|
* page) so that we end up taking a fault that the hardware really
|
|
|
|
* *has* to handle gracefully without affecting other processes.
|
|
|
|
*/
|
2015-09-09 10:40:47 +00:00
|
|
|
svm->iommu->pasid_table[svm->pasid].val = 0;
|
iommu/vt-d: Fix mm refcounting to hold mm_count not mm_users
Holding mm_users works OK for graphics, which was the first user of SVM
with VT-d. However, it works less well for other devices, where we actually
do a mmap() from the file descriptor to which the SVM PASID state is tied.
In this case on process exit we end up with a recursive reference count:
- The MM remains alive until the file is closed and the driver's release()
call ends up unbinding the PASID.
- The VMA corresponding to the mmap() remains intact until the MM is
destroyed.
- Thus the file isn't closed, even when exit_files() runs, because the
VMA is still holding a reference to it. And the MM remains alive…
To address this issue, we *stop* holding mm_users while the PASID is bound.
We already hold mm_count by virtue of the MMU notifier, and that can be
made to be sufficient.
It means that for a period during process exit, the fun part of mmput()
has happened and exit_mmap() has been called so the MM is basically
defunct. But the PGD still exists and the PASID is still bound to it.
During this period, we have to be very careful — exit_mmap() doesn't use
mm->mmap_sem because it doesn't expect anyone else to be touching the MM
(quite reasonably, since mm_users is zero). So we also need to fix the
fault handler to just report failure if mm_users is already zero, and to
temporarily bump mm_users while handling any faults.
Additionally, exit_mmap() calls mmu_notifier_release() *before* it tears
down the page tables, which is too early for us to flush the IOTLB for
this PASID. And __mmu_notifier_release() removes every notifier from the
list, so when exit_mmap() finally *does* tear down the mappings and
clear the page tables, we don't get notified. So we work around this by
clearing the PASID table entry in our MMU notifier release() callback.
That way, the hardware *can't* get any pages back from the page tables
before they get cleared.
Hardware designers have confirmed that the resulting 'PASID not present'
faults should be handled just as gracefully as 'page not present' faults,
the important criterion being that they don't perturb the operation for
any *other* PASID in the system.
Signed-off-by: David Woodhouse <David.Woodhouse@intel.com>
Cc: stable@vger.kernel.org
2016-01-12 19:18:06 +00:00
|
|
|
wmb();
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
list_for_each_entry_rcu(sdev, &svm->devs, list) {
|
|
|
|
intel_flush_pasid_dev(svm, sdev, svm->pasid);
|
|
|
|
intel_flush_svm_range_dev(svm, sdev, 0, -1, 0, !svm->mm);
|
|
|
|
}
|
|
|
|
rcu_read_unlock();
|
2015-09-09 10:40:47 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct mmu_notifier_ops intel_mmuops = {
|
mm, mmu_notifier: annotate mmu notifiers with blockable invalidate callbacks
Commit 4d4bbd8526a8 ("mm, oom_reaper: skip mm structs with mmu
notifiers") prevented the oom reaper from unmapping private anonymous
memory with the oom reaper when the oom victim mm had mmu notifiers
registered.
The rationale is that doing mmu_notifier_invalidate_range_{start,end}()
around the unmap_page_range(), which is needed, can block and the oom
killer will stall forever waiting for the victim to exit, which may not
be possible without reaping.
That concern is real, but only true for mmu notifiers that have
blockable invalidate_range_{start,end}() callbacks. This patch adds a
"flags" field to mmu notifier ops that can set a bit to indicate that
these callbacks do not block.
The implementation is steered toward an expensive slowpath, such as
after the oom reaper has grabbed mm->mmap_sem of a still alive oom
victim.
[rientjes@google.com: mmu_notifier_invalidate_range_end() can also call the invalidate_range() must not block, fix comment]
Link: http://lkml.kernel.org/r/alpine.DEB.2.10.1801091339570.240101@chino.kir.corp.google.com
[akpm@linux-foundation.org: make mm_has_blockable_invalidate_notifiers() return bool, use rwsem_is_locked()]
Link: http://lkml.kernel.org/r/alpine.DEB.2.10.1712141329500.74052@chino.kir.corp.google.com
Signed-off-by: David Rientjes <rientjes@google.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Acked-by: Paolo Bonzini <pbonzini@redhat.com>
Acked-by: Christian König <christian.koenig@amd.com>
Acked-by: Dimitri Sivanich <sivanich@hpe.com>
Cc: Andrea Arcangeli <aarcange@redhat.com>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Oded Gabbay <oded.gabbay@gmail.com>
Cc: Alex Deucher <alexander.deucher@amd.com>
Cc: David Airlie <airlied@linux.ie>
Cc: Joerg Roedel <joro@8bytes.org>
Cc: Doug Ledford <dledford@redhat.com>
Cc: Jani Nikula <jani.nikula@linux.intel.com>
Cc: Mike Marciniszyn <mike.marciniszyn@intel.com>
Cc: Sean Hefty <sean.hefty@intel.com>
Cc: Boris Ostrovsky <boris.ostrovsky@oracle.com>
Cc: Jérôme Glisse <jglisse@redhat.com>
Cc: Radim Krčmář <rkrcmar@redhat.com>
Signed-off-by: David Rientjes <rientjes@google.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2018-02-01 00:18:32 +00:00
|
|
|
.flags = MMU_INVALIDATE_DOES_NOT_BLOCK,
|
2015-09-09 10:40:47 +00:00
|
|
|
.release = intel_mm_release,
|
|
|
|
.change_pte = intel_change_pte,
|
|
|
|
.invalidate_range = intel_invalidate_range,
|
|
|
|
};
|
|
|
|
|
|
|
|
static DEFINE_MUTEX(pasid_mutex);
|
2018-07-14 07:46:55 +00:00
|
|
|
static LIST_HEAD(global_svm_list);
|
2015-09-09 10:40:47 +00:00
|
|
|
|
2015-10-13 16:18:10 +00:00
|
|
|
int intel_svm_bind_mm(struct device *dev, int *pasid, int flags, struct svm_dev_ops *ops)
|
2015-09-09 10:40:47 +00:00
|
|
|
{
|
|
|
|
struct intel_iommu *iommu = intel_svm_device_to_iommu(dev);
|
|
|
|
struct intel_svm_dev *sdev;
|
|
|
|
struct intel_svm *svm = NULL;
|
2015-10-15 14:52:15 +00:00
|
|
|
struct mm_struct *mm = NULL;
|
2017-12-20 19:59:27 +00:00
|
|
|
u64 pasid_entry_val;
|
2015-09-09 10:40:47 +00:00
|
|
|
int pasid_max;
|
|
|
|
int ret;
|
|
|
|
|
2018-06-19 02:49:19 +00:00
|
|
|
if (!iommu || !iommu->pasid_table)
|
2015-09-09 10:40:47 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (dev_is_pci(dev)) {
|
|
|
|
pasid_max = pci_max_pasids(to_pci_dev(dev));
|
|
|
|
if (pasid_max < 0)
|
|
|
|
return -EINVAL;
|
|
|
|
} else
|
|
|
|
pasid_max = 1 << 20;
|
|
|
|
|
2018-05-04 05:08:19 +00:00
|
|
|
if (flags & SVM_FLAG_SUPERVISOR_MODE) {
|
2015-10-15 14:52:15 +00:00
|
|
|
if (!ecap_srs(iommu->ecap))
|
|
|
|
return -EINVAL;
|
|
|
|
} else if (pasid) {
|
|
|
|
mm = get_task_mm(current);
|
|
|
|
BUG_ON(!mm);
|
|
|
|
}
|
|
|
|
|
2015-09-09 10:40:47 +00:00
|
|
|
mutex_lock(&pasid_mutex);
|
2015-10-15 12:59:14 +00:00
|
|
|
if (pasid && !(flags & SVM_FLAG_PRIVATE_PASID)) {
|
2018-07-14 07:46:55 +00:00
|
|
|
struct intel_svm *t;
|
2015-09-09 10:40:47 +00:00
|
|
|
|
2018-07-14 07:46:55 +00:00
|
|
|
list_for_each_entry(t, &global_svm_list, list) {
|
|
|
|
if (t->mm != mm || (t->flags & SVM_FLAG_PRIVATE_PASID))
|
2015-09-09 10:40:47 +00:00
|
|
|
continue;
|
|
|
|
|
2018-07-14 07:46:55 +00:00
|
|
|
svm = t;
|
2015-09-09 10:40:47 +00:00
|
|
|
if (svm->pasid >= pasid_max) {
|
|
|
|
dev_warn(dev,
|
|
|
|
"Limited PASID width. Cannot use existing PASID %d\n",
|
|
|
|
svm->pasid);
|
|
|
|
ret = -ENOSPC;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
list_for_each_entry(sdev, &svm->devs, list) {
|
|
|
|
if (dev == sdev->dev) {
|
2015-10-13 16:18:10 +00:00
|
|
|
if (sdev->ops != ops) {
|
|
|
|
ret = -EBUSY;
|
|
|
|
goto out;
|
|
|
|
}
|
2015-09-09 10:40:47 +00:00
|
|
|
sdev->users++;
|
|
|
|
goto success;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
sdev = kzalloc(sizeof(*sdev), GFP_KERNEL);
|
|
|
|
if (!sdev) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
sdev->dev = dev;
|
|
|
|
|
|
|
|
ret = intel_iommu_enable_pasid(iommu, sdev);
|
|
|
|
if (ret || !pasid) {
|
|
|
|
/* If they don't actually want to assign a PASID, this is
|
|
|
|
* just an enabling check/preparation. */
|
|
|
|
kfree(sdev);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
/* Finish the setup now we know we're keeping it */
|
|
|
|
sdev->users = 1;
|
2015-10-13 16:18:10 +00:00
|
|
|
sdev->ops = ops;
|
2015-09-09 10:40:47 +00:00
|
|
|
init_rcu_head(&sdev->rcu);
|
|
|
|
|
|
|
|
if (!svm) {
|
|
|
|
svm = kzalloc(sizeof(*svm), GFP_KERNEL);
|
|
|
|
if (!svm) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
kfree(sdev);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
svm->iommu = iommu;
|
|
|
|
|
2016-09-12 02:49:11 +00:00
|
|
|
if (pasid_max > iommu->pasid_max)
|
|
|
|
pasid_max = iommu->pasid_max;
|
2015-09-09 10:40:47 +00:00
|
|
|
|
2015-10-24 19:06:39 +00:00
|
|
|
/* Do not use PASID 0 in caching mode (virtualised IOMMU) */
|
|
|
|
ret = idr_alloc(&iommu->pasid_idr, svm,
|
|
|
|
!!cap_caching_mode(iommu->cap),
|
|
|
|
pasid_max - 1, GFP_KERNEL);
|
2015-09-09 10:40:47 +00:00
|
|
|
if (ret < 0) {
|
|
|
|
kfree(svm);
|
2018-02-24 05:42:27 +00:00
|
|
|
kfree(sdev);
|
2015-09-09 10:40:47 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
svm->pasid = ret;
|
|
|
|
svm->notifier.ops = &intel_mmuops;
|
2015-10-15 14:52:15 +00:00
|
|
|
svm->mm = mm;
|
2015-10-15 12:59:14 +00:00
|
|
|
svm->flags = flags;
|
2015-09-09 10:40:47 +00:00
|
|
|
INIT_LIST_HEAD_RCU(&svm->devs);
|
2018-07-14 07:46:55 +00:00
|
|
|
INIT_LIST_HEAD(&svm->list);
|
2015-09-09 10:40:47 +00:00
|
|
|
ret = -ENOMEM;
|
2015-10-15 14:52:15 +00:00
|
|
|
if (mm) {
|
|
|
|
ret = mmu_notifier_register(&svm->notifier, mm);
|
|
|
|
if (ret) {
|
|
|
|
idr_remove(&svm->iommu->pasid_idr, svm->pasid);
|
|
|
|
kfree(svm);
|
|
|
|
kfree(sdev);
|
|
|
|
goto out;
|
|
|
|
}
|
2017-12-20 19:59:27 +00:00
|
|
|
pasid_entry_val = (u64)__pa(mm->pgd) | PASID_ENTRY_P;
|
2015-10-15 14:52:15 +00:00
|
|
|
} else
|
2017-12-20 19:59:27 +00:00
|
|
|
pasid_entry_val = (u64)__pa(init_mm.pgd) |
|
|
|
|
PASID_ENTRY_P | PASID_ENTRY_SRE;
|
|
|
|
if (cpu_feature_enabled(X86_FEATURE_LA57))
|
|
|
|
pasid_entry_val |= PASID_ENTRY_FLPM_5LP;
|
|
|
|
|
|
|
|
iommu->pasid_table[svm->pasid].val = pasid_entry_val;
|
|
|
|
|
2015-09-09 10:40:47 +00:00
|
|
|
wmb();
|
2018-03-16 04:31:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Flush PASID cache when a PASID table entry becomes
|
|
|
|
* present.
|
|
|
|
*/
|
2015-10-24 19:06:39 +00:00
|
|
|
if (cap_caching_mode(iommu->cap))
|
2018-03-16 04:31:36 +00:00
|
|
|
intel_flush_pasid_dev(svm, sdev, svm->pasid);
|
2018-07-14 07:46:55 +00:00
|
|
|
|
|
|
|
list_add_tail(&svm->list, &global_svm_list);
|
2015-09-09 10:40:47 +00:00
|
|
|
}
|
|
|
|
list_add_rcu(&sdev->list, &svm->devs);
|
|
|
|
|
|
|
|
success:
|
|
|
|
*pasid = svm->pasid;
|
|
|
|
ret = 0;
|
|
|
|
out:
|
|
|
|
mutex_unlock(&pasid_mutex);
|
2015-10-15 14:52:15 +00:00
|
|
|
if (mm)
|
|
|
|
mmput(mm);
|
2015-09-09 10:40:47 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(intel_svm_bind_mm);
|
|
|
|
|
|
|
|
int intel_svm_unbind_mm(struct device *dev, int pasid)
|
|
|
|
{
|
|
|
|
struct intel_svm_dev *sdev;
|
|
|
|
struct intel_iommu *iommu;
|
|
|
|
struct intel_svm *svm;
|
|
|
|
int ret = -EINVAL;
|
|
|
|
|
|
|
|
mutex_lock(&pasid_mutex);
|
|
|
|
iommu = intel_svm_device_to_iommu(dev);
|
|
|
|
if (!iommu || !iommu->pasid_table)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
svm = idr_find(&iommu->pasid_idr, pasid);
|
|
|
|
if (!svm)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
list_for_each_entry(sdev, &svm->devs, list) {
|
|
|
|
if (dev == sdev->dev) {
|
|
|
|
ret = 0;
|
|
|
|
sdev->users--;
|
|
|
|
if (!sdev->users) {
|
|
|
|
list_del_rcu(&sdev->list);
|
|
|
|
/* Flush the PASID cache and IOTLB for this device.
|
|
|
|
* Note that we do depend on the hardware *not* using
|
|
|
|
* the PASID any more. Just as we depend on other
|
|
|
|
* devices never using PASIDs that they have no right
|
|
|
|
* to use. We have a *shared* PASID table, because it's
|
|
|
|
* large and has to be physically contiguous. So it's
|
|
|
|
* hard to be as defensive as we might like. */
|
2015-10-24 19:06:39 +00:00
|
|
|
intel_flush_pasid_dev(svm, sdev, svm->pasid);
|
2015-10-16 18:36:53 +00:00
|
|
|
intel_flush_svm_range_dev(svm, sdev, 0, -1, 0, !svm->mm);
|
2015-09-09 10:40:47 +00:00
|
|
|
kfree_rcu(sdev, rcu);
|
|
|
|
|
|
|
|
if (list_empty(&svm->devs)) {
|
2017-11-03 16:51:34 +00:00
|
|
|
svm->iommu->pasid_table[svm->pasid].val = 0;
|
|
|
|
wmb();
|
2015-09-09 10:40:47 +00:00
|
|
|
|
|
|
|
idr_remove(&svm->iommu->pasid_idr, svm->pasid);
|
2015-10-15 14:52:15 +00:00
|
|
|
if (svm->mm)
|
iommu/vt-d: Fix mm refcounting to hold mm_count not mm_users
Holding mm_users works OK for graphics, which was the first user of SVM
with VT-d. However, it works less well for other devices, where we actually
do a mmap() from the file descriptor to which the SVM PASID state is tied.
In this case on process exit we end up with a recursive reference count:
- The MM remains alive until the file is closed and the driver's release()
call ends up unbinding the PASID.
- The VMA corresponding to the mmap() remains intact until the MM is
destroyed.
- Thus the file isn't closed, even when exit_files() runs, because the
VMA is still holding a reference to it. And the MM remains alive…
To address this issue, we *stop* holding mm_users while the PASID is bound.
We already hold mm_count by virtue of the MMU notifier, and that can be
made to be sufficient.
It means that for a period during process exit, the fun part of mmput()
has happened and exit_mmap() has been called so the MM is basically
defunct. But the PGD still exists and the PASID is still bound to it.
During this period, we have to be very careful — exit_mmap() doesn't use
mm->mmap_sem because it doesn't expect anyone else to be touching the MM
(quite reasonably, since mm_users is zero). So we also need to fix the
fault handler to just report failure if mm_users is already zero, and to
temporarily bump mm_users while handling any faults.
Additionally, exit_mmap() calls mmu_notifier_release() *before* it tears
down the page tables, which is too early for us to flush the IOTLB for
this PASID. And __mmu_notifier_release() removes every notifier from the
list, so when exit_mmap() finally *does* tear down the mappings and
clear the page tables, we don't get notified. So we work around this by
clearing the PASID table entry in our MMU notifier release() callback.
That way, the hardware *can't* get any pages back from the page tables
before they get cleared.
Hardware designers have confirmed that the resulting 'PASID not present'
faults should be handled just as gracefully as 'page not present' faults,
the important criterion being that they don't perturb the operation for
any *other* PASID in the system.
Signed-off-by: David Woodhouse <David.Woodhouse@intel.com>
Cc: stable@vger.kernel.org
2016-01-12 19:18:06 +00:00
|
|
|
mmu_notifier_unregister(&svm->notifier, svm->mm);
|
|
|
|
|
2018-07-14 07:46:55 +00:00
|
|
|
list_del(&svm->list);
|
|
|
|
|
2015-09-09 10:40:47 +00:00
|
|
|
/* We mandate that no page faults may be outstanding
|
|
|
|
* for the PASID when intel_svm_unbind_mm() is called.
|
|
|
|
* If that is not obeyed, subtle errors will happen.
|
|
|
|
* Let's make them less subtle... */
|
|
|
|
memset(svm, 0x6b, sizeof(*svm));
|
|
|
|
kfree(svm);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
mutex_unlock(&pasid_mutex);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(intel_svm_unbind_mm);
|
2015-10-07 22:35:18 +00:00
|
|
|
|
2017-05-10 18:39:03 +00:00
|
|
|
int intel_svm_is_pasid_valid(struct device *dev, int pasid)
|
|
|
|
{
|
|
|
|
struct intel_iommu *iommu;
|
|
|
|
struct intel_svm *svm;
|
|
|
|
int ret = -EINVAL;
|
|
|
|
|
|
|
|
mutex_lock(&pasid_mutex);
|
|
|
|
iommu = intel_svm_device_to_iommu(dev);
|
|
|
|
if (!iommu || !iommu->pasid_table)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
svm = idr_find(&iommu->pasid_idr, pasid);
|
|
|
|
if (!svm)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* init_mm is used in this case */
|
|
|
|
if (!svm->mm)
|
|
|
|
ret = 1;
|
|
|
|
else if (atomic_read(&svm->mm->mm_users) > 0)
|
|
|
|
ret = 1;
|
|
|
|
else
|
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
out:
|
|
|
|
mutex_unlock(&pasid_mutex);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(intel_svm_is_pasid_valid);
|
|
|
|
|
2015-10-07 22:35:18 +00:00
|
|
|
/* Page request queue descriptor */
|
|
|
|
struct page_req_dsc {
|
|
|
|
u64 srr:1;
|
|
|
|
u64 bof:1;
|
|
|
|
u64 pasid_present:1;
|
|
|
|
u64 lpig:1;
|
|
|
|
u64 pasid:20;
|
|
|
|
u64 bus:8;
|
|
|
|
u64 private:23;
|
|
|
|
u64 prg_index:9;
|
|
|
|
u64 rd_req:1;
|
|
|
|
u64 wr_req:1;
|
|
|
|
u64 exe_req:1;
|
|
|
|
u64 priv_req:1;
|
|
|
|
u64 devfn:8;
|
|
|
|
u64 addr:52;
|
|
|
|
};
|
|
|
|
|
|
|
|
#define PRQ_RING_MASK ((0x1000 << PRQ_ORDER) - 0x10)
|
2015-11-17 15:11:39 +00:00
|
|
|
|
|
|
|
static bool access_error(struct vm_area_struct *vma, struct page_req_dsc *req)
|
|
|
|
{
|
|
|
|
unsigned long requested = 0;
|
|
|
|
|
|
|
|
if (req->exe_req)
|
|
|
|
requested |= VM_EXEC;
|
|
|
|
|
|
|
|
if (req->rd_req)
|
|
|
|
requested |= VM_READ;
|
|
|
|
|
|
|
|
if (req->wr_req)
|
|
|
|
requested |= VM_WRITE;
|
|
|
|
|
|
|
|
return (requested & ~vma->vm_flags) != 0;
|
|
|
|
}
|
|
|
|
|
2017-08-08 20:29:27 +00:00
|
|
|
static bool is_canonical_address(u64 addr)
|
|
|
|
{
|
|
|
|
int shift = 64 - (__VIRTUAL_MASK_SHIFT + 1);
|
|
|
|
long saddr = (long) addr;
|
|
|
|
|
|
|
|
return (((saddr << shift) >> shift) == saddr);
|
|
|
|
}
|
|
|
|
|
2015-10-07 22:35:18 +00:00
|
|
|
static irqreturn_t prq_event_thread(int irq, void *d)
|
|
|
|
{
|
|
|
|
struct intel_iommu *iommu = d;
|
|
|
|
struct intel_svm *svm = NULL;
|
|
|
|
int head, tail, handled = 0;
|
|
|
|
|
2016-02-15 12:42:38 +00:00
|
|
|
/* Clear PPR bit before reading head/tail registers, to
|
|
|
|
* ensure that we get a new interrupt if needed. */
|
|
|
|
writel(DMA_PRS_PPR, iommu->reg + DMAR_PRS_REG);
|
|
|
|
|
2015-10-07 22:35:18 +00:00
|
|
|
tail = dmar_readq(iommu->reg + DMAR_PQT_REG) & PRQ_RING_MASK;
|
|
|
|
head = dmar_readq(iommu->reg + DMAR_PQH_REG) & PRQ_RING_MASK;
|
|
|
|
while (head != tail) {
|
2015-10-13 16:18:10 +00:00
|
|
|
struct intel_svm_dev *sdev;
|
2015-10-07 22:35:18 +00:00
|
|
|
struct vm_area_struct *vma;
|
|
|
|
struct page_req_dsc *req;
|
|
|
|
struct qi_desc resp;
|
|
|
|
int ret, result;
|
|
|
|
u64 address;
|
|
|
|
|
|
|
|
handled = 1;
|
|
|
|
|
|
|
|
req = &iommu->prq[head / sizeof(*req)];
|
|
|
|
|
|
|
|
result = QI_RESP_FAILURE;
|
2015-10-16 16:22:31 +00:00
|
|
|
address = (u64)req->addr << VTD_PAGE_SHIFT;
|
2015-10-07 22:35:18 +00:00
|
|
|
if (!req->pasid_present) {
|
|
|
|
pr_err("%s: Page request without PASID: %08llx %08llx\n",
|
|
|
|
iommu->name, ((unsigned long long *)req)[0],
|
|
|
|
((unsigned long long *)req)[1]);
|
|
|
|
goto bad_req;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!svm || svm->pasid != req->pasid) {
|
|
|
|
rcu_read_lock();
|
|
|
|
svm = idr_find(&iommu->pasid_idr, req->pasid);
|
|
|
|
/* It *can't* go away, because the driver is not permitted
|
|
|
|
* to unbind the mm while any page faults are outstanding.
|
|
|
|
* So we only need RCU to protect the internal idr code. */
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
|
|
|
if (!svm) {
|
|
|
|
pr_err("%s: Page request for invalid PASID %d: %08llx %08llx\n",
|
|
|
|
iommu->name, req->pasid, ((unsigned long long *)req)[0],
|
|
|
|
((unsigned long long *)req)[1]);
|
2015-10-15 20:12:56 +00:00
|
|
|
goto no_pasid;
|
2015-10-07 22:35:18 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
result = QI_RESP_INVALID;
|
2015-10-15 14:52:15 +00:00
|
|
|
/* Since we're using init_mm.pgd directly, we should never take
|
|
|
|
* any faults on kernel addresses. */
|
|
|
|
if (!svm->mm)
|
|
|
|
goto bad_req;
|
iommu/vt-d: Fix mm refcounting to hold mm_count not mm_users
Holding mm_users works OK for graphics, which was the first user of SVM
with VT-d. However, it works less well for other devices, where we actually
do a mmap() from the file descriptor to which the SVM PASID state is tied.
In this case on process exit we end up with a recursive reference count:
- The MM remains alive until the file is closed and the driver's release()
call ends up unbinding the PASID.
- The VMA corresponding to the mmap() remains intact until the MM is
destroyed.
- Thus the file isn't closed, even when exit_files() runs, because the
VMA is still holding a reference to it. And the MM remains alive…
To address this issue, we *stop* holding mm_users while the PASID is bound.
We already hold mm_count by virtue of the MMU notifier, and that can be
made to be sufficient.
It means that for a period during process exit, the fun part of mmput()
has happened and exit_mmap() has been called so the MM is basically
defunct. But the PGD still exists and the PASID is still bound to it.
During this period, we have to be very careful — exit_mmap() doesn't use
mm->mmap_sem because it doesn't expect anyone else to be touching the MM
(quite reasonably, since mm_users is zero). So we also need to fix the
fault handler to just report failure if mm_users is already zero, and to
temporarily bump mm_users while handling any faults.
Additionally, exit_mmap() calls mmu_notifier_release() *before* it tears
down the page tables, which is too early for us to flush the IOTLB for
this PASID. And __mmu_notifier_release() removes every notifier from the
list, so when exit_mmap() finally *does* tear down the mappings and
clear the page tables, we don't get notified. So we work around this by
clearing the PASID table entry in our MMU notifier release() callback.
That way, the hardware *can't* get any pages back from the page tables
before they get cleared.
Hardware designers have confirmed that the resulting 'PASID not present'
faults should be handled just as gracefully as 'page not present' faults,
the important criterion being that they don't perturb the operation for
any *other* PASID in the system.
Signed-off-by: David Woodhouse <David.Woodhouse@intel.com>
Cc: stable@vger.kernel.org
2016-01-12 19:18:06 +00:00
|
|
|
/* If the mm is already defunct, don't handle faults. */
|
2017-02-27 22:30:13 +00:00
|
|
|
if (!mmget_not_zero(svm->mm))
|
iommu/vt-d: Fix mm refcounting to hold mm_count not mm_users
Holding mm_users works OK for graphics, which was the first user of SVM
with VT-d. However, it works less well for other devices, where we actually
do a mmap() from the file descriptor to which the SVM PASID state is tied.
In this case on process exit we end up with a recursive reference count:
- The MM remains alive until the file is closed and the driver's release()
call ends up unbinding the PASID.
- The VMA corresponding to the mmap() remains intact until the MM is
destroyed.
- Thus the file isn't closed, even when exit_files() runs, because the
VMA is still holding a reference to it. And the MM remains alive…
To address this issue, we *stop* holding mm_users while the PASID is bound.
We already hold mm_count by virtue of the MMU notifier, and that can be
made to be sufficient.
It means that for a period during process exit, the fun part of mmput()
has happened and exit_mmap() has been called so the MM is basically
defunct. But the PGD still exists and the PASID is still bound to it.
During this period, we have to be very careful — exit_mmap() doesn't use
mm->mmap_sem because it doesn't expect anyone else to be touching the MM
(quite reasonably, since mm_users is zero). So we also need to fix the
fault handler to just report failure if mm_users is already zero, and to
temporarily bump mm_users while handling any faults.
Additionally, exit_mmap() calls mmu_notifier_release() *before* it tears
down the page tables, which is too early for us to flush the IOTLB for
this PASID. And __mmu_notifier_release() removes every notifier from the
list, so when exit_mmap() finally *does* tear down the mappings and
clear the page tables, we don't get notified. So we work around this by
clearing the PASID table entry in our MMU notifier release() callback.
That way, the hardware *can't* get any pages back from the page tables
before they get cleared.
Hardware designers have confirmed that the resulting 'PASID not present'
faults should be handled just as gracefully as 'page not present' faults,
the important criterion being that they don't perturb the operation for
any *other* PASID in the system.
Signed-off-by: David Woodhouse <David.Woodhouse@intel.com>
Cc: stable@vger.kernel.org
2016-01-12 19:18:06 +00:00
|
|
|
goto bad_req;
|
2017-08-08 20:29:27 +00:00
|
|
|
|
|
|
|
/* If address is not canonical, return invalid response */
|
|
|
|
if (!is_canonical_address(address))
|
|
|
|
goto bad_req;
|
|
|
|
|
2015-10-07 22:35:18 +00:00
|
|
|
down_read(&svm->mm->mmap_sem);
|
|
|
|
vma = find_extend_vma(svm->mm, address);
|
|
|
|
if (!vma || address < vma->vm_start)
|
|
|
|
goto invalid;
|
|
|
|
|
2015-11-17 15:11:39 +00:00
|
|
|
if (access_error(vma, req))
|
|
|
|
goto invalid;
|
|
|
|
|
2016-07-26 22:25:18 +00:00
|
|
|
ret = handle_mm_fault(vma, address,
|
2015-10-07 22:35:18 +00:00
|
|
|
req->wr_req ? FAULT_FLAG_WRITE : 0);
|
|
|
|
if (ret & VM_FAULT_ERROR)
|
|
|
|
goto invalid;
|
|
|
|
|
|
|
|
result = QI_RESP_SUCCESS;
|
|
|
|
invalid:
|
|
|
|
up_read(&svm->mm->mmap_sem);
|
iommu/vt-d: Fix mm refcounting to hold mm_count not mm_users
Holding mm_users works OK for graphics, which was the first user of SVM
with VT-d. However, it works less well for other devices, where we actually
do a mmap() from the file descriptor to which the SVM PASID state is tied.
In this case on process exit we end up with a recursive reference count:
- The MM remains alive until the file is closed and the driver's release()
call ends up unbinding the PASID.
- The VMA corresponding to the mmap() remains intact until the MM is
destroyed.
- Thus the file isn't closed, even when exit_files() runs, because the
VMA is still holding a reference to it. And the MM remains alive…
To address this issue, we *stop* holding mm_users while the PASID is bound.
We already hold mm_count by virtue of the MMU notifier, and that can be
made to be sufficient.
It means that for a period during process exit, the fun part of mmput()
has happened and exit_mmap() has been called so the MM is basically
defunct. But the PGD still exists and the PASID is still bound to it.
During this period, we have to be very careful — exit_mmap() doesn't use
mm->mmap_sem because it doesn't expect anyone else to be touching the MM
(quite reasonably, since mm_users is zero). So we also need to fix the
fault handler to just report failure if mm_users is already zero, and to
temporarily bump mm_users while handling any faults.
Additionally, exit_mmap() calls mmu_notifier_release() *before* it tears
down the page tables, which is too early for us to flush the IOTLB for
this PASID. And __mmu_notifier_release() removes every notifier from the
list, so when exit_mmap() finally *does* tear down the mappings and
clear the page tables, we don't get notified. So we work around this by
clearing the PASID table entry in our MMU notifier release() callback.
That way, the hardware *can't* get any pages back from the page tables
before they get cleared.
Hardware designers have confirmed that the resulting 'PASID not present'
faults should be handled just as gracefully as 'page not present' faults,
the important criterion being that they don't perturb the operation for
any *other* PASID in the system.
Signed-off-by: David Woodhouse <David.Woodhouse@intel.com>
Cc: stable@vger.kernel.org
2016-01-12 19:18:06 +00:00
|
|
|
mmput(svm->mm);
|
2015-10-07 22:35:18 +00:00
|
|
|
bad_req:
|
|
|
|
/* Accounting for major/minor faults? */
|
2015-10-13 16:18:10 +00:00
|
|
|
rcu_read_lock();
|
|
|
|
list_for_each_entry_rcu(sdev, &svm->devs, list) {
|
2015-10-17 05:18:47 +00:00
|
|
|
if (sdev->sid == PCI_DEVID(req->bus, req->devfn))
|
2015-10-13 16:18:10 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* Other devices can go away, but the drivers are not permitted
|
|
|
|
* to unbind while any page faults might be in flight. So it's
|
|
|
|
* OK to drop the 'lock' here now we have it. */
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
|
|
|
if (WARN_ON(&sdev->list == &svm->devs))
|
|
|
|
sdev = NULL;
|
|
|
|
|
|
|
|
if (sdev && sdev->ops && sdev->ops->fault_cb) {
|
|
|
|
int rwxp = (req->rd_req << 3) | (req->wr_req << 2) |
|
2015-10-28 06:14:09 +00:00
|
|
|
(req->exe_req << 1) | (req->priv_req);
|
2015-10-13 16:18:10 +00:00
|
|
|
sdev->ops->fault_cb(sdev->dev, req->pasid, req->addr, req->private, rwxp, result);
|
|
|
|
}
|
2015-10-15 20:12:56 +00:00
|
|
|
/* We get here in the error case where the PASID lookup failed,
|
|
|
|
and these can be NULL. Do not use them below this point! */
|
|
|
|
sdev = NULL;
|
|
|
|
svm = NULL;
|
|
|
|
no_pasid:
|
2015-10-07 22:35:18 +00:00
|
|
|
if (req->lpig) {
|
|
|
|
/* Page Group Response */
|
|
|
|
resp.low = QI_PGRP_PASID(req->pasid) |
|
|
|
|
QI_PGRP_DID((req->bus << 8) | req->devfn) |
|
|
|
|
QI_PGRP_PASID_P(req->pasid_present) |
|
|
|
|
QI_PGRP_RESP_TYPE;
|
|
|
|
resp.high = QI_PGRP_IDX(req->prg_index) |
|
|
|
|
QI_PGRP_PRIV(req->private) | QI_PGRP_RESP_CODE(result);
|
|
|
|
|
2015-10-15 20:12:56 +00:00
|
|
|
qi_submit_sync(&resp, iommu);
|
2015-10-07 22:35:18 +00:00
|
|
|
} else if (req->srr) {
|
|
|
|
/* Page Stream Response */
|
|
|
|
resp.low = QI_PSTRM_IDX(req->prg_index) |
|
|
|
|
QI_PSTRM_PRIV(req->private) | QI_PSTRM_BUS(req->bus) |
|
|
|
|
QI_PSTRM_PASID(req->pasid) | QI_PSTRM_RESP_TYPE;
|
|
|
|
resp.high = QI_PSTRM_ADDR(address) | QI_PSTRM_DEVFN(req->devfn) |
|
|
|
|
QI_PSTRM_RESP_CODE(result);
|
|
|
|
|
2015-10-15 20:12:56 +00:00
|
|
|
qi_submit_sync(&resp, iommu);
|
2015-10-07 22:35:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
head = (head + sizeof(*req)) & PRQ_RING_MASK;
|
|
|
|
}
|
|
|
|
|
|
|
|
dmar_writeq(iommu->reg + DMAR_PQH_REG, tail);
|
|
|
|
|
|
|
|
return IRQ_RETVAL(handled);
|
|
|
|
}
|