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 unit).\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 refcount_inc(&nsim_bus_devs); 198 /* Allow using nsim_bus_dev */ 199 smp_store_release(&nsim_bus_dev->init, true); 200 201 list_add_tail(&nsim_bus_dev->list, &nsim_bus_dev_list); 202 mutex_unlock(&nsim_bus_dev_list_lock); 203 204 return count; 205 err: 206 mutex_unlock(&nsim_bus_dev_list_lock); 207 return err; 208 } 209 static BUS_ATTR_WO(new_device); 210 211 static void nsim_bus_dev_del(struct nsim_bus_dev *nsim_bus_dev); 212 213 static ssize_t 214 del_device_store(const struct bus_type *bus, const char *buf, size_t count) 215 { 216 struct nsim_bus_dev *nsim_bus_dev, *tmp; 217 unsigned int id; 218 int err; 219 220 err = sscanf(buf, "%u", &id); 221 switch (err) { 222 case 1: 223 if (id > INT_MAX) { 224 pr_err("Value of \"id\" is too big.\n"); 225 return -EINVAL; 226 } 227 break; 228 default: 229 pr_err("Format for deleting device is \"id\" (uint).\n"); 230 return -EINVAL; 231 } 232 233 err = -ENOENT; 234 mutex_lock(&nsim_bus_dev_list_lock); 235 /* Prevent to use resource before initialization. */ 236 if (!smp_load_acquire(&nsim_bus_enable)) { 237 mutex_unlock(&nsim_bus_dev_list_lock); 238 return -EBUSY; 239 } 240 list_for_each_entry_safe(nsim_bus_dev, tmp, &nsim_bus_dev_list, list) { 241 if (nsim_bus_dev->dev.id != id) 242 continue; 243 list_del(&nsim_bus_dev->list); 244 nsim_bus_dev_del(nsim_bus_dev); 245 err = 0; 246 break; 247 } 248 mutex_unlock(&nsim_bus_dev_list_lock); 249 return !err ? count : err; 250 } 251 static BUS_ATTR_WO(del_device); 252 253 static ssize_t link_device_store(const struct bus_type *bus, const char *buf, size_t count) 254 { 255 struct netdevsim *nsim_a, *nsim_b, *peer; 256 struct net_device *dev_a, *dev_b; 257 unsigned int ifidx_a, ifidx_b; 258 int netnsfd_a, netnsfd_b, err; 259 struct net *ns_a, *ns_b; 260 261 err = sscanf(buf, "%d:%u %d:%u", &netnsfd_a, &ifidx_a, &netnsfd_b, 262 &ifidx_b); 263 if (err != 4) { 264 pr_err("Format for linking two devices is \"netnsfd_a:ifidx_a netnsfd_b:ifidx_b\" (int uint int uint).\n"); 265 return -EINVAL; 266 } 267 268 ns_a = get_net_ns_by_fd(netnsfd_a); 269 if (IS_ERR(ns_a)) { 270 pr_err("Could not find netns with fd: %d\n", netnsfd_a); 271 return -EINVAL; 272 } 273 274 ns_b = get_net_ns_by_fd(netnsfd_b); 275 if (IS_ERR(ns_b)) { 276 pr_err("Could not find netns with fd: %d\n", netnsfd_b); 277 put_net(ns_a); 278 return -EINVAL; 279 } 280 281 err = -EINVAL; 282 rtnl_lock(); 283 dev_a = __dev_get_by_index(ns_a, ifidx_a); 284 if (!dev_a) { 285 pr_err("Could not find device with ifindex %u in netnsfd %d\n", 286 ifidx_a, netnsfd_a); 287 goto out_err; 288 } 289 290 if (!netdev_is_nsim(dev_a)) { 291 pr_err("Device with ifindex %u in netnsfd %d is not a netdevsim\n", 292 ifidx_a, netnsfd_a); 293 goto out_err; 294 } 295 296 dev_b = __dev_get_by_index(ns_b, ifidx_b); 297 if (!dev_b) { 298 pr_err("Could not find device with ifindex %u in netnsfd %d\n", 299 ifidx_b, netnsfd_b); 300 goto out_err; 301 } 302 303 if (!netdev_is_nsim(dev_b)) { 304 pr_err("Device with ifindex %u in netnsfd %d is not a netdevsim\n", 305 ifidx_b, netnsfd_b); 306 goto out_err; 307 } 308 309 if (dev_a == dev_b) { 310 pr_err("Cannot link a netdevsim to itself\n"); 311 goto out_err; 312 } 313 314 err = -EBUSY; 315 nsim_a = netdev_priv(dev_a); 316 peer = rtnl_dereference(nsim_a->peer); 317 if (peer) { 318 pr_err("Netdevsim %d:%u is already linked\n", netnsfd_a, 319 ifidx_a); 320 goto out_err; 321 } 322 323 nsim_b = netdev_priv(dev_b); 324 peer = rtnl_dereference(nsim_b->peer); 325 if (peer) { 326 pr_err("Netdevsim %d:%u is already linked\n", netnsfd_b, 327 ifidx_b); 328 goto out_err; 329 } 330 331 err = 0; 332 rcu_assign_pointer(nsim_a->peer, nsim_b); 333 rcu_assign_pointer(nsim_b->peer, nsim_a); 334 335 out_err: 336 put_net(ns_b); 337 put_net(ns_a); 338 rtnl_unlock(); 339 340 return !err ? count : err; 341 } 342 static BUS_ATTR_WO(link_device); 343 344 static ssize_t unlink_device_store(const struct bus_type *bus, const char *buf, size_t count) 345 { 346 struct netdevsim *nsim, *peer; 347 struct net_device *dev; 348 unsigned int ifidx; 349 int netnsfd, err; 350 struct net *ns; 351 352 err = sscanf(buf, "%u:%u", &netnsfd, &ifidx); 353 if (err != 2) { 354 pr_err("Format for unlinking a device is \"netnsfd:ifidx\" (int uint).\n"); 355 return -EINVAL; 356 } 357 358 ns = get_net_ns_by_fd(netnsfd); 359 if (IS_ERR(ns)) { 360 pr_err("Could not find netns with fd: %d\n", netnsfd); 361 return -EINVAL; 362 } 363 364 err = -EINVAL; 365 rtnl_lock(); 366 dev = __dev_get_by_index(ns, ifidx); 367 if (!dev) { 368 pr_err("Could not find device with ifindex %u in netnsfd %d\n", 369 ifidx, netnsfd); 370 goto out_put_netns; 371 } 372 373 if (!netdev_is_nsim(dev)) { 374 pr_err("Device with ifindex %u in netnsfd %d is not a netdevsim\n", 375 ifidx, netnsfd); 376 goto out_put_netns; 377 } 378 379 nsim = netdev_priv(dev); 380 peer = rtnl_dereference(nsim->peer); 381 if (!peer) 382 goto out_put_netns; 383 384 err = 0; 385 RCU_INIT_POINTER(nsim->peer, NULL); 386 RCU_INIT_POINTER(peer->peer, NULL); 387 synchronize_net(); 388 netif_tx_wake_all_queues(dev); 389 netif_tx_wake_all_queues(peer->netdev); 390 391 out_put_netns: 392 put_net(ns); 393 rtnl_unlock(); 394 395 return !err ? count : err; 396 } 397 static BUS_ATTR_WO(unlink_device); 398 399 static struct attribute *nsim_bus_attrs[] = { 400 &bus_attr_new_device.attr, 401 &bus_attr_del_device.attr, 402 &bus_attr_link_device.attr, 403 &bus_attr_unlink_device.attr, 404 NULL 405 }; 406 ATTRIBUTE_GROUPS(nsim_bus); 407 408 static int nsim_bus_probe(struct device *dev) 409 { 410 struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev); 411 412 return nsim_drv_probe(nsim_bus_dev); 413 } 414 415 static void nsim_bus_remove(struct device *dev) 416 { 417 struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev); 418 419 nsim_drv_remove(nsim_bus_dev); 420 } 421 422 static int nsim_num_vf(struct device *dev) 423 { 424 struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev); 425 426 return nsim_bus_dev->num_vfs; 427 } 428 429 static const struct bus_type nsim_bus = { 430 .name = DRV_NAME, 431 .dev_name = DRV_NAME, 432 .bus_groups = nsim_bus_groups, 433 .probe = nsim_bus_probe, 434 .remove = nsim_bus_remove, 435 .num_vf = nsim_num_vf, 436 }; 437 438 #define NSIM_BUS_DEV_MAX_VFS 4 439 440 static struct nsim_bus_dev * 441 nsim_bus_dev_new(unsigned int id, unsigned int port_count, unsigned int num_queues) 442 { 443 struct nsim_bus_dev *nsim_bus_dev; 444 int err; 445 446 nsim_bus_dev = kzalloc(sizeof(*nsim_bus_dev), GFP_KERNEL); 447 if (!nsim_bus_dev) 448 return ERR_PTR(-ENOMEM); 449 450 err = ida_alloc_range(&nsim_bus_dev_ids, id, id, GFP_KERNEL); 451 if (err < 0) 452 goto err_nsim_bus_dev_free; 453 nsim_bus_dev->dev.id = err; 454 nsim_bus_dev->dev.bus = &nsim_bus; 455 nsim_bus_dev->dev.type = &nsim_bus_dev_type; 456 nsim_bus_dev->port_count = port_count; 457 nsim_bus_dev->num_queues = num_queues; 458 nsim_bus_dev->initial_net = current->nsproxy->net_ns; 459 nsim_bus_dev->max_vfs = NSIM_BUS_DEV_MAX_VFS; 460 /* Disallow using nsim_bus_dev */ 461 smp_store_release(&nsim_bus_dev->init, false); 462 463 err = device_register(&nsim_bus_dev->dev); 464 if (err) 465 goto err_nsim_bus_dev_id_free; 466 467 return nsim_bus_dev; 468 469 err_nsim_bus_dev_id_free: 470 ida_free(&nsim_bus_dev_ids, nsim_bus_dev->dev.id); 471 put_device(&nsim_bus_dev->dev); 472 nsim_bus_dev = NULL; 473 err_nsim_bus_dev_free: 474 kfree(nsim_bus_dev); 475 return ERR_PTR(err); 476 } 477 478 static void nsim_bus_dev_del(struct nsim_bus_dev *nsim_bus_dev) 479 { 480 /* Disallow using nsim_bus_dev */ 481 smp_store_release(&nsim_bus_dev->init, false); 482 ida_free(&nsim_bus_dev_ids, nsim_bus_dev->dev.id); 483 device_unregister(&nsim_bus_dev->dev); 484 } 485 486 static struct device_driver nsim_driver = { 487 .name = DRV_NAME, 488 .bus = &nsim_bus, 489 .owner = THIS_MODULE, 490 }; 491 492 int nsim_bus_init(void) 493 { 494 int err; 495 496 err = bus_register(&nsim_bus); 497 if (err) 498 return err; 499 err = driver_register(&nsim_driver); 500 if (err) 501 goto err_bus_unregister; 502 refcount_set(&nsim_bus_devs, 1); 503 /* Allow using resources */ 504 smp_store_release(&nsim_bus_enable, true); 505 return 0; 506 507 err_bus_unregister: 508 bus_unregister(&nsim_bus); 509 return err; 510 } 511 512 void nsim_bus_exit(void) 513 { 514 struct nsim_bus_dev *nsim_bus_dev, *tmp; 515 516 /* Disallow using resources */ 517 smp_store_release(&nsim_bus_enable, false); 518 if (refcount_dec_and_test(&nsim_bus_devs)) 519 complete(&nsim_bus_devs_released); 520 521 mutex_lock(&nsim_bus_dev_list_lock); 522 list_for_each_entry_safe(nsim_bus_dev, tmp, &nsim_bus_dev_list, list) { 523 list_del(&nsim_bus_dev->list); 524 nsim_bus_dev_del(nsim_bus_dev); 525 } 526 mutex_unlock(&nsim_bus_dev_list_lock); 527 528 wait_for_completion(&nsim_bus_devs_released); 529 530 driver_unregister(&nsim_driver); 531 bus_unregister(&nsim_bus); 532 } 533