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