lib/librte_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 #ifndef RTE_NET_NO_COMPAT
  27 #include <rte_ether_compat.h>
  28 #endif
  29
  30 #define RTE_ETHER_ADDR_LEN  6 /**< Length of Ethernet address. */
  31 #define RTE_ETHER_TYPE_LEN  2 /**< Length of Ethernet type field. */
  32 #define RTE_ETHER_CRC_LEN   4 /**< Length of Ethernet CRC. */
  33 #define RTE_ETHER_HDR_LEN   \
  34         (RTE_ETHER_ADDR_LEN * 2 + RTE_ETHER_TYPE_LEN) /**< Length of Ethernet header. */
  35 #define RTE_ETHER_MIN_LEN   64    /**< Minimum frame len, including CRC. */
  36 #define RTE_ETHER_MAX_LEN   1518  /**< Maximum frame len, including CRC. */
  37 #define RTE_ETHER_MTU       \
  38         (RTE_ETHER_MAX_LEN - RTE_ETHER_HDR_LEN - RTE_ETHER_CRC_LEN) /**< Ethernet MTU. */
  39
  40 #define RTE_ETHER_MAX_VLAN_FRAME_LEN \
  41         (RTE_ETHER_MAX_LEN + 4) /**< Maximum VLAN frame length, including CRC. */
  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 } __attribute__((__packed__));
  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         int i;
  86         for (i = 0; i < RTE_ETHER_ADDR_LEN; i++)
  87                 if (ea1->addr_bytes[i] != ea2->addr_bytes[i])
  88                         return 0;
  89         return 1;
  90 }
  91
  92 /**
  93  * Check if an Ethernet address is filled with zeros.
  94  *
  95  * @param ea
  96  *   A pointer to a ether_addr structure containing the ethernet address
  97  *   to check.
  98  * @return
  99  *   True  (1) if the given ethernet address is filled with zeros;
 100  *   false (0) otherwise.
 101  */
 102 static inline int rte_is_zero_ether_addr(const struct rte_ether_addr *ea)
 103 {
 104         int i;
 105         for (i = 0; i < RTE_ETHER_ADDR_LEN; i++)
 106                 if (ea->addr_bytes[i] != 0x00)
 107                         return 0;
 108         return 1;
 109 }
 110
 111 /**
 112  * Check if an Ethernet address is a unicast address.
 113  *
 114  * @param ea
 115  *   A pointer to a ether_addr structure containing the ethernet address
 116  *   to check.
 117  * @return
 118  *   True  (1) if the given ethernet address is a unicast address;
 119  *   false (0) otherwise.
 120  */
 121 static inline int rte_is_unicast_ether_addr(const struct rte_ether_addr *ea)
 122 {
 123         return (ea->addr_bytes[0] & RTE_ETHER_GROUP_ADDR) == 0;
 124 }
 125
 126 /**
 127  * Check if an Ethernet address is a multicast address.
 128  *
 129  * @param ea
 130  *   A pointer to a ether_addr structure containing the ethernet address
 131  *   to check.
 132  * @return
 133  *   True  (1) if the given ethernet address is a multicast address;
 134  *   false (0) otherwise.
 135  */
 136 static inline int rte_is_multicast_ether_addr(const struct rte_ether_addr *ea)
 137 {
 138         return ea->addr_bytes[0] & RTE_ETHER_GROUP_ADDR;
 139 }
 140
 141 /**
 142  * Check if an Ethernet address is a broadcast address.
 143  *
 144  * @param ea
 145  *   A pointer to a ether_addr structure containing the ethernet address
 146  *   to check.
 147  * @return
 148  *   True  (1) if the given ethernet address is a broadcast address;
 149  *   false (0) otherwise.
 150  */
 151 static inline int rte_is_broadcast_ether_addr(const struct rte_ether_addr *ea)
 152 {
 153         const unaligned_uint16_t *ea_words = (const unaligned_uint16_t *)ea;
 154
 155         return (ea_words[0] == 0xFFFF && ea_words[1] == 0xFFFF &&
 156                 ea_words[2] == 0xFFFF);
 157 }
 158
 159 /**
 160  * Check if an Ethernet address is a universally assigned address.
 161  *
 162  * @param ea
 163  *   A pointer to a ether_addr structure containing the ethernet address
 164  *   to check.
 165  * @return
 166  *   True  (1) if the given ethernet address is a universally assigned address;
 167  *   false (0) otherwise.
 168  */
 169 static inline int rte_is_universal_ether_addr(const struct rte_ether_addr *ea)
 170 {
 171         return (ea->addr_bytes[0] & RTE_ETHER_LOCAL_ADMIN_ADDR) == 0;
 172 }
 173
 174 /**
 175  * Check if an Ethernet address is a locally assigned address.
 176  *
 177  * @param ea
 178  *   A pointer to a ether_addr structure containing the ethernet address
 179  *   to check.
 180  * @return
 181  *   True  (1) if the given ethernet address is a locally assigned address;
 182  *   false (0) otherwise.
 183  */
 184 static inline int rte_is_local_admin_ether_addr(const struct rte_ether_addr *ea)
 185 {
 186         return (ea->addr_bytes[0] & RTE_ETHER_LOCAL_ADMIN_ADDR) != 0;
 187 }
 188
 189 /**
 190  * Check if an Ethernet address is a valid address. Checks that the address is a
 191  * unicast address and is not filled with zeros.
 192  *
 193  * @param ea
 194  *   A pointer to a ether_addr structure containing the ethernet address
 195  *   to check.
 196  * @return
 197  *   True  (1) if the given ethernet address is valid;
 198  *   false (0) otherwise.
 199  */
 200 static inline int rte_is_valid_assigned_ether_addr(const struct rte_ether_addr *ea)
 201 {
 202         return rte_is_unicast_ether_addr(ea) && (!rte_is_zero_ether_addr(ea));
 203 }
 204
 205 /**
 206  * Generate a random Ethernet address that is locally administered
 207  * and not multicast.
 208  * @param addr
 209  *   A pointer to Ethernet address.
 210  */
 211 static inline void rte_eth_random_addr(uint8_t *addr)
 212 {
 213         uint64_t rand = rte_rand();
 214         uint8_t *p = (uint8_t *)&rand;
 215
 216         rte_memcpy(addr, p, RTE_ETHER_ADDR_LEN);
 217         addr[0] &= (uint8_t)~RTE_ETHER_GROUP_ADDR;       /* clear multicast bit */
 218         addr[0] |= RTE_ETHER_LOCAL_ADMIN_ADDR;  /* set local assignment bit */
 219 }
 220
 221 /**
 222  * Fast copy an Ethernet address.
 223  *
 224  * @param ea_from
 225  *   A pointer to a ether_addr structure holding the Ethernet address to copy.
 226  * @param ea_to
 227  *   A pointer to a ether_addr structure where to copy the Ethernet address.
 228  */
 229 static inline void rte_ether_addr_copy(const struct rte_ether_addr *ea_from,
 230                                    struct rte_ether_addr *ea_to)
 231 {
 232 #ifdef __INTEL_COMPILER
 233         uint16_t *from_words = (uint16_t *)(ea_from->addr_bytes);
 234         uint16_t *to_words   = (uint16_t *)(ea_to->addr_bytes);
 235
 236         to_words[0] = from_words[0];
 237         to_words[1] = from_words[1];
 238         to_words[2] = from_words[2];
 239 #else
 240         /*
 241          * Use the common way, because of a strange gcc warning.
 242          */
 243         *ea_to = *ea_from;
 244 #endif
 245 }
 246
 247 #define RTE_ETHER_ADDR_FMT_SIZE         18
 248 /**
 249  * Format 48bits Ethernet address in pattern xx:xx:xx:xx:xx:xx.
 250  *
 251  * @param buf
 252  *   A pointer to buffer contains the formatted MAC address.
 253  * @param size
 254  *   The format buffer size.
 255  * @param eth_addr
 256  *   A pointer to a ether_addr structure.
 257  */
 258 static inline void
 259 rte_ether_format_addr(char *buf, uint16_t size,
 260                   const struct rte_ether_addr *eth_addr)
 261 {
 262         snprintf(buf, size, "%02X:%02X:%02X:%02X:%02X:%02X",
 263                  eth_addr->addr_bytes[0],
 264                  eth_addr->addr_bytes[1],
 265                  eth_addr->addr_bytes[2],
 266                  eth_addr->addr_bytes[3],
 267                  eth_addr->addr_bytes[4],
 268                  eth_addr->addr_bytes[5]);
 269 }
 270
 271 /**
 272  * Ethernet header: Contains the destination address, source address
 273  * and frame type.
 274  */
 275 struct rte_ether_hdr {
 276         struct rte_ether_addr d_addr; /**< Destination address. */
 277         struct rte_ether_addr s_addr; /**< Source address. */
 278         uint16_t ether_type;      /**< Frame type. */
 279 } __attribute__((__packed__));
 280
 281 /**
 282  * Ethernet VLAN Header.
 283  * Contains the 16-bit VLAN Tag Control Identifier and the Ethernet type
 284  * of the encapsulated frame.
 285  */
 286 struct rte_vlan_hdr {
 287         uint16_t vlan_tci; /**< Priority (3) + CFI (1) + Identifier Code (12) */
 288         uint16_t eth_proto;/**< Ethernet type of encapsulated frame. */
 289 } __attribute__((__packed__));
 290
 291 /**
 292  * VXLAN protocol header.
 293  * Contains the 8-bit flag, 24-bit VXLAN Network Identifier and
 294  * Reserved fields (24 bits and 8 bits)
 295  */
 296 struct rte_vxlan_hdr {
 297         uint32_t vx_flags; /**< flag (8) + Reserved (24). */
 298         uint32_t vx_vni;   /**< VNI (24) + Reserved (8). */
 299 } __attribute__((__packed__));
 300
 301 /* Ethernet frame types */
 302 #define RTE_ETHER_TYPE_IPv4 0x0800 /**< IPv4 Protocol. */
 303 #define RTE_ETHER_TYPE_IPv6 0x86DD /**< IPv6 Protocol. */
 304 #define RTE_ETHER_TYPE_ARP  0x0806 /**< Arp Protocol. */
 305 #define RTE_ETHER_TYPE_RARP 0x8035 /**< Reverse Arp Protocol. */
 306 #define RTE_ETHER_TYPE_VLAN 0x8100 /**< IEEE 802.1Q VLAN tagging. */
 307 #define RTE_ETHER_TYPE_QINQ 0x88A8 /**< IEEE 802.1ad QinQ tagging. */
 308 #define RTE_ETHER_TYPE_ETAG 0x893F /**< IEEE 802.1BR E-Tag. */
 309 #define RTE_ETHER_TYPE_1588 0x88F7 /**< IEEE 802.1AS 1588 Precise Time Protocol. */
 310 #define RTE_ETHER_TYPE_SLOW 0x8809 /**< Slow protocols (LACP and Marker). */
 311 #define RTE_ETHER_TYPE_TEB  0x6558 /**< Transparent Ethernet Bridging. */
 312 #define RTE_ETHER_TYPE_LLDP 0x88CC /**< LLDP Protocol. */
 313
 314 #define RTE_ETHER_VXLAN_HLEN (sizeof(struct rte_udp_hdr) + sizeof(struct rte_vxlan_hdr))
 315 /**< VXLAN tunnel header length. */
 316
 317 /**
 318  * VXLAN-GPE protocol header (draft-ietf-nvo3-vxlan-gpe-05).
 319  * Contains the 8-bit flag, 8-bit next-protocol, 24-bit VXLAN Network
 320  * Identifier and Reserved fields (16 bits and 8 bits).
 321  */
 322 struct rte_vxlan_gpe_hdr {
 323         uint8_t vx_flags;    /**< flag (8). */
 324         uint8_t reserved[2]; /**< Reserved (16). */
 325         uint8_t proto;       /**< next-protocol (8). */
 326         uint32_t vx_vni;     /**< VNI (24) + Reserved (8). */
 327 } __attribute__((__packed__));
 328
 329 /* VXLAN-GPE next protocol types */
 330 #define RTE_VXLAN_GPE_TYPE_IPV4 1 /**< IPv4 Protocol. */
 331 #define RTE_VXLAN_GPE_TYPE_IPV6 2 /**< IPv6 Protocol. */
 332 #define RTE_VXLAN_GPE_TYPE_ETH  3 /**< Ethernet Protocol. */
 333 #define RTE_VXLAN_GPE_TYPE_NSH  4 /**< NSH Protocol. */
 334 #define RTE_VXLAN_GPE_TYPE_MPLS 5 /**< MPLS Protocol. */
 335 #define RTE_VXLAN_GPE_TYPE_GBP  6 /**< GBP Protocol. */
 336 #define RTE_VXLAN_GPE_TYPE_VBNG 7 /**< vBNG Protocol. */
 337
 338 #define RTE_ETHER_VXLAN_GPE_HLEN (sizeof(struct rte_udp_hdr) + \
 339                               sizeof(struct rte_vxlan_gpe_hdr))
 340 /**< VXLAN-GPE tunnel header length. */
 341
 342 /**
 343  * Extract VLAN tag information into mbuf
 344  *
 345  * Software version of VLAN stripping
 346  *
 347  * @param m
 348  *   The packet mbuf.
 349  * @return
 350  *   - 0: Success
 351  *   - 1: not a vlan packet
 352  */
 353 static inline int rte_vlan_strip(struct rte_mbuf *m)
 354 {
 355         struct rte_ether_hdr *eh
 356                  = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
 357         struct rte_vlan_hdr *vh;
 358
 359         if (eh->ether_type != rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN))
 360                 return -1;
 361
 362         vh = (struct rte_vlan_hdr *)(eh + 1);
 363         m->ol_flags |= PKT_RX_VLAN | PKT_RX_VLAN_STRIPPED;
 364         m->vlan_tci = rte_be_to_cpu_16(vh->vlan_tci);
 365
 366         /* Copy ether header over rather than moving whole packet */
 367         memmove(rte_pktmbuf_adj(m, sizeof(struct rte_vlan_hdr)),
 368                 eh, 2 * RTE_ETHER_ADDR_LEN);
 369
 370         return 0;
 371 }
 372
 373 /**
 374  * Insert VLAN tag into mbuf.
 375  *
 376  * Software version of VLAN unstripping
 377  *
 378  * @param m
 379  *   The packet mbuf.
 380  * @return
 381  *   - 0: On success
 382  *   -EPERM: mbuf is is shared overwriting would be unsafe
 383  *   -ENOSPC: not enough headroom in mbuf
 384  */
 385 static inline int rte_vlan_insert(struct rte_mbuf **m)
 386 {
 387         struct rte_ether_hdr *oh, *nh;
 388         struct rte_vlan_hdr *vh;
 389
 390         /* Can't insert header if mbuf is shared */
 391         if (rte_mbuf_refcnt_read(*m) > 1) {
 392                 struct rte_mbuf *copy;
 393
 394                 copy = rte_pktmbuf_clone(*m, (*m)->pool);
 395                 if (unlikely(copy == NULL))
 396                         return -ENOMEM;
 397                 rte_pktmbuf_free(*m);
 398                 *m = copy;
 399         }
 400
 401         oh = rte_pktmbuf_mtod(*m, struct rte_ether_hdr *);
 402         nh = (struct rte_ether_hdr *)
 403                 rte_pktmbuf_prepend(*m, sizeof(struct rte_vlan_hdr));
 404         if (nh == NULL)
 405                 return -ENOSPC;
 406
 407         memmove(nh, oh, 2 * RTE_ETHER_ADDR_LEN);
 408         nh->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN);
 409
 410         vh = (struct rte_vlan_hdr *) (nh + 1);
 411         vh->vlan_tci = rte_cpu_to_be_16((*m)->vlan_tci);
 412
 413         (*m)->ol_flags &= ~PKT_RX_VLAN_STRIPPED;
 414
 415         return 0;
 416 }
 417
 418 #ifdef __cplusplus
 419 }
 420 #endif
 421
 422 #endif /* _RTE_ETHER_H_ */