1 /* 2 * Copyright (c) 2018 Cumulus Networks. All rights reserved. 3 * Copyright (c) 2018 David Ahern <dsa@cumulusnetworks.com> 4 * Copyright (c) 2019 Mellanox Technologies. All rights reserved. 5 * 6 * This software is licensed under the GNU General License Version 2, 7 * June 1991 as shown in the file COPYING in the top-level directory of this 8 * source tree. 9 * 10 * THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" 11 * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, 12 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 13 * FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE 14 * OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME 15 * THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16 */ 17 18 #include <linux/debugfs.h> 19 #include <linux/device.h> 20 #include <linux/etherdevice.h> 21 #include <linux/inet.h> 22 #include <linux/jiffies.h> 23 #include <linux/kernel.h> 24 #include <linux/list.h> 25 #include <linux/mutex.h> 26 #include <linux/random.h> 27 #include <linux/rtnetlink.h> 28 #include <linux/workqueue.h> 29 #include <net/devlink.h> 30 #include <net/ip.h> 31 #include <net/flow_offload.h> 32 #include <uapi/linux/devlink.h> 33 #include <uapi/linux/ip.h> 34 #include <uapi/linux/udp.h> 35 36 #include "netdevsim.h" 37 38 static unsigned int 39 nsim_dev_port_index(enum nsim_dev_port_type type, unsigned int port_index) 40 { 41 switch (type) { 42 case NSIM_DEV_PORT_TYPE_VF: 43 port_index = NSIM_DEV_VF_PORT_INDEX_BASE + port_index; 44 break; 45 case NSIM_DEV_PORT_TYPE_PF: 46 break; 47 } 48 49 return port_index; 50 } 51 52 static inline unsigned int nsim_dev_port_index_to_vf_index(unsigned int port_index) 53 { 54 return port_index - NSIM_DEV_VF_PORT_INDEX_BASE; 55 } 56 57 static struct dentry *nsim_dev_ddir; 58 59 unsigned int nsim_dev_get_vfs(struct nsim_dev *nsim_dev) 60 { 61 WARN_ON(!lockdep_rtnl_is_held() && 62 !devl_lock_is_held(priv_to_devlink(nsim_dev))); 63 64 return nsim_dev->nsim_bus_dev->num_vfs; 65 } 66 67 static void 68 nsim_bus_dev_set_vfs(struct nsim_bus_dev *nsim_bus_dev, unsigned int num_vfs) 69 { 70 rtnl_lock(); 71 nsim_bus_dev->num_vfs = num_vfs; 72 rtnl_unlock(); 73 } 74 75 #define NSIM_DEV_DUMMY_REGION_SIZE (1024 * 32) 76 77 static int 78 nsim_dev_take_snapshot(struct devlink *devlink, 79 const struct devlink_region_ops *ops, 80 struct netlink_ext_ack *extack, 81 u8 **data) 82 { 83 void *dummy_data; 84 85 dummy_data = kmalloc(NSIM_DEV_DUMMY_REGION_SIZE, GFP_KERNEL); 86 if (!dummy_data) 87 return -ENOMEM; 88 89 get_random_bytes(dummy_data, NSIM_DEV_DUMMY_REGION_SIZE); 90 91 *data = dummy_data; 92 93 return 0; 94 } 95 96 static ssize_t nsim_dev_take_snapshot_write(struct file *file, 97 const char __user *data, 98 size_t count, loff_t *ppos) 99 { 100 struct nsim_dev *nsim_dev = file->private_data; 101 struct devlink *devlink; 102 u8 *dummy_data; 103 int err; 104 u32 id; 105 106 devlink = priv_to_devlink(nsim_dev); 107 108 err = nsim_dev_take_snapshot(devlink, NULL, NULL, &dummy_data); 109 if (err) 110 return err; 111 112 err = devlink_region_snapshot_id_get(devlink, &id); 113 if (err) { 114 pr_err("Failed to get snapshot id\n"); 115 kfree(dummy_data); 116 return err; 117 } 118 err = devlink_region_snapshot_create(nsim_dev->dummy_region, 119 dummy_data, id); 120 devlink_region_snapshot_id_put(devlink, id); 121 if (err) { 122 pr_err("Failed to create region snapshot\n"); 123 kfree(dummy_data); 124 return err; 125 } 126 127 return count; 128 } 129 130 static const struct file_operations nsim_dev_take_snapshot_fops = { 131 .open = simple_open, 132 .write = nsim_dev_take_snapshot_write, 133 .llseek = generic_file_llseek, 134 .owner = THIS_MODULE, 135 }; 136 137 static ssize_t nsim_dev_trap_fa_cookie_read(struct file *file, 138 char __user *data, 139 size_t count, loff_t *ppos) 140 { 141 struct nsim_dev *nsim_dev = file->private_data; 142 struct flow_action_cookie *fa_cookie; 143 unsigned int buf_len; 144 ssize_t ret; 145 char *buf; 146 147 spin_lock(&nsim_dev->fa_cookie_lock); 148 fa_cookie = nsim_dev->fa_cookie; 149 if (!fa_cookie) { 150 ret = -EINVAL; 151 goto errout; 152 } 153 buf_len = fa_cookie->cookie_len * 2; 154 buf = kmalloc(buf_len, GFP_ATOMIC); 155 if (!buf) { 156 ret = -ENOMEM; 157 goto errout; 158 } 159 bin2hex(buf, fa_cookie->cookie, fa_cookie->cookie_len); 160 spin_unlock(&nsim_dev->fa_cookie_lock); 161 162 ret = simple_read_from_buffer(data, count, ppos, buf, buf_len); 163 164 kfree(buf); 165 return ret; 166 167 errout: 168 spin_unlock(&nsim_dev->fa_cookie_lock); 169 return ret; 170 } 171 172 static ssize_t nsim_dev_trap_fa_cookie_write(struct file *file, 173 const char __user *data, 174 size_t count, loff_t *ppos) 175 { 176 struct nsim_dev *nsim_dev = file->private_data; 177 struct flow_action_cookie *fa_cookie; 178 size_t cookie_len; 179 ssize_t ret; 180 char *buf; 181 182 if (*ppos != 0) 183 return -EINVAL; 184 cookie_len = (count - 1) / 2; 185 if ((count - 1) % 2) 186 return -EINVAL; 187 188 buf = memdup_user(data, count); 189 if (IS_ERR(buf)) 190 return PTR_ERR(buf); 191 192 fa_cookie = kmalloc(sizeof(*fa_cookie) + cookie_len, 193 GFP_KERNEL | __GFP_NOWARN); 194 if (!fa_cookie) { 195 ret = -ENOMEM; 196 goto free_buf; 197 } 198 199 fa_cookie->cookie_len = cookie_len; 200 ret = hex2bin(fa_cookie->cookie, buf, cookie_len); 201 if (ret) 202 goto free_fa_cookie; 203 kfree(buf); 204 205 spin_lock(&nsim_dev->fa_cookie_lock); 206 kfree(nsim_dev->fa_cookie); 207 nsim_dev->fa_cookie = fa_cookie; 208 spin_unlock(&nsim_dev->fa_cookie_lock); 209 210 return count; 211 212 free_fa_cookie: 213 kfree(fa_cookie); 214 free_buf: 215 kfree(buf); 216 return ret; 217 } 218 219 static const struct file_operations nsim_dev_trap_fa_cookie_fops = { 220 .open = simple_open, 221 .read = nsim_dev_trap_fa_cookie_read, 222 .write = nsim_dev_trap_fa_cookie_write, 223 .llseek = generic_file_llseek, 224 .owner = THIS_MODULE, 225 }; 226 227 static ssize_t nsim_bus_dev_max_vfs_read(struct file *file, char __user *data, 228 size_t count, loff_t *ppos) 229 { 230 struct nsim_dev *nsim_dev = file->private_data; 231 char buf[11]; 232 ssize_t len; 233 234 len = scnprintf(buf, sizeof(buf), "%u\n", 235 READ_ONCE(nsim_dev->nsim_bus_dev->max_vfs)); 236 237 return simple_read_from_buffer(data, count, ppos, buf, len); 238 } 239 240 static ssize_t nsim_bus_dev_max_vfs_write(struct file *file, 241 const char __user *data, 242 size_t count, loff_t *ppos) 243 { 244 struct nsim_vf_config *vfconfigs; 245 struct nsim_dev *nsim_dev; 246 char buf[10]; 247 ssize_t ret; 248 u32 val; 249 250 if (*ppos != 0) 251 return 0; 252 253 if (count >= sizeof(buf)) 254 return -ENOSPC; 255 256 ret = copy_from_user(buf, data, count); 257 if (ret) 258 return -EFAULT; 259 buf[count] = '\0'; 260 261 ret = kstrtouint(buf, 10, &val); 262 if (ret) 263 return -EINVAL; 264 265 /* max_vfs limited by the maximum number of provided port indexes */ 266 if (val > NSIM_DEV_VF_PORT_INDEX_MAX - NSIM_DEV_VF_PORT_INDEX_BASE) 267 return -ERANGE; 268 269 vfconfigs = kcalloc(val, sizeof(struct nsim_vf_config), 270 GFP_KERNEL | __GFP_NOWARN); 271 if (!vfconfigs) 272 return -ENOMEM; 273 274 nsim_dev = file->private_data; 275 devl_lock(priv_to_devlink(nsim_dev)); 276 /* Reject if VFs are configured */ 277 if (nsim_dev_get_vfs(nsim_dev)) { 278 ret = -EBUSY; 279 } else { 280 swap(nsim_dev->vfconfigs, vfconfigs); 281 WRITE_ONCE(nsim_dev->nsim_bus_dev->max_vfs, val); 282 *ppos += count; 283 ret = count; 284 } 285 devl_unlock(priv_to_devlink(nsim_dev)); 286 287 kfree(vfconfigs); 288 return ret; 289 } 290 291 static const struct file_operations nsim_dev_max_vfs_fops = { 292 .open = simple_open, 293 .read = nsim_bus_dev_max_vfs_read, 294 .write = nsim_bus_dev_max_vfs_write, 295 .llseek = generic_file_llseek, 296 .owner = THIS_MODULE, 297 }; 298 299 static int nsim_dev_debugfs_init(struct nsim_dev *nsim_dev) 300 { 301 char dev_ddir_name[sizeof(DRV_NAME) + 10]; 302 int err; 303 304 sprintf(dev_ddir_name, DRV_NAME "%u", nsim_dev->nsim_bus_dev->dev.id); 305 nsim_dev->ddir = debugfs_create_dir(dev_ddir_name, nsim_dev_ddir); 306 if (IS_ERR(nsim_dev->ddir)) 307 return PTR_ERR(nsim_dev->ddir); 308 nsim_dev->ports_ddir = debugfs_create_dir("ports", nsim_dev->ddir); 309 if (IS_ERR(nsim_dev->ports_ddir)) { 310 err = PTR_ERR(nsim_dev->ports_ddir); 311 goto err_ddir; 312 } 313 debugfs_create_bool("fw_update_status", 0600, nsim_dev->ddir, 314 &nsim_dev->fw_update_status); 315 debugfs_create_u32("fw_update_overwrite_mask", 0600, nsim_dev->ddir, 316 &nsim_dev->fw_update_overwrite_mask); 317 debugfs_create_u32("fw_update_flash_chunk_time_ms", 0600, nsim_dev->ddir, 318 &nsim_dev->fw_update_flash_chunk_time_ms); 319 debugfs_create_u32("max_macs", 0600, nsim_dev->ddir, 320 &nsim_dev->max_macs); 321 debugfs_create_bool("test1", 0600, nsim_dev->ddir, 322 &nsim_dev->test1); 323 nsim_dev->take_snapshot = debugfs_create_file("take_snapshot", 324 0200, 325 nsim_dev->ddir, 326 nsim_dev, 327 &nsim_dev_take_snapshot_fops); 328 debugfs_create_bool("dont_allow_reload", 0600, nsim_dev->ddir, 329 &nsim_dev->dont_allow_reload); 330 debugfs_create_bool("fail_reload", 0600, nsim_dev->ddir, 331 &nsim_dev->fail_reload); 332 debugfs_create_file("trap_flow_action_cookie", 0600, nsim_dev->ddir, 333 nsim_dev, &nsim_dev_trap_fa_cookie_fops); 334 debugfs_create_bool("fail_trap_group_set", 0600, 335 nsim_dev->ddir, 336 &nsim_dev->fail_trap_group_set); 337 debugfs_create_bool("fail_trap_policer_set", 0600, 338 nsim_dev->ddir, 339 &nsim_dev->fail_trap_policer_set); 340 debugfs_create_bool("fail_trap_policer_counter_get", 0600, 341 nsim_dev->ddir, 342 &nsim_dev->fail_trap_policer_counter_get); 343 /* caution, dev_max_vfs write takes devlink lock */ 344 debugfs_create_file("max_vfs", 0600, nsim_dev->ddir, 345 nsim_dev, &nsim_dev_max_vfs_fops); 346 347 nsim_dev->nodes_ddir = debugfs_create_dir("rate_nodes", nsim_dev->ddir); 348 if (IS_ERR(nsim_dev->nodes_ddir)) { 349 err = PTR_ERR(nsim_dev->nodes_ddir); 350 goto err_ports_ddir; 351 } 352 debugfs_create_bool("fail_trap_drop_counter_get", 0600, 353 nsim_dev->ddir, 354 &nsim_dev->fail_trap_drop_counter_get); 355 nsim_udp_tunnels_debugfs_create(nsim_dev); 356 return 0; 357 358 err_ports_ddir: 359 debugfs_remove_recursive(nsim_dev->ports_ddir); 360 err_ddir: 361 debugfs_remove_recursive(nsim_dev->ddir); 362 return err; 363 } 364 365 static void nsim_dev_debugfs_exit(struct nsim_dev *nsim_dev) 366 { 367 debugfs_remove_recursive(nsim_dev->nodes_ddir); 368 debugfs_remove_recursive(nsim_dev->ports_ddir); 369 debugfs_remove_recursive(nsim_dev->ddir); 370 } 371 372 static ssize_t nsim_dev_rate_parent_read(struct file *file, 373 char __user *data, 374 size_t count, loff_t *ppos) 375 { 376 char **name_ptr = file->private_data; 377 size_t len; 378 379 if (!*name_ptr) 380 return 0; 381 382 len = strlen(*name_ptr); 383 return simple_read_from_buffer(data, count, ppos, *name_ptr, len); 384 } 385 386 static const struct file_operations nsim_dev_rate_parent_fops = { 387 .open = simple_open, 388 .read = nsim_dev_rate_parent_read, 389 .llseek = generic_file_llseek, 390 .owner = THIS_MODULE, 391 }; 392 393 static void nsim_dev_tc_bw_debugfs_init(struct dentry *ddir, u32 *tc_bw) 394 { 395 int i; 396 397 for (i = 0; i < DEVLINK_RATE_TCS_MAX; i++) { 398 char name[16]; 399 400 snprintf(name, sizeof(name), "tc%d_bw", i); 401 debugfs_create_u32(name, 0400, ddir, &tc_bw[i]); 402 } 403 } 404 static int nsim_dev_port_debugfs_init(struct nsim_dev *nsim_dev, 405 struct nsim_dev_port *nsim_dev_port) 406 { 407 struct nsim_bus_dev *nsim_bus_dev = nsim_dev->nsim_bus_dev; 408 unsigned int port_index = nsim_dev_port->port_index; 409 char port_ddir_name[16]; 410 char dev_link_name[32]; 411 412 sprintf(port_ddir_name, "%u", port_index); 413 nsim_dev_port->ddir = debugfs_create_dir(port_ddir_name, 414 nsim_dev->ports_ddir); 415 if (IS_ERR(nsim_dev_port->ddir)) 416 return PTR_ERR(nsim_dev_port->ddir); 417 418 sprintf(dev_link_name, "../../../" DRV_NAME "%u", nsim_bus_dev->dev.id); 419 if (nsim_dev_port_is_vf(nsim_dev_port)) { 420 unsigned int vf_id = nsim_dev_port_index_to_vf_index(port_index); 421 422 debugfs_create_u16("tx_share", 0400, nsim_dev_port->ddir, 423 &nsim_dev->vfconfigs[vf_id].min_tx_rate); 424 debugfs_create_u16("tx_max", 0400, nsim_dev_port->ddir, 425 &nsim_dev->vfconfigs[vf_id].max_tx_rate); 426 nsim_dev_port->rate_parent = debugfs_create_file("rate_parent", 427 0400, 428 nsim_dev_port->ddir, 429 &nsim_dev_port->parent_name, 430 &nsim_dev_rate_parent_fops); 431 nsim_dev_tc_bw_debugfs_init(nsim_dev_port->ddir, 432 nsim_dev_port->tc_bw); 433 } 434 debugfs_create_symlink("dev", nsim_dev_port->ddir, dev_link_name); 435 436 return 0; 437 } 438 439 static void nsim_dev_port_debugfs_exit(struct nsim_dev_port *nsim_dev_port) 440 { 441 debugfs_remove_recursive(nsim_dev_port->ddir); 442 } 443 444 static int nsim_dev_resources_register(struct devlink *devlink) 445 { 446 struct devlink_resource_size_params params = { 447 .size_max = (u64)-1, 448 .size_granularity = 1, 449 .unit = DEVLINK_RESOURCE_UNIT_ENTRY 450 }; 451 int err; 452 453 /* Resources for IPv4 */ 454 err = devl_resource_register(devlink, "IPv4", (u64)-1, 455 NSIM_RESOURCE_IPV4, 456 DEVLINK_RESOURCE_ID_PARENT_TOP, 457 ¶ms); 458 if (err) { 459 pr_err("Failed to register IPv4 top resource\n"); 460 goto err_out; 461 } 462 463 err = devl_resource_register(devlink, "fib", (u64)-1, 464 NSIM_RESOURCE_IPV4_FIB, 465 NSIM_RESOURCE_IPV4, ¶ms); 466 if (err) { 467 pr_err("Failed to register IPv4 FIB resource\n"); 468 goto err_out; 469 } 470 471 err = devl_resource_register(devlink, "fib-rules", (u64)-1, 472 NSIM_RESOURCE_IPV4_FIB_RULES, 473 NSIM_RESOURCE_IPV4, ¶ms); 474 if (err) { 475 pr_err("Failed to register IPv4 FIB rules resource\n"); 476 goto err_out; 477 } 478 479 /* Resources for IPv6 */ 480 err = devl_resource_register(devlink, "IPv6", (u64)-1, 481 NSIM_RESOURCE_IPV6, 482 DEVLINK_RESOURCE_ID_PARENT_TOP, 483 ¶ms); 484 if (err) { 485 pr_err("Failed to register IPv6 top resource\n"); 486 goto err_out; 487 } 488 489 err = devl_resource_register(devlink, "fib", (u64)-1, 490 NSIM_RESOURCE_IPV6_FIB, 491 NSIM_RESOURCE_IPV6, ¶ms); 492 if (err) { 493 pr_err("Failed to register IPv6 FIB resource\n"); 494 goto err_out; 495 } 496 497 err = devl_resource_register(devlink, "fib-rules", (u64)-1, 498 NSIM_RESOURCE_IPV6_FIB_RULES, 499 NSIM_RESOURCE_IPV6, ¶ms); 500 if (err) { 501 pr_err("Failed to register IPv6 FIB rules resource\n"); 502 goto err_out; 503 } 504 505 /* Resources for nexthops */ 506 err = devl_resource_register(devlink, "nexthops", (u64)-1, 507 NSIM_RESOURCE_NEXTHOPS, 508 DEVLINK_RESOURCE_ID_PARENT_TOP, 509 ¶ms); 510 if (err) { 511 pr_err("Failed to register NEXTHOPS resource\n"); 512 goto err_out; 513 } 514 return 0; 515 516 err_out: 517 devl_resources_unregister(devlink); 518 return err; 519 } 520 521 enum nsim_devlink_param_id { 522 NSIM_DEVLINK_PARAM_ID_BASE = DEVLINK_PARAM_GENERIC_ID_MAX, 523 NSIM_DEVLINK_PARAM_ID_TEST1, 524 }; 525 526 static const struct devlink_param nsim_devlink_params[] = { 527 DEVLINK_PARAM_GENERIC(MAX_MACS, 528 BIT(DEVLINK_PARAM_CMODE_DRIVERINIT), 529 NULL, NULL, NULL), 530 DEVLINK_PARAM_DRIVER(NSIM_DEVLINK_PARAM_ID_TEST1, 531 "test1", DEVLINK_PARAM_TYPE_BOOL, 532 BIT(DEVLINK_PARAM_CMODE_DRIVERINIT), 533 NULL, NULL, NULL), 534 }; 535 536 static void nsim_devlink_set_params_init_values(struct nsim_dev *nsim_dev, 537 struct devlink *devlink) 538 { 539 union devlink_param_value value; 540 541 value.vu32 = nsim_dev->max_macs; 542 devl_param_driverinit_value_set(devlink, 543 DEVLINK_PARAM_GENERIC_ID_MAX_MACS, 544 value); 545 value.vbool = nsim_dev->test1; 546 devl_param_driverinit_value_set(devlink, 547 NSIM_DEVLINK_PARAM_ID_TEST1, 548 value); 549 } 550 551 static void nsim_devlink_param_load_driverinit_values(struct devlink *devlink) 552 { 553 struct nsim_dev *nsim_dev = devlink_priv(devlink); 554 union devlink_param_value saved_value; 555 int err; 556 557 err = devl_param_driverinit_value_get(devlink, 558 DEVLINK_PARAM_GENERIC_ID_MAX_MACS, 559 &saved_value); 560 if (!err) 561 nsim_dev->max_macs = saved_value.vu32; 562 err = devl_param_driverinit_value_get(devlink, 563 NSIM_DEVLINK_PARAM_ID_TEST1, 564 &saved_value); 565 if (!err) 566 nsim_dev->test1 = saved_value.vbool; 567 } 568 569 #define NSIM_DEV_DUMMY_REGION_SNAPSHOT_MAX 16 570 571 static const struct devlink_region_ops dummy_region_ops = { 572 .name = "dummy", 573 .destructor = &kfree, 574 .snapshot = nsim_dev_take_snapshot, 575 }; 576 577 static int nsim_dev_dummy_region_init(struct nsim_dev *nsim_dev, 578 struct devlink *devlink) 579 { 580 nsim_dev->dummy_region = 581 devl_region_create(devlink, &dummy_region_ops, 582 NSIM_DEV_DUMMY_REGION_SNAPSHOT_MAX, 583 NSIM_DEV_DUMMY_REGION_SIZE); 584 return PTR_ERR_OR_ZERO(nsim_dev->dummy_region); 585 } 586 587 static void nsim_dev_dummy_region_exit(struct nsim_dev *nsim_dev) 588 { 589 devl_region_destroy(nsim_dev->dummy_region); 590 } 591 592 static int 593 __nsim_dev_port_add(struct nsim_dev *nsim_dev, enum nsim_dev_port_type type, 594 unsigned int port_index, u8 perm_addr[ETH_ALEN]); 595 static void __nsim_dev_port_del(struct nsim_dev_port *nsim_dev_port); 596 597 static int nsim_esw_legacy_enable(struct nsim_dev *nsim_dev, 598 struct netlink_ext_ack *extack) 599 { 600 struct devlink *devlink = priv_to_devlink(nsim_dev); 601 struct nsim_dev_port *nsim_dev_port, *tmp; 602 603 devl_rate_nodes_destroy(devlink); 604 list_for_each_entry_safe(nsim_dev_port, tmp, &nsim_dev->port_list, list) 605 if (nsim_dev_port_is_vf(nsim_dev_port)) 606 __nsim_dev_port_del(nsim_dev_port); 607 nsim_dev->esw_mode = DEVLINK_ESWITCH_MODE_LEGACY; 608 return 0; 609 } 610 611 static int nsim_esw_switchdev_enable(struct nsim_dev *nsim_dev, 612 struct netlink_ext_ack *extack) 613 { 614 struct nsim_dev_port *nsim_dev_port, *tmp; 615 int i, err; 616 617 for (i = 0; i < nsim_dev_get_vfs(nsim_dev); i++) { 618 err = __nsim_dev_port_add(nsim_dev, NSIM_DEV_PORT_TYPE_VF, i, NULL); 619 if (err) { 620 NL_SET_ERR_MSG_MOD(extack, "Failed to initialize VFs' netdevsim ports"); 621 pr_err("Failed to initialize VF id=%d. %d.\n", i, err); 622 goto err_port_add_vfs; 623 } 624 } 625 nsim_dev->esw_mode = DEVLINK_ESWITCH_MODE_SWITCHDEV; 626 return 0; 627 628 err_port_add_vfs: 629 list_for_each_entry_safe(nsim_dev_port, tmp, &nsim_dev->port_list, list) 630 if (nsim_dev_port_is_vf(nsim_dev_port)) 631 __nsim_dev_port_del(nsim_dev_port); 632 return err; 633 } 634 635 static int nsim_devlink_eswitch_mode_set(struct devlink *devlink, u16 mode, 636 struct netlink_ext_ack *extack) 637 { 638 struct nsim_dev *nsim_dev = devlink_priv(devlink); 639 640 if (mode == nsim_dev->esw_mode) 641 return 0; 642 643 if (mode == DEVLINK_ESWITCH_MODE_LEGACY) 644 return nsim_esw_legacy_enable(nsim_dev, extack); 645 if (mode == DEVLINK_ESWITCH_MODE_SWITCHDEV) 646 return nsim_esw_switchdev_enable(nsim_dev, extack); 647 648 return -EINVAL; 649 } 650 651 static int nsim_devlink_eswitch_mode_get(struct devlink *devlink, u16 *mode) 652 { 653 struct nsim_dev *nsim_dev = devlink_priv(devlink); 654 655 *mode = nsim_dev->esw_mode; 656 return 0; 657 } 658 659 struct nsim_trap_item { 660 void *trap_ctx; 661 enum devlink_trap_action action; 662 }; 663 664 struct nsim_trap_data { 665 struct delayed_work trap_report_dw; 666 struct nsim_trap_item *trap_items_arr; 667 u64 *trap_policers_cnt_arr; 668 u64 trap_pkt_cnt; 669 struct nsim_dev *nsim_dev; 670 spinlock_t trap_lock; /* Protects trap_items_arr */ 671 }; 672 673 /* All driver-specific traps must be documented in 674 * Documentation/networking/devlink/netdevsim.rst 675 */ 676 enum { 677 NSIM_TRAP_ID_BASE = DEVLINK_TRAP_GENERIC_ID_MAX, 678 NSIM_TRAP_ID_FID_MISS, 679 }; 680 681 #define NSIM_TRAP_NAME_FID_MISS "fid_miss" 682 683 #define NSIM_TRAP_METADATA DEVLINK_TRAP_METADATA_TYPE_F_IN_PORT 684 685 #define NSIM_TRAP_DROP(_id, _group_id) \ 686 DEVLINK_TRAP_GENERIC(DROP, DROP, _id, \ 687 DEVLINK_TRAP_GROUP_GENERIC_ID_##_group_id, \ 688 NSIM_TRAP_METADATA) 689 #define NSIM_TRAP_DROP_EXT(_id, _group_id, _metadata) \ 690 DEVLINK_TRAP_GENERIC(DROP, DROP, _id, \ 691 DEVLINK_TRAP_GROUP_GENERIC_ID_##_group_id, \ 692 NSIM_TRAP_METADATA | (_metadata)) 693 #define NSIM_TRAP_EXCEPTION(_id, _group_id) \ 694 DEVLINK_TRAP_GENERIC(EXCEPTION, TRAP, _id, \ 695 DEVLINK_TRAP_GROUP_GENERIC_ID_##_group_id, \ 696 NSIM_TRAP_METADATA) 697 #define NSIM_TRAP_CONTROL(_id, _group_id, _action) \ 698 DEVLINK_TRAP_GENERIC(CONTROL, _action, _id, \ 699 DEVLINK_TRAP_GROUP_GENERIC_ID_##_group_id, \ 700 NSIM_TRAP_METADATA) 701 #define NSIM_TRAP_DRIVER_EXCEPTION(_id, _group_id) \ 702 DEVLINK_TRAP_DRIVER(EXCEPTION, TRAP, NSIM_TRAP_ID_##_id, \ 703 NSIM_TRAP_NAME_##_id, \ 704 DEVLINK_TRAP_GROUP_GENERIC_ID_##_group_id, \ 705 NSIM_TRAP_METADATA) 706 707 #define NSIM_DEV_TRAP_POLICER_MIN_RATE 1 708 #define NSIM_DEV_TRAP_POLICER_MAX_RATE 8000 709 #define NSIM_DEV_TRAP_POLICER_MIN_BURST 8 710 #define NSIM_DEV_TRAP_POLICER_MAX_BURST 65536 711 712 #define NSIM_TRAP_POLICER(_id, _rate, _burst) \ 713 DEVLINK_TRAP_POLICER(_id, _rate, _burst, \ 714 NSIM_DEV_TRAP_POLICER_MAX_RATE, \ 715 NSIM_DEV_TRAP_POLICER_MIN_RATE, \ 716 NSIM_DEV_TRAP_POLICER_MAX_BURST, \ 717 NSIM_DEV_TRAP_POLICER_MIN_BURST) 718 719 static const struct devlink_trap_policer nsim_trap_policers_arr[] = { 720 NSIM_TRAP_POLICER(1, 1000, 128), 721 NSIM_TRAP_POLICER(2, 2000, 256), 722 NSIM_TRAP_POLICER(3, 3000, 512), 723 }; 724 725 static const struct devlink_trap_group nsim_trap_groups_arr[] = { 726 DEVLINK_TRAP_GROUP_GENERIC(L2_DROPS, 0), 727 DEVLINK_TRAP_GROUP_GENERIC(L3_DROPS, 1), 728 DEVLINK_TRAP_GROUP_GENERIC(L3_EXCEPTIONS, 1), 729 DEVLINK_TRAP_GROUP_GENERIC(BUFFER_DROPS, 2), 730 DEVLINK_TRAP_GROUP_GENERIC(ACL_DROPS, 3), 731 DEVLINK_TRAP_GROUP_GENERIC(MC_SNOOPING, 3), 732 }; 733 734 static const struct devlink_trap nsim_traps_arr[] = { 735 NSIM_TRAP_DROP(SMAC_MC, L2_DROPS), 736 NSIM_TRAP_DROP(VLAN_TAG_MISMATCH, L2_DROPS), 737 NSIM_TRAP_DROP(INGRESS_VLAN_FILTER, L2_DROPS), 738 NSIM_TRAP_DROP(INGRESS_STP_FILTER, L2_DROPS), 739 NSIM_TRAP_DROP(EMPTY_TX_LIST, L2_DROPS), 740 NSIM_TRAP_DROP(PORT_LOOPBACK_FILTER, L2_DROPS), 741 NSIM_TRAP_DRIVER_EXCEPTION(FID_MISS, L2_DROPS), 742 NSIM_TRAP_DROP(BLACKHOLE_ROUTE, L3_DROPS), 743 NSIM_TRAP_EXCEPTION(TTL_ERROR, L3_EXCEPTIONS), 744 NSIM_TRAP_DROP(TAIL_DROP, BUFFER_DROPS), 745 NSIM_TRAP_DROP_EXT(INGRESS_FLOW_ACTION_DROP, ACL_DROPS, 746 DEVLINK_TRAP_METADATA_TYPE_F_FA_COOKIE), 747 NSIM_TRAP_DROP_EXT(EGRESS_FLOW_ACTION_DROP, ACL_DROPS, 748 DEVLINK_TRAP_METADATA_TYPE_F_FA_COOKIE), 749 NSIM_TRAP_CONTROL(IGMP_QUERY, MC_SNOOPING, MIRROR), 750 NSIM_TRAP_CONTROL(IGMP_V1_REPORT, MC_SNOOPING, TRAP), 751 }; 752 753 #define NSIM_TRAP_L4_DATA_LEN 100 754 755 static struct sk_buff *nsim_dev_trap_skb_build(void) 756 { 757 int tot_len, data_len = NSIM_TRAP_L4_DATA_LEN; 758 struct sk_buff *skb; 759 struct udphdr *udph; 760 struct ethhdr *eth; 761 struct iphdr *iph; 762 763 skb = alloc_skb(NLMSG_GOODSIZE, GFP_ATOMIC); 764 if (!skb) 765 return NULL; 766 tot_len = sizeof(struct iphdr) + sizeof(struct udphdr) + data_len; 767 768 skb_reset_mac_header(skb); 769 eth = skb_put(skb, sizeof(struct ethhdr)); 770 eth_random_addr(eth->h_dest); 771 eth_random_addr(eth->h_source); 772 eth->h_proto = htons(ETH_P_IP); 773 skb->protocol = htons(ETH_P_IP); 774 775 skb_set_network_header(skb, skb->len); 776 iph = skb_put(skb, sizeof(struct iphdr)); 777 iph->protocol = IPPROTO_UDP; 778 iph->saddr = in_aton("192.0.2.1"); 779 iph->daddr = in_aton("198.51.100.1"); 780 iph->version = 0x4; 781 iph->frag_off = 0; 782 iph->ihl = 0x5; 783 iph->tot_len = htons(tot_len); 784 iph->ttl = 100; 785 iph->check = 0; 786 iph->check = ip_fast_csum((unsigned char *)iph, iph->ihl); 787 788 skb_set_transport_header(skb, skb->len); 789 udph = skb_put_zero(skb, sizeof(struct udphdr) + data_len); 790 get_random_bytes(&udph->source, sizeof(u16)); 791 get_random_bytes(&udph->dest, sizeof(u16)); 792 udph->len = htons(sizeof(struct udphdr) + data_len); 793 794 return skb; 795 } 796 797 static void nsim_dev_trap_report(struct nsim_dev_port *nsim_dev_port) 798 { 799 struct nsim_dev *nsim_dev = nsim_dev_port->ns->nsim_dev; 800 struct devlink *devlink = priv_to_devlink(nsim_dev); 801 struct nsim_trap_data *nsim_trap_data; 802 int i; 803 804 nsim_trap_data = nsim_dev->trap_data; 805 806 spin_lock(&nsim_trap_data->trap_lock); 807 for (i = 0; i < ARRAY_SIZE(nsim_traps_arr); i++) { 808 struct flow_action_cookie *fa_cookie = NULL; 809 struct nsim_trap_item *nsim_trap_item; 810 struct sk_buff *skb; 811 bool has_fa_cookie; 812 813 has_fa_cookie = nsim_traps_arr[i].metadata_cap & 814 DEVLINK_TRAP_METADATA_TYPE_F_FA_COOKIE; 815 816 nsim_trap_item = &nsim_trap_data->trap_items_arr[i]; 817 if (nsim_trap_item->action == DEVLINK_TRAP_ACTION_DROP) 818 continue; 819 820 skb = nsim_dev_trap_skb_build(); 821 if (!skb) 822 continue; 823 skb->dev = nsim_dev_port->ns->netdev; 824 825 /* Trapped packets are usually passed to devlink in softIRQ, 826 * but in this case they are generated in a workqueue. Disable 827 * softIRQs to prevent lockdep from complaining about 828 * "incosistent lock state". 829 */ 830 831 spin_lock_bh(&nsim_dev->fa_cookie_lock); 832 fa_cookie = has_fa_cookie ? nsim_dev->fa_cookie : NULL; 833 devlink_trap_report(devlink, skb, nsim_trap_item->trap_ctx, 834 &nsim_dev_port->devlink_port, fa_cookie); 835 spin_unlock_bh(&nsim_dev->fa_cookie_lock); 836 consume_skb(skb); 837 } 838 spin_unlock(&nsim_trap_data->trap_lock); 839 } 840 841 #define NSIM_TRAP_REPORT_INTERVAL_MS 100 842 843 static void nsim_dev_trap_report_work(struct work_struct *work) 844 { 845 struct nsim_trap_data *nsim_trap_data; 846 struct nsim_dev_port *nsim_dev_port; 847 struct nsim_dev *nsim_dev; 848 849 nsim_trap_data = container_of(work, struct nsim_trap_data, 850 trap_report_dw.work); 851 nsim_dev = nsim_trap_data->nsim_dev; 852 853 if (!devl_trylock(priv_to_devlink(nsim_dev))) { 854 queue_delayed_work(system_unbound_wq, 855 &nsim_dev->trap_data->trap_report_dw, 1); 856 return; 857 } 858 859 /* For each running port and enabled packet trap, generate a UDP 860 * packet with a random 5-tuple and report it. 861 */ 862 list_for_each_entry(nsim_dev_port, &nsim_dev->port_list, list) { 863 if (!netif_running(nsim_dev_port->ns->netdev)) 864 continue; 865 866 nsim_dev_trap_report(nsim_dev_port); 867 cond_resched(); 868 } 869 devl_unlock(priv_to_devlink(nsim_dev)); 870 queue_delayed_work(system_unbound_wq, 871 &nsim_dev->trap_data->trap_report_dw, 872 msecs_to_jiffies(NSIM_TRAP_REPORT_INTERVAL_MS)); 873 } 874 875 static int nsim_dev_traps_init(struct devlink *devlink) 876 { 877 size_t policers_count = ARRAY_SIZE(nsim_trap_policers_arr); 878 struct nsim_dev *nsim_dev = devlink_priv(devlink); 879 struct nsim_trap_data *nsim_trap_data; 880 int err; 881 882 nsim_trap_data = kzalloc(sizeof(*nsim_trap_data), GFP_KERNEL); 883 if (!nsim_trap_data) 884 return -ENOMEM; 885 886 nsim_trap_data->trap_items_arr = kcalloc(ARRAY_SIZE(nsim_traps_arr), 887 sizeof(struct nsim_trap_item), 888 GFP_KERNEL); 889 if (!nsim_trap_data->trap_items_arr) { 890 err = -ENOMEM; 891 goto err_trap_data_free; 892 } 893 894 nsim_trap_data->trap_policers_cnt_arr = kcalloc(policers_count, 895 sizeof(u64), 896 GFP_KERNEL); 897 if (!nsim_trap_data->trap_policers_cnt_arr) { 898 err = -ENOMEM; 899 goto err_trap_items_free; 900 } 901 902 /* The lock is used to protect the action state of the registered 903 * traps. The value is written by user and read in delayed work when 904 * iterating over all the traps. 905 */ 906 spin_lock_init(&nsim_trap_data->trap_lock); 907 nsim_trap_data->nsim_dev = nsim_dev; 908 nsim_dev->trap_data = nsim_trap_data; 909 910 err = devl_trap_policers_register(devlink, nsim_trap_policers_arr, 911 policers_count); 912 if (err) 913 goto err_trap_policers_cnt_free; 914 915 err = devl_trap_groups_register(devlink, nsim_trap_groups_arr, 916 ARRAY_SIZE(nsim_trap_groups_arr)); 917 if (err) 918 goto err_trap_policers_unregister; 919 920 err = devl_traps_register(devlink, nsim_traps_arr, 921 ARRAY_SIZE(nsim_traps_arr), NULL); 922 if (err) 923 goto err_trap_groups_unregister; 924 925 INIT_DELAYED_WORK(&nsim_dev->trap_data->trap_report_dw, 926 nsim_dev_trap_report_work); 927 queue_delayed_work(system_unbound_wq, 928 &nsim_dev->trap_data->trap_report_dw, 929 msecs_to_jiffies(NSIM_TRAP_REPORT_INTERVAL_MS)); 930 931 return 0; 932 933 err_trap_groups_unregister: 934 devl_trap_groups_unregister(devlink, nsim_trap_groups_arr, 935 ARRAY_SIZE(nsim_trap_groups_arr)); 936 err_trap_policers_unregister: 937 devl_trap_policers_unregister(devlink, nsim_trap_policers_arr, 938 ARRAY_SIZE(nsim_trap_policers_arr)); 939 err_trap_policers_cnt_free: 940 kfree(nsim_trap_data->trap_policers_cnt_arr); 941 err_trap_items_free: 942 kfree(nsim_trap_data->trap_items_arr); 943 err_trap_data_free: 944 kfree(nsim_trap_data); 945 return err; 946 } 947 948 static void nsim_dev_traps_exit(struct devlink *devlink) 949 { 950 struct nsim_dev *nsim_dev = devlink_priv(devlink); 951 952 /* caution, trap work takes devlink lock */ 953 cancel_delayed_work_sync(&nsim_dev->trap_data->trap_report_dw); 954 devl_traps_unregister(devlink, nsim_traps_arr, 955 ARRAY_SIZE(nsim_traps_arr)); 956 devl_trap_groups_unregister(devlink, nsim_trap_groups_arr, 957 ARRAY_SIZE(nsim_trap_groups_arr)); 958 devl_trap_policers_unregister(devlink, nsim_trap_policers_arr, 959 ARRAY_SIZE(nsim_trap_policers_arr)); 960 kfree(nsim_dev->trap_data->trap_policers_cnt_arr); 961 kfree(nsim_dev->trap_data->trap_items_arr); 962 kfree(nsim_dev->trap_data); 963 } 964 965 static int nsim_dev_reload_create(struct nsim_dev *nsim_dev, 966 struct netlink_ext_ack *extack); 967 static void nsim_dev_reload_destroy(struct nsim_dev *nsim_dev); 968 969 static int nsim_dev_reload_down(struct devlink *devlink, bool netns_change, 970 enum devlink_reload_action action, enum devlink_reload_limit limit, 971 struct netlink_ext_ack *extack) 972 { 973 struct nsim_dev *nsim_dev = devlink_priv(devlink); 974 975 if (nsim_dev->dont_allow_reload) { 976 /* For testing purposes, user set debugfs dont_allow_reload 977 * value to true. So forbid it. 978 */ 979 NL_SET_ERR_MSG_MOD(extack, "User forbid the reload for testing purposes"); 980 return -EOPNOTSUPP; 981 } 982 983 nsim_dev_reload_destroy(nsim_dev); 984 return 0; 985 } 986 987 static int nsim_dev_reload_up(struct devlink *devlink, enum devlink_reload_action action, 988 enum devlink_reload_limit limit, u32 *actions_performed, 989 struct netlink_ext_ack *extack) 990 { 991 struct nsim_dev *nsim_dev = devlink_priv(devlink); 992 993 if (nsim_dev->fail_reload) { 994 /* For testing purposes, user set debugfs fail_reload 995 * value to true. Fail right away. 996 */ 997 NL_SET_ERR_MSG_MOD(extack, "User setup the reload to fail for testing purposes"); 998 return -EINVAL; 999 } 1000 1001 *actions_performed = BIT(DEVLINK_RELOAD_ACTION_DRIVER_REINIT); 1002 1003 return nsim_dev_reload_create(nsim_dev, extack); 1004 } 1005 1006 static int nsim_dev_info_get(struct devlink *devlink, 1007 struct devlink_info_req *req, 1008 struct netlink_ext_ack *extack) 1009 { 1010 int err; 1011 1012 err = devlink_info_version_stored_put_ext(req, "fw.mgmt", "10.20.30", 1013 DEVLINK_INFO_VERSION_TYPE_COMPONENT); 1014 if (err) 1015 return err; 1016 return devlink_info_version_running_put_ext(req, "fw.mgmt", "10.20.30", 1017 DEVLINK_INFO_VERSION_TYPE_COMPONENT); 1018 } 1019 1020 #define NSIM_DEV_FLASH_SIZE 50000 1021 #define NSIM_DEV_FLASH_CHUNK_SIZE 1000 1022 #define NSIM_DEV_FLASH_CHUNK_TIME_MS_DEFAULT 100 1023 1024 static int nsim_dev_flash_update(struct devlink *devlink, 1025 struct devlink_flash_update_params *params, 1026 struct netlink_ext_ack *extack) 1027 { 1028 struct nsim_dev *nsim_dev = devlink_priv(devlink); 1029 int i; 1030 1031 if ((params->overwrite_mask & ~nsim_dev->fw_update_overwrite_mask) != 0) 1032 return -EOPNOTSUPP; 1033 1034 if (nsim_dev->fw_update_status) { 1035 devlink_flash_update_status_notify(devlink, 1036 "Preparing to flash", 1037 params->component, 0, 0); 1038 } 1039 1040 for (i = 0; i < NSIM_DEV_FLASH_SIZE / NSIM_DEV_FLASH_CHUNK_SIZE; i++) { 1041 if (nsim_dev->fw_update_status) 1042 devlink_flash_update_status_notify(devlink, "Flashing", 1043 params->component, 1044 i * NSIM_DEV_FLASH_CHUNK_SIZE, 1045 NSIM_DEV_FLASH_SIZE); 1046 msleep(nsim_dev->fw_update_flash_chunk_time_ms ?: 1); 1047 } 1048 1049 if (nsim_dev->fw_update_status) { 1050 devlink_flash_update_status_notify(devlink, "Flashing", 1051 params->component, 1052 NSIM_DEV_FLASH_SIZE, 1053 NSIM_DEV_FLASH_SIZE); 1054 devlink_flash_update_timeout_notify(devlink, "Flash select", 1055 params->component, 81); 1056 devlink_flash_update_status_notify(devlink, "Flashing done", 1057 params->component, 0, 0); 1058 } 1059 1060 return 0; 1061 } 1062 1063 static struct nsim_trap_item * 1064 nsim_dev_trap_item_lookup(struct nsim_dev *nsim_dev, u16 trap_id) 1065 { 1066 struct nsim_trap_data *nsim_trap_data = nsim_dev->trap_data; 1067 int i; 1068 1069 for (i = 0; i < ARRAY_SIZE(nsim_traps_arr); i++) { 1070 if (nsim_traps_arr[i].id == trap_id) 1071 return &nsim_trap_data->trap_items_arr[i]; 1072 } 1073 1074 return NULL; 1075 } 1076 1077 static int nsim_dev_devlink_trap_init(struct devlink *devlink, 1078 const struct devlink_trap *trap, 1079 void *trap_ctx) 1080 { 1081 struct nsim_dev *nsim_dev = devlink_priv(devlink); 1082 struct nsim_trap_item *nsim_trap_item; 1083 1084 nsim_trap_item = nsim_dev_trap_item_lookup(nsim_dev, trap->id); 1085 if (WARN_ON(!nsim_trap_item)) 1086 return -ENOENT; 1087 1088 nsim_trap_item->trap_ctx = trap_ctx; 1089 nsim_trap_item->action = trap->init_action; 1090 1091 return 0; 1092 } 1093 1094 static int 1095 nsim_dev_devlink_trap_action_set(struct devlink *devlink, 1096 const struct devlink_trap *trap, 1097 enum devlink_trap_action action, 1098 struct netlink_ext_ack *extack) 1099 { 1100 struct nsim_dev *nsim_dev = devlink_priv(devlink); 1101 struct nsim_trap_item *nsim_trap_item; 1102 1103 nsim_trap_item = nsim_dev_trap_item_lookup(nsim_dev, trap->id); 1104 if (WARN_ON(!nsim_trap_item)) 1105 return -ENOENT; 1106 1107 spin_lock(&nsim_dev->trap_data->trap_lock); 1108 nsim_trap_item->action = action; 1109 spin_unlock(&nsim_dev->trap_data->trap_lock); 1110 1111 return 0; 1112 } 1113 1114 static int 1115 nsim_dev_devlink_trap_group_set(struct devlink *devlink, 1116 const struct devlink_trap_group *group, 1117 const struct devlink_trap_policer *policer, 1118 struct netlink_ext_ack *extack) 1119 { 1120 struct nsim_dev *nsim_dev = devlink_priv(devlink); 1121 1122 if (nsim_dev->fail_trap_group_set) 1123 return -EINVAL; 1124 1125 return 0; 1126 } 1127 1128 static int 1129 nsim_dev_devlink_trap_policer_set(struct devlink *devlink, 1130 const struct devlink_trap_policer *policer, 1131 u64 rate, u64 burst, 1132 struct netlink_ext_ack *extack) 1133 { 1134 struct nsim_dev *nsim_dev = devlink_priv(devlink); 1135 1136 if (nsim_dev->fail_trap_policer_set) { 1137 NL_SET_ERR_MSG_MOD(extack, "User setup the operation to fail for testing purposes"); 1138 return -EINVAL; 1139 } 1140 1141 return 0; 1142 } 1143 1144 static int 1145 nsim_dev_devlink_trap_policer_counter_get(struct devlink *devlink, 1146 const struct devlink_trap_policer *policer, 1147 u64 *p_drops) 1148 { 1149 struct nsim_dev *nsim_dev = devlink_priv(devlink); 1150 u64 *cnt; 1151 1152 if (nsim_dev->fail_trap_policer_counter_get) 1153 return -EINVAL; 1154 1155 cnt = &nsim_dev->trap_data->trap_policers_cnt_arr[policer->id - 1]; 1156 *p_drops = (*cnt)++; 1157 1158 return 0; 1159 } 1160 1161 #define NSIM_LINK_SPEED_MAX 5000 /* Mbps */ 1162 #define NSIM_LINK_SPEED_UNIT 125000 /* 1 Mbps given in bytes/sec to avoid 1163 * u64 overflow during conversion from 1164 * bytes to bits. 1165 */ 1166 1167 static int nsim_rate_bytes_to_units(char *name, u64 *rate, struct netlink_ext_ack *extack) 1168 { 1169 u64 val; 1170 u32 rem; 1171 1172 val = div_u64_rem(*rate, NSIM_LINK_SPEED_UNIT, &rem); 1173 if (rem) { 1174 pr_err("%s rate value %lluBps not in link speed units of 1Mbps.\n", 1175 name, *rate); 1176 NL_SET_ERR_MSG_MOD(extack, "TX rate value not in link speed units of 1Mbps."); 1177 return -EINVAL; 1178 } 1179 1180 if (val > NSIM_LINK_SPEED_MAX) { 1181 pr_err("%s rate value %lluMbps exceed link maximum speed 5000Mbps.\n", 1182 name, val); 1183 NL_SET_ERR_MSG_MOD(extack, "TX rate value exceed link maximum speed 5000Mbps."); 1184 return -EINVAL; 1185 } 1186 *rate = val; 1187 return 0; 1188 } 1189 1190 static int nsim_leaf_tc_bw_set(struct devlink_rate *devlink_rate, 1191 void *priv, u32 *tc_bw, 1192 struct netlink_ext_ack *extack) 1193 { 1194 struct nsim_dev_port *nsim_dev_port = priv; 1195 int i; 1196 1197 for (i = 0; i < DEVLINK_RATE_TCS_MAX; i++) 1198 nsim_dev_port->tc_bw[i] = tc_bw[i]; 1199 1200 return 0; 1201 } 1202 1203 static int nsim_leaf_tx_share_set(struct devlink_rate *devlink_rate, void *priv, 1204 u64 tx_share, struct netlink_ext_ack *extack) 1205 { 1206 struct nsim_dev_port *nsim_dev_port = priv; 1207 struct nsim_dev *nsim_dev = nsim_dev_port->ns->nsim_dev; 1208 int vf_id = nsim_dev_port_index_to_vf_index(nsim_dev_port->port_index); 1209 int err; 1210 1211 err = nsim_rate_bytes_to_units("tx_share", &tx_share, extack); 1212 if (err) 1213 return err; 1214 1215 nsim_dev->vfconfigs[vf_id].min_tx_rate = tx_share; 1216 return 0; 1217 } 1218 1219 static int nsim_leaf_tx_max_set(struct devlink_rate *devlink_rate, void *priv, 1220 u64 tx_max, struct netlink_ext_ack *extack) 1221 { 1222 struct nsim_dev_port *nsim_dev_port = priv; 1223 struct nsim_dev *nsim_dev = nsim_dev_port->ns->nsim_dev; 1224 int vf_id = nsim_dev_port_index_to_vf_index(nsim_dev_port->port_index); 1225 int err; 1226 1227 err = nsim_rate_bytes_to_units("tx_max", &tx_max, extack); 1228 if (err) 1229 return err; 1230 1231 nsim_dev->vfconfigs[vf_id].max_tx_rate = tx_max; 1232 return 0; 1233 } 1234 1235 struct nsim_rate_node { 1236 struct dentry *ddir; 1237 struct dentry *rate_parent; 1238 char *parent_name; 1239 u16 tx_share; 1240 u16 tx_max; 1241 u32 tc_bw[DEVLINK_RATE_TCS_MAX]; 1242 }; 1243 1244 static int nsim_node_tc_bw_set(struct devlink_rate *devlink_rate, void *priv, 1245 u32 *tc_bw, struct netlink_ext_ack *extack) 1246 { 1247 struct nsim_rate_node *nsim_node = priv; 1248 int i; 1249 1250 for (i = 0; i < DEVLINK_RATE_TCS_MAX; i++) 1251 nsim_node->tc_bw[i] = tc_bw[i]; 1252 1253 return 0; 1254 } 1255 1256 static int nsim_node_tx_share_set(struct devlink_rate *devlink_rate, void *priv, 1257 u64 tx_share, struct netlink_ext_ack *extack) 1258 { 1259 struct nsim_rate_node *nsim_node = priv; 1260 int err; 1261 1262 err = nsim_rate_bytes_to_units("tx_share", &tx_share, extack); 1263 if (err) 1264 return err; 1265 1266 nsim_node->tx_share = tx_share; 1267 return 0; 1268 } 1269 1270 static int nsim_node_tx_max_set(struct devlink_rate *devlink_rate, void *priv, 1271 u64 tx_max, struct netlink_ext_ack *extack) 1272 { 1273 struct nsim_rate_node *nsim_node = priv; 1274 int err; 1275 1276 err = nsim_rate_bytes_to_units("tx_max", &tx_max, extack); 1277 if (err) 1278 return err; 1279 1280 nsim_node->tx_max = tx_max; 1281 return 0; 1282 } 1283 1284 static int nsim_rate_node_new(struct devlink_rate *node, void **priv, 1285 struct netlink_ext_ack *extack) 1286 { 1287 struct nsim_dev *nsim_dev = devlink_priv(node->devlink); 1288 struct nsim_rate_node *nsim_node; 1289 1290 if (!nsim_esw_mode_is_switchdev(nsim_dev)) { 1291 NL_SET_ERR_MSG_MOD(extack, "Node creation allowed only in switchdev mode."); 1292 return -EOPNOTSUPP; 1293 } 1294 1295 nsim_node = kzalloc(sizeof(*nsim_node), GFP_KERNEL); 1296 if (!nsim_node) 1297 return -ENOMEM; 1298 1299 nsim_node->ddir = debugfs_create_dir(node->name, nsim_dev->nodes_ddir); 1300 1301 debugfs_create_u16("tx_share", 0400, nsim_node->ddir, &nsim_node->tx_share); 1302 debugfs_create_u16("tx_max", 0400, nsim_node->ddir, &nsim_node->tx_max); 1303 nsim_node->rate_parent = debugfs_create_file("rate_parent", 0400, 1304 nsim_node->ddir, 1305 &nsim_node->parent_name, 1306 &nsim_dev_rate_parent_fops); 1307 1308 nsim_dev_tc_bw_debugfs_init(nsim_node->ddir, nsim_node->tc_bw); 1309 1310 *priv = nsim_node; 1311 return 0; 1312 } 1313 1314 static int nsim_rate_node_del(struct devlink_rate *node, void *priv, 1315 struct netlink_ext_ack *extack) 1316 { 1317 struct nsim_rate_node *nsim_node = priv; 1318 1319 debugfs_remove(nsim_node->rate_parent); 1320 debugfs_remove_recursive(nsim_node->ddir); 1321 kfree(nsim_node); 1322 return 0; 1323 } 1324 1325 static int nsim_rate_leaf_parent_set(struct devlink_rate *child, 1326 struct devlink_rate *parent, 1327 void *priv_child, void *priv_parent, 1328 struct netlink_ext_ack *extack) 1329 { 1330 struct nsim_dev_port *nsim_dev_port = priv_child; 1331 1332 if (parent) 1333 nsim_dev_port->parent_name = parent->name; 1334 else 1335 nsim_dev_port->parent_name = NULL; 1336 return 0; 1337 } 1338 1339 static int nsim_rate_node_parent_set(struct devlink_rate *child, 1340 struct devlink_rate *parent, 1341 void *priv_child, void *priv_parent, 1342 struct netlink_ext_ack *extack) 1343 { 1344 struct nsim_rate_node *nsim_node = priv_child; 1345 1346 if (parent) 1347 nsim_node->parent_name = parent->name; 1348 else 1349 nsim_node->parent_name = NULL; 1350 return 0; 1351 } 1352 1353 static int 1354 nsim_dev_devlink_trap_drop_counter_get(struct devlink *devlink, 1355 const struct devlink_trap *trap, 1356 u64 *p_drops) 1357 { 1358 struct nsim_dev *nsim_dev = devlink_priv(devlink); 1359 u64 *cnt; 1360 1361 if (nsim_dev->fail_trap_drop_counter_get) 1362 return -EINVAL; 1363 1364 cnt = &nsim_dev->trap_data->trap_pkt_cnt; 1365 *p_drops = (*cnt)++; 1366 1367 return 0; 1368 } 1369 1370 static const struct devlink_ops nsim_dev_devlink_ops = { 1371 .eswitch_mode_set = nsim_devlink_eswitch_mode_set, 1372 .eswitch_mode_get = nsim_devlink_eswitch_mode_get, 1373 .supported_flash_update_params = DEVLINK_SUPPORT_FLASH_UPDATE_OVERWRITE_MASK, 1374 .reload_actions = BIT(DEVLINK_RELOAD_ACTION_DRIVER_REINIT), 1375 .reload_down = nsim_dev_reload_down, 1376 .reload_up = nsim_dev_reload_up, 1377 .info_get = nsim_dev_info_get, 1378 .flash_update = nsim_dev_flash_update, 1379 .trap_init = nsim_dev_devlink_trap_init, 1380 .trap_action_set = nsim_dev_devlink_trap_action_set, 1381 .trap_group_set = nsim_dev_devlink_trap_group_set, 1382 .trap_policer_set = nsim_dev_devlink_trap_policer_set, 1383 .trap_policer_counter_get = nsim_dev_devlink_trap_policer_counter_get, 1384 .rate_leaf_tx_share_set = nsim_leaf_tx_share_set, 1385 .rate_leaf_tx_max_set = nsim_leaf_tx_max_set, 1386 .rate_leaf_tc_bw_set = nsim_leaf_tc_bw_set, 1387 .rate_node_tx_share_set = nsim_node_tx_share_set, 1388 .rate_node_tx_max_set = nsim_node_tx_max_set, 1389 .rate_node_tc_bw_set = nsim_node_tc_bw_set, 1390 .rate_node_new = nsim_rate_node_new, 1391 .rate_node_del = nsim_rate_node_del, 1392 .rate_leaf_parent_set = nsim_rate_leaf_parent_set, 1393 .rate_node_parent_set = nsim_rate_node_parent_set, 1394 .trap_drop_counter_get = nsim_dev_devlink_trap_drop_counter_get, 1395 }; 1396 1397 #define NSIM_DEV_MAX_MACS_DEFAULT 32 1398 #define NSIM_DEV_TEST1_DEFAULT true 1399 1400 static int __nsim_dev_port_add(struct nsim_dev *nsim_dev, enum nsim_dev_port_type type, 1401 unsigned int port_index, u8 perm_addr[ETH_ALEN]) 1402 { 1403 struct devlink_port_attrs attrs = {}; 1404 struct nsim_dev_port *nsim_dev_port; 1405 struct devlink_port *devlink_port; 1406 int err; 1407 1408 if (type == NSIM_DEV_PORT_TYPE_VF && !nsim_dev_get_vfs(nsim_dev)) 1409 return -EINVAL; 1410 1411 nsim_dev_port = kzalloc(sizeof(*nsim_dev_port), GFP_KERNEL); 1412 if (!nsim_dev_port) 1413 return -ENOMEM; 1414 nsim_dev_port->port_index = nsim_dev_port_index(type, port_index); 1415 nsim_dev_port->port_type = type; 1416 1417 devlink_port = &nsim_dev_port->devlink_port; 1418 if (nsim_dev_port_is_pf(nsim_dev_port)) { 1419 attrs.flavour = DEVLINK_PORT_FLAVOUR_PHYSICAL; 1420 attrs.phys.port_number = port_index + 1; 1421 } else { 1422 attrs.flavour = DEVLINK_PORT_FLAVOUR_PCI_VF; 1423 attrs.pci_vf.pf = 0; 1424 attrs.pci_vf.vf = port_index; 1425 } 1426 memcpy(attrs.switch_id.id, nsim_dev->switch_id.id, nsim_dev->switch_id.id_len); 1427 attrs.switch_id.id_len = nsim_dev->switch_id.id_len; 1428 devlink_port_attrs_set(devlink_port, &attrs); 1429 err = devl_port_register(priv_to_devlink(nsim_dev), devlink_port, 1430 nsim_dev_port->port_index); 1431 if (err) 1432 goto err_port_free; 1433 1434 err = nsim_dev_port_debugfs_init(nsim_dev, nsim_dev_port); 1435 if (err) 1436 goto err_dl_port_unregister; 1437 1438 nsim_dev_port->ns = nsim_create(nsim_dev, nsim_dev_port, perm_addr); 1439 if (IS_ERR(nsim_dev_port->ns)) { 1440 err = PTR_ERR(nsim_dev_port->ns); 1441 goto err_port_debugfs_exit; 1442 } 1443 1444 if (nsim_dev_port_is_vf(nsim_dev_port)) { 1445 err = devl_rate_leaf_create(&nsim_dev_port->devlink_port, 1446 nsim_dev_port, NULL); 1447 if (err) 1448 goto err_nsim_destroy; 1449 } 1450 1451 list_add(&nsim_dev_port->list, &nsim_dev->port_list); 1452 1453 return 0; 1454 1455 err_nsim_destroy: 1456 nsim_destroy(nsim_dev_port->ns); 1457 err_port_debugfs_exit: 1458 nsim_dev_port_debugfs_exit(nsim_dev_port); 1459 err_dl_port_unregister: 1460 devl_port_unregister(devlink_port); 1461 err_port_free: 1462 kfree(nsim_dev_port); 1463 return err; 1464 } 1465 1466 static void __nsim_dev_port_del(struct nsim_dev_port *nsim_dev_port) 1467 { 1468 struct devlink_port *devlink_port = &nsim_dev_port->devlink_port; 1469 1470 list_del(&nsim_dev_port->list); 1471 if (nsim_dev_port_is_vf(nsim_dev_port)) 1472 devl_rate_leaf_destroy(&nsim_dev_port->devlink_port); 1473 nsim_destroy(nsim_dev_port->ns); 1474 nsim_dev_port_debugfs_exit(nsim_dev_port); 1475 devl_port_unregister(devlink_port); 1476 kfree(nsim_dev_port); 1477 } 1478 1479 static void nsim_dev_port_del_all(struct nsim_dev *nsim_dev) 1480 { 1481 struct nsim_dev_port *nsim_dev_port, *tmp; 1482 1483 list_for_each_entry_safe(nsim_dev_port, tmp, 1484 &nsim_dev->port_list, list) 1485 __nsim_dev_port_del(nsim_dev_port); 1486 } 1487 1488 static int nsim_dev_port_add_all(struct nsim_dev *nsim_dev, 1489 unsigned int port_count) 1490 { 1491 int i, err; 1492 1493 for (i = 0; i < port_count; i++) { 1494 err = __nsim_dev_port_add(nsim_dev, NSIM_DEV_PORT_TYPE_PF, i, NULL); 1495 if (err) 1496 goto err_port_del_all; 1497 } 1498 return 0; 1499 1500 err_port_del_all: 1501 nsim_dev_port_del_all(nsim_dev); 1502 return err; 1503 } 1504 1505 static int nsim_dev_reload_create(struct nsim_dev *nsim_dev, 1506 struct netlink_ext_ack *extack) 1507 { 1508 struct nsim_bus_dev *nsim_bus_dev = nsim_dev->nsim_bus_dev; 1509 struct devlink *devlink; 1510 int err; 1511 1512 devlink = priv_to_devlink(nsim_dev); 1513 nsim_dev = devlink_priv(devlink); 1514 INIT_LIST_HEAD(&nsim_dev->port_list); 1515 nsim_dev->fw_update_status = true; 1516 nsim_dev->fw_update_overwrite_mask = 0; 1517 1518 nsim_devlink_param_load_driverinit_values(devlink); 1519 1520 err = nsim_dev_dummy_region_init(nsim_dev, devlink); 1521 if (err) 1522 return err; 1523 1524 err = nsim_dev_traps_init(devlink); 1525 if (err) 1526 goto err_dummy_region_exit; 1527 1528 nsim_dev->fib_data = nsim_fib_create(devlink, extack); 1529 if (IS_ERR(nsim_dev->fib_data)) { 1530 err = PTR_ERR(nsim_dev->fib_data); 1531 goto err_traps_exit; 1532 } 1533 1534 err = nsim_dev_health_init(nsim_dev, devlink); 1535 if (err) 1536 goto err_fib_destroy; 1537 1538 err = nsim_dev_psample_init(nsim_dev); 1539 if (err) 1540 goto err_health_exit; 1541 1542 err = nsim_dev_hwstats_init(nsim_dev); 1543 if (err) 1544 goto err_psample_exit; 1545 1546 err = nsim_dev_port_add_all(nsim_dev, nsim_bus_dev->port_count); 1547 if (err) 1548 goto err_hwstats_exit; 1549 1550 nsim_dev->take_snapshot = debugfs_create_file("take_snapshot", 1551 0200, 1552 nsim_dev->ddir, 1553 nsim_dev, 1554 &nsim_dev_take_snapshot_fops); 1555 return 0; 1556 1557 err_hwstats_exit: 1558 nsim_dev_hwstats_exit(nsim_dev); 1559 err_psample_exit: 1560 nsim_dev_psample_exit(nsim_dev); 1561 err_health_exit: 1562 nsim_dev_health_exit(nsim_dev); 1563 err_fib_destroy: 1564 nsim_fib_destroy(devlink, nsim_dev->fib_data); 1565 err_traps_exit: 1566 nsim_dev_traps_exit(devlink); 1567 err_dummy_region_exit: 1568 nsim_dev_dummy_region_exit(nsim_dev); 1569 return err; 1570 } 1571 1572 int nsim_drv_probe(struct nsim_bus_dev *nsim_bus_dev) 1573 { 1574 struct nsim_dev *nsim_dev; 1575 struct devlink *devlink; 1576 int err; 1577 1578 devlink = devlink_alloc_ns(&nsim_dev_devlink_ops, sizeof(*nsim_dev), 1579 nsim_bus_dev->initial_net, &nsim_bus_dev->dev); 1580 if (!devlink) 1581 return -ENOMEM; 1582 devl_lock(devlink); 1583 nsim_dev = devlink_priv(devlink); 1584 nsim_dev->nsim_bus_dev = nsim_bus_dev; 1585 nsim_dev->switch_id.id_len = sizeof(nsim_dev->switch_id.id); 1586 get_random_bytes(nsim_dev->switch_id.id, nsim_dev->switch_id.id_len); 1587 INIT_LIST_HEAD(&nsim_dev->port_list); 1588 nsim_dev->fw_update_status = true; 1589 nsim_dev->fw_update_overwrite_mask = 0; 1590 nsim_dev->fw_update_flash_chunk_time_ms = NSIM_DEV_FLASH_CHUNK_TIME_MS_DEFAULT; 1591 nsim_dev->max_macs = NSIM_DEV_MAX_MACS_DEFAULT; 1592 nsim_dev->test1 = NSIM_DEV_TEST1_DEFAULT; 1593 spin_lock_init(&nsim_dev->fa_cookie_lock); 1594 1595 dev_set_drvdata(&nsim_bus_dev->dev, nsim_dev); 1596 1597 nsim_dev->vfconfigs = kcalloc(nsim_bus_dev->max_vfs, 1598 sizeof(struct nsim_vf_config), 1599 GFP_KERNEL | __GFP_NOWARN); 1600 if (!nsim_dev->vfconfigs) { 1601 err = -ENOMEM; 1602 goto err_devlink_unlock; 1603 } 1604 1605 err = devl_register(devlink); 1606 if (err) 1607 goto err_vfc_free; 1608 1609 err = nsim_dev_resources_register(devlink); 1610 if (err) 1611 goto err_dl_unregister; 1612 1613 err = devl_params_register(devlink, nsim_devlink_params, 1614 ARRAY_SIZE(nsim_devlink_params)); 1615 if (err) 1616 goto err_resource_unregister; 1617 nsim_devlink_set_params_init_values(nsim_dev, devlink); 1618 1619 err = nsim_dev_dummy_region_init(nsim_dev, devlink); 1620 if (err) 1621 goto err_params_unregister; 1622 1623 err = nsim_dev_traps_init(devlink); 1624 if (err) 1625 goto err_dummy_region_exit; 1626 1627 err = nsim_dev_debugfs_init(nsim_dev); 1628 if (err) 1629 goto err_traps_exit; 1630 1631 nsim_dev->fib_data = nsim_fib_create(devlink, NULL); 1632 if (IS_ERR(nsim_dev->fib_data)) { 1633 err = PTR_ERR(nsim_dev->fib_data); 1634 goto err_debugfs_exit; 1635 } 1636 1637 err = nsim_dev_health_init(nsim_dev, devlink); 1638 if (err) 1639 goto err_fib_destroy; 1640 1641 err = nsim_bpf_dev_init(nsim_dev); 1642 if (err) 1643 goto err_health_exit; 1644 1645 err = nsim_dev_psample_init(nsim_dev); 1646 if (err) 1647 goto err_bpf_dev_exit; 1648 1649 err = nsim_dev_hwstats_init(nsim_dev); 1650 if (err) 1651 goto err_psample_exit; 1652 1653 err = nsim_dev_port_add_all(nsim_dev, nsim_bus_dev->port_count); 1654 if (err) 1655 goto err_hwstats_exit; 1656 1657 nsim_dev->esw_mode = DEVLINK_ESWITCH_MODE_LEGACY; 1658 devl_unlock(devlink); 1659 return 0; 1660 1661 err_hwstats_exit: 1662 nsim_dev_hwstats_exit(nsim_dev); 1663 err_psample_exit: 1664 nsim_dev_psample_exit(nsim_dev); 1665 err_bpf_dev_exit: 1666 nsim_bpf_dev_exit(nsim_dev); 1667 err_health_exit: 1668 nsim_dev_health_exit(nsim_dev); 1669 err_fib_destroy: 1670 nsim_fib_destroy(devlink, nsim_dev->fib_data); 1671 err_debugfs_exit: 1672 nsim_dev_debugfs_exit(nsim_dev); 1673 err_traps_exit: 1674 nsim_dev_traps_exit(devlink); 1675 err_dummy_region_exit: 1676 nsim_dev_dummy_region_exit(nsim_dev); 1677 err_params_unregister: 1678 devl_params_unregister(devlink, nsim_devlink_params, 1679 ARRAY_SIZE(nsim_devlink_params)); 1680 err_resource_unregister: 1681 devl_resources_unregister(devlink); 1682 err_dl_unregister: 1683 devl_unregister(devlink); 1684 err_vfc_free: 1685 kfree(nsim_dev->vfconfigs); 1686 err_devlink_unlock: 1687 devl_unlock(devlink); 1688 devlink_free(devlink); 1689 dev_set_drvdata(&nsim_bus_dev->dev, NULL); 1690 return err; 1691 } 1692 1693 static void nsim_dev_reload_destroy(struct nsim_dev *nsim_dev) 1694 { 1695 struct devlink *devlink = priv_to_devlink(nsim_dev); 1696 1697 if (devlink_is_reload_failed(devlink)) 1698 return; 1699 debugfs_remove(nsim_dev->take_snapshot); 1700 1701 if (nsim_dev_get_vfs(nsim_dev)) { 1702 nsim_bus_dev_set_vfs(nsim_dev->nsim_bus_dev, 0); 1703 if (nsim_esw_mode_is_switchdev(nsim_dev)) 1704 nsim_esw_legacy_enable(nsim_dev, NULL); 1705 } 1706 1707 nsim_dev_port_del_all(nsim_dev); 1708 nsim_dev_hwstats_exit(nsim_dev); 1709 nsim_dev_psample_exit(nsim_dev); 1710 nsim_dev_health_exit(nsim_dev); 1711 nsim_fib_destroy(devlink, nsim_dev->fib_data); 1712 nsim_dev_traps_exit(devlink); 1713 nsim_dev_dummy_region_exit(nsim_dev); 1714 } 1715 1716 void nsim_drv_remove(struct nsim_bus_dev *nsim_bus_dev) 1717 { 1718 struct nsim_dev *nsim_dev = dev_get_drvdata(&nsim_bus_dev->dev); 1719 struct devlink *devlink = priv_to_devlink(nsim_dev); 1720 1721 devl_lock(devlink); 1722 nsim_dev_reload_destroy(nsim_dev); 1723 1724 nsim_bpf_dev_exit(nsim_dev); 1725 nsim_dev_debugfs_exit(nsim_dev); 1726 devl_params_unregister(devlink, nsim_devlink_params, 1727 ARRAY_SIZE(nsim_devlink_params)); 1728 devl_resources_unregister(devlink); 1729 devl_unregister(devlink); 1730 kfree(nsim_dev->vfconfigs); 1731 kfree(nsim_dev->fa_cookie); 1732 devl_unlock(devlink); 1733 devlink_free(devlink); 1734 dev_set_drvdata(&nsim_bus_dev->dev, NULL); 1735 } 1736 1737 static struct nsim_dev_port * 1738 __nsim_dev_port_lookup(struct nsim_dev *nsim_dev, enum nsim_dev_port_type type, 1739 unsigned int port_index) 1740 { 1741 struct nsim_dev_port *nsim_dev_port; 1742 1743 port_index = nsim_dev_port_index(type, port_index); 1744 list_for_each_entry(nsim_dev_port, &nsim_dev->port_list, list) 1745 if (nsim_dev_port->port_index == port_index) 1746 return nsim_dev_port; 1747 return NULL; 1748 } 1749 1750 int nsim_drv_port_add(struct nsim_bus_dev *nsim_bus_dev, enum nsim_dev_port_type type, 1751 unsigned int port_index, u8 perm_addr[ETH_ALEN]) 1752 { 1753 struct nsim_dev *nsim_dev = dev_get_drvdata(&nsim_bus_dev->dev); 1754 int err; 1755 1756 devl_lock(priv_to_devlink(nsim_dev)); 1757 if (__nsim_dev_port_lookup(nsim_dev, type, port_index)) 1758 err = -EEXIST; 1759 else 1760 err = __nsim_dev_port_add(nsim_dev, type, port_index, perm_addr); 1761 devl_unlock(priv_to_devlink(nsim_dev)); 1762 return err; 1763 } 1764 1765 int nsim_drv_port_del(struct nsim_bus_dev *nsim_bus_dev, enum nsim_dev_port_type type, 1766 unsigned int port_index) 1767 { 1768 struct nsim_dev *nsim_dev = dev_get_drvdata(&nsim_bus_dev->dev); 1769 struct nsim_dev_port *nsim_dev_port; 1770 int err = 0; 1771 1772 devl_lock(priv_to_devlink(nsim_dev)); 1773 nsim_dev_port = __nsim_dev_port_lookup(nsim_dev, type, port_index); 1774 if (!nsim_dev_port) 1775 err = -ENOENT; 1776 else 1777 __nsim_dev_port_del(nsim_dev_port); 1778 devl_unlock(priv_to_devlink(nsim_dev)); 1779 return err; 1780 } 1781 1782 int nsim_drv_configure_vfs(struct nsim_bus_dev *nsim_bus_dev, 1783 unsigned int num_vfs) 1784 { 1785 struct nsim_dev *nsim_dev = dev_get_drvdata(&nsim_bus_dev->dev); 1786 struct devlink *devlink = priv_to_devlink(nsim_dev); 1787 int ret = 0; 1788 1789 devl_lock(devlink); 1790 if (nsim_bus_dev->num_vfs == num_vfs) 1791 goto exit_unlock; 1792 if (nsim_bus_dev->num_vfs && num_vfs) { 1793 ret = -EBUSY; 1794 goto exit_unlock; 1795 } 1796 if (nsim_bus_dev->max_vfs < num_vfs) { 1797 ret = -ENOMEM; 1798 goto exit_unlock; 1799 } 1800 1801 nsim_bus_dev_set_vfs(nsim_bus_dev, num_vfs); 1802 if (nsim_esw_mode_is_switchdev(nsim_dev)) { 1803 if (num_vfs) { 1804 ret = nsim_esw_switchdev_enable(nsim_dev, NULL); 1805 if (ret) { 1806 nsim_bus_dev_set_vfs(nsim_bus_dev, 0); 1807 goto exit_unlock; 1808 } 1809 } else { 1810 nsim_esw_legacy_enable(nsim_dev, NULL); 1811 } 1812 } 1813 1814 exit_unlock: 1815 devl_unlock(devlink); 1816 1817 return ret; 1818 } 1819 1820 int nsim_dev_init(void) 1821 { 1822 nsim_dev_ddir = debugfs_create_dir(DRV_NAME, NULL); 1823 return PTR_ERR_OR_ZERO(nsim_dev_ddir); 1824 } 1825 1826 void nsim_dev_exit(void) 1827 { 1828 debugfs_remove_recursive(nsim_dev_ddir); 1829 } 1830