Merge tag 'x86-entry-2021-02-24' of git://git.kernel.org/pub/scm/linux/kernel/git...
[linux-2.6-microblaze.git] / 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 }