drivers/vfio/vfio.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * VFIO core
   4  *
   5  * Copyright (C) 2012 Red Hat, Inc.  All rights reserved.
   6  *     Author: Alex Williamson <alex.williamson@redhat.com>
   7  *
   8  * Derived from original vfio:
   9  * Copyright 2010 Cisco Systems, Inc.  All rights reserved.
  10  * Author: Tom Lyon, pugs@cisco.com
  11  */
  12
  13 #include <linux/cdev.h>
  14 #include <linux/compat.h>
  15 #include <linux/device.h>
  16 #include <linux/file.h>
  17 #include <linux/anon_inodes.h>
  18 #include <linux/fs.h>
  19 #include <linux/idr.h>
  20 #include <linux/iommu.h>
  21 #include <linux/list.h>
  22 #include <linux/miscdevice.h>
  23 #include <linux/module.h>
  24 #include <linux/mutex.h>
  25 #include <linux/pci.h>
  26 #include <linux/rwsem.h>
  27 #include <linux/sched.h>
  28 #include <linux/slab.h>
  29 #include <linux/stat.h>
  30 #include <linux/string.h>
  31 #include <linux/uaccess.h>
  32 #include <linux/vfio.h>
  33 #include <linux/wait.h>
  34 #include <linux/sched/signal.h>
  35
  36 #define DRIVER_VERSION  "0.3"
  37 #define DRIVER_AUTHOR   "Alex Williamson <alex.williamson@redhat.com>"
  38 #define DRIVER_DESC     "VFIO - User Level meta-driver"
  39
  40 static struct vfio {
  41         struct class                    *class;
  42         struct list_head                iommu_drivers_list;
  43         struct mutex                    iommu_drivers_lock;
  44         struct list_head                group_list;
  45         struct idr                      group_idr;
  46         struct mutex                    group_lock;
  47         struct cdev                     group_cdev;
  48         dev_t                           group_devt;
  49 } vfio;
  50
  51 struct vfio_iommu_driver {
  52         const struct vfio_iommu_driver_ops      *ops;
  53         struct list_head                        vfio_next;
  54 };
  55
  56 struct vfio_container {
  57         struct kref                     kref;
  58         struct list_head                group_list;
  59         struct rw_semaphore             group_lock;
  60         struct vfio_iommu_driver        *iommu_driver;
  61         void                            *iommu_data;
  62         bool                            noiommu;
  63 };
  64
  65 struct vfio_unbound_dev {
  66         struct device                   *dev;
  67         struct list_head                unbound_next;
  68 };
  69
  70 struct vfio_group {
  71         struct kref                     kref;
  72         int                             minor;
  73         atomic_t                        container_users;
  74         struct iommu_group              *iommu_group;
  75         struct vfio_container           *container;
  76         struct list_head                device_list;
  77         struct mutex                    device_lock;
  78         struct device                   *dev;
  79         struct notifier_block           nb;
  80         struct list_head                vfio_next;
  81         struct list_head                container_next;
  82         struct list_head                unbound_list;
  83         struct mutex                    unbound_lock;
  84         atomic_t                        opened;
  85         wait_queue_head_t               container_q;
  86         bool                            noiommu;
  87         unsigned int                    dev_counter;
  88         struct kvm                      *kvm;
  89         struct blocking_notifier_head   notifier;
  90 };
  91
  92 #ifdef CONFIG_VFIO_NOIOMMU
  93 static bool noiommu __read_mostly;
  94 module_param_named(enable_unsafe_noiommu_mode,
  95                    noiommu, bool, S_IRUGO | S_IWUSR);
  96 MODULE_PARM_DESC(enable_unsafe_noiommu_mode, "Enable UNSAFE, no-IOMMU mode.  This mode provides no device isolation, no DMA translation, no host kernel protection, cannot be used for device assignment to virtual machines, requires RAWIO permissions, and will taint the kernel.  If you do not know what this is for, step away. (default: false)");
  97 #endif
  98
  99 /*
 100  * vfio_iommu_group_{get,put} are only intended for VFIO bus driver probe
 101  * and remove functions, any use cases other than acquiring the first
 102  * reference for the purpose of calling vfio_add_group_dev() or removing
 103  * that symmetric reference after vfio_del_group_dev() should use the raw
 104  * iommu_group_{get,put} functions.  In particular, vfio_iommu_group_put()
 105  * removes the device from the dummy group and cannot be nested.
 106  */
 107 struct iommu_group *vfio_iommu_group_get(struct device *dev)
 108 {
 109         struct iommu_group *group;
 110         int __maybe_unused ret;
 111
 112         group = iommu_group_get(dev);
 113
 114 #ifdef CONFIG_VFIO_NOIOMMU
 115         /*
 116          * With noiommu enabled, an IOMMU group will be created for a device
 117          * that doesn't already have one and doesn't have an iommu_ops on their
 118          * bus.  We set iommudata simply to be able to identify these groups
 119          * as special use and for reclamation later.
 120          */
 121         if (group || !noiommu || iommu_present(dev->bus))
 122                 return group;
 123
 124         group = iommu_group_alloc();
 125         if (IS_ERR(group))
 126                 return NULL;
 127
 128         iommu_group_set_name(group, "vfio-noiommu");
 129         iommu_group_set_iommudata(group, &noiommu, NULL);
 130         ret = iommu_group_add_device(group, dev);
 131         if (ret) {
 132                 iommu_group_put(group);
 133                 return NULL;
 134         }
 135
 136         /*
 137          * Where to taint?  At this point we've added an IOMMU group for a
 138          * device that is not backed by iommu_ops, therefore any iommu_
 139          * callback using iommu_ops can legitimately Oops.  So, while we may
 140          * be about to give a DMA capable device to a user without IOMMU
 141          * protection, which is clearly taint-worthy, let's go ahead and do
 142          * it here.
 143          */
 144         add_taint(TAINT_USER, LOCKDEP_STILL_OK);
 145         dev_warn(dev, "Adding kernel taint for vfio-noiommu group on device\n");
 146 #endif
 147
 148         return group;
 149 }
 150 EXPORT_SYMBOL_GPL(vfio_iommu_group_get);
 151
 152 void vfio_iommu_group_put(struct iommu_group *group, struct device *dev)
 153 {
 154 #ifdef CONFIG_VFIO_NOIOMMU
 155         if (iommu_group_get_iommudata(group) == &noiommu)
 156                 iommu_group_remove_device(dev);
 157 #endif
 158
 159         iommu_group_put(group);
 160 }
 161 EXPORT_SYMBOL_GPL(vfio_iommu_group_put);
 162
 163 #ifdef CONFIG_VFIO_NOIOMMU
 164 static void *vfio_noiommu_open(unsigned long arg)
 165 {
 166         if (arg != VFIO_NOIOMMU_IOMMU)
 167                 return ERR_PTR(-EINVAL);
 168         if (!capable(CAP_SYS_RAWIO))
 169                 return ERR_PTR(-EPERM);
 170
 171         return NULL;
 172 }
 173
 174 static void vfio_noiommu_release(void *iommu_data)
 175 {
 176 }
 177
 178 static long vfio_noiommu_ioctl(void *iommu_data,
 179                                unsigned int cmd, unsigned long arg)
 180 {
 181         if (cmd == VFIO_CHECK_EXTENSION)
 182                 return noiommu && (arg == VFIO_NOIOMMU_IOMMU) ? 1 : 0;
 183
 184         return -ENOTTY;
 185 }
 186
 187 static int vfio_noiommu_attach_group(void *iommu_data,
 188                                      struct iommu_group *iommu_group)
 189 {
 190         return iommu_group_get_iommudata(iommu_group) == &noiommu ? 0 : -EINVAL;
 191 }
 192
 193 static void vfio_noiommu_detach_group(void *iommu_data,
 194                                       struct iommu_group *iommu_group)
 195 {
 196 }
 197
 198 static const struct vfio_iommu_driver_ops vfio_noiommu_ops = {
 199         .name = "vfio-noiommu",
 200         .owner = THIS_MODULE,
 201         .open = vfio_noiommu_open,
 202         .release = vfio_noiommu_release,
 203         .ioctl = vfio_noiommu_ioctl,
 204         .attach_group = vfio_noiommu_attach_group,
 205         .detach_group = vfio_noiommu_detach_group,
 206 };
 207 #endif
 208
 209
 210 /**
 211  * IOMMU driver registration
 212  */
 213 int vfio_register_iommu_driver(const struct vfio_iommu_driver_ops *ops)
 214 {
 215         struct vfio_iommu_driver *driver, *tmp;
 216
 217         driver = kzalloc(sizeof(*driver), GFP_KERNEL);
 218         if (!driver)
 219                 return -ENOMEM;
 220
 221         driver->ops = ops;
 222
 223         mutex_lock(&vfio.iommu_drivers_lock);
 224
 225         /* Check for duplicates */
 226         list_for_each_entry(tmp, &vfio.iommu_drivers_list, vfio_next) {
 227                 if (tmp->ops == ops) {
 228                         mutex_unlock(&vfio.iommu_drivers_lock);
 229                         kfree(driver);
 230                         return -EINVAL;
 231                 }
 232         }
 233
 234         list_add(&driver->vfio_next, &vfio.iommu_drivers_list);
 235
 236         mutex_unlock(&vfio.iommu_drivers_lock);
 237
 238         return 0;
 239 }
 240 EXPORT_SYMBOL_GPL(vfio_register_iommu_driver);
 241
 242 void vfio_unregister_iommu_driver(const struct vfio_iommu_driver_ops *ops)
 243 {
 244         struct vfio_iommu_driver *driver;
 245
 246         mutex_lock(&vfio.iommu_drivers_lock);
 247         list_for_each_entry(driver, &vfio.iommu_drivers_list, vfio_next) {
 248                 if (driver->ops == ops) {
 249                         list_del(&driver->vfio_next);
 250                         mutex_unlock(&vfio.iommu_drivers_lock);
 251                         kfree(driver);
 252                         return;
 253                 }
 254         }
 255         mutex_unlock(&vfio.iommu_drivers_lock);
 256 }
 257 EXPORT_SYMBOL_GPL(vfio_unregister_iommu_driver);
 258
 259 /**
 260  * Group minor allocation/free - both called with vfio.group_lock held
 261  */
 262 static int vfio_alloc_group_minor(struct vfio_group *group)
 263 {
 264         return idr_alloc(&vfio.group_idr, group, 0, MINORMASK + 1, GFP_KERNEL);
 265 }
 266
 267 static void vfio_free_group_minor(int minor)
 268 {
 269         idr_remove(&vfio.group_idr, minor);
 270 }
 271
 272 static int vfio_iommu_group_notifier(struct notifier_block *nb,
 273                                      unsigned long action, void *data);
 274 static void vfio_group_get(struct vfio_group *group);
 275
 276 /**
 277  * Container objects - containers are created when /dev/vfio/vfio is
 278  * opened, but their lifecycle extends until the last user is done, so
 279  * it's freed via kref.  Must support container/group/device being
 280  * closed in any order.
 281  */
 282 static void vfio_container_get(struct vfio_container *container)
 283 {
 284         kref_get(&container->kref);
 285 }
 286
 287 static void vfio_container_release(struct kref *kref)
 288 {
 289         struct vfio_container *container;
 290         container = container_of(kref, struct vfio_container, kref);
 291
 292         kfree(container);
 293 }
 294
 295 static void vfio_container_put(struct vfio_container *container)
 296 {
 297         kref_put(&container->kref, vfio_container_release);
 298 }
 299
 300 static void vfio_group_unlock_and_free(struct vfio_group *group)
 301 {
 302         mutex_unlock(&vfio.group_lock);
 303         /*
 304          * Unregister outside of lock.  A spurious callback is harmless now
 305          * that the group is no longer in vfio.group_list.
 306          */
 307         iommu_group_unregister_notifier(group->iommu_group, &group->nb);
 308         kfree(group);
 309 }
 310
 311 /**
 312  * Group objects - create, release, get, put, search
 313  */
 314 static struct vfio_group *vfio_create_group(struct iommu_group *iommu_group)
 315 {
 316         struct vfio_group *group, *tmp;
 317         struct device *dev;
 318         int ret, minor;
 319
 320         group = kzalloc(sizeof(*group), GFP_KERNEL);
 321         if (!group)
 322                 return ERR_PTR(-ENOMEM);
 323
 324         kref_init(&group->kref);
 325         INIT_LIST_HEAD(&group->device_list);
 326         mutex_init(&group->device_lock);
 327         INIT_LIST_HEAD(&group->unbound_list);
 328         mutex_init(&group->unbound_lock);
 329         atomic_set(&group->container_users, 0);
 330         atomic_set(&group->opened, 0);
 331         init_waitqueue_head(&group->container_q);
 332         group->iommu_group = iommu_group;
 333 #ifdef CONFIG_VFIO_NOIOMMU
 334         group->noiommu = (iommu_group_get_iommudata(iommu_group) == &noiommu);
 335 #endif
 336         BLOCKING_INIT_NOTIFIER_HEAD(&group->notifier);
 337
 338         group->nb.notifier_call = vfio_iommu_group_notifier;
 339
 340         /*
 341          * blocking notifiers acquire a rwsem around registering and hold
 342          * it around callback.  Therefore, need to register outside of
 343          * vfio.group_lock to avoid A-B/B-A contention.  Our callback won't
 344          * do anything unless it can find the group in vfio.group_list, so
 345          * no harm in registering early.
 346          */
 347         ret = iommu_group_register_notifier(iommu_group, &group->nb);
 348         if (ret) {
 349                 kfree(group);
 350                 return ERR_PTR(ret);
 351         }
 352
 353         mutex_lock(&vfio.group_lock);
 354
 355         /* Did we race creating this group? */
 356         list_for_each_entry(tmp, &vfio.group_list, vfio_next) {
 357                 if (tmp->iommu_group == iommu_group) {
 358                         vfio_group_get(tmp);
 359                         vfio_group_unlock_and_free(group);
 360                         return tmp;
 361                 }
 362         }
 363
 364         minor = vfio_alloc_group_minor(group);
 365         if (minor < 0) {
 366                 vfio_group_unlock_and_free(group);
 367                 return ERR_PTR(minor);
 368         }
 369
 370         dev = device_create(vfio.class, NULL,
 371                             MKDEV(MAJOR(vfio.group_devt), minor),
 372                             group, "%s%d", group->noiommu ? "noiommu-" : "",
 373                             iommu_group_id(iommu_group));
 374         if (IS_ERR(dev)) {
 375                 vfio_free_group_minor(minor);
 376                 vfio_group_unlock_and_free(group);
 377                 return ERR_CAST(dev);
 378         }
 379
 380         group->minor = minor;
 381         group->dev = dev;
 382
 383         list_add(&group->vfio_next, &vfio.group_list);
 384
 385         mutex_unlock(&vfio.group_lock);
 386
 387         return group;
 388 }
 389
 390 /* called with vfio.group_lock held */
 391 static void vfio_group_release(struct kref *kref)
 392 {
 393         struct vfio_group *group = container_of(kref, struct vfio_group, kref);
 394         struct vfio_unbound_dev *unbound, *tmp;
 395         struct iommu_group *iommu_group = group->iommu_group;
 396
 397         WARN_ON(!list_empty(&group->device_list));
 398         WARN_ON(group->notifier.head);
 399
 400         list_for_each_entry_safe(unbound, tmp,
 401                                  &group->unbound_list, unbound_next) {
 402                 list_del(&unbound->unbound_next);
 403                 kfree(unbound);
 404         }
 405
 406         device_destroy(vfio.class, MKDEV(MAJOR(vfio.group_devt), group->minor));
 407         list_del(&group->vfio_next);
 408         vfio_free_group_minor(group->minor);
 409         vfio_group_unlock_and_free(group);
 410         iommu_group_put(iommu_group);
 411 }
 412
 413 static void vfio_group_put(struct vfio_group *group)
 414 {
 415         kref_put_mutex(&group->kref, vfio_group_release, &vfio.group_lock);
 416 }
 417
 418 struct vfio_group_put_work {
 419         struct work_struct work;
 420         struct vfio_group *group;
 421 };
 422
 423 static void vfio_group_put_bg(struct work_struct *work)
 424 {
 425         struct vfio_group_put_work *do_work;
 426
 427         do_work = container_of(work, struct vfio_group_put_work, work);
 428
 429         vfio_group_put(do_work->group);
 430         kfree(do_work);
 431 }
 432
 433 static void vfio_group_schedule_put(struct vfio_group *group)
 434 {
 435         struct vfio_group_put_work *do_work;
 436
 437         do_work = kmalloc(sizeof(*do_work), GFP_KERNEL);
 438         if (WARN_ON(!do_work))
 439                 return;
 440
 441         INIT_WORK(&do_work->work, vfio_group_put_bg);
 442         do_work->group = group;
 443         schedule_work(&do_work->work);
 444 }
 445
 446 /* Assume group_lock or group reference is held */
 447 static void vfio_group_get(struct vfio_group *group)
 448 {
 449         kref_get(&group->kref);
 450 }
 451
 452 /*
 453  * Not really a try as we will sleep for mutex, but we need to make
 454  * sure the group pointer is valid under lock and get a reference.
 455  */
 456 static struct vfio_group *vfio_group_try_get(struct vfio_group *group)
 457 {
 458         struct vfio_group *target = group;
 459
 460         mutex_lock(&vfio.group_lock);
 461         list_for_each_entry(group, &vfio.group_list, vfio_next) {
 462                 if (group == target) {
 463                         vfio_group_get(group);
 464                         mutex_unlock(&vfio.group_lock);
 465                         return group;
 466                 }
 467         }
 468         mutex_unlock(&vfio.group_lock);
 469
 470         return NULL;
 471 }
 472
 473 static
 474 struct vfio_group *vfio_group_get_from_iommu(struct iommu_group *iommu_group)
 475 {
 476         struct vfio_group *group;
 477
 478         mutex_lock(&vfio.group_lock);
 479         list_for_each_entry(group, &vfio.group_list, vfio_next) {
 480                 if (group->iommu_group == iommu_group) {
 481                         vfio_group_get(group);
 482                         mutex_unlock(&vfio.group_lock);
 483                         return group;
 484                 }
 485         }
 486         mutex_unlock(&vfio.group_lock);
 487
 488         return NULL;
 489 }
 490
 491 static struct vfio_group *vfio_group_get_from_minor(int minor)
 492 {
 493         struct vfio_group *group;
 494
 495         mutex_lock(&vfio.group_lock);
 496         group = idr_find(&vfio.group_idr, minor);
 497         if (!group) {
 498                 mutex_unlock(&vfio.group_lock);
 499                 return NULL;
 500         }
 501         vfio_group_get(group);
 502         mutex_unlock(&vfio.group_lock);
 503
 504         return group;
 505 }
 506
 507 static struct vfio_group *vfio_group_get_from_dev(struct device *dev)
 508 {
 509         struct iommu_group *iommu_group;
 510         struct vfio_group *group;
 511
 512         iommu_group = iommu_group_get(dev);
 513         if (!iommu_group)
 514                 return NULL;
 515
 516         group = vfio_group_get_from_iommu(iommu_group);
 517         iommu_group_put(iommu_group);
 518
 519         return group;
 520 }
 521
 522 /**
 523  * Device objects - create, release, get, put, search
 524  */
 525 /* Device reference always implies a group reference */
 526 void vfio_device_put(struct vfio_device *device)
 527 {
 528         if (refcount_dec_and_test(&device->refcount))
 529                 complete(&device->comp);
 530 }
 531 EXPORT_SYMBOL_GPL(vfio_device_put);
 532
 533 static bool vfio_device_try_get(struct vfio_device *device)
 534 {
 535         return refcount_inc_not_zero(&device->refcount);
 536 }
 537
 538 static struct vfio_device *vfio_group_get_device(struct vfio_group *group,
 539                                                  struct device *dev)
 540 {
 541         struct vfio_device *device;
 542
 543         mutex_lock(&group->device_lock);
 544         list_for_each_entry(device, &group->device_list, group_next) {
 545                 if (device->dev == dev && vfio_device_try_get(device)) {
 546                         mutex_unlock(&group->device_lock);
 547                         return device;
 548                 }
 549         }
 550         mutex_unlock(&group->device_lock);
 551         return NULL;
 552 }
 553
 554 /*
 555  * Some drivers, like pci-stub, are only used to prevent other drivers from
 556  * claiming a device and are therefore perfectly legitimate for a user owned
 557  * group.  The pci-stub driver has no dependencies on DMA or the IOVA mapping
 558  * of the device, but it does prevent the user from having direct access to
 559  * the device, which is useful in some circumstances.
 560  *
 561  * We also assume that we can include PCI interconnect devices, ie. bridges.
 562  * IOMMU grouping on PCI necessitates that if we lack isolation on a bridge
 563  * then all of the downstream devices will be part of the same IOMMU group as
 564  * the bridge.  Thus, if placing the bridge into the user owned IOVA space
 565  * breaks anything, it only does so for user owned devices downstream.  Note
 566  * that error notification via MSI can be affected for platforms that handle
 567  * MSI within the same IOVA space as DMA.
 568  */
 569 static const char * const vfio_driver_allowed[] = { "pci-stub" };
 570
 571 static bool vfio_dev_driver_allowed(struct device *dev,
 572                                     struct device_driver *drv)
 573 {
 574         if (dev_is_pci(dev)) {
 575                 struct pci_dev *pdev = to_pci_dev(dev);
 576
 577                 if (pdev->hdr_type != PCI_HEADER_TYPE_NORMAL)
 578                         return true;
 579         }
 580
 581         return match_string(vfio_driver_allowed,
 582                             ARRAY_SIZE(vfio_driver_allowed),
 583                             drv->name) >= 0;
 584 }
 585
 586 /*
 587  * A vfio group is viable for use by userspace if all devices are in
 588  * one of the following states:
 589  *  - driver-less
 590  *  - bound to a vfio driver
 591  *  - bound to an otherwise allowed driver
 592  *  - a PCI interconnect device
 593  *
 594  * We use two methods to determine whether a device is bound to a vfio
 595  * driver.  The first is to test whether the device exists in the vfio
 596  * group.  The second is to test if the device exists on the group
 597  * unbound_list, indicating it's in the middle of transitioning from
 598  * a vfio driver to driver-less.
 599  */
 600 static int vfio_dev_viable(struct device *dev, void *data)
 601 {
 602         struct vfio_group *group = data;
 603         struct vfio_device *device;
 604         struct device_driver *drv = READ_ONCE(dev->driver);
 605         struct vfio_unbound_dev *unbound;
 606         int ret = -EINVAL;
 607
 608         mutex_lock(&group->unbound_lock);
 609         list_for_each_entry(unbound, &group->unbound_list, unbound_next) {
 610                 if (dev == unbound->dev) {
 611                         ret = 0;
 612                         break;
 613                 }
 614         }
 615         mutex_unlock(&group->unbound_lock);
 616
 617         if (!ret || !drv || vfio_dev_driver_allowed(dev, drv))
 618                 return 0;
 619
 620         device = vfio_group_get_device(group, dev);
 621         if (device) {
 622                 vfio_device_put(device);
 623                 return 0;
 624         }
 625
 626         return ret;
 627 }
 628
 629 /**
 630  * Async device support
 631  */
 632 static int vfio_group_nb_add_dev(struct vfio_group *group, struct device *dev)
 633 {
 634         struct vfio_device *device;
 635
 636         /* Do we already know about it?  We shouldn't */
 637         device = vfio_group_get_device(group, dev);
 638         if (WARN_ON_ONCE(device)) {
 639                 vfio_device_put(device);
 640                 return 0;
 641         }
 642
 643         /* Nothing to do for idle groups */
 644         if (!atomic_read(&group->container_users))
 645                 return 0;
 646
 647         /* TODO Prevent device auto probing */
 648         dev_WARN(dev, "Device added to live group %d!\n",
 649                  iommu_group_id(group->iommu_group));
 650
 651         return 0;
 652 }
 653
 654 static int vfio_group_nb_verify(struct vfio_group *group, struct device *dev)
 655 {
 656         /* We don't care what happens when the group isn't in use */
 657         if (!atomic_read(&group->container_users))
 658                 return 0;
 659
 660         return vfio_dev_viable(dev, group);
 661 }
 662
 663 static int vfio_iommu_group_notifier(struct notifier_block *nb,
 664                                      unsigned long action, void *data)
 665 {
 666         struct vfio_group *group = container_of(nb, struct vfio_group, nb);
 667         struct device *dev = data;
 668         struct vfio_unbound_dev *unbound;
 669
 670         /*
 671          * Need to go through a group_lock lookup to get a reference or we
 672          * risk racing a group being removed.  Ignore spurious notifies.
 673          */
 674         group = vfio_group_try_get(group);
 675         if (!group)
 676                 return NOTIFY_OK;
 677
 678         switch (action) {
 679         case IOMMU_GROUP_NOTIFY_ADD_DEVICE:
 680                 vfio_group_nb_add_dev(group, dev);
 681                 break;
 682         case IOMMU_GROUP_NOTIFY_DEL_DEVICE:
 683                 /*
 684                  * Nothing to do here.  If the device is in use, then the
 685                  * vfio sub-driver should block the remove callback until
 686                  * it is unused.  If the device is unused or attached to a
 687                  * stub driver, then it should be released and we don't
 688                  * care that it will be going away.
 689                  */
 690                 break;
 691         case IOMMU_GROUP_NOTIFY_BIND_DRIVER:
 692                 dev_dbg(dev, "%s: group %d binding to driver\n", __func__,
 693                         iommu_group_id(group->iommu_group));
 694                 break;
 695         case IOMMU_GROUP_NOTIFY_BOUND_DRIVER:
 696                 dev_dbg(dev, "%s: group %d bound to driver %s\n", __func__,
 697                         iommu_group_id(group->iommu_group), dev->driver->name);
 698                 BUG_ON(vfio_group_nb_verify(group, dev));
 699                 break;
 700         case IOMMU_GROUP_NOTIFY_UNBIND_DRIVER:
 701                 dev_dbg(dev, "%s: group %d unbinding from driver %s\n",
 702                         __func__, iommu_group_id(group->iommu_group),
 703                         dev->driver->name);
 704                 break;
 705         case IOMMU_GROUP_NOTIFY_UNBOUND_DRIVER:
 706                 dev_dbg(dev, "%s: group %d unbound from driver\n", __func__,
 707                         iommu_group_id(group->iommu_group));
 708                 /*
 709                  * XXX An unbound device in a live group is ok, but we'd
 710                  * really like to avoid the above BUG_ON by preventing other
 711                  * drivers from binding to it.  Once that occurs, we have to
 712                  * stop the system to maintain isolation.  At a minimum, we'd
 713                  * want a toggle to disable driver auto probe for this device.
 714                  */
 715
 716                 mutex_lock(&group->unbound_lock);
 717                 list_for_each_entry(unbound,
 718                                     &group->unbound_list, unbound_next) {
 719                         if (dev == unbound->dev) {
 720                                 list_del(&unbound->unbound_next);
 721                                 kfree(unbound);
 722                                 break;
 723                         }
 724                 }
 725                 mutex_unlock(&group->unbound_lock);
 726                 break;
 727         }
 728
 729         /*
 730          * If we're the last reference to the group, the group will be
 731          * released, which includes unregistering the iommu group notifier.
 732          * We hold a read-lock on that notifier list, unregistering needs
 733          * a write-lock... deadlock.  Release our reference asynchronously
 734          * to avoid that situation.
 735          */
 736         vfio_group_schedule_put(group);
 737         return NOTIFY_OK;
 738 }
 739
 740 /**
 741  * VFIO driver API
 742  */
 743 void vfio_init_group_dev(struct vfio_device *device, struct device *dev,
 744                          const struct vfio_device_ops *ops, void *device_data)
 745 {
 746         init_completion(&device->comp);
 747         device->dev = dev;
 748         device->ops = ops;
 749         device->device_data = device_data;
 750 }
 751 EXPORT_SYMBOL_GPL(vfio_init_group_dev);
 752
 753 int vfio_register_group_dev(struct vfio_device *device)
 754 {
 755         struct vfio_device *existing_device;
 756         struct iommu_group *iommu_group;
 757         struct vfio_group *group;
 758
 759         iommu_group = iommu_group_get(device->dev);
 760         if (!iommu_group)
 761                 return -EINVAL;
 762
 763         group = vfio_group_get_from_iommu(iommu_group);
 764         if (!group) {
 765                 group = vfio_create_group(iommu_group);
 766                 if (IS_ERR(group)) {
 767                         iommu_group_put(iommu_group);
 768                         return PTR_ERR(group);
 769                 }
 770         } else {
 771                 /*
 772                  * A found vfio_group already holds a reference to the
 773                  * iommu_group.  A created vfio_group keeps the reference.
 774                  */
 775                 iommu_group_put(iommu_group);
 776         }
 777
 778         existing_device = vfio_group_get_device(group, device->dev);
 779         if (existing_device) {
 780                 dev_WARN(device->dev, "Device already exists on group %d\n",
 781                          iommu_group_id(iommu_group));
 782                 vfio_device_put(existing_device);
 783                 vfio_group_put(group);
 784                 return -EBUSY;
 785         }
 786
 787         /* Our reference on group is moved to the device */
 788         device->group = group;
 789
 790         /* Refcounting can't start until the driver calls register */
 791         refcount_set(&device->refcount, 1);
 792
 793         mutex_lock(&group->device_lock);
 794         list_add(&device->group_next, &group->device_list);
 795         group->dev_counter++;
 796         mutex_unlock(&group->device_lock);
 797
 798         return 0;
 799 }
 800 EXPORT_SYMBOL_GPL(vfio_register_group_dev);
 801
 802 int vfio_add_group_dev(struct device *dev, const struct vfio_device_ops *ops,
 803                        void *device_data)
 804 {
 805         struct vfio_device *device;
 806         int ret;
 807
 808         device = kzalloc(sizeof(*device), GFP_KERNEL);
 809         if (!device)
 810                 return -ENOMEM;
 811
 812         vfio_init_group_dev(device, dev, ops, device_data);
 813         ret = vfio_register_group_dev(device);
 814         if (ret)
 815                 goto err_kfree;
 816         dev_set_drvdata(dev, device);
 817         return 0;
 818
 819 err_kfree:
 820         kfree(device);
 821         return ret;
 822 }
 823 EXPORT_SYMBOL_GPL(vfio_add_group_dev);
 824
 825 /**
 826  * Get a reference to the vfio_device for a device.  Even if the
 827  * caller thinks they own the device, they could be racing with a
 828  * release call path, so we can't trust drvdata for the shortcut.
 829  * Go the long way around, from the iommu_group to the vfio_group
 830  * to the vfio_device.
 831  */
 832 struct vfio_device *vfio_device_get_from_dev(struct device *dev)
 833 {
 834         struct vfio_group *group;
 835         struct vfio_device *device;
 836
 837         group = vfio_group_get_from_dev(dev);
 838         if (!group)
 839                 return NULL;
 840
 841         device = vfio_group_get_device(group, dev);
 842         vfio_group_put(group);
 843
 844         return device;
 845 }
 846 EXPORT_SYMBOL_GPL(vfio_device_get_from_dev);
 847
 848 static struct vfio_device *vfio_device_get_from_name(struct vfio_group *group,
 849                                                      char *buf)
 850 {
 851         struct vfio_device *it, *device = ERR_PTR(-ENODEV);
 852
 853         mutex_lock(&group->device_lock);
 854         list_for_each_entry(it, &group->device_list, group_next) {
 855                 int ret;
 856
 857                 if (it->ops->match) {
 858                         ret = it->ops->match(it->device_data, buf);
 859                         if (ret < 0) {
 860                                 device = ERR_PTR(ret);
 861                                 break;
 862                         }
 863                 } else {
 864                         ret = !strcmp(dev_name(it->dev), buf);
 865                 }
 866
 867                 if (ret && vfio_device_try_get(it)) {
 868                         device = it;
 869                         break;
 870                 }
 871         }
 872         mutex_unlock(&group->device_lock);
 873
 874         return device;
 875 }
 876
 877 /*
 878  * Caller must hold a reference to the vfio_device
 879  */
 880 void *vfio_device_data(struct vfio_device *device)
 881 {
 882         return device->device_data;
 883 }
 884 EXPORT_SYMBOL_GPL(vfio_device_data);
 885
 886 /*
 887  * Decrement the device reference count and wait for the device to be
 888  * removed.  Open file descriptors for the device... */
 889 void vfio_unregister_group_dev(struct vfio_device *device)
 890 {
 891         struct vfio_group *group = device->group;
 892         struct vfio_unbound_dev *unbound;
 893         unsigned int i = 0;
 894         bool interrupted = false;
 895         long rc;
 896
 897         /*
 898          * When the device is removed from the group, the group suddenly
 899          * becomes non-viable; the device has a driver (until the unbind
 900          * completes), but it's not present in the group.  This is bad news
 901          * for any external users that need to re-acquire a group reference
 902          * in order to match and release their existing reference.  To
 903          * solve this, we track such devices on the unbound_list to bridge
 904          * the gap until they're fully unbound.
 905          */
 906         unbound = kzalloc(sizeof(*unbound), GFP_KERNEL);
 907         if (unbound) {
 908                 unbound->dev = device->dev;
 909                 mutex_lock(&group->unbound_lock);
 910                 list_add(&unbound->unbound_next, &group->unbound_list);
 911                 mutex_unlock(&group->unbound_lock);
 912         }
 913         WARN_ON(!unbound);
 914
 915         vfio_device_put(device);
 916         rc = try_wait_for_completion(&device->comp);
 917         while (rc <= 0) {
 918                 if (device->ops->request)
 919                         device->ops->request(device->device_data, i++);
 920
 921                 if (interrupted) {
 922                         rc = wait_for_completion_timeout(&device->comp,
 923                                                          HZ * 10);
 924                 } else {
 925                         rc = wait_for_completion_interruptible_timeout(
 926                                 &device->comp, HZ * 10);
 927                         if (rc < 0) {
 928                                 interrupted = true;
 929                                 dev_warn(device->dev,
 930                                          "Device is currently in use, task"
 931                                          " \"%s\" (%d) "
 932                                          "blocked until device is released",
 933                                          current->comm, task_pid_nr(current));
 934                         }
 935                 }
 936         }
 937
 938         mutex_lock(&group->device_lock);
 939         list_del(&device->group_next);
 940         group->dev_counter--;
 941         mutex_unlock(&group->device_lock);
 942
 943         /*
 944          * In order to support multiple devices per group, devices can be
 945          * plucked from the group while other devices in the group are still
 946          * in use.  The container persists with this group and those remaining
 947          * devices still attached.  If the user creates an isolation violation
 948          * by binding this device to another driver while the group is still in
 949          * use, that's their fault.  However, in the case of removing the last,
 950          * or potentially the only, device in the group there can be no other
 951          * in-use devices in the group.  The user has done their due diligence
 952          * and we should lay no claims to those devices.  In order to do that,
 953          * we need to make sure the group is detached from the container.
 954          * Without this stall, we're potentially racing with a user process
 955          * that may attempt to immediately bind this device to another driver.
 956          */
 957         if (list_empty(&group->device_list))
 958                 wait_event(group->container_q, !group->container);
 959
 960         /* Matches the get in vfio_register_group_dev() */
 961         vfio_group_put(group);
 962 }
 963 EXPORT_SYMBOL_GPL(vfio_unregister_group_dev);
 964
 965 void *vfio_del_group_dev(struct device *dev)
 966 {
 967         struct vfio_device *device = dev_get_drvdata(dev);
 968         void *device_data = device->device_data;
 969
 970         vfio_unregister_group_dev(device);
 971         dev_set_drvdata(dev, NULL);
 972         kfree(device);
 973         return device_data;
 974 }
 975 EXPORT_SYMBOL_GPL(vfio_del_group_dev);
 976
 977 /**
 978  * VFIO base fd, /dev/vfio/vfio
 979  */
 980 static long vfio_ioctl_check_extension(struct vfio_container *container,
 981                                        unsigned long arg)
 982 {
 983         struct vfio_iommu_driver *driver;
 984         long ret = 0;
 985
 986         down_read(&container->group_lock);
 987
 988         driver = container->iommu_driver;
 989
 990         switch (arg) {
 991                 /* No base extensions yet */
 992         default:
 993                 /*
 994                  * If no driver is set, poll all registered drivers for
 995                  * extensions and return the first positive result.  If
 996                  * a driver is already set, further queries will be passed
 997                  * only to that driver.
 998                  */
 999                 if (!driver) {
1000                         mutex_lock(&vfio.iommu_drivers_lock);
1001                         list_for_each_entry(driver, &vfio.iommu_drivers_list,
1002                                             vfio_next) {
1003
1004 #ifdef CONFIG_VFIO_NOIOMMU
1005                                 if (!list_empty(&container->group_list) &&
1006                                     (container->noiommu !=
1007                                      (driver->ops == &vfio_noiommu_ops)))
1008                                         continue;
1009 #endif
1010
1011                                 if (!try_module_get(driver->ops->owner))
1012                                         continue;
1013
1014                                 ret = driver->ops->ioctl(NULL,
1015                                                          VFIO_CHECK_EXTENSION,
1016                                                          arg);
1017                                 module_put(driver->ops->owner);
1018                                 if (ret > 0)
1019                                         break;
1020                         }
1021                         mutex_unlock(&vfio.iommu_drivers_lock);
1022                 } else
1023                         ret = driver->ops->ioctl(container->iommu_data,
1024                                                  VFIO_CHECK_EXTENSION, arg);
1025         }
1026
1027         up_read(&container->group_lock);
1028
1029         return ret;
1030 }
1031
1032 /* hold write lock on container->group_lock */
1033 static int __vfio_container_attach_groups(struct vfio_container *container,
1034                                           struct vfio_iommu_driver *driver,
1035                                           void *data)
1036 {
1037         struct vfio_group *group;
1038         int ret = -ENODEV;
1039
1040         list_for_each_entry(group, &container->group_list, container_next) {
1041                 ret = driver->ops->attach_group(data, group->iommu_group);
1042                 if (ret)
1043                         goto unwind;
1044         }
1045
1046         return ret;
1047
1048 unwind:
1049         list_for_each_entry_continue_reverse(group, &container->group_list,
1050                                              container_next) {
1051                 driver->ops->detach_group(data, group->iommu_group);
1052         }
1053
1054         return ret;
1055 }
1056
1057 static long vfio_ioctl_set_iommu(struct vfio_container *container,
1058                                  unsigned long arg)
1059 {
1060         struct vfio_iommu_driver *driver;
1061         long ret = -ENODEV;
1062
1063         down_write(&container->group_lock);
1064
1065         /*
1066          * The container is designed to be an unprivileged interface while
1067          * the group can be assigned to specific users.  Therefore, only by
1068          * adding a group to a container does the user get the privilege of
1069          * enabling the iommu, which may allocate finite resources.  There
1070          * is no unset_iommu, but by removing all the groups from a container,
1071          * the container is deprivileged and returns to an unset state.
1072          */
1073         if (list_empty(&container->group_list) || container->iommu_driver) {
1074                 up_write(&container->group_lock);
1075                 return -EINVAL;
1076         }
1077
1078         mutex_lock(&vfio.iommu_drivers_lock);
1079         list_for_each_entry(driver, &vfio.iommu_drivers_list, vfio_next) {
1080                 void *data;
1081
1082 #ifdef CONFIG_VFIO_NOIOMMU
1083                 /*
1084                  * Only noiommu containers can use vfio-noiommu and noiommu
1085                  * containers can only use vfio-noiommu.
1086                  */
1087                 if (container->noiommu != (driver->ops == &vfio_noiommu_ops))
1088                         continue;
1089 #endif
1090
1091                 if (!try_module_get(driver->ops->owner))
1092                         continue;
1093
1094                 /*
1095                  * The arg magic for SET_IOMMU is the same as CHECK_EXTENSION,
1096                  * so test which iommu driver reported support for this
1097                  * extension and call open on them.  We also pass them the
1098                  * magic, allowing a single driver to support multiple
1099                  * interfaces if they'd like.
1100                  */
1101                 if (driver->ops->ioctl(NULL, VFIO_CHECK_EXTENSION, arg) <= 0) {
1102                         module_put(driver->ops->owner);
1103                         continue;
1104                 }
1105
1106                 data = driver->ops->open(arg);
1107                 if (IS_ERR(data)) {
1108                         ret = PTR_ERR(data);
1109                         module_put(driver->ops->owner);
1110                         continue;
1111                 }
1112
1113                 ret = __vfio_container_attach_groups(container, driver, data);
1114                 if (ret) {
1115                         driver->ops->release(data);
1116                         module_put(driver->ops->owner);
1117                         continue;
1118                 }
1119
1120                 container->iommu_driver = driver;
1121                 container->iommu_data = data;
1122                 break;
1123         }
1124
1125         mutex_unlock(&vfio.iommu_drivers_lock);
1126         up_write(&container->group_lock);
1127
1128         return ret;
1129 }
1130
1131 static long vfio_fops_unl_ioctl(struct file *filep,
1132                                 unsigned int cmd, unsigned long arg)
1133 {
1134         struct vfio_container *container = filep->private_data;
1135         struct vfio_iommu_driver *driver;
1136         void *data;
1137         long ret = -EINVAL;
1138
1139         if (!container)
1140                 return ret;
1141
1142         switch (cmd) {
1143         case VFIO_GET_API_VERSION:
1144                 ret = VFIO_API_VERSION;
1145                 break;
1146         case VFIO_CHECK_EXTENSION:
1147                 ret = vfio_ioctl_check_extension(container, arg);
1148                 break;
1149         case VFIO_SET_IOMMU:
1150                 ret = vfio_ioctl_set_iommu(container, arg);
1151                 break;
1152         default:
1153                 driver = container->iommu_driver;
1154                 data = container->iommu_data;
1155
1156                 if (driver) /* passthrough all unrecognized ioctls */
1157                         ret = driver->ops->ioctl(data, cmd, arg);
1158         }
1159
1160         return ret;
1161 }
1162
1163 static int vfio_fops_open(struct inode *inode, struct file *filep)
1164 {
1165         struct vfio_container *container;
1166
1167         container = kzalloc(sizeof(*container), GFP_KERNEL);
1168         if (!container)
1169                 return -ENOMEM;
1170
1171         INIT_LIST_HEAD(&container->group_list);
1172         init_rwsem(&container->group_lock);
1173         kref_init(&container->kref);
1174
1175         filep->private_data = container;
1176
1177         return 0;
1178 }
1179
1180 static int vfio_fops_release(struct inode *inode, struct file *filep)
1181 {
1182         struct vfio_container *container = filep->private_data;
1183         struct vfio_iommu_driver *driver = container->iommu_driver;
1184
1185         if (driver && driver->ops->notify)
1186                 driver->ops->notify(container->iommu_data,
1187                                     VFIO_IOMMU_CONTAINER_CLOSE);
1188
1189         filep->private_data = NULL;
1190
1191         vfio_container_put(container);
1192
1193         return 0;
1194 }
1195
1196 /*
1197  * Once an iommu driver is set, we optionally pass read/write/mmap
1198  * on to the driver, allowing management interfaces beyond ioctl.
1199  */
1200 static ssize_t vfio_fops_read(struct file *filep, char __user *buf,
1201                               size_t count, loff_t *ppos)
1202 {
1203         struct vfio_container *container = filep->private_data;
1204         struct vfio_iommu_driver *driver;
1205         ssize_t ret = -EINVAL;
1206
1207         driver = container->iommu_driver;
1208         if (likely(driver && driver->ops->read))
1209                 ret = driver->ops->read(container->iommu_data,
1210                                         buf, count, ppos);
1211
1212         return ret;
1213 }
1214
1215 static ssize_t vfio_fops_write(struct file *filep, const char __user *buf,
1216                                size_t count, loff_t *ppos)
1217 {
1218         struct vfio_container *container = filep->private_data;
1219         struct vfio_iommu_driver *driver;
1220         ssize_t ret = -EINVAL;
1221
1222         driver = container->iommu_driver;
1223         if (likely(driver && driver->ops->write))
1224                 ret = driver->ops->write(container->iommu_data,
1225                                          buf, count, ppos);
1226
1227         return ret;
1228 }
1229
1230 static int vfio_fops_mmap(struct file *filep, struct vm_area_struct *vma)
1231 {
1232         struct vfio_container *container = filep->private_data;
1233         struct vfio_iommu_driver *driver;
1234         int ret = -EINVAL;
1235
1236         driver = container->iommu_driver;
1237         if (likely(driver && driver->ops->mmap))
1238                 ret = driver->ops->mmap(container->iommu_data, vma);
1239
1240         return ret;
1241 }
1242
1243 static const struct file_operations vfio_fops = {
1244         .owner          = THIS_MODULE,
1245         .open           = vfio_fops_open,
1246         .release        = vfio_fops_release,
1247         .read           = vfio_fops_read,
1248         .write          = vfio_fops_write,
1249         .unlocked_ioctl = vfio_fops_unl_ioctl,
1250         .compat_ioctl   = compat_ptr_ioctl,
1251         .mmap           = vfio_fops_mmap,
1252 };
1253
1254 /**
1255  * VFIO Group fd, /dev/vfio/$GROUP
1256  */
1257 static void __vfio_group_unset_container(struct vfio_group *group)
1258 {
1259         struct vfio_container *container = group->container;
1260         struct vfio_iommu_driver *driver;
1261
1262         down_write(&container->group_lock);
1263
1264         driver = container->iommu_driver;
1265         if (driver)
1266                 driver->ops->detach_group(container->iommu_data,
1267                                           group->iommu_group);
1268
1269         group->container = NULL;
1270         wake_up(&group->container_q);
1271         list_del(&group->container_next);
1272
1273         /* Detaching the last group deprivileges a container, remove iommu */
1274         if (driver && list_empty(&container->group_list)) {
1275                 driver->ops->release(container->iommu_data);
1276                 module_put(driver->ops->owner);
1277                 container->iommu_driver = NULL;
1278                 container->iommu_data = NULL;
1279         }
1280
1281         up_write(&container->group_lock);
1282
1283         vfio_container_put(container);
1284 }
1285
1286 /*
1287  * VFIO_GROUP_UNSET_CONTAINER should fail if there are other users or
1288  * if there was no container to unset.  Since the ioctl is called on
1289  * the group, we know that still exists, therefore the only valid
1290  * transition here is 1->0.
1291  */
1292 static int vfio_group_unset_container(struct vfio_group *group)
1293 {
1294         int users = atomic_cmpxchg(&group->container_users, 1, 0);
1295
1296         if (!users)
1297                 return -EINVAL;
1298         if (users != 1)
1299                 return -EBUSY;
1300
1301         __vfio_group_unset_container(group);
1302
1303         return 0;
1304 }
1305
1306 /*
1307  * When removing container users, anything that removes the last user
1308  * implicitly removes the group from the container.  That is, if the
1309  * group file descriptor is closed, as well as any device file descriptors,
1310  * the group is free.
1311  */
1312 static void vfio_group_try_dissolve_container(struct vfio_group *group)
1313 {
1314         if (0 == atomic_dec_if_positive(&group->container_users))
1315                 __vfio_group_unset_container(group);
1316 }
1317
1318 static int vfio_group_set_container(struct vfio_group *group, int container_fd)
1319 {
1320         struct fd f;
1321         struct vfio_container *container;
1322         struct vfio_iommu_driver *driver;
1323         int ret = 0;
1324
1325         if (atomic_read(&group->container_users))
1326                 return -EINVAL;
1327
1328         if (group->noiommu && !capable(CAP_SYS_RAWIO))
1329                 return -EPERM;
1330
1331         f = fdget(container_fd);
1332         if (!f.file)
1333                 return -EBADF;
1334
1335         /* Sanity check, is this really our fd? */
1336         if (f.file->f_op != &vfio_fops) {
1337                 fdput(f);
1338                 return -EINVAL;
1339         }
1340
1341         container = f.file->private_data;
1342         WARN_ON(!container); /* fget ensures we don't race vfio_release */
1343
1344         down_write(&container->group_lock);
1345
1346         /* Real groups and fake groups cannot mix */
1347         if (!list_empty(&container->group_list) &&
1348             container->noiommu != group->noiommu) {
1349                 ret = -EPERM;
1350                 goto unlock_out;
1351         }
1352
1353         driver = container->iommu_driver;
1354         if (driver) {
1355                 ret = driver->ops->attach_group(container->iommu_data,
1356                                                 group->iommu_group);
1357                 if (ret)
1358                         goto unlock_out;
1359         }
1360
1361         group->container = container;
1362         container->noiommu = group->noiommu;
1363         list_add(&group->container_next, &container->group_list);
1364
1365         /* Get a reference on the container and mark a user within the group */
1366         vfio_container_get(container);
1367         atomic_inc(&group->container_users);
1368
1369 unlock_out:
1370         up_write(&container->group_lock);
1371         fdput(f);
1372         return ret;
1373 }
1374
1375 static bool vfio_group_viable(struct vfio_group *group)
1376 {
1377         return (iommu_group_for_each_dev(group->iommu_group,
1378                                          group, vfio_dev_viable) == 0);
1379 }
1380
1381 static int vfio_group_add_container_user(struct vfio_group *group)
1382 {
1383         if (!atomic_inc_not_zero(&group->container_users))
1384                 return -EINVAL;
1385
1386         if (group->noiommu) {
1387                 atomic_dec(&group->container_users);
1388                 return -EPERM;
1389         }
1390         if (!group->container->iommu_driver || !vfio_group_viable(group)) {
1391                 atomic_dec(&group->container_users);
1392                 return -EINVAL;
1393         }
1394
1395         return 0;
1396 }
1397
1398 static const struct file_operations vfio_device_fops;
1399
1400 static int vfio_group_get_device_fd(struct vfio_group *group, char *buf)
1401 {
1402         struct vfio_device *device;
1403         struct file *filep;
1404         int ret;
1405
1406         if (0 == atomic_read(&group->container_users) ||
1407             !group->container->iommu_driver || !vfio_group_viable(group))
1408                 return -EINVAL;
1409
1410         if (group->noiommu && !capable(CAP_SYS_RAWIO))
1411                 return -EPERM;
1412
1413         device = vfio_device_get_from_name(group, buf);
1414         if (IS_ERR(device))
1415                 return PTR_ERR(device);
1416
1417         ret = device->ops->open(device->device_data);
1418         if (ret) {
1419                 vfio_device_put(device);
1420                 return ret;
1421         }
1422
1423         /*
1424          * We can't use anon_inode_getfd() because we need to modify
1425          * the f_mode flags directly to allow more than just ioctls
1426          */
1427         ret = get_unused_fd_flags(O_CLOEXEC);
1428         if (ret < 0) {
1429                 device->ops->release(device->device_data);
1430                 vfio_device_put(device);
1431                 return ret;
1432         }
1433
1434         filep = anon_inode_getfile("[vfio-device]", &vfio_device_fops,
1435                                    device, O_RDWR);
1436         if (IS_ERR(filep)) {
1437                 put_unused_fd(ret);
1438                 ret = PTR_ERR(filep);
1439                 device->ops->release(device->device_data);
1440                 vfio_device_put(device);
1441                 return ret;
1442         }
1443
1444         /*
1445          * TODO: add an anon_inode interface to do this.
1446          * Appears to be missing by lack of need rather than
1447          * explicitly prevented.  Now there's need.
1448          */
1449         filep->f_mode |= (FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE);
1450
1451         atomic_inc(&group->container_users);
1452
1453         fd_install(ret, filep);
1454
1455         if (group->noiommu)
1456                 dev_warn(device->dev, "vfio-noiommu device opened by user "
1457                          "(%s:%d)\n", current->comm, task_pid_nr(current));
1458
1459         return ret;
1460 }
1461
1462 static long vfio_group_fops_unl_ioctl(struct file *filep,
1463                                       unsigned int cmd, unsigned long arg)
1464 {
1465         struct vfio_group *group = filep->private_data;
1466         long ret = -ENOTTY;
1467
1468         switch (cmd) {
1469         case VFIO_GROUP_GET_STATUS:
1470         {
1471                 struct vfio_group_status status;
1472                 unsigned long minsz;
1473
1474                 minsz = offsetofend(struct vfio_group_status, flags);
1475
1476                 if (copy_from_user(&status, (void __user *)arg, minsz))
1477                         return -EFAULT;
1478
1479                 if (status.argsz < minsz)
1480                         return -EINVAL;
1481
1482                 status.flags = 0;
1483
1484                 if (vfio_group_viable(group))
1485                         status.flags |= VFIO_GROUP_FLAGS_VIABLE;
1486
1487                 if (group->container)
1488                         status.flags |= VFIO_GROUP_FLAGS_CONTAINER_SET;
1489
1490                 if (copy_to_user((void __user *)arg, &status, minsz))
1491                         return -EFAULT;
1492
1493                 ret = 0;
1494                 break;
1495         }
1496         case VFIO_GROUP_SET_CONTAINER:
1497         {
1498                 int fd;
1499
1500                 if (get_user(fd, (int __user *)arg))
1501                         return -EFAULT;
1502
1503                 if (fd < 0)
1504                         return -EINVAL;
1505
1506                 ret = vfio_group_set_container(group, fd);
1507                 break;
1508         }
1509         case VFIO_GROUP_UNSET_CONTAINER:
1510                 ret = vfio_group_unset_container(group);
1511                 break;
1512         case VFIO_GROUP_GET_DEVICE_FD:
1513         {
1514                 char *buf;
1515
1516                 buf = strndup_user((const char __user *)arg, PAGE_SIZE);
1517                 if (IS_ERR(buf))
1518                         return PTR_ERR(buf);
1519
1520                 ret = vfio_group_get_device_fd(group, buf);
1521                 kfree(buf);
1522                 break;
1523         }
1524         }
1525
1526         return ret;
1527 }
1528
1529 static int vfio_group_fops_open(struct inode *inode, struct file *filep)
1530 {
1531         struct vfio_group *group;
1532         int opened;
1533
1534         group = vfio_group_get_from_minor(iminor(inode));
1535         if (!group)
1536                 return -ENODEV;
1537
1538         if (group->noiommu && !capable(CAP_SYS_RAWIO)) {
1539                 vfio_group_put(group);
1540                 return -EPERM;
1541         }
1542
1543         /* Do we need multiple instances of the group open?  Seems not. */
1544         opened = atomic_cmpxchg(&group->opened, 0, 1);
1545         if (opened) {
1546                 vfio_group_put(group);
1547                 return -EBUSY;
1548         }
1549
1550         /* Is something still in use from a previous open? */
1551         if (group->container) {
1552                 atomic_dec(&group->opened);
1553                 vfio_group_put(group);
1554                 return -EBUSY;
1555         }
1556
1557         /* Warn if previous user didn't cleanup and re-init to drop them */
1558         if (WARN_ON(group->notifier.head))
1559                 BLOCKING_INIT_NOTIFIER_HEAD(&group->notifier);
1560
1561         filep->private_data = group;
1562
1563         return 0;
1564 }
1565
1566 static int vfio_group_fops_release(struct inode *inode, struct file *filep)
1567 {
1568         struct vfio_group *group = filep->private_data;
1569
1570         filep->private_data = NULL;
1571
1572         vfio_group_try_dissolve_container(group);
1573
1574         atomic_dec(&group->opened);
1575
1576         vfio_group_put(group);
1577
1578         return 0;
1579 }
1580
1581 static const struct file_operations vfio_group_fops = {
1582         .owner          = THIS_MODULE,
1583         .unlocked_ioctl = vfio_group_fops_unl_ioctl,
1584         .compat_ioctl   = compat_ptr_ioctl,
1585         .open           = vfio_group_fops_open,
1586         .release        = vfio_group_fops_release,
1587 };
1588
1589 /**
1590  * VFIO Device fd
1591  */
1592 static int vfio_device_fops_release(struct inode *inode, struct file *filep)
1593 {
1594         struct vfio_device *device = filep->private_data;
1595
1596         device->ops->release(device->device_data);
1597
1598         vfio_group_try_dissolve_container(device->group);
1599
1600         vfio_device_put(device);
1601
1602         return 0;
1603 }
1604
1605 static long vfio_device_fops_unl_ioctl(struct file *filep,
1606                                        unsigned int cmd, unsigned long arg)
1607 {
1608         struct vfio_device *device = filep->private_data;
1609
1610         if (unlikely(!device->ops->ioctl))
1611                 return -EINVAL;
1612
1613         return device->ops->ioctl(device->device_data, cmd, arg);
1614 }
1615
1616 static ssize_t vfio_device_fops_read(struct file *filep, char __user *buf,
1617                                      size_t count, loff_t *ppos)
1618 {
1619         struct vfio_device *device = filep->private_data;
1620
1621         if (unlikely(!device->ops->read))
1622                 return -EINVAL;
1623
1624         return device->ops->read(device->device_data, buf, count, ppos);
1625 }
1626
1627 static ssize_t vfio_device_fops_write(struct file *filep,
1628                                       const char __user *buf,
1629                                       size_t count, loff_t *ppos)
1630 {
1631         struct vfio_device *device = filep->private_data;
1632
1633         if (unlikely(!device->ops->write))
1634                 return -EINVAL;
1635
1636         return device->ops->write(device->device_data, buf, count, ppos);
1637 }
1638
1639 static int vfio_device_fops_mmap(struct file *filep, struct vm_area_struct *vma)
1640 {
1641         struct vfio_device *device = filep->private_data;
1642
1643         if (unlikely(!device->ops->mmap))
1644                 return -EINVAL;
1645
1646         return device->ops->mmap(device->device_data, vma);
1647 }
1648
1649 static const struct file_operations vfio_device_fops = {
1650         .owner          = THIS_MODULE,
1651         .release        = vfio_device_fops_release,
1652         .read           = vfio_device_fops_read,
1653         .write          = vfio_device_fops_write,
1654         .unlocked_ioctl = vfio_device_fops_unl_ioctl,
1655         .compat_ioctl   = compat_ptr_ioctl,
1656         .mmap           = vfio_device_fops_mmap,
1657 };
1658
1659 /**
1660  * External user API, exported by symbols to be linked dynamically.
1661  *
1662  * The protocol includes:
1663  *  1. do normal VFIO init operation:
1664  *      - opening a new container;
1665  *      - attaching group(s) to it;
1666  *      - setting an IOMMU driver for a container.
1667  * When IOMMU is set for a container, all groups in it are
1668  * considered ready to use by an external user.
1669  *
1670  * 2. User space passes a group fd to an external user.
1671  * The external user calls vfio_group_get_external_user()
1672  * to verify that:
1673  *      - the group is initialized;
1674  *      - IOMMU is set for it.
1675  * If both checks passed, vfio_group_get_external_user()
1676  * increments the container user counter to prevent
1677  * the VFIO group from disposal before KVM exits.
1678  *
1679  * 3. The external user calls vfio_external_user_iommu_id()
1680  * to know an IOMMU ID.
1681  *
1682  * 4. When the external KVM finishes, it calls
1683  * vfio_group_put_external_user() to release the VFIO group.
1684  * This call decrements the container user counter.
1685  */
1686 struct vfio_group *vfio_group_get_external_user(struct file *filep)
1687 {
1688         struct vfio_group *group = filep->private_data;
1689         int ret;
1690
1691         if (filep->f_op != &vfio_group_fops)
1692                 return ERR_PTR(-EINVAL);
1693
1694         ret = vfio_group_add_container_user(group);
1695         if (ret)
1696                 return ERR_PTR(ret);
1697
1698         vfio_group_get(group);
1699
1700         return group;
1701 }
1702 EXPORT_SYMBOL_GPL(vfio_group_get_external_user);
1703
1704 /**
1705  * External user API, exported by symbols to be linked dynamically.
1706  * The external user passes in a device pointer
1707  * to verify that:
1708  *      - A VFIO group is assiciated with the device;
1709  *      - IOMMU is set for the group.
1710  * If both checks passed, vfio_group_get_external_user_from_dev()
1711  * increments the container user counter to prevent the VFIO group
1712  * from disposal before external user exits and returns the pointer
1713  * to the VFIO group.
1714  *
1715  * When the external user finishes using the VFIO group, it calls
1716  * vfio_group_put_external_user() to release the VFIO group and
1717  * decrement the container user counter.
1718  *
1719  * @dev [in]    : device
1720  * Return error PTR or pointer to VFIO group.
1721  */
1722
1723 struct vfio_group *vfio_group_get_external_user_from_dev(struct device *dev)
1724 {
1725         struct vfio_group *group;
1726         int ret;
1727
1728         group = vfio_group_get_from_dev(dev);
1729         if (!group)
1730                 return ERR_PTR(-ENODEV);
1731
1732         ret = vfio_group_add_container_user(group);
1733         if (ret) {
1734                 vfio_group_put(group);
1735                 return ERR_PTR(ret);
1736         }
1737
1738         return group;
1739 }
1740 EXPORT_SYMBOL_GPL(vfio_group_get_external_user_from_dev);
1741
1742 void vfio_group_put_external_user(struct vfio_group *group)
1743 {
1744         vfio_group_try_dissolve_container(group);
1745         vfio_group_put(group);
1746 }
1747 EXPORT_SYMBOL_GPL(vfio_group_put_external_user);
1748
1749 bool vfio_external_group_match_file(struct vfio_group *test_group,
1750                                     struct file *filep)
1751 {
1752         struct vfio_group *group = filep->private_data;
1753
1754         return (filep->f_op == &vfio_group_fops) && (group == test_group);
1755 }
1756 EXPORT_SYMBOL_GPL(vfio_external_group_match_file);
1757
1758 int vfio_external_user_iommu_id(struct vfio_group *group)
1759 {
1760         return iommu_group_id(group->iommu_group);
1761 }
1762 EXPORT_SYMBOL_GPL(vfio_external_user_iommu_id);
1763
1764 long vfio_external_check_extension(struct vfio_group *group, unsigned long arg)
1765 {
1766         return vfio_ioctl_check_extension(group->container, arg);
1767 }
1768 EXPORT_SYMBOL_GPL(vfio_external_check_extension);
1769
1770 /**
1771  * Sub-module support
1772  */
1773 /*
1774  * Helper for managing a buffer of info chain capabilities, allocate or
1775  * reallocate a buffer with additional @size, filling in @id and @version
1776  * of the capability.  A pointer to the new capability is returned.
1777  *
1778  * NB. The chain is based at the head of the buffer, so new entries are
1779  * added to the tail, vfio_info_cap_shift() should be called to fixup the
1780  * next offsets prior to copying to the user buffer.
1781  */
1782 struct vfio_info_cap_header *vfio_info_cap_add(struct vfio_info_cap *caps,
1783                                                size_t size, u16 id, u16 version)
1784 {
1785         void *buf;
1786         struct vfio_info_cap_header *header, *tmp;
1787
1788         buf = krealloc(caps->buf, caps->size + size, GFP_KERNEL);
1789         if (!buf) {
1790                 kfree(caps->buf);
1791                 caps->size = 0;
1792                 return ERR_PTR(-ENOMEM);
1793         }
1794
1795         caps->buf = buf;
1796         header = buf + caps->size;
1797
1798         /* Eventually copied to user buffer, zero */
1799         memset(header, 0, size);
1800
1801         header->id = id;
1802         header->version = version;
1803
1804         /* Add to the end of the capability chain */
1805         for (tmp = buf; tmp->next; tmp = buf + tmp->next)
1806                 ; /* nothing */
1807
1808         tmp->next = caps->size;
1809         caps->size += size;
1810
1811         return header;
1812 }
1813 EXPORT_SYMBOL_GPL(vfio_info_cap_add);
1814
1815 void vfio_info_cap_shift(struct vfio_info_cap *caps, size_t offset)
1816 {
1817         struct vfio_info_cap_header *tmp;
1818         void *buf = (void *)caps->buf;
1819
1820         for (tmp = buf; tmp->next; tmp = buf + tmp->next - offset)
1821                 tmp->next += offset;
1822 }
1823 EXPORT_SYMBOL(vfio_info_cap_shift);
1824
1825 int vfio_info_add_capability(struct vfio_info_cap *caps,
1826                              struct vfio_info_cap_header *cap, size_t size)
1827 {
1828         struct vfio_info_cap_header *header;
1829
1830         header = vfio_info_cap_add(caps, size, cap->id, cap->version);
1831         if (IS_ERR(header))
1832                 return PTR_ERR(header);
1833
1834         memcpy(header + 1, cap + 1, size - sizeof(*header));
1835
1836         return 0;
1837 }
1838 EXPORT_SYMBOL(vfio_info_add_capability);
1839
1840 int vfio_set_irqs_validate_and_prepare(struct vfio_irq_set *hdr, int num_irqs,
1841                                        int max_irq_type, size_t *data_size)
1842 {
1843         unsigned long minsz;
1844         size_t size;
1845
1846         minsz = offsetofend(struct vfio_irq_set, count);
1847
1848         if ((hdr->argsz < minsz) || (hdr->index >= max_irq_type) ||
1849             (hdr->count >= (U32_MAX - hdr->start)) ||
1850             (hdr->flags & ~(VFIO_IRQ_SET_DATA_TYPE_MASK |
1851                                 VFIO_IRQ_SET_ACTION_TYPE_MASK)))
1852                 return -EINVAL;
1853
1854         if (data_size)
1855                 *data_size = 0;
1856
1857         if (hdr->start >= num_irqs || hdr->start + hdr->count > num_irqs)
1858                 return -EINVAL;
1859
1860         switch (hdr->flags & VFIO_IRQ_SET_DATA_TYPE_MASK) {
1861         case VFIO_IRQ_SET_DATA_NONE:
1862                 size = 0;
1863                 break;
1864         case VFIO_IRQ_SET_DATA_BOOL:
1865                 size = sizeof(uint8_t);
1866                 break;
1867         case VFIO_IRQ_SET_DATA_EVENTFD:
1868                 size = sizeof(int32_t);
1869                 break;
1870         default:
1871                 return -EINVAL;
1872         }
1873
1874         if (size) {
1875                 if (hdr->argsz - minsz < hdr->count * size)
1876                         return -EINVAL;
1877
1878                 if (!data_size)
1879                         return -EINVAL;
1880
1881                 *data_size = hdr->count * size;
1882         }
1883
1884         return 0;
1885 }
1886 EXPORT_SYMBOL(vfio_set_irqs_validate_and_prepare);
1887
1888 /*
1889  * Pin a set of guest PFNs and return their associated host PFNs for local
1890  * domain only.
1891  * @dev [in]     : device
1892  * @user_pfn [in]: array of user/guest PFNs to be pinned.
1893  * @npage [in]   : count of elements in user_pfn array.  This count should not
1894  *                 be greater VFIO_PIN_PAGES_MAX_ENTRIES.
1895  * @prot [in]    : protection flags
1896  * @phys_pfn[out]: array of host PFNs
1897  * Return error or number of pages pinned.
1898  */
1899 int vfio_pin_pages(struct device *dev, unsigned long *user_pfn, int npage,
1900                    int prot, unsigned long *phys_pfn)
1901 {
1902         struct vfio_container *container;
1903         struct vfio_group *group;
1904         struct vfio_iommu_driver *driver;
1905         int ret;
1906
1907         if (!dev || !user_pfn || !phys_pfn || !npage)
1908                 return -EINVAL;
1909
1910         if (npage > VFIO_PIN_PAGES_MAX_ENTRIES)
1911                 return -E2BIG;
1912
1913         group = vfio_group_get_from_dev(dev);
1914         if (!group)
1915                 return -ENODEV;
1916
1917         if (group->dev_counter > 1) {
1918                 ret = -EINVAL;
1919                 goto err_pin_pages;
1920         }
1921
1922         ret = vfio_group_add_container_user(group);
1923         if (ret)
1924                 goto err_pin_pages;
1925
1926         container = group->container;
1927         driver = container->iommu_driver;
1928         if (likely(driver && driver->ops->pin_pages))
1929                 ret = driver->ops->pin_pages(container->iommu_data,
1930                                              group->iommu_group, user_pfn,
1931                                              npage, prot, phys_pfn);
1932         else
1933                 ret = -ENOTTY;
1934
1935         vfio_group_try_dissolve_container(group);
1936
1937 err_pin_pages:
1938         vfio_group_put(group);
1939         return ret;
1940 }
1941 EXPORT_SYMBOL(vfio_pin_pages);
1942
1943 /*
1944  * Unpin set of host PFNs for local domain only.
1945  * @dev [in]     : device
1946  * @user_pfn [in]: array of user/guest PFNs to be unpinned. Number of user/guest
1947  *                 PFNs should not be greater than VFIO_PIN_PAGES_MAX_ENTRIES.
1948  * @npage [in]   : count of elements in user_pfn array.  This count should not
1949  *                 be greater than VFIO_PIN_PAGES_MAX_ENTRIES.
1950  * Return error or number of pages unpinned.
1951  */
1952 int vfio_unpin_pages(struct device *dev, unsigned long *user_pfn, int npage)
1953 {
1954         struct vfio_container *container;
1955         struct vfio_group *group;
1956         struct vfio_iommu_driver *driver;
1957         int ret;
1958
1959         if (!dev || !user_pfn || !npage)
1960                 return -EINVAL;
1961
1962         if (npage > VFIO_PIN_PAGES_MAX_ENTRIES)
1963                 return -E2BIG;
1964
1965         group = vfio_group_get_from_dev(dev);
1966         if (!group)
1967                 return -ENODEV;
1968
1969         ret = vfio_group_add_container_user(group);
1970         if (ret)
1971                 goto err_unpin_pages;
1972
1973         container = group->container;
1974         driver = container->iommu_driver;
1975         if (likely(driver && driver->ops->unpin_pages))
1976                 ret = driver->ops->unpin_pages(container->iommu_data, user_pfn,
1977                                                npage);
1978         else
1979                 ret = -ENOTTY;
1980
1981         vfio_group_try_dissolve_container(group);
1982
1983 err_unpin_pages:
1984         vfio_group_put(group);
1985         return ret;
1986 }
1987 EXPORT_SYMBOL(vfio_unpin_pages);
1988
1989 /*
1990  * Pin a set of guest IOVA PFNs and return their associated host PFNs for a
1991  * VFIO group.
1992  *
1993  * The caller needs to call vfio_group_get_external_user() or
1994  * vfio_group_get_external_user_from_dev() prior to calling this interface,
1995  * so as to prevent the VFIO group from disposal in the middle of the call.
1996  * But it can keep the reference to the VFIO group for several calls into
1997  * this interface.
1998  * After finishing using of the VFIO group, the caller needs to release the
1999  * VFIO group by calling vfio_group_put_external_user().
2000  *
2001  * @group [in]          : VFIO group
2002  * @user_iova_pfn [in]  : array of user/guest IOVA PFNs to be pinned.
2003  * @npage [in]          : count of elements in user_iova_pfn array.
2004  *                        This count should not be greater
2005  *                        VFIO_PIN_PAGES_MAX_ENTRIES.
2006  * @prot [in]           : protection flags
2007  * @phys_pfn [out]      : array of host PFNs
2008  * Return error or number of pages pinned.
2009  */
2010 int vfio_group_pin_pages(struct vfio_group *group,
2011                          unsigned long *user_iova_pfn, int npage,
2012                          int prot, unsigned long *phys_pfn)
2013 {
2014         struct vfio_container *container;
2015         struct vfio_iommu_driver *driver;
2016         int ret;
2017
2018         if (!group || !user_iova_pfn || !phys_pfn || !npage)
2019                 return -EINVAL;
2020
2021         if (group->dev_counter > 1)
2022                 return -EINVAL;
2023
2024         if (npage > VFIO_PIN_PAGES_MAX_ENTRIES)
2025                 return -E2BIG;
2026
2027         container = group->container;
2028         driver = container->iommu_driver;
2029         if (likely(driver && driver->ops->pin_pages))
2030                 ret = driver->ops->pin_pages(container->iommu_data,
2031                                              group->iommu_group, user_iova_pfn,
2032                                              npage, prot, phys_pfn);
2033         else
2034                 ret = -ENOTTY;
2035
2036         return ret;
2037 }
2038 EXPORT_SYMBOL(vfio_group_pin_pages);
2039
2040 /*
2041  * Unpin a set of guest IOVA PFNs for a VFIO group.
2042  *
2043  * The caller needs to call vfio_group_get_external_user() or
2044  * vfio_group_get_external_user_from_dev() prior to calling this interface,
2045  * so as to prevent the VFIO group from disposal in the middle of the call.
2046  * But it can keep the reference to the VFIO group for several calls into
2047  * this interface.
2048  * After finishing using of the VFIO group, the caller needs to release the
2049  * VFIO group by calling vfio_group_put_external_user().
2050  *
2051  * @group [in]          : vfio group
2052  * @user_iova_pfn [in]  : array of user/guest IOVA PFNs to be unpinned.
2053  * @npage [in]          : count of elements in user_iova_pfn array.
2054  *                        This count should not be greater than
2055  *                        VFIO_PIN_PAGES_MAX_ENTRIES.
2056  * Return error or number of pages unpinned.
2057  */
2058 int vfio_group_unpin_pages(struct vfio_group *group,
2059                            unsigned long *user_iova_pfn, int npage)
2060 {
2061         struct vfio_container *container;
2062         struct vfio_iommu_driver *driver;
2063         int ret;
2064
2065         if (!group || !user_iova_pfn || !npage)
2066                 return -EINVAL;
2067
2068         if (npage > VFIO_PIN_PAGES_MAX_ENTRIES)
2069                 return -E2BIG;
2070
2071         container = group->container;
2072         driver = container->iommu_driver;
2073         if (likely(driver && driver->ops->unpin_pages))
2074                 ret = driver->ops->unpin_pages(container->iommu_data,
2075                                                user_iova_pfn, npage);
2076         else
2077                 ret = -ENOTTY;
2078
2079         return ret;
2080 }
2081 EXPORT_SYMBOL(vfio_group_unpin_pages);
2082
2083
2084 /*
2085  * This interface allows the CPUs to perform some sort of virtual DMA on
2086  * behalf of the device.
2087  *
2088  * CPUs read/write from/into a range of IOVAs pointing to user space memory
2089  * into/from a kernel buffer.
2090  *
2091  * As the read/write of user space memory is conducted via the CPUs and is
2092  * not a real device DMA, it is not necessary to pin the user space memory.
2093  *
2094  * The caller needs to call vfio_group_get_external_user() or
2095  * vfio_group_get_external_user_from_dev() prior to calling this interface,
2096  * so as to prevent the VFIO group from disposal in the middle of the call.
2097  * But it can keep the reference to the VFIO group for several calls into
2098  * this interface.
2099  * After finishing using of the VFIO group, the caller needs to release the
2100  * VFIO group by calling vfio_group_put_external_user().
2101  *
2102  * @group [in]          : VFIO group
2103  * @user_iova [in]      : base IOVA of a user space buffer
2104  * @data [in]           : pointer to kernel buffer
2105  * @len [in]            : kernel buffer length
2106  * @write               : indicate read or write
2107  * Return error code on failure or 0 on success.
2108  */
2109 int vfio_dma_rw(struct vfio_group *group, dma_addr_t user_iova,
2110                 void *data, size_t len, bool write)
2111 {
2112         struct vfio_container *container;
2113         struct vfio_iommu_driver *driver;
2114         int ret = 0;
2115
2116         if (!group || !data || len <= 0)
2117                 return -EINVAL;
2118
2119         container = group->container;
2120         driver = container->iommu_driver;
2121
2122         if (likely(driver && driver->ops->dma_rw))
2123                 ret = driver->ops->dma_rw(container->iommu_data,
2124                                           user_iova, data, len, write);
2125         else
2126                 ret = -ENOTTY;
2127
2128         return ret;
2129 }
2130 EXPORT_SYMBOL(vfio_dma_rw);
2131
2132 static int vfio_register_iommu_notifier(struct vfio_group *group,
2133                                         unsigned long *events,
2134                                         struct notifier_block *nb)
2135 {
2136         struct vfio_container *container;
2137         struct vfio_iommu_driver *driver;
2138         int ret;
2139
2140         ret = vfio_group_add_container_user(group);
2141         if (ret)
2142                 return -EINVAL;
2143
2144         container = group->container;
2145         driver = container->iommu_driver;
2146         if (likely(driver && driver->ops->register_notifier))
2147                 ret = driver->ops->register_notifier(container->iommu_data,
2148                                                      events, nb);
2149         else
2150                 ret = -ENOTTY;
2151
2152         vfio_group_try_dissolve_container(group);
2153
2154         return ret;
2155 }
2156
2157 static int vfio_unregister_iommu_notifier(struct vfio_group *group,
2158                                           struct notifier_block *nb)
2159 {
2160         struct vfio_container *container;
2161         struct vfio_iommu_driver *driver;
2162         int ret;
2163
2164         ret = vfio_group_add_container_user(group);
2165         if (ret)
2166                 return -EINVAL;
2167
2168         container = group->container;
2169         driver = container->iommu_driver;
2170         if (likely(driver && driver->ops->unregister_notifier))
2171                 ret = driver->ops->unregister_notifier(container->iommu_data,
2172                                                        nb);
2173         else
2174                 ret = -ENOTTY;
2175
2176         vfio_group_try_dissolve_container(group);
2177
2178         return ret;
2179 }
2180
2181 void vfio_group_set_kvm(struct vfio_group *group, struct kvm *kvm)
2182 {
2183         group->kvm = kvm;
2184         blocking_notifier_call_chain(&group->notifier,
2185                                 VFIO_GROUP_NOTIFY_SET_KVM, kvm);
2186 }
2187 EXPORT_SYMBOL_GPL(vfio_group_set_kvm);
2188
2189 static int vfio_register_group_notifier(struct vfio_group *group,
2190                                         unsigned long *events,
2191                                         struct notifier_block *nb)
2192 {
2193         int ret;
2194         bool set_kvm = false;
2195
2196         if (*events & VFIO_GROUP_NOTIFY_SET_KVM)
2197                 set_kvm = true;
2198
2199         /* clear known events */
2200         *events &= ~VFIO_GROUP_NOTIFY_SET_KVM;
2201
2202         /* refuse to continue if still events remaining */
2203         if (*events)
2204                 return -EINVAL;
2205
2206         ret = vfio_group_add_container_user(group);
2207         if (ret)
2208                 return -EINVAL;
2209
2210         ret = blocking_notifier_chain_register(&group->notifier, nb);
2211
2212         /*
2213          * The attaching of kvm and vfio_group might already happen, so
2214          * here we replay once upon registration.
2215          */
2216         if (!ret && set_kvm && group->kvm)
2217                 blocking_notifier_call_chain(&group->notifier,
2218                                         VFIO_GROUP_NOTIFY_SET_KVM, group->kvm);
2219
2220         vfio_group_try_dissolve_container(group);
2221
2222         return ret;
2223 }
2224
2225 static int vfio_unregister_group_notifier(struct vfio_group *group,
2226                                          struct notifier_block *nb)
2227 {
2228         int ret;
2229
2230         ret = vfio_group_add_container_user(group);
2231         if (ret)
2232                 return -EINVAL;
2233
2234         ret = blocking_notifier_chain_unregister(&group->notifier, nb);
2235
2236         vfio_group_try_dissolve_container(group);
2237
2238         return ret;
2239 }
2240
2241 int vfio_register_notifier(struct device *dev, enum vfio_notify_type type,
2242                            unsigned long *events, struct notifier_block *nb)
2243 {
2244         struct vfio_group *group;
2245         int ret;
2246
2247         if (!dev || !nb || !events || (*events == 0))
2248                 return -EINVAL;
2249
2250         group = vfio_group_get_from_dev(dev);
2251         if (!group)
2252                 return -ENODEV;
2253
2254         switch (type) {
2255         case VFIO_IOMMU_NOTIFY:
2256                 ret = vfio_register_iommu_notifier(group, events, nb);
2257                 break;
2258         case VFIO_GROUP_NOTIFY:
2259                 ret = vfio_register_group_notifier(group, events, nb);
2260                 break;
2261         default:
2262                 ret = -EINVAL;
2263         }
2264
2265         vfio_group_put(group);
2266         return ret;
2267 }
2268 EXPORT_SYMBOL(vfio_register_notifier);
2269
2270 int vfio_unregister_notifier(struct device *dev, enum vfio_notify_type type,
2271                              struct notifier_block *nb)
2272 {
2273         struct vfio_group *group;
2274         int ret;
2275
2276         if (!dev || !nb)
2277                 return -EINVAL;
2278
2279         group = vfio_group_get_from_dev(dev);
2280         if (!group)
2281                 return -ENODEV;
2282
2283         switch (type) {
2284         case VFIO_IOMMU_NOTIFY:
2285                 ret = vfio_unregister_iommu_notifier(group, nb);
2286                 break;
2287         case VFIO_GROUP_NOTIFY:
2288                 ret = vfio_unregister_group_notifier(group, nb);
2289                 break;
2290         default:
2291                 ret = -EINVAL;
2292         }
2293
2294         vfio_group_put(group);
2295         return ret;
2296 }
2297 EXPORT_SYMBOL(vfio_unregister_notifier);
2298
2299 struct iommu_domain *vfio_group_iommu_domain(struct vfio_group *group)
2300 {
2301         struct vfio_container *container;
2302         struct vfio_iommu_driver *driver;
2303
2304         if (!group)
2305                 return ERR_PTR(-EINVAL);
2306
2307         container = group->container;
2308         driver = container->iommu_driver;
2309         if (likely(driver && driver->ops->group_iommu_domain))
2310                 return driver->ops->group_iommu_domain(container->iommu_data,
2311                                                        group->iommu_group);
2312
2313         return ERR_PTR(-ENOTTY);
2314 }
2315 EXPORT_SYMBOL_GPL(vfio_group_iommu_domain);
2316
2317 /**
2318  * Module/class support
2319  */
2320 static char *vfio_devnode(struct device *dev, umode_t *mode)
2321 {
2322         return kasprintf(GFP_KERNEL, "vfio/%s", dev_name(dev));
2323 }
2324
2325 static struct miscdevice vfio_dev = {
2326         .minor = VFIO_MINOR,
2327         .name = "vfio",
2328         .fops = &vfio_fops,
2329         .nodename = "vfio/vfio",
2330         .mode = S_IRUGO | S_IWUGO,
2331 };
2332
2333 static int __init vfio_init(void)
2334 {
2335         int ret;
2336
2337         idr_init(&vfio.group_idr);
2338         mutex_init(&vfio.group_lock);
2339         mutex_init(&vfio.iommu_drivers_lock);
2340         INIT_LIST_HEAD(&vfio.group_list);
2341         INIT_LIST_HEAD(&vfio.iommu_drivers_list);
2342
2343         ret = misc_register(&vfio_dev);
2344         if (ret) {
2345                 pr_err("vfio: misc device register failed\n");
2346                 return ret;
2347         }
2348
2349         /* /dev/vfio/$GROUP */
2350         vfio.class = class_create(THIS_MODULE, "vfio");
2351         if (IS_ERR(vfio.class)) {
2352                 ret = PTR_ERR(vfio.class);
2353                 goto err_class;
2354         }
2355
2356         vfio.class->devnode = vfio_devnode;
2357
2358         ret = alloc_chrdev_region(&vfio.group_devt, 0, MINORMASK + 1, "vfio");
2359         if (ret)
2360                 goto err_alloc_chrdev;
2361
2362         cdev_init(&vfio.group_cdev, &vfio_group_fops);
2363         ret = cdev_add(&vfio.group_cdev, vfio.group_devt, MINORMASK + 1);
2364         if (ret)
2365                 goto err_cdev_add;
2366
2367         pr_info(DRIVER_DESC " version: " DRIVER_VERSION "\n");
2368
2369 #ifdef CONFIG_VFIO_NOIOMMU
2370         vfio_register_iommu_driver(&vfio_noiommu_ops);
2371 #endif
2372         return 0;
2373
2374 err_cdev_add:
2375         unregister_chrdev_region(vfio.group_devt, MINORMASK + 1);
2376 err_alloc_chrdev:
2377         class_destroy(vfio.class);
2378         vfio.class = NULL;
2379 err_class:
2380         misc_deregister(&vfio_dev);
2381         return ret;
2382 }
2383
2384 static void __exit vfio_cleanup(void)
2385 {
2386         WARN_ON(!list_empty(&vfio.group_list));
2387
2388 #ifdef CONFIG_VFIO_NOIOMMU
2389         vfio_unregister_iommu_driver(&vfio_noiommu_ops);
2390 #endif
2391         idr_destroy(&vfio.group_idr);
2392         cdev_del(&vfio.group_cdev);
2393         unregister_chrdev_region(vfio.group_devt, MINORMASK + 1);
2394         class_destroy(vfio.class);
2395         vfio.class = NULL;
2396         misc_deregister(&vfio_dev);
2397 }
2398
2399 module_init(vfio_init);
2400 module_exit(vfio_cleanup);
2401
2402 MODULE_VERSION(DRIVER_VERSION);
2403 MODULE_LICENSE("GPL v2");
2404 MODULE_AUTHOR(DRIVER_AUTHOR);
2405 MODULE_DESCRIPTION(DRIVER_DESC);
2406 MODULE_ALIAS_MISCDEV(VFIO_MINOR);
2407 MODULE_ALIAS("devname:vfio/vfio");
2408 MODULE_SOFTDEP("post: vfio_iommu_type1 vfio_iommu_spapr_tce");