etherdevice.h 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333
  1. /*
  2. * INET An implementation of the TCP/IP protocol suite for the LINUX
  3. * operating system. NET is implemented using the BSD Socket
  4. * interface as the means of communication with the user level.
  5. *
  6. * Definitions for the Ethernet handlers.
  7. *
  8. * Version: @(#)eth.h 1.0.4 05/13/93
  9. *
  10. * Authors: Ross Biro
  11. * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
  12. *
  13. * Relocated to include/linux where it belongs by Alan Cox
  14. * <gw4pts@gw4pts.ampr.org>
  15. *
  16. * This program is free software; you can redistribute it and/or
  17. * modify it under the terms of the GNU General Public License
  18. * as published by the Free Software Foundation; either version
  19. * 2 of the License, or (at your option) any later version.
  20. *
  21. */
  22. #ifndef _LINUX_ETHERDEVICE_H
  23. #define _LINUX_ETHERDEVICE_H
  24. #include <linux/if_ether.h>
  25. #include <linux/netdevice.h>
  26. #include <linux/random.h>
  27. #include <asm/unaligned.h>
  28. #ifdef __KERNEL__
  29. extern __be16 eth_type_trans(struct sk_buff *skb, struct net_device *dev);
  30. extern const struct header_ops eth_header_ops;
  31. extern int eth_header(struct sk_buff *skb, struct net_device *dev,
  32. unsigned short type,
  33. const void *daddr, const void *saddr, unsigned len);
  34. extern int eth_rebuild_header(struct sk_buff *skb);
  35. extern int eth_header_parse(const struct sk_buff *skb, unsigned char *haddr);
  36. extern int eth_header_cache(const struct neighbour *neigh, struct hh_cache *hh, __be16 type);
  37. extern void eth_header_cache_update(struct hh_cache *hh,
  38. const struct net_device *dev,
  39. const unsigned char *haddr);
  40. extern int eth_mac_addr(struct net_device *dev, void *p);
  41. extern int eth_change_mtu(struct net_device *dev, int new_mtu);
  42. extern int eth_validate_addr(struct net_device *dev);
  43. extern struct net_device *alloc_etherdev_mqs(int sizeof_priv, unsigned int txqs,
  44. unsigned int rxqs);
  45. #define alloc_etherdev(sizeof_priv) alloc_etherdev_mq(sizeof_priv, 1)
  46. #define alloc_etherdev_mq(sizeof_priv, count) alloc_etherdev_mqs(sizeof_priv, count, count)
  47. /* Reserved Ethernet Addresses per IEEE 802.1Q */
  48. static const u8 br_reserved_address[ETH_ALEN] = { 0x01, 0x80, 0xc2, 0x00, 0x00, 0x00 };
  49. /**
  50. * is_link_local - Determine if given Eth addr is a link local mcast address.
  51. * @addr: Pointer to a six-byte array containing the Ethernet address
  52. *
  53. * Return true if address is link local reserved addr (01:80:c2:00:00:0X) per
  54. * IEEE 802.1Q 8.6.3 Frame filtering.
  55. */
  56. static inline int is_link_local(const unsigned char *dest)
  57. {
  58. __be16 *a = (__be16 *)dest;
  59. static const __be16 *b = (const __be16 *)br_reserved_address;
  60. static const __be16 m = cpu_to_be16(0xfff0);
  61. return ((a[0] ^ b[0]) | (a[1] ^ b[1]) | ((a[2] ^ b[2]) & m)) == 0;
  62. }
  63. /**
  64. * is_zero_ether_addr - Determine if give Ethernet address is all zeros.
  65. * @addr: Pointer to a six-byte array containing the Ethernet address
  66. *
  67. * Return true if the address is all zeroes.
  68. */
  69. static inline bool is_zero_ether_addr(const u8 *addr)
  70. {
  71. return !(addr[0] | addr[1] | addr[2] | addr[3] | addr[4] | addr[5]);
  72. }
  73. /**
  74. * is_multicast_ether_addr - Determine if the Ethernet address is a multicast.
  75. * @addr: Pointer to a six-byte array containing the Ethernet address
  76. *
  77. * Return true if the address is a multicast address.
  78. * By definition the broadcast address is also a multicast address.
  79. */
  80. static inline bool is_multicast_ether_addr(const u8 *addr)
  81. {
  82. return 0x01 & addr[0];
  83. }
  84. /**
  85. * is_local_ether_addr - Determine if the Ethernet address is locally-assigned one (IEEE 802).
  86. * @addr: Pointer to a six-byte array containing the Ethernet address
  87. *
  88. * Return true if the address is a local address.
  89. */
  90. static inline bool is_local_ether_addr(const u8 *addr)
  91. {
  92. return 0x02 & addr[0];
  93. }
  94. /**
  95. * is_broadcast_ether_addr - Determine if the Ethernet address is broadcast
  96. * @addr: Pointer to a six-byte array containing the Ethernet address
  97. *
  98. * Return true if the address is the broadcast address.
  99. */
  100. static inline bool is_broadcast_ether_addr(const u8 *addr)
  101. {
  102. return (addr[0] & addr[1] & addr[2] & addr[3] & addr[4] & addr[5]) == 0xff;
  103. }
  104. /**
  105. * is_unicast_ether_addr - Determine if the Ethernet address is unicast
  106. * @addr: Pointer to a six-byte array containing the Ethernet address
  107. *
  108. * Return true if the address is a unicast address.
  109. */
  110. static inline bool is_unicast_ether_addr(const u8 *addr)
  111. {
  112. return !is_multicast_ether_addr(addr);
  113. }
  114. /**
  115. * is_valid_ether_addr - Determine if the given Ethernet address is valid
  116. * @addr: Pointer to a six-byte array containing the Ethernet address
  117. *
  118. * Check that the Ethernet address (MAC) is not 00:00:00:00:00:00, is not
  119. * a multicast address, and is not FF:FF:FF:FF:FF:FF.
  120. *
  121. * Return true if the address is valid.
  122. */
  123. static inline bool is_valid_ether_addr(const u8 *addr)
  124. {
  125. /* FF:FF:FF:FF:FF:FF is a multicast address so we don't need to
  126. * explicitly check for it here. */
  127. return !is_multicast_ether_addr(addr) && !is_zero_ether_addr(addr);
  128. }
  129. /**
  130. * eth_random_addr - Generate software assigned random Ethernet address
  131. * @addr: Pointer to a six-byte array containing the Ethernet address
  132. *
  133. * Generate a random Ethernet address (MAC) that is not multicast
  134. * and has the local assigned bit set.
  135. */
  136. static inline void eth_random_addr(u8 *addr)
  137. {
  138. get_random_bytes(addr, ETH_ALEN);
  139. addr[0] &= 0xfe; /* clear multicast bit */
  140. addr[0] |= 0x02; /* set local assignment bit (IEEE802) */
  141. }
  142. #define random_ether_addr(addr) eth_random_addr(addr)
  143. /**
  144. * eth_broadcast_addr - Assign broadcast address
  145. * @addr: Pointer to a six-byte array containing the Ethernet address
  146. *
  147. * Assign the broadcast address to the given address array.
  148. */
  149. static inline void eth_broadcast_addr(u8 *addr)
  150. {
  151. memset(addr, 0xff, ETH_ALEN);
  152. }
  153. /**
  154. * eth_zero_addr - Assign zero address
  155. * @addr: Pointer to a six-byte array containing the Ethernet address
  156. *
  157. * Assign the zero address to the given address array.
  158. */
  159. static inline void eth_zero_addr(u8 *addr)
  160. {
  161. memset(addr, 0x00, ETH_ALEN);
  162. }
  163. /**
  164. * eth_hw_addr_random - Generate software assigned random Ethernet and
  165. * set device flag
  166. * @dev: pointer to net_device structure
  167. *
  168. * Generate a random Ethernet address (MAC) to be used by a net device
  169. * and set addr_assign_type so the state can be read by sysfs and be
  170. * used by userspace.
  171. */
  172. static inline void eth_hw_addr_random(struct net_device *dev)
  173. {
  174. dev->addr_assign_type |= NET_ADDR_RANDOM;
  175. eth_random_addr(dev->dev_addr);
  176. }
  177. /**
  178. * compare_ether_addr - Compare two Ethernet addresses
  179. * @addr1: Pointer to a six-byte array containing the Ethernet address
  180. * @addr2: Pointer other six-byte array containing the Ethernet address
  181. *
  182. * Compare two Ethernet addresses, returns 0 if equal, non-zero otherwise.
  183. * Unlike memcmp(), it doesn't return a value suitable for sorting.
  184. */
  185. static inline unsigned compare_ether_addr(const u8 *addr1, const u8 *addr2)
  186. {
  187. const u16 *a = (const u16 *) addr1;
  188. const u16 *b = (const u16 *) addr2;
  189. BUILD_BUG_ON(ETH_ALEN != 6);
  190. return ((a[0] ^ b[0]) | (a[1] ^ b[1]) | (a[2] ^ b[2])) != 0;
  191. }
  192. /**
  193. * ether_addr_equal - Compare two Ethernet addresses
  194. * @addr1: Pointer to a six-byte array containing the Ethernet address
  195. * @addr2: Pointer other six-byte array containing the Ethernet address
  196. *
  197. * Compare two Ethernet addresses, returns true if equal
  198. */
  199. static inline bool ether_addr_equal(const u8 *addr1, const u8 *addr2)
  200. {
  201. return !compare_ether_addr(addr1, addr2);
  202. }
  203. static inline unsigned long zap_last_2bytes(unsigned long value)
  204. {
  205. #ifdef __BIG_ENDIAN
  206. return value >> 16;
  207. #else
  208. return value << 16;
  209. #endif
  210. }
  211. /**
  212. * ether_addr_equal_64bits - Compare two Ethernet addresses
  213. * @addr1: Pointer to an array of 8 bytes
  214. * @addr2: Pointer to an other array of 8 bytes
  215. *
  216. * Compare two Ethernet addresses, returns true if equal, false otherwise.
  217. *
  218. * The function doesn't need any conditional branches and possibly uses
  219. * word memory accesses on CPU allowing cheap unaligned memory reads.
  220. * arrays = { byte1, byte2, byte3, byte4, byte5, byte6, pad1, pad2 }
  221. *
  222. * Please note that alignment of addr1 & addr2 are only guaranteed to be 16 bits.
  223. */
  224. static inline bool ether_addr_equal_64bits(const u8 addr1[6+2],
  225. const u8 addr2[6+2])
  226. {
  227. #ifdef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
  228. unsigned long fold = ((*(unsigned long *)addr1) ^
  229. (*(unsigned long *)addr2));
  230. if (sizeof(fold) == 8)
  231. return zap_last_2bytes(fold) == 0;
  232. fold |= zap_last_2bytes((*(unsigned long *)(addr1 + 4)) ^
  233. (*(unsigned long *)(addr2 + 4)));
  234. return fold == 0;
  235. #else
  236. return ether_addr_equal(addr1, addr2);
  237. #endif
  238. }
  239. /**
  240. * is_etherdev_addr - Tell if given Ethernet address belongs to the device.
  241. * @dev: Pointer to a device structure
  242. * @addr: Pointer to a six-byte array containing the Ethernet address
  243. *
  244. * Compare passed address with all addresses of the device. Return true if the
  245. * address if one of the device addresses.
  246. *
  247. * Note that this function calls ether_addr_equal_64bits() so take care of
  248. * the right padding.
  249. */
  250. static inline bool is_etherdev_addr(const struct net_device *dev,
  251. const u8 addr[6 + 2])
  252. {
  253. struct netdev_hw_addr *ha;
  254. bool res = false;
  255. rcu_read_lock();
  256. for_each_dev_addr(dev, ha) {
  257. res = ether_addr_equal_64bits(addr, ha->addr);
  258. if (res)
  259. break;
  260. }
  261. rcu_read_unlock();
  262. return res;
  263. }
  264. #endif /* __KERNEL__ */
  265. /**
  266. * compare_ether_header - Compare two Ethernet headers
  267. * @a: Pointer to Ethernet header
  268. * @b: Pointer to Ethernet header
  269. *
  270. * Compare two Ethernet headers, returns 0 if equal.
  271. * This assumes that the network header (i.e., IP header) is 4-byte
  272. * aligned OR the platform can handle unaligned access. This is the
  273. * case for all packets coming into netif_receive_skb or similar
  274. * entry points.
  275. */
  276. static inline unsigned long compare_ether_header(const void *a, const void *b)
  277. {
  278. #if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) && BITS_PER_LONG == 64
  279. unsigned long fold;
  280. /*
  281. * We want to compare 14 bytes:
  282. * [a0 ... a13] ^ [b0 ... b13]
  283. * Use two long XOR, ORed together, with an overlap of two bytes.
  284. * [a0 a1 a2 a3 a4 a5 a6 a7 ] ^ [b0 b1 b2 b3 b4 b5 b6 b7 ] |
  285. * [a6 a7 a8 a9 a10 a11 a12 a13] ^ [b6 b7 b8 b9 b10 b11 b12 b13]
  286. * This means the [a6 a7] ^ [b6 b7] part is done two times.
  287. */
  288. fold = *(unsigned long *)a ^ *(unsigned long *)b;
  289. fold |= *(unsigned long *)(a + 6) ^ *(unsigned long *)(b + 6);
  290. return fold;
  291. #else
  292. u32 *a32 = (u32 *)((u8 *)a + 2);
  293. u32 *b32 = (u32 *)((u8 *)b + 2);
  294. return (*(u16 *)a ^ *(u16 *)b) | (a32[0] ^ b32[0]) |
  295. (a32[1] ^ b32[1]) | (a32[2] ^ b32[2]);
  296. #endif
  297. }
  298. #endif /* _LINUX_ETHERDEVICE_H */