1 /*
2 * INET An implementation of the TCP/IP protocol suite for the LINUX
3 * operating system. INET is implemented using the BSD Socket
4 * interface as the means of communication with the user level.
5 *
6 * Ethernet-type device handling.
7 *
8 * Version: @(#)eth.c 1.0.7 05/25/93
9 *
10 * Authors: Ross Biro
11 * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
12 * Mark Evans, <evansmp@uhura.aston.ac.uk>
13 * Florian La Roche, <rzsfl@rz.uni-sb.de>
14 * Alan Cox, <gw4pts@gw4pts.ampr.org>
15 *
16 * Fixes:
17 * Mr Linux : Arp problems
18 * Alan Cox : Generic queue tidyup (very tiny here)
19 * Alan Cox : eth_header ntohs should be htons
20 * Alan Cox : eth_rebuild_header missing an htons and
21 * minor other things.
22 * Tegge : Arp bug fixes.
23 * Florian : Removed many unnecessary functions, code cleanup
24 * and changes for new arp and skbuff.
25 * Alan Cox : Redid header building to reflect new format.
26 * Alan Cox : ARP only when compiled with CONFIG_INET
27 * Greg Page : 802.2 and SNAP stuff.
28 * Alan Cox : MAC layer pointers/new format.
29 * Paul Gortmaker : eth_copy_and_sum shouldn't csum padding.
30 * Alan Cox : Protect against forwarding explosions with
31 * older network drivers and IFF_ALLMULTI.
32 * Christer Weinigel : Better rebuild header message.
33 * Andrew Morton : 26Feb01: kill ether_setup() - use netdev_boot_setup().
34 *
35 * This program is free software; you can redistribute it and/or
36 * modify it under the terms of the GNU General Public License
37 * as published by the Free Software Foundation; either version
38 * 2 of the License, or (at your option) any later version.
39 */
40 #include <linux/module.h>
41 #include <linux/types.h>
42 #include <linux/kernel.h>
43 #include <linux/string.h>
44 #include <linux/mm.h>
45 #include <linux/socket.h>
46 #include <linux/in.h>
47 #include <linux/inet.h>
48 #include <linux/ip.h>
49 #include <linux/netdevice.h>
50 #include <linux/etherdevice.h>
51 #include <linux/skbuff.h>
52 #include <linux/errno.h>
53 #include <linux/init.h>
54 #include <linux/if_ether.h>
55 #include <linux/of_net.h>
56 #include <linux/pci.h>
57 #include <net/dst.h>
58 #include <net/arp.h>
59 #include <net/sock.h>
60 #include <net/ipv6.h>
61 #include <net/ip.h>
62 #include <net/dsa.h>
63 #include <net/flow_dissector.h>
64 #include <linux/uaccess.h>
65
66 __setup("ether=", netdev_boot_setup);
67
68 /**
69 * eth_header - create the Ethernet header
70 * @skb: buffer to alter
71 * @dev: source device
72 * @type: Ethernet type field
73 * @daddr: destination address (NULL leave destination address)
74 * @saddr: source address (NULL use device source address)
75 * @len: packet length (<= skb->len)
76 *
77 *
78 * Set the protocol type. For a packet of type ETH_P_802_3/2 we put the length
79 * in here instead.
80 */
eth_header(struct sk_buff * skb,struct net_device * dev,unsigned short type,const void * daddr,const void * saddr,unsigned int len)81 int eth_header(struct sk_buff *skb, struct net_device *dev,
82 unsigned short type,
83 const void *daddr, const void *saddr, unsigned int len)
84 {
85 struct ethhdr *eth = (struct ethhdr *)skb_push(skb, ETH_HLEN);
86
87 if (type != ETH_P_802_3 && type != ETH_P_802_2)
88 eth->h_proto = htons(type);
89 else
90 eth->h_proto = htons(len);
91
92 /*
93 * Set the source hardware address.
94 */
95
96 if (!saddr)
97 saddr = dev->dev_addr;
98 memcpy(eth->h_source, saddr, ETH_ALEN);
99
100 if (daddr) {
101 memcpy(eth->h_dest, daddr, ETH_ALEN);
102 return ETH_HLEN;
103 }
104
105 /*
106 * Anyway, the loopback-device should never use this function...
107 */
108
109 if (dev->flags & (IFF_LOOPBACK | IFF_NOARP)) {
110 eth_zero_addr(eth->h_dest);
111 return ETH_HLEN;
112 }
113
114 return -ETH_HLEN;
115 }
116 EXPORT_SYMBOL(eth_header);
117
118 /**
119 * eth_get_headlen - determine the length of header for an ethernet frame
120 * @data: pointer to start of frame
121 * @len: total length of frame
122 *
123 * Make a best effort attempt to pull the length for all of the headers for
124 * a given frame in a linear buffer.
125 */
eth_get_headlen(void * data,unsigned int len)126 u32 eth_get_headlen(void *data, unsigned int len)
127 {
128 const unsigned int flags = FLOW_DISSECTOR_F_PARSE_1ST_FRAG;
129 const struct ethhdr *eth = (const struct ethhdr *)data;
130 struct flow_keys keys;
131
132 /* this should never happen, but better safe than sorry */
133 if (unlikely(len < sizeof(*eth)))
134 return len;
135
136 /* parse any remaining L2/L3 headers, check for L4 */
137 if (!skb_flow_dissect_flow_keys_buf(&keys, data, eth->h_proto,
138 sizeof(*eth), len, flags))
139 return max_t(u32, keys.control.thoff, sizeof(*eth));
140
141 /* parse for any L4 headers */
142 return min_t(u32, __skb_get_poff(NULL, data, &keys, len), len);
143 }
144 EXPORT_SYMBOL(eth_get_headlen);
145
146 /**
147 * eth_type_trans - determine the packet's protocol ID.
148 * @skb: received socket data
149 * @dev: receiving network device
150 *
151 * The rule here is that we
152 * assume 802.3 if the type field is short enough to be a length.
153 * This is normal practice and works for any 'now in use' protocol.
154 */
eth_type_trans(struct sk_buff * skb,struct net_device * dev)155 __be16 eth_type_trans(struct sk_buff *skb, struct net_device *dev)
156 {
157 unsigned short _service_access_point;
158 const unsigned short *sap;
159 const struct ethhdr *eth;
160
161 skb->dev = dev;
162 skb_reset_mac_header(skb);
163
164 eth = (struct ethhdr *)skb->data;
165 skb_pull_inline(skb, ETH_HLEN);
166
167 if (unlikely(is_multicast_ether_addr_64bits(eth->h_dest))) {
168 if (ether_addr_equal_64bits(eth->h_dest, dev->broadcast))
169 skb->pkt_type = PACKET_BROADCAST;
170 else
171 skb->pkt_type = PACKET_MULTICAST;
172 }
173 else if (unlikely(!ether_addr_equal_64bits(eth->h_dest,
174 dev->dev_addr)))
175 skb->pkt_type = PACKET_OTHERHOST;
176
177 /*
178 * Some variants of DSA tagging don't have an ethertype field
179 * at all, so we check here whether one of those tagging
180 * variants has been configured on the receiving interface,
181 * and if so, set skb->protocol without looking at the packet.
182 */
183 if (unlikely(netdev_uses_dsa(dev)))
184 return htons(ETH_P_XDSA);
185
186 if (likely(eth_proto_is_802_3(eth->h_proto)))
187 return eth->h_proto;
188
189 /*
190 * This is a magic hack to spot IPX packets. Older Novell breaks
191 * the protocol design and runs IPX over 802.3 without an 802.2 LLC
192 * layer. We look for FFFF which isn't a used 802.2 SSAP/DSAP. This
193 * won't work for fault tolerant netware but does for the rest.
194 */
195 sap = skb_header_pointer(skb, 0, sizeof(*sap), &_service_access_point);
196 if (sap && *sap == 0xFFFF)
197 return htons(ETH_P_802_3);
198
199 /*
200 * Real 802.2 LLC
201 */
202 return htons(ETH_P_802_2);
203 }
204 EXPORT_SYMBOL(eth_type_trans);
205
206 /**
207 * eth_header_parse - extract hardware address from packet
208 * @skb: packet to extract header from
209 * @haddr: destination buffer
210 */
eth_header_parse(const struct sk_buff * skb,unsigned char * haddr)211 int eth_header_parse(const struct sk_buff *skb, unsigned char *haddr)
212 {
213 const struct ethhdr *eth = eth_hdr(skb);
214 memcpy(haddr, eth->h_source, ETH_ALEN);
215 return ETH_ALEN;
216 }
217 EXPORT_SYMBOL(eth_header_parse);
218
219 /**
220 * eth_header_cache - fill cache entry from neighbour
221 * @neigh: source neighbour
222 * @hh: destination cache entry
223 * @type: Ethernet type field
224 *
225 * Create an Ethernet header template from the neighbour.
226 */
eth_header_cache(const struct neighbour * neigh,struct hh_cache * hh,__be16 type)227 int eth_header_cache(const struct neighbour *neigh, struct hh_cache *hh, __be16 type)
228 {
229 struct ethhdr *eth;
230 const struct net_device *dev = neigh->dev;
231
232 eth = (struct ethhdr *)
233 (((u8 *) hh->hh_data) + (HH_DATA_OFF(sizeof(*eth))));
234
235 if (type == htons(ETH_P_802_3))
236 return -1;
237
238 eth->h_proto = type;
239 memcpy(eth->h_source, dev->dev_addr, ETH_ALEN);
240 memcpy(eth->h_dest, neigh->ha, ETH_ALEN);
241 hh->hh_len = ETH_HLEN;
242 return 0;
243 }
244 EXPORT_SYMBOL(eth_header_cache);
245
246 /**
247 * eth_header_cache_update - update cache entry
248 * @hh: destination cache entry
249 * @dev: network device
250 * @haddr: new hardware address
251 *
252 * Called by Address Resolution module to notify changes in address.
253 */
eth_header_cache_update(struct hh_cache * hh,const struct net_device * dev,const unsigned char * haddr)254 void eth_header_cache_update(struct hh_cache *hh,
255 const struct net_device *dev,
256 const unsigned char *haddr)
257 {
258 memcpy(((u8 *) hh->hh_data) + HH_DATA_OFF(sizeof(struct ethhdr)),
259 haddr, ETH_ALEN);
260 }
261 EXPORT_SYMBOL(eth_header_cache_update);
262
263 /**
264 * eth_prepare_mac_addr_change - prepare for mac change
265 * @dev: network device
266 * @p: socket address
267 */
eth_prepare_mac_addr_change(struct net_device * dev,void * p)268 int eth_prepare_mac_addr_change(struct net_device *dev, void *p)
269 {
270 struct sockaddr *addr = p;
271
272 if (!(dev->priv_flags & IFF_LIVE_ADDR_CHANGE) && netif_running(dev))
273 return -EBUSY;
274 if (!is_valid_ether_addr(addr->sa_data))
275 return -EADDRNOTAVAIL;
276 return 0;
277 }
278 EXPORT_SYMBOL(eth_prepare_mac_addr_change);
279
280 /**
281 * eth_commit_mac_addr_change - commit mac change
282 * @dev: network device
283 * @p: socket address
284 */
eth_commit_mac_addr_change(struct net_device * dev,void * p)285 void eth_commit_mac_addr_change(struct net_device *dev, void *p)
286 {
287 struct sockaddr *addr = p;
288
289 memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
290 }
291 EXPORT_SYMBOL(eth_commit_mac_addr_change);
292
293 /**
294 * eth_mac_addr - set new Ethernet hardware address
295 * @dev: network device
296 * @p: socket address
297 *
298 * Change hardware address of device.
299 *
300 * This doesn't change hardware matching, so needs to be overridden
301 * for most real devices.
302 */
eth_mac_addr(struct net_device * dev,void * p)303 int eth_mac_addr(struct net_device *dev, void *p)
304 {
305 int ret;
306
307 ret = eth_prepare_mac_addr_change(dev, p);
308 if (ret < 0)
309 return ret;
310 eth_commit_mac_addr_change(dev, p);
311 return 0;
312 }
313 EXPORT_SYMBOL(eth_mac_addr);
314
315 /**
316 * eth_change_mtu - set new MTU size
317 * @dev: network device
318 * @new_mtu: new Maximum Transfer Unit
319 *
320 * Allow changing MTU size. Needs to be overridden for devices
321 * supporting jumbo frames.
322 */
eth_change_mtu(struct net_device * dev,int new_mtu)323 int eth_change_mtu(struct net_device *dev, int new_mtu)
324 {
325 if (new_mtu < 68 || new_mtu > ETH_DATA_LEN)
326 return -EINVAL;
327 dev->mtu = new_mtu;
328 return 0;
329 }
330 EXPORT_SYMBOL(eth_change_mtu);
331
eth_validate_addr(struct net_device * dev)332 int eth_validate_addr(struct net_device *dev)
333 {
334 if (!is_valid_ether_addr(dev->dev_addr))
335 return -EADDRNOTAVAIL;
336
337 return 0;
338 }
339 EXPORT_SYMBOL(eth_validate_addr);
340
341 const struct header_ops eth_header_ops ____cacheline_aligned = {
342 .create = eth_header,
343 .parse = eth_header_parse,
344 .cache = eth_header_cache,
345 .cache_update = eth_header_cache_update,
346 };
347
348 /**
349 * ether_setup - setup Ethernet network device
350 * @dev: network device
351 *
352 * Fill in the fields of the device structure with Ethernet-generic values.
353 */
ether_setup(struct net_device * dev)354 void ether_setup(struct net_device *dev)
355 {
356 dev->header_ops = ð_header_ops;
357 dev->type = ARPHRD_ETHER;
358 dev->hard_header_len = ETH_HLEN;
359 dev->min_header_len = ETH_HLEN;
360 dev->mtu = ETH_DATA_LEN;
361 dev->addr_len = ETH_ALEN;
362 dev->tx_queue_len = 1000; /* Ethernet wants good queues */
363 dev->flags = IFF_BROADCAST|IFF_MULTICAST;
364 dev->priv_flags |= IFF_TX_SKB_SHARING;
365
366 eth_broadcast_addr(dev->broadcast);
367
368 }
369 EXPORT_SYMBOL(ether_setup);
370
371 /**
372 * alloc_etherdev_mqs - Allocates and sets up an Ethernet device
373 * @sizeof_priv: Size of additional driver-private structure to be allocated
374 * for this Ethernet device
375 * @txqs: The number of TX queues this device has.
376 * @rxqs: The number of RX queues this device has.
377 *
378 * Fill in the fields of the device structure with Ethernet-generic
379 * values. Basically does everything except registering the device.
380 *
381 * Constructs a new net device, complete with a private data area of
382 * size (sizeof_priv). A 32-byte (not bit) alignment is enforced for
383 * this private data area.
384 */
385
alloc_etherdev_mqs(int sizeof_priv,unsigned int txqs,unsigned int rxqs)386 struct net_device *alloc_etherdev_mqs(int sizeof_priv, unsigned int txqs,
387 unsigned int rxqs)
388 {
389 return alloc_netdev_mqs(sizeof_priv, "eth%d", NET_NAME_UNKNOWN,
390 ether_setup, txqs, rxqs);
391 }
392 EXPORT_SYMBOL(alloc_etherdev_mqs);
393
sysfs_format_mac(char * buf,const unsigned char * addr,int len)394 ssize_t sysfs_format_mac(char *buf, const unsigned char *addr, int len)
395 {
396 return scnprintf(buf, PAGE_SIZE, "%*phC\n", len, addr);
397 }
398 EXPORT_SYMBOL(sysfs_format_mac);
399
eth_gro_receive(struct sk_buff ** head,struct sk_buff * skb)400 struct sk_buff **eth_gro_receive(struct sk_buff **head,
401 struct sk_buff *skb)
402 {
403 struct sk_buff *p, **pp = NULL;
404 struct ethhdr *eh, *eh2;
405 unsigned int hlen, off_eth;
406 const struct packet_offload *ptype;
407 __be16 type;
408 int flush = 1;
409
410 off_eth = skb_gro_offset(skb);
411 hlen = off_eth + sizeof(*eh);
412 eh = skb_gro_header_fast(skb, off_eth);
413 if (skb_gro_header_hard(skb, hlen)) {
414 eh = skb_gro_header_slow(skb, hlen, off_eth);
415 if (unlikely(!eh))
416 goto out;
417 }
418
419 flush = 0;
420
421 for (p = *head; p; p = p->next) {
422 if (!NAPI_GRO_CB(p)->same_flow)
423 continue;
424
425 eh2 = (struct ethhdr *)(p->data + off_eth);
426 if (compare_ether_header(eh, eh2)) {
427 NAPI_GRO_CB(p)->same_flow = 0;
428 continue;
429 }
430 }
431
432 type = eh->h_proto;
433
434 rcu_read_lock();
435 ptype = gro_find_receive_by_type(type);
436 if (ptype == NULL) {
437 flush = 1;
438 goto out_unlock;
439 }
440
441 skb_gro_pull(skb, sizeof(*eh));
442 skb_gro_postpull_rcsum(skb, eh, sizeof(*eh));
443 pp = call_gro_receive(ptype->callbacks.gro_receive, head, skb);
444
445 out_unlock:
446 rcu_read_unlock();
447 out:
448 NAPI_GRO_CB(skb)->flush |= flush;
449
450 return pp;
451 }
452 EXPORT_SYMBOL(eth_gro_receive);
453
eth_gro_complete(struct sk_buff * skb,int nhoff)454 int eth_gro_complete(struct sk_buff *skb, int nhoff)
455 {
456 struct ethhdr *eh = (struct ethhdr *)(skb->data + nhoff);
457 __be16 type = eh->h_proto;
458 struct packet_offload *ptype;
459 int err = -ENOSYS;
460
461 if (skb->encapsulation)
462 skb_set_inner_mac_header(skb, nhoff);
463
464 rcu_read_lock();
465 ptype = gro_find_complete_by_type(type);
466 if (ptype != NULL)
467 err = ptype->callbacks.gro_complete(skb, nhoff +
468 sizeof(struct ethhdr));
469
470 rcu_read_unlock();
471 return err;
472 }
473 EXPORT_SYMBOL(eth_gro_complete);
474
475 static struct packet_offload eth_packet_offload __read_mostly = {
476 .type = cpu_to_be16(ETH_P_TEB),
477 .priority = 10,
478 .callbacks = {
479 .gro_receive = eth_gro_receive,
480 .gro_complete = eth_gro_complete,
481 },
482 };
483
eth_offload_init(void)484 static int __init eth_offload_init(void)
485 {
486 dev_add_offload(ð_packet_offload);
487
488 return 0;
489 }
490
491 fs_initcall(eth_offload_init);
492
arch_get_platform_mac_address(void)493 unsigned char * __weak arch_get_platform_mac_address(void)
494 {
495 return NULL;
496 }
497
eth_platform_get_mac_address(struct device * dev,u8 * mac_addr)498 int eth_platform_get_mac_address(struct device *dev, u8 *mac_addr)
499 {
500 const unsigned char *addr;
501 struct device_node *dp;
502
503 if (dev_is_pci(dev))
504 dp = pci_device_to_OF_node(to_pci_dev(dev));
505 else
506 dp = dev->of_node;
507
508 addr = NULL;
509 if (dp)
510 addr = of_get_mac_address(dp);
511 if (!addr)
512 addr = arch_get_platform_mac_address();
513
514 if (!addr)
515 return -ENODEV;
516
517 ether_addr_copy(mac_addr, addr);
518 return 0;
519 }
520 EXPORT_SYMBOL(eth_platform_get_mac_address);
521