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 int err; 1145 1146 if (!nsim_esw_mode_is_switchdev(nsim_dev)) { 1147 NL_SET_ERR_MSG_MOD(extack, "Node creation allowed only in switchdev mode."); 1148 return -EOPNOTSUPP; 1149 } 1150 1151 nsim_node = kzalloc(sizeof(*nsim_node), GFP_KERNEL); 1152 if (!nsim_node) 1153 return -ENOMEM; 1154 1155 nsim_node->ddir = debugfs_create_dir(node->name, nsim_dev->nodes_ddir); 1156 if (!nsim_node->ddir) { 1157 err = -ENOMEM; 1158 goto err_node; 1159 } 1160 debugfs_create_u16("tx_share", 0400, nsim_node->ddir, &nsim_node->tx_share); 1161 debugfs_create_u16("tx_max", 0400, nsim_node->ddir, &nsim_node->tx_max); 1162 nsim_node->rate_parent = debugfs_create_file("rate_parent", 0400, 1163 nsim_node->ddir, 1164 &nsim_node->parent_name, 1165 &nsim_dev_rate_parent_fops); 1166 if (IS_ERR(nsim_node->rate_parent)) { 1167 err = PTR_ERR(nsim_node->rate_parent); 1168 goto err_ddir; 1169 } 1170 1171 *priv = nsim_node; 1172 return 0; 1173 1174 err_ddir: 1175 debugfs_remove_recursive(nsim_node->ddir); 1176 err_node: 1177 kfree(nsim_node); 1178 return err; 1179 } 1180 1181 static int nsim_rate_node_del(struct devlink_rate *node, void *priv, 1182 struct netlink_ext_ack *extack) 1183 { 1184 struct nsim_rate_node *nsim_node = priv; 1185 1186 debugfs_remove(nsim_node->rate_parent); 1187 debugfs_remove_recursive(nsim_node->ddir); 1188 kfree(nsim_node); 1189 return 0; 1190 } 1191 1192 static int nsim_rate_leaf_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_dev_port *nsim_dev_port = priv_child; 1198 1199 if (parent) 1200 nsim_dev_port->parent_name = parent->name; 1201 else 1202 nsim_dev_port->parent_name = NULL; 1203 return 0; 1204 } 1205 1206 static int nsim_rate_node_parent_set(struct devlink_rate *child, 1207 struct devlink_rate *parent, 1208 void *priv_child, void *priv_parent, 1209 struct netlink_ext_ack *extack) 1210 { 1211 struct nsim_rate_node *nsim_node = priv_child; 1212 1213 if (parent) 1214 nsim_node->parent_name = parent->name; 1215 else 1216 nsim_node->parent_name = NULL; 1217 return 0; 1218 } 1219 1220 static const struct devlink_ops nsim_dev_devlink_ops = { 1221 .eswitch_mode_set = nsim_devlink_eswitch_mode_set, 1222 .eswitch_mode_get = nsim_devlink_eswitch_mode_get, 1223 .supported_flash_update_params = DEVLINK_SUPPORT_FLASH_UPDATE_COMPONENT | 1224 DEVLINK_SUPPORT_FLASH_UPDATE_OVERWRITE_MASK, 1225 .reload_actions = BIT(DEVLINK_RELOAD_ACTION_DRIVER_REINIT), 1226 .reload_down = nsim_dev_reload_down, 1227 .reload_up = nsim_dev_reload_up, 1228 .info_get = nsim_dev_info_get, 1229 .flash_update = nsim_dev_flash_update, 1230 .trap_init = nsim_dev_devlink_trap_init, 1231 .trap_action_set = nsim_dev_devlink_trap_action_set, 1232 .trap_group_set = nsim_dev_devlink_trap_group_set, 1233 .trap_policer_set = nsim_dev_devlink_trap_policer_set, 1234 .trap_policer_counter_get = nsim_dev_devlink_trap_policer_counter_get, 1235 .rate_leaf_tx_share_set = nsim_leaf_tx_share_set, 1236 .rate_leaf_tx_max_set = nsim_leaf_tx_max_set, 1237 .rate_node_tx_share_set = nsim_node_tx_share_set, 1238 .rate_node_tx_max_set = nsim_node_tx_max_set, 1239 .rate_node_new = nsim_rate_node_new, 1240 .rate_node_del = nsim_rate_node_del, 1241 .rate_leaf_parent_set = nsim_rate_leaf_parent_set, 1242 .rate_node_parent_set = nsim_rate_node_parent_set, 1243 }; 1244 1245 #define NSIM_DEV_MAX_MACS_DEFAULT 32 1246 #define NSIM_DEV_TEST1_DEFAULT true 1247 1248 static int __nsim_dev_port_add(struct nsim_dev *nsim_dev, enum nsim_dev_port_type type, 1249 unsigned int port_index) 1250 { 1251 struct nsim_bus_dev *nsim_bus_dev = nsim_dev->nsim_bus_dev; 1252 struct devlink_port_attrs attrs = {}; 1253 struct nsim_dev_port *nsim_dev_port; 1254 struct devlink_port *devlink_port; 1255 int err; 1256 1257 if (type == NSIM_DEV_PORT_TYPE_VF && !nsim_bus_dev->num_vfs) 1258 return -EINVAL; 1259 1260 nsim_dev_port = kzalloc(sizeof(*nsim_dev_port), GFP_KERNEL); 1261 if (!nsim_dev_port) 1262 return -ENOMEM; 1263 nsim_dev_port->port_index = nsim_dev_port_index(type, port_index); 1264 nsim_dev_port->port_type = type; 1265 1266 devlink_port = &nsim_dev_port->devlink_port; 1267 if (nsim_dev_port_is_pf(nsim_dev_port)) { 1268 attrs.flavour = DEVLINK_PORT_FLAVOUR_PHYSICAL; 1269 attrs.phys.port_number = port_index + 1; 1270 } else { 1271 attrs.flavour = DEVLINK_PORT_FLAVOUR_PCI_VF; 1272 attrs.pci_vf.pf = 0; 1273 attrs.pci_vf.vf = port_index; 1274 } 1275 memcpy(attrs.switch_id.id, nsim_dev->switch_id.id, nsim_dev->switch_id.id_len); 1276 attrs.switch_id.id_len = nsim_dev->switch_id.id_len; 1277 devlink_port_attrs_set(devlink_port, &attrs); 1278 err = devlink_port_register(priv_to_devlink(nsim_dev), devlink_port, 1279 nsim_dev_port->port_index); 1280 if (err) 1281 goto err_port_free; 1282 1283 err = nsim_dev_port_debugfs_init(nsim_dev, nsim_dev_port); 1284 if (err) 1285 goto err_dl_port_unregister; 1286 1287 nsim_dev_port->ns = nsim_create(nsim_dev, nsim_dev_port); 1288 if (IS_ERR(nsim_dev_port->ns)) { 1289 err = PTR_ERR(nsim_dev_port->ns); 1290 goto err_port_debugfs_exit; 1291 } 1292 1293 if (nsim_dev_port_is_vf(nsim_dev_port)) { 1294 err = devlink_rate_leaf_create(&nsim_dev_port->devlink_port, 1295 nsim_dev_port); 1296 if (err) 1297 goto err_nsim_destroy; 1298 } 1299 1300 devlink_port_type_eth_set(devlink_port, nsim_dev_port->ns->netdev); 1301 list_add(&nsim_dev_port->list, &nsim_dev->port_list); 1302 1303 return 0; 1304 1305 err_nsim_destroy: 1306 nsim_destroy(nsim_dev_port->ns); 1307 err_port_debugfs_exit: 1308 nsim_dev_port_debugfs_exit(nsim_dev_port); 1309 err_dl_port_unregister: 1310 devlink_port_unregister(devlink_port); 1311 err_port_free: 1312 kfree(nsim_dev_port); 1313 return err; 1314 } 1315 1316 static void __nsim_dev_port_del(struct nsim_dev_port *nsim_dev_port) 1317 { 1318 struct devlink_port *devlink_port = &nsim_dev_port->devlink_port; 1319 1320 list_del(&nsim_dev_port->list); 1321 if (nsim_dev_port_is_vf(nsim_dev_port)) 1322 devlink_rate_leaf_destroy(&nsim_dev_port->devlink_port); 1323 devlink_port_type_clear(devlink_port); 1324 nsim_destroy(nsim_dev_port->ns); 1325 nsim_dev_port_debugfs_exit(nsim_dev_port); 1326 devlink_port_unregister(devlink_port); 1327 kfree(nsim_dev_port); 1328 } 1329 1330 static void nsim_dev_port_del_all(struct nsim_dev *nsim_dev) 1331 { 1332 struct nsim_dev_port *nsim_dev_port, *tmp; 1333 1334 mutex_lock(&nsim_dev->port_list_lock); 1335 list_for_each_entry_safe(nsim_dev_port, tmp, 1336 &nsim_dev->port_list, list) 1337 __nsim_dev_port_del(nsim_dev_port); 1338 mutex_unlock(&nsim_dev->port_list_lock); 1339 } 1340 1341 static int nsim_dev_port_add_all(struct nsim_dev *nsim_dev, 1342 unsigned int port_count) 1343 { 1344 int i, err; 1345 1346 for (i = 0; i < port_count; i++) { 1347 err = __nsim_dev_port_add(nsim_dev, NSIM_DEV_PORT_TYPE_PF, i); 1348 if (err) 1349 goto err_port_del_all; 1350 } 1351 return 0; 1352 1353 err_port_del_all: 1354 nsim_dev_port_del_all(nsim_dev); 1355 return err; 1356 } 1357 1358 static int nsim_dev_reload_create(struct nsim_dev *nsim_dev, 1359 struct netlink_ext_ack *extack) 1360 { 1361 struct nsim_bus_dev *nsim_bus_dev = nsim_dev->nsim_bus_dev; 1362 struct devlink *devlink; 1363 int err; 1364 1365 devlink = priv_to_devlink(nsim_dev); 1366 nsim_dev = devlink_priv(devlink); 1367 INIT_LIST_HEAD(&nsim_dev->port_list); 1368 mutex_init(&nsim_dev->port_list_lock); 1369 nsim_dev->fw_update_status = true; 1370 nsim_dev->fw_update_overwrite_mask = 0; 1371 1372 nsim_devlink_param_load_driverinit_values(devlink); 1373 1374 err = nsim_dev_dummy_region_init(nsim_dev, devlink); 1375 if (err) 1376 return err; 1377 1378 err = nsim_dev_traps_init(devlink); 1379 if (err) 1380 goto err_dummy_region_exit; 1381 1382 nsim_dev->fib_data = nsim_fib_create(devlink, extack); 1383 if (IS_ERR(nsim_dev->fib_data)) { 1384 err = PTR_ERR(nsim_dev->fib_data); 1385 goto err_traps_exit; 1386 } 1387 1388 err = nsim_dev_health_init(nsim_dev, devlink); 1389 if (err) 1390 goto err_fib_destroy; 1391 1392 err = nsim_dev_psample_init(nsim_dev); 1393 if (err) 1394 goto err_health_exit; 1395 1396 err = nsim_dev_port_add_all(nsim_dev, nsim_bus_dev->port_count); 1397 if (err) 1398 goto err_psample_exit; 1399 1400 nsim_dev->take_snapshot = debugfs_create_file("take_snapshot", 1401 0200, 1402 nsim_dev->ddir, 1403 nsim_dev, 1404 &nsim_dev_take_snapshot_fops); 1405 return 0; 1406 1407 err_psample_exit: 1408 nsim_dev_psample_exit(nsim_dev); 1409 err_health_exit: 1410 nsim_dev_health_exit(nsim_dev); 1411 err_fib_destroy: 1412 nsim_fib_destroy(devlink, nsim_dev->fib_data); 1413 err_traps_exit: 1414 nsim_dev_traps_exit(devlink); 1415 err_dummy_region_exit: 1416 nsim_dev_dummy_region_exit(nsim_dev); 1417 return err; 1418 } 1419 1420 int nsim_dev_probe(struct nsim_bus_dev *nsim_bus_dev) 1421 { 1422 struct nsim_dev *nsim_dev; 1423 struct devlink *devlink; 1424 int err; 1425 1426 devlink = devlink_alloc(&nsim_dev_devlink_ops, sizeof(*nsim_dev)); 1427 if (!devlink) 1428 return -ENOMEM; 1429 devlink_net_set(devlink, nsim_bus_dev->initial_net); 1430 nsim_dev = devlink_priv(devlink); 1431 nsim_dev->nsim_bus_dev = nsim_bus_dev; 1432 nsim_dev->switch_id.id_len = sizeof(nsim_dev->switch_id.id); 1433 get_random_bytes(nsim_dev->switch_id.id, nsim_dev->switch_id.id_len); 1434 INIT_LIST_HEAD(&nsim_dev->port_list); 1435 mutex_init(&nsim_dev->port_list_lock); 1436 nsim_dev->fw_update_status = true; 1437 nsim_dev->fw_update_overwrite_mask = 0; 1438 nsim_dev->max_macs = NSIM_DEV_MAX_MACS_DEFAULT; 1439 nsim_dev->test1 = NSIM_DEV_TEST1_DEFAULT; 1440 spin_lock_init(&nsim_dev->fa_cookie_lock); 1441 1442 dev_set_drvdata(&nsim_bus_dev->dev, nsim_dev); 1443 1444 err = nsim_dev_resources_register(devlink); 1445 if (err) 1446 goto err_devlink_free; 1447 1448 err = devlink_register(devlink, &nsim_bus_dev->dev); 1449 if (err) 1450 goto err_resources_unregister; 1451 1452 err = devlink_params_register(devlink, nsim_devlink_params, 1453 ARRAY_SIZE(nsim_devlink_params)); 1454 if (err) 1455 goto err_dl_unregister; 1456 nsim_devlink_set_params_init_values(nsim_dev, devlink); 1457 1458 err = nsim_dev_dummy_region_init(nsim_dev, devlink); 1459 if (err) 1460 goto err_params_unregister; 1461 1462 err = nsim_dev_traps_init(devlink); 1463 if (err) 1464 goto err_dummy_region_exit; 1465 1466 err = nsim_dev_debugfs_init(nsim_dev); 1467 if (err) 1468 goto err_traps_exit; 1469 1470 nsim_dev->fib_data = nsim_fib_create(devlink, NULL); 1471 if (IS_ERR(nsim_dev->fib_data)) { 1472 err = PTR_ERR(nsim_dev->fib_data); 1473 goto err_debugfs_exit; 1474 } 1475 1476 err = nsim_dev_health_init(nsim_dev, devlink); 1477 if (err) 1478 goto err_fib_destroy; 1479 1480 err = nsim_bpf_dev_init(nsim_dev); 1481 if (err) 1482 goto err_health_exit; 1483 1484 err = nsim_dev_psample_init(nsim_dev); 1485 if (err) 1486 goto err_bpf_dev_exit; 1487 1488 err = nsim_dev_port_add_all(nsim_dev, nsim_bus_dev->port_count); 1489 if (err) 1490 goto err_psample_exit; 1491 1492 devlink_params_publish(devlink); 1493 devlink_reload_enable(devlink); 1494 nsim_dev->esw_mode = DEVLINK_ESWITCH_MODE_LEGACY; 1495 return 0; 1496 1497 err_psample_exit: 1498 nsim_dev_psample_exit(nsim_dev); 1499 err_bpf_dev_exit: 1500 nsim_bpf_dev_exit(nsim_dev); 1501 err_health_exit: 1502 nsim_dev_health_exit(nsim_dev); 1503 err_fib_destroy: 1504 nsim_fib_destroy(devlink, nsim_dev->fib_data); 1505 err_debugfs_exit: 1506 nsim_dev_debugfs_exit(nsim_dev); 1507 err_traps_exit: 1508 nsim_dev_traps_exit(devlink); 1509 err_dummy_region_exit: 1510 nsim_dev_dummy_region_exit(nsim_dev); 1511 err_params_unregister: 1512 devlink_params_unregister(devlink, nsim_devlink_params, 1513 ARRAY_SIZE(nsim_devlink_params)); 1514 err_dl_unregister: 1515 devlink_unregister(devlink); 1516 err_resources_unregister: 1517 devlink_resources_unregister(devlink, NULL); 1518 err_devlink_free: 1519 devlink_free(devlink); 1520 return err; 1521 } 1522 1523 static void nsim_dev_reload_destroy(struct nsim_dev *nsim_dev) 1524 { 1525 struct devlink *devlink = priv_to_devlink(nsim_dev); 1526 1527 if (devlink_is_reload_failed(devlink)) 1528 return; 1529 debugfs_remove(nsim_dev->take_snapshot); 1530 1531 mutex_lock(&nsim_dev->nsim_bus_dev->vfs_lock); 1532 if (nsim_dev->nsim_bus_dev->num_vfs) 1533 nsim_bus_dev_vfs_disable(nsim_dev->nsim_bus_dev); 1534 mutex_unlock(&nsim_dev->nsim_bus_dev->vfs_lock); 1535 1536 nsim_dev_port_del_all(nsim_dev); 1537 nsim_dev_psample_exit(nsim_dev); 1538 nsim_dev_health_exit(nsim_dev); 1539 nsim_fib_destroy(devlink, nsim_dev->fib_data); 1540 nsim_dev_traps_exit(devlink); 1541 nsim_dev_dummy_region_exit(nsim_dev); 1542 mutex_destroy(&nsim_dev->port_list_lock); 1543 } 1544 1545 void nsim_dev_remove(struct nsim_bus_dev *nsim_bus_dev) 1546 { 1547 struct nsim_dev *nsim_dev = dev_get_drvdata(&nsim_bus_dev->dev); 1548 struct devlink *devlink = priv_to_devlink(nsim_dev); 1549 1550 devlink_reload_disable(devlink); 1551 1552 nsim_dev_reload_destroy(nsim_dev); 1553 1554 nsim_bpf_dev_exit(nsim_dev); 1555 nsim_dev_debugfs_exit(nsim_dev); 1556 devlink_params_unregister(devlink, nsim_devlink_params, 1557 ARRAY_SIZE(nsim_devlink_params)); 1558 devlink_unregister(devlink); 1559 devlink_resources_unregister(devlink, NULL); 1560 devlink_free(devlink); 1561 } 1562 1563 static struct nsim_dev_port * 1564 __nsim_dev_port_lookup(struct nsim_dev *nsim_dev, enum nsim_dev_port_type type, 1565 unsigned int port_index) 1566 { 1567 struct nsim_dev_port *nsim_dev_port; 1568 1569 port_index = nsim_dev_port_index(type, port_index); 1570 list_for_each_entry(nsim_dev_port, &nsim_dev->port_list, list) 1571 if (nsim_dev_port->port_index == port_index) 1572 return nsim_dev_port; 1573 return NULL; 1574 } 1575 1576 int nsim_dev_port_add(struct nsim_bus_dev *nsim_bus_dev, enum nsim_dev_port_type type, 1577 unsigned int port_index) 1578 { 1579 struct nsim_dev *nsim_dev = dev_get_drvdata(&nsim_bus_dev->dev); 1580 int err; 1581 1582 mutex_lock(&nsim_dev->port_list_lock); 1583 if (__nsim_dev_port_lookup(nsim_dev, type, port_index)) 1584 err = -EEXIST; 1585 else 1586 err = __nsim_dev_port_add(nsim_dev, type, port_index); 1587 mutex_unlock(&nsim_dev->port_list_lock); 1588 return err; 1589 } 1590 1591 int nsim_dev_port_del(struct nsim_bus_dev *nsim_bus_dev, enum nsim_dev_port_type type, 1592 unsigned int port_index) 1593 { 1594 struct nsim_dev *nsim_dev = dev_get_drvdata(&nsim_bus_dev->dev); 1595 struct nsim_dev_port *nsim_dev_port; 1596 int err = 0; 1597 1598 mutex_lock(&nsim_dev->port_list_lock); 1599 nsim_dev_port = __nsim_dev_port_lookup(nsim_dev, type, port_index); 1600 if (!nsim_dev_port) 1601 err = -ENOENT; 1602 else 1603 __nsim_dev_port_del(nsim_dev_port); 1604 mutex_unlock(&nsim_dev->port_list_lock); 1605 return err; 1606 } 1607 1608 int nsim_dev_init(void) 1609 { 1610 nsim_dev_ddir = debugfs_create_dir(DRV_NAME, NULL); 1611 return PTR_ERR_OR_ZERO(nsim_dev_ddir); 1612 } 1613 1614 void nsim_dev_exit(void) 1615 { 1616 debugfs_remove_recursive(nsim_dev_ddir); 1617 } 1618