2019-05-27 06:55:01 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* 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
|
|
|
|
*
|
2005-05-05 23:16:16 +00:00
|
|
|
* Authors: Ross Biro
|
2005-04-16 22:20:36 +00:00
|
|
|
* 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>
|
2007-02-09 14:24:44 +00:00
|
|
|
*
|
2005-04-16 22:20:36 +00:00
|
|
|
* 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.
|
2007-02-09 14:24:44 +00:00
|
|
|
* Tegge : Arp bug fixes.
|
2005-04-16 22:20:36 +00:00
|
|
|
* 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().
|
|
|
|
*/
|
|
|
|
#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>
|
2018-11-30 08:20:57 +00:00
|
|
|
#include <linux/nvmem-consumer.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/etherdevice.h>
|
|
|
|
#include <linux/skbuff.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/init.h>
|
2006-01-06 00:35:42 +00:00
|
|
|
#include <linux/if_ether.h>
|
2015-11-05 16:34:57 +00:00
|
|
|
#include <linux/of_net.h>
|
|
|
|
#include <linux/pci.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <net/dst.h>
|
|
|
|
#include <net/arp.h>
|
|
|
|
#include <net/sock.h>
|
|
|
|
#include <net/ipv6.h>
|
|
|
|
#include <net/ip.h>
|
2008-10-07 13:45:02 +00:00
|
|
|
#include <net/dsa.h>
|
2015-05-12 12:56:09 +00:00
|
|
|
#include <net/flow_dissector.h>
|
2013-09-19 16:06:50 +00:00
|
|
|
#include <linux/uaccess.h>
|
2016-11-03 13:56:01 +00:00
|
|
|
#include <net/pkt_sched.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
__setup("ether=", netdev_boot_setup);
|
|
|
|
|
2006-08-18 01:18:53 +00:00
|
|
|
/**
|
|
|
|
* 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)
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2006-08-18 01:18:53 +00:00
|
|
|
*
|
2009-12-26 11:50:59 +00:00
|
|
|
* Set the protocol type. For a packet of type ETH_P_802_3/2 we put the length
|
|
|
|
* in here instead.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2007-10-09 08:40:57 +00:00
|
|
|
int eth_header(struct sk_buff *skb, struct net_device *dev,
|
|
|
|
unsigned short type,
|
2012-04-15 05:58:06 +00:00
|
|
|
const void *daddr, const void *saddr, unsigned int len)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
networking: make skb_push & __skb_push return void pointers
It seems like a historic accident that these return unsigned char *,
and in many places that means casts are required, more often than not.
Make these functions return void * and remove all the casts across
the tree, adding a (u8 *) cast only where the unsigned char pointer
was used directly, all done with the following spatch:
@@
expression SKB, LEN;
typedef u8;
identifier fn = { skb_push, __skb_push, skb_push_rcsum };
@@
- *(fn(SKB, LEN))
+ *(u8 *)fn(SKB, LEN)
@@
expression E, SKB, LEN;
identifier fn = { skb_push, __skb_push, skb_push_rcsum };
type T;
@@
- E = ((T *)(fn(SKB, LEN)))
+ E = fn(SKB, LEN)
@@
expression SKB, LEN;
identifier fn = { skb_push, __skb_push, skb_push_rcsum };
@@
- fn(SKB, LEN)[0]
+ *(u8 *)fn(SKB, LEN)
Note that the last part there converts from push(...)[0] to the
more idiomatic *(u8 *)push(...).
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-06-16 12:29:23 +00:00
|
|
|
struct ethhdr *eth = skb_push(skb, ETH_HLEN);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-12-26 11:50:59 +00:00
|
|
|
if (type != ETH_P_802_3 && type != ETH_P_802_2)
|
2005-04-16 22:20:36 +00:00
|
|
|
eth->h_proto = htons(type);
|
|
|
|
else
|
|
|
|
eth->h_proto = htons(len);
|
|
|
|
|
|
|
|
/*
|
2006-08-18 01:20:18 +00:00
|
|
|
* Set the source hardware address.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2006-08-18 01:20:18 +00:00
|
|
|
|
|
|
|
if (!saddr)
|
2005-06-28 22:49:06 +00:00
|
|
|
saddr = dev->dev_addr;
|
2007-08-25 05:35:44 +00:00
|
|
|
memcpy(eth->h_source, saddr, ETH_ALEN);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-08-18 01:20:18 +00:00
|
|
|
if (daddr) {
|
2007-08-25 05:35:44 +00:00
|
|
|
memcpy(eth->h_dest, daddr, ETH_ALEN);
|
2006-02-24 00:18:01 +00:00
|
|
|
return ETH_HLEN;
|
|
|
|
}
|
2006-08-18 01:20:18 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2006-08-18 01:20:18 +00:00
|
|
|
* Anyway, the loopback-device should never use this function...
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
|
2006-08-18 01:20:18 +00:00
|
|
|
if (dev->flags & (IFF_LOOPBACK | IFF_NOARP)) {
|
2015-03-03 03:54:56 +00:00
|
|
|
eth_zero_addr(eth->h_dest);
|
2005-04-16 22:20:36 +00:00
|
|
|
return ETH_HLEN;
|
|
|
|
}
|
2006-08-18 01:20:18 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return -ETH_HLEN;
|
|
|
|
}
|
2007-10-09 08:40:57 +00:00
|
|
|
EXPORT_SYMBOL(eth_header);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-09-05 23:20:26 +00:00
|
|
|
/**
|
2015-08-06 12:27:54 +00:00
|
|
|
* eth_get_headlen - determine the length of header for an ethernet frame
|
2019-04-22 15:55:48 +00:00
|
|
|
* @dev: pointer to network device
|
2014-09-05 23:20:26 +00:00
|
|
|
* @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.
|
|
|
|
*/
|
2019-04-22 15:55:48 +00:00
|
|
|
u32 eth_get_headlen(const struct net_device *dev, void *data, unsigned int len)
|
2014-09-05 23:20:26 +00:00
|
|
|
{
|
2016-02-24 17:30:04 +00:00
|
|
|
const unsigned int flags = FLOW_DISSECTOR_F_PARSE_1ST_FRAG;
|
2014-09-05 23:20:26 +00:00
|
|
|
const struct ethhdr *eth = (const struct ethhdr *)data;
|
2018-05-04 09:32:59 +00:00
|
|
|
struct flow_keys_basic keys;
|
2014-09-05 23:20:26 +00:00
|
|
|
|
|
|
|
/* this should never happen, but better safe than sorry */
|
2015-09-28 10:47:14 +00:00
|
|
|
if (unlikely(len < sizeof(*eth)))
|
2014-09-05 23:20:26 +00:00
|
|
|
return len;
|
|
|
|
|
|
|
|
/* parse any remaining L2/L3 headers, check for L4 */
|
2019-04-22 15:55:48 +00:00
|
|
|
if (!skb_flow_dissect_flow_keys_basic(dev_net(dev), NULL, &keys, data,
|
2019-04-22 15:55:46 +00:00
|
|
|
eth->h_proto, sizeof(*eth),
|
|
|
|
len, flags))
|
2015-06-04 16:16:40 +00:00
|
|
|
return max_t(u32, keys.control.thoff, sizeof(*eth));
|
2014-09-05 23:20:26 +00:00
|
|
|
|
|
|
|
/* parse for any L4 headers */
|
|
|
|
return min_t(u32, __skb_get_poff(NULL, data, &keys, len), len);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(eth_get_headlen);
|
|
|
|
|
2006-08-18 01:18:53 +00:00
|
|
|
/**
|
|
|
|
* 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.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2005-07-12 19:08:43 +00:00
|
|
|
__be16 eth_type_trans(struct sk_buff *skb, struct net_device *dev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2014-01-16 23:03:31 +00:00
|
|
|
unsigned short _service_access_point;
|
|
|
|
const unsigned short *sap;
|
|
|
|
const struct ethhdr *eth;
|
2006-08-18 01:20:18 +00:00
|
|
|
|
2007-04-26 00:40:23 +00:00
|
|
|
skb->dev = dev;
|
2007-03-19 22:30:44 +00:00
|
|
|
skb_reset_mac_header(skb);
|
2015-04-30 21:53:59 +00:00
|
|
|
|
|
|
|
eth = (struct ethhdr *)skb->data;
|
2010-05-02 09:21:44 +00:00
|
|
|
skb_pull_inline(skb, ETH_HLEN);
|
2006-08-18 01:20:18 +00:00
|
|
|
|
2018-11-13 01:34:31 +00:00
|
|
|
if (unlikely(!ether_addr_equal_64bits(eth->h_dest,
|
|
|
|
dev->dev_addr))) {
|
|
|
|
if (unlikely(is_multicast_ether_addr_64bits(eth->h_dest))) {
|
|
|
|
if (ether_addr_equal_64bits(eth->h_dest, dev->broadcast))
|
|
|
|
skb->pkt_type = PACKET_BROADCAST;
|
|
|
|
else
|
|
|
|
skb->pkt_type = PACKET_MULTICAST;
|
|
|
|
} else {
|
|
|
|
skb->pkt_type = PACKET_OTHERHOST;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2006-08-18 01:20:18 +00:00
|
|
|
|
2008-10-07 13:45:02 +00:00
|
|
|
/*
|
|
|
|
* 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.
|
net: dsa: Allow drivers to filter packets they can decode source port from
Frames get processed by DSA and redirected to switch port net devices
based on the ETH_P_XDSA multiplexed packet_type handler found by the
network stack when calling eth_type_trans().
The running assumption is that once the DSA .rcv function is called, DSA
is always able to decode the switch tag in order to change the skb->dev
from its master.
However there are tagging protocols (such as the new DSA_TAG_PROTO_SJA1105,
user of DSA_TAG_PROTO_8021Q) where this assumption is not completely
true, since switch tagging piggybacks on the absence of a vlan_filtering
bridge. Moreover, management traffic (BPDU, PTP) for this switch doesn't
rely on switch tagging, but on a different mechanism. So it would make
sense to at least be able to terminate that.
Having DSA receive traffic it can't decode would put it in an impossible
situation: the eth_type_trans() function would invoke the DSA .rcv(),
which could not change skb->dev, then eth_type_trans() would be invoked
again, which again would call the DSA .rcv, and the packet would never
be able to exit the DSA filter and would spiral in a loop until the
whole system dies.
This happens because eth_type_trans() doesn't actually look at the skb
(so as to identify a potential tag) when it deems it as being
ETH_P_XDSA. It just checks whether skb->dev has a DSA private pointer
installed (therefore it's a DSA master) and that there exists a .rcv
callback (everybody except DSA_TAG_PROTO_NONE has that). This is
understandable as there are many switch tags out there, and exhaustively
checking for all of them is far from ideal.
The solution lies in introducing a filtering function for each tagging
protocol. In the absence of a filtering function, all traffic is passed
to the .rcv DSA callback. The tagging protocol should see the filtering
function as a pre-validation that it can decode the incoming skb. The
traffic that doesn't match the filter will bypass the DSA .rcv callback
and be left on the master netdevice, which wasn't previously possible.
Signed-off-by: Vladimir Oltean <olteanv@gmail.com>
Reviewed-by: Florian Fainelli <f.fainelli@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2019-05-05 10:19:23 +00:00
|
|
|
* The DSA tagging protocol may be able to decode some but not all
|
|
|
|
* traffic (for example only for management). In that case give it the
|
|
|
|
* option to filter the packets from which it can decode source port
|
|
|
|
* information.
|
2008-10-07 13:45:02 +00:00
|
|
|
*/
|
net: dsa: Allow drivers to filter packets they can decode source port from
Frames get processed by DSA and redirected to switch port net devices
based on the ETH_P_XDSA multiplexed packet_type handler found by the
network stack when calling eth_type_trans().
The running assumption is that once the DSA .rcv function is called, DSA
is always able to decode the switch tag in order to change the skb->dev
from its master.
However there are tagging protocols (such as the new DSA_TAG_PROTO_SJA1105,
user of DSA_TAG_PROTO_8021Q) where this assumption is not completely
true, since switch tagging piggybacks on the absence of a vlan_filtering
bridge. Moreover, management traffic (BPDU, PTP) for this switch doesn't
rely on switch tagging, but on a different mechanism. So it would make
sense to at least be able to terminate that.
Having DSA receive traffic it can't decode would put it in an impossible
situation: the eth_type_trans() function would invoke the DSA .rcv(),
which could not change skb->dev, then eth_type_trans() would be invoked
again, which again would call the DSA .rcv, and the packet would never
be able to exit the DSA filter and would spiral in a loop until the
whole system dies.
This happens because eth_type_trans() doesn't actually look at the skb
(so as to identify a potential tag) when it deems it as being
ETH_P_XDSA. It just checks whether skb->dev has a DSA private pointer
installed (therefore it's a DSA master) and that there exists a .rcv
callback (everybody except DSA_TAG_PROTO_NONE has that). This is
understandable as there are many switch tags out there, and exhaustively
checking for all of them is far from ideal.
The solution lies in introducing a filtering function for each tagging
protocol. In the absence of a filtering function, all traffic is passed
to the .rcv DSA callback. The tagging protocol should see the filtering
function as a pre-validation that it can decode the incoming skb. The
traffic that doesn't match the filter will bypass the DSA .rcv callback
and be left on the master netdevice, which wasn't previously possible.
Signed-off-by: Vladimir Oltean <olteanv@gmail.com>
Reviewed-by: Florian Fainelli <f.fainelli@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2019-05-05 10:19:23 +00:00
|
|
|
if (unlikely(netdev_uses_dsa(dev)) && dsa_can_decode(skb, dev))
|
2014-08-28 00:04:46 +00:00
|
|
|
return htons(ETH_P_XDSA);
|
2008-10-07 13:45:02 +00:00
|
|
|
|
2015-05-04 21:33:48 +00:00
|
|
|
if (likely(eth_proto_is_802_3(eth->h_proto)))
|
2005-04-16 22:20:36 +00:00
|
|
|
return eth->h_proto;
|
2006-08-18 01:20:18 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2006-08-18 01:20:18 +00:00
|
|
|
* 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.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2014-01-16 23:03:31 +00:00
|
|
|
sap = skb_header_pointer(skb, 0, sizeof(*sap), &_service_access_point);
|
|
|
|
if (sap && *sap == 0xFFFF)
|
2005-04-16 22:20:36 +00:00
|
|
|
return htons(ETH_P_802_3);
|
2006-08-18 01:20:18 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2006-08-18 01:20:18 +00:00
|
|
|
* Real 802.2 LLC
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
return htons(ETH_P_802_2);
|
|
|
|
}
|
2006-08-18 01:20:18 +00:00
|
|
|
EXPORT_SYMBOL(eth_type_trans);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-08-18 01:18:53 +00:00
|
|
|
/**
|
|
|
|
* eth_header_parse - extract hardware address from packet
|
|
|
|
* @skb: packet to extract header from
|
|
|
|
* @haddr: destination buffer
|
|
|
|
*/
|
2007-10-09 08:40:57 +00:00
|
|
|
int eth_header_parse(const struct sk_buff *skb, unsigned char *haddr)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2007-09-27 05:13:38 +00:00
|
|
|
const struct ethhdr *eth = eth_hdr(skb);
|
2005-04-16 22:20:36 +00:00
|
|
|
memcpy(haddr, eth->h_source, ETH_ALEN);
|
|
|
|
return ETH_ALEN;
|
|
|
|
}
|
2007-10-09 08:40:57 +00:00
|
|
|
EXPORT_SYMBOL(eth_header_parse);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-08-18 01:18:53 +00:00
|
|
|
/**
|
|
|
|
* eth_header_cache - fill cache entry from neighbour
|
|
|
|
* @neigh: source neighbour
|
|
|
|
* @hh: destination cache entry
|
2011-07-25 23:17:01 +00:00
|
|
|
* @type: Ethernet type field
|
2012-07-10 10:55:09 +00:00
|
|
|
*
|
2006-08-18 01:18:53 +00:00
|
|
|
* Create an Ethernet header template from the neighbour.
|
|
|
|
*/
|
2011-07-13 06:28:12 +00:00
|
|
|
int eth_header_cache(const struct neighbour *neigh, struct hh_cache *hh, __be16 type)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct ethhdr *eth;
|
2007-10-09 08:40:57 +00:00
|
|
|
const struct net_device *dev = neigh->dev;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-08-18 01:20:18 +00:00
|
|
|
eth = (struct ethhdr *)
|
|
|
|
(((u8 *) hh->hh_data) + (HH_DATA_OFF(sizeof(*eth))));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-03-07 05:19:03 +00:00
|
|
|
if (type == htons(ETH_P_802_3))
|
2005-04-16 22:20:36 +00:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
eth->h_proto = type;
|
2007-08-25 05:35:44 +00:00
|
|
|
memcpy(eth->h_source, dev->dev_addr, ETH_ALEN);
|
|
|
|
memcpy(eth->h_dest, neigh->ha, ETH_ALEN);
|
2019-11-08 02:29:11 +00:00
|
|
|
|
|
|
|
/* Pairs with READ_ONCE() in neigh_resolve_output(),
|
|
|
|
* neigh_hh_output() and neigh_update_hhs().
|
|
|
|
*/
|
|
|
|
smp_store_release(&hh->hh_len, ETH_HLEN);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2007-10-09 08:40:57 +00:00
|
|
|
EXPORT_SYMBOL(eth_header_cache);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-08-18 01:18:53 +00:00
|
|
|
/**
|
|
|
|
* eth_header_cache_update - update cache entry
|
|
|
|
* @hh: destination cache entry
|
|
|
|
* @dev: network device
|
|
|
|
* @haddr: new hardware address
|
|
|
|
*
|
2005-04-16 22:20:36 +00:00
|
|
|
* Called by Address Resolution module to notify changes in address.
|
|
|
|
*/
|
2007-10-09 08:40:57 +00:00
|
|
|
void eth_header_cache_update(struct hh_cache *hh,
|
|
|
|
const struct net_device *dev,
|
|
|
|
const unsigned char *haddr)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-08-18 01:20:18 +00:00
|
|
|
memcpy(((u8 *) hh->hh_data) + HH_DATA_OFF(sizeof(struct ethhdr)),
|
2007-08-25 05:35:44 +00:00
|
|
|
haddr, ETH_ALEN);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2007-10-09 08:40:57 +00:00
|
|
|
EXPORT_SYMBOL(eth_header_cache_update);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2019-02-21 12:39:59 +00:00
|
|
|
/**
|
|
|
|
* eth_header_parser_protocol - extract protocol from L2 header
|
|
|
|
* @skb: packet to extract protocol from
|
|
|
|
*/
|
|
|
|
__be16 eth_header_parse_protocol(const struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
const struct ethhdr *eth = eth_hdr(skb);
|
|
|
|
|
|
|
|
return eth->h_proto;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(eth_header_parse_protocol);
|
|
|
|
|
2013-01-21 01:17:22 +00:00
|
|
|
/**
|
|
|
|
* 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);
|
|
|
|
|
2006-08-18 01:18:53 +00:00
|
|
|
/**
|
|
|
|
* eth_mac_addr - set new Ethernet hardware address
|
|
|
|
* @dev: network device
|
|
|
|
* @p: socket address
|
2012-07-10 10:55:09 +00:00
|
|
|
*
|
2006-08-18 01:18:53 +00:00
|
|
|
* Change hardware address of device.
|
|
|
|
*
|
|
|
|
* This doesn't change hardware matching, so needs to be overridden
|
|
|
|
* for most real devices.
|
|
|
|
*/
|
2008-11-20 06:42:31 +00:00
|
|
|
int eth_mac_addr(struct net_device *dev, void *p)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2013-01-21 01:17:22 +00:00
|
|
|
int ret;
|
2007-07-12 02:41:18 +00:00
|
|
|
|
2013-01-21 01:17:22 +00:00
|
|
|
ret = eth_prepare_mac_addr_change(dev, p);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
eth_commit_mac_addr_change(dev, p);
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2008-11-20 06:42:31 +00:00
|
|
|
EXPORT_SYMBOL(eth_mac_addr);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-11-20 06:42:31 +00:00
|
|
|
int eth_validate_addr(struct net_device *dev)
|
2007-10-24 03:19:37 +00:00
|
|
|
{
|
|
|
|
if (!is_valid_ether_addr(dev->dev_addr))
|
2008-04-14 05:45:40 +00:00
|
|
|
return -EADDRNOTAVAIL;
|
2007-10-24 03:19:37 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2008-11-20 06:42:31 +00:00
|
|
|
EXPORT_SYMBOL(eth_validate_addr);
|
2007-10-24 03:19:37 +00:00
|
|
|
|
2007-10-09 08:40:57 +00:00
|
|
|
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,
|
2019-02-21 12:39:59 +00:00
|
|
|
.parse_protocol = eth_header_parse_protocol,
|
2007-10-09 08:40:57 +00:00
|
|
|
};
|
|
|
|
|
2006-08-18 01:18:53 +00:00
|
|
|
/**
|
|
|
|
* ether_setup - setup Ethernet network device
|
|
|
|
* @dev: network device
|
2012-07-10 10:55:09 +00:00
|
|
|
*
|
2006-08-18 01:18:53 +00:00
|
|
|
* Fill in the fields of the device structure with Ethernet-generic values.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
void ether_setup(struct net_device *dev)
|
|
|
|
{
|
2007-10-09 08:40:57 +00:00
|
|
|
dev->header_ops = ð_header_ops;
|
2005-04-16 22:20:36 +00:00
|
|
|
dev->type = ARPHRD_ETHER;
|
|
|
|
dev->hard_header_len = ETH_HLEN;
|
2017-02-07 20:57:20 +00:00
|
|
|
dev->min_header_len = ETH_HLEN;
|
2006-01-06 00:35:42 +00:00
|
|
|
dev->mtu = ETH_DATA_LEN;
|
net: deprecate eth_change_mtu, remove usage
With centralized MTU checking, there's nothing productive done by
eth_change_mtu that isn't already done in dev_set_mtu, so mark it as
deprecated and remove all usage of it in the kernel. All callers have been
audited for calls to alloc_etherdev* or ether_setup directly, which means
they all have a valid dev->min_mtu and dev->max_mtu. Now eth_change_mtu
prints out a netdev_warn about being deprecated, for the benefit of
out-of-tree drivers that might be utilizing it.
Of note, dvb_net.c actually had dev->mtu = 4096, while using
eth_change_mtu, meaning that if you ever tried changing it's mtu, you
couldn't set it above 1500 anymore. It's now getting dev->max_mtu also set
to 4096 to remedy that.
v2: fix up lantiq_etop, missed breakage due to drive not compiling on x86
CC: netdev@vger.kernel.org
Signed-off-by: Jarod Wilson <jarod@redhat.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-10-08 02:04:34 +00:00
|
|
|
dev->min_mtu = ETH_MIN_MTU;
|
|
|
|
dev->max_mtu = ETH_DATA_LEN;
|
2005-04-16 22:20:36 +00:00
|
|
|
dev->addr_len = ETH_ALEN;
|
2016-11-03 13:56:01 +00:00
|
|
|
dev->tx_queue_len = DEFAULT_TX_QUEUE_LEN;
|
2005-04-16 22:20:36 +00:00
|
|
|
dev->flags = IFF_BROADCAST|IFF_MULTICAST;
|
2011-09-14 03:05:02 +00:00
|
|
|
dev->priv_flags |= IFF_TX_SKB_SHARING;
|
2007-02-09 14:24:44 +00:00
|
|
|
|
2015-03-03 03:54:56 +00:00
|
|
|
eth_broadcast_addr(dev->broadcast);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ether_setup);
|
|
|
|
|
|
|
|
/**
|
2011-01-09 19:36:31 +00:00
|
|
|
* alloc_etherdev_mqs - Allocates and sets up an Ethernet device
|
2005-04-16 22:20:36 +00:00
|
|
|
* @sizeof_priv: Size of additional driver-private structure to be allocated
|
2006-08-18 01:18:53 +00:00
|
|
|
* for this Ethernet device
|
2011-01-09 19:36:31 +00:00
|
|
|
* @txqs: The number of TX queues this device has.
|
2011-01-12 14:50:51 +00:00
|
|
|
* @rxqs: The number of RX queues this device has.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2006-08-18 01:18:53 +00:00
|
|
|
* Fill in the fields of the device structure with Ethernet-generic
|
2005-04-16 22:20:36 +00:00
|
|
|
* values. Basically does everything except registering the device.
|
|
|
|
*
|
|
|
|
* Constructs a new net device, complete with a private data area of
|
2006-08-18 01:18:53 +00:00
|
|
|
* size (sizeof_priv). A 32-byte (not bit) alignment is enforced for
|
2005-04-16 22:20:36 +00:00
|
|
|
* this private data area.
|
|
|
|
*/
|
|
|
|
|
2011-01-09 19:36:31 +00:00
|
|
|
struct net_device *alloc_etherdev_mqs(int sizeof_priv, unsigned int txqs,
|
|
|
|
unsigned int rxqs)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
net: set name_assign_type in alloc_netdev()
Extend alloc_netdev{,_mq{,s}}() to take name_assign_type as argument, and convert
all users to pass NET_NAME_UNKNOWN.
Coccinelle patch:
@@
expression sizeof_priv, name, setup, txqs, rxqs, count;
@@
(
-alloc_netdev_mqs(sizeof_priv, name, setup, txqs, rxqs)
+alloc_netdev_mqs(sizeof_priv, name, NET_NAME_UNKNOWN, setup, txqs, rxqs)
|
-alloc_netdev_mq(sizeof_priv, name, setup, count)
+alloc_netdev_mq(sizeof_priv, name, NET_NAME_UNKNOWN, setup, count)
|
-alloc_netdev(sizeof_priv, name, setup)
+alloc_netdev(sizeof_priv, name, NET_NAME_UNKNOWN, setup)
)
v9: move comments here from the wrong commit
Signed-off-by: Tom Gundersen <teg@jklm.no>
Reviewed-by: David Herrmann <dh.herrmann@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-07-14 14:37:24 +00:00
|
|
|
return alloc_netdev_mqs(sizeof_priv, "eth%d", NET_NAME_UNKNOWN,
|
|
|
|
ether_setup, txqs, rxqs);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2011-01-09 19:36:31 +00:00
|
|
|
EXPORT_SYMBOL(alloc_etherdev_mqs);
|
2007-10-04 00:59:30 +00:00
|
|
|
|
2007-12-25 05:28:09 +00:00
|
|
|
ssize_t sysfs_format_mac(char *buf, const unsigned char *addr, int len)
|
|
|
|
{
|
2013-07-17 00:09:15 +00:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%*phC\n", len, addr);
|
2007-12-25 05:28:09 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(sysfs_format_mac);
|
2014-12-31 03:10:15 +00:00
|
|
|
|
2018-06-24 05:13:49 +00:00
|
|
|
struct sk_buff *eth_gro_receive(struct list_head *head, struct sk_buff *skb)
|
2014-12-31 03:10:15 +00:00
|
|
|
{
|
|
|
|
const struct packet_offload *ptype;
|
2018-06-24 05:13:49 +00:00
|
|
|
unsigned int hlen, off_eth;
|
|
|
|
struct sk_buff *pp = NULL;
|
|
|
|
struct ethhdr *eh, *eh2;
|
|
|
|
struct sk_buff *p;
|
2014-12-31 03:10:15 +00:00
|
|
|
__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;
|
|
|
|
|
2018-06-24 05:13:49 +00:00
|
|
|
list_for_each_entry(p, head, list) {
|
2014-12-31 03:10:15 +00:00
|
|
|
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));
|
2016-10-20 13:58:02 +00:00
|
|
|
pp = call_gro_receive(ptype->callbacks.gro_receive, head, skb);
|
2014-12-31 03:10:15 +00:00
|
|
|
|
|
|
|
out_unlock:
|
|
|
|
rcu_read_unlock();
|
|
|
|
out:
|
2017-02-15 08:39:39 +00:00
|
|
|
skb_gro_flush_final(skb, pp, flush);
|
2014-12-31 03:10:15 +00:00
|
|
|
|
|
|
|
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),
|
2015-06-01 21:56:09 +00:00
|
|
|
.priority = 10,
|
2014-12-31 03:10:15 +00:00
|
|
|
.callbacks = {
|
|
|
|
.gro_receive = eth_gro_receive,
|
|
|
|
.gro_complete = eth_gro_complete,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static int __init eth_offload_init(void)
|
|
|
|
{
|
|
|
|
dev_add_offload(ð_packet_offload);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
fs_initcall(eth_offload_init);
|
2015-11-05 16:34:57 +00:00
|
|
|
|
|
|
|
unsigned char * __weak arch_get_platform_mac_address(void)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
int eth_platform_get_mac_address(struct device *dev, u8 *mac_addr)
|
|
|
|
{
|
2019-05-31 17:14:44 +00:00
|
|
|
const unsigned char *addr = NULL;
|
2015-11-05 16:34:57 +00:00
|
|
|
|
2019-05-31 17:14:44 +00:00
|
|
|
if (dev->of_node)
|
|
|
|
addr = of_get_mac_address(dev->of_node);
|
2019-05-06 21:27:04 +00:00
|
|
|
if (IS_ERR_OR_NULL(addr))
|
2015-11-05 16:34:57 +00:00
|
|
|
addr = arch_get_platform_mac_address();
|
|
|
|
|
|
|
|
if (!addr)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
ether_addr_copy(mac_addr, addr);
|
2019-05-31 17:14:44 +00:00
|
|
|
|
2015-11-05 16:34:57 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(eth_platform_get_mac_address);
|
2018-11-30 08:20:57 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Obtain the MAC address from an nvmem cell named 'mac-address' associated
|
|
|
|
* with given device.
|
|
|
|
*
|
|
|
|
* @dev: Device with which the mac-address cell is associated.
|
|
|
|
* @addrbuf: Buffer to which the MAC address will be copied on success.
|
|
|
|
*
|
|
|
|
* Returns 0 on success or a negative error number on failure.
|
|
|
|
*/
|
|
|
|
int nvmem_get_mac_address(struct device *dev, void *addrbuf)
|
|
|
|
{
|
|
|
|
struct nvmem_cell *cell;
|
|
|
|
const void *mac;
|
|
|
|
size_t len;
|
|
|
|
|
|
|
|
cell = nvmem_cell_get(dev, "mac-address");
|
|
|
|
if (IS_ERR(cell))
|
|
|
|
return PTR_ERR(cell);
|
|
|
|
|
|
|
|
mac = nvmem_cell_read(cell, &len);
|
|
|
|
nvmem_cell_put(cell);
|
|
|
|
|
|
|
|
if (IS_ERR(mac))
|
|
|
|
return PTR_ERR(mac);
|
|
|
|
|
|
|
|
if (len != ETH_ALEN || !is_valid_ether_addr(mac)) {
|
|
|
|
kfree(mac);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
ether_addr_copy(addrbuf, mac);
|
|
|
|
kfree(mac);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(nvmem_get_mac_address);
|