drivers/vfio/mdev/mdev_core.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Mediated device Core Driver
   4  *
   5  * Copyright (c) 2016, NVIDIA CORPORATION. All rights reserved.
   6  *     Author: Neo Jia <cjia@nvidia.com>
   7  *             Kirti Wankhede <kwankhede@nvidia.com>
   8  */
   9
  10 #include <linux/module.h>
  11 #include <linux/device.h>
  12 #include <linux/slab.h>
  13 #include <linux/uuid.h>
  14 #include <linux/sysfs.h>
  15 #include <linux/mdev.h>
  16
  17 #include "mdev_private.h"
  18
  19 #define DRIVER_VERSION          "0.1"
  20 #define DRIVER_AUTHOR           "NVIDIA Corporation"
  21 #define DRIVER_DESC             "Mediated device Core Driver"
  22
  23 static LIST_HEAD(parent_list);
  24 static DEFINE_MUTEX(parent_list_lock);
  25 static struct class_compat *mdev_bus_compat_class;
  26
  27 static LIST_HEAD(mdev_list);
  28 static DEFINE_MUTEX(mdev_list_lock);
  29
  30 struct device *mdev_parent_dev(struct mdev_device *mdev)
  31 {
  32         return mdev->type->parent->dev;
  33 }
  34 EXPORT_SYMBOL(mdev_parent_dev);
  35
  36 /*
  37  * Return the index in supported_type_groups that this mdev_device was created
  38  * from.
  39  */
  40 unsigned int mdev_get_type_group_id(struct mdev_device *mdev)
  41 {
  42         return mdev->type->type_group_id;
  43 }
  44 EXPORT_SYMBOL(mdev_get_type_group_id);
  45
  46 /*
  47  * Used in mdev_type_attribute sysfs functions to return the index in the
  48  * supported_type_groups that the sysfs is called from.
  49  */
  50 unsigned int mtype_get_type_group_id(struct mdev_type *mtype)
  51 {
  52         return mtype->type_group_id;
  53 }
  54 EXPORT_SYMBOL(mtype_get_type_group_id);
  55
  56 /*
  57  * Used in mdev_type_attribute sysfs functions to return the parent struct
  58  * device
  59  */
  60 struct device *mtype_get_parent_dev(struct mdev_type *mtype)
  61 {
  62         return mtype->parent->dev;
  63 }
  64 EXPORT_SYMBOL(mtype_get_parent_dev);
  65
  66 /* Should be called holding parent_list_lock */
  67 static struct mdev_parent *__find_parent_device(struct device *dev)
  68 {
  69         struct mdev_parent *parent;
  70
  71         list_for_each_entry(parent, &parent_list, next) {
  72                 if (parent->dev == dev)
  73                         return parent;
  74         }
  75         return NULL;
  76 }
  77
  78 void mdev_release_parent(struct kref *kref)
  79 {
  80         struct mdev_parent *parent = container_of(kref, struct mdev_parent,
  81                                                   ref);
  82         struct device *dev = parent->dev;
  83
  84         kfree(parent);
  85         put_device(dev);
  86 }
  87
  88 /* Caller must hold parent unreg_sem read or write lock */
  89 static void mdev_device_remove_common(struct mdev_device *mdev)
  90 {
  91         struct mdev_parent *parent = mdev->type->parent;
  92         int ret;
  93
  94         mdev_remove_sysfs_files(mdev);
  95         device_del(&mdev->dev);
  96         lockdep_assert_held(&parent->unreg_sem);
  97         if (parent->ops->remove) {
  98                 ret = parent->ops->remove(mdev);
  99                 if (ret)
 100                         dev_err(&mdev->dev, "Remove failed: err=%d\n", ret);
 101         }
 102
 103         /* Balances with device_initialize() */
 104         put_device(&mdev->dev);
 105 }
 106
 107 static int mdev_device_remove_cb(struct device *dev, void *data)
 108 {
 109         struct mdev_device *mdev = mdev_from_dev(dev);
 110
 111         if (mdev)
 112                 mdev_device_remove_common(mdev);
 113         return 0;
 114 }
 115
 116 /*
 117  * mdev_register_device : Register a device
 118  * @dev: device structure representing parent device.
 119  * @ops: Parent device operation structure to be registered.
 120  *
 121  * Add device to list of registered parent devices.
 122  * Returns a negative value on error, otherwise 0.
 123  */
 124 int mdev_register_device(struct device *dev, const struct mdev_parent_ops *ops)
 125 {
 126         int ret;
 127         struct mdev_parent *parent;
 128         char *env_string = "MDEV_STATE=registered";
 129         char *envp[] = { env_string, NULL };
 130
 131         /* check for mandatory ops */
 132         if (!ops || !ops->supported_type_groups)
 133                 return -EINVAL;
 134         if (!ops->device_driver && (!ops->create || !ops->remove))
 135                 return -EINVAL;
 136
 137         dev = get_device(dev);
 138         if (!dev)
 139                 return -EINVAL;
 140
 141         /* Not mandatory, but its absence could be a problem */
 142         if (!ops->request)
 143                 dev_info(dev, "Driver cannot be asked to release device\n");
 144
 145         mutex_lock(&parent_list_lock);
 146
 147         /* Check for duplicate */
 148         parent = __find_parent_device(dev);
 149         if (parent) {
 150                 parent = NULL;
 151                 ret = -EEXIST;
 152                 goto add_dev_err;
 153         }
 154
 155         parent = kzalloc(sizeof(*parent), GFP_KERNEL);
 156         if (!parent) {
 157                 ret = -ENOMEM;
 158                 goto add_dev_err;
 159         }
 160
 161         kref_init(&parent->ref);
 162         init_rwsem(&parent->unreg_sem);
 163
 164         parent->dev = dev;
 165         parent->ops = ops;
 166
 167         if (!mdev_bus_compat_class) {
 168                 mdev_bus_compat_class = class_compat_register("mdev_bus");
 169                 if (!mdev_bus_compat_class) {
 170                         ret = -ENOMEM;
 171                         goto add_dev_err;
 172                 }
 173         }
 174
 175         ret = parent_create_sysfs_files(parent);
 176         if (ret)
 177                 goto add_dev_err;
 178
 179         ret = class_compat_create_link(mdev_bus_compat_class, dev, NULL);
 180         if (ret)
 181                 dev_warn(dev, "Failed to create compatibility class link\n");
 182
 183         list_add(&parent->next, &parent_list);
 184         mutex_unlock(&parent_list_lock);
 185
 186         dev_info(dev, "MDEV: Registered\n");
 187         kobject_uevent_env(&dev->kobj, KOBJ_CHANGE, envp);
 188
 189         return 0;
 190
 191 add_dev_err:
 192         mutex_unlock(&parent_list_lock);
 193         if (parent)
 194                 mdev_put_parent(parent);
 195         else
 196                 put_device(dev);
 197         return ret;
 198 }
 199 EXPORT_SYMBOL(mdev_register_device);
 200
 201 /*
 202  * mdev_unregister_device : Unregister a parent device
 203  * @dev: device structure representing parent device.
 204  *
 205  * Remove device from list of registered parent devices. Give a chance to free
 206  * existing mediated devices for given device.
 207  */
 208
 209 void mdev_unregister_device(struct device *dev)
 210 {
 211         struct mdev_parent *parent;
 212         char *env_string = "MDEV_STATE=unregistered";
 213         char *envp[] = { env_string, NULL };
 214
 215         mutex_lock(&parent_list_lock);
 216         parent = __find_parent_device(dev);
 217
 218         if (!parent) {
 219                 mutex_unlock(&parent_list_lock);
 220                 return;
 221         }
 222         dev_info(dev, "MDEV: Unregistering\n");
 223
 224         list_del(&parent->next);
 225         mutex_unlock(&parent_list_lock);
 226
 227         down_write(&parent->unreg_sem);
 228
 229         class_compat_remove_link(mdev_bus_compat_class, dev, NULL);
 230
 231         device_for_each_child(dev, NULL, mdev_device_remove_cb);
 232
 233         parent_remove_sysfs_files(parent);
 234         up_write(&parent->unreg_sem);
 235
 236         mdev_put_parent(parent);
 237
 238         /* We still have the caller's reference to use for the uevent */
 239         kobject_uevent_env(&dev->kobj, KOBJ_CHANGE, envp);
 240 }
 241 EXPORT_SYMBOL(mdev_unregister_device);
 242
 243 static void mdev_device_release(struct device *dev)
 244 {
 245         struct mdev_device *mdev = to_mdev_device(dev);
 246
 247         /* Pairs with the get in mdev_device_create() */
 248         kobject_put(&mdev->type->kobj);
 249
 250         mutex_lock(&mdev_list_lock);
 251         list_del(&mdev->next);
 252         mutex_unlock(&mdev_list_lock);
 253
 254         dev_dbg(&mdev->dev, "MDEV: destroying\n");
 255         kfree(mdev);
 256 }
 257
 258 int mdev_device_create(struct mdev_type *type, const guid_t *uuid)
 259 {
 260         int ret;
 261         struct mdev_device *mdev, *tmp;
 262         struct mdev_parent *parent = type->parent;
 263         struct mdev_driver *drv = parent->ops->device_driver;
 264
 265         mutex_lock(&mdev_list_lock);
 266
 267         /* Check for duplicate */
 268         list_for_each_entry(tmp, &mdev_list, next) {
 269                 if (guid_equal(&tmp->uuid, uuid)) {
 270                         mutex_unlock(&mdev_list_lock);
 271                         return -EEXIST;
 272                 }
 273         }
 274
 275         mdev = kzalloc(sizeof(*mdev), GFP_KERNEL);
 276         if (!mdev) {
 277                 mutex_unlock(&mdev_list_lock);
 278                 return -ENOMEM;
 279         }
 280
 281         device_initialize(&mdev->dev);
 282         mdev->dev.parent  = parent->dev;
 283         mdev->dev.bus = &mdev_bus_type;
 284         mdev->dev.release = mdev_device_release;
 285         mdev->dev.groups = parent->ops->mdev_attr_groups;
 286         mdev->type = type;
 287         /* Pairs with the put in mdev_device_release() */
 288         kobject_get(&type->kobj);
 289
 290         guid_copy(&mdev->uuid, uuid);
 291         list_add(&mdev->next, &mdev_list);
 292         mutex_unlock(&mdev_list_lock);
 293
 294         ret = dev_set_name(&mdev->dev, "%pUl", uuid);
 295         if (ret)
 296                 goto out_put_device;
 297
 298         /* Check if parent unregistration has started */
 299         if (!down_read_trylock(&parent->unreg_sem)) {
 300                 ret = -ENODEV;
 301                 goto out_put_device;
 302         }
 303
 304         if (parent->ops->create) {
 305                 ret = parent->ops->create(mdev);
 306                 if (ret)
 307                         goto out_unlock;
 308         }
 309
 310         ret = device_add(&mdev->dev);
 311         if (ret)
 312                 goto out_remove;
 313
 314         if (!drv)
 315                 drv = &vfio_mdev_driver;
 316         ret = device_driver_attach(&drv->driver, &mdev->dev);
 317         if (ret)
 318                 goto out_del;
 319
 320         ret = mdev_create_sysfs_files(mdev);
 321         if (ret)
 322                 goto out_del;
 323
 324         mdev->active = true;
 325         dev_dbg(&mdev->dev, "MDEV: created\n");
 326         up_read(&parent->unreg_sem);
 327
 328         return 0;
 329
 330 out_del:
 331         device_del(&mdev->dev);
 332 out_remove:
 333         if (parent->ops->remove)
 334                 parent->ops->remove(mdev);
 335 out_unlock:
 336         up_read(&parent->unreg_sem);
 337 out_put_device:
 338         put_device(&mdev->dev);
 339         return ret;
 340 }
 341
 342 int mdev_device_remove(struct mdev_device *mdev)
 343 {
 344         struct mdev_device *tmp;
 345         struct mdev_parent *parent = mdev->type->parent;
 346
 347         mutex_lock(&mdev_list_lock);
 348         list_for_each_entry(tmp, &mdev_list, next) {
 349                 if (tmp == mdev)
 350                         break;
 351         }
 352
 353         if (tmp != mdev) {
 354                 mutex_unlock(&mdev_list_lock);
 355                 return -ENODEV;
 356         }
 357
 358         if (!mdev->active) {
 359                 mutex_unlock(&mdev_list_lock);
 360                 return -EAGAIN;
 361         }
 362
 363         mdev->active = false;
 364         mutex_unlock(&mdev_list_lock);
 365
 366         /* Check if parent unregistration has started */
 367         if (!down_read_trylock(&parent->unreg_sem))
 368                 return -ENODEV;
 369
 370         mdev_device_remove_common(mdev);
 371         up_read(&parent->unreg_sem);
 372         return 0;
 373 }
 374
 375 static int __init mdev_init(void)
 376 {
 377         int rc;
 378
 379         rc = mdev_bus_register();
 380         if (rc)
 381                 return rc;
 382         rc = mdev_register_driver(&vfio_mdev_driver);
 383         if (rc)
 384                 goto err_bus;
 385         return 0;
 386 err_bus:
 387         mdev_bus_unregister();
 388         return rc;
 389 }
 390
 391 static void __exit mdev_exit(void)
 392 {
 393         mdev_unregister_driver(&vfio_mdev_driver);
 394
 395         if (mdev_bus_compat_class)
 396                 class_compat_unregister(mdev_bus_compat_class);
 397
 398         mdev_bus_unregister();
 399 }
 400
 401 module_init(mdev_init)
 402 module_exit(mdev_exit)
 403
 404 MODULE_VERSION(DRIVER_VERSION);
 405 MODULE_LICENSE("GPL v2");
 406 MODULE_AUTHOR(DRIVER_AUTHOR);
 407 MODULE_DESCRIPTION(DRIVER_DESC);