1 // SPDX-License-Identifier: GPL-2.0 2 /* Copyright (C) 2017 Netronome Systems, Inc. 3 * Copyright (C) 2019 Mellanox Technologies. All rights reserved 4 */ 5 6 #include <linux/device.h> 7 #include <linux/idr.h> 8 #include <linux/kernel.h> 9 #include <linux/list.h> 10 #include <linux/mutex.h> 11 #include <linux/rtnetlink.h> 12 #include <linux/slab.h> 13 #include <linux/sysfs.h> 14 15 #include "netdevsim.h" 16 17 static DEFINE_IDA(nsim_bus_dev_ids); 18 static LIST_HEAD(nsim_bus_dev_list); 19 static DEFINE_MUTEX(nsim_bus_dev_list_lock); 20 static bool nsim_bus_enable; 21 22 static struct nsim_bus_dev *to_nsim_bus_dev(struct device *dev) 23 { 24 return container_of(dev, struct nsim_bus_dev, dev); 25 } 26 27 static int nsim_bus_dev_vfs_enable(struct nsim_bus_dev *nsim_bus_dev, 28 unsigned int num_vfs) 29 { 30 struct nsim_dev *nsim_dev; 31 int err = 0; 32 33 if (nsim_bus_dev->max_vfs < num_vfs) 34 return -ENOMEM; 35 36 if (!nsim_bus_dev->vfconfigs) 37 return -ENOMEM; 38 nsim_bus_dev->num_vfs = num_vfs; 39 40 nsim_dev = dev_get_drvdata(&nsim_bus_dev->dev); 41 if (nsim_esw_mode_is_switchdev(nsim_dev)) { 42 err = nsim_esw_switchdev_enable(nsim_dev, NULL); 43 if (err) 44 nsim_bus_dev->num_vfs = 0; 45 } 46 47 return err; 48 } 49 50 void nsim_bus_dev_vfs_disable(struct nsim_bus_dev *nsim_bus_dev) 51 { 52 struct nsim_dev *nsim_dev; 53 54 nsim_bus_dev->num_vfs = 0; 55 nsim_dev = dev_get_drvdata(&nsim_bus_dev->dev); 56 if (nsim_esw_mode_is_switchdev(nsim_dev)) 57 nsim_esw_legacy_enable(nsim_dev, NULL); 58 } 59 60 static ssize_t 61 nsim_bus_dev_numvfs_store(struct device *dev, struct device_attribute *attr, 62 const char *buf, size_t count) 63 { 64 struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev); 65 unsigned int num_vfs; 66 int ret; 67 68 ret = kstrtouint(buf, 0, &num_vfs); 69 if (ret) 70 return ret; 71 72 mutex_lock(&nsim_bus_dev->vfs_lock); 73 if (nsim_bus_dev->num_vfs == num_vfs) 74 goto exit_good; 75 if (nsim_bus_dev->num_vfs && num_vfs) { 76 ret = -EBUSY; 77 goto exit_unlock; 78 } 79 80 if (num_vfs) { 81 ret = nsim_bus_dev_vfs_enable(nsim_bus_dev, num_vfs); 82 if (ret) 83 goto exit_unlock; 84 } else { 85 nsim_bus_dev_vfs_disable(nsim_bus_dev); 86 } 87 exit_good: 88 ret = count; 89 exit_unlock: 90 mutex_unlock(&nsim_bus_dev->vfs_lock); 91 92 return ret; 93 } 94 95 static ssize_t 96 nsim_bus_dev_numvfs_show(struct device *dev, 97 struct device_attribute *attr, char *buf) 98 { 99 struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev); 100 101 return sprintf(buf, "%u\n", nsim_bus_dev->num_vfs); 102 } 103 104 static struct device_attribute nsim_bus_dev_numvfs_attr = 105 __ATTR(sriov_numvfs, 0664, nsim_bus_dev_numvfs_show, 106 nsim_bus_dev_numvfs_store); 107 108 ssize_t nsim_bus_dev_max_vfs_read(struct file *file, 109 char __user *data, 110 size_t count, loff_t *ppos) 111 { 112 struct nsim_bus_dev *nsim_bus_dev = file->private_data; 113 char buf[11]; 114 ssize_t len; 115 116 len = snprintf(buf, sizeof(buf), "%u\n", nsim_bus_dev->max_vfs); 117 if (len < 0) 118 return len; 119 120 return simple_read_from_buffer(data, count, ppos, buf, len); 121 } 122 123 ssize_t nsim_bus_dev_max_vfs_write(struct file *file, 124 const char __user *data, 125 size_t count, loff_t *ppos) 126 { 127 struct nsim_bus_dev *nsim_bus_dev = file->private_data; 128 struct nsim_vf_config *vfconfigs; 129 ssize_t ret; 130 char buf[10]; 131 u32 val; 132 133 if (*ppos != 0) 134 return 0; 135 136 if (count >= sizeof(buf)) 137 return -ENOSPC; 138 139 mutex_lock(&nsim_bus_dev->vfs_lock); 140 /* Reject if VFs are configured */ 141 if (nsim_bus_dev->num_vfs) { 142 ret = -EBUSY; 143 goto unlock; 144 } 145 146 ret = copy_from_user(buf, data, count); 147 if (ret) { 148 ret = -EFAULT; 149 goto unlock; 150 } 151 152 buf[count] = '\0'; 153 ret = kstrtouint(buf, 10, &val); 154 if (ret) { 155 ret = -EIO; 156 goto unlock; 157 } 158 159 /* max_vfs limited by the maximum number of provided port indexes */ 160 if (val > NSIM_DEV_VF_PORT_INDEX_MAX - NSIM_DEV_VF_PORT_INDEX_BASE) { 161 ret = -ERANGE; 162 goto unlock; 163 } 164 165 vfconfigs = kcalloc(val, sizeof(struct nsim_vf_config), GFP_KERNEL | __GFP_NOWARN); 166 if (!vfconfigs) { 167 ret = -ENOMEM; 168 goto unlock; 169 } 170 171 kfree(nsim_bus_dev->vfconfigs); 172 nsim_bus_dev->vfconfigs = vfconfigs; 173 nsim_bus_dev->max_vfs = val; 174 *ppos += count; 175 ret = count; 176 unlock: 177 mutex_unlock(&nsim_bus_dev->vfs_lock); 178 return ret; 179 } 180 181 static ssize_t 182 new_port_store(struct device *dev, struct device_attribute *attr, 183 const char *buf, size_t count) 184 { 185 struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev); 186 struct nsim_dev *nsim_dev = dev_get_drvdata(dev); 187 struct devlink *devlink; 188 unsigned int port_index; 189 int ret; 190 191 /* Prevent to use nsim_bus_dev before initialization. */ 192 if (!smp_load_acquire(&nsim_bus_dev->init)) 193 return -EBUSY; 194 ret = kstrtouint(buf, 0, &port_index); 195 if (ret) 196 return ret; 197 198 devlink = priv_to_devlink(nsim_dev); 199 200 mutex_lock(&nsim_bus_dev->nsim_bus_reload_lock); 201 devlink_reload_disable(devlink); 202 ret = nsim_dev_port_add(nsim_bus_dev, NSIM_DEV_PORT_TYPE_PF, port_index); 203 devlink_reload_enable(devlink); 204 mutex_unlock(&nsim_bus_dev->nsim_bus_reload_lock); 205 return ret ? ret : count; 206 } 207 208 static struct device_attribute nsim_bus_dev_new_port_attr = __ATTR_WO(new_port); 209 210 static ssize_t 211 del_port_store(struct device *dev, struct device_attribute *attr, 212 const char *buf, size_t count) 213 { 214 struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev); 215 struct nsim_dev *nsim_dev = dev_get_drvdata(dev); 216 struct devlink *devlink; 217 unsigned int port_index; 218 int ret; 219 220 /* Prevent to use nsim_bus_dev before initialization. */ 221 if (!smp_load_acquire(&nsim_bus_dev->init)) 222 return -EBUSY; 223 ret = kstrtouint(buf, 0, &port_index); 224 if (ret) 225 return ret; 226 227 devlink = priv_to_devlink(nsim_dev); 228 229 mutex_lock(&nsim_bus_dev->nsim_bus_reload_lock); 230 devlink_reload_disable(devlink); 231 ret = nsim_dev_port_del(nsim_bus_dev, NSIM_DEV_PORT_TYPE_PF, port_index); 232 devlink_reload_enable(devlink); 233 mutex_unlock(&nsim_bus_dev->nsim_bus_reload_lock); 234 return ret ? ret : count; 235 } 236 237 static struct device_attribute nsim_bus_dev_del_port_attr = __ATTR_WO(del_port); 238 239 static struct attribute *nsim_bus_dev_attrs[] = { 240 &nsim_bus_dev_numvfs_attr.attr, 241 &nsim_bus_dev_new_port_attr.attr, 242 &nsim_bus_dev_del_port_attr.attr, 243 NULL, 244 }; 245 246 static const struct attribute_group nsim_bus_dev_attr_group = { 247 .attrs = nsim_bus_dev_attrs, 248 }; 249 250 static const struct attribute_group *nsim_bus_dev_attr_groups[] = { 251 &nsim_bus_dev_attr_group, 252 NULL, 253 }; 254 255 static void nsim_bus_dev_release(struct device *dev) 256 { 257 } 258 259 static struct device_type nsim_bus_dev_type = { 260 .groups = nsim_bus_dev_attr_groups, 261 .release = nsim_bus_dev_release, 262 }; 263 264 static struct nsim_bus_dev * 265 nsim_bus_dev_new(unsigned int id, unsigned int port_count); 266 267 static ssize_t 268 new_device_store(struct bus_type *bus, const char *buf, size_t count) 269 { 270 struct nsim_bus_dev *nsim_bus_dev; 271 unsigned int port_count; 272 unsigned int id; 273 int err; 274 275 err = sscanf(buf, "%u %u", &id, &port_count); 276 switch (err) { 277 case 1: 278 port_count = 1; 279 fallthrough; 280 case 2: 281 if (id > INT_MAX) { 282 pr_err("Value of \"id\" is too big.\n"); 283 return -EINVAL; 284 } 285 break; 286 default: 287 pr_err("Format for adding new device is \"id port_count\" (uint uint).\n"); 288 return -EINVAL; 289 } 290 291 mutex_lock(&nsim_bus_dev_list_lock); 292 /* Prevent to use resource before initialization. */ 293 if (!smp_load_acquire(&nsim_bus_enable)) { 294 err = -EBUSY; 295 goto err; 296 } 297 298 nsim_bus_dev = nsim_bus_dev_new(id, port_count); 299 if (IS_ERR(nsim_bus_dev)) { 300 err = PTR_ERR(nsim_bus_dev); 301 goto err; 302 } 303 304 /* Allow using nsim_bus_dev */ 305 smp_store_release(&nsim_bus_dev->init, true); 306 307 list_add_tail(&nsim_bus_dev->list, &nsim_bus_dev_list); 308 mutex_unlock(&nsim_bus_dev_list_lock); 309 310 return count; 311 err: 312 mutex_unlock(&nsim_bus_dev_list_lock); 313 return err; 314 } 315 static BUS_ATTR_WO(new_device); 316 317 static void nsim_bus_dev_del(struct nsim_bus_dev *nsim_bus_dev); 318 319 static ssize_t 320 del_device_store(struct bus_type *bus, const char *buf, size_t count) 321 { 322 struct nsim_bus_dev *nsim_bus_dev, *tmp; 323 unsigned int id; 324 int err; 325 326 err = sscanf(buf, "%u", &id); 327 switch (err) { 328 case 1: 329 if (id > INT_MAX) { 330 pr_err("Value of \"id\" is too big.\n"); 331 return -EINVAL; 332 } 333 break; 334 default: 335 pr_err("Format for deleting device is \"id\" (uint).\n"); 336 return -EINVAL; 337 } 338 339 err = -ENOENT; 340 mutex_lock(&nsim_bus_dev_list_lock); 341 /* Prevent to use resource before initialization. */ 342 if (!smp_load_acquire(&nsim_bus_enable)) { 343 mutex_unlock(&nsim_bus_dev_list_lock); 344 return -EBUSY; 345 } 346 list_for_each_entry_safe(nsim_bus_dev, tmp, &nsim_bus_dev_list, list) { 347 if (nsim_bus_dev->dev.id != id) 348 continue; 349 list_del(&nsim_bus_dev->list); 350 nsim_bus_dev_del(nsim_bus_dev); 351 err = 0; 352 break; 353 } 354 mutex_unlock(&nsim_bus_dev_list_lock); 355 return !err ? count : err; 356 } 357 static BUS_ATTR_WO(del_device); 358 359 static struct attribute *nsim_bus_attrs[] = { 360 &bus_attr_new_device.attr, 361 &bus_attr_del_device.attr, 362 NULL 363 }; 364 ATTRIBUTE_GROUPS(nsim_bus); 365 366 static int nsim_bus_probe(struct device *dev) 367 { 368 struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev); 369 370 return nsim_dev_probe(nsim_bus_dev); 371 } 372 373 static void nsim_bus_remove(struct device *dev) 374 { 375 struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev); 376 377 nsim_dev_remove(nsim_bus_dev); 378 } 379 380 static int nsim_num_vf(struct device *dev) 381 { 382 struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev); 383 384 return nsim_bus_dev->num_vfs; 385 } 386 387 static struct bus_type nsim_bus = { 388 .name = DRV_NAME, 389 .dev_name = DRV_NAME, 390 .bus_groups = nsim_bus_groups, 391 .probe = nsim_bus_probe, 392 .remove = nsim_bus_remove, 393 .num_vf = nsim_num_vf, 394 }; 395 396 #define NSIM_BUS_DEV_MAX_VFS 4 397 398 static struct nsim_bus_dev * 399 nsim_bus_dev_new(unsigned int id, unsigned int port_count) 400 { 401 struct nsim_bus_dev *nsim_bus_dev; 402 int err; 403 404 nsim_bus_dev = kzalloc(sizeof(*nsim_bus_dev), GFP_KERNEL); 405 if (!nsim_bus_dev) 406 return ERR_PTR(-ENOMEM); 407 408 err = ida_alloc_range(&nsim_bus_dev_ids, id, id, GFP_KERNEL); 409 if (err < 0) 410 goto err_nsim_bus_dev_free; 411 nsim_bus_dev->dev.id = err; 412 nsim_bus_dev->dev.bus = &nsim_bus; 413 nsim_bus_dev->dev.type = &nsim_bus_dev_type; 414 nsim_bus_dev->port_count = port_count; 415 nsim_bus_dev->initial_net = current->nsproxy->net_ns; 416 nsim_bus_dev->max_vfs = NSIM_BUS_DEV_MAX_VFS; 417 mutex_init(&nsim_bus_dev->nsim_bus_reload_lock); 418 mutex_init(&nsim_bus_dev->vfs_lock); 419 /* Disallow using nsim_bus_dev */ 420 smp_store_release(&nsim_bus_dev->init, false); 421 422 nsim_bus_dev->vfconfigs = kcalloc(nsim_bus_dev->max_vfs, 423 sizeof(struct nsim_vf_config), 424 GFP_KERNEL | __GFP_NOWARN); 425 if (!nsim_bus_dev->vfconfigs) { 426 err = -ENOMEM; 427 goto err_nsim_bus_dev_id_free; 428 } 429 430 err = device_register(&nsim_bus_dev->dev); 431 if (err) 432 goto err_nsim_vfs_free; 433 434 return nsim_bus_dev; 435 436 err_nsim_vfs_free: 437 kfree(nsim_bus_dev->vfconfigs); 438 err_nsim_bus_dev_id_free: 439 ida_free(&nsim_bus_dev_ids, nsim_bus_dev->dev.id); 440 err_nsim_bus_dev_free: 441 kfree(nsim_bus_dev); 442 return ERR_PTR(err); 443 } 444 445 static void nsim_bus_dev_del(struct nsim_bus_dev *nsim_bus_dev) 446 { 447 /* Disallow using nsim_bus_dev */ 448 smp_store_release(&nsim_bus_dev->init, false); 449 device_unregister(&nsim_bus_dev->dev); 450 ida_free(&nsim_bus_dev_ids, nsim_bus_dev->dev.id); 451 kfree(nsim_bus_dev->vfconfigs); 452 kfree(nsim_bus_dev); 453 } 454 455 static struct device_driver nsim_driver = { 456 .name = DRV_NAME, 457 .bus = &nsim_bus, 458 .owner = THIS_MODULE, 459 }; 460 461 int nsim_bus_init(void) 462 { 463 int err; 464 465 err = bus_register(&nsim_bus); 466 if (err) 467 return err; 468 err = driver_register(&nsim_driver); 469 if (err) 470 goto err_bus_unregister; 471 /* Allow using resources */ 472 smp_store_release(&nsim_bus_enable, true); 473 return 0; 474 475 err_bus_unregister: 476 bus_unregister(&nsim_bus); 477 return err; 478 } 479 480 void nsim_bus_exit(void) 481 { 482 struct nsim_bus_dev *nsim_bus_dev, *tmp; 483 484 /* Disallow using resources */ 485 smp_store_release(&nsim_bus_enable, false); 486 487 mutex_lock(&nsim_bus_dev_list_lock); 488 list_for_each_entry_safe(nsim_bus_dev, tmp, &nsim_bus_dev_list, list) { 489 list_del(&nsim_bus_dev->list); 490 nsim_bus_dev_del(nsim_bus_dev); 491 } 492 mutex_unlock(&nsim_bus_dev_list_lock); 493 494 driver_unregister(&nsim_driver); 495 bus_unregister(&nsim_bus); 496 } 497