[linux-2.6-block.git] / net / sched / act_csum.c

/*
 * Checksum updating actions
 *
 * Copyright (c) 2010 Gregoire Baron <baronchon@n7mm.org>
 *
 * 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/types.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/spinlock.h>

#include <linux/netlink.h>
#include <net/netlink.h>
#include <linux/rtnetlink.h>

#include <linux/skbuff.h>

#include <net/ip.h>
#include <net/ipv6.h>
#include <net/icmp.h>
#include <linux/icmpv6.h>
#include <linux/igmp.h>
#include <net/tcp.h>
#include <net/udp.h>
#include <net/ip6_checksum.h>
#include <net/sctp/checksum.h>

#include <net/act_api.h>

#include <linux/tc_act/tc_csum.h>
#include <net/tc_act/tc_csum.h>

static const struct nla_policy csum_policy[TCA_CSUM_MAX + 1] = {
	[TCA_CSUM_PARMS] = { .len = sizeof(struct tc_csum), },
};

static unsigned int csum_net_id;
static struct tc_action_ops act_csum_ops;

static int tcf_csum_init(struct net *net, struct nlattr *nla,
			 struct nlattr *est, struct tc_action **a, int ovr,
			 int bind)
{
	struct tc_action_net *tn = net_generic(net, csum_net_id);
	struct tcf_csum_params *params_old, *params_new;
	struct nlattr *tb[TCA_CSUM_MAX + 1];
	struct tc_csum *parm;
	struct tcf_csum *p;
	int ret = 0, err;

	if (nla == NULL)
		return -EINVAL;

	err = nla_parse_nested(tb, TCA_CSUM_MAX, nla, csum_policy, NULL);
	if (err < 0)
		return err;

	if (tb[TCA_CSUM_PARMS] == NULL)
		return -EINVAL;
	parm = nla_data(tb[TCA_CSUM_PARMS]);

	if (!tcf_idr_check(tn, parm->index, a, bind)) {
		ret = tcf_idr_create(tn, parm->index, est, a,
				     &act_csum_ops, bind, true);
		if (ret)
			return ret;
		ret = ACT_P_CREATED;
	} else {
		if (bind)/* dont override defaults */
			return 0;
		tcf_idr_release(*a, bind);
		if (!ovr)
			return -EEXIST;
	}

	p = to_tcf_csum(*a);
	ASSERT_RTNL();

	params_new = kzalloc(sizeof(*params_new), GFP_KERNEL);
	if (unlikely(!params_new)) {
		if (ret == ACT_P_CREATED)
			tcf_idr_release(*a, bind);
		return -ENOMEM;
	}
	params_old = rtnl_dereference(p->params);

	params_new->action = parm->action;
	params_new->update_flags = parm->update_flags;
	rcu_assign_pointer(p->params, params_new);
	if (params_old)
		kfree_rcu(params_old, rcu);

	if (ret == ACT_P_CREATED)
		tcf_idr_insert(tn, *a);

	return ret;
}

/**
 * tcf_csum_skb_nextlayer - Get next layer pointer
 * @skb: sk_buff to use
 * @ihl: previous summed headers length
 * @ipl: complete packet length
 * @jhl: next header length
 *
 * Check the expected next layer availability in the specified sk_buff.
 * Return the next layer pointer if pass, NULL otherwise.
 */
static void *tcf_csum_skb_nextlayer(struct sk_buff *skb,
				    unsigned int ihl, unsigned int ipl,
				    unsigned int jhl)
{
	int ntkoff = skb_network_offset(skb);
	int hl = ihl + jhl;

	if (!pskb_may_pull(skb, ipl + ntkoff) || (ipl < hl) ||
	    skb_try_make_writable(skb, hl + ntkoff))
		return NULL;
	else
		return (void *)(skb_network_header(skb) + ihl);
}

static int tcf_csum_ipv4_icmp(struct sk_buff *skb, unsigned int ihl,
			      unsigned int ipl)
{
	struct icmphdr *icmph;

	icmph = tcf_csum_skb_nextlayer(skb, ihl, ipl, sizeof(*icmph));
	if (icmph == NULL)
		return 0;

	icmph->checksum = 0;
	skb->csum = csum_partial(icmph, ipl - ihl, 0);
	icmph->checksum = csum_fold(skb->csum);

	skb->ip_summed = CHECKSUM_NONE;

	return 1;
}

static int tcf_csum_ipv4_igmp(struct sk_buff *skb,
			      unsigned int ihl, unsigned int ipl)
{
	struct igmphdr *igmph;

	igmph = tcf_csum_skb_nextlayer(skb, ihl, ipl, sizeof(*igmph));
	if (igmph == NULL)
		return 0;

	igmph->csum = 0;
	skb->csum = csum_partial(igmph, ipl - ihl, 0);
	igmph->csum = csum_fold(skb->csum);

	skb->ip_summed = CHECKSUM_NONE;

	return 1;
}

static int tcf_csum_ipv6_icmp(struct sk_buff *skb, unsigned int ihl,
			      unsigned int ipl)
{
	struct icmp6hdr *icmp6h;
	const struct ipv6hdr *ip6h;

	icmp6h = tcf_csum_skb_nextlayer(skb, ihl, ipl, sizeof(*icmp6h));
	if (icmp6h == NULL)
		return 0;

	ip6h = ipv6_hdr(skb);
	icmp6h->icmp6_cksum = 0;
	skb->csum = csum_partial(icmp6h, ipl - ihl, 0);
	icmp6h->icmp6_cksum = csum_ipv6_magic(&ip6h->saddr, &ip6h->daddr,
					      ipl - ihl, IPPROTO_ICMPV6,
					      skb->csum);

	skb->ip_summed = CHECKSUM_NONE;

	return 1;
}

static int tcf_csum_ipv4_tcp(struct sk_buff *skb, unsigned int ihl,
			     unsigned int ipl)
{
	struct tcphdr *tcph;
	const struct iphdr *iph;

	if (skb_is_gso(skb) && skb_shinfo(skb)->gso_type & SKB_GSO_TCPV4)
		return 1;

	tcph = tcf_csum_skb_nextlayer(skb, ihl, ipl, sizeof(*tcph));
	if (tcph == NULL)
		return 0;

	iph = ip_hdr(skb);
	tcph->check = 0;
	skb->csum = csum_partial(tcph, ipl - ihl, 0);
	tcph->check = tcp_v4_check(ipl - ihl,
				   iph->saddr, iph->daddr, skb->csum);

	skb->ip_summed = CHECKSUM_NONE;

	return 1;
}

static int tcf_csum_ipv6_tcp(struct sk_buff *skb, unsigned int ihl,
			     unsigned int ipl)
{
	struct tcphdr *tcph;
	const struct ipv6hdr *ip6h;

	if (skb_is_gso(skb) && skb_shinfo(skb)->gso_type & SKB_GSO_TCPV6)
		return 1;

	tcph = tcf_csum_skb_nextlayer(skb, ihl, ipl, sizeof(*tcph));
	if (tcph == NULL)
		return 0;

	ip6h = ipv6_hdr(skb);
	tcph->check = 0;
	skb->csum = csum_partial(tcph, ipl - ihl, 0);
	tcph->check = csum_ipv6_magic(&ip6h->saddr, &ip6h->daddr,
				      ipl - ihl, IPPROTO_TCP,
				      skb->csum);

	skb->ip_summed = CHECKSUM_NONE;

	return 1;
}

static int tcf_csum_ipv4_udp(struct sk_buff *skb, unsigned int ihl,
			     unsigned int ipl, int udplite)
{
	struct udphdr *udph;
	const struct iphdr *iph;
	u16 ul;

	if (skb_is_gso(skb) && skb_shinfo(skb)->gso_type & SKB_GSO_UDP)
		return 1;

	/*
	 * Support both UDP and UDPLITE checksum algorithms, Don't use
	 * udph->len to get the real length without any protocol check,
	 * UDPLITE uses udph->len for another thing,
	 * Use iph->tot_len, or just ipl.
	 */

	udph = tcf_csum_skb_nextlayer(skb, ihl, ipl, sizeof(*udph));
	if (udph == NULL)
		return 0;

	iph = ip_hdr(skb);
	ul = ntohs(udph->len);

	if (udplite || udph->check) {

		udph->check = 0;

		if (udplite) {
			if (ul == 0)
				skb->csum = csum_partial(udph, ipl - ihl, 0);
			else if ((ul >= sizeof(*udph)) && (ul <= ipl - ihl))
				skb->csum = csum_partial(udph, ul, 0);
			else
				goto ignore_obscure_skb;
		} else {
			if (ul != ipl - ihl)
				goto ignore_obscure_skb;

			skb->csum = csum_partial(udph, ul, 0);
		}

		udph->check = csum_tcpudp_magic(iph->saddr, iph->daddr,
						ul, iph->protocol,
						skb->csum);

		if (!udph->check)
			udph->check = CSUM_MANGLED_0;
	}

	skb->ip_summed = CHECKSUM_NONE;

ignore_obscure_skb:
	return 1;
}

static int tcf_csum_ipv6_udp(struct sk_buff *skb, unsigned int ihl,
			     unsigned int ipl, int udplite)
{
	struct udphdr *udph;
	const struct ipv6hdr *ip6h;
	u16 ul;

	if (skb_is_gso(skb) && skb_shinfo(skb)->gso_type & SKB_GSO_UDP)
		return 1;

	/*
	 * Support both UDP and UDPLITE checksum algorithms, Don't use
	 * udph->len to get the real length without any protocol check,
	 * UDPLITE uses udph->len for another thing,
	 * Use ip6h->payload_len + sizeof(*ip6h) ... , or just ipl.
	 */

	udph = tcf_csum_skb_nextlayer(skb, ihl, ipl, sizeof(*udph));
	if (udph == NULL)
		return 0;

	ip6h = ipv6_hdr(skb);
	ul = ntohs(udph->len);

	udph->check = 0;

	if (udplite) {
		if (ul == 0)
			skb->csum = csum_partial(udph, ipl - ihl, 0);

		else if ((ul >= sizeof(*udph)) && (ul <= ipl - ihl))
			skb->csum = csum_partial(udph, ul, 0);

		else
			goto ignore_obscure_skb;
	} else {
		if (ul != ipl - ihl)
			goto ignore_obscure_skb;

		skb->csum = csum_partial(udph, ul, 0);
	}

	udph->check = csum_ipv6_magic(&ip6h->saddr, &ip6h->daddr, ul,
				      udplite ? IPPROTO_UDPLITE : IPPROTO_UDP,
				      skb->csum);

	if (!udph->check)
		udph->check = CSUM_MANGLED_0;

	skb->ip_summed = CHECKSUM_NONE;

ignore_obscure_skb:
	return 1;
}

static int tcf_csum_sctp(struct sk_buff *skb, unsigned int ihl,
			 unsigned int ipl)
{
	struct sctphdr *sctph;

	if (skb_is_gso(skb) && skb_is_gso_sctp(skb))
		return 1;

	sctph = tcf_csum_skb_nextlayer(skb, ihl, ipl, sizeof(*sctph));
	if (!sctph)
		return 0;

	sctph->checksum = sctp_compute_cksum(skb,
					     skb_network_offset(skb) + ihl);
	skb->ip_summed = CHECKSUM_NONE;
	skb->csum_not_inet = 0;

	return 1;
}

static int tcf_csum_ipv4(struct sk_buff *skb, u32 update_flags)
{
	const struct iphdr *iph;
	int ntkoff;

	ntkoff = skb_network_offset(skb);

	if (!pskb_may_pull(skb, sizeof(*iph) + ntkoff))
		goto fail;

	iph = ip_hdr(skb);

	switch (iph->frag_off & htons(IP_OFFSET) ? 0 : iph->protocol) {
	case IPPROTO_ICMP:
		if (update_flags & TCA_CSUM_UPDATE_FLAG_ICMP)
			if (!tcf_csum_ipv4_icmp(skb, iph->ihl * 4,
						ntohs(iph->tot_len)))
				goto fail;
		break;
	case IPPROTO_IGMP:
		if (update_flags & TCA_CSUM_UPDATE_FLAG_IGMP)
			if (!tcf_csum_ipv4_igmp(skb, iph->ihl * 4,
						ntohs(iph->tot_len)))
				goto fail;
		break;
	case IPPROTO_TCP:
		if (update_flags & TCA_CSUM_UPDATE_FLAG_TCP)
			if (!tcf_csum_ipv4_tcp(skb, iph->ihl * 4,
					       ntohs(iph->tot_len)))
				goto fail;
		break;
	case IPPROTO_UDP:
		if (update_flags & TCA_CSUM_UPDATE_FLAG_UDP)
			if (!tcf_csum_ipv4_udp(skb, iph->ihl * 4,
					       ntohs(iph->tot_len), 0))
				goto fail;
		break;
	case IPPROTO_UDPLITE:
		if (update_flags & TCA_CSUM_UPDATE_FLAG_UDPLITE)
			if (!tcf_csum_ipv4_udp(skb, iph->ihl * 4,
					       ntohs(iph->tot_len), 1))
				goto fail;
		break;
	case IPPROTO_SCTP:
		if ((update_flags & TCA_CSUM_UPDATE_FLAG_SCTP) &&
		    !tcf_csum_sctp(skb, iph->ihl * 4, ntohs(iph->tot_len)))
			goto fail;
		break;
	}

	if (update_flags & TCA_CSUM_UPDATE_FLAG_IPV4HDR) {
		if (skb_try_make_writable(skb, sizeof(*iph) + ntkoff))
			goto fail;

		ip_send_check(ip_hdr(skb));
	}

	return 1;

fail:
	return 0;
}

static int tcf_csum_ipv6_hopopts(struct ipv6_opt_hdr *ip6xh, unsigned int ixhl,
				 unsigned int *pl)
{
	int off, len, optlen;
	unsigned char *xh = (void *)ip6xh;

	off = sizeof(*ip6xh);
	len = ixhl - off;

	while (len > 1) {
		switch (xh[off]) {
		case IPV6_TLV_PAD1:
			optlen = 1;
			break;
		case IPV6_TLV_JUMBO:
			optlen = xh[off + 1] + 2;
			if (optlen != 6 || len < 6 || (off & 3) != 2)
				/* wrong jumbo option length/alignment */
				return 0;
			*pl = ntohl(*(__be32 *)(xh + off + 2));
			goto done;
		default:
			optlen = xh[off + 1] + 2;
			if (optlen > len)
				/* ignore obscure options */
				goto done;
			break;
		}
		off += optlen;
		len -= optlen;
	}

done:
	return 1;
}

static int tcf_csum_ipv6(struct sk_buff *skb, u32 update_flags)
{
	struct ipv6hdr *ip6h;
	struct ipv6_opt_hdr *ip6xh;
	unsigned int hl, ixhl;
	unsigned int pl;
	int ntkoff;
	u8 nexthdr;

	ntkoff = skb_network_offset(skb);

	hl = sizeof(*ip6h);

	if (!pskb_may_pull(skb, hl + ntkoff))
		goto fail;

	ip6h = ipv6_hdr(skb);

	pl = ntohs(ip6h->payload_len);
	nexthdr = ip6h->nexthdr;

	do {
		switch (nexthdr) {
		case NEXTHDR_FRAGMENT:
			goto ignore_skb;
		case NEXTHDR_ROUTING:
		case NEXTHDR_HOP:
		case NEXTHDR_DEST:
			if (!pskb_may_pull(skb, hl + sizeof(*ip6xh) + ntkoff))
				goto fail;
			ip6xh = (void *)(skb_network_header(skb) + hl);
			ixhl = ipv6_optlen(ip6xh);
			if (!pskb_may_pull(skb, hl + ixhl + ntkoff))
				goto fail;
			ip6xh = (void *)(skb_network_header(skb) + hl);
			if ((nexthdr == NEXTHDR_HOP) &&
			    !(tcf_csum_ipv6_hopopts(ip6xh, ixhl, &pl)))
				goto fail;
			nexthdr = ip6xh->nexthdr;
			hl += ixhl;
			break;
		case IPPROTO_ICMPV6:
			if (update_flags & TCA_CSUM_UPDATE_FLAG_ICMP)
				if (!tcf_csum_ipv6_icmp(skb,
							hl, pl + sizeof(*ip6h)))
					goto fail;
			goto done;
		case IPPROTO_TCP:
			if (update_flags & TCA_CSUM_UPDATE_FLAG_TCP)
				if (!tcf_csum_ipv6_tcp(skb,
						       hl, pl + sizeof(*ip6h)))
					goto fail;
			goto done;
		case IPPROTO_UDP:
			if (update_flags & TCA_CSUM_UPDATE_FLAG_UDP)
				if (!tcf_csum_ipv6_udp(skb, hl,
						       pl + sizeof(*ip6h), 0))
					goto fail;
			goto done;
		case IPPROTO_UDPLITE:
			if (update_flags & TCA_CSUM_UPDATE_FLAG_UDPLITE)
				if (!tcf_csum_ipv6_udp(skb, hl,
						       pl + sizeof(*ip6h), 1))
					goto fail;
			goto done;
		case IPPROTO_SCTP:
			if ((update_flags & TCA_CSUM_UPDATE_FLAG_SCTP) &&
			    !tcf_csum_sctp(skb, hl, pl + sizeof(*ip6h)))
				goto fail;
			goto done;
		default:
			goto ignore_skb;
		}
	} while (pskb_may_pull(skb, hl + 1 + ntkoff));

done:
ignore_skb:
	return 1;

fail:
	return 0;
}

static int tcf_csum(struct sk_buff *skb, const struct tc_action *a,
		    struct tcf_result *res)
{
	struct tcf_csum *p = to_tcf_csum(a);
	struct tcf_csum_params *params;
	u32 update_flags;
	int action;

	rcu_read_lock();
	params = rcu_dereference(p->params);

	tcf_lastuse_update(&p->tcf_tm);
	bstats_cpu_update(this_cpu_ptr(p->common.cpu_bstats), skb);

	action = params->action;
	if (unlikely(action == TC_ACT_SHOT))
		goto drop_stats;

	update_flags = params->update_flags;
	switch (tc_skb_protocol(skb)) {
	case cpu_to_be16(ETH_P_IP):
		if (!tcf_csum_ipv4(skb, update_flags))
			goto drop;
		break;
	case cpu_to_be16(ETH_P_IPV6):
		if (!tcf_csum_ipv6(skb, update_flags))
			goto drop;
		break;
	}

unlock:
	rcu_read_unlock();
	return action;

drop:
	action = TC_ACT_SHOT;

drop_stats:
	qstats_drop_inc(this_cpu_ptr(p->common.cpu_qstats));
	goto unlock;
}

static int tcf_csum_dump(struct sk_buff *skb, struct tc_action *a, int bind,
			 int ref)
{
	unsigned char *b = skb_tail_pointer(skb);
	struct tcf_csum *p = to_tcf_csum(a);
	struct tcf_csum_params *params;
	struct tc_csum opt = {
		.index   = p->tcf_index,
		.refcnt  = p->tcf_refcnt - ref,
		.bindcnt = p->tcf_bindcnt - bind,
	};
	struct tcf_t t;

	params = rtnl_dereference(p->params);
	opt.action = params->action;
	opt.update_flags = params->update_flags;

	if (nla_put(skb, TCA_CSUM_PARMS, sizeof(opt), &opt))
		goto nla_put_failure;

	tcf_tm_dump(&t, &p->tcf_tm);
	if (nla_put_64bit(skb, TCA_CSUM_TM, sizeof(t), &t, TCA_CSUM_PAD))
		goto nla_put_failure;

	return skb->len;

nla_put_failure:
	nlmsg_trim(skb, b);
	return -1;
}

static void tcf_csum_cleanup(struct tc_action *a)
{
	struct tcf_csum *p = to_tcf_csum(a);
	struct tcf_csum_params *params;

	params = rcu_dereference_protected(p->params, 1);
	if (params)
		kfree_rcu(params, rcu);
}

static int tcf_csum_walker(struct net *net, struct sk_buff *skb,
			   struct netlink_callback *cb, int type,
			   const struct tc_action_ops *ops)
{
	struct tc_action_net *tn = net_generic(net, csum_net_id);

	return tcf_generic_walker(tn, skb, cb, type, ops);
}

static int tcf_csum_search(struct net *net, struct tc_action **a, u32 index)
{
	struct tc_action_net *tn = net_generic(net, csum_net_id);

	return tcf_idr_search(tn, a, index);
}

static struct tc_action_ops act_csum_ops = {
	.kind		= "csum",
	.type		= TCA_ACT_CSUM,
	.owner		= THIS_MODULE,
	.act		= tcf_csum,
	.dump		= tcf_csum_dump,
	.init		= tcf_csum_init,
	.cleanup	= tcf_csum_cleanup,
	.walk		= tcf_csum_walker,
	.lookup		= tcf_csum_search,
	.size		= sizeof(struct tcf_csum),
};

static __net_init int csum_init_net(struct net *net)
{
	struct tc_action_net *tn = net_generic(net, csum_net_id);

	return tc_action_net_init(tn, &act_csum_ops);
}

static void __net_exit csum_exit_net(struct list_head *net_list)
{
	tc_action_net_exit(net_list, csum_net_id);
}

static struct pernet_operations csum_net_ops = {
	.init = csum_init_net,
	.exit_batch = csum_exit_net,
	.id   = &csum_net_id,
	.size = sizeof(struct tc_action_net),
};

MODULE_DESCRIPTION("Checksum updating actions");
MODULE_LICENSE("GPL");

static int __init csum_init_module(void)
{
	return tcf_register_action(&act_csum_ops, &csum_net_ops);
}

static void __exit csum_cleanup_module(void)
{
	tcf_unregister_action(&act_csum_ops, &csum_net_ops);
}

module_init(csum_init_module);
module_exit(csum_cleanup_module);
Commit	Line	Data
eb4d4065 GB	1	/*
	2	* Checksum updating actions
	3	*
	4	* Copyright (c) 2010 Gregoire Baron <baronchon@n7mm.org>
	5	*
	6	* This program is free software; you can redistribute it and/or modify it
	7	* under the terms of the GNU General Public License as published by the Free
	8	* Software Foundation; either version 2 of the License, or (at your option)
	9	* any later version.
	10	*
	11	*/
	12
	13	#include <linux/types.h>
	14	#include <linux/init.h>
	15	#include <linux/kernel.h>
	16	#include <linux/module.h>
	17	#include <linux/spinlock.h>
	18
	19	#include <linux/netlink.h>
	20	#include <net/netlink.h>
	21	#include <linux/rtnetlink.h>
	22
	23	#include <linux/skbuff.h>
	24
	25	#include <net/ip.h>
	26	#include <net/ipv6.h>
	27	#include <net/icmp.h>
	28	#include <linux/icmpv6.h>
	29	#include <linux/igmp.h>
	30	#include <net/tcp.h>
	31	#include <net/udp.h>
2436243a	32	#include <net/ip6_checksum.h>
c008b33f	33	#include <net/sctp/checksum.h>
eb4d4065 GB	34
	35	#include <net/act_api.h>
	36
	37	#include <linux/tc_act/tc_csum.h>
	38	#include <net/tc_act/tc_csum.h>
	39
eb4d4065 GB	40	static const struct nla_policy csum_policy[TCA_CSUM_MAX + 1] = {
	41	[TCA_CSUM_PARMS] = { .len = sizeof(struct tc_csum), },
	42	};
	43
c7d03a00	44	static unsigned int csum_net_id;
a85a970a	45	static struct tc_action_ops act_csum_ops;
ddf97ccd WC	46
ddf97ccd WC	47	static int tcf_csum_init(struct net net, struct nlattr nla,
a85a970a	48	struct nlattr est, struct tc_action *a, int ovr,
ddf97ccd	49	int bind)
eb4d4065	50	{
ddf97ccd	51	struct tc_action_net *tn = net_generic(net, csum_net_id);
9c5f69bb	52	struct tcf_csum_params params_old, params_new;
eb4d4065 GB	53	struct nlattr *tb[TCA_CSUM_MAX + 1];
eb4d4065 GB	54	struct tc_csum *parm;
eb4d4065 GB	55	struct tcf_csum *p;
	56	int ret = 0, err;
	57
	58	if (nla == NULL)
	59	return -EINVAL;
	60
fceb6435	61	err = nla_parse_nested(tb, TCA_CSUM_MAX, nla, csum_policy, NULL);
eb4d4065 GB	62	if (err < 0)
	63	return err;
	64
	65	if (tb[TCA_CSUM_PARMS] == NULL)
	66	return -EINVAL;
	67	parm = nla_data(tb[TCA_CSUM_PARMS]);
	68
65a206c0 CM	69	if (!tcf_idr_check(tn, parm->index, a, bind)) {
65a206c0 CM	70	ret = tcf_idr_create(tn, parm->index, est, a,
f6052cf2	71	&act_csum_ops, bind, true);
86062033 WC	72	if (ret)
86062033 WC	73	return ret;
eb4d4065 GB	74	ret = ACT_P_CREATED;
eb4d4065 GB	75	} else {
1a29321e JHS	76	if (bind)/* dont override defaults */
1a29321e JHS	77	return 0;
65a206c0	78	tcf_idr_release(*a, bind);
1a29321e	79	if (!ovr)
eb4d4065	80	return -EEXIST;
eb4d4065 GB	81	}
eb4d4065 GB	82
a85a970a	83	p = to_tcf_csum(*a);
9c5f69bb DC	84	ASSERT_RTNL();
	85
	86	params_new = kzalloc(sizeof(*params_new), GFP_KERNEL);
	87	if (unlikely(!params_new)) {
	88	if (ret == ACT_P_CREATED)
	89	tcf_idr_release(*a, bind);
	90	return -ENOMEM;
	91	}
	92	params_old = rtnl_dereference(p->params);
	93
	94	params_new->action = parm->action;
	95	params_new->update_flags = parm->update_flags;
	96	rcu_assign_pointer(p->params, params_new);
	97	if (params_old)
	98	kfree_rcu(params_old, rcu);
eb4d4065 GB	99
eb4d4065 GB	100	if (ret == ACT_P_CREATED)
65a206c0	101	tcf_idr_insert(tn, *a);
eb4d4065 GB	102
	103	return ret;
	104	}
	105
eb4d4065 GB	106	/**
	107	* tcf_csum_skb_nextlayer - Get next layer pointer
	108	* @skb: sk_buff to use
	109	* @ihl: previous summed headers length
	110	* @ipl: complete packet length
	111	* @jhl: next header length
	112	*
	113	* Check the expected next layer availability in the specified sk_buff.
	114	* Return the next layer pointer if pass, NULL otherwise.
	115	*/
	116	static void tcf_csum_skb_nextlayer(struct sk_buff skb,
	117	unsigned int ihl, unsigned int ipl,
	118	unsigned int jhl)
	119	{
	120	int ntkoff = skb_network_offset(skb);
	121	int hl = ihl + jhl;
	122
	123	if (!pskb_may_pull(skb, ipl + ntkoff) \|\| (ipl < hl) \|\|
3697649f	124	skb_try_make_writable(skb, hl + ntkoff))
eb4d4065 GB	125	return NULL;
	126	else
	127	return (void *)(skb_network_header(skb) + ihl);
	128	}
	129
5a7a5555 JHS	130	static int tcf_csum_ipv4_icmp(struct sk_buff *skb, unsigned int ihl,
5a7a5555 JHS	131	unsigned int ipl)
eb4d4065 GB	132	{
	133	struct icmphdr *icmph;
	134
	135	icmph = tcf_csum_skb_nextlayer(skb, ihl, ipl, sizeof(*icmph));
	136	if (icmph == NULL)
	137	return 0;
	138
	139	icmph->checksum = 0;
	140	skb->csum = csum_partial(icmph, ipl - ihl, 0);
	141	icmph->checksum = csum_fold(skb->csum);
	142
	143	skb->ip_summed = CHECKSUM_NONE;
	144
	145	return 1;
	146	}
	147
	148	static int tcf_csum_ipv4_igmp(struct sk_buff *skb,
	149	unsigned int ihl, unsigned int ipl)
	150	{
	151	struct igmphdr *igmph;
	152
	153	igmph = tcf_csum_skb_nextlayer(skb, ihl, ipl, sizeof(*igmph));
	154	if (igmph == NULL)
	155	return 0;
	156
	157	igmph->csum = 0;
	158	skb->csum = csum_partial(igmph, ipl - ihl, 0);
	159	igmph->csum = csum_fold(skb->csum);
	160
	161	skb->ip_summed = CHECKSUM_NONE;
	162
	163	return 1;
	164	}
	165
5a7a5555 JHS	166	static int tcf_csum_ipv6_icmp(struct sk_buff *skb, unsigned int ihl,
5a7a5555 JHS	167	unsigned int ipl)
eb4d4065 GB	168	{
eb4d4065 GB	169	struct icmp6hdr *icmp6h;
d14a489a	170	const struct ipv6hdr *ip6h;
eb4d4065 GB	171
	172	icmp6h = tcf_csum_skb_nextlayer(skb, ihl, ipl, sizeof(*icmp6h));
	173	if (icmp6h == NULL)
	174	return 0;
	175
d14a489a	176	ip6h = ipv6_hdr(skb);
eb4d4065 GB	177	icmp6h->icmp6_cksum = 0;
	178	skb->csum = csum_partial(icmp6h, ipl - ihl, 0);
	179	icmp6h->icmp6_cksum = csum_ipv6_magic(&ip6h->saddr, &ip6h->daddr,
	180	ipl - ihl, IPPROTO_ICMPV6,
	181	skb->csum);
	182
	183	skb->ip_summed = CHECKSUM_NONE;
	184
	185	return 1;
	186	}
	187
5a7a5555 JHS	188	static int tcf_csum_ipv4_tcp(struct sk_buff *skb, unsigned int ihl,
5a7a5555 JHS	189	unsigned int ipl)
eb4d4065 GB	190	{
eb4d4065 GB	191	struct tcphdr *tcph;
d14a489a	192	const struct iphdr *iph;
eb4d4065	193
add641e7 DC	194	if (skb_is_gso(skb) && skb_shinfo(skb)->gso_type & SKB_GSO_TCPV4)
	195	return 1;
	196
eb4d4065 GB	197	tcph = tcf_csum_skb_nextlayer(skb, ihl, ipl, sizeof(*tcph));
	198	if (tcph == NULL)
	199	return 0;
	200
d14a489a	201	iph = ip_hdr(skb);
eb4d4065 GB	202	tcph->check = 0;
	203	skb->csum = csum_partial(tcph, ipl - ihl, 0);
	204	tcph->check = tcp_v4_check(ipl - ihl,
	205	iph->saddr, iph->daddr, skb->csum);
	206
	207	skb->ip_summed = CHECKSUM_NONE;
	208
	209	return 1;
	210	}
	211
5a7a5555 JHS	212	static int tcf_csum_ipv6_tcp(struct sk_buff *skb, unsigned int ihl,
5a7a5555 JHS	213	unsigned int ipl)
eb4d4065 GB	214	{
eb4d4065 GB	215	struct tcphdr *tcph;
d14a489a	216	const struct ipv6hdr *ip6h;
eb4d4065	217
add641e7 DC	218	if (skb_is_gso(skb) && skb_shinfo(skb)->gso_type & SKB_GSO_TCPV6)
	219	return 1;
	220
eb4d4065 GB	221	tcph = tcf_csum_skb_nextlayer(skb, ihl, ipl, sizeof(*tcph));
	222	if (tcph == NULL)
	223	return 0;
	224
d14a489a	225	ip6h = ipv6_hdr(skb);
eb4d4065 GB	226	tcph->check = 0;
	227	skb->csum = csum_partial(tcph, ipl - ihl, 0);
	228	tcph->check = csum_ipv6_magic(&ip6h->saddr, &ip6h->daddr,
	229	ipl - ihl, IPPROTO_TCP,
	230	skb->csum);
	231
	232	skb->ip_summed = CHECKSUM_NONE;
	233
	234	return 1;
	235	}
	236
5a7a5555 JHS	237	static int tcf_csum_ipv4_udp(struct sk_buff *skb, unsigned int ihl,
5a7a5555 JHS	238	unsigned int ipl, int udplite)
eb4d4065 GB	239	{
eb4d4065 GB	240	struct udphdr *udph;
d14a489a	241	const struct iphdr *iph;
eb4d4065 GB	242	u16 ul;
eb4d4065 GB	243
0c19f846 WB	244	if (skb_is_gso(skb) && skb_shinfo(skb)->gso_type & SKB_GSO_UDP)
	245	return 1;
	246
0eec32ff CG	247	/*
	248	* Support both UDP and UDPLITE checksum algorithms, Don't use
	249	* udph->len to get the real length without any protocol check,
eb4d4065 GB	250	* UDPLITE uses udph->len for another thing,
	251	* Use iph->tot_len, or just ipl.
	252	*/
	253
	254	udph = tcf_csum_skb_nextlayer(skb, ihl, ipl, sizeof(*udph));
	255	if (udph == NULL)
	256	return 0;
	257
d14a489a	258	iph = ip_hdr(skb);
eb4d4065 GB	259	ul = ntohs(udph->len);
	260
	261	if (udplite \|\| udph->check) {
	262
	263	udph->check = 0;
	264
	265	if (udplite) {
	266	if (ul == 0)
	267	skb->csum = csum_partial(udph, ipl - ihl, 0);
eb4d4065 GB	268	else if ((ul >= sizeof(*udph)) && (ul <= ipl - ihl))
eb4d4065 GB	269	skb->csum = csum_partial(udph, ul, 0);
eb4d4065 GB	270	else
	271	goto ignore_obscure_skb;
	272	} else {
	273	if (ul != ipl - ihl)
	274	goto ignore_obscure_skb;
	275
	276	skb->csum = csum_partial(udph, ul, 0);
	277	}
	278
	279	udph->check = csum_tcpudp_magic(iph->saddr, iph->daddr,
	280	ul, iph->protocol,
	281	skb->csum);
	282
	283	if (!udph->check)
	284	udph->check = CSUM_MANGLED_0;
	285	}
	286
	287	skb->ip_summed = CHECKSUM_NONE;
	288
	289	ignore_obscure_skb:
	290	return 1;
	291	}
	292
5a7a5555 JHS	293	static int tcf_csum_ipv6_udp(struct sk_buff *skb, unsigned int ihl,
5a7a5555 JHS	294	unsigned int ipl, int udplite)
eb4d4065 GB	295	{
eb4d4065 GB	296	struct udphdr *udph;
d14a489a	297	const struct ipv6hdr *ip6h;
eb4d4065 GB	298	u16 ul;
eb4d4065 GB	299
0c19f846 WB	300	if (skb_is_gso(skb) && skb_shinfo(skb)->gso_type & SKB_GSO_UDP)
	301	return 1;
	302
0eec32ff CG	303	/*
	304	* Support both UDP and UDPLITE checksum algorithms, Don't use
	305	* udph->len to get the real length without any protocol check,
eb4d4065 GB	306	* UDPLITE uses udph->len for another thing,
	307	* Use ip6h->payload_len + sizeof(*ip6h) ... , or just ipl.
	308	*/
	309
	310	udph = tcf_csum_skb_nextlayer(skb, ihl, ipl, sizeof(*udph));
	311	if (udph == NULL)
	312	return 0;
	313
d14a489a	314	ip6h = ipv6_hdr(skb);
eb4d4065 GB	315	ul = ntohs(udph->len);
	316
	317	udph->check = 0;
	318
	319	if (udplite) {
	320	if (ul == 0)
	321	skb->csum = csum_partial(udph, ipl - ihl, 0);
	322
	323	else if ((ul >= sizeof(*udph)) && (ul <= ipl - ihl))
	324	skb->csum = csum_partial(udph, ul, 0);
	325
	326	else
	327	goto ignore_obscure_skb;
	328	} else {
	329	if (ul != ipl - ihl)
	330	goto ignore_obscure_skb;
	331
	332	skb->csum = csum_partial(udph, ul, 0);
	333	}
	334
	335	udph->check = csum_ipv6_magic(&ip6h->saddr, &ip6h->daddr, ul,
	336	udplite ? IPPROTO_UDPLITE : IPPROTO_UDP,
	337	skb->csum);
	338
	339	if (!udph->check)
	340	udph->check = CSUM_MANGLED_0;
	341
	342	skb->ip_summed = CHECKSUM_NONE;
	343
	344	ignore_obscure_skb:
	345	return 1;
	346	}
	347
c008b33f DC	348	static int tcf_csum_sctp(struct sk_buff *skb, unsigned int ihl,
	349	unsigned int ipl)
	350	{
	351	struct sctphdr *sctph;
	352
1dd27cde	353	if (skb_is_gso(skb) && skb_is_gso_sctp(skb))
c008b33f DC	354	return 1;
	355
	356	sctph = tcf_csum_skb_nextlayer(skb, ihl, ipl, sizeof(*sctph));
	357	if (!sctph)
	358	return 0;
	359
	360	sctph->checksum = sctp_compute_cksum(skb,
	361	skb_network_offset(skb) + ihl);
	362	skb->ip_summed = CHECKSUM_NONE;
dba00306	363	skb->csum_not_inet = 0;
c008b33f DC	364
	365	return 1;
	366	}
	367
eb4d4065 GB	368	static int tcf_csum_ipv4(struct sk_buff *skb, u32 update_flags)
eb4d4065 GB	369	{
d14a489a	370	const struct iphdr *iph;
eb4d4065 GB	371	int ntkoff;
	372
	373	ntkoff = skb_network_offset(skb);
	374
	375	if (!pskb_may_pull(skb, sizeof(*iph) + ntkoff))
	376	goto fail;
	377
	378	iph = ip_hdr(skb);
	379
	380	switch (iph->frag_off & htons(IP_OFFSET) ? 0 : iph->protocol) {
	381	case IPPROTO_ICMP:
	382	if (update_flags & TCA_CSUM_UPDATE_FLAG_ICMP)
0eec32ff CG	383	if (!tcf_csum_ipv4_icmp(skb, iph->ihl * 4,
0eec32ff CG	384	ntohs(iph->tot_len)))
eb4d4065 GB	385	goto fail;
	386	break;
	387	case IPPROTO_IGMP:
	388	if (update_flags & TCA_CSUM_UPDATE_FLAG_IGMP)
0eec32ff CG	389	if (!tcf_csum_ipv4_igmp(skb, iph->ihl * 4,
0eec32ff CG	390	ntohs(iph->tot_len)))
eb4d4065 GB	391	goto fail;
	392	break;
	393	case IPPROTO_TCP:
	394	if (update_flags & TCA_CSUM_UPDATE_FLAG_TCP)
d14a489a	395	if (!tcf_csum_ipv4_tcp(skb, iph->ihl * 4,
0eec32ff	396	ntohs(iph->tot_len)))
eb4d4065 GB	397	goto fail;
	398	break;
	399	case IPPROTO_UDP:
	400	if (update_flags & TCA_CSUM_UPDATE_FLAG_UDP)
d14a489a	401	if (!tcf_csum_ipv4_udp(skb, iph->ihl * 4,
0eec32ff	402	ntohs(iph->tot_len), 0))
eb4d4065 GB	403	goto fail;
	404	break;
	405	case IPPROTO_UDPLITE:
	406	if (update_flags & TCA_CSUM_UPDATE_FLAG_UDPLITE)
d14a489a	407	if (!tcf_csum_ipv4_udp(skb, iph->ihl * 4,
0eec32ff	408	ntohs(iph->tot_len), 1))
eb4d4065 GB	409	goto fail;
eb4d4065 GB	410	break;
c008b33f DC	411	case IPPROTO_SCTP:
	412	if ((update_flags & TCA_CSUM_UPDATE_FLAG_SCTP) &&
	413	!tcf_csum_sctp(skb, iph->ihl * 4, ntohs(iph->tot_len)))
	414	goto fail;
	415	break;
eb4d4065 GB	416	}
	417
	418	if (update_flags & TCA_CSUM_UPDATE_FLAG_IPV4HDR) {
3697649f	419	if (skb_try_make_writable(skb, sizeof(*iph) + ntkoff))
eb4d4065 GB	420	goto fail;
eb4d4065 GB	421
d14a489a	422	ip_send_check(ip_hdr(skb));
eb4d4065 GB	423	}
	424
	425	return 1;
	426
	427	fail:
	428	return 0;
	429	}
	430
5a7a5555 JHS	431	static int tcf_csum_ipv6_hopopts(struct ipv6_opt_hdr *ip6xh, unsigned int ixhl,
5a7a5555 JHS	432	unsigned int *pl)
eb4d4065 GB	433	{
	434	int off, len, optlen;
	435	unsigned char xh = (void )ip6xh;
	436
	437	off = sizeof(*ip6xh);
	438	len = ixhl - off;
	439
	440	while (len > 1) {
0eec32ff	441	switch (xh[off]) {
1de5a71c	442	case IPV6_TLV_PAD1:
eb4d4065 GB	443	optlen = 1;
	444	break;
	445	case IPV6_TLV_JUMBO:
	446	optlen = xh[off + 1] + 2;
	447	if (optlen != 6 \|\| len < 6 \|\| (off & 3) != 2)
	448	/* wrong jumbo option length/alignment */
	449	return 0;
	450	pl = ntohl((__be32 *)(xh + off + 2));
	451	goto done;
	452	default:
	453	optlen = xh[off + 1] + 2;
	454	if (optlen > len)
	455	/* ignore obscure options */
	456	goto done;
	457	break;
	458	}
	459	off += optlen;
	460	len -= optlen;
	461	}
	462
	463	done:
	464	return 1;
	465	}
	466
	467	static int tcf_csum_ipv6(struct sk_buff *skb, u32 update_flags)
	468	{
	469	struct ipv6hdr *ip6h;
	470	struct ipv6_opt_hdr *ip6xh;
	471	unsigned int hl, ixhl;
	472	unsigned int pl;
	473	int ntkoff;
	474	u8 nexthdr;
	475
	476	ntkoff = skb_network_offset(skb);
	477
	478	hl = sizeof(*ip6h);
	479
	480	if (!pskb_may_pull(skb, hl + ntkoff))
	481	goto fail;
	482
	483	ip6h = ipv6_hdr(skb);
	484
	485	pl = ntohs(ip6h->payload_len);
	486	nexthdr = ip6h->nexthdr;
	487
	488	do {
	489	switch (nexthdr) {
	490	case NEXTHDR_FRAGMENT:
	491	goto ignore_skb;
	492	case NEXTHDR_ROUTING:
	493	case NEXTHDR_HOP:
	494	case NEXTHDR_DEST:
	495	if (!pskb_may_pull(skb, hl + sizeof(*ip6xh) + ntkoff))
	496	goto fail;
	497	ip6xh = (void *)(skb_network_header(skb) + hl);
	498	ixhl = ipv6_optlen(ip6xh);
	499	if (!pskb_may_pull(skb, hl + ixhl + ntkoff))
	500	goto fail;
d14a489a	501	ip6xh = (void *)(skb_network_header(skb) + hl);
eb4d4065 GB	502	if ((nexthdr == NEXTHDR_HOP) &&
	503	!(tcf_csum_ipv6_hopopts(ip6xh, ixhl, &pl)))
	504	goto fail;
	505	nexthdr = ip6xh->nexthdr;
	506	hl += ixhl;
	507	break;
	508	case IPPROTO_ICMPV6:
	509	if (update_flags & TCA_CSUM_UPDATE_FLAG_ICMP)
d14a489a	510	if (!tcf_csum_ipv6_icmp(skb,
eb4d4065 GB	511	hl, pl + sizeof(*ip6h)))
	512	goto fail;
	513	goto done;
	514	case IPPROTO_TCP:
	515	if (update_flags & TCA_CSUM_UPDATE_FLAG_TCP)
d14a489a	516	if (!tcf_csum_ipv6_tcp(skb,
eb4d4065 GB	517	hl, pl + sizeof(*ip6h)))
	518	goto fail;
	519	goto done;
	520	case IPPROTO_UDP:
	521	if (update_flags & TCA_CSUM_UPDATE_FLAG_UDP)
d14a489a	522	if (!tcf_csum_ipv6_udp(skb, hl,
0eec32ff	523	pl + sizeof(*ip6h), 0))
eb4d4065 GB	524	goto fail;
	525	goto done;
	526	case IPPROTO_UDPLITE:
	527	if (update_flags & TCA_CSUM_UPDATE_FLAG_UDPLITE)
d14a489a	528	if (!tcf_csum_ipv6_udp(skb, hl,
0eec32ff	529	pl + sizeof(*ip6h), 1))
eb4d4065 GB	530	goto fail;
eb4d4065 GB	531	goto done;
c008b33f DC	532	case IPPROTO_SCTP:
	533	if ((update_flags & TCA_CSUM_UPDATE_FLAG_SCTP) &&
	534	!tcf_csum_sctp(skb, hl, pl + sizeof(*ip6h)))
	535	goto fail;
	536	goto done;
eb4d4065 GB	537	default:
	538	goto ignore_skb;
	539	}
	540	} while (pskb_may_pull(skb, hl + 1 + ntkoff));
	541
	542	done:
	543	ignore_skb:
	544	return 1;
	545
	546	fail:
	547	return 0;
	548	}
	549
5a7a5555 JHS	550	static int tcf_csum(struct sk_buff skb, const struct tc_action a,
5a7a5555 JHS	551	struct tcf_result *res)
eb4d4065	552	{
a85a970a	553	struct tcf_csum *p = to_tcf_csum(a);
9c5f69bb	554	struct tcf_csum_params *params;
eb4d4065	555	u32 update_flags;
9c5f69bb DC	556	int action;
	557
	558	rcu_read_lock();
	559	params = rcu_dereference(p->params);
eb4d4065	560
9c4a4e48	561	tcf_lastuse_update(&p->tcf_tm);
f6052cf2	562	bstats_cpu_update(this_cpu_ptr(p->common.cpu_bstats), skb);
eb4d4065	563
9c5f69bb	564	action = params->action;
eb4d4065	565	if (unlikely(action == TC_ACT_SHOT))
9c5f69bb	566	goto drop_stats;
eb4d4065	567
9c5f69bb	568	update_flags = params->update_flags;
d8b9605d	569	switch (tc_skb_protocol(skb)) {
eb4d4065 GB	570	case cpu_to_be16(ETH_P_IP):
	571	if (!tcf_csum_ipv4(skb, update_flags))
	572	goto drop;
	573	break;
	574	case cpu_to_be16(ETH_P_IPV6):
	575	if (!tcf_csum_ipv6(skb, update_flags))
	576	goto drop;
	577	break;
	578	}
	579
9c5f69bb DC	580	unlock:
9c5f69bb DC	581	rcu_read_unlock();
eb4d4065 GB	582	return action;
	583
	584	drop:
9c5f69bb DC	585	action = TC_ACT_SHOT;
	586
	587	drop_stats:
f6052cf2	588	qstats_drop_inc(this_cpu_ptr(p->common.cpu_qstats));
9c5f69bb	589	goto unlock;
eb4d4065 GB	590	}
eb4d4065 GB	591
5a7a5555 JHS	592	static int tcf_csum_dump(struct sk_buff skb, struct tc_action a, int bind,
5a7a5555 JHS	593	int ref)
eb4d4065 GB	594	{
eb4d4065 GB	595	unsigned char *b = skb_tail_pointer(skb);
a85a970a	596	struct tcf_csum *p = to_tcf_csum(a);
9c5f69bb	597	struct tcf_csum_params *params;
eb4d4065	598	struct tc_csum opt = {
eb4d4065	599	.index = p->tcf_index,
eb4d4065 GB	600	.refcnt = p->tcf_refcnt - ref,
	601	.bindcnt = p->tcf_bindcnt - bind,
	602	};
	603	struct tcf_t t;
	604
9c5f69bb DC	605	params = rtnl_dereference(p->params);
	606	opt.action = params->action;
	607	opt.update_flags = params->update_flags;
	608
1b34ec43 DM	609	if (nla_put(skb, TCA_CSUM_PARMS, sizeof(opt), &opt))
1b34ec43 DM	610	goto nla_put_failure;
48d8ee16 JHS	611
48d8ee16 JHS	612	tcf_tm_dump(&t, &p->tcf_tm);
9854518e	613	if (nla_put_64bit(skb, TCA_CSUM_TM, sizeof(t), &t, TCA_CSUM_PAD))
1b34ec43	614	goto nla_put_failure;
eb4d4065 GB	615
	616	return skb->len;
	617
	618	nla_put_failure:
	619	nlmsg_trim(skb, b);
	620	return -1;
	621	}
	622
9c5f69bb DC	623	static void tcf_csum_cleanup(struct tc_action *a)
	624	{
	625	struct tcf_csum *p = to_tcf_csum(a);
	626	struct tcf_csum_params *params;
	627
	628	params = rcu_dereference_protected(p->params, 1);
aab378a7 DC	629	if (params)
aab378a7 DC	630	kfree_rcu(params, rcu);
9c5f69bb DC	631	}
9c5f69bb DC	632
ddf97ccd WC	633	static int tcf_csum_walker(struct net net, struct sk_buff skb,
ddf97ccd WC	634	struct netlink_callback *cb, int type,
a85a970a	635	const struct tc_action_ops *ops)
ddf97ccd WC	636	{
	637	struct tc_action_net *tn = net_generic(net, csum_net_id);
	638
a85a970a	639	return tcf_generic_walker(tn, skb, cb, type, ops);
ddf97ccd WC	640	}
ddf97ccd WC	641
a85a970a	642	static int tcf_csum_search(struct net net, struct tc_action *a, u32 index)
ddf97ccd WC	643	{
	644	struct tc_action_net *tn = net_generic(net, csum_net_id);
	645
65a206c0	646	return tcf_idr_search(tn, a, index);
ddf97ccd WC	647	}
ddf97ccd WC	648
eb4d4065	649	static struct tc_action_ops act_csum_ops = {
0eec32ff	650	.kind = "csum",
0eec32ff	651	.type = TCA_ACT_CSUM,
0eec32ff CG	652	.owner = THIS_MODULE,
	653	.act = tcf_csum,
	654	.dump = tcf_csum_dump,
0eec32ff	655	.init = tcf_csum_init,
9c5f69bb	656	.cleanup = tcf_csum_cleanup,
ddf97ccd WC	657	.walk = tcf_csum_walker,
ddf97ccd WC	658	.lookup = tcf_csum_search,
a85a970a	659	.size = sizeof(struct tcf_csum),
ddf97ccd WC	660	};
	661
	662	static __net_init int csum_init_net(struct net *net)
	663	{
	664	struct tc_action_net *tn = net_generic(net, csum_net_id);
	665
c7e460ce	666	return tc_action_net_init(tn, &act_csum_ops);
ddf97ccd WC	667	}
ddf97ccd WC	668
039af9c6	669	static void __net_exit csum_exit_net(struct list_head *net_list)
ddf97ccd	670	{
039af9c6	671	tc_action_net_exit(net_list, csum_net_id);
ddf97ccd WC	672	}
	673
	674	static struct pernet_operations csum_net_ops = {
	675	.init = csum_init_net,
039af9c6	676	.exit_batch = csum_exit_net,
ddf97ccd WC	677	.id = &csum_net_id,
ddf97ccd WC	678	.size = sizeof(struct tc_action_net),
eb4d4065 GB	679	};
	680
	681	MODULE_DESCRIPTION("Checksum updating actions");
	682	MODULE_LICENSE("GPL");
	683
	684	static int __init csum_init_module(void)
	685	{
ddf97ccd	686	return tcf_register_action(&act_csum_ops, &csum_net_ops);
eb4d4065 GB	687	}
	688
	689	static void __exit csum_cleanup_module(void)
	690	{
ddf97ccd	691	tcf_unregister_action(&act_csum_ops, &csum_net_ops);
eb4d4065 GB	692	}
	693
	694	module_init(csum_init_module);
	695	module_exit(csum_cleanup_module);