1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * net/switchdev/switchdev.c - Switch device API 4 * Copyright (c) 2014-2015 Jiri Pirko <jiri@resnulli.us> 5 * Copyright (c) 2014-2015 Scott Feldman <sfeldma@gmail.com> 6 */ 7 8 #include <linux/kernel.h> 9 #include <linux/types.h> 10 #include <linux/init.h> 11 #include <linux/mutex.h> 12 #include <linux/notifier.h> 13 #include <linux/netdevice.h> 14 #include <linux/etherdevice.h> 15 #include <linux/if_bridge.h> 16 #include <linux/list.h> 17 #include <linux/workqueue.h> 18 #include <linux/if_vlan.h> 19 #include <linux/rtnetlink.h> 20 #include <net/switchdev.h> 21 22 static bool switchdev_obj_eq(const struct switchdev_obj *a, 23 const struct switchdev_obj *b) 24 { 25 const struct switchdev_obj_port_vlan *va, *vb; 26 const struct switchdev_obj_port_mdb *ma, *mb; 27 28 if (a->id != b->id || a->orig_dev != b->orig_dev) 29 return false; 30 31 switch (a->id) { 32 case SWITCHDEV_OBJ_ID_PORT_VLAN: 33 va = SWITCHDEV_OBJ_PORT_VLAN(a); 34 vb = SWITCHDEV_OBJ_PORT_VLAN(b); 35 return va->flags == vb->flags && 36 va->vid == vb->vid && 37 va->changed == vb->changed; 38 case SWITCHDEV_OBJ_ID_PORT_MDB: 39 case SWITCHDEV_OBJ_ID_HOST_MDB: 40 ma = SWITCHDEV_OBJ_PORT_MDB(a); 41 mb = SWITCHDEV_OBJ_PORT_MDB(b); 42 return ma->vid == mb->vid && 43 ether_addr_equal(ma->addr, mb->addr); 44 default: 45 break; 46 } 47 48 BUG(); 49 } 50 51 static LIST_HEAD(deferred); 52 static DEFINE_SPINLOCK(deferred_lock); 53 54 typedef void switchdev_deferred_func_t(struct net_device *dev, 55 const void *data); 56 57 struct switchdev_deferred_item { 58 struct list_head list; 59 struct net_device *dev; 60 netdevice_tracker dev_tracker; 61 switchdev_deferred_func_t *func; 62 unsigned long data[]; 63 }; 64 65 static struct switchdev_deferred_item *switchdev_deferred_dequeue(void) 66 { 67 struct switchdev_deferred_item *dfitem; 68 69 spin_lock_bh(&deferred_lock); 70 if (list_empty(&deferred)) { 71 dfitem = NULL; 72 goto unlock; 73 } 74 dfitem = list_first_entry(&deferred, 75 struct switchdev_deferred_item, list); 76 list_del(&dfitem->list); 77 unlock: 78 spin_unlock_bh(&deferred_lock); 79 return dfitem; 80 } 81 82 /** 83 * switchdev_deferred_process - Process ops in deferred queue 84 * 85 * Called to flush the ops currently queued in deferred ops queue. 86 * rtnl_lock must be held. 87 */ 88 void switchdev_deferred_process(void) 89 { 90 struct switchdev_deferred_item *dfitem; 91 92 ASSERT_RTNL(); 93 94 while ((dfitem = switchdev_deferred_dequeue())) { 95 dfitem->func(dfitem->dev, dfitem->data); 96 netdev_put(dfitem->dev, &dfitem->dev_tracker); 97 kfree(dfitem); 98 } 99 } 100 EXPORT_SYMBOL_GPL(switchdev_deferred_process); 101 102 static void switchdev_deferred_process_work(struct work_struct *work) 103 { 104 rtnl_lock(); 105 switchdev_deferred_process(); 106 rtnl_unlock(); 107 } 108 109 static DECLARE_WORK(deferred_process_work, switchdev_deferred_process_work); 110 111 static int switchdev_deferred_enqueue(struct net_device *dev, 112 const void *data, size_t data_len, 113 switchdev_deferred_func_t *func) 114 { 115 struct switchdev_deferred_item *dfitem; 116 117 dfitem = kmalloc(struct_size(dfitem, data, data_len), GFP_ATOMIC); 118 if (!dfitem) 119 return -ENOMEM; 120 dfitem->dev = dev; 121 dfitem->func = func; 122 memcpy(dfitem->data, data, data_len); 123 netdev_hold(dev, &dfitem->dev_tracker, GFP_ATOMIC); 124 spin_lock_bh(&deferred_lock); 125 list_add_tail(&dfitem->list, &deferred); 126 spin_unlock_bh(&deferred_lock); 127 schedule_work(&deferred_process_work); 128 return 0; 129 } 130 131 static int switchdev_port_attr_notify(enum switchdev_notifier_type nt, 132 struct net_device *dev, 133 const struct switchdev_attr *attr, 134 struct netlink_ext_ack *extack) 135 { 136 int err; 137 int rc; 138 139 struct switchdev_notifier_port_attr_info attr_info = { 140 .attr = attr, 141 .handled = false, 142 }; 143 144 rc = call_switchdev_blocking_notifiers(nt, dev, 145 &attr_info.info, extack); 146 err = notifier_to_errno(rc); 147 if (err) { 148 WARN_ON(!attr_info.handled); 149 return err; 150 } 151 152 if (!attr_info.handled) 153 return -EOPNOTSUPP; 154 155 return 0; 156 } 157 158 static int switchdev_port_attr_set_now(struct net_device *dev, 159 const struct switchdev_attr *attr, 160 struct netlink_ext_ack *extack) 161 { 162 return switchdev_port_attr_notify(SWITCHDEV_PORT_ATTR_SET, dev, attr, 163 extack); 164 } 165 166 static void switchdev_port_attr_set_deferred(struct net_device *dev, 167 const void *data) 168 { 169 const struct switchdev_attr *attr = data; 170 int err; 171 172 err = switchdev_port_attr_set_now(dev, attr, NULL); 173 if (err && err != -EOPNOTSUPP) 174 netdev_err(dev, "failed (err=%d) to set attribute (id=%d)\n", 175 err, attr->id); 176 if (attr->complete) 177 attr->complete(dev, err, attr->complete_priv); 178 } 179 180 static int switchdev_port_attr_set_defer(struct net_device *dev, 181 const struct switchdev_attr *attr) 182 { 183 return switchdev_deferred_enqueue(dev, attr, sizeof(*attr), 184 switchdev_port_attr_set_deferred); 185 } 186 187 /** 188 * switchdev_port_attr_set - Set port attribute 189 * 190 * @dev: port device 191 * @attr: attribute to set 192 * @extack: netlink extended ack, for error message propagation 193 * 194 * rtnl_lock must be held and must not be in atomic section, 195 * in case SWITCHDEV_F_DEFER flag is not set. 196 */ 197 int switchdev_port_attr_set(struct net_device *dev, 198 const struct switchdev_attr *attr, 199 struct netlink_ext_ack *extack) 200 { 201 if (attr->flags & SWITCHDEV_F_DEFER) 202 return switchdev_port_attr_set_defer(dev, attr); 203 ASSERT_RTNL(); 204 return switchdev_port_attr_set_now(dev, attr, extack); 205 } 206 EXPORT_SYMBOL_GPL(switchdev_port_attr_set); 207 208 static size_t switchdev_obj_size(const struct switchdev_obj *obj) 209 { 210 switch (obj->id) { 211 case SWITCHDEV_OBJ_ID_PORT_VLAN: 212 return sizeof(struct switchdev_obj_port_vlan); 213 case SWITCHDEV_OBJ_ID_PORT_MDB: 214 return sizeof(struct switchdev_obj_port_mdb); 215 case SWITCHDEV_OBJ_ID_HOST_MDB: 216 return sizeof(struct switchdev_obj_port_mdb); 217 default: 218 BUG(); 219 } 220 return 0; 221 } 222 223 static int switchdev_port_obj_notify(enum switchdev_notifier_type nt, 224 struct net_device *dev, 225 const struct switchdev_obj *obj, 226 struct netlink_ext_ack *extack) 227 { 228 int rc; 229 int err; 230 231 struct switchdev_notifier_port_obj_info obj_info = { 232 .obj = obj, 233 .handled = false, 234 }; 235 236 rc = call_switchdev_blocking_notifiers(nt, dev, &obj_info.info, extack); 237 err = notifier_to_errno(rc); 238 if (err) { 239 WARN_ON(!obj_info.handled); 240 return err; 241 } 242 if (!obj_info.handled) 243 return -EOPNOTSUPP; 244 return 0; 245 } 246 247 static void switchdev_obj_id_to_helpful_msg(struct net_device *dev, 248 enum switchdev_obj_id obj_id, 249 int err, bool add) 250 { 251 const char *action = add ? "add" : "del"; 252 const char *reason = ""; 253 const char *problem; 254 const char *obj_str; 255 256 switch (obj_id) { 257 case SWITCHDEV_OBJ_ID_UNDEFINED: 258 obj_str = "Undefined object"; 259 problem = "Attempted operation is undefined, indicating a possible programming\n" 260 "error.\n"; 261 break; 262 case SWITCHDEV_OBJ_ID_PORT_VLAN: 263 obj_str = "VLAN entry"; 264 problem = "Failure in VLAN settings on this port might disrupt network\n" 265 "segmentation or traffic isolation, affecting network partitioning.\n"; 266 break; 267 case SWITCHDEV_OBJ_ID_PORT_MDB: 268 obj_str = "Port Multicast Database entry"; 269 problem = "Failure in updating the port's Multicast Database could lead to\n" 270 "multicast forwarding issues.\n"; 271 break; 272 case SWITCHDEV_OBJ_ID_HOST_MDB: 273 obj_str = "Host Multicast Database entry"; 274 problem = "Failure in updating the host's Multicast Database may impact multicast\n" 275 "group memberships or traffic delivery, affecting multicast\n" 276 "communication.\n"; 277 break; 278 case SWITCHDEV_OBJ_ID_MRP: 279 obj_str = "Media Redundancy Protocol configuration for port"; 280 problem = "Failure to set MRP ring ID on this port prevents communication with\n" 281 "the specified redundancy ring, resulting in an inability to engage\n" 282 "in MRP-based network operations.\n"; 283 break; 284 case SWITCHDEV_OBJ_ID_RING_TEST_MRP: 285 obj_str = "MRP Test Frame Operations for port"; 286 problem = "Failure to generate/monitor MRP test frames may lead to inability to\n" 287 "assess the ring's operational integrity and fault response, hindering\n" 288 "proactive network management.\n"; 289 break; 290 case SWITCHDEV_OBJ_ID_RING_ROLE_MRP: 291 obj_str = "MRP Ring Role Configuration"; 292 problem = "Improper MRP ring role configuration may create conflicts in the ring,\n" 293 "disrupting communication for all participants, or isolate the local\n" 294 "system from the ring, hindering its ability to communicate with other\n" 295 "participants.\n"; 296 break; 297 case SWITCHDEV_OBJ_ID_RING_STATE_MRP: 298 obj_str = "MRP Ring State Configuration"; 299 problem = "Failure to correctly set the MRP ring state can result in network\n" 300 "loops or leave segments without communication. In a Closed state,\n" 301 "it maintains loop prevention by blocking one MRM port, while an Open\n" 302 "state activates in response to failures, changing port states to\n" 303 "preserve network connectivity.\n"; 304 break; 305 case SWITCHDEV_OBJ_ID_IN_TEST_MRP: 306 obj_str = "MRP_InTest Frame Generation Configuration"; 307 problem = "Failure in managing MRP_InTest frame generation can misjudge the\n" 308 "interconnection ring's state, leading to incorrect blocking or\n" 309 "unblocking of the I/C port. This misconfiguration might result\n" 310 "in unintended network loops or isolate critical network segments,\n" 311 "compromising network integrity and reliability.\n"; 312 break; 313 case SWITCHDEV_OBJ_ID_IN_ROLE_MRP: 314 obj_str = "Interconnection Ring Role Configuration"; 315 problem = "Failure in incorrect assignment of interconnection ring roles\n" 316 "(MIM/MIC) can impair the formation of the interconnection rings.\n"; 317 break; 318 case SWITCHDEV_OBJ_ID_IN_STATE_MRP: 319 obj_str = "Interconnection Ring State Configuration"; 320 problem = "Failure in updating the interconnection ring state can lead in\n" 321 "case of Open state to incorrect blocking or unblocking of the\n" 322 "I/C port, resulting in unintended network loops or isolation\n" 323 "of critical network\n"; 324 break; 325 default: 326 obj_str = "Unknown object"; 327 problem = "Indicating a possible programming error.\n"; 328 } 329 330 switch (err) { 331 case -ENOSPC: 332 reason = "Current HW/SW setup lacks sufficient resources.\n"; 333 break; 334 } 335 336 netdev_err(dev, "Failed to %s %s (object id=%d) with error: %pe (%d).\n%s%s\n", 337 action, obj_str, obj_id, ERR_PTR(err), err, problem, reason); 338 } 339 340 static void switchdev_port_obj_add_deferred(struct net_device *dev, 341 const void *data) 342 { 343 const struct switchdev_obj *obj = data; 344 int err; 345 346 ASSERT_RTNL(); 347 err = switchdev_port_obj_notify(SWITCHDEV_PORT_OBJ_ADD, 348 dev, obj, NULL); 349 if (err && err != -EOPNOTSUPP) 350 switchdev_obj_id_to_helpful_msg(dev, obj->id, err, true); 351 if (obj->complete) 352 obj->complete(dev, err, obj->complete_priv); 353 } 354 355 static int switchdev_port_obj_add_defer(struct net_device *dev, 356 const struct switchdev_obj *obj) 357 { 358 return switchdev_deferred_enqueue(dev, obj, switchdev_obj_size(obj), 359 switchdev_port_obj_add_deferred); 360 } 361 362 /** 363 * switchdev_port_obj_add - Add port object 364 * 365 * @dev: port device 366 * @obj: object to add 367 * @extack: netlink extended ack 368 * 369 * rtnl_lock must be held and must not be in atomic section, 370 * in case SWITCHDEV_F_DEFER flag is not set. 371 */ 372 int switchdev_port_obj_add(struct net_device *dev, 373 const struct switchdev_obj *obj, 374 struct netlink_ext_ack *extack) 375 { 376 if (obj->flags & SWITCHDEV_F_DEFER) 377 return switchdev_port_obj_add_defer(dev, obj); 378 ASSERT_RTNL(); 379 return switchdev_port_obj_notify(SWITCHDEV_PORT_OBJ_ADD, 380 dev, obj, extack); 381 } 382 EXPORT_SYMBOL_GPL(switchdev_port_obj_add); 383 384 static int switchdev_port_obj_del_now(struct net_device *dev, 385 const struct switchdev_obj *obj) 386 { 387 return switchdev_port_obj_notify(SWITCHDEV_PORT_OBJ_DEL, 388 dev, obj, NULL); 389 } 390 391 static void switchdev_port_obj_del_deferred(struct net_device *dev, 392 const void *data) 393 { 394 const struct switchdev_obj *obj = data; 395 int err; 396 397 err = switchdev_port_obj_del_now(dev, obj); 398 if (err && err != -EOPNOTSUPP) 399 switchdev_obj_id_to_helpful_msg(dev, obj->id, err, false); 400 if (obj->complete) 401 obj->complete(dev, err, obj->complete_priv); 402 } 403 404 static int switchdev_port_obj_del_defer(struct net_device *dev, 405 const struct switchdev_obj *obj) 406 { 407 return switchdev_deferred_enqueue(dev, obj, switchdev_obj_size(obj), 408 switchdev_port_obj_del_deferred); 409 } 410 411 /** 412 * switchdev_port_obj_del - Delete port object 413 * 414 * @dev: port device 415 * @obj: object to delete 416 * 417 * rtnl_lock must be held and must not be in atomic section, 418 * in case SWITCHDEV_F_DEFER flag is not set. 419 */ 420 int switchdev_port_obj_del(struct net_device *dev, 421 const struct switchdev_obj *obj) 422 { 423 if (obj->flags & SWITCHDEV_F_DEFER) 424 return switchdev_port_obj_del_defer(dev, obj); 425 ASSERT_RTNL(); 426 return switchdev_port_obj_del_now(dev, obj); 427 } 428 EXPORT_SYMBOL_GPL(switchdev_port_obj_del); 429 430 /** 431 * switchdev_port_obj_act_is_deferred - Is object action pending? 432 * 433 * @dev: port device 434 * @nt: type of action; add or delete 435 * @obj: object to test 436 * 437 * Returns true if a deferred item is pending, which is 438 * equivalent to the action @nt on an object @obj. 439 * 440 * rtnl_lock must be held. 441 */ 442 bool switchdev_port_obj_act_is_deferred(struct net_device *dev, 443 enum switchdev_notifier_type nt, 444 const struct switchdev_obj *obj) 445 { 446 struct switchdev_deferred_item *dfitem; 447 bool found = false; 448 449 ASSERT_RTNL(); 450 451 spin_lock_bh(&deferred_lock); 452 453 list_for_each_entry(dfitem, &deferred, list) { 454 if (dfitem->dev != dev) 455 continue; 456 457 if ((dfitem->func == switchdev_port_obj_add_deferred && 458 nt == SWITCHDEV_PORT_OBJ_ADD) || 459 (dfitem->func == switchdev_port_obj_del_deferred && 460 nt == SWITCHDEV_PORT_OBJ_DEL)) { 461 if (switchdev_obj_eq((const void *)dfitem->data, obj)) { 462 found = true; 463 break; 464 } 465 } 466 } 467 468 spin_unlock_bh(&deferred_lock); 469 470 return found; 471 } 472 EXPORT_SYMBOL_GPL(switchdev_port_obj_act_is_deferred); 473 474 static ATOMIC_NOTIFIER_HEAD(switchdev_notif_chain); 475 static BLOCKING_NOTIFIER_HEAD(switchdev_blocking_notif_chain); 476 477 /** 478 * register_switchdev_notifier - Register notifier 479 * @nb: notifier_block 480 * 481 * Register switch device notifier. 482 */ 483 int register_switchdev_notifier(struct notifier_block *nb) 484 { 485 return atomic_notifier_chain_register(&switchdev_notif_chain, nb); 486 } 487 EXPORT_SYMBOL_GPL(register_switchdev_notifier); 488 489 /** 490 * unregister_switchdev_notifier - Unregister notifier 491 * @nb: notifier_block 492 * 493 * Unregister switch device notifier. 494 */ 495 int unregister_switchdev_notifier(struct notifier_block *nb) 496 { 497 return atomic_notifier_chain_unregister(&switchdev_notif_chain, nb); 498 } 499 EXPORT_SYMBOL_GPL(unregister_switchdev_notifier); 500 501 /** 502 * call_switchdev_notifiers - Call notifiers 503 * @val: value passed unmodified to notifier function 504 * @dev: port device 505 * @info: notifier information data 506 * @extack: netlink extended ack 507 * Call all network notifier blocks. 508 */ 509 int call_switchdev_notifiers(unsigned long val, struct net_device *dev, 510 struct switchdev_notifier_info *info, 511 struct netlink_ext_ack *extack) 512 { 513 info->dev = dev; 514 info->extack = extack; 515 return atomic_notifier_call_chain(&switchdev_notif_chain, val, info); 516 } 517 EXPORT_SYMBOL_GPL(call_switchdev_notifiers); 518 519 int register_switchdev_blocking_notifier(struct notifier_block *nb) 520 { 521 struct blocking_notifier_head *chain = &switchdev_blocking_notif_chain; 522 523 return blocking_notifier_chain_register(chain, nb); 524 } 525 EXPORT_SYMBOL_GPL(register_switchdev_blocking_notifier); 526 527 int unregister_switchdev_blocking_notifier(struct notifier_block *nb) 528 { 529 struct blocking_notifier_head *chain = &switchdev_blocking_notif_chain; 530 531 return blocking_notifier_chain_unregister(chain, nb); 532 } 533 EXPORT_SYMBOL_GPL(unregister_switchdev_blocking_notifier); 534 535 int call_switchdev_blocking_notifiers(unsigned long val, struct net_device *dev, 536 struct switchdev_notifier_info *info, 537 struct netlink_ext_ack *extack) 538 { 539 info->dev = dev; 540 info->extack = extack; 541 return blocking_notifier_call_chain(&switchdev_blocking_notif_chain, 542 val, info); 543 } 544 EXPORT_SYMBOL_GPL(call_switchdev_blocking_notifiers); 545 546 struct switchdev_nested_priv { 547 bool (*check_cb)(const struct net_device *dev); 548 bool (*foreign_dev_check_cb)(const struct net_device *dev, 549 const struct net_device *foreign_dev); 550 const struct net_device *dev; 551 struct net_device *lower_dev; 552 }; 553 554 static int switchdev_lower_dev_walk(struct net_device *lower_dev, 555 struct netdev_nested_priv *priv) 556 { 557 struct switchdev_nested_priv *switchdev_priv = priv->data; 558 bool (*foreign_dev_check_cb)(const struct net_device *dev, 559 const struct net_device *foreign_dev); 560 bool (*check_cb)(const struct net_device *dev); 561 const struct net_device *dev; 562 563 check_cb = switchdev_priv->check_cb; 564 foreign_dev_check_cb = switchdev_priv->foreign_dev_check_cb; 565 dev = switchdev_priv->dev; 566 567 if (check_cb(lower_dev) && !foreign_dev_check_cb(lower_dev, dev)) { 568 switchdev_priv->lower_dev = lower_dev; 569 return 1; 570 } 571 572 return 0; 573 } 574 575 static struct net_device * 576 switchdev_lower_dev_find_rcu(struct net_device *dev, 577 bool (*check_cb)(const struct net_device *dev), 578 bool (*foreign_dev_check_cb)(const struct net_device *dev, 579 const struct net_device *foreign_dev)) 580 { 581 struct switchdev_nested_priv switchdev_priv = { 582 .check_cb = check_cb, 583 .foreign_dev_check_cb = foreign_dev_check_cb, 584 .dev = dev, 585 .lower_dev = NULL, 586 }; 587 struct netdev_nested_priv priv = { 588 .data = &switchdev_priv, 589 }; 590 591 netdev_walk_all_lower_dev_rcu(dev, switchdev_lower_dev_walk, &priv); 592 593 return switchdev_priv.lower_dev; 594 } 595 596 static struct net_device * 597 switchdev_lower_dev_find(struct net_device *dev, 598 bool (*check_cb)(const struct net_device *dev), 599 bool (*foreign_dev_check_cb)(const struct net_device *dev, 600 const struct net_device *foreign_dev)) 601 { 602 struct switchdev_nested_priv switchdev_priv = { 603 .check_cb = check_cb, 604 .foreign_dev_check_cb = foreign_dev_check_cb, 605 .dev = dev, 606 .lower_dev = NULL, 607 }; 608 struct netdev_nested_priv priv = { 609 .data = &switchdev_priv, 610 }; 611 612 netdev_walk_all_lower_dev(dev, switchdev_lower_dev_walk, &priv); 613 614 return switchdev_priv.lower_dev; 615 } 616 617 static int __switchdev_handle_fdb_event_to_device(struct net_device *dev, 618 struct net_device *orig_dev, unsigned long event, 619 const struct switchdev_notifier_fdb_info *fdb_info, 620 bool (*check_cb)(const struct net_device *dev), 621 bool (*foreign_dev_check_cb)(const struct net_device *dev, 622 const struct net_device *foreign_dev), 623 int (*mod_cb)(struct net_device *dev, struct net_device *orig_dev, 624 unsigned long event, const void *ctx, 625 const struct switchdev_notifier_fdb_info *fdb_info)) 626 { 627 const struct switchdev_notifier_info *info = &fdb_info->info; 628 struct net_device *br, *lower_dev, *switchdev; 629 struct list_head *iter; 630 int err = -EOPNOTSUPP; 631 632 if (check_cb(dev)) 633 return mod_cb(dev, orig_dev, event, info->ctx, fdb_info); 634 635 /* Recurse through lower interfaces in case the FDB entry is pointing 636 * towards a bridge or a LAG device. 637 */ 638 netdev_for_each_lower_dev(dev, lower_dev, iter) { 639 /* Do not propagate FDB entries across bridges */ 640 if (netif_is_bridge_master(lower_dev)) 641 continue; 642 643 /* Bridge ports might be either us, or LAG interfaces 644 * that we offload. 645 */ 646 if (!check_cb(lower_dev) && 647 !switchdev_lower_dev_find_rcu(lower_dev, check_cb, 648 foreign_dev_check_cb)) 649 continue; 650 651 err = __switchdev_handle_fdb_event_to_device(lower_dev, orig_dev, 652 event, fdb_info, check_cb, 653 foreign_dev_check_cb, 654 mod_cb); 655 if (err && err != -EOPNOTSUPP) 656 return err; 657 } 658 659 /* Event is neither on a bridge nor a LAG. Check whether it is on an 660 * interface that is in a bridge with us. 661 */ 662 br = netdev_master_upper_dev_get_rcu(dev); 663 if (!br || !netif_is_bridge_master(br)) 664 return 0; 665 666 switchdev = switchdev_lower_dev_find_rcu(br, check_cb, foreign_dev_check_cb); 667 if (!switchdev) 668 return 0; 669 670 if (!foreign_dev_check_cb(switchdev, dev)) 671 return err; 672 673 return __switchdev_handle_fdb_event_to_device(br, orig_dev, event, fdb_info, 674 check_cb, foreign_dev_check_cb, 675 mod_cb); 676 } 677 678 int switchdev_handle_fdb_event_to_device(struct net_device *dev, unsigned long event, 679 const struct switchdev_notifier_fdb_info *fdb_info, 680 bool (*check_cb)(const struct net_device *dev), 681 bool (*foreign_dev_check_cb)(const struct net_device *dev, 682 const struct net_device *foreign_dev), 683 int (*mod_cb)(struct net_device *dev, struct net_device *orig_dev, 684 unsigned long event, const void *ctx, 685 const struct switchdev_notifier_fdb_info *fdb_info)) 686 { 687 int err; 688 689 err = __switchdev_handle_fdb_event_to_device(dev, dev, event, fdb_info, 690 check_cb, foreign_dev_check_cb, 691 mod_cb); 692 if (err == -EOPNOTSUPP) 693 err = 0; 694 695 return err; 696 } 697 EXPORT_SYMBOL_GPL(switchdev_handle_fdb_event_to_device); 698 699 static int __switchdev_handle_port_obj_add(struct net_device *dev, 700 struct switchdev_notifier_port_obj_info *port_obj_info, 701 bool (*check_cb)(const struct net_device *dev), 702 bool (*foreign_dev_check_cb)(const struct net_device *dev, 703 const struct net_device *foreign_dev), 704 int (*add_cb)(struct net_device *dev, const void *ctx, 705 const struct switchdev_obj *obj, 706 struct netlink_ext_ack *extack)) 707 { 708 struct switchdev_notifier_info *info = &port_obj_info->info; 709 struct net_device *br, *lower_dev, *switchdev; 710 struct netlink_ext_ack *extack; 711 struct list_head *iter; 712 int err = -EOPNOTSUPP; 713 714 extack = switchdev_notifier_info_to_extack(info); 715 716 if (check_cb(dev)) { 717 err = add_cb(dev, info->ctx, port_obj_info->obj, extack); 718 if (err != -EOPNOTSUPP) 719 port_obj_info->handled = true; 720 return err; 721 } 722 723 /* Switch ports might be stacked under e.g. a LAG. Ignore the 724 * unsupported devices, another driver might be able to handle them. But 725 * propagate to the callers any hard errors. 726 * 727 * If the driver does its own bookkeeping of stacked ports, it's not 728 * necessary to go through this helper. 729 */ 730 netdev_for_each_lower_dev(dev, lower_dev, iter) { 731 if (netif_is_bridge_master(lower_dev)) 732 continue; 733 734 /* When searching for switchdev interfaces that are neighbors 735 * of foreign ones, and @dev is a bridge, do not recurse on the 736 * foreign interface again, it was already visited. 737 */ 738 if (foreign_dev_check_cb && !check_cb(lower_dev) && 739 !switchdev_lower_dev_find(lower_dev, check_cb, foreign_dev_check_cb)) 740 continue; 741 742 err = __switchdev_handle_port_obj_add(lower_dev, port_obj_info, 743 check_cb, foreign_dev_check_cb, 744 add_cb); 745 if (err && err != -EOPNOTSUPP) 746 return err; 747 } 748 749 /* Event is neither on a bridge nor a LAG. Check whether it is on an 750 * interface that is in a bridge with us. 751 */ 752 if (!foreign_dev_check_cb) 753 return err; 754 755 br = netdev_master_upper_dev_get(dev); 756 if (!br || !netif_is_bridge_master(br)) 757 return err; 758 759 switchdev = switchdev_lower_dev_find(br, check_cb, foreign_dev_check_cb); 760 if (!switchdev) 761 return err; 762 763 if (!foreign_dev_check_cb(switchdev, dev)) 764 return err; 765 766 return __switchdev_handle_port_obj_add(br, port_obj_info, check_cb, 767 foreign_dev_check_cb, add_cb); 768 } 769 770 /* Pass through a port object addition, if @dev passes @check_cb, or replicate 771 * it towards all lower interfaces of @dev that pass @check_cb, if @dev is a 772 * bridge or a LAG. 773 */ 774 int switchdev_handle_port_obj_add(struct net_device *dev, 775 struct switchdev_notifier_port_obj_info *port_obj_info, 776 bool (*check_cb)(const struct net_device *dev), 777 int (*add_cb)(struct net_device *dev, const void *ctx, 778 const struct switchdev_obj *obj, 779 struct netlink_ext_ack *extack)) 780 { 781 int err; 782 783 err = __switchdev_handle_port_obj_add(dev, port_obj_info, check_cb, 784 NULL, add_cb); 785 if (err == -EOPNOTSUPP) 786 err = 0; 787 return err; 788 } 789 EXPORT_SYMBOL_GPL(switchdev_handle_port_obj_add); 790 791 /* Same as switchdev_handle_port_obj_add(), except if object is notified on a 792 * @dev that passes @foreign_dev_check_cb, it is replicated towards all devices 793 * that pass @check_cb and are in the same bridge as @dev. 794 */ 795 int switchdev_handle_port_obj_add_foreign(struct net_device *dev, 796 struct switchdev_notifier_port_obj_info *port_obj_info, 797 bool (*check_cb)(const struct net_device *dev), 798 bool (*foreign_dev_check_cb)(const struct net_device *dev, 799 const struct net_device *foreign_dev), 800 int (*add_cb)(struct net_device *dev, const void *ctx, 801 const struct switchdev_obj *obj, 802 struct netlink_ext_ack *extack)) 803 { 804 int err; 805 806 err = __switchdev_handle_port_obj_add(dev, port_obj_info, check_cb, 807 foreign_dev_check_cb, add_cb); 808 if (err == -EOPNOTSUPP) 809 err = 0; 810 return err; 811 } 812 EXPORT_SYMBOL_GPL(switchdev_handle_port_obj_add_foreign); 813 814 static int __switchdev_handle_port_obj_del(struct net_device *dev, 815 struct switchdev_notifier_port_obj_info *port_obj_info, 816 bool (*check_cb)(const struct net_device *dev), 817 bool (*foreign_dev_check_cb)(const struct net_device *dev, 818 const struct net_device *foreign_dev), 819 int (*del_cb)(struct net_device *dev, const void *ctx, 820 const struct switchdev_obj *obj)) 821 { 822 struct switchdev_notifier_info *info = &port_obj_info->info; 823 struct net_device *br, *lower_dev, *switchdev; 824 struct list_head *iter; 825 int err = -EOPNOTSUPP; 826 827 if (check_cb(dev)) { 828 err = del_cb(dev, info->ctx, port_obj_info->obj); 829 if (err != -EOPNOTSUPP) 830 port_obj_info->handled = true; 831 return err; 832 } 833 834 /* Switch ports might be stacked under e.g. a LAG. Ignore the 835 * unsupported devices, another driver might be able to handle them. But 836 * propagate to the callers any hard errors. 837 * 838 * If the driver does its own bookkeeping of stacked ports, it's not 839 * necessary to go through this helper. 840 */ 841 netdev_for_each_lower_dev(dev, lower_dev, iter) { 842 if (netif_is_bridge_master(lower_dev)) 843 continue; 844 845 /* When searching for switchdev interfaces that are neighbors 846 * of foreign ones, and @dev is a bridge, do not recurse on the 847 * foreign interface again, it was already visited. 848 */ 849 if (foreign_dev_check_cb && !check_cb(lower_dev) && 850 !switchdev_lower_dev_find(lower_dev, check_cb, foreign_dev_check_cb)) 851 continue; 852 853 err = __switchdev_handle_port_obj_del(lower_dev, port_obj_info, 854 check_cb, foreign_dev_check_cb, 855 del_cb); 856 if (err && err != -EOPNOTSUPP) 857 return err; 858 } 859 860 /* Event is neither on a bridge nor a LAG. Check whether it is on an 861 * interface that is in a bridge with us. 862 */ 863 if (!foreign_dev_check_cb) 864 return err; 865 866 br = netdev_master_upper_dev_get(dev); 867 if (!br || !netif_is_bridge_master(br)) 868 return err; 869 870 switchdev = switchdev_lower_dev_find(br, check_cb, foreign_dev_check_cb); 871 if (!switchdev) 872 return err; 873 874 if (!foreign_dev_check_cb(switchdev, dev)) 875 return err; 876 877 return __switchdev_handle_port_obj_del(br, port_obj_info, check_cb, 878 foreign_dev_check_cb, del_cb); 879 } 880 881 /* Pass through a port object deletion, if @dev passes @check_cb, or replicate 882 * it towards all lower interfaces of @dev that pass @check_cb, if @dev is a 883 * bridge or a LAG. 884 */ 885 int switchdev_handle_port_obj_del(struct net_device *dev, 886 struct switchdev_notifier_port_obj_info *port_obj_info, 887 bool (*check_cb)(const struct net_device *dev), 888 int (*del_cb)(struct net_device *dev, const void *ctx, 889 const struct switchdev_obj *obj)) 890 { 891 int err; 892 893 err = __switchdev_handle_port_obj_del(dev, port_obj_info, check_cb, 894 NULL, del_cb); 895 if (err == -EOPNOTSUPP) 896 err = 0; 897 return err; 898 } 899 EXPORT_SYMBOL_GPL(switchdev_handle_port_obj_del); 900 901 /* Same as switchdev_handle_port_obj_del(), except if object is notified on a 902 * @dev that passes @foreign_dev_check_cb, it is replicated towards all devices 903 * that pass @check_cb and are in the same bridge as @dev. 904 */ 905 int switchdev_handle_port_obj_del_foreign(struct net_device *dev, 906 struct switchdev_notifier_port_obj_info *port_obj_info, 907 bool (*check_cb)(const struct net_device *dev), 908 bool (*foreign_dev_check_cb)(const struct net_device *dev, 909 const struct net_device *foreign_dev), 910 int (*del_cb)(struct net_device *dev, const void *ctx, 911 const struct switchdev_obj *obj)) 912 { 913 int err; 914 915 err = __switchdev_handle_port_obj_del(dev, port_obj_info, check_cb, 916 foreign_dev_check_cb, del_cb); 917 if (err == -EOPNOTSUPP) 918 err = 0; 919 return err; 920 } 921 EXPORT_SYMBOL_GPL(switchdev_handle_port_obj_del_foreign); 922 923 static int __switchdev_handle_port_attr_set(struct net_device *dev, 924 struct switchdev_notifier_port_attr_info *port_attr_info, 925 bool (*check_cb)(const struct net_device *dev), 926 int (*set_cb)(struct net_device *dev, const void *ctx, 927 const struct switchdev_attr *attr, 928 struct netlink_ext_ack *extack)) 929 { 930 struct switchdev_notifier_info *info = &port_attr_info->info; 931 struct netlink_ext_ack *extack; 932 struct net_device *lower_dev; 933 struct list_head *iter; 934 int err = -EOPNOTSUPP; 935 936 extack = switchdev_notifier_info_to_extack(info); 937 938 if (check_cb(dev)) { 939 err = set_cb(dev, info->ctx, port_attr_info->attr, extack); 940 if (err != -EOPNOTSUPP) 941 port_attr_info->handled = true; 942 return err; 943 } 944 945 /* Switch ports might be stacked under e.g. a LAG. Ignore the 946 * unsupported devices, another driver might be able to handle them. But 947 * propagate to the callers any hard errors. 948 * 949 * If the driver does its own bookkeeping of stacked ports, it's not 950 * necessary to go through this helper. 951 */ 952 netdev_for_each_lower_dev(dev, lower_dev, iter) { 953 if (netif_is_bridge_master(lower_dev)) 954 continue; 955 956 err = __switchdev_handle_port_attr_set(lower_dev, port_attr_info, 957 check_cb, set_cb); 958 if (err && err != -EOPNOTSUPP) 959 return err; 960 } 961 962 return err; 963 } 964 965 int switchdev_handle_port_attr_set(struct net_device *dev, 966 struct switchdev_notifier_port_attr_info *port_attr_info, 967 bool (*check_cb)(const struct net_device *dev), 968 int (*set_cb)(struct net_device *dev, const void *ctx, 969 const struct switchdev_attr *attr, 970 struct netlink_ext_ack *extack)) 971 { 972 int err; 973 974 err = __switchdev_handle_port_attr_set(dev, port_attr_info, check_cb, 975 set_cb); 976 if (err == -EOPNOTSUPP) 977 err = 0; 978 return err; 979 } 980 EXPORT_SYMBOL_GPL(switchdev_handle_port_attr_set); 981 982 int switchdev_bridge_port_offload(struct net_device *brport_dev, 983 struct net_device *dev, const void *ctx, 984 struct notifier_block *atomic_nb, 985 struct notifier_block *blocking_nb, 986 bool tx_fwd_offload, 987 struct netlink_ext_ack *extack) 988 { 989 struct switchdev_notifier_brport_info brport_info = { 990 .brport = { 991 .dev = dev, 992 .ctx = ctx, 993 .atomic_nb = atomic_nb, 994 .blocking_nb = blocking_nb, 995 .tx_fwd_offload = tx_fwd_offload, 996 }, 997 }; 998 int err; 999 1000 ASSERT_RTNL(); 1001 1002 err = call_switchdev_blocking_notifiers(SWITCHDEV_BRPORT_OFFLOADED, 1003 brport_dev, &brport_info.info, 1004 extack); 1005 return notifier_to_errno(err); 1006 } 1007 EXPORT_SYMBOL_GPL(switchdev_bridge_port_offload); 1008 1009 void switchdev_bridge_port_unoffload(struct net_device *brport_dev, 1010 const void *ctx, 1011 struct notifier_block *atomic_nb, 1012 struct notifier_block *blocking_nb) 1013 { 1014 struct switchdev_notifier_brport_info brport_info = { 1015 .brport = { 1016 .ctx = ctx, 1017 .atomic_nb = atomic_nb, 1018 .blocking_nb = blocking_nb, 1019 }, 1020 }; 1021 1022 ASSERT_RTNL(); 1023 1024 call_switchdev_blocking_notifiers(SWITCHDEV_BRPORT_UNOFFLOADED, 1025 brport_dev, &brport_info.info, 1026 NULL); 1027 } 1028 EXPORT_SYMBOL_GPL(switchdev_bridge_port_unoffload); 1029 1030 int switchdev_bridge_port_replay(struct net_device *brport_dev, 1031 struct net_device *dev, const void *ctx, 1032 struct notifier_block *atomic_nb, 1033 struct notifier_block *blocking_nb, 1034 struct netlink_ext_ack *extack) 1035 { 1036 struct switchdev_notifier_brport_info brport_info = { 1037 .brport = { 1038 .dev = dev, 1039 .ctx = ctx, 1040 .atomic_nb = atomic_nb, 1041 .blocking_nb = blocking_nb, 1042 }, 1043 }; 1044 int err; 1045 1046 ASSERT_RTNL(); 1047 1048 err = call_switchdev_blocking_notifiers(SWITCHDEV_BRPORT_REPLAY, 1049 brport_dev, &brport_info.info, 1050 extack); 1051 return notifier_to_errno(err); 1052 } 1053 EXPORT_SYMBOL_GPL(switchdev_bridge_port_replay); 1054