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>
65 __setup("ether=", netdev_boot_setup
);
68 * eth_header - create the Ethernet header
69 * @skb: buffer to alter
71 * @type: Ethernet type field
72 * @daddr: destination address (NULL leave destination address)
73 * @saddr: source address (NULL use device source address)
74 * @len: packet length (<= skb->len)
77 * Set the protocol type. For a packet of type ETH_P_802_3/2 we put the length
80 int eth_header(struct sk_buff
*skb
, struct net_device
*dev
,
82 const void *daddr
, const void *saddr
, unsigned int len
)
84 struct ethhdr
*eth
= skb_push(skb
, ETH_HLEN
);
86 if (type
!= ETH_P_802_3
&& type
!= ETH_P_802_2
)
87 eth
->h_proto
= htons(type
);
89 eth
->h_proto
= htons(len
);
92 * Set the source hardware address.
96 saddr
= dev
->dev_addr
;
97 memcpy(eth
->h_source
, saddr
, ETH_ALEN
);
100 memcpy(eth
->h_dest
, daddr
, ETH_ALEN
);
105 * Anyway, the loopback-device should never use this function...
108 if (dev
->flags
& (IFF_LOOPBACK
| IFF_NOARP
)) {
109 eth_zero_addr(eth
->h_dest
);
115 EXPORT_SYMBOL(eth_header
);
118 * eth_get_headlen - determine the length of header for an ethernet frame
119 * @dev: pointer to network device
120 * @data: pointer to start of frame
121 * @len: total length of frame
123 * Make a best effort attempt to pull the length for all of the headers for
124 * a given frame in a linear buffer.
126 u32
eth_get_headlen(const struct net_device
*dev
, const void *data
, u32 len
)
128 const unsigned int flags
= FLOW_DISSECTOR_F_PARSE_1ST_FRAG
;
129 const struct ethhdr
*eth
= (const struct ethhdr
*)data
;
130 struct flow_keys_basic keys
;
132 /* this should never happen, but better safe than sorry */
133 if (unlikely(len
< sizeof(*eth
)))
136 /* parse any remaining L2/L3 headers, check for L4 */
137 if (!skb_flow_dissect_flow_keys_basic(dev_net(dev
), NULL
, &keys
, data
,
138 eth
->h_proto
, sizeof(*eth
),
140 return max_t(u32
, keys
.control
.thoff
, sizeof(*eth
));
142 /* parse for any L4 headers */
143 return min_t(u32
, __skb_get_poff(NULL
, data
, &keys
, len
), len
);
145 EXPORT_SYMBOL(eth_get_headlen
);
148 * eth_type_trans - determine the packet's protocol ID.
149 * @skb: received socket data
150 * @dev: receiving network device
152 * The rule here is that we
153 * assume 802.3 if the type field is short enough to be a length.
154 * This is normal practice and works for any 'now in use' protocol.
156 __be16
eth_type_trans(struct sk_buff
*skb
, struct net_device
*dev
)
158 unsigned short _service_access_point
;
159 const unsigned short *sap
;
160 const struct ethhdr
*eth
;
163 skb_reset_mac_header(skb
);
165 eth
= (struct ethhdr
*)skb
->data
;
166 skb_pull_inline(skb
, ETH_HLEN
);
168 if (unlikely(!ether_addr_equal_64bits(eth
->h_dest
,
170 if (unlikely(is_multicast_ether_addr_64bits(eth
->h_dest
))) {
171 if (ether_addr_equal_64bits(eth
->h_dest
, dev
->broadcast
))
172 skb
->pkt_type
= PACKET_BROADCAST
;
174 skb
->pkt_type
= PACKET_MULTICAST
;
176 skb
->pkt_type
= PACKET_OTHERHOST
;
181 * Some variants of DSA tagging don't have an ethertype field
182 * at all, so we check here whether one of those tagging
183 * variants has been configured on the receiving interface,
184 * and if so, set skb->protocol without looking at the packet.
185 * The DSA tagging protocol may be able to decode some but not all
186 * traffic (for example only for management). In that case give it the
187 * option to filter the packets from which it can decode source port
190 if (unlikely(netdev_uses_dsa(dev
)) && dsa_can_decode(skb
, dev
))
191 return htons(ETH_P_XDSA
);
193 if (likely(eth_proto_is_802_3(eth
->h_proto
)))
197 * This is a magic hack to spot IPX packets. Older Novell breaks
198 * the protocol design and runs IPX over 802.3 without an 802.2 LLC
199 * layer. We look for FFFF which isn't a used 802.2 SSAP/DSAP. This
200 * won't work for fault tolerant netware but does for the rest.
202 sap
= skb_header_pointer(skb
, 0, sizeof(*sap
), &_service_access_point
);
203 if (sap
&& *sap
== 0xFFFF)
204 return htons(ETH_P_802_3
);
209 return htons(ETH_P_802_2
);
211 EXPORT_SYMBOL(eth_type_trans
);
214 * eth_header_parse - extract hardware address from packet
215 * @skb: packet to extract header from
216 * @haddr: destination buffer
218 int eth_header_parse(const struct sk_buff
*skb
, unsigned char *haddr
)
220 const struct ethhdr
*eth
= eth_hdr(skb
);
221 memcpy(haddr
, eth
->h_source
, ETH_ALEN
);
224 EXPORT_SYMBOL(eth_header_parse
);
227 * eth_header_cache - fill cache entry from neighbour
228 * @neigh: source neighbour
229 * @hh: destination cache entry
230 * @type: Ethernet type field
232 * Create an Ethernet header template from the neighbour.
234 int eth_header_cache(const struct neighbour
*neigh
, struct hh_cache
*hh
, __be16 type
)
237 const struct net_device
*dev
= neigh
->dev
;
239 eth
= (struct ethhdr
*)
240 (((u8
*) hh
->hh_data
) + (HH_DATA_OFF(sizeof(*eth
))));
242 if (type
== htons(ETH_P_802_3
))
246 memcpy(eth
->h_source
, dev
->dev_addr
, ETH_ALEN
);
247 memcpy(eth
->h_dest
, neigh
->ha
, ETH_ALEN
);
249 /* Pairs with READ_ONCE() in neigh_resolve_output(),
250 * neigh_hh_output() and neigh_update_hhs().
252 smp_store_release(&hh
->hh_len
, ETH_HLEN
);
256 EXPORT_SYMBOL(eth_header_cache
);
259 * eth_header_cache_update - update cache entry
260 * @hh: destination cache entry
261 * @dev: network device
262 * @haddr: new hardware address
264 * Called by Address Resolution module to notify changes in address.
266 void eth_header_cache_update(struct hh_cache
*hh
,
267 const struct net_device
*dev
,
268 const unsigned char *haddr
)
270 memcpy(((u8
*) hh
->hh_data
) + HH_DATA_OFF(sizeof(struct ethhdr
)),
273 EXPORT_SYMBOL(eth_header_cache_update
);
276 * eth_header_parse_protocol - extract protocol from L2 header
277 * @skb: packet to extract protocol from
279 __be16
eth_header_parse_protocol(const struct sk_buff
*skb
)
281 const struct ethhdr
*eth
= eth_hdr(skb
);
285 EXPORT_SYMBOL(eth_header_parse_protocol
);
288 * eth_prepare_mac_addr_change - prepare for mac change
289 * @dev: network device
292 int eth_prepare_mac_addr_change(struct net_device
*dev
, void *p
)
294 struct sockaddr
*addr
= p
;
296 if (!(dev
->priv_flags
& IFF_LIVE_ADDR_CHANGE
) && netif_running(dev
))
298 if (!is_valid_ether_addr(addr
->sa_data
))
299 return -EADDRNOTAVAIL
;
302 EXPORT_SYMBOL(eth_prepare_mac_addr_change
);
305 * eth_commit_mac_addr_change - commit mac change
306 * @dev: network device
309 void eth_commit_mac_addr_change(struct net_device
*dev
, void *p
)
311 struct sockaddr
*addr
= p
;
313 memcpy(dev
->dev_addr
, addr
->sa_data
, ETH_ALEN
);
315 EXPORT_SYMBOL(eth_commit_mac_addr_change
);
318 * eth_mac_addr - set new Ethernet hardware address
319 * @dev: network device
322 * Change hardware address of device.
324 * This doesn't change hardware matching, so needs to be overridden
325 * for most real devices.
327 int eth_mac_addr(struct net_device
*dev
, void *p
)
331 ret
= eth_prepare_mac_addr_change(dev
, p
);
334 eth_commit_mac_addr_change(dev
, p
);
337 EXPORT_SYMBOL(eth_mac_addr
);
339 int eth_validate_addr(struct net_device
*dev
)
341 if (!is_valid_ether_addr(dev
->dev_addr
))
342 return -EADDRNOTAVAIL
;
346 EXPORT_SYMBOL(eth_validate_addr
);
348 const struct header_ops eth_header_ops ____cacheline_aligned
= {
349 .create
= eth_header
,
350 .parse
= eth_header_parse
,
351 .cache
= eth_header_cache
,
352 .cache_update
= eth_header_cache_update
,
353 .parse_protocol
= eth_header_parse_protocol
,
357 * ether_setup - setup Ethernet network device
358 * @dev: network device
360 * Fill in the fields of the device structure with Ethernet-generic values.
362 void ether_setup(struct net_device
*dev
)
364 dev
->header_ops
= ð_header_ops
;
365 dev
->type
= ARPHRD_ETHER
;
366 dev
->hard_header_len
= ETH_HLEN
;
367 dev
->min_header_len
= ETH_HLEN
;
368 dev
->mtu
= ETH_DATA_LEN
;
369 dev
->min_mtu
= ETH_MIN_MTU
;
370 dev
->max_mtu
= ETH_DATA_LEN
;
371 dev
->addr_len
= ETH_ALEN
;
372 dev
->tx_queue_len
= DEFAULT_TX_QUEUE_LEN
;
373 dev
->flags
= IFF_BROADCAST
|IFF_MULTICAST
;
374 dev
->priv_flags
|= IFF_TX_SKB_SHARING
;
376 eth_broadcast_addr(dev
->broadcast
);
379 EXPORT_SYMBOL(ether_setup
);
382 * alloc_etherdev_mqs - Allocates and sets up an Ethernet device
383 * @sizeof_priv: Size of additional driver-private structure to be allocated
384 * for this Ethernet device
385 * @txqs: The number of TX queues this device has.
386 * @rxqs: The number of RX queues this device has.
388 * Fill in the fields of the device structure with Ethernet-generic
389 * values. Basically does everything except registering the device.
391 * Constructs a new net device, complete with a private data area of
392 * size (sizeof_priv). A 32-byte (not bit) alignment is enforced for
393 * this private data area.
396 struct net_device
*alloc_etherdev_mqs(int sizeof_priv
, unsigned int txqs
,
399 return alloc_netdev_mqs(sizeof_priv
, "eth%d", NET_NAME_UNKNOWN
,
400 ether_setup
, txqs
, rxqs
);
402 EXPORT_SYMBOL(alloc_etherdev_mqs
);
404 ssize_t
sysfs_format_mac(char *buf
, const unsigned char *addr
, int len
)
406 return scnprintf(buf
, PAGE_SIZE
, "%*phC\n", len
, addr
);
408 EXPORT_SYMBOL(sysfs_format_mac
);
410 struct sk_buff
*eth_gro_receive(struct list_head
*head
, struct sk_buff
*skb
)
412 const struct packet_offload
*ptype
;
413 unsigned int hlen
, off_eth
;
414 struct sk_buff
*pp
= NULL
;
415 struct ethhdr
*eh
, *eh2
;
420 off_eth
= skb_gro_offset(skb
);
421 hlen
= off_eth
+ sizeof(*eh
);
422 eh
= skb_gro_header_fast(skb
, off_eth
);
423 if (skb_gro_header_hard(skb
, hlen
)) {
424 eh
= skb_gro_header_slow(skb
, hlen
, off_eth
);
431 list_for_each_entry(p
, head
, list
) {
432 if (!NAPI_GRO_CB(p
)->same_flow
)
435 eh2
= (struct ethhdr
*)(p
->data
+ off_eth
);
436 if (compare_ether_header(eh
, eh2
)) {
437 NAPI_GRO_CB(p
)->same_flow
= 0;
445 ptype
= gro_find_receive_by_type(type
);
451 skb_gro_pull(skb
, sizeof(*eh
));
452 skb_gro_postpull_rcsum(skb
, eh
, sizeof(*eh
));
454 pp
= indirect_call_gro_receive_inet(ptype
->callbacks
.gro_receive
,
455 ipv6_gro_receive
, inet_gro_receive
,
461 skb_gro_flush_final(skb
, pp
, flush
);
465 EXPORT_SYMBOL(eth_gro_receive
);
467 int eth_gro_complete(struct sk_buff
*skb
, int nhoff
)
469 struct ethhdr
*eh
= (struct ethhdr
*)(skb
->data
+ nhoff
);
470 __be16 type
= eh
->h_proto
;
471 struct packet_offload
*ptype
;
474 if (skb
->encapsulation
)
475 skb_set_inner_mac_header(skb
, nhoff
);
478 ptype
= gro_find_complete_by_type(type
);
480 err
= INDIRECT_CALL_INET(ptype
->callbacks
.gro_complete
,
481 ipv6_gro_complete
, inet_gro_complete
,
482 skb
, nhoff
+ sizeof(*eh
));
487 EXPORT_SYMBOL(eth_gro_complete
);
489 static struct packet_offload eth_packet_offload __read_mostly
= {
490 .type
= cpu_to_be16(ETH_P_TEB
),
493 .gro_receive
= eth_gro_receive
,
494 .gro_complete
= eth_gro_complete
,
498 static int __init
eth_offload_init(void)
500 dev_add_offload(ð_packet_offload
);
505 fs_initcall(eth_offload_init
);
507 unsigned char * __weak
arch_get_platform_mac_address(void)
512 int eth_platform_get_mac_address(struct device
*dev
, u8
*mac_addr
)
517 ret
= of_get_mac_address(dev
->of_node
, mac_addr
);
521 addr
= arch_get_platform_mac_address();
525 ether_addr_copy(mac_addr
, addr
);
529 EXPORT_SYMBOL(eth_platform_get_mac_address
);
532 * nvmem_get_mac_address - Obtain the MAC address from an nvmem cell named
533 * 'mac-address' associated with given device.
535 * @dev: Device with which the mac-address cell is associated.
536 * @addrbuf: Buffer to which the MAC address will be copied on success.
538 * Returns 0 on success or a negative error number on failure.
540 int nvmem_get_mac_address(struct device
*dev
, void *addrbuf
)
542 struct nvmem_cell
*cell
;
546 cell
= nvmem_cell_get(dev
, "mac-address");
548 return PTR_ERR(cell
);
550 mac
= nvmem_cell_read(cell
, &len
);
551 nvmem_cell_put(cell
);
556 if (len
!= ETH_ALEN
|| !is_valid_ether_addr(mac
)) {
561 ether_addr_copy(addrbuf
, mac
);
566 EXPORT_SYMBOL(nvmem_get_mac_address
);