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