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