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 388 out_put_netns: 389 put_net(ns); 390 rtnl_unlock(); 391 392 return !err ? count : err; 393 } 394 static BUS_ATTR_WO(unlink_device); 395 396 static struct attribute *nsim_bus_attrs[] = { 397 &bus_attr_new_device.attr, 398 &bus_attr_del_device.attr, 399 &bus_attr_link_device.attr, 400 &bus_attr_unlink_device.attr, 401 NULL 402 }; 403 ATTRIBUTE_GROUPS(nsim_bus); 404 405 static int nsim_bus_probe(struct device *dev) 406 { 407 struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev); 408 409 return nsim_drv_probe(nsim_bus_dev); 410 } 411 412 static void nsim_bus_remove(struct device *dev) 413 { 414 struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev); 415 416 nsim_drv_remove(nsim_bus_dev); 417 } 418 419 static int nsim_num_vf(struct device *dev) 420 { 421 struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev); 422 423 return nsim_bus_dev->num_vfs; 424 } 425 426 static const struct bus_type nsim_bus = { 427 .name = DRV_NAME, 428 .dev_name = DRV_NAME, 429 .bus_groups = nsim_bus_groups, 430 .probe = nsim_bus_probe, 431 .remove = nsim_bus_remove, 432 .num_vf = nsim_num_vf, 433 }; 434 435 #define NSIM_BUS_DEV_MAX_VFS 4 436 437 static struct nsim_bus_dev * 438 nsim_bus_dev_new(unsigned int id, unsigned int port_count, unsigned int num_queues) 439 { 440 struct nsim_bus_dev *nsim_bus_dev; 441 int err; 442 443 nsim_bus_dev = kzalloc(sizeof(*nsim_bus_dev), GFP_KERNEL); 444 if (!nsim_bus_dev) 445 return ERR_PTR(-ENOMEM); 446 447 err = ida_alloc_range(&nsim_bus_dev_ids, id, id, GFP_KERNEL); 448 if (err < 0) 449 goto err_nsim_bus_dev_free; 450 nsim_bus_dev->dev.id = err; 451 nsim_bus_dev->dev.bus = &nsim_bus; 452 nsim_bus_dev->dev.type = &nsim_bus_dev_type; 453 nsim_bus_dev->port_count = port_count; 454 nsim_bus_dev->num_queues = num_queues; 455 nsim_bus_dev->initial_net = current->nsproxy->net_ns; 456 nsim_bus_dev->max_vfs = NSIM_BUS_DEV_MAX_VFS; 457 /* Disallow using nsim_bus_dev */ 458 smp_store_release(&nsim_bus_dev->init, false); 459 460 err = device_register(&nsim_bus_dev->dev); 461 if (err) 462 goto err_nsim_bus_dev_id_free; 463 464 return nsim_bus_dev; 465 466 err_nsim_bus_dev_id_free: 467 ida_free(&nsim_bus_dev_ids, nsim_bus_dev->dev.id); 468 put_device(&nsim_bus_dev->dev); 469 nsim_bus_dev = NULL; 470 err_nsim_bus_dev_free: 471 kfree(nsim_bus_dev); 472 return ERR_PTR(err); 473 } 474 475 static void nsim_bus_dev_del(struct nsim_bus_dev *nsim_bus_dev) 476 { 477 /* Disallow using nsim_bus_dev */ 478 smp_store_release(&nsim_bus_dev->init, false); 479 ida_free(&nsim_bus_dev_ids, nsim_bus_dev->dev.id); 480 device_unregister(&nsim_bus_dev->dev); 481 } 482 483 static struct device_driver nsim_driver = { 484 .name = DRV_NAME, 485 .bus = &nsim_bus, 486 .owner = THIS_MODULE, 487 }; 488 489 int nsim_bus_init(void) 490 { 491 int err; 492 493 err = bus_register(&nsim_bus); 494 if (err) 495 return err; 496 err = driver_register(&nsim_driver); 497 if (err) 498 goto err_bus_unregister; 499 refcount_set(&nsim_bus_devs, 1); 500 /* Allow using resources */ 501 smp_store_release(&nsim_bus_enable, true); 502 return 0; 503 504 err_bus_unregister: 505 bus_unregister(&nsim_bus); 506 return err; 507 } 508 509 void nsim_bus_exit(void) 510 { 511 struct nsim_bus_dev *nsim_bus_dev, *tmp; 512 513 /* Disallow using resources */ 514 smp_store_release(&nsim_bus_enable, false); 515 if (refcount_dec_and_test(&nsim_bus_devs)) 516 complete(&nsim_bus_devs_released); 517 518 mutex_lock(&nsim_bus_dev_list_lock); 519 list_for_each_entry_safe(nsim_bus_dev, tmp, &nsim_bus_dev_list, list) { 520 list_del(&nsim_bus_dev->list); 521 nsim_bus_dev_del(nsim_bus_dev); 522 } 523 mutex_unlock(&nsim_bus_dev_list_lock); 524 525 wait_for_completion(&nsim_bus_devs_released); 526 527 driver_unregister(&nsim_driver); 528 bus_unregister(&nsim_bus); 529 } 530