net/dsa/tag.h

   1 /* SPDX-License-Identifier: GPL-2.0-or-later */
   2
   3 #ifndef __DSA_TAG_H
   4 #define __DSA_TAG_H
   5
   6 #include <linux/if_vlan.h>
   7 #include <linux/list.h>
   8 #include <linux/types.h>
   9 #include <net/dsa.h>
  10
  11 #include "port.h"
  12 #include "user.h"
  13
  14 struct dsa_tag_driver {
  15         const struct dsa_device_ops *ops;
  16         struct list_head list;
  17         struct module *owner;
  18 };
  19
  20 extern struct packet_type dsa_pack_type;
  21
  22 const struct dsa_device_ops *dsa_tag_driver_get_by_id(int tag_protocol);
  23 const struct dsa_device_ops *dsa_tag_driver_get_by_name(const char *name);
  24 void dsa_tag_driver_put(const struct dsa_device_ops *ops);
  25 const char *dsa_tag_protocol_to_str(const struct dsa_device_ops *ops);
  26
  27 static inline int dsa_tag_protocol_overhead(const struct dsa_device_ops *ops)
  28 {
  29         return ops->needed_headroom + ops->needed_tailroom;
  30 }
  31
  32 static inline struct net_device *dsa_conduit_find_user(struct net_device *dev,
  33                                                        int device, int port)
  34 {
  35         struct dsa_port *cpu_dp = dev->dsa_ptr;
  36         struct dsa_switch_tree *dst = cpu_dp->dst;
  37         struct dsa_port *dp;
  38
  39         list_for_each_entry(dp, &dst->ports, list)
  40                 if (dp->ds->index == device && dp->index == port &&
  41                     dp->type == DSA_PORT_TYPE_USER)
  42                         return dp->user;
  43
  44         return NULL;
  45 }
  46
  47 /* If under a bridge with vlan_filtering=0, make sure to send pvid-tagged
  48  * frames as untagged, since the bridge will not untag them.
  49  */
  50 static inline struct sk_buff *dsa_untag_bridge_pvid(struct sk_buff *skb)
  51 {
  52         struct dsa_port *dp = dsa_user_to_port(skb->dev);
  53         struct net_device *br = dsa_port_bridge_dev_get(dp);
  54         struct net_device *dev = skb->dev;
  55         struct net_device *upper_dev;
  56         u16 vid, pvid, proto;
  57         int err;
  58
  59         if (!br || br_vlan_enabled(br))
  60                 return skb;
  61
  62         err = br_vlan_get_proto(br, &proto);
  63         if (err)
  64                 return skb;
  65
  66         /* Move VLAN tag from data to hwaccel */
  67         if (!skb_vlan_tag_present(skb) && skb->protocol == htons(proto)) {
  68                 skb = skb_vlan_untag(skb);
  69                 if (!skb)
  70                         return NULL;
  71         }
  72
  73         if (!skb_vlan_tag_present(skb))
  74                 return skb;
  75
  76         vid = skb_vlan_tag_get_id(skb);
  77
  78         /* We already run under an RCU read-side critical section since
  79          * we are called from netif_receive_skb_list_internal().
  80          */
  81         err = br_vlan_get_pvid_rcu(dev, &pvid);
  82         if (err)
  83                 return skb;
  84
  85         if (vid != pvid)
  86                 return skb;
  87
  88         /* The sad part about attempting to untag from DSA is that we
  89          * don't know, unless we check, if the skb will end up in
  90          * the bridge's data path - br_allowed_ingress() - or not.
  91          * For example, there might be an 8021q upper for the
  92          * default_pvid of the bridge, which will steal VLAN-tagged traffic
  93          * from the bridge's data path. This is a configuration that DSA
  94          * supports because vlan_filtering is 0. In that case, we should
  95          * definitely keep the tag, to make sure it keeps working.
  96          */
  97         upper_dev = __vlan_find_dev_deep_rcu(br, htons(proto), vid);
  98         if (upper_dev)
  99                 return skb;
 100
 101         __vlan_hwaccel_clear_tag(skb);
 102
 103         return skb;
 104 }
 105
 106 /* For switches without hardware support for DSA tagging to be able
 107  * to support termination through the bridge.
 108  */
 109 static inline struct net_device *
 110 dsa_find_designated_bridge_port_by_vid(struct net_device *conduit, u16 vid)
 111 {
 112         struct dsa_port *cpu_dp = conduit->dsa_ptr;
 113         struct dsa_switch_tree *dst = cpu_dp->dst;
 114         struct bridge_vlan_info vinfo;
 115         struct net_device *user;
 116         struct dsa_port *dp;
 117         int err;
 118
 119         list_for_each_entry(dp, &dst->ports, list) {
 120                 if (dp->type != DSA_PORT_TYPE_USER)
 121                         continue;
 122
 123                 if (!dp->bridge)
 124                         continue;
 125
 126                 if (dp->stp_state != BR_STATE_LEARNING &&
 127                     dp->stp_state != BR_STATE_FORWARDING)
 128                         continue;
 129
 130                 /* Since the bridge might learn this packet, keep the CPU port
 131                  * affinity with the port that will be used for the reply on
 132                  * xmit.
 133                  */
 134                 if (dp->cpu_dp != cpu_dp)
 135                         continue;
 136
 137                 user = dp->user;
 138
 139                 err = br_vlan_get_info_rcu(user, vid, &vinfo);
 140                 if (err)
 141                         continue;
 142
 143                 return user;
 144         }
 145
 146         return NULL;
 147 }
 148
 149 /* If the ingress port offloads the bridge, we mark the frame as autonomously
 150  * forwarded by hardware, so the software bridge doesn't forward in twice, back
 151  * to us, because we already did. However, if we're in fallback mode and we do
 152  * software bridging, we are not offloading it, therefore the dp->bridge
 153  * pointer is not populated, and flooding needs to be done by software (we are
 154  * effectively operating in standalone ports mode).
 155  */
 156 static inline void dsa_default_offload_fwd_mark(struct sk_buff *skb)
 157 {
 158         struct dsa_port *dp = dsa_user_to_port(skb->dev);
 159
 160         skb->offload_fwd_mark = !!(dp->bridge);
 161 }
 162
 163 /* Helper for removing DSA header tags from packets in the RX path.
 164  * Must not be called before skb_pull(len).
 165  *                                                                 skb->data
 166  *                                                                         |
 167  *                                                                         v
 168  * |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |
 169  * +-----------------------+-----------------------+---------------+-------+
 170  * |    Destination MAC    |      Source MAC       |  DSA header   | EType |
 171  * +-----------------------+-----------------------+---------------+-------+
 172  *                                                 |               |
 173  * <----- len ----->                               <----- len ----->
 174  *                 |
 175  *       >>>>>>>   v
 176  *       >>>>>>>   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |
 177  *       >>>>>>>   +-----------------------+-----------------------+-------+
 178  *       >>>>>>>   |    Destination MAC    |      Source MAC       | EType |
 179  *                 +-----------------------+-----------------------+-------+
 180  *                                                                         ^
 181  *                                                                         |
 182  *                                                                 skb->data
 183  */
 184 static inline void dsa_strip_etype_header(struct sk_buff *skb, int len)
 185 {
 186         memmove(skb->data - ETH_HLEN, skb->data - ETH_HLEN - len, 2 * ETH_ALEN);
 187 }
 188
 189 /* Helper for creating space for DSA header tags in TX path packets.
 190  * Must not be called before skb_push(len).
 191  *
 192  * Before:
 193  *
 194  *       <<<<<<<   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |
 195  * ^     <<<<<<<   +-----------------------+-----------------------+-------+
 196  * |     <<<<<<<   |    Destination MAC    |      Source MAC       | EType |
 197  * |               +-----------------------+-----------------------+-------+
 198  * <----- len ----->
 199  * |
 200  * |
 201  * skb->data
 202  *
 203  * After:
 204  *
 205  * |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |
 206  * +-----------------------+-----------------------+---------------+-------+
 207  * |    Destination MAC    |      Source MAC       |  DSA header   | EType |
 208  * +-----------------------+-----------------------+---------------+-------+
 209  * ^                                               |               |
 210  * |                                               <----- len ----->
 211  * skb->data
 212  */
 213 static inline void dsa_alloc_etype_header(struct sk_buff *skb, int len)
 214 {
 215         memmove(skb->data, skb->data + len, 2 * ETH_ALEN);
 216 }
 217
 218 /* On RX, eth_type_trans() on the DSA conduit pulls ETH_HLEN bytes starting from
 219  * skb_mac_header(skb), which leaves skb->data pointing at the first byte after
 220  * what the DSA conduit perceives as the EtherType (the beginning of the L3
 221  * protocol). Since DSA EtherType header taggers treat the EtherType as part of
 222  * the DSA tag itself, and the EtherType is 2 bytes in length, the DSA header
 223  * is located 2 bytes behind skb->data. Note that EtherType in this context
 224  * means the first 2 bytes of the DSA header, not the encapsulated EtherType
 225  * that will become visible after the DSA header is stripped.
 226  */
 227 static inline void *dsa_etype_header_pos_rx(struct sk_buff *skb)
 228 {
 229         return skb->data - 2;
 230 }
 231
 232 /* On TX, skb->data points to the MAC header, which means that EtherType
 233  * header taggers start exactly where the EtherType is (the EtherType is
 234  * treated as part of the DSA header).
 235  */
 236 static inline void *dsa_etype_header_pos_tx(struct sk_buff *skb)
 237 {
 238         return skb->data + 2 * ETH_ALEN;
 239 }
 240
 241 /* Create 2 modaliases per tagging protocol, one to auto-load the module
 242  * given the ID reported by get_tag_protocol(), and the other by name.
 243  */
 244 #define DSA_TAG_DRIVER_ALIAS "dsa_tag:"
 245 #define MODULE_ALIAS_DSA_TAG_DRIVER(__proto, __name) \
 246         MODULE_ALIAS(DSA_TAG_DRIVER_ALIAS __name); \
 247         MODULE_ALIAS(DSA_TAG_DRIVER_ALIAS "id-" \
 248                      __stringify(__proto##_VALUE))
 249
 250 void dsa_tag_drivers_register(struct dsa_tag_driver *dsa_tag_driver_array[],
 251                               unsigned int count,
 252                               struct module *owner);
 253 void dsa_tag_drivers_unregister(struct dsa_tag_driver *dsa_tag_driver_array[],
 254                                 unsigned int count);
 255
 256 #define dsa_tag_driver_module_drivers(__dsa_tag_drivers_array, __count) \
 257 static int __init dsa_tag_driver_module_init(void)                      \
 258 {                                                                       \
 259         dsa_tag_drivers_register(__dsa_tag_drivers_array, __count,      \
 260                                  THIS_MODULE);                          \
 261         return 0;                                                       \
 262 }                                                                       \
 263 module_init(dsa_tag_driver_module_init);                                \
 264                                                                         \
 265 static void __exit dsa_tag_driver_module_exit(void)                     \
 266 {                                                                       \
 267         dsa_tag_drivers_unregister(__dsa_tag_drivers_array, __count);   \
 268 }                                                                       \
 269 module_exit(dsa_tag_driver_module_exit)
 270
 271 /**
 272  * module_dsa_tag_drivers() - Helper macro for registering DSA tag
 273  * drivers
 274  * @__ops_array: Array of tag driver structures
 275  *
 276  * Helper macro for DSA tag drivers which do not do anything special
 277  * in module init/exit. Each module may only use this macro once, and
 278  * calling it replaces module_init() and module_exit().
 279  */
 280 #define module_dsa_tag_drivers(__ops_array)                             \
 281 dsa_tag_driver_module_drivers(__ops_array, ARRAY_SIZE(__ops_array))
 282
 283 #define DSA_TAG_DRIVER_NAME(__ops) dsa_tag_driver ## _ ## __ops
 284
 285 /* Create a static structure we can build a linked list of dsa_tag
 286  * drivers
 287  */
 288 #define DSA_TAG_DRIVER(__ops)                                           \
 289 static struct dsa_tag_driver DSA_TAG_DRIVER_NAME(__ops) = {             \
 290         .ops = &__ops,                                                  \
 291 }
 292
 293 /**
 294  * module_dsa_tag_driver() - Helper macro for registering a single DSA tag
 295  * driver
 296  * @__ops: Single tag driver structures
 297  *
 298  * Helper macro for DSA tag drivers which do not do anything special
 299  * in module init/exit. Each module may only use this macro once, and
 300  * calling it replaces module_init() and module_exit().
 301  */
 302 #define module_dsa_tag_driver(__ops)                                    \
 303 DSA_TAG_DRIVER(__ops);                                                  \
 304                                                                         \
 305 static struct dsa_tag_driver *dsa_tag_driver_array[] =  {               \
 306         &DSA_TAG_DRIVER_NAME(__ops)                                     \
 307 };                                                                      \
 308 module_dsa_tag_drivers(dsa_tag_driver_array)
 309
 310 #endif