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, unsigned int num_queues); 266 267 static ssize_t 268 new_device_store(struct bus_type *bus, const char *buf, size_t count) 269 { 270 unsigned int id, port_count, num_queues; 271 struct nsim_bus_dev *nsim_bus_dev; 272 int err; 273 274 err = sscanf(buf, "%u %u %u", &id, &port_count, &num_queues); 275 switch (err) { 276 case 1: 277 port_count = 1; 278 fallthrough; 279 case 2: 280 num_queues = 1; 281 fallthrough; 282 case 3: 283 if (id > INT_MAX) { 284 pr_err("Value of \"id\" is too big.\n"); 285 return -EINVAL; 286 } 287 break; 288 default: 289 pr_err("Format for adding new device is \"id port_count num_queues\" (uint uint unit).\n"); 290 return -EINVAL; 291 } 292 293 mutex_lock(&nsim_bus_dev_list_lock); 294 /* Prevent to use resource before initialization. */ 295 if (!smp_load_acquire(&nsim_bus_enable)) { 296 err = -EBUSY; 297 goto err; 298 } 299 300 nsim_bus_dev = nsim_bus_dev_new(id, port_count, num_queues); 301 if (IS_ERR(nsim_bus_dev)) { 302 err = PTR_ERR(nsim_bus_dev); 303 goto err; 304 } 305 306 /* Allow using nsim_bus_dev */ 307 smp_store_release(&nsim_bus_dev->init, true); 308 309 list_add_tail(&nsim_bus_dev->list, &nsim_bus_dev_list); 310 mutex_unlock(&nsim_bus_dev_list_lock); 311 312 return count; 313 err: 314 mutex_unlock(&nsim_bus_dev_list_lock); 315 return err; 316 } 317 static BUS_ATTR_WO(new_device); 318 319 static void nsim_bus_dev_del(struct nsim_bus_dev *nsim_bus_dev); 320 321 static ssize_t 322 del_device_store(struct bus_type *bus, const char *buf, size_t count) 323 { 324 struct nsim_bus_dev *nsim_bus_dev, *tmp; 325 unsigned int id; 326 int err; 327 328 err = sscanf(buf, "%u", &id); 329 switch (err) { 330 case 1: 331 if (id > INT_MAX) { 332 pr_err("Value of \"id\" is too big.\n"); 333 return -EINVAL; 334 } 335 break; 336 default: 337 pr_err("Format for deleting device is \"id\" (uint).\n"); 338 return -EINVAL; 339 } 340 341 err = -ENOENT; 342 mutex_lock(&nsim_bus_dev_list_lock); 343 /* Prevent to use resource before initialization. */ 344 if (!smp_load_acquire(&nsim_bus_enable)) { 345 mutex_unlock(&nsim_bus_dev_list_lock); 346 return -EBUSY; 347 } 348 list_for_each_entry_safe(nsim_bus_dev, tmp, &nsim_bus_dev_list, list) { 349 if (nsim_bus_dev->dev.id != id) 350 continue; 351 list_del(&nsim_bus_dev->list); 352 nsim_bus_dev_del(nsim_bus_dev); 353 err = 0; 354 break; 355 } 356 mutex_unlock(&nsim_bus_dev_list_lock); 357 return !err ? count : err; 358 } 359 static BUS_ATTR_WO(del_device); 360 361 static struct attribute *nsim_bus_attrs[] = { 362 &bus_attr_new_device.attr, 363 &bus_attr_del_device.attr, 364 NULL 365 }; 366 ATTRIBUTE_GROUPS(nsim_bus); 367 368 static int nsim_bus_probe(struct device *dev) 369 { 370 struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev); 371 372 return nsim_dev_probe(nsim_bus_dev); 373 } 374 375 static int nsim_bus_remove(struct device *dev) 376 { 377 struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev); 378 379 nsim_dev_remove(nsim_bus_dev); 380 return 0; 381 } 382 383 static int nsim_num_vf(struct device *dev) 384 { 385 struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev); 386 387 return nsim_bus_dev->num_vfs; 388 } 389 390 static struct bus_type nsim_bus = { 391 .name = DRV_NAME, 392 .dev_name = DRV_NAME, 393 .bus_groups = nsim_bus_groups, 394 .probe = nsim_bus_probe, 395 .remove = nsim_bus_remove, 396 .num_vf = nsim_num_vf, 397 }; 398 399 #define NSIM_BUS_DEV_MAX_VFS 4 400 401 static struct nsim_bus_dev * 402 nsim_bus_dev_new(unsigned int id, unsigned int port_count, unsigned int num_queues) 403 { 404 struct nsim_bus_dev *nsim_bus_dev; 405 int err; 406 407 nsim_bus_dev = kzalloc(sizeof(*nsim_bus_dev), GFP_KERNEL); 408 if (!nsim_bus_dev) 409 return ERR_PTR(-ENOMEM); 410 411 err = ida_alloc_range(&nsim_bus_dev_ids, id, id, GFP_KERNEL); 412 if (err < 0) 413 goto err_nsim_bus_dev_free; 414 nsim_bus_dev->dev.id = err; 415 nsim_bus_dev->dev.bus = &nsim_bus; 416 nsim_bus_dev->dev.type = &nsim_bus_dev_type; 417 nsim_bus_dev->port_count = port_count; 418 nsim_bus_dev->num_queues = num_queues; 419 nsim_bus_dev->initial_net = current->nsproxy->net_ns; 420 nsim_bus_dev->max_vfs = NSIM_BUS_DEV_MAX_VFS; 421 mutex_init(&nsim_bus_dev->nsim_bus_reload_lock); 422 mutex_init(&nsim_bus_dev->vfs_lock); 423 /* Disallow using nsim_bus_dev */ 424 smp_store_release(&nsim_bus_dev->init, false); 425 426 nsim_bus_dev->vfconfigs = kcalloc(nsim_bus_dev->max_vfs, 427 sizeof(struct nsim_vf_config), 428 GFP_KERNEL | __GFP_NOWARN); 429 if (!nsim_bus_dev->vfconfigs) { 430 err = -ENOMEM; 431 goto err_nsim_bus_dev_id_free; 432 } 433 434 err = device_register(&nsim_bus_dev->dev); 435 if (err) 436 goto err_nsim_vfs_free; 437 438 return nsim_bus_dev; 439 440 err_nsim_vfs_free: 441 kfree(nsim_bus_dev->vfconfigs); 442 err_nsim_bus_dev_id_free: 443 ida_free(&nsim_bus_dev_ids, nsim_bus_dev->dev.id); 444 err_nsim_bus_dev_free: 445 kfree(nsim_bus_dev); 446 return ERR_PTR(err); 447 } 448 449 static void nsim_bus_dev_del(struct nsim_bus_dev *nsim_bus_dev) 450 { 451 /* Disallow using nsim_bus_dev */ 452 smp_store_release(&nsim_bus_dev->init, false); 453 device_unregister(&nsim_bus_dev->dev); 454 ida_free(&nsim_bus_dev_ids, nsim_bus_dev->dev.id); 455 kfree(nsim_bus_dev->vfconfigs); 456 kfree(nsim_bus_dev); 457 } 458 459 static struct device_driver nsim_driver = { 460 .name = DRV_NAME, 461 .bus = &nsim_bus, 462 .owner = THIS_MODULE, 463 }; 464 465 int nsim_bus_init(void) 466 { 467 int err; 468 469 err = bus_register(&nsim_bus); 470 if (err) 471 return err; 472 err = driver_register(&nsim_driver); 473 if (err) 474 goto err_bus_unregister; 475 /* Allow using resources */ 476 smp_store_release(&nsim_bus_enable, true); 477 return 0; 478 479 err_bus_unregister: 480 bus_unregister(&nsim_bus); 481 return err; 482 } 483 484 void nsim_bus_exit(void) 485 { 486 struct nsim_bus_dev *nsim_bus_dev, *tmp; 487 488 /* Disallow using resources */ 489 smp_store_release(&nsim_bus_enable, false); 490 491 mutex_lock(&nsim_bus_dev_list_lock); 492 list_for_each_entry_safe(nsim_bus_dev, tmp, &nsim_bus_dev_list, list) { 493 list_del(&nsim_bus_dev->list); 494 nsim_bus_dev_del(nsim_bus_dev); 495 } 496 mutex_unlock(&nsim_bus_dev_list_lock); 497 498 driver_unregister(&nsim_driver); 499 bus_unregister(&nsim_bus); 500 } 501