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 netdev_put(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 netdev_hold(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 { 463 const struct switchdev_notifier_info *info = &fdb_info->info; 464 struct net_device *br, *lower_dev, *switchdev; 465 struct list_head *iter; 466 int err = -EOPNOTSUPP; 467 468 if (check_cb(dev)) 469 return mod_cb(dev, orig_dev, event, info->ctx, fdb_info); 470 471 /* Recurse through lower interfaces in case the FDB entry is pointing 472 * towards a bridge or a LAG device. 473 */ 474 netdev_for_each_lower_dev(dev, lower_dev, iter) { 475 /* Do not propagate FDB entries across bridges */ 476 if (netif_is_bridge_master(lower_dev)) 477 continue; 478 479 /* Bridge ports might be either us, or LAG interfaces 480 * that we offload. 481 */ 482 if (!check_cb(lower_dev) && 483 !switchdev_lower_dev_find_rcu(lower_dev, check_cb, 484 foreign_dev_check_cb)) 485 continue; 486 487 err = __switchdev_handle_fdb_event_to_device(lower_dev, orig_dev, 488 event, fdb_info, check_cb, 489 foreign_dev_check_cb, 490 mod_cb); 491 if (err && err != -EOPNOTSUPP) 492 return err; 493 } 494 495 /* Event is neither on a bridge nor a LAG. Check whether it is on an 496 * interface that is in a bridge with us. 497 */ 498 br = netdev_master_upper_dev_get_rcu(dev); 499 if (!br || !netif_is_bridge_master(br)) 500 return 0; 501 502 switchdev = switchdev_lower_dev_find_rcu(br, check_cb, foreign_dev_check_cb); 503 if (!switchdev) 504 return 0; 505 506 if (!foreign_dev_check_cb(switchdev, dev)) 507 return err; 508 509 return __switchdev_handle_fdb_event_to_device(br, orig_dev, event, fdb_info, 510 check_cb, foreign_dev_check_cb, 511 mod_cb); 512 } 513 514 int switchdev_handle_fdb_event_to_device(struct net_device *dev, unsigned long event, 515 const struct switchdev_notifier_fdb_info *fdb_info, 516 bool (*check_cb)(const struct net_device *dev), 517 bool (*foreign_dev_check_cb)(const struct net_device *dev, 518 const struct net_device *foreign_dev), 519 int (*mod_cb)(struct net_device *dev, struct net_device *orig_dev, 520 unsigned long event, const void *ctx, 521 const struct switchdev_notifier_fdb_info *fdb_info)) 522 { 523 int err; 524 525 err = __switchdev_handle_fdb_event_to_device(dev, dev, event, fdb_info, 526 check_cb, foreign_dev_check_cb, 527 mod_cb); 528 if (err == -EOPNOTSUPP) 529 err = 0; 530 531 return err; 532 } 533 EXPORT_SYMBOL_GPL(switchdev_handle_fdb_event_to_device); 534 535 static int __switchdev_handle_port_obj_add(struct net_device *dev, 536 struct switchdev_notifier_port_obj_info *port_obj_info, 537 bool (*check_cb)(const struct net_device *dev), 538 bool (*foreign_dev_check_cb)(const struct net_device *dev, 539 const struct net_device *foreign_dev), 540 int (*add_cb)(struct net_device *dev, const void *ctx, 541 const struct switchdev_obj *obj, 542 struct netlink_ext_ack *extack)) 543 { 544 struct switchdev_notifier_info *info = &port_obj_info->info; 545 struct net_device *br, *lower_dev, *switchdev; 546 struct netlink_ext_ack *extack; 547 struct list_head *iter; 548 int err = -EOPNOTSUPP; 549 550 extack = switchdev_notifier_info_to_extack(info); 551 552 if (check_cb(dev)) { 553 err = add_cb(dev, info->ctx, port_obj_info->obj, extack); 554 if (err != -EOPNOTSUPP) 555 port_obj_info->handled = true; 556 return err; 557 } 558 559 /* Switch ports might be stacked under e.g. a LAG. Ignore the 560 * unsupported devices, another driver might be able to handle them. But 561 * propagate to the callers any hard errors. 562 * 563 * If the driver does its own bookkeeping of stacked ports, it's not 564 * necessary to go through this helper. 565 */ 566 netdev_for_each_lower_dev(dev, lower_dev, iter) { 567 if (netif_is_bridge_master(lower_dev)) 568 continue; 569 570 /* When searching for switchdev interfaces that are neighbors 571 * of foreign ones, and @dev is a bridge, do not recurse on the 572 * foreign interface again, it was already visited. 573 */ 574 if (foreign_dev_check_cb && !check_cb(lower_dev) && 575 !switchdev_lower_dev_find(lower_dev, check_cb, foreign_dev_check_cb)) 576 continue; 577 578 err = __switchdev_handle_port_obj_add(lower_dev, port_obj_info, 579 check_cb, foreign_dev_check_cb, 580 add_cb); 581 if (err && err != -EOPNOTSUPP) 582 return err; 583 } 584 585 /* Event is neither on a bridge nor a LAG. Check whether it is on an 586 * interface that is in a bridge with us. 587 */ 588 if (!foreign_dev_check_cb) 589 return err; 590 591 br = netdev_master_upper_dev_get(dev); 592 if (!br || !netif_is_bridge_master(br)) 593 return err; 594 595 switchdev = switchdev_lower_dev_find(br, check_cb, foreign_dev_check_cb); 596 if (!switchdev) 597 return err; 598 599 if (!foreign_dev_check_cb(switchdev, dev)) 600 return err; 601 602 return __switchdev_handle_port_obj_add(br, port_obj_info, check_cb, 603 foreign_dev_check_cb, add_cb); 604 } 605 606 /* Pass through a port object addition, if @dev passes @check_cb, or replicate 607 * it towards all lower interfaces of @dev that pass @check_cb, if @dev is a 608 * bridge or a LAG. 609 */ 610 int switchdev_handle_port_obj_add(struct net_device *dev, 611 struct switchdev_notifier_port_obj_info *port_obj_info, 612 bool (*check_cb)(const struct net_device *dev), 613 int (*add_cb)(struct net_device *dev, const void *ctx, 614 const struct switchdev_obj *obj, 615 struct netlink_ext_ack *extack)) 616 { 617 int err; 618 619 err = __switchdev_handle_port_obj_add(dev, port_obj_info, check_cb, 620 NULL, add_cb); 621 if (err == -EOPNOTSUPP) 622 err = 0; 623 return err; 624 } 625 EXPORT_SYMBOL_GPL(switchdev_handle_port_obj_add); 626 627 /* Same as switchdev_handle_port_obj_add(), except if object is notified on a 628 * @dev that passes @foreign_dev_check_cb, it is replicated towards all devices 629 * that pass @check_cb and are in the same bridge as @dev. 630 */ 631 int switchdev_handle_port_obj_add_foreign(struct net_device *dev, 632 struct switchdev_notifier_port_obj_info *port_obj_info, 633 bool (*check_cb)(const struct net_device *dev), 634 bool (*foreign_dev_check_cb)(const struct net_device *dev, 635 const struct net_device *foreign_dev), 636 int (*add_cb)(struct net_device *dev, const void *ctx, 637 const struct switchdev_obj *obj, 638 struct netlink_ext_ack *extack)) 639 { 640 int err; 641 642 err = __switchdev_handle_port_obj_add(dev, port_obj_info, check_cb, 643 foreign_dev_check_cb, add_cb); 644 if (err == -EOPNOTSUPP) 645 err = 0; 646 return err; 647 } 648 EXPORT_SYMBOL_GPL(switchdev_handle_port_obj_add_foreign); 649 650 static int __switchdev_handle_port_obj_del(struct net_device *dev, 651 struct switchdev_notifier_port_obj_info *port_obj_info, 652 bool (*check_cb)(const struct net_device *dev), 653 bool (*foreign_dev_check_cb)(const struct net_device *dev, 654 const struct net_device *foreign_dev), 655 int (*del_cb)(struct net_device *dev, const void *ctx, 656 const struct switchdev_obj *obj)) 657 { 658 struct switchdev_notifier_info *info = &port_obj_info->info; 659 struct net_device *br, *lower_dev, *switchdev; 660 struct list_head *iter; 661 int err = -EOPNOTSUPP; 662 663 if (check_cb(dev)) { 664 err = del_cb(dev, info->ctx, port_obj_info->obj); 665 if (err != -EOPNOTSUPP) 666 port_obj_info->handled = true; 667 return err; 668 } 669 670 /* Switch ports might be stacked under e.g. a LAG. Ignore the 671 * unsupported devices, another driver might be able to handle them. But 672 * propagate to the callers any hard errors. 673 * 674 * If the driver does its own bookkeeping of stacked ports, it's not 675 * necessary to go through this helper. 676 */ 677 netdev_for_each_lower_dev(dev, lower_dev, iter) { 678 if (netif_is_bridge_master(lower_dev)) 679 continue; 680 681 /* When searching for switchdev interfaces that are neighbors 682 * of foreign ones, and @dev is a bridge, do not recurse on the 683 * foreign interface again, it was already visited. 684 */ 685 if (foreign_dev_check_cb && !check_cb(lower_dev) && 686 !switchdev_lower_dev_find(lower_dev, check_cb, foreign_dev_check_cb)) 687 continue; 688 689 err = __switchdev_handle_port_obj_del(lower_dev, port_obj_info, 690 check_cb, foreign_dev_check_cb, 691 del_cb); 692 if (err && err != -EOPNOTSUPP) 693 return err; 694 } 695 696 /* Event is neither on a bridge nor a LAG. Check whether it is on an 697 * interface that is in a bridge with us. 698 */ 699 if (!foreign_dev_check_cb) 700 return err; 701 702 br = netdev_master_upper_dev_get(dev); 703 if (!br || !netif_is_bridge_master(br)) 704 return err; 705 706 switchdev = switchdev_lower_dev_find(br, check_cb, foreign_dev_check_cb); 707 if (!switchdev) 708 return err; 709 710 if (!foreign_dev_check_cb(switchdev, dev)) 711 return err; 712 713 return __switchdev_handle_port_obj_del(br, port_obj_info, check_cb, 714 foreign_dev_check_cb, del_cb); 715 } 716 717 /* Pass through a port object deletion, if @dev passes @check_cb, or replicate 718 * it towards all lower interfaces of @dev that pass @check_cb, if @dev is a 719 * bridge or a LAG. 720 */ 721 int switchdev_handle_port_obj_del(struct net_device *dev, 722 struct switchdev_notifier_port_obj_info *port_obj_info, 723 bool (*check_cb)(const struct net_device *dev), 724 int (*del_cb)(struct net_device *dev, const void *ctx, 725 const struct switchdev_obj *obj)) 726 { 727 int err; 728 729 err = __switchdev_handle_port_obj_del(dev, port_obj_info, check_cb, 730 NULL, del_cb); 731 if (err == -EOPNOTSUPP) 732 err = 0; 733 return err; 734 } 735 EXPORT_SYMBOL_GPL(switchdev_handle_port_obj_del); 736 737 /* Same as switchdev_handle_port_obj_del(), except if object is notified on a 738 * @dev that passes @foreign_dev_check_cb, it is replicated towards all devices 739 * that pass @check_cb and are in the same bridge as @dev. 740 */ 741 int switchdev_handle_port_obj_del_foreign(struct net_device *dev, 742 struct switchdev_notifier_port_obj_info *port_obj_info, 743 bool (*check_cb)(const struct net_device *dev), 744 bool (*foreign_dev_check_cb)(const struct net_device *dev, 745 const struct net_device *foreign_dev), 746 int (*del_cb)(struct net_device *dev, const void *ctx, 747 const struct switchdev_obj *obj)) 748 { 749 int err; 750 751 err = __switchdev_handle_port_obj_del(dev, port_obj_info, check_cb, 752 foreign_dev_check_cb, del_cb); 753 if (err == -EOPNOTSUPP) 754 err = 0; 755 return err; 756 } 757 EXPORT_SYMBOL_GPL(switchdev_handle_port_obj_del_foreign); 758 759 static int __switchdev_handle_port_attr_set(struct net_device *dev, 760 struct switchdev_notifier_port_attr_info *port_attr_info, 761 bool (*check_cb)(const struct net_device *dev), 762 int (*set_cb)(struct net_device *dev, const void *ctx, 763 const struct switchdev_attr *attr, 764 struct netlink_ext_ack *extack)) 765 { 766 struct switchdev_notifier_info *info = &port_attr_info->info; 767 struct netlink_ext_ack *extack; 768 struct net_device *lower_dev; 769 struct list_head *iter; 770 int err = -EOPNOTSUPP; 771 772 extack = switchdev_notifier_info_to_extack(info); 773 774 if (check_cb(dev)) { 775 err = set_cb(dev, info->ctx, port_attr_info->attr, extack); 776 if (err != -EOPNOTSUPP) 777 port_attr_info->handled = true; 778 return err; 779 } 780 781 /* Switch ports might be stacked under e.g. a LAG. Ignore the 782 * unsupported devices, another driver might be able to handle them. But 783 * propagate to the callers any hard errors. 784 * 785 * If the driver does its own bookkeeping of stacked ports, it's not 786 * necessary to go through this helper. 787 */ 788 netdev_for_each_lower_dev(dev, lower_dev, iter) { 789 if (netif_is_bridge_master(lower_dev)) 790 continue; 791 792 err = __switchdev_handle_port_attr_set(lower_dev, port_attr_info, 793 check_cb, set_cb); 794 if (err && err != -EOPNOTSUPP) 795 return err; 796 } 797 798 return err; 799 } 800 801 int switchdev_handle_port_attr_set(struct net_device *dev, 802 struct switchdev_notifier_port_attr_info *port_attr_info, 803 bool (*check_cb)(const struct net_device *dev), 804 int (*set_cb)(struct net_device *dev, const void *ctx, 805 const struct switchdev_attr *attr, 806 struct netlink_ext_ack *extack)) 807 { 808 int err; 809 810 err = __switchdev_handle_port_attr_set(dev, port_attr_info, check_cb, 811 set_cb); 812 if (err == -EOPNOTSUPP) 813 err = 0; 814 return err; 815 } 816 EXPORT_SYMBOL_GPL(switchdev_handle_port_attr_set); 817 818 int switchdev_bridge_port_offload(struct net_device *brport_dev, 819 struct net_device *dev, const void *ctx, 820 struct notifier_block *atomic_nb, 821 struct notifier_block *blocking_nb, 822 bool tx_fwd_offload, 823 struct netlink_ext_ack *extack) 824 { 825 struct switchdev_notifier_brport_info brport_info = { 826 .brport = { 827 .dev = dev, 828 .ctx = ctx, 829 .atomic_nb = atomic_nb, 830 .blocking_nb = blocking_nb, 831 .tx_fwd_offload = tx_fwd_offload, 832 }, 833 }; 834 int err; 835 836 ASSERT_RTNL(); 837 838 err = call_switchdev_blocking_notifiers(SWITCHDEV_BRPORT_OFFLOADED, 839 brport_dev, &brport_info.info, 840 extack); 841 return notifier_to_errno(err); 842 } 843 EXPORT_SYMBOL_GPL(switchdev_bridge_port_offload); 844 845 void switchdev_bridge_port_unoffload(struct net_device *brport_dev, 846 const void *ctx, 847 struct notifier_block *atomic_nb, 848 struct notifier_block *blocking_nb) 849 { 850 struct switchdev_notifier_brport_info brport_info = { 851 .brport = { 852 .ctx = ctx, 853 .atomic_nb = atomic_nb, 854 .blocking_nb = blocking_nb, 855 }, 856 }; 857 858 ASSERT_RTNL(); 859 860 call_switchdev_blocking_notifiers(SWITCHDEV_BRPORT_UNOFFLOADED, 861 brport_dev, &brport_info.info, 862 NULL); 863 } 864 EXPORT_SYMBOL_GPL(switchdev_bridge_port_unoffload); 865 866 int switchdev_bridge_port_replay(struct net_device *brport_dev, 867 struct net_device *dev, const void *ctx, 868 struct notifier_block *atomic_nb, 869 struct notifier_block *blocking_nb, 870 struct netlink_ext_ack *extack) 871 { 872 struct switchdev_notifier_brport_info brport_info = { 873 .brport = { 874 .dev = dev, 875 .ctx = ctx, 876 .atomic_nb = atomic_nb, 877 .blocking_nb = blocking_nb, 878 }, 879 }; 880 int err; 881 882 ASSERT_RTNL(); 883 884 err = call_switchdev_blocking_notifiers(SWITCHDEV_BRPORT_REPLAY, 885 brport_dev, &brport_info.info, 886 extack); 887 return notifier_to_errno(err); 888 } 889 EXPORT_SYMBOL_GPL(switchdev_bridge_port_replay); 890