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_register_group_dev() or removing
 103  * that symmetric reference after vfio_unregister_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 /**
 803  * Get a reference to the vfio_device for a device.  Even if the
 804  * caller thinks they own the device, they could be racing with a
 805  * release call path, so we can't trust drvdata for the shortcut.
 806  * Go the long way around, from the iommu_group to the vfio_group
 807  * to the vfio_device.
 808  */
 809 struct vfio_device *vfio_device_get_from_dev(struct device *dev)
 810 {
 811         struct vfio_group *group;
 812         struct vfio_device *device;
 813
 814         group = vfio_group_get_from_dev(dev);
 815         if (!group)
 816                 return NULL;
 817
 818         device = vfio_group_get_device(group, dev);
 819         vfio_group_put(group);
 820
 821         return device;
 822 }
 823 EXPORT_SYMBOL_GPL(vfio_device_get_from_dev);
 824
 825 static struct vfio_device *vfio_device_get_from_name(struct vfio_group *group,
 826                                                      char *buf)
 827 {
 828         struct vfio_device *it, *device = ERR_PTR(-ENODEV);
 829
 830         mutex_lock(&group->device_lock);
 831         list_for_each_entry(it, &group->device_list, group_next) {
 832                 int ret;
 833
 834                 if (it->ops->match) {
 835                         ret = it->ops->match(it, buf);
 836                         if (ret < 0) {
 837                                 device = ERR_PTR(ret);
 838                                 break;
 839                         }
 840                 } else {
 841                         ret = !strcmp(dev_name(it->dev), buf);
 842                 }
 843
 844                 if (ret && vfio_device_try_get(it)) {
 845                         device = it;
 846                         break;
 847                 }
 848         }
 849         mutex_unlock(&group->device_lock);
 850
 851         return device;
 852 }
 853
 854 /*
 855  * Caller must hold a reference to the vfio_device
 856  */
 857 void *vfio_device_data(struct vfio_device *device)
 858 {
 859         return device->device_data;
 860 }
 861 EXPORT_SYMBOL_GPL(vfio_device_data);
 862
 863 /*
 864  * Decrement the device reference count and wait for the device to be
 865  * removed.  Open file descriptors for the device... */
 866 void vfio_unregister_group_dev(struct vfio_device *device)
 867 {
 868         struct vfio_group *group = device->group;
 869         struct vfio_unbound_dev *unbound;
 870         unsigned int i = 0;
 871         bool interrupted = false;
 872         long rc;
 873
 874         /*
 875          * When the device is removed from the group, the group suddenly
 876          * becomes non-viable; the device has a driver (until the unbind
 877          * completes), but it's not present in the group.  This is bad news
 878          * for any external users that need to re-acquire a group reference
 879          * in order to match and release their existing reference.  To
 880          * solve this, we track such devices on the unbound_list to bridge
 881          * the gap until they're fully unbound.
 882          */
 883         unbound = kzalloc(sizeof(*unbound), GFP_KERNEL);
 884         if (unbound) {
 885                 unbound->dev = device->dev;
 886                 mutex_lock(&group->unbound_lock);
 887                 list_add(&unbound->unbound_next, &group->unbound_list);
 888                 mutex_unlock(&group->unbound_lock);
 889         }
 890         WARN_ON(!unbound);
 891
 892         vfio_device_put(device);
 893         rc = try_wait_for_completion(&device->comp);
 894         while (rc <= 0) {
 895                 if (device->ops->request)
 896                         device->ops->request(device, i++);
 897
 898                 if (interrupted) {
 899                         rc = wait_for_completion_timeout(&device->comp,
 900                                                          HZ * 10);
 901                 } else {
 902                         rc = wait_for_completion_interruptible_timeout(
 903                                 &device->comp, HZ * 10);
 904                         if (rc < 0) {
 905                                 interrupted = true;
 906                                 dev_warn(device->dev,
 907                                          "Device is currently in use, task"
 908                                          " \"%s\" (%d) "
 909                                          "blocked until device is released",
 910                                          current->comm, task_pid_nr(current));
 911                         }
 912                 }
 913         }
 914
 915         mutex_lock(&group->device_lock);
 916         list_del(&device->group_next);
 917         group->dev_counter--;
 918         mutex_unlock(&group->device_lock);
 919
 920         /*
 921          * In order to support multiple devices per group, devices can be
 922          * plucked from the group while other devices in the group are still
 923          * in use.  The container persists with this group and those remaining
 924          * devices still attached.  If the user creates an isolation violation
 925          * by binding this device to another driver while the group is still in
 926          * use, that's their fault.  However, in the case of removing the last,
 927          * or potentially the only, device in the group there can be no other
 928          * in-use devices in the group.  The user has done their due diligence
 929          * and we should lay no claims to those devices.  In order to do that,
 930          * we need to make sure the group is detached from the container.
 931          * Without this stall, we're potentially racing with a user process
 932          * that may attempt to immediately bind this device to another driver.
 933          */
 934         if (list_empty(&group->device_list))
 935                 wait_event(group->container_q, !group->container);
 936
 937         /* Matches the get in vfio_register_group_dev() */
 938         vfio_group_put(group);
 939 }
 940 EXPORT_SYMBOL_GPL(vfio_unregister_group_dev);
 941
 942 /**
 943  * VFIO base fd, /dev/vfio/vfio
 944  */
 945 static long vfio_ioctl_check_extension(struct vfio_container *container,
 946                                        unsigned long arg)
 947 {
 948         struct vfio_iommu_driver *driver;
 949         long ret = 0;
 950
 951         down_read(&container->group_lock);
 952
 953         driver = container->iommu_driver;
 954
 955         switch (arg) {
 956                 /* No base extensions yet */
 957         default:
 958                 /*
 959                  * If no driver is set, poll all registered drivers for
 960                  * extensions and return the first positive result.  If
 961                  * a driver is already set, further queries will be passed
 962                  * only to that driver.
 963                  */
 964                 if (!driver) {
 965                         mutex_lock(&vfio.iommu_drivers_lock);
 966                         list_for_each_entry(driver, &vfio.iommu_drivers_list,
 967                                             vfio_next) {
 968
 969 #ifdef CONFIG_VFIO_NOIOMMU
 970                                 if (!list_empty(&container->group_list) &&
 971                                     (container->noiommu !=
 972                                      (driver->ops == &vfio_noiommu_ops)))
 973                                         continue;
 974 #endif
 975
 976                                 if (!try_module_get(driver->ops->owner))
 977                                         continue;
 978
 979                                 ret = driver->ops->ioctl(NULL,
 980                                                          VFIO_CHECK_EXTENSION,
 981                                                          arg);
 982                                 module_put(driver->ops->owner);
 983                                 if (ret > 0)
 984                                         break;
 985                         }
 986                         mutex_unlock(&vfio.iommu_drivers_lock);
 987                 } else
 988                         ret = driver->ops->ioctl(container->iommu_data,
 989                                                  VFIO_CHECK_EXTENSION, arg);
 990         }
 991
 992         up_read(&container->group_lock);
 993
 994         return ret;
 995 }
 996
 997 /* hold write lock on container->group_lock */
 998 static int __vfio_container_attach_groups(struct vfio_container *container,
 999                                           struct vfio_iommu_driver *driver,
1000                                           void *data)
1001 {
1002         struct vfio_group *group;
1003         int ret = -ENODEV;
1004
1005         list_for_each_entry(group, &container->group_list, container_next) {
1006                 ret = driver->ops->attach_group(data, group->iommu_group);
1007                 if (ret)
1008                         goto unwind;
1009         }
1010
1011         return ret;
1012
1013 unwind:
1014         list_for_each_entry_continue_reverse(group, &container->group_list,
1015                                              container_next) {
1016                 driver->ops->detach_group(data, group->iommu_group);
1017         }
1018
1019         return ret;
1020 }
1021
1022 static long vfio_ioctl_set_iommu(struct vfio_container *container,
1023                                  unsigned long arg)
1024 {
1025         struct vfio_iommu_driver *driver;
1026         long ret = -ENODEV;
1027
1028         down_write(&container->group_lock);
1029
1030         /*
1031          * The container is designed to be an unprivileged interface while
1032          * the group can be assigned to specific users.  Therefore, only by
1033          * adding a group to a container does the user get the privilege of
1034          * enabling the iommu, which may allocate finite resources.  There
1035          * is no unset_iommu, but by removing all the groups from a container,
1036          * the container is deprivileged and returns to an unset state.
1037          */
1038         if (list_empty(&container->group_list) || container->iommu_driver) {
1039                 up_write(&container->group_lock);
1040                 return -EINVAL;
1041         }
1042
1043         mutex_lock(&vfio.iommu_drivers_lock);
1044         list_for_each_entry(driver, &vfio.iommu_drivers_list, vfio_next) {
1045                 void *data;
1046
1047 #ifdef CONFIG_VFIO_NOIOMMU
1048                 /*
1049                  * Only noiommu containers can use vfio-noiommu and noiommu
1050                  * containers can only use vfio-noiommu.
1051                  */
1052                 if (container->noiommu != (driver->ops == &vfio_noiommu_ops))
1053                         continue;
1054 #endif
1055
1056                 if (!try_module_get(driver->ops->owner))
1057                         continue;
1058
1059                 /*
1060                  * The arg magic for SET_IOMMU is the same as CHECK_EXTENSION,
1061                  * so test which iommu driver reported support for this
1062                  * extension and call open on them.  We also pass them the
1063                  * magic, allowing a single driver to support multiple
1064                  * interfaces if they'd like.
1065                  */
1066                 if (driver->ops->ioctl(NULL, VFIO_CHECK_EXTENSION, arg) <= 0) {
1067                         module_put(driver->ops->owner);
1068                         continue;
1069                 }
1070
1071                 data = driver->ops->open(arg);
1072                 if (IS_ERR(data)) {
1073                         ret = PTR_ERR(data);
1074                         module_put(driver->ops->owner);
1075                         continue;
1076                 }
1077
1078                 ret = __vfio_container_attach_groups(container, driver, data);
1079                 if (ret) {
1080                         driver->ops->release(data);
1081                         module_put(driver->ops->owner);
1082                         continue;
1083                 }
1084
1085                 container->iommu_driver = driver;
1086                 container->iommu_data = data;
1087                 break;
1088         }
1089
1090         mutex_unlock(&vfio.iommu_drivers_lock);
1091         up_write(&container->group_lock);
1092
1093         return ret;
1094 }
1095
1096 static long vfio_fops_unl_ioctl(struct file *filep,
1097                                 unsigned int cmd, unsigned long arg)
1098 {
1099         struct vfio_container *container = filep->private_data;
1100         struct vfio_iommu_driver *driver;
1101         void *data;
1102         long ret = -EINVAL;
1103
1104         if (!container)
1105                 return ret;
1106
1107         switch (cmd) {
1108         case VFIO_GET_API_VERSION:
1109                 ret = VFIO_API_VERSION;
1110                 break;
1111         case VFIO_CHECK_EXTENSION:
1112                 ret = vfio_ioctl_check_extension(container, arg);
1113                 break;
1114         case VFIO_SET_IOMMU:
1115                 ret = vfio_ioctl_set_iommu(container, arg);
1116                 break;
1117         default:
1118                 driver = container->iommu_driver;
1119                 data = container->iommu_data;
1120
1121                 if (driver) /* passthrough all unrecognized ioctls */
1122                         ret = driver->ops->ioctl(data, cmd, arg);
1123         }
1124
1125         return ret;
1126 }
1127
1128 static int vfio_fops_open(struct inode *inode, struct file *filep)
1129 {
1130         struct vfio_container *container;
1131
1132         container = kzalloc(sizeof(*container), GFP_KERNEL);
1133         if (!container)
1134                 return -ENOMEM;
1135
1136         INIT_LIST_HEAD(&container->group_list);
1137         init_rwsem(&container->group_lock);
1138         kref_init(&container->kref);
1139
1140         filep->private_data = container;
1141
1142         return 0;
1143 }
1144
1145 static int vfio_fops_release(struct inode *inode, struct file *filep)
1146 {
1147         struct vfio_container *container = filep->private_data;
1148         struct vfio_iommu_driver *driver = container->iommu_driver;
1149
1150         if (driver && driver->ops->notify)
1151                 driver->ops->notify(container->iommu_data,
1152                                     VFIO_IOMMU_CONTAINER_CLOSE);
1153
1154         filep->private_data = NULL;
1155
1156         vfio_container_put(container);
1157
1158         return 0;
1159 }
1160
1161 /*
1162  * Once an iommu driver is set, we optionally pass read/write/mmap
1163  * on to the driver, allowing management interfaces beyond ioctl.
1164  */
1165 static ssize_t vfio_fops_read(struct file *filep, char __user *buf,
1166                               size_t count, loff_t *ppos)
1167 {
1168         struct vfio_container *container = filep->private_data;
1169         struct vfio_iommu_driver *driver;
1170         ssize_t ret = -EINVAL;
1171
1172         driver = container->iommu_driver;
1173         if (likely(driver && driver->ops->read))
1174                 ret = driver->ops->read(container->iommu_data,
1175                                         buf, count, ppos);
1176
1177         return ret;
1178 }
1179
1180 static ssize_t vfio_fops_write(struct file *filep, const char __user *buf,
1181                                size_t count, loff_t *ppos)
1182 {
1183         struct vfio_container *container = filep->private_data;
1184         struct vfio_iommu_driver *driver;
1185         ssize_t ret = -EINVAL;
1186
1187         driver = container->iommu_driver;
1188         if (likely(driver && driver->ops->write))
1189                 ret = driver->ops->write(container->iommu_data,
1190                                          buf, count, ppos);
1191
1192         return ret;
1193 }
1194
1195 static int vfio_fops_mmap(struct file *filep, struct vm_area_struct *vma)
1196 {
1197         struct vfio_container *container = filep->private_data;
1198         struct vfio_iommu_driver *driver;
1199         int ret = -EINVAL;
1200
1201         driver = container->iommu_driver;
1202         if (likely(driver && driver->ops->mmap))
1203                 ret = driver->ops->mmap(container->iommu_data, vma);
1204
1205         return ret;
1206 }
1207
1208 static const struct file_operations vfio_fops = {
1209         .owner          = THIS_MODULE,
1210         .open           = vfio_fops_open,
1211         .release        = vfio_fops_release,
1212         .read           = vfio_fops_read,
1213         .write          = vfio_fops_write,
1214         .unlocked_ioctl = vfio_fops_unl_ioctl,
1215         .compat_ioctl   = compat_ptr_ioctl,
1216         .mmap           = vfio_fops_mmap,
1217 };
1218
1219 /**
1220  * VFIO Group fd, /dev/vfio/$GROUP
1221  */
1222 static void __vfio_group_unset_container(struct vfio_group *group)
1223 {
1224         struct vfio_container *container = group->container;
1225         struct vfio_iommu_driver *driver;
1226
1227         down_write(&container->group_lock);
1228
1229         driver = container->iommu_driver;
1230         if (driver)
1231                 driver->ops->detach_group(container->iommu_data,
1232                                           group->iommu_group);
1233
1234         group->container = NULL;
1235         wake_up(&group->container_q);
1236         list_del(&group->container_next);
1237
1238         /* Detaching the last group deprivileges a container, remove iommu */
1239         if (driver && list_empty(&container->group_list)) {
1240                 driver->ops->release(container->iommu_data);
1241                 module_put(driver->ops->owner);
1242                 container->iommu_driver = NULL;
1243                 container->iommu_data = NULL;
1244         }
1245
1246         up_write(&container->group_lock);
1247
1248         vfio_container_put(container);
1249 }
1250
1251 /*
1252  * VFIO_GROUP_UNSET_CONTAINER should fail if there are other users or
1253  * if there was no container to unset.  Since the ioctl is called on
1254  * the group, we know that still exists, therefore the only valid
1255  * transition here is 1->0.
1256  */
1257 static int vfio_group_unset_container(struct vfio_group *group)
1258 {
1259         int users = atomic_cmpxchg(&group->container_users, 1, 0);
1260
1261         if (!users)
1262                 return -EINVAL;
1263         if (users != 1)
1264                 return -EBUSY;
1265
1266         __vfio_group_unset_container(group);
1267
1268         return 0;
1269 }
1270
1271 /*
1272  * When removing container users, anything that removes the last user
1273  * implicitly removes the group from the container.  That is, if the
1274  * group file descriptor is closed, as well as any device file descriptors,
1275  * the group is free.
1276  */
1277 static void vfio_group_try_dissolve_container(struct vfio_group *group)
1278 {
1279         if (0 == atomic_dec_if_positive(&group->container_users))
1280                 __vfio_group_unset_container(group);
1281 }
1282
1283 static int vfio_group_set_container(struct vfio_group *group, int container_fd)
1284 {
1285         struct fd f;
1286         struct vfio_container *container;
1287         struct vfio_iommu_driver *driver;
1288         int ret = 0;
1289
1290         if (atomic_read(&group->container_users))
1291                 return -EINVAL;
1292
1293         if (group->noiommu && !capable(CAP_SYS_RAWIO))
1294                 return -EPERM;
1295
1296         f = fdget(container_fd);
1297         if (!f.file)
1298                 return -EBADF;
1299
1300         /* Sanity check, is this really our fd? */
1301         if (f.file->f_op != &vfio_fops) {
1302                 fdput(f);
1303                 return -EINVAL;
1304         }
1305
1306         container = f.file->private_data;
1307         WARN_ON(!container); /* fget ensures we don't race vfio_release */
1308
1309         down_write(&container->group_lock);
1310
1311         /* Real groups and fake groups cannot mix */
1312         if (!list_empty(&container->group_list) &&
1313             container->noiommu != group->noiommu) {
1314                 ret = -EPERM;
1315                 goto unlock_out;
1316         }
1317
1318         driver = container->iommu_driver;
1319         if (driver) {
1320                 ret = driver->ops->attach_group(container->iommu_data,
1321                                                 group->iommu_group);
1322                 if (ret)
1323                         goto unlock_out;
1324         }
1325
1326         group->container = container;
1327         container->noiommu = group->noiommu;
1328         list_add(&group->container_next, &container->group_list);
1329
1330         /* Get a reference on the container and mark a user within the group */
1331         vfio_container_get(container);
1332         atomic_inc(&group->container_users);
1333
1334 unlock_out:
1335         up_write(&container->group_lock);
1336         fdput(f);
1337         return ret;
1338 }
1339
1340 static bool vfio_group_viable(struct vfio_group *group)
1341 {
1342         return (iommu_group_for_each_dev(group->iommu_group,
1343                                          group, vfio_dev_viable) == 0);
1344 }
1345
1346 static int vfio_group_add_container_user(struct vfio_group *group)
1347 {
1348         if (!atomic_inc_not_zero(&group->container_users))
1349                 return -EINVAL;
1350
1351         if (group->noiommu) {
1352                 atomic_dec(&group->container_users);
1353                 return -EPERM;
1354         }
1355         if (!group->container->iommu_driver || !vfio_group_viable(group)) {
1356                 atomic_dec(&group->container_users);
1357                 return -EINVAL;
1358         }
1359
1360         return 0;
1361 }
1362
1363 static const struct file_operations vfio_device_fops;
1364
1365 static int vfio_group_get_device_fd(struct vfio_group *group, char *buf)
1366 {
1367         struct vfio_device *device;
1368         struct file *filep;
1369         int ret;
1370
1371         if (0 == atomic_read(&group->container_users) ||
1372             !group->container->iommu_driver || !vfio_group_viable(group))
1373                 return -EINVAL;
1374
1375         if (group->noiommu && !capable(CAP_SYS_RAWIO))
1376                 return -EPERM;
1377
1378         device = vfio_device_get_from_name(group, buf);
1379         if (IS_ERR(device))
1380                 return PTR_ERR(device);
1381
1382         ret = device->ops->open(device);
1383         if (ret) {
1384                 vfio_device_put(device);
1385                 return ret;
1386         }
1387
1388         /*
1389          * We can't use anon_inode_getfd() because we need to modify
1390          * the f_mode flags directly to allow more than just ioctls
1391          */
1392         ret = get_unused_fd_flags(O_CLOEXEC);
1393         if (ret < 0) {
1394                 device->ops->release(device);
1395                 vfio_device_put(device);
1396                 return ret;
1397         }
1398
1399         filep = anon_inode_getfile("[vfio-device]", &vfio_device_fops,
1400                                    device, O_RDWR);
1401         if (IS_ERR(filep)) {
1402                 put_unused_fd(ret);
1403                 ret = PTR_ERR(filep);
1404                 device->ops->release(device);
1405                 vfio_device_put(device);
1406                 return ret;
1407         }
1408
1409         /*
1410          * TODO: add an anon_inode interface to do this.
1411          * Appears to be missing by lack of need rather than
1412          * explicitly prevented.  Now there's need.
1413          */
1414         filep->f_mode |= (FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE);
1415
1416         atomic_inc(&group->container_users);
1417
1418         fd_install(ret, filep);
1419
1420         if (group->noiommu)
1421                 dev_warn(device->dev, "vfio-noiommu device opened by user "
1422                          "(%s:%d)\n", current->comm, task_pid_nr(current));
1423
1424         return ret;
1425 }
1426
1427 static long vfio_group_fops_unl_ioctl(struct file *filep,
1428                                       unsigned int cmd, unsigned long arg)
1429 {
1430         struct vfio_group *group = filep->private_data;
1431         long ret = -ENOTTY;
1432
1433         switch (cmd) {
1434         case VFIO_GROUP_GET_STATUS:
1435         {
1436                 struct vfio_group_status status;
1437                 unsigned long minsz;
1438
1439                 minsz = offsetofend(struct vfio_group_status, flags);
1440
1441                 if (copy_from_user(&status, (void __user *)arg, minsz))
1442                         return -EFAULT;
1443
1444                 if (status.argsz < minsz)
1445                         return -EINVAL;
1446
1447                 status.flags = 0;
1448
1449                 if (vfio_group_viable(group))
1450                         status.flags |= VFIO_GROUP_FLAGS_VIABLE;
1451
1452                 if (group->container)
1453                         status.flags |= VFIO_GROUP_FLAGS_CONTAINER_SET;
1454
1455                 if (copy_to_user((void __user *)arg, &status, minsz))
1456                         return -EFAULT;
1457
1458                 ret = 0;
1459                 break;
1460         }
1461         case VFIO_GROUP_SET_CONTAINER:
1462         {
1463                 int fd;
1464
1465                 if (get_user(fd, (int __user *)arg))
1466                         return -EFAULT;
1467
1468                 if (fd < 0)
1469                         return -EINVAL;
1470
1471                 ret = vfio_group_set_container(group, fd);
1472                 break;
1473         }
1474         case VFIO_GROUP_UNSET_CONTAINER:
1475                 ret = vfio_group_unset_container(group);
1476                 break;
1477         case VFIO_GROUP_GET_DEVICE_FD:
1478         {
1479                 char *buf;
1480
1481                 buf = strndup_user((const char __user *)arg, PAGE_SIZE);
1482                 if (IS_ERR(buf))
1483                         return PTR_ERR(buf);
1484
1485                 ret = vfio_group_get_device_fd(group, buf);
1486                 kfree(buf);
1487                 break;
1488         }
1489         }
1490
1491         return ret;
1492 }
1493
1494 static int vfio_group_fops_open(struct inode *inode, struct file *filep)
1495 {
1496         struct vfio_group *group;
1497         int opened;
1498
1499         group = vfio_group_get_from_minor(iminor(inode));
1500         if (!group)
1501                 return -ENODEV;
1502
1503         if (group->noiommu && !capable(CAP_SYS_RAWIO)) {
1504                 vfio_group_put(group);
1505                 return -EPERM;
1506         }
1507
1508         /* Do we need multiple instances of the group open?  Seems not. */
1509         opened = atomic_cmpxchg(&group->opened, 0, 1);
1510         if (opened) {
1511                 vfio_group_put(group);
1512                 return -EBUSY;
1513         }
1514
1515         /* Is something still in use from a previous open? */
1516         if (group->container) {
1517                 atomic_dec(&group->opened);
1518                 vfio_group_put(group);
1519                 return -EBUSY;
1520         }
1521
1522         /* Warn if previous user didn't cleanup and re-init to drop them */
1523         if (WARN_ON(group->notifier.head))
1524                 BLOCKING_INIT_NOTIFIER_HEAD(&group->notifier);
1525
1526         filep->private_data = group;
1527
1528         return 0;
1529 }
1530
1531 static int vfio_group_fops_release(struct inode *inode, struct file *filep)
1532 {
1533         struct vfio_group *group = filep->private_data;
1534
1535         filep->private_data = NULL;
1536
1537         vfio_group_try_dissolve_container(group);
1538
1539         atomic_dec(&group->opened);
1540
1541         vfio_group_put(group);
1542
1543         return 0;
1544 }
1545
1546 static const struct file_operations vfio_group_fops = {
1547         .owner          = THIS_MODULE,
1548         .unlocked_ioctl = vfio_group_fops_unl_ioctl,
1549         .compat_ioctl   = compat_ptr_ioctl,
1550         .open           = vfio_group_fops_open,
1551         .release        = vfio_group_fops_release,
1552 };
1553
1554 /**
1555  * VFIO Device fd
1556  */
1557 static int vfio_device_fops_release(struct inode *inode, struct file *filep)
1558 {
1559         struct vfio_device *device = filep->private_data;
1560
1561         device->ops->release(device);
1562
1563         vfio_group_try_dissolve_container(device->group);
1564
1565         vfio_device_put(device);
1566
1567         return 0;
1568 }
1569
1570 static long vfio_device_fops_unl_ioctl(struct file *filep,
1571                                        unsigned int cmd, unsigned long arg)
1572 {
1573         struct vfio_device *device = filep->private_data;
1574
1575         if (unlikely(!device->ops->ioctl))
1576                 return -EINVAL;
1577
1578         return device->ops->ioctl(device, cmd, arg);
1579 }
1580
1581 static ssize_t vfio_device_fops_read(struct file *filep, char __user *buf,
1582                                      size_t count, loff_t *ppos)
1583 {
1584         struct vfio_device *device = filep->private_data;
1585
1586         if (unlikely(!device->ops->read))
1587                 return -EINVAL;
1588
1589         return device->ops->read(device, buf, count, ppos);
1590 }
1591
1592 static ssize_t vfio_device_fops_write(struct file *filep,
1593                                       const char __user *buf,
1594                                       size_t count, loff_t *ppos)
1595 {
1596         struct vfio_device *device = filep->private_data;
1597
1598         if (unlikely(!device->ops->write))
1599                 return -EINVAL;
1600
1601         return device->ops->write(device, buf, count, ppos);
1602 }
1603
1604 static int vfio_device_fops_mmap(struct file *filep, struct vm_area_struct *vma)
1605 {
1606         struct vfio_device *device = filep->private_data;
1607
1608         if (unlikely(!device->ops->mmap))
1609                 return -EINVAL;
1610
1611         return device->ops->mmap(device, vma);
1612 }
1613
1614 static const struct file_operations vfio_device_fops = {
1615         .owner          = THIS_MODULE,
1616         .release        = vfio_device_fops_release,
1617         .read           = vfio_device_fops_read,
1618         .write          = vfio_device_fops_write,
1619         .unlocked_ioctl = vfio_device_fops_unl_ioctl,
1620         .compat_ioctl   = compat_ptr_ioctl,
1621         .mmap           = vfio_device_fops_mmap,
1622 };
1623
1624 /**
1625  * External user API, exported by symbols to be linked dynamically.
1626  *
1627  * The protocol includes:
1628  *  1. do normal VFIO init operation:
1629  *      - opening a new container;
1630  *      - attaching group(s) to it;
1631  *      - setting an IOMMU driver for a container.
1632  * When IOMMU is set for a container, all groups in it are
1633  * considered ready to use by an external user.
1634  *
1635  * 2. User space passes a group fd to an external user.
1636  * The external user calls vfio_group_get_external_user()
1637  * to verify that:
1638  *      - the group is initialized;
1639  *      - IOMMU is set for it.
1640  * If both checks passed, vfio_group_get_external_user()
1641  * increments the container user counter to prevent
1642  * the VFIO group from disposal before KVM exits.
1643  *
1644  * 3. The external user calls vfio_external_user_iommu_id()
1645  * to know an IOMMU ID.
1646  *
1647  * 4. When the external KVM finishes, it calls
1648  * vfio_group_put_external_user() to release the VFIO group.
1649  * This call decrements the container user counter.
1650  */
1651 struct vfio_group *vfio_group_get_external_user(struct file *filep)
1652 {
1653         struct vfio_group *group = filep->private_data;
1654         int ret;
1655
1656         if (filep->f_op != &vfio_group_fops)
1657                 return ERR_PTR(-EINVAL);
1658
1659         ret = vfio_group_add_container_user(group);
1660         if (ret)
1661                 return ERR_PTR(ret);
1662
1663         vfio_group_get(group);
1664
1665         return group;
1666 }
1667 EXPORT_SYMBOL_GPL(vfio_group_get_external_user);
1668
1669 /**
1670  * External user API, exported by symbols to be linked dynamically.
1671  * The external user passes in a device pointer
1672  * to verify that:
1673  *      - A VFIO group is assiciated with the device;
1674  *      - IOMMU is set for the group.
1675  * If both checks passed, vfio_group_get_external_user_from_dev()
1676  * increments the container user counter to prevent the VFIO group
1677  * from disposal before external user exits and returns the pointer
1678  * to the VFIO group.
1679  *
1680  * When the external user finishes using the VFIO group, it calls
1681  * vfio_group_put_external_user() to release the VFIO group and
1682  * decrement the container user counter.
1683  *
1684  * @dev [in]    : device
1685  * Return error PTR or pointer to VFIO group.
1686  */
1687
1688 struct vfio_group *vfio_group_get_external_user_from_dev(struct device *dev)
1689 {
1690         struct vfio_group *group;
1691         int ret;
1692
1693         group = vfio_group_get_from_dev(dev);
1694         if (!group)
1695                 return ERR_PTR(-ENODEV);
1696
1697         ret = vfio_group_add_container_user(group);
1698         if (ret) {
1699                 vfio_group_put(group);
1700                 return ERR_PTR(ret);
1701         }
1702
1703         return group;
1704 }
1705 EXPORT_SYMBOL_GPL(vfio_group_get_external_user_from_dev);
1706
1707 void vfio_group_put_external_user(struct vfio_group *group)
1708 {
1709         vfio_group_try_dissolve_container(group);
1710         vfio_group_put(group);
1711 }
1712 EXPORT_SYMBOL_GPL(vfio_group_put_external_user);
1713
1714 bool vfio_external_group_match_file(struct vfio_group *test_group,
1715                                     struct file *filep)
1716 {
1717         struct vfio_group *group = filep->private_data;
1718
1719         return (filep->f_op == &vfio_group_fops) && (group == test_group);
1720 }
1721 EXPORT_SYMBOL_GPL(vfio_external_group_match_file);
1722
1723 int vfio_external_user_iommu_id(struct vfio_group *group)
1724 {
1725         return iommu_group_id(group->iommu_group);
1726 }
1727 EXPORT_SYMBOL_GPL(vfio_external_user_iommu_id);
1728
1729 long vfio_external_check_extension(struct vfio_group *group, unsigned long arg)
1730 {
1731         return vfio_ioctl_check_extension(group->container, arg);
1732 }
1733 EXPORT_SYMBOL_GPL(vfio_external_check_extension);
1734
1735 /**
1736  * Sub-module support
1737  */
1738 /*
1739  * Helper for managing a buffer of info chain capabilities, allocate or
1740  * reallocate a buffer with additional @size, filling in @id and @version
1741  * of the capability.  A pointer to the new capability is returned.
1742  *
1743  * NB. The chain is based at the head of the buffer, so new entries are
1744  * added to the tail, vfio_info_cap_shift() should be called to fixup the
1745  * next offsets prior to copying to the user buffer.
1746  */
1747 struct vfio_info_cap_header *vfio_info_cap_add(struct vfio_info_cap *caps,
1748                                                size_t size, u16 id, u16 version)
1749 {
1750         void *buf;
1751         struct vfio_info_cap_header *header, *tmp;
1752
1753         buf = krealloc(caps->buf, caps->size + size, GFP_KERNEL);
1754         if (!buf) {
1755                 kfree(caps->buf);
1756                 caps->size = 0;
1757                 return ERR_PTR(-ENOMEM);
1758         }
1759
1760         caps->buf = buf;
1761         header = buf + caps->size;
1762
1763         /* Eventually copied to user buffer, zero */
1764         memset(header, 0, size);
1765
1766         header->id = id;
1767         header->version = version;
1768
1769         /* Add to the end of the capability chain */
1770         for (tmp = buf; tmp->next; tmp = buf + tmp->next)
1771                 ; /* nothing */
1772
1773         tmp->next = caps->size;
1774         caps->size += size;
1775
1776         return header;
1777 }
1778 EXPORT_SYMBOL_GPL(vfio_info_cap_add);
1779
1780 void vfio_info_cap_shift(struct vfio_info_cap *caps, size_t offset)
1781 {
1782         struct vfio_info_cap_header *tmp;
1783         void *buf = (void *)caps->buf;
1784
1785         for (tmp = buf; tmp->next; tmp = buf + tmp->next - offset)
1786                 tmp->next += offset;
1787 }
1788 EXPORT_SYMBOL(vfio_info_cap_shift);
1789
1790 int vfio_info_add_capability(struct vfio_info_cap *caps,
1791                              struct vfio_info_cap_header *cap, size_t size)
1792 {
1793         struct vfio_info_cap_header *header;
1794
1795         header = vfio_info_cap_add(caps, size, cap->id, cap->version);
1796         if (IS_ERR(header))
1797                 return PTR_ERR(header);
1798
1799         memcpy(header + 1, cap + 1, size - sizeof(*header));
1800
1801         return 0;
1802 }
1803 EXPORT_SYMBOL(vfio_info_add_capability);
1804
1805 int vfio_set_irqs_validate_and_prepare(struct vfio_irq_set *hdr, int num_irqs,
1806                                        int max_irq_type, size_t *data_size)
1807 {
1808         unsigned long minsz;
1809         size_t size;
1810
1811         minsz = offsetofend(struct vfio_irq_set, count);
1812
1813         if ((hdr->argsz < minsz) || (hdr->index >= max_irq_type) ||
1814             (hdr->count >= (U32_MAX - hdr->start)) ||
1815             (hdr->flags & ~(VFIO_IRQ_SET_DATA_TYPE_MASK |
1816                                 VFIO_IRQ_SET_ACTION_TYPE_MASK)))
1817                 return -EINVAL;
1818
1819         if (data_size)
1820                 *data_size = 0;
1821
1822         if (hdr->start >= num_irqs || hdr->start + hdr->count > num_irqs)
1823                 return -EINVAL;
1824
1825         switch (hdr->flags & VFIO_IRQ_SET_DATA_TYPE_MASK) {
1826         case VFIO_IRQ_SET_DATA_NONE:
1827                 size = 0;
1828                 break;
1829         case VFIO_IRQ_SET_DATA_BOOL:
1830                 size = sizeof(uint8_t);
1831                 break;
1832         case VFIO_IRQ_SET_DATA_EVENTFD:
1833                 size = sizeof(int32_t);
1834                 break;
1835         default:
1836                 return -EINVAL;
1837         }
1838
1839         if (size) {
1840                 if (hdr->argsz - minsz < hdr->count * size)
1841                         return -EINVAL;
1842
1843                 if (!data_size)
1844                         return -EINVAL;
1845
1846                 *data_size = hdr->count * size;
1847         }
1848
1849         return 0;
1850 }
1851 EXPORT_SYMBOL(vfio_set_irqs_validate_and_prepare);
1852
1853 /*
1854  * Pin a set of guest PFNs and return their associated host PFNs for local
1855  * domain only.
1856  * @dev [in]     : device
1857  * @user_pfn [in]: array of user/guest PFNs to be pinned.
1858  * @npage [in]   : count of elements in user_pfn array.  This count should not
1859  *                 be greater VFIO_PIN_PAGES_MAX_ENTRIES.
1860  * @prot [in]    : protection flags
1861  * @phys_pfn[out]: array of host PFNs
1862  * Return error or number of pages pinned.
1863  */
1864 int vfio_pin_pages(struct device *dev, unsigned long *user_pfn, int npage,
1865                    int prot, unsigned long *phys_pfn)
1866 {
1867         struct vfio_container *container;
1868         struct vfio_group *group;
1869         struct vfio_iommu_driver *driver;
1870         int ret;
1871
1872         if (!dev || !user_pfn || !phys_pfn || !npage)
1873                 return -EINVAL;
1874
1875         if (npage > VFIO_PIN_PAGES_MAX_ENTRIES)
1876                 return -E2BIG;
1877
1878         group = vfio_group_get_from_dev(dev);
1879         if (!group)
1880                 return -ENODEV;
1881
1882         if (group->dev_counter > 1) {
1883                 ret = -EINVAL;
1884                 goto err_pin_pages;
1885         }
1886
1887         ret = vfio_group_add_container_user(group);
1888         if (ret)
1889                 goto err_pin_pages;
1890
1891         container = group->container;
1892         driver = container->iommu_driver;
1893         if (likely(driver && driver->ops->pin_pages))
1894                 ret = driver->ops->pin_pages(container->iommu_data,
1895                                              group->iommu_group, user_pfn,
1896                                              npage, prot, phys_pfn);
1897         else
1898                 ret = -ENOTTY;
1899
1900         vfio_group_try_dissolve_container(group);
1901
1902 err_pin_pages:
1903         vfio_group_put(group);
1904         return ret;
1905 }
1906 EXPORT_SYMBOL(vfio_pin_pages);
1907
1908 /*
1909  * Unpin set of host PFNs for local domain only.
1910  * @dev [in]     : device
1911  * @user_pfn [in]: array of user/guest PFNs to be unpinned. Number of user/guest
1912  *                 PFNs should not be greater than VFIO_PIN_PAGES_MAX_ENTRIES.
1913  * @npage [in]   : count of elements in user_pfn array.  This count should not
1914  *                 be greater than VFIO_PIN_PAGES_MAX_ENTRIES.
1915  * Return error or number of pages unpinned.
1916  */
1917 int vfio_unpin_pages(struct device *dev, unsigned long *user_pfn, int npage)
1918 {
1919         struct vfio_container *container;
1920         struct vfio_group *group;
1921         struct vfio_iommu_driver *driver;
1922         int ret;
1923
1924         if (!dev || !user_pfn || !npage)
1925                 return -EINVAL;
1926
1927         if (npage > VFIO_PIN_PAGES_MAX_ENTRIES)
1928                 return -E2BIG;
1929
1930         group = vfio_group_get_from_dev(dev);
1931         if (!group)
1932                 return -ENODEV;
1933
1934         ret = vfio_group_add_container_user(group);
1935         if (ret)
1936                 goto err_unpin_pages;
1937
1938         container = group->container;
1939         driver = container->iommu_driver;
1940         if (likely(driver && driver->ops->unpin_pages))
1941                 ret = driver->ops->unpin_pages(container->iommu_data, user_pfn,
1942                                                npage);
1943         else
1944                 ret = -ENOTTY;
1945
1946         vfio_group_try_dissolve_container(group);
1947
1948 err_unpin_pages:
1949         vfio_group_put(group);
1950         return ret;
1951 }
1952 EXPORT_SYMBOL(vfio_unpin_pages);
1953
1954 /*
1955  * Pin a set of guest IOVA PFNs and return their associated host PFNs for a
1956  * VFIO group.
1957  *
1958  * The caller needs to call vfio_group_get_external_user() or
1959  * vfio_group_get_external_user_from_dev() prior to calling this interface,
1960  * so as to prevent the VFIO group from disposal in the middle of the call.
1961  * But it can keep the reference to the VFIO group for several calls into
1962  * this interface.
1963  * After finishing using of the VFIO group, the caller needs to release the
1964  * VFIO group by calling vfio_group_put_external_user().
1965  *
1966  * @group [in]          : VFIO group
1967  * @user_iova_pfn [in]  : array of user/guest IOVA PFNs to be pinned.
1968  * @npage [in]          : count of elements in user_iova_pfn array.
1969  *                        This count should not be greater
1970  *                        VFIO_PIN_PAGES_MAX_ENTRIES.
1971  * @prot [in]           : protection flags
1972  * @phys_pfn [out]      : array of host PFNs
1973  * Return error or number of pages pinned.
1974  */
1975 int vfio_group_pin_pages(struct vfio_group *group,
1976                          unsigned long *user_iova_pfn, int npage,
1977                          int prot, unsigned long *phys_pfn)
1978 {
1979         struct vfio_container *container;
1980         struct vfio_iommu_driver *driver;
1981         int ret;
1982
1983         if (!group || !user_iova_pfn || !phys_pfn || !npage)
1984                 return -EINVAL;
1985
1986         if (group->dev_counter > 1)
1987                 return -EINVAL;
1988
1989         if (npage > VFIO_PIN_PAGES_MAX_ENTRIES)
1990                 return -E2BIG;
1991
1992         container = group->container;
1993         driver = container->iommu_driver;
1994         if (likely(driver && driver->ops->pin_pages))
1995                 ret = driver->ops->pin_pages(container->iommu_data,
1996                                              group->iommu_group, user_iova_pfn,
1997                                              npage, prot, phys_pfn);
1998         else
1999                 ret = -ENOTTY;
2000
2001         return ret;
2002 }
2003 EXPORT_SYMBOL(vfio_group_pin_pages);
2004
2005 /*
2006  * Unpin a set of guest IOVA PFNs for a VFIO group.
2007  *
2008  * The caller needs to call vfio_group_get_external_user() or
2009  * vfio_group_get_external_user_from_dev() prior to calling this interface,
2010  * so as to prevent the VFIO group from disposal in the middle of the call.
2011  * But it can keep the reference to the VFIO group for several calls into
2012  * this interface.
2013  * After finishing using of the VFIO group, the caller needs to release the
2014  * VFIO group by calling vfio_group_put_external_user().
2015  *
2016  * @group [in]          : vfio group
2017  * @user_iova_pfn [in]  : array of user/guest IOVA PFNs to be unpinned.
2018  * @npage [in]          : count of elements in user_iova_pfn array.
2019  *                        This count should not be greater than
2020  *                        VFIO_PIN_PAGES_MAX_ENTRIES.
2021  * Return error or number of pages unpinned.
2022  */
2023 int vfio_group_unpin_pages(struct vfio_group *group,
2024                            unsigned long *user_iova_pfn, int npage)
2025 {
2026         struct vfio_container *container;
2027         struct vfio_iommu_driver *driver;
2028         int ret;
2029
2030         if (!group || !user_iova_pfn || !npage)
2031                 return -EINVAL;
2032
2033         if (npage > VFIO_PIN_PAGES_MAX_ENTRIES)
2034                 return -E2BIG;
2035
2036         container = group->container;
2037         driver = container->iommu_driver;
2038         if (likely(driver && driver->ops->unpin_pages))
2039                 ret = driver->ops->unpin_pages(container->iommu_data,
2040                                                user_iova_pfn, npage);
2041         else
2042                 ret = -ENOTTY;
2043
2044         return ret;
2045 }
2046 EXPORT_SYMBOL(vfio_group_unpin_pages);
2047
2048
2049 /*
2050  * This interface allows the CPUs to perform some sort of virtual DMA on
2051  * behalf of the device.
2052  *
2053  * CPUs read/write from/into a range of IOVAs pointing to user space memory
2054  * into/from a kernel buffer.
2055  *
2056  * As the read/write of user space memory is conducted via the CPUs and is
2057  * not a real device DMA, it is not necessary to pin the user space memory.
2058  *
2059  * The caller needs to call vfio_group_get_external_user() or
2060  * vfio_group_get_external_user_from_dev() prior to calling this interface,
2061  * so as to prevent the VFIO group from disposal in the middle of the call.
2062  * But it can keep the reference to the VFIO group for several calls into
2063  * this interface.
2064  * After finishing using of the VFIO group, the caller needs to release the
2065  * VFIO group by calling vfio_group_put_external_user().
2066  *
2067  * @group [in]          : VFIO group
2068  * @user_iova [in]      : base IOVA of a user space buffer
2069  * @data [in]           : pointer to kernel buffer
2070  * @len [in]            : kernel buffer length
2071  * @write               : indicate read or write
2072  * Return error code on failure or 0 on success.
2073  */
2074 int vfio_dma_rw(struct vfio_group *group, dma_addr_t user_iova,
2075                 void *data, size_t len, bool write)
2076 {
2077         struct vfio_container *container;
2078         struct vfio_iommu_driver *driver;
2079         int ret = 0;
2080
2081         if (!group || !data || len <= 0)
2082                 return -EINVAL;
2083
2084         container = group->container;
2085         driver = container->iommu_driver;
2086
2087         if (likely(driver && driver->ops->dma_rw))
2088                 ret = driver->ops->dma_rw(container->iommu_data,
2089                                           user_iova, data, len, write);
2090         else
2091                 ret = -ENOTTY;
2092
2093         return ret;
2094 }
2095 EXPORT_SYMBOL(vfio_dma_rw);
2096
2097 static int vfio_register_iommu_notifier(struct vfio_group *group,
2098                                         unsigned long *events,
2099                                         struct notifier_block *nb)
2100 {
2101         struct vfio_container *container;
2102         struct vfio_iommu_driver *driver;
2103         int ret;
2104
2105         ret = vfio_group_add_container_user(group);
2106         if (ret)
2107                 return -EINVAL;
2108
2109         container = group->container;
2110         driver = container->iommu_driver;
2111         if (likely(driver && driver->ops->register_notifier))
2112                 ret = driver->ops->register_notifier(container->iommu_data,
2113                                                      events, nb);
2114         else
2115                 ret = -ENOTTY;
2116
2117         vfio_group_try_dissolve_container(group);
2118
2119         return ret;
2120 }
2121
2122 static int vfio_unregister_iommu_notifier(struct vfio_group *group,
2123                                           struct notifier_block *nb)
2124 {
2125         struct vfio_container *container;
2126         struct vfio_iommu_driver *driver;
2127         int ret;
2128
2129         ret = vfio_group_add_container_user(group);
2130         if (ret)
2131                 return -EINVAL;
2132
2133         container = group->container;
2134         driver = container->iommu_driver;
2135         if (likely(driver && driver->ops->unregister_notifier))
2136                 ret = driver->ops->unregister_notifier(container->iommu_data,
2137                                                        nb);
2138         else
2139                 ret = -ENOTTY;
2140
2141         vfio_group_try_dissolve_container(group);
2142
2143         return ret;
2144 }
2145
2146 void vfio_group_set_kvm(struct vfio_group *group, struct kvm *kvm)
2147 {
2148         group->kvm = kvm;
2149         blocking_notifier_call_chain(&group->notifier,
2150                                 VFIO_GROUP_NOTIFY_SET_KVM, kvm);
2151 }
2152 EXPORT_SYMBOL_GPL(vfio_group_set_kvm);
2153
2154 static int vfio_register_group_notifier(struct vfio_group *group,
2155                                         unsigned long *events,
2156                                         struct notifier_block *nb)
2157 {
2158         int ret;
2159         bool set_kvm = false;
2160
2161         if (*events & VFIO_GROUP_NOTIFY_SET_KVM)
2162                 set_kvm = true;
2163
2164         /* clear known events */
2165         *events &= ~VFIO_GROUP_NOTIFY_SET_KVM;
2166
2167         /* refuse to continue if still events remaining */
2168         if (*events)
2169                 return -EINVAL;
2170
2171         ret = vfio_group_add_container_user(group);
2172         if (ret)
2173                 return -EINVAL;
2174
2175         ret = blocking_notifier_chain_register(&group->notifier, nb);
2176
2177         /*
2178          * The attaching of kvm and vfio_group might already happen, so
2179          * here we replay once upon registration.
2180          */
2181         if (!ret && set_kvm && group->kvm)
2182                 blocking_notifier_call_chain(&group->notifier,
2183                                         VFIO_GROUP_NOTIFY_SET_KVM, group->kvm);
2184
2185         vfio_group_try_dissolve_container(group);
2186
2187         return ret;
2188 }
2189
2190 static int vfio_unregister_group_notifier(struct vfio_group *group,
2191                                          struct notifier_block *nb)
2192 {
2193         int ret;
2194
2195         ret = vfio_group_add_container_user(group);
2196         if (ret)
2197                 return -EINVAL;
2198
2199         ret = blocking_notifier_chain_unregister(&group->notifier, nb);
2200
2201         vfio_group_try_dissolve_container(group);
2202
2203         return ret;
2204 }
2205
2206 int vfio_register_notifier(struct device *dev, enum vfio_notify_type type,
2207                            unsigned long *events, struct notifier_block *nb)
2208 {
2209         struct vfio_group *group;
2210         int ret;
2211
2212         if (!dev || !nb || !events || (*events == 0))
2213                 return -EINVAL;
2214
2215         group = vfio_group_get_from_dev(dev);
2216         if (!group)
2217                 return -ENODEV;
2218
2219         switch (type) {
2220         case VFIO_IOMMU_NOTIFY:
2221                 ret = vfio_register_iommu_notifier(group, events, nb);
2222                 break;
2223         case VFIO_GROUP_NOTIFY:
2224                 ret = vfio_register_group_notifier(group, events, nb);
2225                 break;
2226         default:
2227                 ret = -EINVAL;
2228         }
2229
2230         vfio_group_put(group);
2231         return ret;
2232 }
2233 EXPORT_SYMBOL(vfio_register_notifier);
2234
2235 int vfio_unregister_notifier(struct device *dev, enum vfio_notify_type type,
2236                              struct notifier_block *nb)
2237 {
2238         struct vfio_group *group;
2239         int ret;
2240
2241         if (!dev || !nb)
2242                 return -EINVAL;
2243
2244         group = vfio_group_get_from_dev(dev);
2245         if (!group)
2246                 return -ENODEV;
2247
2248         switch (type) {
2249         case VFIO_IOMMU_NOTIFY:
2250                 ret = vfio_unregister_iommu_notifier(group, nb);
2251                 break;
2252         case VFIO_GROUP_NOTIFY:
2253                 ret = vfio_unregister_group_notifier(group, nb);
2254                 break;
2255         default:
2256                 ret = -EINVAL;
2257         }
2258
2259         vfio_group_put(group);
2260         return ret;
2261 }
2262 EXPORT_SYMBOL(vfio_unregister_notifier);
2263
2264 struct iommu_domain *vfio_group_iommu_domain(struct vfio_group *group)
2265 {
2266         struct vfio_container *container;
2267         struct vfio_iommu_driver *driver;
2268
2269         if (!group)
2270                 return ERR_PTR(-EINVAL);
2271
2272         container = group->container;
2273         driver = container->iommu_driver;
2274         if (likely(driver && driver->ops->group_iommu_domain))
2275                 return driver->ops->group_iommu_domain(container->iommu_data,
2276                                                        group->iommu_group);
2277
2278         return ERR_PTR(-ENOTTY);
2279 }
2280 EXPORT_SYMBOL_GPL(vfio_group_iommu_domain);
2281
2282 /**
2283  * Module/class support
2284  */
2285 static char *vfio_devnode(struct device *dev, umode_t *mode)
2286 {
2287         return kasprintf(GFP_KERNEL, "vfio/%s", dev_name(dev));
2288 }
2289
2290 static struct miscdevice vfio_dev = {
2291         .minor = VFIO_MINOR,
2292         .name = "vfio",
2293         .fops = &vfio_fops,
2294         .nodename = "vfio/vfio",
2295         .mode = S_IRUGO | S_IWUGO,
2296 };
2297
2298 static int __init vfio_init(void)
2299 {
2300         int ret;
2301
2302         idr_init(&vfio.group_idr);
2303         mutex_init(&vfio.group_lock);
2304         mutex_init(&vfio.iommu_drivers_lock);
2305         INIT_LIST_HEAD(&vfio.group_list);
2306         INIT_LIST_HEAD(&vfio.iommu_drivers_list);
2307
2308         ret = misc_register(&vfio_dev);
2309         if (ret) {
2310                 pr_err("vfio: misc device register failed\n");
2311                 return ret;
2312         }
2313
2314         /* /dev/vfio/$GROUP */
2315         vfio.class = class_create(THIS_MODULE, "vfio");
2316         if (IS_ERR(vfio.class)) {
2317                 ret = PTR_ERR(vfio.class);
2318                 goto err_class;
2319         }
2320
2321         vfio.class->devnode = vfio_devnode;
2322
2323         ret = alloc_chrdev_region(&vfio.group_devt, 0, MINORMASK + 1, "vfio");
2324         if (ret)
2325                 goto err_alloc_chrdev;
2326
2327         cdev_init(&vfio.group_cdev, &vfio_group_fops);
2328         ret = cdev_add(&vfio.group_cdev, vfio.group_devt, MINORMASK + 1);
2329         if (ret)
2330                 goto err_cdev_add;
2331
2332         pr_info(DRIVER_DESC " version: " DRIVER_VERSION "\n");
2333
2334 #ifdef CONFIG_VFIO_NOIOMMU
2335         vfio_register_iommu_driver(&vfio_noiommu_ops);
2336 #endif
2337         return 0;
2338
2339 err_cdev_add:
2340         unregister_chrdev_region(vfio.group_devt, MINORMASK + 1);
2341 err_alloc_chrdev:
2342         class_destroy(vfio.class);
2343         vfio.class = NULL;
2344 err_class:
2345         misc_deregister(&vfio_dev);
2346         return ret;
2347 }
2348
2349 static void __exit vfio_cleanup(void)
2350 {
2351         WARN_ON(!list_empty(&vfio.group_list));
2352
2353 #ifdef CONFIG_VFIO_NOIOMMU
2354         vfio_unregister_iommu_driver(&vfio_noiommu_ops);
2355 #endif
2356         idr_destroy(&vfio.group_idr);
2357         cdev_del(&vfio.group_cdev);
2358         unregister_chrdev_region(vfio.group_devt, MINORMASK + 1);
2359         class_destroy(vfio.class);
2360         vfio.class = NULL;
2361         misc_deregister(&vfio_dev);
2362 }
2363
2364 module_init(vfio_init);
2365 module_exit(vfio_cleanup);
2366
2367 MODULE_VERSION(DRIVER_VERSION);
2368 MODULE_LICENSE("GPL v2");
2369 MODULE_AUTHOR(DRIVER_AUTHOR);
2370 MODULE_DESCRIPTION(DRIVER_DESC);
2371 MODULE_ALIAS_MISCDEV(VFIO_MINOR);
2372 MODULE_ALIAS("devname:vfio/vfio");
2373 MODULE_SOFTDEP("post: vfio_iommu_type1 vfio_iommu_spapr_tce");