Merge tag 'vfio-v4.18-rc1' of git://github.com/awilliam/linux-vfio
Pull VFIO updates from Alex Williamson: - Bind type1 task tracking to group_leader to facilitate vCPU hotplug in QEMU (Alex Williamson) - Sample mdev display drivers, including region-based host and guest Linux drivers and bochs compatible dmabuf device (Gerd Hoffmann) - Fix vfio-platform reset module leak (Geert Uytterhoeven) - vfio-platform error message consistency (Geert Uytterhoeven) - Global checking for mdev uuid collisions rather than per parent device (Alex Williamson) - Use match_string() helper (Yisheng Xie) - vfio-platform PM domain fixes (Geert Uytterhoeven) - Fix sample mbochs driver build dependency (Arnd Bergmann) * tag 'vfio-v4.18-rc1' of git://github.com/awilliam/linux-vfio: samples: mbochs: add DMA_SHARED_BUFFER dependency vfio: platform: Fix using devices in PM Domains vfio: use match_string() helper vfio/mdev: Re-order sysfs attribute creation vfio/mdev: Check globally for duplicate devices vfio: platform: Make printed error messages more consistent vfio: platform: Fix reset module leak in error path sample: vfio bochs vbe display (host device for bochs-drm) sample: vfio mdev display - guest driver sample: vfio mdev display - host device vfio/type1: Fix task tracking for QEMU vCPU hotplug
这个提交包含在：
Linus Torvalds
@@ -66,34 +66,6 @@ uuid_le mdev_uuid(struct mdev_device *mdev)
|
||||
}
|
||||
EXPORT_SYMBOL(mdev_uuid);
|
||||
|
||||
static int _find_mdev_device(struct device *dev, void *data)
|
||||
{
|
||||
struct mdev_device *mdev;
|
||||
|
||||
if (!dev_is_mdev(dev))
|
||||
return 0;
|
||||
|
||||
mdev = to_mdev_device(dev);
|
||||
|
||||
if (uuid_le_cmp(mdev->uuid, *(uuid_le *)data) == 0)
|
||||
return 1;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static bool mdev_device_exist(struct mdev_parent *parent, uuid_le uuid)
|
||||
{
|
||||
struct device *dev;
|
||||
|
||||
dev = device_find_child(parent->dev, &uuid, _find_mdev_device);
|
||||
if (dev) {
|
||||
put_device(dev);
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/* Should be called holding parent_list_lock */
|
||||
static struct mdev_parent *__find_parent_device(struct device *dev)
|
||||
{
|
||||
@@ -221,7 +193,6 @@ int mdev_register_device(struct device *dev, const struct mdev_parent_ops *ops)
|
||||
}
|
||||
|
||||
kref_init(&parent->ref);
|
||||
mutex_init(&parent->lock);
|
||||
|
||||
parent->dev = dev;
|
||||
parent->ops = ops;
|
||||
@@ -297,6 +268,10 @@ static void mdev_device_release(struct device *dev)
|
||||
{
|
||||
struct mdev_device *mdev = to_mdev_device(dev);
|
||||
|
||||
mutex_lock(&mdev_list_lock);
|
||||
list_del(&mdev->next);
|
||||
mutex_unlock(&mdev_list_lock);
|
||||
|
||||
dev_dbg(&mdev->dev, "MDEV: destroying\n");
|
||||
kfree(mdev);
|
||||
}
|
||||
@@ -304,7 +279,7 @@ static void mdev_device_release(struct device *dev)
|
||||
int mdev_device_create(struct kobject *kobj, struct device *dev, uuid_le uuid)
|
||||
{
|
||||
int ret;
|
||||
struct mdev_device *mdev;
|
||||
struct mdev_device *mdev, *tmp;
|
||||
struct mdev_parent *parent;
|
||||
struct mdev_type *type = to_mdev_type(kobj);
|
||||
|
||||
@@ -312,21 +287,28 @@ int mdev_device_create(struct kobject *kobj, struct device *dev, uuid_le uuid)
|
||||
if (!parent)
|
||||
return -EINVAL;
|
||||
|
||||
mutex_lock(&parent->lock);
|
||||
mutex_lock(&mdev_list_lock);
|
||||
|
||||
/* Check for duplicate */
|
||||
if (mdev_device_exist(parent, uuid)) {
|
||||
ret = -EEXIST;
|
||||
goto create_err;
|
||||
list_for_each_entry(tmp, &mdev_list, next) {
|
||||
if (!uuid_le_cmp(tmp->uuid, uuid)) {
|
||||
mutex_unlock(&mdev_list_lock);
|
||||
ret = -EEXIST;
|
||||
goto mdev_fail;
|
||||
}
|
||||
}
|
||||
|
||||
mdev = kzalloc(sizeof(*mdev), GFP_KERNEL);
|
||||
if (!mdev) {
|
||||
mutex_unlock(&mdev_list_lock);
|
||||
ret = -ENOMEM;
|
||||
goto create_err;
|
||||
goto mdev_fail;
|
||||
}
|
||||
|
||||
memcpy(&mdev->uuid, &uuid, sizeof(uuid_le));
|
||||
list_add(&mdev->next, &mdev_list);
|
||||
mutex_unlock(&mdev_list_lock);
|
||||
|
||||
mdev->parent = parent;
|
||||
kref_init(&mdev->ref);
|
||||
|
||||
@@ -338,35 +320,28 @@ int mdev_device_create(struct kobject *kobj, struct device *dev, uuid_le uuid)
|
||||
ret = device_register(&mdev->dev);
|
||||
if (ret) {
|
||||
put_device(&mdev->dev);
|
||||
goto create_err;
|
||||
goto mdev_fail;
|
||||
}
|
||||
|
||||
ret = mdev_device_create_ops(kobj, mdev);
|
||||
if (ret)
|
||||
goto create_failed;
|
||||
goto create_fail;
|
||||
|
||||
ret = mdev_create_sysfs_files(&mdev->dev, type);
|
||||
if (ret) {
|
||||
mdev_device_remove_ops(mdev, true);
|
||||
goto create_failed;
|
||||
goto create_fail;
|
||||
}
|
||||
|
||||
mdev->type_kobj = kobj;
|
||||
mdev->active = true;
|
||||
dev_dbg(&mdev->dev, "MDEV: created\n");
|
||||
|
||||
mutex_unlock(&parent->lock);
|
||||
return 0;
|
||||
|
||||
mutex_lock(&mdev_list_lock);
|
||||
list_add(&mdev->next, &mdev_list);
|
||||
mutex_unlock(&mdev_list_lock);
|
||||
|
||||
return ret;
|
||||
|
||||
create_failed:
|
||||
create_fail:
|
||||
device_unregister(&mdev->dev);
|
||||
|
||||
create_err:
|
||||
mutex_unlock(&parent->lock);
|
||||
mdev_fail:
|
||||
mdev_put_parent(parent);
|
||||
return ret;
|
||||
}
|
||||
@@ -377,44 +352,39 @@ int mdev_device_remove(struct device *dev, bool force_remove)
|
||||
struct mdev_parent *parent;
|
||||
struct mdev_type *type;
|
||||
int ret;
|
||||
bool found = false;
|
||||
|
||||
mdev = to_mdev_device(dev);
|
||||
|
||||
mutex_lock(&mdev_list_lock);
|
||||
list_for_each_entry(tmp, &mdev_list, next) {
|
||||
if (tmp == mdev) {
|
||||
found = true;
|
||||
if (tmp == mdev)
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (found)
|
||||
list_del(&mdev->next);
|
||||
|
||||
mutex_unlock(&mdev_list_lock);
|
||||
|
||||
if (!found)
|
||||
if (tmp != mdev) {
|
||||
mutex_unlock(&mdev_list_lock);
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
if (!mdev->active) {
|
||||
mutex_unlock(&mdev_list_lock);
|
||||
return -EAGAIN;
|
||||
}
|
||||
|
||||
mdev->active = false;
|
||||
mutex_unlock(&mdev_list_lock);
|
||||
|
||||
type = to_mdev_type(mdev->type_kobj);
|
||||
parent = mdev->parent;
|
||||
mutex_lock(&parent->lock);
|
||||
|
||||
ret = mdev_device_remove_ops(mdev, force_remove);
|
||||
if (ret) {
|
||||
mutex_unlock(&parent->lock);
|
||||
|
||||
mutex_lock(&mdev_list_lock);
|
||||
list_add(&mdev->next, &mdev_list);
|
||||
mutex_unlock(&mdev_list_lock);
|
||||
|
||||
mdev->active = true;
|
||||
return ret;
|
||||
}
|
||||
|
||||
mdev_remove_sysfs_files(dev, type);
|
||||
device_unregister(dev);
|
||||
mutex_unlock(&parent->lock);
|
||||
mdev_put_parent(parent);
|
||||
|
||||
return 0;
|
||||
|
||||
@@ -20,7 +20,6 @@ struct mdev_parent {
|
||||
struct device *dev;
|
||||
const struct mdev_parent_ops *ops;
|
||||
struct kref ref;
|
||||
struct mutex lock;
|
||||
struct list_head next;
|
||||
struct kset *mdev_types_kset;
|
||||
struct list_head type_list;
|
||||
@@ -34,6 +33,7 @@ struct mdev_device {
|
||||
struct kref ref;
|
||||
struct list_head next;
|
||||
struct kobject *type_kobj;
|
||||
bool active;
|
||||
};
|
||||
|
||||
#define to_mdev_device(dev) container_of(dev, struct mdev_device, dev)
|
||||
|
||||
@@ -257,24 +257,24 @@ int mdev_create_sysfs_files(struct device *dev, struct mdev_type *type)
|
||||
{
|
||||
int ret;
|
||||
|
||||
ret = sysfs_create_files(&dev->kobj, mdev_device_attrs);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
ret = sysfs_create_link(type->devices_kobj, &dev->kobj, dev_name(dev));
|
||||
if (ret)
|
||||
goto device_link_failed;
|
||||
return ret;
|
||||
|
||||
ret = sysfs_create_link(&dev->kobj, &type->kobj, "mdev_type");
|
||||
if (ret)
|
||||
goto type_link_failed;
|
||||
|
||||
ret = sysfs_create_files(&dev->kobj, mdev_device_attrs);
|
||||
if (ret)
|
||||
goto create_files_failed;
|
||||
|
||||
return ret;
|
||||
|
||||
create_files_failed:
|
||||
sysfs_remove_link(&dev->kobj, "mdev_type");
|
||||
type_link_failed:
|
||||
sysfs_remove_link(type->devices_kobj, dev_name(dev));
|
||||
device_link_failed:
|
||||
sysfs_remove_files(&dev->kobj, mdev_device_attrs);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
@@ -17,6 +17,7 @@
|
||||
#include <linux/iommu.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/mutex.h>
|
||||
#include <linux/pm_runtime.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/types.h>
|
||||
#include <linux/uaccess.h>
|
||||
@@ -239,6 +240,7 @@ static void vfio_platform_release(void *device_data)
|
||||
ret, extra_dbg ? extra_dbg : "");
|
||||
WARN_ON(1);
|
||||
}
|
||||
pm_runtime_put(vdev->device);
|
||||
vfio_platform_regions_cleanup(vdev);
|
||||
vfio_platform_irq_cleanup(vdev);
|
||||
}
|
||||
@@ -269,6 +271,10 @@ static int vfio_platform_open(void *device_data)
|
||||
if (ret)
|
||||
goto err_irq;
|
||||
|
||||
ret = pm_runtime_get_sync(vdev->device);
|
||||
if (ret < 0)
|
||||
goto err_pm;
|
||||
|
||||
ret = vfio_platform_call_reset(vdev, &extra_dbg);
|
||||
if (ret && vdev->reset_required) {
|
||||
dev_warn(vdev->device, "reset driver is required and reset call failed in open (%d) %s\n",
|
||||
@@ -283,6 +289,8 @@ static int vfio_platform_open(void *device_data)
|
||||
return 0;
|
||||
|
||||
err_rst:
|
||||
pm_runtime_put(vdev->device);
|
||||
err_pm:
|
||||
vfio_platform_irq_cleanup(vdev);
|
||||
err_irq:
|
||||
vfio_platform_regions_cleanup(vdev);
|
||||
@@ -630,8 +638,7 @@ static int vfio_platform_of_probe(struct vfio_platform_device *vdev,
|
||||
ret = device_property_read_string(dev, "compatible",
|
||||
&vdev->compat);
|
||||
if (ret)
|
||||
pr_err("VFIO: cannot retrieve compat for %s\n",
|
||||
vdev->name);
|
||||
pr_err("VFIO: Cannot retrieve compat for %s\n", vdev->name);
|
||||
|
||||
return ret;
|
||||
}
|
||||
@@ -673,7 +680,7 @@ int vfio_platform_probe_common(struct vfio_platform_device *vdev,
|
||||
|
||||
ret = vfio_platform_get_reset(vdev);
|
||||
if (ret && vdev->reset_required) {
|
||||
pr_err("vfio: no reset function found for device %s\n",
|
||||
pr_err("VFIO: No reset function found for device %s\n",
|
||||
vdev->name);
|
||||
return ret;
|
||||
}
|
||||
@@ -681,18 +688,24 @@ int vfio_platform_probe_common(struct vfio_platform_device *vdev,
|
||||
group = vfio_iommu_group_get(dev);
|
||||
if (!group) {
|
||||
pr_err("VFIO: No IOMMU group for device %s\n", vdev->name);
|
||||
return -EINVAL;
|
||||
ret = -EINVAL;
|
||||
goto put_reset;
|
||||
}
|
||||
|
||||
ret = vfio_add_group_dev(dev, &vfio_platform_ops, vdev);
|
||||
if (ret) {
|
||||
vfio_iommu_group_put(group, dev);
|
||||
return ret;
|
||||
}
|
||||
if (ret)
|
||||
goto put_iommu;
|
||||
|
||||
mutex_init(&vdev->igate);
|
||||
|
||||
pm_runtime_enable(vdev->device);
|
||||
return 0;
|
||||
|
||||
put_iommu:
|
||||
vfio_iommu_group_put(group, dev);
|
||||
put_reset:
|
||||
vfio_platform_put_reset(vdev);
|
||||
return ret;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(vfio_platform_probe_common);
|
||||
|
||||
@@ -703,6 +716,7 @@ struct vfio_platform_device *vfio_platform_remove_common(struct device *dev)
|
||||
vdev = vfio_del_group_dev(dev);
|
||||
|
||||
if (vdev) {
|
||||
pm_runtime_disable(vdev->device);
|
||||
vfio_platform_put_reset(vdev);
|
||||
vfio_iommu_group_put(dev->iommu_group, dev);
|
||||
}
|
||||
|
||||
@@ -630,8 +630,6 @@ static const char * const vfio_driver_whitelist[] = { "pci-stub" };
|
||||
|
||||
static bool vfio_dev_whitelisted(struct device *dev, struct device_driver *drv)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (dev_is_pci(dev)) {
|
||||
struct pci_dev *pdev = to_pci_dev(dev);
|
||||
|
||||
@@ -639,12 +637,9 @@ static bool vfio_dev_whitelisted(struct device *dev, struct device_driver *drv)
|
||||
return true;
|
||||
}
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(vfio_driver_whitelist); i++) {
|
||||
if (!strcmp(drv->name, vfio_driver_whitelist[i]))
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
return match_string(vfio_driver_whitelist,
|
||||
ARRAY_SIZE(vfio_driver_whitelist),
|
||||
drv->name) >= 0;
|
||||
}
|
||||
|
||||
/*
|
||||
|
||||
@@ -83,6 +83,7 @@ struct vfio_dma {
|
||||
size_t size; /* Map size (bytes) */
|
||||
int prot; /* IOMMU_READ/WRITE */
|
||||
bool iommu_mapped;
|
||||
bool lock_cap; /* capable(CAP_IPC_LOCK) */
|
||||
struct task_struct *task;
|
||||
struct rb_root pfn_list; /* Ex-user pinned pfn list */
|
||||
};
|
||||
@@ -253,29 +254,25 @@ static int vfio_iova_put_vfio_pfn(struct vfio_dma *dma, struct vfio_pfn *vpfn)
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int vfio_lock_acct(struct task_struct *task, long npage, bool *lock_cap)
|
||||
static int vfio_lock_acct(struct vfio_dma *dma, long npage, bool async)
|
||||
{
|
||||
struct mm_struct *mm;
|
||||
bool is_current;
|
||||
int ret;
|
||||
|
||||
if (!npage)
|
||||
return 0;
|
||||
|
||||
is_current = (task->mm == current->mm);
|
||||
|
||||
mm = is_current ? task->mm : get_task_mm(task);
|
||||
mm = async ? get_task_mm(dma->task) : dma->task->mm;
|
||||
if (!mm)
|
||||
return -ESRCH; /* process exited */
|
||||
|
||||
ret = down_write_killable(&mm->mmap_sem);
|
||||
if (!ret) {
|
||||
if (npage > 0) {
|
||||
if (lock_cap ? !*lock_cap :
|
||||
!has_capability(task, CAP_IPC_LOCK)) {
|
||||
if (!dma->lock_cap) {
|
||||
unsigned long limit;
|
||||
|
||||
limit = task_rlimit(task,
|
||||
limit = task_rlimit(dma->task,
|
||||
RLIMIT_MEMLOCK) >> PAGE_SHIFT;
|
||||
|
||||
if (mm->locked_vm + npage > limit)
|
||||
@@ -289,7 +286,7 @@ static int vfio_lock_acct(struct task_struct *task, long npage, bool *lock_cap)
|
||||
up_write(&mm->mmap_sem);
|
||||
}
|
||||
|
||||
if (!is_current)
|
||||
if (async)
|
||||
mmput(mm);
|
||||
|
||||
return ret;
|
||||
@@ -400,7 +397,7 @@ static int vaddr_get_pfn(struct mm_struct *mm, unsigned long vaddr,
|
||||
*/
|
||||
static long vfio_pin_pages_remote(struct vfio_dma *dma, unsigned long vaddr,
|
||||
long npage, unsigned long *pfn_base,
|
||||
bool lock_cap, unsigned long limit)
|
||||
unsigned long limit)
|
||||
{
|
||||
unsigned long pfn = 0;
|
||||
long ret, pinned = 0, lock_acct = 0;
|
||||
@@ -423,7 +420,7 @@ static long vfio_pin_pages_remote(struct vfio_dma *dma, unsigned long vaddr,
|
||||
* pages are already counted against the user.
|
||||
*/
|
||||
if (!rsvd && !vfio_find_vpfn(dma, iova)) {
|
||||
if (!lock_cap && current->mm->locked_vm + 1 > limit) {
|
||||
if (!dma->lock_cap && current->mm->locked_vm + 1 > limit) {
|
||||
put_pfn(*pfn_base, dma->prot);
|
||||
pr_warn("%s: RLIMIT_MEMLOCK (%ld) exceeded\n", __func__,
|
||||
limit << PAGE_SHIFT);
|
||||
@@ -449,7 +446,7 @@ static long vfio_pin_pages_remote(struct vfio_dma *dma, unsigned long vaddr,
|
||||
}
|
||||
|
||||
if (!rsvd && !vfio_find_vpfn(dma, iova)) {
|
||||
if (!lock_cap &&
|
||||
if (!dma->lock_cap &&
|
||||
current->mm->locked_vm + lock_acct + 1 > limit) {
|
||||
put_pfn(pfn, dma->prot);
|
||||
pr_warn("%s: RLIMIT_MEMLOCK (%ld) exceeded\n",
|
||||
@@ -462,7 +459,7 @@ static long vfio_pin_pages_remote(struct vfio_dma *dma, unsigned long vaddr,
|
||||
}
|
||||
|
||||
out:
|
||||
ret = vfio_lock_acct(current, lock_acct, &lock_cap);
|
||||
ret = vfio_lock_acct(dma, lock_acct, false);
|
||||
|
||||
unpin_out:
|
||||
if (ret) {
|
||||
@@ -493,7 +490,7 @@ static long vfio_unpin_pages_remote(struct vfio_dma *dma, dma_addr_t iova,
|
||||
}
|
||||
|
||||
if (do_accounting)
|
||||
vfio_lock_acct(dma->task, locked - unlocked, NULL);
|
||||
vfio_lock_acct(dma, locked - unlocked, true);
|
||||
|
||||
return unlocked;
|
||||
}
|
||||
@@ -510,7 +507,7 @@ static int vfio_pin_page_external(struct vfio_dma *dma, unsigned long vaddr,
|
||||
|
||||
ret = vaddr_get_pfn(mm, vaddr, dma->prot, pfn_base);
|
||||
if (!ret && do_accounting && !is_invalid_reserved_pfn(*pfn_base)) {
|
||||
ret = vfio_lock_acct(dma->task, 1, NULL);
|
||||
ret = vfio_lock_acct(dma, 1, true);
|
||||
if (ret) {
|
||||
put_pfn(*pfn_base, dma->prot);
|
||||
if (ret == -ENOMEM)
|
||||
@@ -537,7 +534,7 @@ static int vfio_unpin_page_external(struct vfio_dma *dma, dma_addr_t iova,
|
||||
unlocked = vfio_iova_put_vfio_pfn(dma, vpfn);
|
||||
|
||||
if (do_accounting)
|
||||
vfio_lock_acct(dma->task, -unlocked, NULL);
|
||||
vfio_lock_acct(dma, -unlocked, true);
|
||||
|
||||
return unlocked;
|
||||
}
|
||||
@@ -829,7 +826,7 @@ static long vfio_unmap_unpin(struct vfio_iommu *iommu, struct vfio_dma *dma,
|
||||
unlocked += vfio_sync_unpin(dma, domain, &unmapped_region_list);
|
||||
|
||||
if (do_accounting) {
|
||||
vfio_lock_acct(dma->task, -unlocked, NULL);
|
||||
vfio_lock_acct(dma, -unlocked, true);
|
||||
return 0;
|
||||
}
|
||||
return unlocked;
|
||||
@@ -1044,14 +1041,12 @@ static int vfio_pin_map_dma(struct vfio_iommu *iommu, struct vfio_dma *dma,
|
||||
size_t size = map_size;
|
||||
long npage;
|
||||
unsigned long pfn, limit = rlimit(RLIMIT_MEMLOCK) >> PAGE_SHIFT;
|
||||
bool lock_cap = capable(CAP_IPC_LOCK);
|
||||
int ret = 0;
|
||||
|
||||
while (size) {
|
||||
/* Pin a contiguous chunk of memory */
|
||||
npage = vfio_pin_pages_remote(dma, vaddr + dma->size,
|
||||
size >> PAGE_SHIFT, &pfn,
|
||||
lock_cap, limit);
|
||||
size >> PAGE_SHIFT, &pfn, limit);
|
||||
if (npage <= 0) {
|
||||
WARN_ON(!npage);
|
||||
ret = (int)npage;
|
||||
@@ -1126,8 +1121,36 @@ static int vfio_dma_do_map(struct vfio_iommu *iommu,
|
||||
dma->iova = iova;
|
||||
dma->vaddr = vaddr;
|
||||
dma->prot = prot;
|
||||
get_task_struct(current);
|
||||
dma->task = current;
|
||||
|
||||
/*
|
||||
* We need to be able to both add to a task's locked memory and test
|
||||
* against the locked memory limit and we need to be able to do both
|
||||
* outside of this call path as pinning can be asynchronous via the
|
||||
* external interfaces for mdev devices. RLIMIT_MEMLOCK requires a
|
||||
* task_struct and VM locked pages requires an mm_struct, however
|
||||
* holding an indefinite mm reference is not recommended, therefore we
|
||||
* only hold a reference to a task. We could hold a reference to
|
||||
* current, however QEMU uses this call path through vCPU threads,
|
||||
* which can be killed resulting in a NULL mm and failure in the unmap
|
||||
* path when called via a different thread. Avoid this problem by
|
||||
* using the group_leader as threads within the same group require
|
||||
* both CLONE_THREAD and CLONE_VM and will therefore use the same
|
||||
* mm_struct.
|
||||
*
|
||||
* Previously we also used the task for testing CAP_IPC_LOCK at the
|
||||
* time of pinning and accounting, however has_capability() makes use
|
||||
* of real_cred, a copy-on-write field, so we can't guarantee that it
|
||||
* matches group_leader, or in fact that it might not change by the
|
||||
* time it's evaluated. If a process were to call MAP_DMA with
|
||||
* CAP_IPC_LOCK but later drop it, it doesn't make sense that they
|
||||
* possibly see different results for an iommu_mapped vfio_dma vs
|
||||
* externally mapped. Therefore track CAP_IPC_LOCK in vfio_dma at the
|
||||
* time of calling MAP_DMA.
|
||||
*/
|
||||
get_task_struct(current->group_leader);
|
||||
dma->task = current->group_leader;
|
||||
dma->lock_cap = capable(CAP_IPC_LOCK);
|
||||
|
||||
dma->pfn_list = RB_ROOT;
|
||||
|
||||
/* Insert zero-sized and grow as we map chunks of it */
|
||||
@@ -1162,7 +1185,6 @@ static int vfio_iommu_replay(struct vfio_iommu *iommu,
|
||||
struct vfio_domain *d;
|
||||
struct rb_node *n;
|
||||
unsigned long limit = rlimit(RLIMIT_MEMLOCK) >> PAGE_SHIFT;
|
||||
bool lock_cap = capable(CAP_IPC_LOCK);
|
||||
int ret;
|
||||
|
||||
/* Arbitrarily pick the first domain in the list for lookups */
|
||||
@@ -1209,8 +1231,7 @@ static int vfio_iommu_replay(struct vfio_iommu *iommu,
|
||||
|
||||
npage = vfio_pin_pages_remote(dma, vaddr,
|
||||
n >> PAGE_SHIFT,
|
||||
&pfn, lock_cap,
|
||||
limit);
|
||||
&pfn, limit);
|
||||
if (npage <= 0) {
|
||||
WARN_ON(!npage);
|
||||
ret = (int)npage;
|
||||
@@ -1487,7 +1508,7 @@ static void vfio_iommu_unmap_unpin_reaccount(struct vfio_iommu *iommu)
|
||||
if (!is_invalid_reserved_pfn(vpfn->pfn))
|
||||
locked++;
|
||||
}
|
||||
vfio_lock_acct(dma->task, locked - unlocked, NULL);
|
||||
vfio_lock_acct(dma, locked - unlocked, true);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
在新工单中引用
屏蔽一个用户