1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36#include <linux/module.h>
37#include <linux/types.h>
38#include <linux/kernel.h>
39#include <linux/string.h>
40#include <linux/mm.h>
41#include <linux/socket.h>
42#include <linux/in.h>
43#include <linux/inet.h>
44#include <linux/ip.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>
54#include <net/dst.h>
55#include <net/arp.h>
56#include <net/sock.h>
57#include <net/ipv6.h>
58#include <net/ip.h>
59#include <net/dsa.h>
60#include <net/flow_dissector.h>
61#include <net/gro.h>
62#include <linux/uaccess.h>
63#include <net/pkt_sched.h>
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78int eth_header(struct sk_buff *skb, struct net_device *dev,
79 unsigned short type,
80 const void *daddr, const void *saddr, unsigned int len)
81{
82 struct ethhdr *eth = skb_push(skb, ETH_HLEN);
83
84 if (type != ETH_P_802_3 && type != ETH_P_802_2)
85 eth->h_proto = htons(type);
86 else
87 eth->h_proto = htons(len);
88
89
90
91
92
93 if (!saddr)
94 saddr = dev->dev_addr;
95 memcpy(eth->h_source, saddr, ETH_ALEN);
96
97 if (daddr) {
98 memcpy(eth->h_dest, daddr, ETH_ALEN);
99 return ETH_HLEN;
100 }
101
102
103
104
105
106 if (dev->flags & (IFF_LOOPBACK | IFF_NOARP)) {
107 eth_zero_addr(eth->h_dest);
108 return ETH_HLEN;
109 }
110
111 return -ETH_HLEN;
112}
113EXPORT_SYMBOL(eth_header);
114
115
116
117
118
119
120
121
122
123
124u32 eth_get_headlen(const struct net_device *dev, const void *data, u32 len)
125{
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;
129
130
131 if (unlikely(len < sizeof(*eth)))
132 return len;
133
134
135 if (!skb_flow_dissect_flow_keys_basic(dev_net(dev), NULL, &keys, data,
136 eth->h_proto, sizeof(*eth),
137 len, flags))
138 return max_t(u32, keys.control.thoff, sizeof(*eth));
139
140
141 return min_t(u32, __skb_get_poff(NULL, data, &keys, len), len);
142}
143EXPORT_SYMBOL(eth_get_headlen);
144
145
146
147
148
149
150
151
152
153
154__be16 eth_type_trans(struct sk_buff *skb, struct net_device *dev)
155{
156 unsigned short _service_access_point;
157 const unsigned short *sap;
158 const struct ethhdr *eth;
159
160 skb->dev = dev;
161 skb_reset_mac_header(skb);
162
163 eth = (struct ethhdr *)skb->data;
164 skb_pull_inline(skb, ETH_HLEN);
165
166 if (unlikely(!ether_addr_equal_64bits(eth->h_dest,
167 dev->dev_addr))) {
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;
171 else
172 skb->pkt_type = PACKET_MULTICAST;
173 } else {
174 skb->pkt_type = PACKET_OTHERHOST;
175 }
176 }
177
178
179
180
181
182
183
184 if (unlikely(netdev_uses_dsa(dev)))
185 return htons(ETH_P_XDSA);
186
187 if (likely(eth_proto_is_802_3(eth->h_proto)))
188 return eth->h_proto;
189
190
191
192
193
194
195
196 sap = skb_header_pointer(skb, 0, sizeof(*sap), &_service_access_point);
197 if (sap && *sap == 0xFFFF)
198 return htons(ETH_P_802_3);
199
200
201
202
203 return htons(ETH_P_802_2);
204}
205EXPORT_SYMBOL(eth_type_trans);
206
207
208
209
210
211
212int eth_header_parse(const struct sk_buff *skb, unsigned char *haddr)
213{
214 const struct ethhdr *eth = eth_hdr(skb);
215 memcpy(haddr, eth->h_source, ETH_ALEN);
216 return ETH_ALEN;
217}
218EXPORT_SYMBOL(eth_header_parse);
219
220
221
222
223
224
225
226
227
228int eth_header_cache(const struct neighbour *neigh, struct hh_cache *hh, __be16 type)
229{
230 struct ethhdr *eth;
231 const struct net_device *dev = neigh->dev;
232
233 eth = (struct ethhdr *)
234 (((u8 *) hh->hh_data) + (HH_DATA_OFF(sizeof(*eth))));
235
236 if (type == htons(ETH_P_802_3))
237 return -1;
238
239 eth->h_proto = type;
240 memcpy(eth->h_source, dev->dev_addr, ETH_ALEN);
241 memcpy(eth->h_dest, neigh->ha, ETH_ALEN);
242
243
244
245
246 smp_store_release(&hh->hh_len, ETH_HLEN);
247
248 return 0;
249}
250EXPORT_SYMBOL(eth_header_cache);
251
252
253
254
255
256
257
258
259
260void eth_header_cache_update(struct hh_cache *hh,
261 const struct net_device *dev,
262 const unsigned char *haddr)
263{
264 memcpy(((u8 *) hh->hh_data) + HH_DATA_OFF(sizeof(struct ethhdr)),
265 haddr, ETH_ALEN);
266}
267EXPORT_SYMBOL(eth_header_cache_update);
268
269
270
271
272
273__be16 eth_header_parse_protocol(const struct sk_buff *skb)
274{
275 const struct ethhdr *eth = eth_hdr(skb);
276
277 return eth->h_proto;
278}
279EXPORT_SYMBOL(eth_header_parse_protocol);
280
281
282
283
284
285
286int eth_prepare_mac_addr_change(struct net_device *dev, void *p)
287{
288 struct sockaddr *addr = p;
289
290 if (!(dev->priv_flags & IFF_LIVE_ADDR_CHANGE) && netif_running(dev))
291 return -EBUSY;
292 if (!is_valid_ether_addr(addr->sa_data))
293 return -EADDRNOTAVAIL;
294 return 0;
295}
296EXPORT_SYMBOL(eth_prepare_mac_addr_change);
297
298
299
300
301
302
303void eth_commit_mac_addr_change(struct net_device *dev, void *p)
304{
305 struct sockaddr *addr = p;
306
307 memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
308}
309EXPORT_SYMBOL(eth_commit_mac_addr_change);
310
311
312
313
314
315
316
317
318
319
320
321int eth_mac_addr(struct net_device *dev, void *p)
322{
323 int ret;
324
325 ret = eth_prepare_mac_addr_change(dev, p);
326 if (ret < 0)
327 return ret;
328 eth_commit_mac_addr_change(dev, p);
329 return 0;
330}
331EXPORT_SYMBOL(eth_mac_addr);
332
333int eth_validate_addr(struct net_device *dev)
334{
335 if (!is_valid_ether_addr(dev->dev_addr))
336 return -EADDRNOTAVAIL;
337
338 return 0;
339}
340EXPORT_SYMBOL(eth_validate_addr);
341
342const 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,
348};
349
350
351
352
353
354
355
356void ether_setup(struct net_device *dev)
357{
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;
369
370 eth_broadcast_addr(dev->broadcast);
371
372}
373EXPORT_SYMBOL(ether_setup);
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390struct net_device *alloc_etherdev_mqs(int sizeof_priv, unsigned int txqs,
391 unsigned int rxqs)
392{
393 return alloc_netdev_mqs(sizeof_priv, "eth%d", NET_NAME_UNKNOWN,
394 ether_setup, txqs, rxqs);
395}
396EXPORT_SYMBOL(alloc_etherdev_mqs);
397
398ssize_t sysfs_format_mac(char *buf, const unsigned char *addr, int len)
399{
400 return scnprintf(buf, PAGE_SIZE, "%*phC\n", len, addr);
401}
402EXPORT_SYMBOL(sysfs_format_mac);
403
404struct sk_buff *eth_gro_receive(struct list_head *head, struct sk_buff *skb)
405{
406 const struct packet_offload *ptype;
407 unsigned int hlen, off_eth;
408 struct sk_buff *pp = NULL;
409 struct ethhdr *eh, *eh2;
410 struct sk_buff *p;
411 __be16 type;
412 int flush = 1;
413
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);
419 if (unlikely(!eh))
420 goto out;
421 }
422
423 flush = 0;
424
425 list_for_each_entry(p, head, list) {
426 if (!NAPI_GRO_CB(p)->same_flow)
427 continue;
428
429 eh2 = (struct ethhdr *)(p->data + off_eth);
430 if (compare_ether_header(eh, eh2)) {
431 NAPI_GRO_CB(p)->same_flow = 0;
432 continue;
433 }
434 }
435
436 type = eh->h_proto;
437
438 rcu_read_lock();
439 ptype = gro_find_receive_by_type(type);
440 if (ptype == NULL) {
441 flush = 1;
442 goto out_unlock;
443 }
444
445 skb_gro_pull(skb, sizeof(*eh));
446 skb_gro_postpull_rcsum(skb, eh, sizeof(*eh));
447
448 pp = indirect_call_gro_receive_inet(ptype->callbacks.gro_receive,
449 ipv6_gro_receive, inet_gro_receive,
450 head, skb);
451
452out_unlock:
453 rcu_read_unlock();
454out:
455 skb_gro_flush_final(skb, pp, flush);
456
457 return pp;
458}
459EXPORT_SYMBOL(eth_gro_receive);
460
461int eth_gro_complete(struct sk_buff *skb, int nhoff)
462{
463 struct ethhdr *eh = (struct ethhdr *)(skb->data + nhoff);
464 __be16 type = eh->h_proto;
465 struct packet_offload *ptype;
466 int err = -ENOSYS;
467
468 if (skb->encapsulation)
469 skb_set_inner_mac_header(skb, nhoff);
470
471 rcu_read_lock();
472 ptype = gro_find_complete_by_type(type);
473 if (ptype != NULL)
474 err = INDIRECT_CALL_INET(ptype->callbacks.gro_complete,
475 ipv6_gro_complete, inet_gro_complete,
476 skb, nhoff + sizeof(*eh));
477
478 rcu_read_unlock();
479 return err;
480}
481EXPORT_SYMBOL(eth_gro_complete);
482
483static struct packet_offload eth_packet_offload __read_mostly = {
484 .type = cpu_to_be16(ETH_P_TEB),
485 .priority = 10,
486 .callbacks = {
487 .gro_receive = eth_gro_receive,
488 .gro_complete = eth_gro_complete,
489 },
490};
491
492static int __init eth_offload_init(void)
493{
494 dev_add_offload(ð_packet_offload);
495
496 return 0;
497}
498
499fs_initcall(eth_offload_init);
500
501unsigned char * __weak arch_get_platform_mac_address(void)
502{
503 return NULL;
504}
505
506int eth_platform_get_mac_address(struct device *dev, u8 *mac_addr)
507{
508 unsigned char *addr;
509 int ret;
510
511 ret = of_get_mac_address(dev->of_node, mac_addr);
512 if (!ret)
513 return 0;
514
515 addr = arch_get_platform_mac_address();
516 if (!addr)
517 return -ENODEV;
518
519 ether_addr_copy(mac_addr, addr);
520
521 return 0;
522}
523EXPORT_SYMBOL(eth_platform_get_mac_address);
524
525
526
527
528
529
530
531
532
533
534int nvmem_get_mac_address(struct device *dev, void *addrbuf)
535{
536 struct nvmem_cell *cell;
537 const void *mac;
538 size_t len;
539
540 cell = nvmem_cell_get(dev, "mac-address");
541 if (IS_ERR(cell))
542 return PTR_ERR(cell);
543
544 mac = nvmem_cell_read(cell, &len);
545 nvmem_cell_put(cell);
546
547 if (IS_ERR(mac))
548 return PTR_ERR(mac);
549
550 if (len != ETH_ALEN || !is_valid_ether_addr(mac)) {
551 kfree(mac);
552 return -EINVAL;
553 }
554
555 ether_addr_copy(addrbuf, mac);
556 kfree(mac);
557
558 return 0;
559}
560EXPORT_SYMBOL(nvmem_get_mac_address);
561