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/completion.h> 7 #include <linux/device.h> 8 #include <linux/idr.h> 9 #include <linux/kernel.h> 10 #include <linux/list.h> 11 #include <linux/mutex.h> 12 #include <linux/refcount.h> 13 #include <linux/slab.h> 14 #include <linux/sysfs.h> 15 16 #include "netdevsim.h" 17 18 static DEFINE_IDA(nsim_bus_dev_ids); 19 static LIST_HEAD(nsim_bus_dev_list); 20 static DEFINE_MUTEX(nsim_bus_dev_list_lock); 21 static bool nsim_bus_enable; 22 static refcount_t nsim_bus_devs; /* Including the bus itself. */ 23 static DECLARE_COMPLETION(nsim_bus_devs_released); 24 25 static struct nsim_bus_dev *to_nsim_bus_dev(struct device *dev) 26 { 27 return container_of(dev, struct nsim_bus_dev, dev); 28 } 29 30 static ssize_t 31 nsim_bus_dev_numvfs_store(struct device *dev, struct device_attribute *attr, 32 const char *buf, size_t count) 33 { 34 struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev); 35 unsigned int num_vfs; 36 int ret; 37 38 ret = kstrtouint(buf, 0, &num_vfs); 39 if (ret) 40 return ret; 41 42 device_lock(dev); 43 ret = -ENOENT; 44 if (dev_get_drvdata(dev)) 45 ret = nsim_drv_configure_vfs(nsim_bus_dev, num_vfs); 46 device_unlock(dev); 47 48 return ret ? ret : count; 49 } 50 51 static ssize_t 52 nsim_bus_dev_numvfs_show(struct device *dev, 53 struct device_attribute *attr, char *buf) 54 { 55 struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev); 56 57 return sprintf(buf, "%u\n", nsim_bus_dev->num_vfs); 58 } 59 60 static struct device_attribute nsim_bus_dev_numvfs_attr = 61 __ATTR(sriov_numvfs, 0664, nsim_bus_dev_numvfs_show, 62 nsim_bus_dev_numvfs_store); 63 64 static ssize_t 65 new_port_store(struct device *dev, struct device_attribute *attr, 66 const char *buf, size_t count) 67 { 68 struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev); 69 u8 eth_addr[ETH_ALEN] = {}; 70 unsigned int port_index; 71 bool addr_set = false; 72 int ret; 73 74 /* Prevent to use nsim_bus_dev before initialization. */ 75 if (!smp_load_acquire(&nsim_bus_dev->init)) 76 return -EBUSY; 77 78 ret = sscanf(buf, "%u %hhx:%hhx:%hhx:%hhx:%hhx:%hhx", &port_index, 79 ð_addr[0], ð_addr[1], ð_addr[2], ð_addr[3], 80 ð_addr[4], ð_addr[5]); 81 switch (ret) { 82 case 7: 83 if (!is_valid_ether_addr(eth_addr)) { 84 pr_err("The supplied perm_addr is not a valid MAC address\n"); 85 return -EINVAL; 86 } 87 addr_set = true; 88 fallthrough; 89 case 1: 90 break; 91 default: 92 pr_err("Format for adding new port is \"id [perm_addr]\" (uint MAC).\n"); 93 return -EINVAL; 94 } 95 96 ret = nsim_drv_port_add(nsim_bus_dev, NSIM_DEV_PORT_TYPE_PF, port_index, 97 addr_set ? eth_addr : NULL); 98 return ret ? ret : count; 99 } 100 101 static struct device_attribute nsim_bus_dev_new_port_attr = __ATTR_WO(new_port); 102 103 static ssize_t 104 del_port_store(struct device *dev, struct device_attribute *attr, 105 const char *buf, size_t count) 106 { 107 struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev); 108 unsigned int port_index; 109 int ret; 110 111 /* Prevent to use nsim_bus_dev before initialization. */ 112 if (!smp_load_acquire(&nsim_bus_dev->init)) 113 return -EBUSY; 114 ret = kstrtouint(buf, 0, &port_index); 115 if (ret) 116 return ret; 117 118 ret = nsim_drv_port_del(nsim_bus_dev, NSIM_DEV_PORT_TYPE_PF, port_index); 119 return ret ? ret : count; 120 } 121 122 static struct device_attribute nsim_bus_dev_del_port_attr = __ATTR_WO(del_port); 123 124 static struct attribute *nsim_bus_dev_attrs[] = { 125 &nsim_bus_dev_numvfs_attr.attr, 126 &nsim_bus_dev_new_port_attr.attr, 127 &nsim_bus_dev_del_port_attr.attr, 128 NULL, 129 }; 130 131 static const struct attribute_group nsim_bus_dev_attr_group = { 132 .attrs = nsim_bus_dev_attrs, 133 }; 134 135 static const struct attribute_group *nsim_bus_dev_attr_groups[] = { 136 &nsim_bus_dev_attr_group, 137 NULL, 138 }; 139 140 static void nsim_bus_dev_release(struct device *dev) 141 { 142 struct nsim_bus_dev *nsim_bus_dev; 143 144 nsim_bus_dev = container_of(dev, struct nsim_bus_dev, dev); 145 kfree(nsim_bus_dev); 146 if (refcount_dec_and_test(&nsim_bus_devs)) 147 complete(&nsim_bus_devs_released); 148 } 149 150 static const struct device_type nsim_bus_dev_type = { 151 .groups = nsim_bus_dev_attr_groups, 152 .release = nsim_bus_dev_release, 153 }; 154 155 static struct nsim_bus_dev * 156 nsim_bus_dev_new(unsigned int id, unsigned int port_count, unsigned int num_queues); 157 158 static ssize_t 159 new_device_store(const struct bus_type *bus, const char *buf, size_t count) 160 { 161 unsigned int id, port_count, num_queues; 162 struct nsim_bus_dev *nsim_bus_dev; 163 int err; 164 165 err = sscanf(buf, "%u %u %u", &id, &port_count, &num_queues); 166 switch (err) { 167 case 1: 168 port_count = 1; 169 fallthrough; 170 case 2: 171 num_queues = 1; 172 fallthrough; 173 case 3: 174 if (id > INT_MAX) { 175 pr_err("Value of \"id\" is too big.\n"); 176 return -EINVAL; 177 } 178 break; 179 default: 180 pr_err("Format for adding new device is \"id port_count num_queues\" (uint uint uint).\n"); 181 return -EINVAL; 182 } 183 184 mutex_lock(&nsim_bus_dev_list_lock); 185 /* Prevent to use resource before initialization. */ 186 if (!smp_load_acquire(&nsim_bus_enable)) { 187 err = -EBUSY; 188 goto err; 189 } 190 191 nsim_bus_dev = nsim_bus_dev_new(id, port_count, num_queues); 192 if (IS_ERR(nsim_bus_dev)) { 193 err = PTR_ERR(nsim_bus_dev); 194 goto err; 195 } 196 197 /* Allow using nsim_bus_dev */ 198 smp_store_release(&nsim_bus_dev->init, true); 199 200 list_add_tail(&nsim_bus_dev->list, &nsim_bus_dev_list); 201 mutex_unlock(&nsim_bus_dev_list_lock); 202 203 return count; 204 err: 205 mutex_unlock(&nsim_bus_dev_list_lock); 206 return err; 207 } 208 static BUS_ATTR_WO(new_device); 209 210 static void nsim_bus_dev_del(struct nsim_bus_dev *nsim_bus_dev); 211 212 static ssize_t 213 del_device_store(const struct bus_type *bus, const char *buf, size_t count) 214 { 215 struct nsim_bus_dev *nsim_bus_dev, *tmp; 216 unsigned int id; 217 int err; 218 219 err = sscanf(buf, "%u", &id); 220 switch (err) { 221 case 1: 222 if (id > INT_MAX) { 223 pr_err("Value of \"id\" is too big.\n"); 224 return -EINVAL; 225 } 226 break; 227 default: 228 pr_err("Format for deleting device is \"id\" (uint).\n"); 229 return -EINVAL; 230 } 231 232 err = -ENOENT; 233 mutex_lock(&nsim_bus_dev_list_lock); 234 /* Prevent to use resource before initialization. */ 235 if (!smp_load_acquire(&nsim_bus_enable)) { 236 mutex_unlock(&nsim_bus_dev_list_lock); 237 return -EBUSY; 238 } 239 list_for_each_entry_safe(nsim_bus_dev, tmp, &nsim_bus_dev_list, list) { 240 if (nsim_bus_dev->dev.id != id) 241 continue; 242 list_del(&nsim_bus_dev->list); 243 nsim_bus_dev_del(nsim_bus_dev); 244 err = 0; 245 break; 246 } 247 mutex_unlock(&nsim_bus_dev_list_lock); 248 return !err ? count : err; 249 } 250 static BUS_ATTR_WO(del_device); 251 252 static ssize_t link_device_store(const struct bus_type *bus, const char *buf, size_t count) 253 { 254 struct netdevsim *nsim_a, *nsim_b, *peer; 255 struct net_device *dev_a, *dev_b; 256 unsigned int ifidx_a, ifidx_b; 257 int netnsfd_a, netnsfd_b, err; 258 struct net *ns_a, *ns_b; 259 260 err = sscanf(buf, "%d:%u %d:%u", &netnsfd_a, &ifidx_a, &netnsfd_b, 261 &ifidx_b); 262 if (err != 4) { 263 pr_err("Format for linking two devices is \"netnsfd_a:ifidx_a netnsfd_b:ifidx_b\" (int uint int uint).\n"); 264 return -EINVAL; 265 } 266 267 ns_a = get_net_ns_by_fd(netnsfd_a); 268 if (IS_ERR(ns_a)) { 269 pr_err("Could not find netns with fd: %d\n", netnsfd_a); 270 return -EINVAL; 271 } 272 273 ns_b = get_net_ns_by_fd(netnsfd_b); 274 if (IS_ERR(ns_b)) { 275 pr_err("Could not find netns with fd: %d\n", netnsfd_b); 276 put_net(ns_a); 277 return -EINVAL; 278 } 279 280 err = -EINVAL; 281 rtnl_lock(); 282 dev_a = __dev_get_by_index(ns_a, ifidx_a); 283 if (!dev_a) { 284 pr_err("Could not find device with ifindex %u in netnsfd %d\n", 285 ifidx_a, netnsfd_a); 286 goto out_err; 287 } 288 289 if (!netdev_is_nsim(dev_a)) { 290 pr_err("Device with ifindex %u in netnsfd %d is not a netdevsim\n", 291 ifidx_a, netnsfd_a); 292 goto out_err; 293 } 294 295 dev_b = __dev_get_by_index(ns_b, ifidx_b); 296 if (!dev_b) { 297 pr_err("Could not find device with ifindex %u in netnsfd %d\n", 298 ifidx_b, netnsfd_b); 299 goto out_err; 300 } 301 302 if (!netdev_is_nsim(dev_b)) { 303 pr_err("Device with ifindex %u in netnsfd %d is not a netdevsim\n", 304 ifidx_b, netnsfd_b); 305 goto out_err; 306 } 307 308 if (dev_a == dev_b) { 309 pr_err("Cannot link a netdevsim to itself\n"); 310 goto out_err; 311 } 312 313 err = -EBUSY; 314 nsim_a = netdev_priv(dev_a); 315 peer = rtnl_dereference(nsim_a->peer); 316 if (peer) { 317 pr_err("Netdevsim %d:%u is already linked\n", netnsfd_a, 318 ifidx_a); 319 goto out_err; 320 } 321 322 nsim_b = netdev_priv(dev_b); 323 peer = rtnl_dereference(nsim_b->peer); 324 if (peer) { 325 pr_err("Netdevsim %d:%u is already linked\n", netnsfd_b, 326 ifidx_b); 327 goto out_err; 328 } 329 330 err = 0; 331 rcu_assign_pointer(nsim_a->peer, nsim_b); 332 rcu_assign_pointer(nsim_b->peer, nsim_a); 333 334 if (netif_running(dev_a) && netif_running(dev_b)) { 335 netif_carrier_on(dev_a); 336 netif_carrier_on(dev_b); 337 } 338 339 out_err: 340 put_net(ns_b); 341 put_net(ns_a); 342 rtnl_unlock(); 343 344 return !err ? count : err; 345 } 346 static BUS_ATTR_WO(link_device); 347 348 static ssize_t unlink_device_store(const struct bus_type *bus, const char *buf, size_t count) 349 { 350 struct netdevsim *nsim, *peer; 351 struct net_device *dev; 352 unsigned int ifidx; 353 int netnsfd, err; 354 struct net *ns; 355 356 err = sscanf(buf, "%u:%u", &netnsfd, &ifidx); 357 if (err != 2) { 358 pr_err("Format for unlinking a device is \"netnsfd:ifidx\" (int uint).\n"); 359 return -EINVAL; 360 } 361 362 ns = get_net_ns_by_fd(netnsfd); 363 if (IS_ERR(ns)) { 364 pr_err("Could not find netns with fd: %d\n", netnsfd); 365 return -EINVAL; 366 } 367 368 err = -EINVAL; 369 rtnl_lock(); 370 dev = __dev_get_by_index(ns, ifidx); 371 if (!dev) { 372 pr_err("Could not find device with ifindex %u in netnsfd %d\n", 373 ifidx, netnsfd); 374 goto out_put_netns; 375 } 376 377 if (!netdev_is_nsim(dev)) { 378 pr_err("Device with ifindex %u in netnsfd %d is not a netdevsim\n", 379 ifidx, netnsfd); 380 goto out_put_netns; 381 } 382 383 nsim = netdev_priv(dev); 384 peer = rtnl_dereference(nsim->peer); 385 if (!peer) 386 goto out_put_netns; 387 388 netif_carrier_off(dev); 389 netif_carrier_off(peer->netdev); 390 391 err = 0; 392 RCU_INIT_POINTER(nsim->peer, NULL); 393 RCU_INIT_POINTER(peer->peer, NULL); 394 synchronize_net(); 395 netif_tx_wake_all_queues(dev); 396 netif_tx_wake_all_queues(peer->netdev); 397 398 out_put_netns: 399 put_net(ns); 400 rtnl_unlock(); 401 402 return !err ? count : err; 403 } 404 static BUS_ATTR_WO(unlink_device); 405 406 static struct attribute *nsim_bus_attrs[] = { 407 &bus_attr_new_device.attr, 408 &bus_attr_del_device.attr, 409 &bus_attr_link_device.attr, 410 &bus_attr_unlink_device.attr, 411 NULL 412 }; 413 ATTRIBUTE_GROUPS(nsim_bus); 414 415 static int nsim_bus_probe(struct device *dev) 416 { 417 struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev); 418 419 return nsim_drv_probe(nsim_bus_dev); 420 } 421 422 static void nsim_bus_remove(struct device *dev) 423 { 424 struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev); 425 426 nsim_drv_remove(nsim_bus_dev); 427 } 428 429 static int nsim_num_vf(struct device *dev) 430 { 431 struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev); 432 433 return nsim_bus_dev->num_vfs; 434 } 435 436 static const struct bus_type nsim_bus = { 437 .name = DRV_NAME, 438 .dev_name = DRV_NAME, 439 .bus_groups = nsim_bus_groups, 440 .probe = nsim_bus_probe, 441 .remove = nsim_bus_remove, 442 .num_vf = nsim_num_vf, 443 }; 444 445 static struct nsim_bus_dev * 446 nsim_bus_dev_new(unsigned int id, unsigned int port_count, unsigned int num_queues) 447 { 448 struct nsim_bus_dev *nsim_bus_dev; 449 int err; 450 451 nsim_bus_dev = kzalloc_obj(*nsim_bus_dev); 452 if (!nsim_bus_dev) 453 return ERR_PTR(-ENOMEM); 454 455 err = ida_alloc_range(&nsim_bus_dev_ids, id, id, GFP_KERNEL); 456 if (err < 0) 457 goto err_nsim_bus_dev_free; 458 nsim_bus_dev->dev.id = err; 459 nsim_bus_dev->dev.bus = &nsim_bus; 460 nsim_bus_dev->dev.type = &nsim_bus_dev_type; 461 nsim_bus_dev->port_count = port_count; 462 nsim_bus_dev->num_queues = num_queues; 463 nsim_bus_dev->initial_net = current->nsproxy->net_ns; 464 /* Disallow using nsim_bus_dev */ 465 smp_store_release(&nsim_bus_dev->init, false); 466 467 refcount_inc(&nsim_bus_devs); 468 err = device_register(&nsim_bus_dev->dev); 469 if (err) 470 goto err_nsim_bus_dev_id_free; 471 472 return nsim_bus_dev; 473 474 err_nsim_bus_dev_id_free: 475 ida_free(&nsim_bus_dev_ids, nsim_bus_dev->dev.id); 476 put_device(&nsim_bus_dev->dev); 477 nsim_bus_dev = NULL; 478 err_nsim_bus_dev_free: 479 kfree(nsim_bus_dev); 480 return ERR_PTR(err); 481 } 482 483 static void nsim_bus_dev_del(struct nsim_bus_dev *nsim_bus_dev) 484 { 485 /* Disallow using nsim_bus_dev */ 486 smp_store_release(&nsim_bus_dev->init, false); 487 ida_free(&nsim_bus_dev_ids, nsim_bus_dev->dev.id); 488 device_unregister(&nsim_bus_dev->dev); 489 } 490 491 static struct device_driver nsim_driver = { 492 .name = DRV_NAME, 493 .bus = &nsim_bus, 494 .owner = THIS_MODULE, 495 }; 496 497 int nsim_bus_init(void) 498 { 499 int err; 500 501 err = bus_register(&nsim_bus); 502 if (err) 503 return err; 504 err = driver_register(&nsim_driver); 505 if (err) 506 goto err_bus_unregister; 507 refcount_set(&nsim_bus_devs, 1); 508 /* Allow using resources */ 509 smp_store_release(&nsim_bus_enable, true); 510 return 0; 511 512 err_bus_unregister: 513 bus_unregister(&nsim_bus); 514 return err; 515 } 516 517 void nsim_bus_exit(void) 518 { 519 struct nsim_bus_dev *nsim_bus_dev, *tmp; 520 521 /* Disallow using resources */ 522 smp_store_release(&nsim_bus_enable, false); 523 524 mutex_lock(&nsim_bus_dev_list_lock); 525 list_for_each_entry_safe(nsim_bus_dev, tmp, &nsim_bus_dev_list, list) { 526 list_del(&nsim_bus_dev->list); 527 nsim_bus_dev_del(nsim_bus_dev); 528 } 529 mutex_unlock(&nsim_bus_dev_list_lock); 530 531 if (refcount_dec_and_test(&nsim_bus_devs)) 532 complete(&nsim_bus_devs_released); 533 534 wait_for_completion(&nsim_bus_devs_released); 535 536 driver_unregister(&nsim_driver); 537 bus_unregister(&nsim_bus); 538 } 539