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