net/bridge/br_switchdev.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <linux/kernel.h>
   3 #include <linux/list.h>
   4 #include <linux/netdevice.h>
   5 #include <linux/rtnetlink.h>
   6 #include <linux/skbuff.h>
   7 #include <net/switchdev.h>
   8
   9 #include "br_private.h"
  10
  11 static int br_switchdev_mark_get(struct net_bridge *br, struct net_device *dev)
  12 {
  13         struct net_bridge_port *p;
  14
  15         /* dev is yet to be added to the port list. */
  16         list_for_each_entry(p, &br->port_list, list) {
  17                 if (netdev_port_same_parent_id(dev, p->dev))
  18                         return p->offload_fwd_mark;
  19         }
  20
  21         return ++br->offload_fwd_mark;
  22 }
  23
  24 int nbp_switchdev_mark_set(struct net_bridge_port *p)
  25 {
  26         struct netdev_phys_item_id ppid = { };
  27         int err;
  28
  29         ASSERT_RTNL();
  30
  31         err = dev_get_port_parent_id(p->dev, &ppid, true);
  32         if (err) {
  33                 if (err == -EOPNOTSUPP)
  34                         return 0;
  35                 return err;
  36         }
  37
  38         p->offload_fwd_mark = br_switchdev_mark_get(p->br, p->dev);
  39
  40         return 0;
  41 }
  42
  43 void nbp_switchdev_frame_mark(const struct net_bridge_port *p,
  44                               struct sk_buff *skb)
  45 {
  46         if (skb->offload_fwd_mark && !WARN_ON_ONCE(!p->offload_fwd_mark))
  47                 BR_INPUT_SKB_CB(skb)->offload_fwd_mark = p->offload_fwd_mark;
  48 }
  49
  50 bool nbp_switchdev_allowed_egress(const struct net_bridge_port *p,
  51                                   const struct sk_buff *skb)
  52 {
  53         return !skb->offload_fwd_mark ||
  54                BR_INPUT_SKB_CB(skb)->offload_fwd_mark != p->offload_fwd_mark;
  55 }
  56
  57 /* Flags that can be offloaded to hardware */
  58 #define BR_PORT_FLAGS_HW_OFFLOAD (BR_LEARNING | BR_FLOOD | \
  59                                   BR_MCAST_FLOOD | BR_BCAST_FLOOD)
  60
  61 int br_switchdev_set_port_flag(struct net_bridge_port *p,
  62                                unsigned long flags,
  63                                unsigned long mask,
  64                                struct netlink_ext_ack *extack)
  65 {
  66         struct switchdev_attr attr = {
  67                 .orig_dev = p->dev,
  68         };
  69         struct switchdev_notifier_port_attr_info info = {
  70                 .attr = &attr,
  71         };
  72         int err;
  73
  74         mask &= BR_PORT_FLAGS_HW_OFFLOAD;
  75         if (!mask)
  76                 return 0;
  77
  78         attr.id = SWITCHDEV_ATTR_ID_PORT_PRE_BRIDGE_FLAGS;
  79         attr.u.brport_flags.val = flags;
  80         attr.u.brport_flags.mask = mask;
  81
  82         /* We run from atomic context here */
  83         err = call_switchdev_notifiers(SWITCHDEV_PORT_ATTR_SET, p->dev,
  84                                        &info.info, extack);
  85         err = notifier_to_errno(err);
  86         if (err == -EOPNOTSUPP)
  87                 return 0;
  88
  89         if (err) {
  90                 if (extack && !extack->_msg)
  91                         NL_SET_ERR_MSG_MOD(extack,
  92                                            "bridge flag offload is not supported");
  93                 return -EOPNOTSUPP;
  94         }
  95
  96         attr.id = SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS;
  97         attr.flags = SWITCHDEV_F_DEFER;
  98
  99         err = switchdev_port_attr_set(p->dev, &attr, extack);
 100         if (err) {
 101                 if (extack && !extack->_msg)
 102                         NL_SET_ERR_MSG_MOD(extack,
 103                                            "error setting offload flag on port");
 104                 return err;
 105         }
 106
 107         return 0;
 108 }
 109
 110 static void
 111 br_switchdev_fdb_call_notifiers(bool adding, const unsigned char *mac,
 112                                 u16 vid, struct net_device *dev,
 113                                 bool added_by_user, bool offloaded)
 114 {
 115         struct switchdev_notifier_fdb_info info;
 116         unsigned long notifier_type;
 117
 118         info.addr = mac;
 119         info.vid = vid;
 120         info.added_by_user = added_by_user;
 121         info.offloaded = offloaded;
 122         notifier_type = adding ? SWITCHDEV_FDB_ADD_TO_DEVICE : SWITCHDEV_FDB_DEL_TO_DEVICE;
 123         call_switchdev_notifiers(notifier_type, dev, &info.info, NULL);
 124 }
 125
 126 void
 127 br_switchdev_fdb_notify(const struct net_bridge_fdb_entry *fdb, int type)
 128 {
 129         if (!fdb->dst)
 130                 return;
 131
 132         switch (type) {
 133         case RTM_DELNEIGH:
 134                 br_switchdev_fdb_call_notifiers(false, fdb->key.addr.addr,
 135                                                 fdb->key.vlan_id,
 136                                                 fdb->dst->dev,
 137                                                 test_bit(BR_FDB_ADDED_BY_USER,
 138                                                          &fdb->flags),
 139                                                 test_bit(BR_FDB_OFFLOADED,
 140                                                          &fdb->flags));
 141                 break;
 142         case RTM_NEWNEIGH:
 143                 br_switchdev_fdb_call_notifiers(true, fdb->key.addr.addr,
 144                                                 fdb->key.vlan_id,
 145                                                 fdb->dst->dev,
 146                                                 test_bit(BR_FDB_ADDED_BY_USER,
 147                                                          &fdb->flags),
 148                                                 test_bit(BR_FDB_OFFLOADED,
 149                                                          &fdb->flags));
 150                 break;
 151         }
 152 }
 153
 154 int br_switchdev_port_vlan_add(struct net_device *dev, u16 vid, u16 flags,
 155                                struct netlink_ext_ack *extack)
 156 {
 157         struct switchdev_obj_port_vlan v = {
 158                 .obj.orig_dev = dev,
 159                 .obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN,
 160                 .flags = flags,
 161                 .vid = vid,
 162         };
 163
 164         return switchdev_port_obj_add(dev, &v.obj, extack);
 165 }
 166
 167 int br_switchdev_port_vlan_del(struct net_device *dev, u16 vid)
 168 {
 169         struct switchdev_obj_port_vlan v = {
 170                 .obj.orig_dev = dev,
 171                 .obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN,
 172                 .vid = vid,
 173         };
 174
 175         return switchdev_port_obj_del(dev, &v.obj);
 176 }