提交 6ae23ad3 编写于 作者: T Tom Herbert 提交者: David S. Miller

net: Add driver helper functions to determine checksum offloadability

Add skb_csum_offload_chk driver helper function to determine if a
device with limited checksum offload capabilities is able to offload the
checksum for a given packet.

This patch includes:
  - The skb_csum_offload_chk function. Returns true if checksum is
    offloadable, else false. Optionally, in the case that the checksum
    is not offloable, the function can call skb_checksum_help to resolve
    the checksum. skb_csum_offload_chk also returns whether the checksum
    refers to an encapsulated checksum.
  - Definition of skb_csum_offl_spec structure that caller uses to
    indicate rules about what it can offload (e.g. IPv4/v6, TCP/UDP only,
    whether encapsulated checksums can be offloaded, whether checksum with
    IPv6 extension headers can be offloaded).
  - Ancilary functions called skb_csum_offload_chk_help,
    skb_csum_off_chk_help_cmn, skb_csum_off_chk_help_cmn_v4_only.
Signed-off-by: NTom Herbert <tom@herbertland.com>
Signed-off-by: NDavid S. Miller <davem@davemloft.net>
上级 9a49850d
......@@ -2522,6 +2522,71 @@ static inline void skb_gro_remcsum_cleanup(struct sk_buff *skb,
remcsum_unadjust((__sum16 *)ptr, grc->delta);
}
struct skb_csum_offl_spec {
__u16 ipv4_okay:1,
ipv6_okay:1,
encap_okay:1,
ip_options_okay:1,
ext_hdrs_okay:1,
tcp_okay:1,
udp_okay:1,
sctp_okay:1,
vlan_okay:1,
no_encapped_ipv6:1,
no_not_encapped:1;
};
bool __skb_csum_offload_chk(struct sk_buff *skb,
const struct skb_csum_offl_spec *spec,
bool *csum_encapped,
bool csum_help);
static inline bool skb_csum_offload_chk(struct sk_buff *skb,
const struct skb_csum_offl_spec *spec,
bool *csum_encapped,
bool csum_help)
{
if (skb->ip_summed != CHECKSUM_PARTIAL)
return false;
return __skb_csum_offload_chk(skb, spec, csum_encapped, csum_help);
}
static inline bool skb_csum_offload_chk_help(struct sk_buff *skb,
const struct skb_csum_offl_spec *spec)
{
bool csum_encapped;
return skb_csum_offload_chk(skb, spec, &csum_encapped, true);
}
static inline bool skb_csum_off_chk_help_cmn(struct sk_buff *skb)
{
static const struct skb_csum_offl_spec csum_offl_spec = {
.ipv4_okay = 1,
.ip_options_okay = 1,
.ipv6_okay = 1,
.vlan_okay = 1,
.tcp_okay = 1,
.udp_okay = 1,
};
return skb_csum_offload_chk_help(skb, &csum_offl_spec);
}
static inline bool skb_csum_off_chk_help_cmn_v4_only(struct sk_buff *skb)
{
static const struct skb_csum_offl_spec csum_offl_spec = {
.ipv4_okay = 1,
.ip_options_okay = 1,
.tcp_okay = 1,
.udp_okay = 1,
.vlan_okay = 1,
};
return skb_csum_offload_chk_help(skb, &csum_offl_spec);
}
static inline int dev_hard_header(struct sk_buff *skb, struct net_device *dev,
unsigned short type,
const void *daddr, const void *saddr,
......@@ -3711,6 +3776,19 @@ static inline bool can_checksum_protocol(netdev_features_t features,
}
}
/* Map an ethertype into IP protocol if possible */
static inline int eproto_to_ipproto(int eproto)
{
switch (eproto) {
case htons(ETH_P_IP):
return IPPROTO_IP;
case htons(ETH_P_IPV6):
return IPPROTO_IPV6;
default:
return -1;
}
}
#ifdef CONFIG_BUG
void netdev_rx_csum_fault(struct net_device *dev);
#else
......
......@@ -138,6 +138,7 @@
#include <linux/errqueue.h>
#include <linux/hrtimer.h>
#include <linux/netfilter_ingress.h>
#include <linux/sctp.h>
#include "net-sysfs.h"
......@@ -2471,6 +2472,141 @@ int skb_checksum_help(struct sk_buff *skb)
}
EXPORT_SYMBOL(skb_checksum_help);
/* skb_csum_offload_check - Driver helper function to determine if a device
* with limited checksum offload capabilities is able to offload the checksum
* for a given packet.
*
* Arguments:
* skb - sk_buff for the packet in question
* spec - contains the description of what device can offload
* csum_encapped - returns true if the checksum being offloaded is
* encpasulated. That is it is checksum for the transport header
* in the inner headers.
* checksum_help - when set indicates that helper function should
* call skb_checksum_help if offload checks fail
*
* Returns:
* true: Packet has passed the checksum checks and should be offloadable to
* the device (a driver may still need to check for additional
* restrictions of its device)
* false: Checksum is not offloadable. If checksum_help was set then
* skb_checksum_help was called to resolve checksum for non-GSO
* packets and when IP protocol is not SCTP
*/
bool __skb_csum_offload_chk(struct sk_buff *skb,
const struct skb_csum_offl_spec *spec,
bool *csum_encapped,
bool csum_help)
{
struct iphdr *iph;
struct ipv6hdr *ipv6;
void *nhdr;
int protocol;
u8 ip_proto;
if (skb->protocol == htons(ETH_P_8021Q) ||
skb->protocol == htons(ETH_P_8021AD)) {
if (!spec->vlan_okay)
goto need_help;
}
/* We check whether the checksum refers to a transport layer checksum in
* the outermost header or an encapsulated transport layer checksum that
* corresponds to the inner headers of the skb. If the checksum is for
* something else in the packet we need help.
*/
if (skb_checksum_start_offset(skb) == skb_transport_offset(skb)) {
/* Non-encapsulated checksum */
protocol = eproto_to_ipproto(vlan_get_protocol(skb));
nhdr = skb_network_header(skb);
*csum_encapped = false;
if (spec->no_not_encapped)
goto need_help;
} else if (skb->encapsulation && spec->encap_okay &&
skb_checksum_start_offset(skb) ==
skb_inner_transport_offset(skb)) {
/* Encapsulated checksum */
*csum_encapped = true;
switch (skb->inner_protocol_type) {
case ENCAP_TYPE_ETHER:
protocol = eproto_to_ipproto(skb->inner_protocol);
break;
case ENCAP_TYPE_IPPROTO:
protocol = skb->inner_protocol;
break;
}
nhdr = skb_inner_network_header(skb);
} else {
goto need_help;
}
switch (protocol) {
case IPPROTO_IP:
if (!spec->ipv4_okay)
goto need_help;
iph = nhdr;
ip_proto = iph->protocol;
if (iph->ihl != 5 && !spec->ip_options_okay)
goto need_help;
break;
case IPPROTO_IPV6:
if (!spec->ipv6_okay)
goto need_help;
if (spec->no_encapped_ipv6 && *csum_encapped)
goto need_help;
ipv6 = nhdr;
nhdr += sizeof(*ipv6);
ip_proto = ipv6->nexthdr;
break;
default:
goto need_help;
}
ip_proto_again:
switch (ip_proto) {
case IPPROTO_TCP:
if (!spec->tcp_okay ||
skb->csum_offset != offsetof(struct tcphdr, check))
goto need_help;
break;
case IPPROTO_UDP:
if (!spec->udp_okay ||
skb->csum_offset != offsetof(struct udphdr, check))
goto need_help;
break;
case IPPROTO_SCTP:
if (!spec->sctp_okay ||
skb->csum_offset != offsetof(struct sctphdr, checksum))
goto cant_help;
break;
case NEXTHDR_HOP:
case NEXTHDR_ROUTING:
case NEXTHDR_DEST: {
u8 *opthdr = nhdr;
if (protocol != IPPROTO_IPV6 || !spec->ext_hdrs_okay)
goto need_help;
ip_proto = opthdr[0];
nhdr += (opthdr[1] + 1) << 3;
goto ip_proto_again;
}
default:
goto need_help;
}
/* Passed the tests for offloading checksum */
return true;
need_help:
if (csum_help && !skb_shinfo(skb)->gso_size)
skb_checksum_help(skb);
cant_help:
return false;
}
EXPORT_SYMBOL(__skb_csum_offload_chk);
__be16 skb_network_protocol(struct sk_buff *skb, int *depth)
{
__be16 type = skb->protocol;
......
Markdown is supported
0% .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑!
想要评论请 注册