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 LIST_HEAD(deferred); 23 static DEFINE_SPINLOCK(deferred_lock); 24 25 typedef void switchdev_deferred_func_t(struct net_device *dev, 26 const void *data); 27 28 struct switchdev_deferred_item { 29 struct list_head list; 30 struct net_device *dev; 31 netdevice_tracker dev_tracker; 32 switchdev_deferred_func_t *func; 33 unsigned long data[]; 34 }; 35 36 static struct switchdev_deferred_item *switchdev_deferred_dequeue(void) 37 { 38 struct switchdev_deferred_item *dfitem; 39 40 spin_lock_bh(&deferred_lock); 41 if (list_empty(&deferred)) { 42 dfitem = NULL; 43 goto unlock; 44 } 45 dfitem = list_first_entry(&deferred, 46 struct switchdev_deferred_item, list); 47 list_del(&dfitem->list); 48 unlock: 49 spin_unlock_bh(&deferred_lock); 50 return dfitem; 51 } 52 53 /** 54 * switchdev_deferred_process - Process ops in deferred queue 55 * 56 * Called to flush the ops currently queued in deferred ops queue. 57 * rtnl_lock must be held. 58 */ 59 void switchdev_deferred_process(void) 60 { 61 struct switchdev_deferred_item *dfitem; 62 63 ASSERT_RTNL(); 64 65 while ((dfitem = switchdev_deferred_dequeue())) { 66 dfitem->func(dfitem->dev, dfitem->data); 67 dev_put_track(dfitem->dev, &dfitem->dev_tracker); 68 kfree(dfitem); 69 } 70 } 71 EXPORT_SYMBOL_GPL(switchdev_deferred_process); 72 73 static void switchdev_deferred_process_work(struct work_struct *work) 74 { 75 rtnl_lock(); 76 switchdev_deferred_process(); 77 rtnl_unlock(); 78 } 79 80 static DECLARE_WORK(deferred_process_work, switchdev_deferred_process_work); 81 82 static int switchdev_deferred_enqueue(struct net_device *dev, 83 const void *data, size_t data_len, 84 switchdev_deferred_func_t *func) 85 { 86 struct switchdev_deferred_item *dfitem; 87 88 dfitem = kmalloc(struct_size(dfitem, data, data_len), GFP_ATOMIC); 89 if (!dfitem) 90 return -ENOMEM; 91 dfitem->dev = dev; 92 dfitem->func = func; 93 memcpy(dfitem->data, data, data_len); 94 dev_hold_track(dev, &dfitem->dev_tracker, GFP_ATOMIC); 95 spin_lock_bh(&deferred_lock); 96 list_add_tail(&dfitem->list, &deferred); 97 spin_unlock_bh(&deferred_lock); 98 schedule_work(&deferred_process_work); 99 return 0; 100 } 101 102 static int switchdev_port_attr_notify(enum switchdev_notifier_type nt, 103 struct net_device *dev, 104 const struct switchdev_attr *attr, 105 struct netlink_ext_ack *extack) 106 { 107 int err; 108 int rc; 109 110 struct switchdev_notifier_port_attr_info attr_info = { 111 .attr = attr, 112 .handled = false, 113 }; 114 115 rc = call_switchdev_blocking_notifiers(nt, dev, 116 &attr_info.info, extack); 117 err = notifier_to_errno(rc); 118 if (err) { 119 WARN_ON(!attr_info.handled); 120 return err; 121 } 122 123 if (!attr_info.handled) 124 return -EOPNOTSUPP; 125 126 return 0; 127 } 128 129 static int switchdev_port_attr_set_now(struct net_device *dev, 130 const struct switchdev_attr *attr, 131 struct netlink_ext_ack *extack) 132 { 133 return switchdev_port_attr_notify(SWITCHDEV_PORT_ATTR_SET, dev, attr, 134 extack); 135 } 136 137 static void switchdev_port_attr_set_deferred(struct net_device *dev, 138 const void *data) 139 { 140 const struct switchdev_attr *attr = data; 141 int err; 142 143 err = switchdev_port_attr_set_now(dev, attr, NULL); 144 if (err && err != -EOPNOTSUPP) 145 netdev_err(dev, "failed (err=%d) to set attribute (id=%d)\n", 146 err, attr->id); 147 if (attr->complete) 148 attr->complete(dev, err, attr->complete_priv); 149 } 150 151 static int switchdev_port_attr_set_defer(struct net_device *dev, 152 const struct switchdev_attr *attr) 153 { 154 return switchdev_deferred_enqueue(dev, attr, sizeof(*attr), 155 switchdev_port_attr_set_deferred); 156 } 157 158 /** 159 * switchdev_port_attr_set - Set port attribute 160 * 161 * @dev: port device 162 * @attr: attribute to set 163 * @extack: netlink extended ack, for error message propagation 164 * 165 * rtnl_lock must be held and must not be in atomic section, 166 * in case SWITCHDEV_F_DEFER flag is not set. 167 */ 168 int switchdev_port_attr_set(struct net_device *dev, 169 const struct switchdev_attr *attr, 170 struct netlink_ext_ack *extack) 171 { 172 if (attr->flags & SWITCHDEV_F_DEFER) 173 return switchdev_port_attr_set_defer(dev, attr); 174 ASSERT_RTNL(); 175 return switchdev_port_attr_set_now(dev, attr, extack); 176 } 177 EXPORT_SYMBOL_GPL(switchdev_port_attr_set); 178 179 static size_t switchdev_obj_size(const struct switchdev_obj *obj) 180 { 181 switch (obj->id) { 182 case SWITCHDEV_OBJ_ID_PORT_VLAN: 183 return sizeof(struct switchdev_obj_port_vlan); 184 case SWITCHDEV_OBJ_ID_PORT_MDB: 185 return sizeof(struct switchdev_obj_port_mdb); 186 case SWITCHDEV_OBJ_ID_HOST_MDB: 187 return sizeof(struct switchdev_obj_port_mdb); 188 default: 189 BUG(); 190 } 191 return 0; 192 } 193 194 static int switchdev_port_obj_notify(enum switchdev_notifier_type nt, 195 struct net_device *dev, 196 const struct switchdev_obj *obj, 197 struct netlink_ext_ack *extack) 198 { 199 int rc; 200 int err; 201 202 struct switchdev_notifier_port_obj_info obj_info = { 203 .obj = obj, 204 .handled = false, 205 }; 206 207 rc = call_switchdev_blocking_notifiers(nt, dev, &obj_info.info, extack); 208 err = notifier_to_errno(rc); 209 if (err) { 210 WARN_ON(!obj_info.handled); 211 return err; 212 } 213 if (!obj_info.handled) 214 return -EOPNOTSUPP; 215 return 0; 216 } 217 218 static void switchdev_port_obj_add_deferred(struct net_device *dev, 219 const void *data) 220 { 221 const struct switchdev_obj *obj = data; 222 int err; 223 224 ASSERT_RTNL(); 225 err = switchdev_port_obj_notify(SWITCHDEV_PORT_OBJ_ADD, 226 dev, obj, NULL); 227 if (err && err != -EOPNOTSUPP) 228 netdev_err(dev, "failed (err=%d) to add object (id=%d)\n", 229 err, obj->id); 230 if (obj->complete) 231 obj->complete(dev, err, obj->complete_priv); 232 } 233 234 static int switchdev_port_obj_add_defer(struct net_device *dev, 235 const struct switchdev_obj *obj) 236 { 237 return switchdev_deferred_enqueue(dev, obj, switchdev_obj_size(obj), 238 switchdev_port_obj_add_deferred); 239 } 240 241 /** 242 * switchdev_port_obj_add - Add port object 243 * 244 * @dev: port device 245 * @obj: object to add 246 * @extack: netlink extended ack 247 * 248 * rtnl_lock must be held and must not be in atomic section, 249 * in case SWITCHDEV_F_DEFER flag is not set. 250 */ 251 int switchdev_port_obj_add(struct net_device *dev, 252 const struct switchdev_obj *obj, 253 struct netlink_ext_ack *extack) 254 { 255 if (obj->flags & SWITCHDEV_F_DEFER) 256 return switchdev_port_obj_add_defer(dev, obj); 257 ASSERT_RTNL(); 258 return switchdev_port_obj_notify(SWITCHDEV_PORT_OBJ_ADD, 259 dev, obj, extack); 260 } 261 EXPORT_SYMBOL_GPL(switchdev_port_obj_add); 262 263 static int switchdev_port_obj_del_now(struct net_device *dev, 264 const struct switchdev_obj *obj) 265 { 266 return switchdev_port_obj_notify(SWITCHDEV_PORT_OBJ_DEL, 267 dev, obj, NULL); 268 } 269 270 static void switchdev_port_obj_del_deferred(struct net_device *dev, 271 const void *data) 272 { 273 const struct switchdev_obj *obj = data; 274 int err; 275 276 err = switchdev_port_obj_del_now(dev, obj); 277 if (err && err != -EOPNOTSUPP) 278 netdev_err(dev, "failed (err=%d) to del object (id=%d)\n", 279 err, obj->id); 280 if (obj->complete) 281 obj->complete(dev, err, obj->complete_priv); 282 } 283 284 static int switchdev_port_obj_del_defer(struct net_device *dev, 285 const struct switchdev_obj *obj) 286 { 287 return switchdev_deferred_enqueue(dev, obj, switchdev_obj_size(obj), 288 switchdev_port_obj_del_deferred); 289 } 290 291 /** 292 * switchdev_port_obj_del - Delete port object 293 * 294 * @dev: port device 295 * @obj: object to delete 296 * 297 * rtnl_lock must be held and must not be in atomic section, 298 * in case SWITCHDEV_F_DEFER flag is not set. 299 */ 300 int switchdev_port_obj_del(struct net_device *dev, 301 const struct switchdev_obj *obj) 302 { 303 if (obj->flags & SWITCHDEV_F_DEFER) 304 return switchdev_port_obj_del_defer(dev, obj); 305 ASSERT_RTNL(); 306 return switchdev_port_obj_del_now(dev, obj); 307 } 308 EXPORT_SYMBOL_GPL(switchdev_port_obj_del); 309 310 static ATOMIC_NOTIFIER_HEAD(switchdev_notif_chain); 311 static BLOCKING_NOTIFIER_HEAD(switchdev_blocking_notif_chain); 312 313 /** 314 * register_switchdev_notifier - Register notifier 315 * @nb: notifier_block 316 * 317 * Register switch device notifier. 318 */ 319 int register_switchdev_notifier(struct notifier_block *nb) 320 { 321 return atomic_notifier_chain_register(&switchdev_notif_chain, nb); 322 } 323 EXPORT_SYMBOL_GPL(register_switchdev_notifier); 324 325 /** 326 * unregister_switchdev_notifier - Unregister notifier 327 * @nb: notifier_block 328 * 329 * Unregister switch device notifier. 330 */ 331 int unregister_switchdev_notifier(struct notifier_block *nb) 332 { 333 return atomic_notifier_chain_unregister(&switchdev_notif_chain, nb); 334 } 335 EXPORT_SYMBOL_GPL(unregister_switchdev_notifier); 336 337 /** 338 * call_switchdev_notifiers - Call notifiers 339 * @val: value passed unmodified to notifier function 340 * @dev: port device 341 * @info: notifier information data 342 * @extack: netlink extended ack 343 * Call all network notifier blocks. 344 */ 345 int call_switchdev_notifiers(unsigned long val, struct net_device *dev, 346 struct switchdev_notifier_info *info, 347 struct netlink_ext_ack *extack) 348 { 349 info->dev = dev; 350 info->extack = extack; 351 return atomic_notifier_call_chain(&switchdev_notif_chain, val, info); 352 } 353 EXPORT_SYMBOL_GPL(call_switchdev_notifiers); 354 355 int register_switchdev_blocking_notifier(struct notifier_block *nb) 356 { 357 struct blocking_notifier_head *chain = &switchdev_blocking_notif_chain; 358 359 return blocking_notifier_chain_register(chain, nb); 360 } 361 EXPORT_SYMBOL_GPL(register_switchdev_blocking_notifier); 362 363 int unregister_switchdev_blocking_notifier(struct notifier_block *nb) 364 { 365 struct blocking_notifier_head *chain = &switchdev_blocking_notif_chain; 366 367 return blocking_notifier_chain_unregister(chain, nb); 368 } 369 EXPORT_SYMBOL_GPL(unregister_switchdev_blocking_notifier); 370 371 int call_switchdev_blocking_notifiers(unsigned long val, struct net_device *dev, 372 struct switchdev_notifier_info *info, 373 struct netlink_ext_ack *extack) 374 { 375 info->dev = dev; 376 info->extack = extack; 377 return blocking_notifier_call_chain(&switchdev_blocking_notif_chain, 378 val, info); 379 } 380 EXPORT_SYMBOL_GPL(call_switchdev_blocking_notifiers); 381 382 struct switchdev_nested_priv { 383 bool (*check_cb)(const struct net_device *dev); 384 bool (*foreign_dev_check_cb)(const struct net_device *dev, 385 const struct net_device *foreign_dev); 386 const struct net_device *dev; 387 struct net_device *lower_dev; 388 }; 389 390 static int switchdev_lower_dev_walk(struct net_device *lower_dev, 391 struct netdev_nested_priv *priv) 392 { 393 struct switchdev_nested_priv *switchdev_priv = priv->data; 394 bool (*foreign_dev_check_cb)(const struct net_device *dev, 395 const struct net_device *foreign_dev); 396 bool (*check_cb)(const struct net_device *dev); 397 const struct net_device *dev; 398 399 check_cb = switchdev_priv->check_cb; 400 foreign_dev_check_cb = switchdev_priv->foreign_dev_check_cb; 401 dev = switchdev_priv->dev; 402 403 if (check_cb(lower_dev) && !foreign_dev_check_cb(lower_dev, dev)) { 404 switchdev_priv->lower_dev = lower_dev; 405 return 1; 406 } 407 408 return 0; 409 } 410 411 static struct net_device * 412 switchdev_lower_dev_find_rcu(struct net_device *dev, 413 bool (*check_cb)(const struct net_device *dev), 414 bool (*foreign_dev_check_cb)(const struct net_device *dev, 415 const struct net_device *foreign_dev)) 416 { 417 struct switchdev_nested_priv switchdev_priv = { 418 .check_cb = check_cb, 419 .foreign_dev_check_cb = foreign_dev_check_cb, 420 .dev = dev, 421 .lower_dev = NULL, 422 }; 423 struct netdev_nested_priv priv = { 424 .data = &switchdev_priv, 425 }; 426 427 netdev_walk_all_lower_dev_rcu(dev, switchdev_lower_dev_walk, &priv); 428 429 return switchdev_priv.lower_dev; 430 } 431 432 static struct net_device * 433 switchdev_lower_dev_find(struct net_device *dev, 434 bool (*check_cb)(const struct net_device *dev), 435 bool (*foreign_dev_check_cb)(const struct net_device *dev, 436 const struct net_device *foreign_dev)) 437 { 438 struct switchdev_nested_priv switchdev_priv = { 439 .check_cb = check_cb, 440 .foreign_dev_check_cb = foreign_dev_check_cb, 441 .dev = dev, 442 .lower_dev = NULL, 443 }; 444 struct netdev_nested_priv priv = { 445 .data = &switchdev_priv, 446 }; 447 448 netdev_walk_all_lower_dev(dev, switchdev_lower_dev_walk, &priv); 449 450 return switchdev_priv.lower_dev; 451 } 452 453 static int __switchdev_handle_fdb_event_to_device(struct net_device *dev, 454 struct net_device *orig_dev, unsigned long event, 455 const struct switchdev_notifier_fdb_info *fdb_info, 456 bool (*check_cb)(const struct net_device *dev), 457 bool (*foreign_dev_check_cb)(const struct net_device *dev, 458 const struct net_device *foreign_dev), 459 int (*mod_cb)(struct net_device *dev, struct net_device *orig_dev, 460 unsigned long event, const void *ctx, 461 const struct switchdev_notifier_fdb_info *fdb_info), 462 int (*lag_mod_cb)(struct net_device *dev, struct net_device *orig_dev, 463 unsigned long event, const void *ctx, 464 const struct switchdev_notifier_fdb_info *fdb_info)) 465 { 466 const struct switchdev_notifier_info *info = &fdb_info->info; 467 struct net_device *br, *lower_dev; 468 struct list_head *iter; 469 int err = -EOPNOTSUPP; 470 471 if (check_cb(dev)) 472 return mod_cb(dev, orig_dev, event, info->ctx, fdb_info); 473 474 if (netif_is_lag_master(dev)) { 475 if (!switchdev_lower_dev_find_rcu(dev, check_cb, foreign_dev_check_cb)) 476 goto maybe_bridged_with_us; 477 478 /* This is a LAG interface that we offload */ 479 if (!lag_mod_cb) 480 return -EOPNOTSUPP; 481 482 return lag_mod_cb(dev, orig_dev, event, info->ctx, fdb_info); 483 } 484 485 /* Recurse through lower interfaces in case the FDB entry is pointing 486 * towards a bridge device. 487 */ 488 if (netif_is_bridge_master(dev)) { 489 if (!switchdev_lower_dev_find_rcu(dev, check_cb, foreign_dev_check_cb)) 490 return 0; 491 492 /* This is a bridge interface that we offload */ 493 netdev_for_each_lower_dev(dev, lower_dev, iter) { 494 /* Do not propagate FDB entries across bridges */ 495 if (netif_is_bridge_master(lower_dev)) 496 continue; 497 498 /* Bridge ports might be either us, or LAG interfaces 499 * that we offload. 500 */ 501 if (!check_cb(lower_dev) && 502 !switchdev_lower_dev_find_rcu(lower_dev, check_cb, 503 foreign_dev_check_cb)) 504 continue; 505 506 err = __switchdev_handle_fdb_event_to_device(lower_dev, orig_dev, 507 event, fdb_info, check_cb, 508 foreign_dev_check_cb, 509 mod_cb, lag_mod_cb); 510 if (err && err != -EOPNOTSUPP) 511 return err; 512 } 513 514 return 0; 515 } 516 517 maybe_bridged_with_us: 518 /* Event is neither on a bridge nor a LAG. Check whether it is on an 519 * interface that is in a bridge with us. 520 */ 521 br = netdev_master_upper_dev_get_rcu(dev); 522 if (!br || !netif_is_bridge_master(br)) 523 return 0; 524 525 if (!switchdev_lower_dev_find_rcu(br, check_cb, foreign_dev_check_cb)) 526 return 0; 527 528 return __switchdev_handle_fdb_event_to_device(br, orig_dev, event, fdb_info, 529 check_cb, foreign_dev_check_cb, 530 mod_cb, lag_mod_cb); 531 } 532 533 int switchdev_handle_fdb_event_to_device(struct net_device *dev, unsigned long event, 534 const struct switchdev_notifier_fdb_info *fdb_info, 535 bool (*check_cb)(const struct net_device *dev), 536 bool (*foreign_dev_check_cb)(const struct net_device *dev, 537 const struct net_device *foreign_dev), 538 int (*mod_cb)(struct net_device *dev, struct net_device *orig_dev, 539 unsigned long event, const void *ctx, 540 const struct switchdev_notifier_fdb_info *fdb_info), 541 int (*lag_mod_cb)(struct net_device *dev, struct net_device *orig_dev, 542 unsigned long event, const void *ctx, 543 const struct switchdev_notifier_fdb_info *fdb_info)) 544 { 545 int err; 546 547 err = __switchdev_handle_fdb_event_to_device(dev, dev, event, fdb_info, 548 check_cb, foreign_dev_check_cb, 549 mod_cb, lag_mod_cb); 550 if (err == -EOPNOTSUPP) 551 err = 0; 552 553 return err; 554 } 555 EXPORT_SYMBOL_GPL(switchdev_handle_fdb_event_to_device); 556 557 static int __switchdev_handle_port_obj_add(struct net_device *dev, 558 struct switchdev_notifier_port_obj_info *port_obj_info, 559 bool (*check_cb)(const struct net_device *dev), 560 bool (*foreign_dev_check_cb)(const struct net_device *dev, 561 const struct net_device *foreign_dev), 562 int (*add_cb)(struct net_device *dev, const void *ctx, 563 const struct switchdev_obj *obj, 564 struct netlink_ext_ack *extack)) 565 { 566 struct switchdev_notifier_info *info = &port_obj_info->info; 567 struct net_device *br, *lower_dev; 568 struct netlink_ext_ack *extack; 569 struct list_head *iter; 570 int err = -EOPNOTSUPP; 571 572 extack = switchdev_notifier_info_to_extack(info); 573 574 if (check_cb(dev)) { 575 err = add_cb(dev, info->ctx, port_obj_info->obj, extack); 576 if (err != -EOPNOTSUPP) 577 port_obj_info->handled = true; 578 return err; 579 } 580 581 /* Switch ports might be stacked under e.g. a LAG. Ignore the 582 * unsupported devices, another driver might be able to handle them. But 583 * propagate to the callers any hard errors. 584 * 585 * If the driver does its own bookkeeping of stacked ports, it's not 586 * necessary to go through this helper. 587 */ 588 netdev_for_each_lower_dev(dev, lower_dev, iter) { 589 if (netif_is_bridge_master(lower_dev)) 590 continue; 591 592 /* When searching for switchdev interfaces that are neighbors 593 * of foreign ones, and @dev is a bridge, do not recurse on the 594 * foreign interface again, it was already visited. 595 */ 596 if (foreign_dev_check_cb && !check_cb(lower_dev) && 597 !switchdev_lower_dev_find(lower_dev, check_cb, foreign_dev_check_cb)) 598 continue; 599 600 err = __switchdev_handle_port_obj_add(lower_dev, port_obj_info, 601 check_cb, foreign_dev_check_cb, 602 add_cb); 603 if (err && err != -EOPNOTSUPP) 604 return err; 605 } 606 607 /* Event is neither on a bridge nor a LAG. Check whether it is on an 608 * interface that is in a bridge with us. 609 */ 610 if (!foreign_dev_check_cb) 611 return err; 612 613 br = netdev_master_upper_dev_get(dev); 614 if (!br || !netif_is_bridge_master(br)) 615 return err; 616 617 if (!switchdev_lower_dev_find(br, check_cb, foreign_dev_check_cb)) 618 return err; 619 620 return __switchdev_handle_port_obj_add(br, port_obj_info, check_cb, 621 foreign_dev_check_cb, add_cb); 622 } 623 624 /* Pass through a port object addition, if @dev passes @check_cb, or replicate 625 * it towards all lower interfaces of @dev that pass @check_cb, if @dev is a 626 * bridge or a LAG. 627 */ 628 int switchdev_handle_port_obj_add(struct net_device *dev, 629 struct switchdev_notifier_port_obj_info *port_obj_info, 630 bool (*check_cb)(const struct net_device *dev), 631 int (*add_cb)(struct net_device *dev, const void *ctx, 632 const struct switchdev_obj *obj, 633 struct netlink_ext_ack *extack)) 634 { 635 int err; 636 637 err = __switchdev_handle_port_obj_add(dev, port_obj_info, check_cb, 638 NULL, add_cb); 639 if (err == -EOPNOTSUPP) 640 err = 0; 641 return err; 642 } 643 EXPORT_SYMBOL_GPL(switchdev_handle_port_obj_add); 644 645 /* Same as switchdev_handle_port_obj_add(), except if object is notified on a 646 * @dev that passes @foreign_dev_check_cb, it is replicated towards all devices 647 * that pass @check_cb and are in the same bridge as @dev. 648 */ 649 int switchdev_handle_port_obj_add_foreign(struct net_device *dev, 650 struct switchdev_notifier_port_obj_info *port_obj_info, 651 bool (*check_cb)(const struct net_device *dev), 652 bool (*foreign_dev_check_cb)(const struct net_device *dev, 653 const struct net_device *foreign_dev), 654 int (*add_cb)(struct net_device *dev, const void *ctx, 655 const struct switchdev_obj *obj, 656 struct netlink_ext_ack *extack)) 657 { 658 int err; 659 660 err = __switchdev_handle_port_obj_add(dev, port_obj_info, check_cb, 661 foreign_dev_check_cb, add_cb); 662 if (err == -EOPNOTSUPP) 663 err = 0; 664 return err; 665 } 666 EXPORT_SYMBOL_GPL(switchdev_handle_port_obj_add_foreign); 667 668 static int __switchdev_handle_port_obj_del(struct net_device *dev, 669 struct switchdev_notifier_port_obj_info *port_obj_info, 670 bool (*check_cb)(const struct net_device *dev), 671 bool (*foreign_dev_check_cb)(const struct net_device *dev, 672 const struct net_device *foreign_dev), 673 int (*del_cb)(struct net_device *dev, const void *ctx, 674 const struct switchdev_obj *obj)) 675 { 676 struct switchdev_notifier_info *info = &port_obj_info->info; 677 struct net_device *br, *lower_dev; 678 struct list_head *iter; 679 int err = -EOPNOTSUPP; 680 681 if (check_cb(dev)) { 682 err = del_cb(dev, info->ctx, port_obj_info->obj); 683 if (err != -EOPNOTSUPP) 684 port_obj_info->handled = true; 685 return err; 686 } 687 688 /* Switch ports might be stacked under e.g. a LAG. Ignore the 689 * unsupported devices, another driver might be able to handle them. But 690 * propagate to the callers any hard errors. 691 * 692 * If the driver does its own bookkeeping of stacked ports, it's not 693 * necessary to go through this helper. 694 */ 695 netdev_for_each_lower_dev(dev, lower_dev, iter) { 696 if (netif_is_bridge_master(lower_dev)) 697 continue; 698 699 /* When searching for switchdev interfaces that are neighbors 700 * of foreign ones, and @dev is a bridge, do not recurse on the 701 * foreign interface again, it was already visited. 702 */ 703 if (foreign_dev_check_cb && !check_cb(lower_dev) && 704 !switchdev_lower_dev_find(lower_dev, check_cb, foreign_dev_check_cb)) 705 continue; 706 707 err = __switchdev_handle_port_obj_del(lower_dev, port_obj_info, 708 check_cb, foreign_dev_check_cb, 709 del_cb); 710 if (err && err != -EOPNOTSUPP) 711 return err; 712 } 713 714 /* Event is neither on a bridge nor a LAG. Check whether it is on an 715 * interface that is in a bridge with us. 716 */ 717 if (!foreign_dev_check_cb) 718 return err; 719 720 br = netdev_master_upper_dev_get(dev); 721 if (!br || !netif_is_bridge_master(br)) 722 return err; 723 724 if (!switchdev_lower_dev_find(br, check_cb, foreign_dev_check_cb)) 725 return err; 726 727 return __switchdev_handle_port_obj_del(br, port_obj_info, check_cb, 728 foreign_dev_check_cb, del_cb); 729 } 730 731 /* Pass through a port object deletion, if @dev passes @check_cb, or replicate 732 * it towards all lower interfaces of @dev that pass @check_cb, if @dev is a 733 * bridge or a LAG. 734 */ 735 int switchdev_handle_port_obj_del(struct net_device *dev, 736 struct switchdev_notifier_port_obj_info *port_obj_info, 737 bool (*check_cb)(const struct net_device *dev), 738 int (*del_cb)(struct net_device *dev, const void *ctx, 739 const struct switchdev_obj *obj)) 740 { 741 int err; 742 743 err = __switchdev_handle_port_obj_del(dev, port_obj_info, check_cb, 744 NULL, del_cb); 745 if (err == -EOPNOTSUPP) 746 err = 0; 747 return err; 748 } 749 EXPORT_SYMBOL_GPL(switchdev_handle_port_obj_del); 750 751 /* Same as switchdev_handle_port_obj_del(), except if object is notified on a 752 * @dev that passes @foreign_dev_check_cb, it is replicated towards all devices 753 * that pass @check_cb and are in the same bridge as @dev. 754 */ 755 int switchdev_handle_port_obj_del_foreign(struct net_device *dev, 756 struct switchdev_notifier_port_obj_info *port_obj_info, 757 bool (*check_cb)(const struct net_device *dev), 758 bool (*foreign_dev_check_cb)(const struct net_device *dev, 759 const struct net_device *foreign_dev), 760 int (*del_cb)(struct net_device *dev, const void *ctx, 761 const struct switchdev_obj *obj)) 762 { 763 int err; 764 765 err = __switchdev_handle_port_obj_del(dev, port_obj_info, check_cb, 766 foreign_dev_check_cb, del_cb); 767 if (err == -EOPNOTSUPP) 768 err = 0; 769 return err; 770 } 771 EXPORT_SYMBOL_GPL(switchdev_handle_port_obj_del_foreign); 772 773 static int __switchdev_handle_port_attr_set(struct net_device *dev, 774 struct switchdev_notifier_port_attr_info *port_attr_info, 775 bool (*check_cb)(const struct net_device *dev), 776 int (*set_cb)(struct net_device *dev, const void *ctx, 777 const struct switchdev_attr *attr, 778 struct netlink_ext_ack *extack)) 779 { 780 struct switchdev_notifier_info *info = &port_attr_info->info; 781 struct netlink_ext_ack *extack; 782 struct net_device *lower_dev; 783 struct list_head *iter; 784 int err = -EOPNOTSUPP; 785 786 extack = switchdev_notifier_info_to_extack(info); 787 788 if (check_cb(dev)) { 789 err = set_cb(dev, info->ctx, port_attr_info->attr, extack); 790 if (err != -EOPNOTSUPP) 791 port_attr_info->handled = true; 792 return err; 793 } 794 795 /* Switch ports might be stacked under e.g. a LAG. Ignore the 796 * unsupported devices, another driver might be able to handle them. But 797 * propagate to the callers any hard errors. 798 * 799 * If the driver does its own bookkeeping of stacked ports, it's not 800 * necessary to go through this helper. 801 */ 802 netdev_for_each_lower_dev(dev, lower_dev, iter) { 803 if (netif_is_bridge_master(lower_dev)) 804 continue; 805 806 err = __switchdev_handle_port_attr_set(lower_dev, port_attr_info, 807 check_cb, set_cb); 808 if (err && err != -EOPNOTSUPP) 809 return err; 810 } 811 812 return err; 813 } 814 815 int switchdev_handle_port_attr_set(struct net_device *dev, 816 struct switchdev_notifier_port_attr_info *port_attr_info, 817 bool (*check_cb)(const struct net_device *dev), 818 int (*set_cb)(struct net_device *dev, const void *ctx, 819 const struct switchdev_attr *attr, 820 struct netlink_ext_ack *extack)) 821 { 822 int err; 823 824 err = __switchdev_handle_port_attr_set(dev, port_attr_info, check_cb, 825 set_cb); 826 if (err == -EOPNOTSUPP) 827 err = 0; 828 return err; 829 } 830 EXPORT_SYMBOL_GPL(switchdev_handle_port_attr_set); 831 832 int switchdev_bridge_port_offload(struct net_device *brport_dev, 833 struct net_device *dev, const void *ctx, 834 struct notifier_block *atomic_nb, 835 struct notifier_block *blocking_nb, 836 bool tx_fwd_offload, 837 struct netlink_ext_ack *extack) 838 { 839 struct switchdev_notifier_brport_info brport_info = { 840 .brport = { 841 .dev = dev, 842 .ctx = ctx, 843 .atomic_nb = atomic_nb, 844 .blocking_nb = blocking_nb, 845 .tx_fwd_offload = tx_fwd_offload, 846 }, 847 }; 848 int err; 849 850 ASSERT_RTNL(); 851 852 err = call_switchdev_blocking_notifiers(SWITCHDEV_BRPORT_OFFLOADED, 853 brport_dev, &brport_info.info, 854 extack); 855 return notifier_to_errno(err); 856 } 857 EXPORT_SYMBOL_GPL(switchdev_bridge_port_offload); 858 859 void switchdev_bridge_port_unoffload(struct net_device *brport_dev, 860 const void *ctx, 861 struct notifier_block *atomic_nb, 862 struct notifier_block *blocking_nb) 863 { 864 struct switchdev_notifier_brport_info brport_info = { 865 .brport = { 866 .ctx = ctx, 867 .atomic_nb = atomic_nb, 868 .blocking_nb = blocking_nb, 869 }, 870 }; 871 872 ASSERT_RTNL(); 873 874 call_switchdev_blocking_notifiers(SWITCHDEV_BRPORT_UNOFFLOADED, 875 brport_dev, &brport_info.info, 876 NULL); 877 } 878 EXPORT_SYMBOL_GPL(switchdev_bridge_port_unoffload); 879