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 <[email protected]> 7 * Kirti Wankhede <[email protected]> 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(<ype->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 } 294