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