lib/net/rte_ether.h

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2010-2014 Intel Corporation
   3  */
   4
   5 #ifndef _RTE_ETHER_H_
   6 #define _RTE_ETHER_H_
   7
   8 /**
   9  * @file
  10  *
  11  * Ethernet Helpers in RTE
  12  */
  13
  14 #ifdef __cplusplus
  15 extern "C" {
  16 #endif
  17
  18 #include <stdint.h>
  19 #include <stdio.h>
  20
  21 #include <rte_memcpy.h>
  22 #include <rte_random.h>
  23 #include <rte_mbuf.h>
  24 #include <rte_byteorder.h>
  25
  26 #define RTE_ETHER_ADDR_LEN  6 /**< Length of Ethernet address. */
  27 #define RTE_ETHER_TYPE_LEN  2 /**< Length of Ethernet type field. */
  28 #define RTE_ETHER_CRC_LEN   4 /**< Length of Ethernet CRC. */
  29 #define RTE_ETHER_HDR_LEN   \
  30         (RTE_ETHER_ADDR_LEN * 2 + \
  31                 RTE_ETHER_TYPE_LEN) /**< Length of Ethernet header. */
  32 #define RTE_ETHER_MIN_LEN   64    /**< Minimum frame len, including CRC. */
  33 #define RTE_ETHER_MAX_LEN   1518  /**< Maximum frame len, including CRC. */
  34 #define RTE_ETHER_MTU       \
  35         (RTE_ETHER_MAX_LEN - RTE_ETHER_HDR_LEN - \
  36                 RTE_ETHER_CRC_LEN) /**< Ethernet MTU. */
  37
  38 #define RTE_VLAN_HLEN       4  /**< VLAN (IEEE 802.1Q) header length. */
  39 /** Maximum VLAN frame length (excluding QinQ), including CRC. */
  40 #define RTE_ETHER_MAX_VLAN_FRAME_LEN \
  41         (RTE_ETHER_MAX_LEN + RTE_VLAN_HLEN)
  42
  43 #define RTE_ETHER_MAX_JUMBO_FRAME_LEN \
  44         0x3F00 /**< Maximum Jumbo frame length, including CRC. */
  45
  46 #define RTE_ETHER_MAX_VLAN_ID  4095 /**< Maximum VLAN ID. */
  47
  48 #define RTE_ETHER_MIN_MTU 68 /**< Minimum MTU for IPv4 packets, see RFC 791. */
  49
  50 /**
  51  * Ethernet address:
  52  * A universally administered address is uniquely assigned to a device by its
  53  * manufacturer. The first three octets (in transmission order) contain the
  54  * Organizationally Unique Identifier (OUI). The following three (MAC-48 and
  55  * EUI-48) octets are assigned by that organization with the only constraint
  56  * of uniqueness.
  57  * A locally administered address is assigned to a device by a network
  58  * administrator and does not contain OUIs.
  59  * See http://standards.ieee.org/regauth/groupmac/tutorial.html
  60  */
  61 struct rte_ether_addr {
  62         uint8_t addr_bytes[RTE_ETHER_ADDR_LEN]; /**< Addr bytes in tx order */
  63 } __rte_aligned(2);
  64
  65 #define RTE_ETHER_LOCAL_ADMIN_ADDR 0x02 /**< Locally assigned Eth. address. */
  66 #define RTE_ETHER_GROUP_ADDR  0x01 /**< Multicast or broadcast Eth. address. */
  67
  68 /**
  69  * Check if two Ethernet addresses are the same.
  70  *
  71  * @param ea1
  72  *  A pointer to the first ether_addr structure containing
  73  *  the ethernet address.
  74  * @param ea2
  75  *  A pointer to the second ether_addr structure containing
  76  *  the ethernet address.
  77  *
  78  * @return
  79  *  True  (1) if the given two ethernet address are the same;
  80  *  False (0) otherwise.
  81  */
  82 static inline int rte_is_same_ether_addr(const struct rte_ether_addr *ea1,
  83                                      const struct rte_ether_addr *ea2)
  84 {
  85         const uint16_t *w1 = (const uint16_t *)ea1;
  86         const uint16_t *w2 = (const uint16_t *)ea2;
  87
  88         return ((w1[0] ^ w2[0]) | (w1[1] ^ w2[1]) | (w1[2] ^ w2[2])) == 0;
  89 }
  90
  91 /**
  92  * Check if an Ethernet address is filled with zeros.
  93  *
  94  * @param ea
  95  *   A pointer to a ether_addr structure containing the ethernet address
  96  *   to check.
  97  * @return
  98  *   True  (1) if the given ethernet address is filled with zeros;
  99  *   false (0) otherwise.
 100  */
 101 static inline int rte_is_zero_ether_addr(const struct rte_ether_addr *ea)
 102 {
 103         const uint16_t *w = (const uint16_t *)ea;
 104
 105         return (w[0] | w[1] | w[2]) == 0;
 106 }
 107
 108 /**
 109  * Check if an Ethernet address is a unicast address.
 110  *
 111  * @param ea
 112  *   A pointer to a ether_addr structure containing the ethernet address
 113  *   to check.
 114  * @return
 115  *   True  (1) if the given ethernet address is a unicast address;
 116  *   false (0) otherwise.
 117  */
 118 static inline int rte_is_unicast_ether_addr(const struct rte_ether_addr *ea)
 119 {
 120         return (ea->addr_bytes[0] & RTE_ETHER_GROUP_ADDR) == 0;
 121 }
 122
 123 /**
 124  * Check if an Ethernet address is a multicast address.
 125  *
 126  * @param ea
 127  *   A pointer to a ether_addr structure containing the ethernet address
 128  *   to check.
 129  * @return
 130  *   True  (1) if the given ethernet address is a multicast address;
 131  *   false (0) otherwise.
 132  */
 133 static inline int rte_is_multicast_ether_addr(const struct rte_ether_addr *ea)
 134 {
 135         return ea->addr_bytes[0] & RTE_ETHER_GROUP_ADDR;
 136 }
 137
 138 /**
 139  * Check if an Ethernet address is a broadcast address.
 140  *
 141  * @param ea
 142  *   A pointer to a ether_addr structure containing the ethernet address
 143  *   to check.
 144  * @return
 145  *   True  (1) if the given ethernet address is a broadcast address;
 146  *   false (0) otherwise.
 147  */
 148 static inline int rte_is_broadcast_ether_addr(const struct rte_ether_addr *ea)
 149 {
 150         const uint16_t *w = (const uint16_t *)ea;
 151
 152         return (w[0] & w[1] & w[2]) == 0xFFFF;
 153 }
 154
 155 /**
 156  * Check if an Ethernet address is a universally assigned address.
 157  *
 158  * @param ea
 159  *   A pointer to a ether_addr structure containing the ethernet address
 160  *   to check.
 161  * @return
 162  *   True  (1) if the given ethernet address is a universally assigned address;
 163  *   false (0) otherwise.
 164  */
 165 static inline int rte_is_universal_ether_addr(const struct rte_ether_addr *ea)
 166 {
 167         return (ea->addr_bytes[0] & RTE_ETHER_LOCAL_ADMIN_ADDR) == 0;
 168 }
 169
 170 /**
 171  * Check if an Ethernet address is a locally assigned address.
 172  *
 173  * @param ea
 174  *   A pointer to a ether_addr structure containing the ethernet address
 175  *   to check.
 176  * @return
 177  *   True  (1) if the given ethernet address is a locally assigned address;
 178  *   false (0) otherwise.
 179  */
 180 static inline int rte_is_local_admin_ether_addr(const struct rte_ether_addr *ea)
 181 {
 182         return (ea->addr_bytes[0] & RTE_ETHER_LOCAL_ADMIN_ADDR) != 0;
 183 }
 184
 185 /**
 186  * Check if an Ethernet address is a valid address. Checks that the address is a
 187  * unicast address and is not filled with zeros.
 188  *
 189  * @param ea
 190  *   A pointer to a ether_addr structure containing the ethernet address
 191  *   to check.
 192  * @return
 193  *   True  (1) if the given ethernet address is valid;
 194  *   false (0) otherwise.
 195  */
 196 static inline int rte_is_valid_assigned_ether_addr(const struct rte_ether_addr *ea)
 197 {
 198         return rte_is_unicast_ether_addr(ea) && (!rte_is_zero_ether_addr(ea));
 199 }
 200
 201 /**
 202  * Generate a random Ethernet address that is locally administered
 203  * and not multicast.
 204  * @param addr
 205  *   A pointer to Ethernet address.
 206  */
 207 void
 208 rte_eth_random_addr(uint8_t *addr);
 209
 210 /**
 211  * Copy an Ethernet address.
 212  *
 213  * @param ea_from
 214  *   A pointer to a ether_addr structure holding the Ethernet address to copy.
 215  * @param ea_to
 216  *   A pointer to a ether_addr structure where to copy the Ethernet address.
 217  */
 218 static inline void
 219 rte_ether_addr_copy(const struct rte_ether_addr *__restrict ea_from,
 220                     struct rte_ether_addr *__restrict ea_to)
 221 {
 222         *ea_to = *ea_from;
 223 }
 224
 225 /**
 226  * Macro to print six-bytes of MAC address in hex format
 227  */
 228 #define RTE_ETHER_ADDR_PRT_FMT     "%02X:%02X:%02X:%02X:%02X:%02X"
 229 /**
 230  * Macro to extract the MAC address bytes from rte_ether_addr struct
 231  */
 232 #define RTE_ETHER_ADDR_BYTES(mac_addrs) ((mac_addrs)->addr_bytes[0]), \
 233                                          ((mac_addrs)->addr_bytes[1]), \
 234                                          ((mac_addrs)->addr_bytes[2]), \
 235                                          ((mac_addrs)->addr_bytes[3]), \
 236                                          ((mac_addrs)->addr_bytes[4]), \
 237                                          ((mac_addrs)->addr_bytes[5])
 238
 239 #define RTE_ETHER_ADDR_FMT_SIZE         18
 240 /**
 241  * Format 48bits Ethernet address in pattern xx:xx:xx:xx:xx:xx.
 242  *
 243  * @param buf
 244  *   A pointer to buffer contains the formatted MAC address.
 245  * @param size
 246  *   The format buffer size.
 247  * @param eth_addr
 248  *   A pointer to a ether_addr structure.
 249  */
 250 void
 251 rte_ether_format_addr(char *buf, uint16_t size,
 252                       const struct rte_ether_addr *eth_addr);
 253 /**
 254  * Convert string with Ethernet address to an ether_addr.
 255  *
 256  * @param str
 257  *   A pointer to buffer contains the formatted MAC address.
 258  *   The supported formats are:
 259  *     XX:XX:XX:XX:XX:XX or XXXX:XXXX:XXXX
 260  *   where XX is a hex digit: 0-9, a-f, or A-F.
 261  * @param eth_addr
 262  *   A pointer to a ether_addr structure.
 263  * @return
 264  *   0 if successful
 265  *   -1 and sets rte_errno if invalid string
 266  */
 267 int
 268 rte_ether_unformat_addr(const char *str, struct rte_ether_addr *eth_addr);
 269
 270 /**
 271  * Ethernet header: Contains the destination address, source address
 272  * and frame type.
 273  */
 274 struct rte_ether_hdr {
 275         struct rte_ether_addr dst_addr; /**< Destination address. */
 276         struct rte_ether_addr src_addr; /**< Source address. */
 277         rte_be16_t ether_type; /**< Frame type. */
 278 } __rte_aligned(2);
 279
 280 /**
 281  * Ethernet VLAN Header.
 282  * Contains the 16-bit VLAN Tag Control Identifier and the Ethernet type
 283  * of the encapsulated frame.
 284  */
 285 struct rte_vlan_hdr {
 286         rte_be16_t vlan_tci;  /**< Priority (3) + CFI (1) + Identifier Code (12) */
 287         rte_be16_t eth_proto; /**< Ethernet type of encapsulated frame. */
 288 } __rte_packed;
 289
 290
 291
 292 /* Ethernet frame types */
 293 #define RTE_ETHER_TYPE_IPV4 0x0800 /**< IPv4 Protocol. */
 294 #define RTE_ETHER_TYPE_IPV6 0x86DD /**< IPv6 Protocol. */
 295 #define RTE_ETHER_TYPE_ARP  0x0806 /**< Arp Protocol. */
 296 #define RTE_ETHER_TYPE_RARP 0x8035 /**< Reverse Arp Protocol. */
 297 #define RTE_ETHER_TYPE_VLAN 0x8100 /**< IEEE 802.1Q VLAN tagging. */
 298 #define RTE_ETHER_TYPE_QINQ 0x88A8 /**< IEEE 802.1ad QinQ tagging. */
 299 #define RTE_ETHER_TYPE_QINQ1 0x9100 /**< Deprecated QinQ VLAN. */
 300 #define RTE_ETHER_TYPE_QINQ2 0x9200 /**< Deprecated QinQ VLAN. */
 301 #define RTE_ETHER_TYPE_QINQ3 0x9300 /**< Deprecated QinQ VLAN. */
 302 #define RTE_ETHER_TYPE_PPPOE_DISCOVERY 0x8863 /**< PPPoE Discovery Stage. */
 303 #define RTE_ETHER_TYPE_PPPOE_SESSION 0x8864 /**< PPPoE Session Stage. */
 304 #define RTE_ETHER_TYPE_ETAG 0x893F /**< IEEE 802.1BR E-Tag. */
 305 #define RTE_ETHER_TYPE_1588 0x88F7
 306         /**< IEEE 802.1AS 1588 Precise Time Protocol. */
 307 #define RTE_ETHER_TYPE_SLOW 0x8809 /**< Slow protocols (LACP and Marker). */
 308 #define RTE_ETHER_TYPE_TEB  0x6558 /**< Transparent Ethernet Bridging. */
 309 #define RTE_ETHER_TYPE_LLDP 0x88CC /**< LLDP Protocol. */
 310 #define RTE_ETHER_TYPE_MPLS 0x8847 /**< MPLS ethertype. */
 311 #define RTE_ETHER_TYPE_MPLSM 0x8848 /**< MPLS multicast ethertype. */
 312 #define RTE_ETHER_TYPE_ECPRI 0xAEFE /**< eCPRI ethertype (.1Q supported). */
 313
 314 /**
 315  * Extract VLAN tag information into mbuf
 316  *
 317  * Software version of VLAN stripping
 318  *
 319  * @param m
 320  *   The packet mbuf.
 321  * @return
 322  *   - 0: Success
 323  *   - 1: not a vlan packet
 324  */
 325 static inline int rte_vlan_strip(struct rte_mbuf *m)
 326 {
 327         struct rte_ether_hdr *eh
 328                  = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
 329         struct rte_vlan_hdr *vh;
 330
 331         if (eh->ether_type != rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN))
 332                 return -1;
 333
 334         vh = (struct rte_vlan_hdr *)(eh + 1);
 335         m->ol_flags |= RTE_MBUF_F_RX_VLAN | RTE_MBUF_F_RX_VLAN_STRIPPED;
 336         m->vlan_tci = rte_be_to_cpu_16(vh->vlan_tci);
 337
 338         /* Copy ether header over rather than moving whole packet */
 339         memmove(rte_pktmbuf_adj(m, sizeof(struct rte_vlan_hdr)),
 340                 eh, 2 * RTE_ETHER_ADDR_LEN);
 341
 342         return 0;
 343 }
 344
 345 /**
 346  * Insert VLAN tag into mbuf.
 347  *
 348  * Software version of VLAN unstripping
 349  *
 350  * @param m
 351  *   The packet mbuf.
 352  * @return
 353  *   - 0: On success
 354  *   -EPERM: mbuf is is shared overwriting would be unsafe
 355  *   -ENOSPC: not enough headroom in mbuf
 356  */
 357 static inline int rte_vlan_insert(struct rte_mbuf **m)
 358 {
 359         struct rte_ether_hdr *oh, *nh;
 360         struct rte_vlan_hdr *vh;
 361
 362         /* Can't insert header if mbuf is shared */
 363         if (!RTE_MBUF_DIRECT(*m) || rte_mbuf_refcnt_read(*m) > 1)
 364                 return -EINVAL;
 365
 366         /* Can't insert header if the first segment is too short */
 367         if (rte_pktmbuf_data_len(*m) < 2 * RTE_ETHER_ADDR_LEN)
 368                 return -EINVAL;
 369
 370         oh = rte_pktmbuf_mtod(*m, struct rte_ether_hdr *);
 371         nh = (struct rte_ether_hdr *)(void *)
 372                 rte_pktmbuf_prepend(*m, sizeof(struct rte_vlan_hdr));
 373         if (nh == NULL)
 374                 return -ENOSPC;
 375
 376         memmove(nh, oh, 2 * RTE_ETHER_ADDR_LEN);
 377         nh->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN);
 378
 379         vh = (struct rte_vlan_hdr *) (nh + 1);
 380         vh->vlan_tci = rte_cpu_to_be_16((*m)->vlan_tci);
 381
 382         (*m)->ol_flags &= ~(RTE_MBUF_F_RX_VLAN_STRIPPED | RTE_MBUF_F_TX_VLAN);
 383
 384         if ((*m)->ol_flags & RTE_MBUF_F_TX_TUNNEL_MASK)
 385                 (*m)->outer_l2_len += sizeof(struct rte_vlan_hdr);
 386         else
 387                 (*m)->l2_len += sizeof(struct rte_vlan_hdr);
 388
 389         return 0;
 390 }
 391
 392 #ifdef __cplusplus
 393 }
 394 #endif
 395
 396 #endif /* _RTE_ETHER_H_ */