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         ret = parent->ops->remove(mdev);
  98         if (ret)
  99                 dev_err(&mdev->dev, "Remove failed: err=%d\n", ret);
 100
 101         /* Balances with device_initialize() */
 102         put_device(&mdev->dev);
 103 }
 104
 105 static int mdev_device_remove_cb(struct device *dev, void *data)
 106 {
 107         struct mdev_device *mdev = mdev_from_dev(dev);
 108
 109         if (mdev)
 110                 mdev_device_remove_common(mdev);
 111         return 0;
 112 }
 113
 114 /*
 115  * mdev_register_device : Register a device
 116  * @dev: device structure representing parent device.
 117  * @ops: Parent device operation structure to be registered.
 118  *
 119  * Add device to list of registered parent devices.
 120  * Returns a negative value on error, otherwise 0.
 121  */
 122 int mdev_register_device(struct device *dev, const struct mdev_parent_ops *ops)
 123 {
 124         int ret;
 125         struct mdev_parent *parent;
 126         char *env_string = "MDEV_STATE=registered";
 127         char *envp[] = { env_string, NULL };
 128
 129         /* check for mandatory ops */
 130         if (!ops || !ops->create || !ops->remove || !ops->supported_type_groups)
 131                 return -EINVAL;
 132
 133         dev = get_device(dev);
 134         if (!dev)
 135                 return -EINVAL;
 136
 137         /* Not mandatory, but its absence could be a problem */
 138         if (!ops->request)
 139                 dev_info(dev, "Driver cannot be asked to release device\n");
 140
 141         mutex_lock(&parent_list_lock);
 142
 143         /* Check for duplicate */
 144         parent = __find_parent_device(dev);
 145         if (parent) {
 146                 parent = NULL;
 147                 ret = -EEXIST;
 148                 goto add_dev_err;
 149         }
 150
 151         parent = kzalloc(sizeof(*parent), GFP_KERNEL);
 152         if (!parent) {
 153                 ret = -ENOMEM;
 154                 goto add_dev_err;
 155         }
 156
 157         kref_init(&parent->ref);
 158         init_rwsem(&parent->unreg_sem);
 159
 160         parent->dev = dev;
 161         parent->ops = ops;
 162
 163         if (!mdev_bus_compat_class) {
 164                 mdev_bus_compat_class = class_compat_register("mdev_bus");
 165                 if (!mdev_bus_compat_class) {
 166                         ret = -ENOMEM;
 167                         goto add_dev_err;
 168                 }
 169         }
 170
 171         ret = parent_create_sysfs_files(parent);
 172         if (ret)
 173                 goto add_dev_err;
 174
 175         ret = class_compat_create_link(mdev_bus_compat_class, dev, NULL);
 176         if (ret)
 177                 dev_warn(dev, "Failed to create compatibility class link\n");
 178
 179         list_add(&parent->next, &parent_list);
 180         mutex_unlock(&parent_list_lock);
 181
 182         dev_info(dev, "MDEV: Registered\n");
 183         kobject_uevent_env(&dev->kobj, KOBJ_CHANGE, envp);
 184
 185         return 0;
 186
 187 add_dev_err:
 188         mutex_unlock(&parent_list_lock);
 189         if (parent)
 190                 mdev_put_parent(parent);
 191         else
 192                 put_device(dev);
 193         return ret;
 194 }
 195 EXPORT_SYMBOL(mdev_register_device);
 196
 197 /*
 198  * mdev_unregister_device : Unregister a parent device
 199  * @dev: device structure representing parent device.
 200  *
 201  * Remove device from list of registered parent devices. Give a chance to free
 202  * existing mediated devices for given device.
 203  */
 204
 205 void mdev_unregister_device(struct device *dev)
 206 {
 207         struct mdev_parent *parent;
 208         char *env_string = "MDEV_STATE=unregistered";
 209         char *envp[] = { env_string, NULL };
 210
 211         mutex_lock(&parent_list_lock);
 212         parent = __find_parent_device(dev);
 213
 214         if (!parent) {
 215                 mutex_unlock(&parent_list_lock);
 216                 return;
 217         }
 218         dev_info(dev, "MDEV: Unregistering\n");
 219
 220         list_del(&parent->next);
 221         mutex_unlock(&parent_list_lock);
 222
 223         down_write(&parent->unreg_sem);
 224
 225         class_compat_remove_link(mdev_bus_compat_class, dev, NULL);
 226
 227         device_for_each_child(dev, NULL, mdev_device_remove_cb);
 228
 229         parent_remove_sysfs_files(parent);
 230         up_write(&parent->unreg_sem);
 231
 232         mdev_put_parent(parent);
 233
 234         /* We still have the caller's reference to use for the uevent */
 235         kobject_uevent_env(&dev->kobj, KOBJ_CHANGE, envp);
 236 }
 237 EXPORT_SYMBOL(mdev_unregister_device);
 238
 239 static void mdev_device_release(struct device *dev)
 240 {
 241         struct mdev_device *mdev = to_mdev_device(dev);
 242
 243         /* Pairs with the get in mdev_device_create() */
 244         kobject_put(&mdev->type->kobj);
 245
 246         mutex_lock(&mdev_list_lock);
 247         list_del(&mdev->next);
 248         mutex_unlock(&mdev_list_lock);
 249
 250         dev_dbg(&mdev->dev, "MDEV: destroying\n");
 251         kfree(mdev);
 252 }
 253
 254 int mdev_device_create(struct mdev_type *type, const guid_t *uuid)
 255 {
 256         int ret;
 257         struct mdev_device *mdev, *tmp;
 258         struct mdev_parent *parent = type->parent;
 259
 260         mutex_lock(&mdev_list_lock);
 261
 262         /* Check for duplicate */
 263         list_for_each_entry(tmp, &mdev_list, next) {
 264                 if (guid_equal(&tmp->uuid, uuid)) {
 265                         mutex_unlock(&mdev_list_lock);
 266                         return -EEXIST;
 267                 }
 268         }
 269
 270         mdev = kzalloc(sizeof(*mdev), GFP_KERNEL);
 271         if (!mdev) {
 272                 mutex_unlock(&mdev_list_lock);
 273                 return -ENOMEM;
 274         }
 275
 276         device_initialize(&mdev->dev);
 277         mdev->dev.parent  = parent->dev;
 278         mdev->dev.bus = &mdev_bus_type;
 279         mdev->dev.release = mdev_device_release;
 280         mdev->dev.groups = parent->ops->mdev_attr_groups;
 281         mdev->type = type;
 282         /* Pairs with the put in mdev_device_release() */
 283         kobject_get(&type->kobj);
 284
 285         guid_copy(&mdev->uuid, uuid);
 286         list_add(&mdev->next, &mdev_list);
 287         mutex_unlock(&mdev_list_lock);
 288
 289         ret = dev_set_name(&mdev->dev, "%pUl", uuid);
 290         if (ret)
 291                 goto out_put_device;
 292
 293         /* Check if parent unregistration has started */
 294         if (!down_read_trylock(&parent->unreg_sem)) {
 295                 ret = -ENODEV;
 296                 goto out_put_device;
 297         }
 298
 299         ret = parent->ops->create(mdev);
 300         if (ret)
 301                 goto out_unlock;
 302
 303         ret = device_add(&mdev->dev);
 304         if (ret)
 305                 goto out_remove;
 306
 307         ret = mdev_create_sysfs_files(mdev);
 308         if (ret)
 309                 goto out_del;
 310
 311         mdev->active = true;
 312         dev_dbg(&mdev->dev, "MDEV: created\n");
 313         up_read(&parent->unreg_sem);
 314
 315         return 0;
 316
 317 out_del:
 318         device_del(&mdev->dev);
 319 out_remove:
 320         parent->ops->remove(mdev);
 321 out_unlock:
 322         up_read(&parent->unreg_sem);
 323 out_put_device:
 324         put_device(&mdev->dev);
 325         return ret;
 326 }
 327
 328 int mdev_device_remove(struct mdev_device *mdev)
 329 {
 330         struct mdev_device *tmp;
 331         struct mdev_parent *parent = mdev->type->parent;
 332
 333         mutex_lock(&mdev_list_lock);
 334         list_for_each_entry(tmp, &mdev_list, next) {
 335                 if (tmp == mdev)
 336                         break;
 337         }
 338
 339         if (tmp != mdev) {
 340                 mutex_unlock(&mdev_list_lock);
 341                 return -ENODEV;
 342         }
 343
 344         if (!mdev->active) {
 345                 mutex_unlock(&mdev_list_lock);
 346                 return -EAGAIN;
 347         }
 348
 349         mdev->active = false;
 350         mutex_unlock(&mdev_list_lock);
 351
 352         /* Check if parent unregistration has started */
 353         if (!down_read_trylock(&parent->unreg_sem))
 354                 return -ENODEV;
 355
 356         mdev_device_remove_common(mdev);
 357         up_read(&parent->unreg_sem);
 358         return 0;
 359 }
 360
 361 static int __init mdev_init(void)
 362 {
 363         return mdev_bus_register();
 364 }
 365
 366 static void __exit mdev_exit(void)
 367 {
 368         if (mdev_bus_compat_class)
 369                 class_compat_unregister(mdev_bus_compat_class);
 370
 371         mdev_bus_unregister();
 372 }
 373
 374 module_init(mdev_init)
 375 module_exit(mdev_exit)
 376
 377 MODULE_VERSION(DRIVER_VERSION);
 378 MODULE_LICENSE("GPL v2");
 379 MODULE_AUTHOR(DRIVER_AUTHOR);
 380 MODULE_DESCRIPTION(DRIVER_DESC);
 381 MODULE_SOFTDEP("post: vfio_mdev");