drivers/vfio/mdev/mdev_sysfs.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * File attributes for Mediated devices
   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/sysfs.h>
  11 #include <linux/ctype.h>
  12 #include <linux/device.h>
  13 #include <linux/slab.h>
  14 #include <linux/uuid.h>
  15 #include <linux/mdev.h>
  16
  17 #include "mdev_private.h"
  18
  19 /* Static functions */
  20
  21 static ssize_t mdev_type_attr_show(struct kobject *kobj,
  22                                      struct attribute *__attr, char *buf)
  23 {
  24         struct mdev_type_attribute *attr = to_mdev_type_attr(__attr);
  25         struct mdev_type *type = to_mdev_type(kobj);
  26         ssize_t ret = -EIO;
  27
  28         if (attr->show)
  29                 ret = attr->show(kobj, type->parent->dev, buf);
  30         return ret;
  31 }
  32
  33 static ssize_t mdev_type_attr_store(struct kobject *kobj,
  34                                       struct attribute *__attr,
  35                                       const char *buf, size_t count)
  36 {
  37         struct mdev_type_attribute *attr = to_mdev_type_attr(__attr);
  38         struct mdev_type *type = to_mdev_type(kobj);
  39         ssize_t ret = -EIO;
  40
  41         if (attr->store)
  42                 ret = attr->store(&type->kobj, type->parent->dev, buf, count);
  43         return ret;
  44 }
  45
  46 static const struct sysfs_ops mdev_type_sysfs_ops = {
  47         .show = mdev_type_attr_show,
  48         .store = mdev_type_attr_store,
  49 };
  50
  51 static ssize_t create_store(struct kobject *kobj, struct device *dev,
  52                             const char *buf, size_t count)
  53 {
  54         char *str;
  55         guid_t uuid;
  56         int ret;
  57
  58         if ((count < UUID_STRING_LEN) || (count > UUID_STRING_LEN + 1))
  59                 return -EINVAL;
  60
  61         str = kstrndup(buf, count, GFP_KERNEL);
  62         if (!str)
  63                 return -ENOMEM;
  64
  65         ret = guid_parse(str, &uuid);
  66         kfree(str);
  67         if (ret)
  68                 return ret;
  69
  70         ret = mdev_device_create(to_mdev_type(kobj), &uuid);
  71         if (ret)
  72                 return ret;
  73
  74         return count;
  75 }
  76
  77 static MDEV_TYPE_ATTR_WO(create);
  78
  79 static void mdev_type_release(struct kobject *kobj)
  80 {
  81         struct mdev_type *type = to_mdev_type(kobj);
  82
  83         pr_debug("Releasing group %s\n", kobj->name);
  84         /* Pairs with the get in add_mdev_supported_type() */
  85         mdev_put_parent(type->parent);
  86         kfree(type);
  87 }
  88
  89 static struct kobj_type mdev_type_ktype = {
  90         .sysfs_ops = &mdev_type_sysfs_ops,
  91         .release = mdev_type_release,
  92 };
  93
  94 static struct mdev_type *add_mdev_supported_type(struct mdev_parent *parent,
  95                                                  unsigned int type_group_id)
  96 {
  97         struct mdev_type *type;
  98         struct attribute_group *group =
  99                 parent->ops->supported_type_groups[type_group_id];
 100         int ret;
 101
 102         if (!group->name) {
 103                 pr_err("%s: Type name empty!\n", __func__);
 104                 return ERR_PTR(-EINVAL);
 105         }
 106
 107         type = kzalloc(sizeof(*type), GFP_KERNEL);
 108         if (!type)
 109                 return ERR_PTR(-ENOMEM);
 110
 111         type->kobj.kset = parent->mdev_types_kset;
 112         type->parent = parent;
 113         /* Pairs with the put in mdev_type_release() */
 114         mdev_get_parent(parent);
 115         type->type_group_id = type_group_id;
 116
 117         ret = kobject_init_and_add(&type->kobj, &mdev_type_ktype, NULL,
 118                                    "%s-%s", dev_driver_string(parent->dev),
 119                                    group->name);
 120         if (ret) {
 121                 kobject_put(&type->kobj);
 122                 return ERR_PTR(ret);
 123         }
 124
 125         ret = sysfs_create_file(&type->kobj, &mdev_type_attr_create.attr);
 126         if (ret)
 127                 goto attr_create_failed;
 128
 129         type->devices_kobj = kobject_create_and_add("devices", &type->kobj);
 130         if (!type->devices_kobj) {
 131                 ret = -ENOMEM;
 132                 goto attr_devices_failed;
 133         }
 134
 135         ret = sysfs_create_files(&type->kobj,
 136                                  (const struct attribute **)group->attrs);
 137         if (ret) {
 138                 ret = -ENOMEM;
 139                 goto attrs_failed;
 140         }
 141         return type;
 142
 143 attrs_failed:
 144         kobject_put(type->devices_kobj);
 145 attr_devices_failed:
 146         sysfs_remove_file(&type->kobj, &mdev_type_attr_create.attr);
 147 attr_create_failed:
 148         kobject_del(&type->kobj);
 149         kobject_put(&type->kobj);
 150         return ERR_PTR(ret);
 151 }
 152
 153 static void remove_mdev_supported_type(struct mdev_type *type)
 154 {
 155         struct attribute_group *group =
 156                 type->parent->ops->supported_type_groups[type->type_group_id];
 157
 158         sysfs_remove_files(&type->kobj,
 159                            (const struct attribute **)group->attrs);
 160         kobject_put(type->devices_kobj);
 161         sysfs_remove_file(&type->kobj, &mdev_type_attr_create.attr);
 162         kobject_del(&type->kobj);
 163         kobject_put(&type->kobj);
 164 }
 165
 166 static int add_mdev_supported_type_groups(struct mdev_parent *parent)
 167 {
 168         int i;
 169
 170         for (i = 0; parent->ops->supported_type_groups[i]; i++) {
 171                 struct mdev_type *type;
 172
 173                 type = add_mdev_supported_type(parent, i);
 174                 if (IS_ERR(type)) {
 175                         struct mdev_type *ltype, *tmp;
 176
 177                         list_for_each_entry_safe(ltype, tmp, &parent->type_list,
 178                                                   next) {
 179                                 list_del(&ltype->next);
 180                                 remove_mdev_supported_type(ltype);
 181                         }
 182                         return PTR_ERR(type);
 183                 }
 184                 list_add(&type->next, &parent->type_list);
 185         }
 186         return 0;
 187 }
 188
 189 /* mdev sysfs functions */
 190 void parent_remove_sysfs_files(struct mdev_parent *parent)
 191 {
 192         struct mdev_type *type, *tmp;
 193
 194         list_for_each_entry_safe(type, tmp, &parent->type_list, next) {
 195                 list_del(&type->next);
 196                 remove_mdev_supported_type(type);
 197         }
 198
 199         sysfs_remove_groups(&parent->dev->kobj, parent->ops->dev_attr_groups);
 200         kset_unregister(parent->mdev_types_kset);
 201 }
 202
 203 int parent_create_sysfs_files(struct mdev_parent *parent)
 204 {
 205         int ret;
 206
 207         parent->mdev_types_kset = kset_create_and_add("mdev_supported_types",
 208                                                NULL, &parent->dev->kobj);
 209
 210         if (!parent->mdev_types_kset)
 211                 return -ENOMEM;
 212
 213         INIT_LIST_HEAD(&parent->type_list);
 214
 215         ret = sysfs_create_groups(&parent->dev->kobj,
 216                                   parent->ops->dev_attr_groups);
 217         if (ret)
 218                 goto create_err;
 219
 220         ret = add_mdev_supported_type_groups(parent);
 221         if (ret)
 222                 sysfs_remove_groups(&parent->dev->kobj,
 223                                     parent->ops->dev_attr_groups);
 224         else
 225                 return ret;
 226
 227 create_err:
 228         kset_unregister(parent->mdev_types_kset);
 229         return ret;
 230 }
 231
 232 static ssize_t remove_store(struct device *dev, struct device_attribute *attr,
 233                             const char *buf, size_t count)
 234 {
 235         struct mdev_device *mdev = to_mdev_device(dev);
 236         unsigned long val;
 237
 238         if (kstrtoul(buf, 0, &val) < 0)
 239                 return -EINVAL;
 240
 241         if (val && device_remove_file_self(dev, attr)) {
 242                 int ret;
 243
 244                 ret = mdev_device_remove(mdev);
 245                 if (ret)
 246                         return ret;
 247         }
 248
 249         return count;
 250 }
 251
 252 static DEVICE_ATTR_WO(remove);
 253
 254 static const struct attribute *mdev_device_attrs[] = {
 255         &dev_attr_remove.attr,
 256         NULL,
 257 };
 258
 259 int mdev_create_sysfs_files(struct mdev_device *mdev)
 260 {
 261         struct mdev_type *type = mdev->type;
 262         struct kobject *kobj = &mdev->dev.kobj;
 263         int ret;
 264
 265         ret = sysfs_create_link(type->devices_kobj, kobj, dev_name(&mdev->dev));
 266         if (ret)
 267                 return ret;
 268
 269         ret = sysfs_create_link(kobj, &type->kobj, "mdev_type");
 270         if (ret)
 271                 goto type_link_failed;
 272
 273         ret = sysfs_create_files(kobj, mdev_device_attrs);
 274         if (ret)
 275                 goto create_files_failed;
 276
 277         return ret;
 278
 279 create_files_failed:
 280         sysfs_remove_link(kobj, "mdev_type");
 281 type_link_failed:
 282         sysfs_remove_link(mdev->type->devices_kobj, dev_name(&mdev->dev));
 283         return ret;
 284 }
 285
 286 void mdev_remove_sysfs_files(struct mdev_device *mdev)
 287 {
 288         struct kobject *kobj = &mdev->dev.kobj;
 289
 290         sysfs_remove_files(kobj, mdev_device_attrs);
 291         sysfs_remove_link(kobj, "mdev_type");
 292         sysfs_remove_link(mdev->type->devices_kobj, dev_name(&mdev->dev));
 293 }