eth.c 12.7 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
2
3
4
5
6
7
8
9
/*
 * INET		An implementation of the TCP/IP protocol suite for the LINUX
 *		operating system.  INET is implemented using the  BSD Socket
 *		interface as the means of communication with the user level.
 *
 *		Ethernet-type device handling.
 *
 * Version:	@(#)eth.c	1.0.7	05/25/93
 *
10
 * Authors:	Ross Biro
Linus Torvalds's avatar
Linus Torvalds committed
11
12
13
14
 *		Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
 *		Mark Evans, <evansmp@uhura.aston.ac.uk>
 *		Florian  La Roche, <rzsfl@rz.uni-sb.de>
 *		Alan Cox, <gw4pts@gw4pts.ampr.org>
15
 *
Linus Torvalds's avatar
Linus Torvalds committed
16
17
18
19
20
21
 * Fixes:
 *		Mr Linux	: Arp problems
 *		Alan Cox	: Generic queue tidyup (very tiny here)
 *		Alan Cox	: eth_header ntohs should be htons
 *		Alan Cox	: eth_rebuild_header missing an htons and
 *				  minor other things.
22
 *		Tegge		: Arp bug fixes.
Linus Torvalds's avatar
Linus Torvalds committed
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 *		Florian		: Removed many unnecessary functions, code cleanup
 *				  and changes for new arp and skbuff.
 *		Alan Cox	: Redid header building to reflect new format.
 *		Alan Cox	: ARP only when compiled with CONFIG_INET
 *		Greg Page	: 802.2 and SNAP stuff.
 *		Alan Cox	: MAC layer pointers/new format.
 *		Paul Gortmaker	: eth_copy_and_sum shouldn't csum padding.
 *		Alan Cox	: Protect against forwarding explosions with
 *				  older network drivers and IFF_ALLMULTI.
 *	Christer Weinigel	: Better rebuild header message.
 *             Andrew Morton    : 26Feb01: kill ether_setup() - use netdev_boot_setup().
 *
 *		This program is free software; you can redistribute it and/or
 *		modify it under the terms of the GNU General Public License
 *		as published by the Free Software Foundation; either version
 *		2 of the License, or (at your option) any later version.
 */
#include <linux/module.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/string.h>
#include <linux/mm.h>
#include <linux/socket.h>
#include <linux/in.h>
#include <linux/inet.h>
#include <linux/ip.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/skbuff.h>
#include <linux/errno.h>
#include <linux/init.h>
54
#include <linux/if_ether.h>
Linus Torvalds's avatar
Linus Torvalds committed
55
56
57
58
59
#include <net/dst.h>
#include <net/arp.h>
#include <net/sock.h>
#include <net/ipv6.h>
#include <net/ip.h>
60
#include <net/dsa.h>
61
#include <net/flow_dissector.h>
62
#include <linux/uaccess.h>
Linus Torvalds's avatar
Linus Torvalds committed
63
64
65

__setup("ether=", netdev_boot_setup);

Stephen Hemminger's avatar
Stephen Hemminger committed
66
67
68
69
70
71
72
73
/**
 * eth_header - create the Ethernet header
 * @skb:	buffer to alter
 * @dev:	source device
 * @type:	Ethernet type field
 * @daddr: destination address (NULL leave destination address)
 * @saddr: source address (NULL use device source address)
 * @len:   packet length (<= skb->len)
Linus Torvalds's avatar
Linus Torvalds committed
74
 *
Stephen Hemminger's avatar
Stephen Hemminger committed
75
 *
Octavian Purdila's avatar
Octavian Purdila committed
76
77
 * Set the protocol type. For a packet of type ETH_P_802_3/2 we put the length
 * in here instead.
Linus Torvalds's avatar
Linus Torvalds committed
78
 */
79
80
int eth_header(struct sk_buff *skb, struct net_device *dev,
	       unsigned short type,
81
	       const void *daddr, const void *saddr, unsigned int len)
Linus Torvalds's avatar
Linus Torvalds committed
82
{
83
	struct ethhdr *eth = (struct ethhdr *)skb_push(skb, ETH_HLEN);
Linus Torvalds's avatar
Linus Torvalds committed
84

Octavian Purdila's avatar
Octavian Purdila committed
85
	if (type != ETH_P_802_3 && type != ETH_P_802_2)
Linus Torvalds's avatar
Linus Torvalds committed
86
87
88
89
90
		eth->h_proto = htons(type);
	else
		eth->h_proto = htons(len);

	/*
91
	 *      Set the source hardware address.
Linus Torvalds's avatar
Linus Torvalds committed
92
	 */
93
94

	if (!saddr)
95
		saddr = dev->dev_addr;
96
	memcpy(eth->h_source, saddr, ETH_ALEN);
Linus Torvalds's avatar
Linus Torvalds committed
97

98
	if (daddr) {
99
		memcpy(eth->h_dest, daddr, ETH_ALEN);
100
101
		return ETH_HLEN;
	}
102

Linus Torvalds's avatar
Linus Torvalds committed
103
	/*
104
	 *      Anyway, the loopback-device should never use this function...
Linus Torvalds's avatar
Linus Torvalds committed
105
106
	 */

107
	if (dev->flags & (IFF_LOOPBACK | IFF_NOARP)) {
108
		eth_zero_addr(eth->h_dest);
Linus Torvalds's avatar
Linus Torvalds committed
109
110
		return ETH_HLEN;
	}
111

Linus Torvalds's avatar
Linus Torvalds committed
112
113
	return -ETH_HLEN;
}
114
EXPORT_SYMBOL(eth_header);
Linus Torvalds's avatar
Linus Torvalds committed
115

116
/**
117
 * eth_get_headlen - determine the length of header for an ethernet frame
118
119
120
121
122
123
124
125
126
127
128
129
 * @data: pointer to start of frame
 * @len: total length of frame
 *
 * Make a best effort attempt to pull the length for all of the headers for
 * a given frame in a linear buffer.
 */
u32 eth_get_headlen(void *data, unsigned int len)
{
	const struct ethhdr *eth = (const struct ethhdr *)data;
	struct flow_keys keys;

	/* this should never happen, but better safe than sorry */
130
	if (unlikely(len < sizeof(*eth)))
131
132
133
		return len;

	/* parse any remaining L2/L3 headers, check for L4 */
134
	if (!skb_flow_dissect_flow_keys_buf(&keys, data, eth->h_proto,
135
					    sizeof(*eth), len, 0))
136
		return max_t(u32, keys.control.thoff, sizeof(*eth));
137
138
139
140
141
142

	/* parse for any L4 headers */
	return min_t(u32, __skb_get_poff(NULL, data, &keys, len), len);
}
EXPORT_SYMBOL(eth_get_headlen);

Stephen Hemminger's avatar
Stephen Hemminger committed
143
144
145
146
147
148
149
150
/**
 * eth_type_trans - determine the packet's protocol ID.
 * @skb: received socket data
 * @dev: receiving network device
 *
 * The rule here is that we
 * assume 802.3 if the type field is short enough to be a length.
 * This is normal practice and works for any 'now in use' protocol.
Linus Torvalds's avatar
Linus Torvalds committed
151
 */
152
__be16 eth_type_trans(struct sk_buff *skb, struct net_device *dev)
Linus Torvalds's avatar
Linus Torvalds committed
153
{
154
155
156
	unsigned short _service_access_point;
	const unsigned short *sap;
	const struct ethhdr *eth;
157

158
	skb->dev = dev;
159
	skb_reset_mac_header(skb);
160
161

	eth = (struct ethhdr *)skb->data;
162
	skb_pull_inline(skb, ETH_HLEN);
163

164
	if (unlikely(is_multicast_ether_addr_64bits(eth->h_dest))) {
165
		if (ether_addr_equal_64bits(eth->h_dest, dev->broadcast))
166
			skb->pkt_type = PACKET_BROADCAST;
Linus Torvalds's avatar
Linus Torvalds committed
167
		else
168
			skb->pkt_type = PACKET_MULTICAST;
Linus Torvalds's avatar
Linus Torvalds committed
169
	}
170
171
172
	else if (unlikely(!ether_addr_equal_64bits(eth->h_dest,
						   dev->dev_addr)))
		skb->pkt_type = PACKET_OTHERHOST;
173

174
175
176
177
178
179
	/*
	 * Some variants of DSA tagging don't have an ethertype field
	 * at all, so we check here whether one of those tagging
	 * variants has been configured on the receiving interface,
	 * and if so, set skb->protocol without looking at the packet.
	 */
180
181
	if (unlikely(netdev_uses_dsa(dev)))
		return htons(ETH_P_XDSA);
182

183
	if (likely(eth_proto_is_802_3(eth->h_proto)))
Linus Torvalds's avatar
Linus Torvalds committed
184
		return eth->h_proto;
185

Linus Torvalds's avatar
Linus Torvalds committed
186
	/*
187
188
189
190
	 *      This is a magic hack to spot IPX packets. Older Novell breaks
	 *      the protocol design and runs IPX over 802.3 without an 802.2 LLC
	 *      layer. We look for FFFF which isn't a used 802.2 SSAP/DSAP. This
	 *      won't work for fault tolerant netware but does for the rest.
Linus Torvalds's avatar
Linus Torvalds committed
191
	 */
192
193
	sap = skb_header_pointer(skb, 0, sizeof(*sap), &_service_access_point);
	if (sap && *sap == 0xFFFF)
Linus Torvalds's avatar
Linus Torvalds committed
194
		return htons(ETH_P_802_3);
195

Linus Torvalds's avatar
Linus Torvalds committed
196
	/*
197
	 *      Real 802.2 LLC
Linus Torvalds's avatar
Linus Torvalds committed
198
199
200
	 */
	return htons(ETH_P_802_2);
}
201
EXPORT_SYMBOL(eth_type_trans);
Linus Torvalds's avatar
Linus Torvalds committed
202

Stephen Hemminger's avatar
Stephen Hemminger committed
203
204
205
206
207
/**
 * eth_header_parse - extract hardware address from packet
 * @skb: packet to extract header from
 * @haddr: destination buffer
 */
208
int eth_header_parse(const struct sk_buff *skb, unsigned char *haddr)
Linus Torvalds's avatar
Linus Torvalds committed
209
{
210
	const struct ethhdr *eth = eth_hdr(skb);
Linus Torvalds's avatar
Linus Torvalds committed
211
212
213
	memcpy(haddr, eth->h_source, ETH_ALEN);
	return ETH_ALEN;
}
214
EXPORT_SYMBOL(eth_header_parse);
Linus Torvalds's avatar
Linus Torvalds committed
215

Stephen Hemminger's avatar
Stephen Hemminger committed
216
217
218
219
/**
 * eth_header_cache - fill cache entry from neighbour
 * @neigh: source neighbour
 * @hh: destination cache entry
220
 * @type: Ethernet type field
221
 *
Stephen Hemminger's avatar
Stephen Hemminger committed
222
223
 * Create an Ethernet header template from the neighbour.
 */
224
int eth_header_cache(const struct neighbour *neigh, struct hh_cache *hh, __be16 type)
Linus Torvalds's avatar
Linus Torvalds committed
225
226
{
	struct ethhdr *eth;
227
	const struct net_device *dev = neigh->dev;
Linus Torvalds's avatar
Linus Torvalds committed
228

229
230
	eth = (struct ethhdr *)
	    (((u8 *) hh->hh_data) + (HH_DATA_OFF(sizeof(*eth))));
Linus Torvalds's avatar
Linus Torvalds committed
231

232
	if (type == htons(ETH_P_802_3))
Linus Torvalds's avatar
Linus Torvalds committed
233
234
235
		return -1;

	eth->h_proto = type;
236
237
	memcpy(eth->h_source, dev->dev_addr, ETH_ALEN);
	memcpy(eth->h_dest, neigh->ha, ETH_ALEN);
Linus Torvalds's avatar
Linus Torvalds committed
238
239
240
	hh->hh_len = ETH_HLEN;
	return 0;
}
241
EXPORT_SYMBOL(eth_header_cache);
Linus Torvalds's avatar
Linus Torvalds committed
242

Stephen Hemminger's avatar
Stephen Hemminger committed
243
244
245
246
247
248
/**
 * eth_header_cache_update - update cache entry
 * @hh: destination cache entry
 * @dev: network device
 * @haddr: new hardware address
 *
Linus Torvalds's avatar
Linus Torvalds committed
249
250
 * Called by Address Resolution module to notify changes in address.
 */
251
252
253
void eth_header_cache_update(struct hh_cache *hh,
			     const struct net_device *dev,
			     const unsigned char *haddr)
Linus Torvalds's avatar
Linus Torvalds committed
254
{
255
	memcpy(((u8 *) hh->hh_data) + HH_DATA_OFF(sizeof(struct ethhdr)),
256
	       haddr, ETH_ALEN);
Linus Torvalds's avatar
Linus Torvalds committed
257
}
258
EXPORT_SYMBOL(eth_header_cache_update);
Linus Torvalds's avatar
Linus Torvalds committed
259

260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
/**
 * eth_prepare_mac_addr_change - prepare for mac change
 * @dev: network device
 * @p: socket address
 */
int eth_prepare_mac_addr_change(struct net_device *dev, void *p)
{
	struct sockaddr *addr = p;

	if (!(dev->priv_flags & IFF_LIVE_ADDR_CHANGE) && netif_running(dev))
		return -EBUSY;
	if (!is_valid_ether_addr(addr->sa_data))
		return -EADDRNOTAVAIL;
	return 0;
}
EXPORT_SYMBOL(eth_prepare_mac_addr_change);

/**
 * eth_commit_mac_addr_change - commit mac change
 * @dev: network device
 * @p: socket address
 */
void eth_commit_mac_addr_change(struct net_device *dev, void *p)
{
	struct sockaddr *addr = p;

	memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
}
EXPORT_SYMBOL(eth_commit_mac_addr_change);

Stephen Hemminger's avatar
Stephen Hemminger committed
290
291
292
293
/**
 * eth_mac_addr - set new Ethernet hardware address
 * @dev: network device
 * @p: socket address
294
 *
Stephen Hemminger's avatar
Stephen Hemminger committed
295
296
297
298
299
 * Change hardware address of device.
 *
 * This doesn't change hardware matching, so needs to be overridden
 * for most real devices.
 */
300
int eth_mac_addr(struct net_device *dev, void *p)
Linus Torvalds's avatar
Linus Torvalds committed
301
{
302
	int ret;
303

304
305
306
307
	ret = eth_prepare_mac_addr_change(dev, p);
	if (ret < 0)
		return ret;
	eth_commit_mac_addr_change(dev, p);
Linus Torvalds's avatar
Linus Torvalds committed
308
309
	return 0;
}
310
EXPORT_SYMBOL(eth_mac_addr);
Linus Torvalds's avatar
Linus Torvalds committed
311

Stephen Hemminger's avatar
Stephen Hemminger committed
312
313
314
315
316
317
318
319
/**
 * eth_change_mtu - set new MTU size
 * @dev: network device
 * @new_mtu: new Maximum Transfer Unit
 *
 * Allow changing MTU size. Needs to be overridden for devices
 * supporting jumbo frames.
 */
320
int eth_change_mtu(struct net_device *dev, int new_mtu)
Linus Torvalds's avatar
Linus Torvalds committed
321
{
322
	if (new_mtu < 68 || new_mtu > ETH_DATA_LEN)
Linus Torvalds's avatar
Linus Torvalds committed
323
324
325
326
		return -EINVAL;
	dev->mtu = new_mtu;
	return 0;
}
327
EXPORT_SYMBOL(eth_change_mtu);
Linus Torvalds's avatar
Linus Torvalds committed
328

329
int eth_validate_addr(struct net_device *dev)
330
331
{
	if (!is_valid_ether_addr(dev->dev_addr))
332
		return -EADDRNOTAVAIL;
333
334
335

	return 0;
}
336
EXPORT_SYMBOL(eth_validate_addr);
337

338
339
340
341
342
343
344
const struct header_ops eth_header_ops ____cacheline_aligned = {
	.create		= eth_header,
	.parse		= eth_header_parse,
	.cache		= eth_header_cache,
	.cache_update	= eth_header_cache_update,
};

Stephen Hemminger's avatar
Stephen Hemminger committed
345
346
347
/**
 * ether_setup - setup Ethernet network device
 * @dev: network device
348
 *
Stephen Hemminger's avatar
Stephen Hemminger committed
349
 * Fill in the fields of the device structure with Ethernet-generic values.
Linus Torvalds's avatar
Linus Torvalds committed
350
351
352
 */
void ether_setup(struct net_device *dev)
{
353
	dev->header_ops		= &eth_header_ops;
Linus Torvalds's avatar
Linus Torvalds committed
354
355
	dev->type		= ARPHRD_ETHER;
	dev->hard_header_len 	= ETH_HLEN;
356
	dev->mtu		= ETH_DATA_LEN;
Linus Torvalds's avatar
Linus Torvalds committed
357
	dev->addr_len		= ETH_ALEN;
358
	dev->tx_queue_len	= 1000;	/* Ethernet wants good queues */
Linus Torvalds's avatar
Linus Torvalds committed
359
	dev->flags		= IFF_BROADCAST|IFF_MULTICAST;
360
	dev->priv_flags		|= IFF_TX_SKB_SHARING;
361

362
	eth_broadcast_addr(dev->broadcast);
Linus Torvalds's avatar
Linus Torvalds committed
363
364
365
366
367

}
EXPORT_SYMBOL(ether_setup);

/**
368
 * alloc_etherdev_mqs - Allocates and sets up an Ethernet device
Linus Torvalds's avatar
Linus Torvalds committed
369
 * @sizeof_priv: Size of additional driver-private structure to be allocated
Stephen Hemminger's avatar
Stephen Hemminger committed
370
 *	for this Ethernet device
371
 * @txqs: The number of TX queues this device has.
Randy Dunlap's avatar
Randy Dunlap committed
372
 * @rxqs: The number of RX queues this device has.
Linus Torvalds's avatar
Linus Torvalds committed
373
 *
Stephen Hemminger's avatar
Stephen Hemminger committed
374
 * Fill in the fields of the device structure with Ethernet-generic
Linus Torvalds's avatar
Linus Torvalds committed
375
376
377
 * values. Basically does everything except registering the device.
 *
 * Constructs a new net device, complete with a private data area of
Stephen Hemminger's avatar
Stephen Hemminger committed
378
 * size (sizeof_priv).  A 32-byte (not bit) alignment is enforced for
Linus Torvalds's avatar
Linus Torvalds committed
379
380
381
 * this private data area.
 */

382
383
struct net_device *alloc_etherdev_mqs(int sizeof_priv, unsigned int txqs,
				      unsigned int rxqs)
Linus Torvalds's avatar
Linus Torvalds committed
384
{
385
386
	return alloc_netdev_mqs(sizeof_priv, "eth%d", NET_NAME_UNKNOWN,
				ether_setup, txqs, rxqs);
Linus Torvalds's avatar
Linus Torvalds committed
387
}
388
EXPORT_SYMBOL(alloc_etherdev_mqs);
389

390
391
ssize_t sysfs_format_mac(char *buf, const unsigned char *addr, int len)
{
392
	return scnprintf(buf, PAGE_SIZE, "%*phC\n", len, addr);
393
394
}
EXPORT_SYMBOL(sysfs_format_mac);
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472

struct sk_buff **eth_gro_receive(struct sk_buff **head,
				 struct sk_buff *skb)
{
	struct sk_buff *p, **pp = NULL;
	struct ethhdr *eh, *eh2;
	unsigned int hlen, off_eth;
	const struct packet_offload *ptype;
	__be16 type;
	int flush = 1;

	off_eth = skb_gro_offset(skb);
	hlen = off_eth + sizeof(*eh);
	eh = skb_gro_header_fast(skb, off_eth);
	if (skb_gro_header_hard(skb, hlen)) {
		eh = skb_gro_header_slow(skb, hlen, off_eth);
		if (unlikely(!eh))
			goto out;
	}

	flush = 0;

	for (p = *head; p; p = p->next) {
		if (!NAPI_GRO_CB(p)->same_flow)
			continue;

		eh2 = (struct ethhdr *)(p->data + off_eth);
		if (compare_ether_header(eh, eh2)) {
			NAPI_GRO_CB(p)->same_flow = 0;
			continue;
		}
	}

	type = eh->h_proto;

	rcu_read_lock();
	ptype = gro_find_receive_by_type(type);
	if (ptype == NULL) {
		flush = 1;
		goto out_unlock;
	}

	skb_gro_pull(skb, sizeof(*eh));
	skb_gro_postpull_rcsum(skb, eh, sizeof(*eh));
	pp = ptype->callbacks.gro_receive(head, skb);

out_unlock:
	rcu_read_unlock();
out:
	NAPI_GRO_CB(skb)->flush |= flush;

	return pp;
}
EXPORT_SYMBOL(eth_gro_receive);

int eth_gro_complete(struct sk_buff *skb, int nhoff)
{
	struct ethhdr *eh = (struct ethhdr *)(skb->data + nhoff);
	__be16 type = eh->h_proto;
	struct packet_offload *ptype;
	int err = -ENOSYS;

	if (skb->encapsulation)
		skb_set_inner_mac_header(skb, nhoff);

	rcu_read_lock();
	ptype = gro_find_complete_by_type(type);
	if (ptype != NULL)
		err = ptype->callbacks.gro_complete(skb, nhoff +
						    sizeof(struct ethhdr));

	rcu_read_unlock();
	return err;
}
EXPORT_SYMBOL(eth_gro_complete);

static struct packet_offload eth_packet_offload __read_mostly = {
	.type = cpu_to_be16(ETH_P_TEB),
473
	.priority = 10,
474
475
476
477
478
479
480
481
482
483
484
485
486
487
	.callbacks = {
		.gro_receive = eth_gro_receive,
		.gro_complete = eth_gro_complete,
	},
};

static int __init eth_offload_init(void)
{
	dev_add_offload(&eth_packet_offload);

	return 0;
}

fs_initcall(eth_offload_init);