Skip to content

Commit

Permalink
Merge branch 'skb_checksum_help'
Browse files Browse the repository at this point in the history 
Paul Durrant says:

====================
make skb_checksum_setup generally available

Both xen-netfront and xen-netback need to be able to set up the partial
checksum offset of an skb and may also need to recalculate the pseudo-
header checksum in the process. This functionality is currently private
and duplicated between the two drivers.

Patch #1 of this series moves the implementation into the core network code
as there is nothing xen-specific about it and it is potentially useful to
any network driver.
Patch #2 removes the private implementation from netback.
Patch #3 removes the private implementation from netfront.

v2:
- Put skb_checksum_setup in skbuff.c rather than dev.c
- remove inline
====================

Signed-off-by: David S. Miller <[email protected]>
  • Loading branch information
@davem330
davem330 committed Jan 14, 2014
2 parents b86f81c + b5cf66c commit a49da88
Show file tree
Hide file tree
Showing 4 changed files with 281 additions and 302 deletions.
260 changes: 3 additions & 257 deletions drivers/net/xen-netback/netback.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -39,7 +39,6 @@
#include <linux/udp.h>

#include <net/tcp.h>
#include <net/ip6_checksum.h>

#include <xen/xen.h>
#include <xen/events.h>
Expand Down Expand Up @@ -1051,257 +1050,9 @@ static int xenvif_set_skb_gso(struct xenvif *vif,
return 0;
}

static inline int maybe_pull_tail(struct sk_buff *skb, unsigned int len,
unsigned int max)
{
if (skb_headlen(skb) >= len)
return 0;

/* If we need to pullup then pullup to the max, so we
* won't need to do it again.
*/
if (max > skb->len)
max = skb->len;

if (__pskb_pull_tail(skb, max - skb_headlen(skb)) == NULL)
return -ENOMEM;

if (skb_headlen(skb) < len)
return -EPROTO;

return 0;
}

/* This value should be large enough to cover a tagged ethernet header plus
* maximally sized IP and TCP or UDP headers.
*/
#define MAX_IP_HDR_LEN 128

static int checksum_setup_ip(struct xenvif *vif, struct sk_buff *skb,
int recalculate_partial_csum)
{
unsigned int off;
bool fragment;
int err;

fragment = false;

err = maybe_pull_tail(skb,
sizeof(struct iphdr),
MAX_IP_HDR_LEN);
if (err < 0)
goto out;

if (ip_hdr(skb)->frag_off & htons(IP_OFFSET | IP_MF))
fragment = true;

off = ip_hdrlen(skb);

err = -EPROTO;

if (fragment)
goto out;

switch (ip_hdr(skb)->protocol) {
case IPPROTO_TCP:
err = maybe_pull_tail(skb,
off + sizeof(struct tcphdr),
MAX_IP_HDR_LEN);
if (err < 0)
goto out;

if (!skb_partial_csum_set(skb, off,
offsetof(struct tcphdr, check))) {
err = -EPROTO;
goto out;
}

if (recalculate_partial_csum)
tcp_hdr(skb)->check =
~csum_tcpudp_magic(ip_hdr(skb)->saddr,
ip_hdr(skb)->daddr,
skb->len - off,
IPPROTO_TCP, 0);
break;
case IPPROTO_UDP:
err = maybe_pull_tail(skb,
off + sizeof(struct udphdr),
MAX_IP_HDR_LEN);
if (err < 0)
goto out;

if (!skb_partial_csum_set(skb, off,
offsetof(struct udphdr, check))) {
err = -EPROTO;
goto out;
}

if (recalculate_partial_csum)
udp_hdr(skb)->check =
~csum_tcpudp_magic(ip_hdr(skb)->saddr,
ip_hdr(skb)->daddr,
skb->len - off,
IPPROTO_UDP, 0);
break;
default:
goto out;
}

err = 0;

out:
return err;
}

/* This value should be large enough to cover a tagged ethernet header plus
* an IPv6 header, all options, and a maximal TCP or UDP header.
*/
#define MAX_IPV6_HDR_LEN 256

#define OPT_HDR(type, skb, off) \
(type *)(skb_network_header(skb) + (off))

static int checksum_setup_ipv6(struct xenvif *vif, struct sk_buff *skb,
int recalculate_partial_csum)
{
int err;
u8 nexthdr;
unsigned int off;
unsigned int len;
bool fragment;
bool done;

fragment = false;
done = false;

off = sizeof(struct ipv6hdr);

err = maybe_pull_tail(skb, off, MAX_IPV6_HDR_LEN);
if (err < 0)
goto out;

nexthdr = ipv6_hdr(skb)->nexthdr;

len = sizeof(struct ipv6hdr) + ntohs(ipv6_hdr(skb)->payload_len);
while (off <= len && !done) {
switch (nexthdr) {
case IPPROTO_DSTOPTS:
case IPPROTO_HOPOPTS:
case IPPROTO_ROUTING: {
struct ipv6_opt_hdr *hp;

err = maybe_pull_tail(skb,
off +
sizeof(struct ipv6_opt_hdr),
MAX_IPV6_HDR_LEN);
if (err < 0)
goto out;

hp = OPT_HDR(struct ipv6_opt_hdr, skb, off);
nexthdr = hp->nexthdr;
off += ipv6_optlen(hp);
break;
}
case IPPROTO_AH: {
struct ip_auth_hdr *hp;

err = maybe_pull_tail(skb,
off +
sizeof(struct ip_auth_hdr),
MAX_IPV6_HDR_LEN);
if (err < 0)
goto out;

hp = OPT_HDR(struct ip_auth_hdr, skb, off);
nexthdr = hp->nexthdr;
off += ipv6_authlen(hp);
break;
}
case IPPROTO_FRAGMENT: {
struct frag_hdr *hp;

err = maybe_pull_tail(skb,
off +
sizeof(struct frag_hdr),
MAX_IPV6_HDR_LEN);
if (err < 0)
goto out;

hp = OPT_HDR(struct frag_hdr, skb, off);

if (hp->frag_off & htons(IP6_OFFSET | IP6_MF))
fragment = true;

nexthdr = hp->nexthdr;
off += sizeof(struct frag_hdr);
break;
}
default:
done = true;
break;
}
}

err = -EPROTO;

if (!done || fragment)
goto out;

switch (nexthdr) {
case IPPROTO_TCP:
err = maybe_pull_tail(skb,
off + sizeof(struct tcphdr),
MAX_IPV6_HDR_LEN);
if (err < 0)
goto out;

if (!skb_partial_csum_set(skb, off,
offsetof(struct tcphdr, check))) {
err = -EPROTO;
goto out;
}

if (recalculate_partial_csum)
tcp_hdr(skb)->check =
~csum_ipv6_magic(&ipv6_hdr(skb)->saddr,
&ipv6_hdr(skb)->daddr,
skb->len - off,
IPPROTO_TCP, 0);
break;
case IPPROTO_UDP:
err = maybe_pull_tail(skb,
off + sizeof(struct udphdr),
MAX_IPV6_HDR_LEN);
if (err < 0)
goto out;

if (!skb_partial_csum_set(skb, off,
offsetof(struct udphdr, check))) {
err = -EPROTO;
goto out;
}

if (recalculate_partial_csum)
udp_hdr(skb)->check =
~csum_ipv6_magic(&ipv6_hdr(skb)->saddr,
&ipv6_hdr(skb)->daddr,
skb->len - off,
IPPROTO_UDP, 0);
break;
default:
goto out;
}

err = 0;

out:
return err;
}

static int checksum_setup(struct xenvif *vif, struct sk_buff *skb)
{
int err = -EPROTO;
int recalculate_partial_csum = 0;
bool recalculate_partial_csum = false;

/* A GSO SKB must be CHECKSUM_PARTIAL. However some buggy
* peers can fail to set NETRXF_csum_blank when sending a GSO
Expand All @@ -1311,19 +1062,14 @@ static int checksum_setup(struct xenvif *vif, struct sk_buff *skb)
if (skb->ip_summed != CHECKSUM_PARTIAL && skb_is_gso(skb)) {
vif->rx_gso_checksum_fixup++;
skb->ip_summed = CHECKSUM_PARTIAL;
recalculate_partial_csum = 1;
recalculate_partial_csum = true;
}

/* A non-CHECKSUM_PARTIAL SKB does not require setup. */
if (skb->ip_summed != CHECKSUM_PARTIAL)
return 0;

if (skb->protocol == htons(ETH_P_IP))
err = checksum_setup_ip(vif, skb, recalculate_partial_csum);
else if (skb->protocol == htons(ETH_P_IPV6))
err = checksum_setup_ipv6(vif, skb, recalculate_partial_csum);

return err;
return skb_checksum_setup(skb, recalculate_partial_csum);
}

static bool tx_credit_exceeded(struct xenvif *vif, unsigned size)
Expand Down
48 changes: 3 additions & 45 deletions drivers/net/xen-netfront.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -859,9 +859,7 @@ static RING_IDX xennet_fill_frags(struct netfront_info *np,

static int checksum_setup(struct net_device *dev, struct sk_buff *skb)
{
struct iphdr *iph;
int err = -EPROTO;
int recalculate_partial_csum = 0;
bool recalculate_partial_csum = false;

/*
* A GSO SKB must be CHECKSUM_PARTIAL. However some buggy
Expand All @@ -873,54 +871,14 @@ static int checksum_setup(struct net_device *dev, struct sk_buff *skb)
struct netfront_info *np = netdev_priv(dev);
np->rx_gso_checksum_fixup++;
skb->ip_summed = CHECKSUM_PARTIAL;
recalculate_partial_csum = 1;
recalculate_partial_csum = true;
}

/* A non-CHECKSUM_PARTIAL SKB does not require setup. */
if (skb->ip_summed != CHECKSUM_PARTIAL)
return 0;

if (skb->protocol != htons(ETH_P_IP))
goto out;

iph = (void *)skb->data;

switch (iph->protocol) {
case IPPROTO_TCP:
if (!skb_partial_csum_set(skb, 4 * iph->ihl,
offsetof(struct tcphdr, check)))
goto out;

if (recalculate_partial_csum) {
struct tcphdr *tcph = tcp_hdr(skb);
tcph->check = ~csum_tcpudp_magic(iph->saddr, iph->daddr,
skb->len - iph->ihl*4,
IPPROTO_TCP, 0);
}
break;
case IPPROTO_UDP:
if (!skb_partial_csum_set(skb, 4 * iph->ihl,
offsetof(struct udphdr, check)))
goto out;

if (recalculate_partial_csum) {
struct udphdr *udph = udp_hdr(skb);
udph->check = ~csum_tcpudp_magic(iph->saddr, iph->daddr,
skb->len - iph->ihl*4,
IPPROTO_UDP, 0);
}
break;
default:
if (net_ratelimit())
pr_err("Attempting to checksum a non-TCP/UDP packet, dropping a protocol %d packet\n",
iph->protocol);
goto out;
}

err = 0;

out:
return err;
return skb_checksum_setup(skb, recalculate_partial_csum);
}

static int handle_incoming_queue(struct net_device *dev,
Expand Down
2 changes: 2 additions & 0 deletions include/linux/skbuff.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2893,6 +2893,8 @@ static inline void skb_checksum_none_assert(const struct sk_buff *skb)

bool skb_partial_csum_set(struct sk_buff *skb, u16 start, u16 off);

int skb_checksum_setup(struct sk_buff *skb, bool recalculate);

u32 __skb_get_poff(const struct sk_buff *skb);

/**
Expand Down
Loading

0 comments on commit a49da88

Please sign in to comment.