1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * INET An implementation of the TCP/IP protocol suite for the LINUX
4 * operating system. INET is implemented using the BSD Socket
5 * interface as the means of communication with the user level.
7 * Ethernet-type device handling.
9 * Version: @(#)eth.c 1.0.7 05/25/93
12 * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
13 * Mark Evans, <evansmp@uhura.aston.ac.uk>
14 * Florian La Roche, <rzsfl@rz.uni-sb.de>
15 * Alan Cox, <gw4pts@gw4pts.ampr.org>
18 * Mr Linux : Arp problems
19 * Alan Cox : Generic queue tidyup (very tiny here)
20 * Alan Cox : eth_header ntohs should be htons
21 * Alan Cox : eth_rebuild_header missing an htons and
23 * Tegge : Arp bug fixes.
24 * Florian : Removed many unnecessary functions, code cleanup
25 * and changes for new arp and skbuff.
26 * Alan Cox : Redid header building to reflect new format.
27 * Alan Cox : ARP only when compiled with CONFIG_INET
28 * Greg Page : 802.2 and SNAP stuff.
29 * Alan Cox : MAC layer pointers/new format.
30 * Paul Gortmaker : eth_copy_and_sum shouldn't csum padding.
31 * Alan Cox : Protect against forwarding explosions with
32 * older network drivers and IFF_ALLMULTI.
33 * Christer Weinigel : Better rebuild header message.
34 * Andrew Morton : 26Feb01: kill ether_setup() - use netdev_boot_setup().
36 #include <linux/module.h>
37 #include <linux/types.h>
38 #include <linux/kernel.h>
39 #include <linux/string.h>
41 #include <linux/socket.h>
43 #include <linux/inet.h>
45 #include <linux/netdevice.h>
46 #include <linux/nvmem-consumer.h>
47 #include <linux/etherdevice.h>
48 #include <linux/skbuff.h>
49 #include <linux/errno.h>
50 #include <linux/init.h>
51 #include <linux/if_ether.h>
52 #include <linux/of_net.h>
53 #include <linux/pci.h>
60 #include <net/flow_dissector.h>
62 #include <linux/uaccess.h>
63 #include <net/pkt_sched.h>
66 * eth_header - create the Ethernet header
67 * @skb: buffer to alter
69 * @type: Ethernet type field
70 * @daddr: destination address (NULL leave destination address)
71 * @saddr: source address (NULL use device source address)
72 * @len: packet length (<= skb->len)
75 * Set the protocol type. For a packet of type ETH_P_802_3/2 we put the length
78 int eth_header(struct sk_buff
*skb
, struct net_device
*dev
,
80 const void *daddr
, const void *saddr
, unsigned int len
)
82 struct ethhdr
*eth
= skb_push(skb
, ETH_HLEN
);
84 if (type
!= ETH_P_802_3
&& type
!= ETH_P_802_2
)
85 eth
->h_proto
= htons(type
);
87 eth
->h_proto
= htons(len
);
90 * Set the source hardware address.
94 saddr
= dev
->dev_addr
;
95 memcpy(eth
->h_source
, saddr
, ETH_ALEN
);
98 memcpy(eth
->h_dest
, daddr
, ETH_ALEN
);
103 * Anyway, the loopback-device should never use this function...
106 if (dev
->flags
& (IFF_LOOPBACK
| IFF_NOARP
)) {
107 eth_zero_addr(eth
->h_dest
);
113 EXPORT_SYMBOL(eth_header
);
116 * eth_get_headlen - determine the length of header for an ethernet frame
117 * @dev: pointer to network device
118 * @data: pointer to start of frame
119 * @len: total length of frame
121 * Make a best effort attempt to pull the length for all of the headers for
122 * a given frame in a linear buffer.
124 u32
eth_get_headlen(const struct net_device
*dev
, const void *data
, u32 len
)
126 const unsigned int flags
= FLOW_DISSECTOR_F_PARSE_1ST_FRAG
;
127 const struct ethhdr
*eth
= (const struct ethhdr
*)data
;
128 struct flow_keys_basic keys
;
130 /* this should never happen, but better safe than sorry */
131 if (unlikely(len
< sizeof(*eth
)))
134 /* parse any remaining L2/L3 headers, check for L4 */
135 if (!skb_flow_dissect_flow_keys_basic(dev_net(dev
), NULL
, &keys
, data
,
136 eth
->h_proto
, sizeof(*eth
),
138 return max_t(u32
, keys
.control
.thoff
, sizeof(*eth
));
140 /* parse for any L4 headers */
141 return min_t(u32
, __skb_get_poff(NULL
, data
, &keys
, len
), len
);
143 EXPORT_SYMBOL(eth_get_headlen
);
146 * eth_type_trans - determine the packet's protocol ID.
147 * @skb: received socket data
148 * @dev: receiving network device
150 * The rule here is that we
151 * assume 802.3 if the type field is short enough to be a length.
152 * This is normal practice and works for any 'now in use' protocol.
154 __be16
eth_type_trans(struct sk_buff
*skb
, struct net_device
*dev
)
156 unsigned short _service_access_point
;
157 const unsigned short *sap
;
158 const struct ethhdr
*eth
;
161 skb_reset_mac_header(skb
);
163 eth
= (struct ethhdr
*)skb
->data
;
164 skb_pull_inline(skb
, ETH_HLEN
);
166 if (unlikely(!ether_addr_equal_64bits(eth
->h_dest
,
168 if (unlikely(is_multicast_ether_addr_64bits(eth
->h_dest
))) {
169 if (ether_addr_equal_64bits(eth
->h_dest
, dev
->broadcast
))
170 skb
->pkt_type
= PACKET_BROADCAST
;
172 skb
->pkt_type
= PACKET_MULTICAST
;
174 skb
->pkt_type
= PACKET_OTHERHOST
;
179 * Some variants of DSA tagging don't have an ethertype field
180 * at all, so we check here whether one of those tagging
181 * variants has been configured on the receiving interface,
182 * and if so, set skb->protocol without looking at the packet.
184 if (unlikely(netdev_uses_dsa(dev
)))
185 return htons(ETH_P_XDSA
);
187 if (likely(eth_proto_is_802_3(eth
->h_proto
)))
191 * This is a magic hack to spot IPX packets. Older Novell breaks
192 * the protocol design and runs IPX over 802.3 without an 802.2 LLC
193 * layer. We look for FFFF which isn't a used 802.2 SSAP/DSAP. This
194 * won't work for fault tolerant netware but does for the rest.
196 sap
= skb_header_pointer(skb
, 0, sizeof(*sap
), &_service_access_point
);
197 if (sap
&& *sap
== 0xFFFF)
198 return htons(ETH_P_802_3
);
203 return htons(ETH_P_802_2
);
205 EXPORT_SYMBOL(eth_type_trans
);
208 * eth_header_parse - extract hardware address from packet
209 * @skb: packet to extract header from
210 * @haddr: destination buffer
212 int eth_header_parse(const struct sk_buff
*skb
, unsigned char *haddr
)
214 const struct ethhdr
*eth
= eth_hdr(skb
);
215 memcpy(haddr
, eth
->h_source
, ETH_ALEN
);
218 EXPORT_SYMBOL(eth_header_parse
);
221 * eth_header_cache - fill cache entry from neighbour
222 * @neigh: source neighbour
223 * @hh: destination cache entry
224 * @type: Ethernet type field
226 * Create an Ethernet header template from the neighbour.
228 int eth_header_cache(const struct neighbour
*neigh
, struct hh_cache
*hh
, __be16 type
)
231 const struct net_device
*dev
= neigh
->dev
;
233 eth
= (struct ethhdr
*)
234 (((u8
*) hh
->hh_data
) + (HH_DATA_OFF(sizeof(*eth
))));
236 if (type
== htons(ETH_P_802_3
))
240 memcpy(eth
->h_source
, dev
->dev_addr
, ETH_ALEN
);
241 memcpy(eth
->h_dest
, neigh
->ha
, ETH_ALEN
);
243 /* Pairs with READ_ONCE() in neigh_resolve_output(),
244 * neigh_hh_output() and neigh_update_hhs().
246 smp_store_release(&hh
->hh_len
, ETH_HLEN
);
250 EXPORT_SYMBOL(eth_header_cache
);
253 * eth_header_cache_update - update cache entry
254 * @hh: destination cache entry
255 * @dev: network device
256 * @haddr: new hardware address
258 * Called by Address Resolution module to notify changes in address.
260 void eth_header_cache_update(struct hh_cache
*hh
,
261 const struct net_device
*dev
,
262 const unsigned char *haddr
)
264 memcpy(((u8
*) hh
->hh_data
) + HH_DATA_OFF(sizeof(struct ethhdr
)),
267 EXPORT_SYMBOL(eth_header_cache_update
);
270 * eth_header_parse_protocol - extract protocol from L2 header
271 * @skb: packet to extract protocol from
273 __be16
eth_header_parse_protocol(const struct sk_buff
*skb
)
275 const struct ethhdr
*eth
= eth_hdr(skb
);
279 EXPORT_SYMBOL(eth_header_parse_protocol
);
282 * eth_prepare_mac_addr_change - prepare for mac change
283 * @dev: network device
286 int eth_prepare_mac_addr_change(struct net_device
*dev
, void *p
)
288 struct sockaddr
*addr
= p
;
290 if (!(dev
->priv_flags
& IFF_LIVE_ADDR_CHANGE
) && netif_running(dev
))
292 if (!is_valid_ether_addr(addr
->sa_data
))
293 return -EADDRNOTAVAIL
;
296 EXPORT_SYMBOL(eth_prepare_mac_addr_change
);
299 * eth_commit_mac_addr_change - commit mac change
300 * @dev: network device
303 void eth_commit_mac_addr_change(struct net_device
*dev
, void *p
)
305 struct sockaddr
*addr
= p
;
307 memcpy(dev
->dev_addr
, addr
->sa_data
, ETH_ALEN
);
309 EXPORT_SYMBOL(eth_commit_mac_addr_change
);
312 * eth_mac_addr - set new Ethernet hardware address
313 * @dev: network device
316 * Change hardware address of device.
318 * This doesn't change hardware matching, so needs to be overridden
319 * for most real devices.
321 int eth_mac_addr(struct net_device
*dev
, void *p
)
325 ret
= eth_prepare_mac_addr_change(dev
, p
);
328 eth_commit_mac_addr_change(dev
, p
);
331 EXPORT_SYMBOL(eth_mac_addr
);
333 int eth_validate_addr(struct net_device
*dev
)
335 if (!is_valid_ether_addr(dev
->dev_addr
))
336 return -EADDRNOTAVAIL
;
340 EXPORT_SYMBOL(eth_validate_addr
);
342 const struct header_ops eth_header_ops ____cacheline_aligned
= {
343 .create
= eth_header
,
344 .parse
= eth_header_parse
,
345 .cache
= eth_header_cache
,
346 .cache_update
= eth_header_cache_update
,
347 .parse_protocol
= eth_header_parse_protocol
,
351 * ether_setup - setup Ethernet network device
352 * @dev: network device
354 * Fill in the fields of the device structure with Ethernet-generic values.
356 void ether_setup(struct net_device
*dev
)
358 dev
->header_ops
= ð_header_ops
;
359 dev
->type
= ARPHRD_ETHER
;
360 dev
->hard_header_len
= ETH_HLEN
;
361 dev
->min_header_len
= ETH_HLEN
;
362 dev
->mtu
= ETH_DATA_LEN
;
363 dev
->min_mtu
= ETH_MIN_MTU
;
364 dev
->max_mtu
= ETH_DATA_LEN
;
365 dev
->addr_len
= ETH_ALEN
;
366 dev
->tx_queue_len
= DEFAULT_TX_QUEUE_LEN
;
367 dev
->flags
= IFF_BROADCAST
|IFF_MULTICAST
;
368 dev
->priv_flags
|= IFF_TX_SKB_SHARING
;
370 eth_broadcast_addr(dev
->broadcast
);
373 EXPORT_SYMBOL(ether_setup
);
376 * alloc_etherdev_mqs - Allocates and sets up an Ethernet device
377 * @sizeof_priv: Size of additional driver-private structure to be allocated
378 * for this Ethernet device
379 * @txqs: The number of TX queues this device has.
380 * @rxqs: The number of RX queues this device has.
382 * Fill in the fields of the device structure with Ethernet-generic
383 * values. Basically does everything except registering the device.
385 * Constructs a new net device, complete with a private data area of
386 * size (sizeof_priv). A 32-byte (not bit) alignment is enforced for
387 * this private data area.
390 struct net_device
*alloc_etherdev_mqs(int sizeof_priv
, unsigned int txqs
,
393 return alloc_netdev_mqs(sizeof_priv
, "eth%d", NET_NAME_UNKNOWN
,
394 ether_setup
, txqs
, rxqs
);
396 EXPORT_SYMBOL(alloc_etherdev_mqs
);
398 ssize_t
sysfs_format_mac(char *buf
, const unsigned char *addr
, int len
)
400 return scnprintf(buf
, PAGE_SIZE
, "%*phC\n", len
, addr
);
402 EXPORT_SYMBOL(sysfs_format_mac
);
404 struct sk_buff
*eth_gro_receive(struct list_head
*head
, struct sk_buff
*skb
)
406 const struct packet_offload
*ptype
;
407 unsigned int hlen
, off_eth
;
408 struct sk_buff
*pp
= NULL
;
409 struct ethhdr
*eh
, *eh2
;
414 off_eth
= skb_gro_offset(skb
);
415 hlen
= off_eth
+ sizeof(*eh
);
416 eh
= skb_gro_header_fast(skb
, off_eth
);
417 if (skb_gro_header_hard(skb
, hlen
)) {
418 eh
= skb_gro_header_slow(skb
, hlen
, off_eth
);
425 list_for_each_entry(p
, head
, list
) {
426 if (!NAPI_GRO_CB(p
)->same_flow
)
429 eh2
= (struct ethhdr
*)(p
->data
+ off_eth
);
430 if (compare_ether_header(eh
, eh2
)) {
431 NAPI_GRO_CB(p
)->same_flow
= 0;
439 ptype
= gro_find_receive_by_type(type
);
445 skb_gro_pull(skb
, sizeof(*eh
));
446 skb_gro_postpull_rcsum(skb
, eh
, sizeof(*eh
));
448 pp
= indirect_call_gro_receive_inet(ptype
->callbacks
.gro_receive
,
449 ipv6_gro_receive
, inet_gro_receive
,
455 skb_gro_flush_final(skb
, pp
, flush
);
459 EXPORT_SYMBOL(eth_gro_receive
);
461 int eth_gro_complete(struct sk_buff
*skb
, int nhoff
)
463 struct ethhdr
*eh
= (struct ethhdr
*)(skb
->data
+ nhoff
);
464 __be16 type
= eh
->h_proto
;
465 struct packet_offload
*ptype
;
468 if (skb
->encapsulation
)
469 skb_set_inner_mac_header(skb
, nhoff
);
472 ptype
= gro_find_complete_by_type(type
);
474 err
= INDIRECT_CALL_INET(ptype
->callbacks
.gro_complete
,
475 ipv6_gro_complete
, inet_gro_complete
,
476 skb
, nhoff
+ sizeof(*eh
));
481 EXPORT_SYMBOL(eth_gro_complete
);
483 static struct packet_offload eth_packet_offload __read_mostly
= {
484 .type
= cpu_to_be16(ETH_P_TEB
),
487 .gro_receive
= eth_gro_receive
,
488 .gro_complete
= eth_gro_complete
,
492 static int __init
eth_offload_init(void)
494 dev_add_offload(ð_packet_offload
);
499 fs_initcall(eth_offload_init
);
501 unsigned char * __weak
arch_get_platform_mac_address(void)
506 int eth_platform_get_mac_address(struct device
*dev
, u8
*mac_addr
)
511 ret
= of_get_mac_address(dev
->of_node
, mac_addr
);
515 addr
= arch_get_platform_mac_address();
519 ether_addr_copy(mac_addr
, addr
);
523 EXPORT_SYMBOL(eth_platform_get_mac_address
);
526 * nvmem_get_mac_address - Obtain the MAC address from an nvmem cell named
527 * 'mac-address' associated with given device.
529 * @dev: Device with which the mac-address cell is associated.
530 * @addrbuf: Buffer to which the MAC address will be copied on success.
532 * Returns 0 on success or a negative error number on failure.
534 int nvmem_get_mac_address(struct device
*dev
, void *addrbuf
)
536 struct nvmem_cell
*cell
;
540 cell
= nvmem_cell_get(dev
, "mac-address");
542 return PTR_ERR(cell
);
544 mac
= nvmem_cell_read(cell
, &len
);
545 nvmem_cell_put(cell
);
550 if (len
!= ETH_ALEN
|| !is_valid_ether_addr(mac
)) {
555 ether_addr_copy(addrbuf
, mac
);
560 EXPORT_SYMBOL(nvmem_get_mac_address
);