Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 651a6493ae5c055c78777bb7178c23b5565631da

Authored by Jamal Hadi Salim 2013-12-04 22:26:56 +0800

Committed by David S. Miller 2013-12-06 08:28:43 +0800

Exists in smarc-imx_3.14.28_1.0.0_ga and in 1 other branch

net_sched: Use default action walker methods

Signed-off-by: Jamal Hadi Salim <jhs@mojatatu.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

Showing 8 changed files with 0 additions and 9 deletions Inline Diff

net/sched/act_csum.c
net/sched/act_gact.c
net/sched/act_ipt.c
net/sched/act_mirred.c
net/sched/act_nat.c
net/sched/act_pedit.c
net/sched/act_simple.c
net/sched/act_skbedit.c

net/sched/act_csum.c

Diff comments View file @ 651a649

 /*
  * 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/act_api.h>
 #include <linux/tc_act/tc_csum.h>
 #include <net/tc_act/tc_csum.h>
 #define CSUM_TAB_MASK 15
 static struct tcf_common *tcf_csum_ht[CSUM_TAB_MASK + 1];
 static u32 csum_idx_gen;
 static DEFINE_RWLOCK(csum_lock);
 static struct tcf_hashinfo csum_hash_info = {
 	.htab	= tcf_csum_ht,
 	.hmask	= CSUM_TAB_MASK,
 	.lock	= &csum_lock,
 };
 static const struct nla_policy csum_policy[TCA_CSUM_MAX + 1] = {
 	[TCA_CSUM_PARMS] = { .len = sizeof(struct tc_csum), },
 };
 static int tcf_csum_init(struct net *n, struct nlattr *nla, struct nlattr *est,
 			 struct tc_action *a, int ovr, int bind)
 {
 	struct nlattr *tb[TCA_CSUM_MAX + 1];
 	struct tc_csum *parm;
 	struct tcf_common *pc;
 	struct tcf_csum *p;
 	int ret = 0, err;
 	if (nla == NULL)
 		return -EINVAL;
 	err = nla_parse_nested(tb, TCA_CSUM_MAX, nla, csum_policy);
 	if (err < 0)
 		return err;
 	if (tb[TCA_CSUM_PARMS] == NULL)
 		return -EINVAL;
 	parm = nla_data(tb[TCA_CSUM_PARMS]);
 	pc = tcf_hash_check(parm->index, a, bind, &csum_hash_info);
 	if (!pc) {
 		pc = tcf_hash_create(parm->index, est, a, sizeof(*p), bind,
 				     &csum_idx_gen, &csum_hash_info);
 		if (IS_ERR(pc))
 			return PTR_ERR(pc);
 		p = to_tcf_csum(pc);
 		ret = ACT_P_CREATED;
 	} else {
 		p = to_tcf_csum(pc);
 		if (!ovr) {
 			tcf_hash_release(pc, bind, &csum_hash_info);
 			return -EEXIST;
 		}
 	}
 	spin_lock_bh(&p->tcf_lock);
 	p->tcf_action = parm->action;
 	p->update_flags = parm->update_flags;
 	spin_unlock_bh(&p->tcf_lock);
 	if (ret == ACT_P_CREATED)
 		tcf_hash_insert(pc, &csum_hash_info);
 	return ret;
 }
 static int tcf_csum_cleanup(struct tc_action *a, int bind)
 {
 	struct tcf_csum *p = a->priv;
 	return tcf_hash_release(&p->common, bind, &csum_hash_info);
 }
 /**
  * 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_cloned(skb) &&
 	     !skb_clone_writable(skb, hl + ntkoff) &&
 	     pskb_expand_head(skb, 0, 0, GFP_ATOMIC)))
 		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;
 	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;
 	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;
 	/*
 	 * 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;
 	/*
 	 * 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_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;
 	}
 	if (update_flags & TCA_CSUM_UPDATE_FLAG_IPV4HDR) {
 		if (skb_cloned(skb) &&
 		    !skb_clone_writable(skb, sizeof(*iph) + ntkoff) &&
 		    pskb_expand_head(skb, 0, 0, GFP_ATOMIC))
 			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;
 		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 = a->priv;
 	int action;
 	u32 update_flags;
 	spin_lock(&p->tcf_lock);
 	p->tcf_tm.lastuse = jiffies;
 	bstats_update(&p->tcf_bstats, skb);
 	action = p->tcf_action;
 	update_flags = p->update_flags;
 	spin_unlock(&p->tcf_lock);
 	if (unlikely(action == TC_ACT_SHOT))
 		goto drop;
 	switch (skb->protocol) {
 	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;
 	}
 	return action;
 drop:
 	spin_lock(&p->tcf_lock);
 	p->tcf_qstats.drops++;
 	spin_unlock(&p->tcf_lock);
 	return TC_ACT_SHOT;
 }
 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 = a->priv;
 	struct tc_csum opt = {
 		.update_flags = p->update_flags,
 		.index   = p->tcf_index,
 		.action  = p->tcf_action,
 		.refcnt  = p->tcf_refcnt - ref,
 		.bindcnt = p->tcf_bindcnt - bind,
 	};
 	struct tcf_t t;
 	if (nla_put(skb, TCA_CSUM_PARMS, sizeof(opt), &opt))
 		goto nla_put_failure;
 	t.install = jiffies_to_clock_t(jiffies - p->tcf_tm.install);
 	t.lastuse = jiffies_to_clock_t(jiffies - p->tcf_tm.lastuse);
 	t.expires = jiffies_to_clock_t(p->tcf_tm.expires);
 	if (nla_put(skb, TCA_CSUM_TM, sizeof(t), &t))
 		goto nla_put_failure;
 	return skb->len;
 nla_put_failure:
 	nlmsg_trim(skb, b);
 	return -1;
 }
 static struct tc_action_ops act_csum_ops = {
 	.kind		= "csum",
 	.hinfo		= &csum_hash_info,
 	.type		= TCA_ACT_CSUM,
 	.capab		= TCA_CAP_NONE,
 	.owner		= THIS_MODULE,
 	.act		= tcf_csum,
 	.dump		= tcf_csum_dump,
 	.cleanup	= tcf_csum_cleanup,
 	.init		= tcf_csum_init,
-	.walk		= tcf_generic_walker
 };
 MODULE_DESCRIPTION("Checksum updating actions");
 MODULE_LICENSE("GPL");
 static int __init csum_init_module(void)
 {
 	return tcf_register_action(&act_csum_ops);
 }
 static void __exit csum_cleanup_module(void)
 {
 	tcf_unregister_action(&act_csum_ops);
 }
 module_init(csum_init_module);
 module_exit(csum_cleanup_module);

net/sched/act_gact.c

Diff comments View file @ 651a649

 /*
  * net/sched/gact.c	Generic actions
  *
  *		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.
  *
  * copyright 	Jamal Hadi Salim (2002-4)
  *
  */
 #include <linux/types.h>
 #include <linux/kernel.h>
 #include <linux/string.h>
 #include <linux/errno.h>
 #include <linux/skbuff.h>
 #include <linux/rtnetlink.h>
 #include <linux/module.h>
 #include <linux/init.h>
 #include <net/netlink.h>
 #include <net/pkt_sched.h>
 #include <linux/tc_act/tc_gact.h>
 #include <net/tc_act/tc_gact.h>
 #define GACT_TAB_MASK	15
 static struct tcf_common *tcf_gact_ht[GACT_TAB_MASK + 1];
 static u32 gact_idx_gen;
 static DEFINE_RWLOCK(gact_lock);
 static struct tcf_hashinfo gact_hash_info = {
 	.htab	=	tcf_gact_ht,
 	.hmask	=	GACT_TAB_MASK,
 	.lock	=	&gact_lock,
 };
 #ifdef CONFIG_GACT_PROB
 static int gact_net_rand(struct tcf_gact *gact)
 {
 	if (!gact->tcfg_pval || net_random() % gact->tcfg_pval)
 		return gact->tcf_action;
 	return gact->tcfg_paction;
 }
 static int gact_determ(struct tcf_gact *gact)
 {
 	if (!gact->tcfg_pval || gact->tcf_bstats.packets % gact->tcfg_pval)
 		return gact->tcf_action;
 	return gact->tcfg_paction;
 }
 typedef int (*g_rand)(struct tcf_gact *gact);
 static g_rand gact_rand[MAX_RAND] = { NULL, gact_net_rand, gact_determ };
 #endif /* CONFIG_GACT_PROB */
 static const struct nla_policy gact_policy[TCA_GACT_MAX + 1] = {
 	[TCA_GACT_PARMS]	= { .len = sizeof(struct tc_gact) },
 	[TCA_GACT_PROB]		= { .len = sizeof(struct tc_gact_p) },
 };
 static int tcf_gact_init(struct net *net, struct nlattr *nla,
 			 struct nlattr *est, struct tc_action *a,
 			 int ovr, int bind)
 {
 	struct nlattr *tb[TCA_GACT_MAX + 1];
 	struct tc_gact *parm;
 	struct tcf_gact *gact;
 	struct tcf_common *pc;
 	int ret = 0;
 	int err;
 #ifdef CONFIG_GACT_PROB
 	struct tc_gact_p *p_parm = NULL;
 #endif
 	if (nla == NULL)
 		return -EINVAL;
 	err = nla_parse_nested(tb, TCA_GACT_MAX, nla, gact_policy);
 	if (err < 0)
 		return err;
 	if (tb[TCA_GACT_PARMS] == NULL)
 		return -EINVAL;
 	parm = nla_data(tb[TCA_GACT_PARMS]);
 #ifndef CONFIG_GACT_PROB
 	if (tb[TCA_GACT_PROB] != NULL)
 		return -EOPNOTSUPP;
 #else
 	if (tb[TCA_GACT_PROB]) {
 		p_parm = nla_data(tb[TCA_GACT_PROB]);
 		if (p_parm->ptype >= MAX_RAND)
 			return -EINVAL;
 	}
 #endif
 	pc = tcf_hash_check(parm->index, a, bind, &gact_hash_info);
 	if (!pc) {
 		pc = tcf_hash_create(parm->index, est, a, sizeof(*gact),
 				     bind, &gact_idx_gen, &gact_hash_info);
 		if (IS_ERR(pc))
 			return PTR_ERR(pc);
 		ret = ACT_P_CREATED;
 	} else {
 		if (!ovr) {
 			tcf_hash_release(pc, bind, &gact_hash_info);
 			return -EEXIST;
 		}
 	}
 	gact = to_gact(pc);
 	spin_lock_bh(&gact->tcf_lock);
 	gact->tcf_action = parm->action;
 #ifdef CONFIG_GACT_PROB
 	if (p_parm) {
 		gact->tcfg_paction = p_parm->paction;
 		gact->tcfg_pval    = p_parm->pval;
 		gact->tcfg_ptype   = p_parm->ptype;
 	}
 #endif
 	spin_unlock_bh(&gact->tcf_lock);
 	if (ret == ACT_P_CREATED)
 		tcf_hash_insert(pc, &gact_hash_info);
 	return ret;
 }
 static int tcf_gact_cleanup(struct tc_action *a, int bind)
 {
 	struct tcf_gact *gact = a->priv;
 	if (gact)
 		return tcf_hash_release(&gact->common, bind, &gact_hash_info);
 	return 0;
 }
 static int tcf_gact(struct sk_buff *skb, const struct tc_action *a,
 		    struct tcf_result *res)
 {
 	struct tcf_gact *gact = a->priv;
 	int action = TC_ACT_SHOT;
 	spin_lock(&gact->tcf_lock);
 #ifdef CONFIG_GACT_PROB
 	if (gact->tcfg_ptype)
 		action = gact_rand[gact->tcfg_ptype](gact);
 	else
 		action = gact->tcf_action;
 #else
 	action = gact->tcf_action;
 #endif
 	gact->tcf_bstats.bytes += qdisc_pkt_len(skb);
 	gact->tcf_bstats.packets++;
 	if (action == TC_ACT_SHOT)
 		gact->tcf_qstats.drops++;
 	gact->tcf_tm.lastuse = jiffies;
 	spin_unlock(&gact->tcf_lock);
 	return action;
 }
 static int tcf_gact_dump(struct sk_buff *skb, struct tc_action *a, int bind, int ref)
 {
 	unsigned char *b = skb_tail_pointer(skb);
 	struct tcf_gact *gact = a->priv;
 	struct tc_gact opt = {
 		.index   = gact->tcf_index,
 		.refcnt  = gact->tcf_refcnt - ref,
 		.bindcnt = gact->tcf_bindcnt - bind,
 		.action  = gact->tcf_action,
 	};
 	struct tcf_t t;
 	if (nla_put(skb, TCA_GACT_PARMS, sizeof(opt), &opt))
 		goto nla_put_failure;
 #ifdef CONFIG_GACT_PROB
 	if (gact->tcfg_ptype) {
 		struct tc_gact_p p_opt = {
 			.paction = gact->tcfg_paction,
 			.pval    = gact->tcfg_pval,
 			.ptype   = gact->tcfg_ptype,
 		};
 		if (nla_put(skb, TCA_GACT_PROB, sizeof(p_opt), &p_opt))
 			goto nla_put_failure;
 	}
 #endif
 	t.install = jiffies_to_clock_t(jiffies - gact->tcf_tm.install);
 	t.lastuse = jiffies_to_clock_t(jiffies - gact->tcf_tm.lastuse);
 	t.expires = jiffies_to_clock_t(gact->tcf_tm.expires);
 	if (nla_put(skb, TCA_GACT_TM, sizeof(t), &t))
 		goto nla_put_failure;
 	return skb->len;
 nla_put_failure:
 	nlmsg_trim(skb, b);
 	return -1;
 }
 static struct tc_action_ops act_gact_ops = {
 	.kind		=	"gact",
 	.hinfo		=	&gact_hash_info,
 	.type		=	TCA_ACT_GACT,
 	.capab		=	TCA_CAP_NONE,
 	.owner		=	THIS_MODULE,
 	.act		=	tcf_gact,
 	.dump		=	tcf_gact_dump,
 	.cleanup	=	tcf_gact_cleanup,
 	.init		=	tcf_gact_init,
-	.walk		=	tcf_generic_walker
 };
 MODULE_AUTHOR("Jamal Hadi Salim(2002-4)");
 MODULE_DESCRIPTION("Generic Classifier actions");
 MODULE_LICENSE("GPL");
 static int __init gact_init_module(void)
 {
 #ifdef CONFIG_GACT_PROB
 	pr_info("GACT probability on\n");
 #else
 	pr_info("GACT probability NOT on\n");
 #endif
 	return tcf_register_action(&act_gact_ops);
 }
 static void __exit gact_cleanup_module(void)
 {
 	tcf_unregister_action(&act_gact_ops);
 }
 module_init(gact_init_module);
 module_exit(gact_cleanup_module);

net/sched/act_ipt.c

Diff comments View file @ 651a649

 /*
  * net/sched/ipt.c     iptables target interface
  *
  *TODO: Add other tables. For now we only support the ipv4 table targets
  *
  *		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.
  *
  * Copyright:	Jamal Hadi Salim (2002-13)
  */
 #include <linux/types.h>
 #include <linux/kernel.h>
 #include <linux/string.h>
 #include <linux/errno.h>
 #include <linux/skbuff.h>
 #include <linux/rtnetlink.h>
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <net/netlink.h>
 #include <net/pkt_sched.h>
 #include <linux/tc_act/tc_ipt.h>
 #include <net/tc_act/tc_ipt.h>
 #include <linux/netfilter_ipv4/ip_tables.h>
 #define IPT_TAB_MASK     15
 static struct tcf_common *tcf_ipt_ht[IPT_TAB_MASK + 1];
 static u32 ipt_idx_gen;
 static DEFINE_RWLOCK(ipt_lock);
 static struct tcf_hashinfo ipt_hash_info = {
 	.htab	=	tcf_ipt_ht,
 	.hmask	=	IPT_TAB_MASK,
 	.lock	=	&ipt_lock,
 };
 static int ipt_init_target(struct xt_entry_target *t, char *table, unsigned int hook)
 {
 	struct xt_tgchk_param par;
 	struct xt_target *target;
 	int ret = 0;
 	target = xt_request_find_target(AF_INET, t->u.user.name,
 					t->u.user.revision);
 	if (IS_ERR(target))
 		return PTR_ERR(target);
 	t->u.kernel.target = target;
 	par.table     = table;
 	par.entryinfo = NULL;
 	par.target    = target;
 	par.targinfo  = t->data;
 	par.hook_mask = hook;
 	par.family    = NFPROTO_IPV4;
 	ret = xt_check_target(&par, t->u.target_size - sizeof(*t), 0, false);
 	if (ret < 0) {
 		module_put(t->u.kernel.target->me);
 		return ret;
 	}
 	return 0;
 }
 static void ipt_destroy_target(struct xt_entry_target *t)
 {
 	struct xt_tgdtor_param par = {
 		.target   = t->u.kernel.target,
 		.targinfo = t->data,
 	};
 	if (par.target->destroy != NULL)
 		par.target->destroy(&par);
 	module_put(par.target->me);
 }
 static int tcf_ipt_release(struct tcf_ipt *ipt, int bind)
 {
 	int ret = 0;
 	if (ipt) {
 		if (bind)
 			ipt->tcf_bindcnt--;
 		ipt->tcf_refcnt--;
 		if (ipt->tcf_bindcnt <= 0 && ipt->tcf_refcnt <= 0) {
 			ipt_destroy_target(ipt->tcfi_t);
 			kfree(ipt->tcfi_tname);
 			kfree(ipt->tcfi_t);
 			tcf_hash_destroy(&ipt->common, &ipt_hash_info);
 			ret = ACT_P_DELETED;
 		}
 	}
 	return ret;
 }
 static const struct nla_policy ipt_policy[TCA_IPT_MAX + 1] = {
 	[TCA_IPT_TABLE]	= { .type = NLA_STRING, .len = IFNAMSIZ },
 	[TCA_IPT_HOOK]	= { .type = NLA_U32 },
 	[TCA_IPT_INDEX]	= { .type = NLA_U32 },
 	[TCA_IPT_TARG]	= { .len = sizeof(struct xt_entry_target) },
 };
 static int tcf_ipt_init(struct net *net, struct nlattr *nla, struct nlattr *est,
 			struct tc_action *a, int ovr, int bind)
 {
 	struct nlattr *tb[TCA_IPT_MAX + 1];
 	struct tcf_ipt *ipt;
 	struct tcf_common *pc;
 	struct xt_entry_target *td, *t;
 	char *tname;
 	int ret = 0, err;
 	u32 hook = 0;
 	u32 index = 0;
 	if (nla == NULL)
 		return -EINVAL;
 	err = nla_parse_nested(tb, TCA_IPT_MAX, nla, ipt_policy);
 	if (err < 0)
 		return err;
 	if (tb[TCA_IPT_HOOK] == NULL)
 		return -EINVAL;
 	if (tb[TCA_IPT_TARG] == NULL)
 		return -EINVAL;
 	td = (struct xt_entry_target *)nla_data(tb[TCA_IPT_TARG]);
 	if (nla_len(tb[TCA_IPT_TARG]) < td->u.target_size)
 		return -EINVAL;
 	if (tb[TCA_IPT_INDEX] != NULL)
 		index = nla_get_u32(tb[TCA_IPT_INDEX]);
 	pc = tcf_hash_check(index, a, bind, &ipt_hash_info);
 	if (!pc) {
 		pc = tcf_hash_create(index, est, a, sizeof(*ipt), bind,
 				     &ipt_idx_gen, &ipt_hash_info);
 		if (IS_ERR(pc))
 			return PTR_ERR(pc);
 		ret = ACT_P_CREATED;
 	} else {
 		if (!ovr) {
 			tcf_ipt_release(to_ipt(pc), bind);
 			return -EEXIST;
 		}
 	}
 	ipt = to_ipt(pc);
 	hook = nla_get_u32(tb[TCA_IPT_HOOK]);
 	err = -ENOMEM;
 	tname = kmalloc(IFNAMSIZ, GFP_KERNEL);
 	if (unlikely(!tname))
 		goto err1;
 	if (tb[TCA_IPT_TABLE] == NULL ||
 	    nla_strlcpy(tname, tb[TCA_IPT_TABLE], IFNAMSIZ) >= IFNAMSIZ)
 		strcpy(tname, "mangle");
 	t = kmemdup(td, td->u.target_size, GFP_KERNEL);
 	if (unlikely(!t))
 		goto err2;
 	err = ipt_init_target(t, tname, hook);
 	if (err < 0)
 		goto err3;
 	spin_lock_bh(&ipt->tcf_lock);
 	if (ret != ACT_P_CREATED) {
 		ipt_destroy_target(ipt->tcfi_t);
 		kfree(ipt->tcfi_tname);
 		kfree(ipt->tcfi_t);
 	}
 	ipt->tcfi_tname = tname;
 	ipt->tcfi_t     = t;
 	ipt->tcfi_hook  = hook;
 	spin_unlock_bh(&ipt->tcf_lock);
 	if (ret == ACT_P_CREATED)
 		tcf_hash_insert(pc, &ipt_hash_info);
 	return ret;
 err3:
 	kfree(t);
 err2:
 	kfree(tname);
 err1:
 	if (ret == ACT_P_CREATED) {
 		if (est)
 			gen_kill_estimator(&pc->tcfc_bstats,
 					   &pc->tcfc_rate_est);
 		kfree_rcu(pc, tcfc_rcu);
 	}
 	return err;
 }
 static int tcf_ipt_cleanup(struct tc_action *a, int bind)
 {
 	struct tcf_ipt *ipt = a->priv;
 	return tcf_ipt_release(ipt, bind);
 }
 static int tcf_ipt(struct sk_buff *skb, const struct tc_action *a,
 		   struct tcf_result *res)
 {
 	int ret = 0, result = 0;
 	struct tcf_ipt *ipt = a->priv;
 	struct xt_action_param par;
 	if (skb_unclone(skb, GFP_ATOMIC))
 		return TC_ACT_UNSPEC;
 	spin_lock(&ipt->tcf_lock);
 	ipt->tcf_tm.lastuse = jiffies;
 	bstats_update(&ipt->tcf_bstats, skb);
 	/* yes, we have to worry about both in and out dev
 	 * worry later - danger - this API seems to have changed
 	 * from earlier kernels
 	 */
 	par.in       = skb->dev;
 	par.out      = NULL;
 	par.hooknum  = ipt->tcfi_hook;
 	par.target   = ipt->tcfi_t->u.kernel.target;
 	par.targinfo = ipt->tcfi_t->data;
 	ret = par.target->target(skb, &par);
 	switch (ret) {
 	case NF_ACCEPT:
 		result = TC_ACT_OK;
 		break;
 	case NF_DROP:
 		result = TC_ACT_SHOT;
 		ipt->tcf_qstats.drops++;
 		break;
 	case XT_CONTINUE:
 		result = TC_ACT_PIPE;
 		break;
 	default:
 		net_notice_ratelimited("tc filter: Bogus netfilter code %d assume ACCEPT\n",
 				       ret);
 		result = TC_POLICE_OK;
 		break;
 	}
 	spin_unlock(&ipt->tcf_lock);
 	return result;
 }
 static int tcf_ipt_dump(struct sk_buff *skb, struct tc_action *a, int bind, int ref)
 {
 	unsigned char *b = skb_tail_pointer(skb);
 	struct tcf_ipt *ipt = a->priv;
 	struct xt_entry_target *t;
 	struct tcf_t tm;
 	struct tc_cnt c;
 	/* for simple targets kernel size == user size
 	 * user name = target name
 	 * for foolproof you need to not assume this
 	 */
 	t = kmemdup(ipt->tcfi_t, ipt->tcfi_t->u.user.target_size, GFP_ATOMIC);
 	if (unlikely(!t))
 		goto nla_put_failure;
 	c.bindcnt = ipt->tcf_bindcnt - bind;
 	c.refcnt = ipt->tcf_refcnt - ref;
 	strcpy(t->u.user.name, ipt->tcfi_t->u.kernel.target->name);
 	if (nla_put(skb, TCA_IPT_TARG, ipt->tcfi_t->u.user.target_size, t) ||
 	    nla_put_u32(skb, TCA_IPT_INDEX, ipt->tcf_index) ||
 	    nla_put_u32(skb, TCA_IPT_HOOK, ipt->tcfi_hook) ||
 	    nla_put(skb, TCA_IPT_CNT, sizeof(struct tc_cnt), &c) ||
 	    nla_put_string(skb, TCA_IPT_TABLE, ipt->tcfi_tname))
 		goto nla_put_failure;
 	tm.install = jiffies_to_clock_t(jiffies - ipt->tcf_tm.install);
 	tm.lastuse = jiffies_to_clock_t(jiffies - ipt->tcf_tm.lastuse);
 	tm.expires = jiffies_to_clock_t(ipt->tcf_tm.expires);
 	if (nla_put(skb, TCA_IPT_TM, sizeof (tm), &tm))
 		goto nla_put_failure;
 	kfree(t);
 	return skb->len;
 nla_put_failure:
 	nlmsg_trim(skb, b);
 	kfree(t);
 	return -1;
 }
 static struct tc_action_ops act_ipt_ops = {
 	.kind		=	"ipt",
 	.hinfo		=	&ipt_hash_info,
 	.type		=	TCA_ACT_IPT,
 	.capab		=	TCA_CAP_NONE,
 	.owner		=	THIS_MODULE,
 	.act		=	tcf_ipt,
 	.dump		=	tcf_ipt_dump,
 	.cleanup	=	tcf_ipt_cleanup,
 	.init		=	tcf_ipt_init,
-	.walk		=	tcf_generic_walker
 };
 static struct tc_action_ops act_xt_ops = {
 	.kind		=	"xt",
 	.hinfo		=	&ipt_hash_info,
 	.type		=	TCA_ACT_IPT,
 	.capab		=	TCA_CAP_NONE,
 	.owner		=	THIS_MODULE,
 	.act		=	tcf_ipt,
 	.dump		=	tcf_ipt_dump,
 	.cleanup	=	tcf_ipt_cleanup,
 	.init		=	tcf_ipt_init,
-	.walk		=	tcf_generic_walker
 };
 MODULE_AUTHOR("Jamal Hadi Salim(2002-13)");
 MODULE_DESCRIPTION("Iptables target actions");
 MODULE_LICENSE("GPL");
 MODULE_ALIAS("act_xt");
 static int __init ipt_init_module(void)
 {
 	int ret1, ret2;
 	ret1 = tcf_register_action(&act_xt_ops);
 	if (ret1 < 0)
 		printk("Failed to load xt action\n");
 	ret2 = tcf_register_action(&act_ipt_ops);
 	if (ret2 < 0)
 		printk("Failed to load ipt action\n");
 	if (ret1 < 0 && ret2 < 0)
 		return ret1;
 	else
 		return 0;
 }
 static void __exit ipt_cleanup_module(void)
 {
 	tcf_unregister_action(&act_xt_ops);
 	tcf_unregister_action(&act_ipt_ops);
 }
 module_init(ipt_init_module);
 module_exit(ipt_cleanup_module);

net/sched/act_mirred.c

Diff comments View file @ 651a649

 /*
  * net/sched/mirred.c	packet mirroring and redirect actions
  *
  *		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.
  *
  * Authors:	Jamal Hadi Salim (2002-4)
  *
  * TODO: Add ingress support (and socket redirect support)
  *
  */
 #include <linux/types.h>
 #include <linux/kernel.h>
 #include <linux/string.h>
 #include <linux/errno.h>
 #include <linux/skbuff.h>
 #include <linux/rtnetlink.h>
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/gfp.h>
 #include <net/net_namespace.h>
 #include <net/netlink.h>
 #include <net/pkt_sched.h>
 #include <linux/tc_act/tc_mirred.h>
 #include <net/tc_act/tc_mirred.h>
 #include <linux/if_arp.h>
 #define MIRRED_TAB_MASK     7
 static struct tcf_common *tcf_mirred_ht[MIRRED_TAB_MASK + 1];
 static u32 mirred_idx_gen;
 static DEFINE_RWLOCK(mirred_lock);
 static LIST_HEAD(mirred_list);
 static struct tcf_hashinfo mirred_hash_info = {
 	.htab	=	tcf_mirred_ht,
 	.hmask	=	MIRRED_TAB_MASK,
 	.lock	=	&mirred_lock,
 };
 static int tcf_mirred_release(struct tcf_mirred *m, int bind)
 {
 	if (m) {
 		if (bind)
 			m->tcf_bindcnt--;
 		m->tcf_refcnt--;
 		if (!m->tcf_bindcnt && m->tcf_refcnt <= 0) {
 			list_del(&m->tcfm_list);
 			if (m->tcfm_dev)
 				dev_put(m->tcfm_dev);
 			tcf_hash_destroy(&m->common, &mirred_hash_info);
 			return 1;
 		}
 	}
 	return 0;
 }
 static const struct nla_policy mirred_policy[TCA_MIRRED_MAX + 1] = {
 	[TCA_MIRRED_PARMS]	= { .len = sizeof(struct tc_mirred) },
 };
 static int tcf_mirred_init(struct net *net, struct nlattr *nla,
 			   struct nlattr *est, struct tc_action *a, int ovr,
 			   int bind)
 {
 	struct nlattr *tb[TCA_MIRRED_MAX + 1];
 	struct tc_mirred *parm;
 	struct tcf_mirred *m;
 	struct tcf_common *pc;
 	struct net_device *dev;
 	int ret, ok_push = 0;
 	if (nla == NULL)
 		return -EINVAL;
 	ret = nla_parse_nested(tb, TCA_MIRRED_MAX, nla, mirred_policy);
 	if (ret < 0)
 		return ret;
 	if (tb[TCA_MIRRED_PARMS] == NULL)
 		return -EINVAL;
 	parm = nla_data(tb[TCA_MIRRED_PARMS]);
 	switch (parm->eaction) {
 	case TCA_EGRESS_MIRROR:
 	case TCA_EGRESS_REDIR:
 		break;
 	default:
 		return -EINVAL;
 	}
 	if (parm->ifindex) {
 		dev = __dev_get_by_index(net, parm->ifindex);
 		if (dev == NULL)
 			return -ENODEV;
 		switch (dev->type) {
 		case ARPHRD_TUNNEL:
 		case ARPHRD_TUNNEL6:
 		case ARPHRD_SIT:
 		case ARPHRD_IPGRE:
 		case ARPHRD_VOID:
 		case ARPHRD_NONE:
 			ok_push = 0;
 			break;
 		default:
 			ok_push = 1;
 			break;
 		}
 	} else {
 		dev = NULL;
 	}
 	pc = tcf_hash_check(parm->index, a, bind, &mirred_hash_info);
 	if (!pc) {
 		if (dev == NULL)
 			return -EINVAL;
 		pc = tcf_hash_create(parm->index, est, a, sizeof(*m), bind,
 				     &mirred_idx_gen, &mirred_hash_info);
 		if (IS_ERR(pc))
 			return PTR_ERR(pc);
 		ret = ACT_P_CREATED;
 	} else {
 		if (!ovr) {
 			tcf_mirred_release(to_mirred(pc), bind);
 			return -EEXIST;
 		}
 	}
 	m = to_mirred(pc);
 	spin_lock_bh(&m->tcf_lock);
 	m->tcf_action = parm->action;
 	m->tcfm_eaction = parm->eaction;
 	if (dev != NULL) {
 		m->tcfm_ifindex = parm->ifindex;
 		if (ret != ACT_P_CREATED)
 			dev_put(m->tcfm_dev);
 		dev_hold(dev);
 		m->tcfm_dev = dev;
 		m->tcfm_ok_push = ok_push;
 	}
 	spin_unlock_bh(&m->tcf_lock);
 	if (ret == ACT_P_CREATED) {
 		list_add(&m->tcfm_list, &mirred_list);
 		tcf_hash_insert(pc, &mirred_hash_info);
 	}
 	return ret;
 }
 static int tcf_mirred_cleanup(struct tc_action *a, int bind)
 {
 	struct tcf_mirred *m = a->priv;
 	if (m)
 		return tcf_mirred_release(m, bind);
 	return 0;
 }
 static int tcf_mirred(struct sk_buff *skb, const struct tc_action *a,
 		      struct tcf_result *res)
 {
 	struct tcf_mirred *m = a->priv;
 	struct net_device *dev;
 	struct sk_buff *skb2;
 	u32 at;
 	int retval, err = 1;
 	spin_lock(&m->tcf_lock);
 	m->tcf_tm.lastuse = jiffies;
 	bstats_update(&m->tcf_bstats, skb);
 	dev = m->tcfm_dev;
 	if (!dev) {
 		printk_once(KERN_NOTICE "tc mirred: target device is gone\n");
 		goto out;
 	}
 	if (!(dev->flags & IFF_UP)) {
 		net_notice_ratelimited("tc mirred to Houston: device %s is down\n",
 				       dev->name);
 		goto out;
 	}
 	at = G_TC_AT(skb->tc_verd);
 	skb2 = skb_act_clone(skb, GFP_ATOMIC, m->tcf_action);
 	if (skb2 == NULL)
 		goto out;
 	if (!(at & AT_EGRESS)) {
 		if (m->tcfm_ok_push)
 			skb_push(skb2, skb2->dev->hard_header_len);
 	}
 	/* mirror is always swallowed */
 	if (m->tcfm_eaction != TCA_EGRESS_MIRROR)
 		skb2->tc_verd = SET_TC_FROM(skb2->tc_verd, at);
 	skb2->skb_iif = skb->dev->ifindex;
 	skb2->dev = dev;
 	err = dev_queue_xmit(skb2);
 out:
 	if (err) {
 		m->tcf_qstats.overlimits++;
 		if (m->tcfm_eaction != TCA_EGRESS_MIRROR)
 			retval = TC_ACT_SHOT;
 		else
 			retval = m->tcf_action;
 	} else
 		retval = m->tcf_action;
 	spin_unlock(&m->tcf_lock);
 	return retval;
 }
 static int tcf_mirred_dump(struct sk_buff *skb, struct tc_action *a, int bind, int ref)
 {
 	unsigned char *b = skb_tail_pointer(skb);
 	struct tcf_mirred *m = a->priv;
 	struct tc_mirred opt = {
 		.index   = m->tcf_index,
 		.action  = m->tcf_action,
 		.refcnt  = m->tcf_refcnt - ref,
 		.bindcnt = m->tcf_bindcnt - bind,
 		.eaction = m->tcfm_eaction,
 		.ifindex = m->tcfm_ifindex,
 	};
 	struct tcf_t t;
 	if (nla_put(skb, TCA_MIRRED_PARMS, sizeof(opt), &opt))
 		goto nla_put_failure;
 	t.install = jiffies_to_clock_t(jiffies - m->tcf_tm.install);
 	t.lastuse = jiffies_to_clock_t(jiffies - m->tcf_tm.lastuse);
 	t.expires = jiffies_to_clock_t(m->tcf_tm.expires);
 	if (nla_put(skb, TCA_MIRRED_TM, sizeof(t), &t))
 		goto nla_put_failure;
 	return skb->len;
 nla_put_failure:
 	nlmsg_trim(skb, b);
 	return -1;
 }
 static int mirred_device_event(struct notifier_block *unused,
 			       unsigned long event, void *ptr)
 {
 	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
 	struct tcf_mirred *m;
 	if (event == NETDEV_UNREGISTER)
 		list_for_each_entry(m, &mirred_list, tcfm_list) {
 			if (m->tcfm_dev == dev) {
 				dev_put(dev);
 				m->tcfm_dev = NULL;
 			}
 		}
 	return NOTIFY_DONE;
 }
 static struct notifier_block mirred_device_notifier = {
 	.notifier_call = mirred_device_event,
 };
 static struct tc_action_ops act_mirred_ops = {
 	.kind		=	"mirred",
 	.hinfo		=	&mirred_hash_info,
 	.type		=	TCA_ACT_MIRRED,
 	.capab		=	TCA_CAP_NONE,
 	.owner		=	THIS_MODULE,
 	.act		=	tcf_mirred,
 	.dump		=	tcf_mirred_dump,
 	.cleanup	=	tcf_mirred_cleanup,
 	.init		=	tcf_mirred_init,
-	.walk		=	tcf_generic_walker
 };
 MODULE_AUTHOR("Jamal Hadi Salim(2002)");
 MODULE_DESCRIPTION("Device Mirror/redirect actions");
 MODULE_LICENSE("GPL");
 static int __init mirred_init_module(void)
 {
 	int err = register_netdevice_notifier(&mirred_device_notifier);
 	if (err)
 		return err;
 	pr_info("Mirror/redirect action on\n");
 	return tcf_register_action(&act_mirred_ops);
 }
 static void __exit mirred_cleanup_module(void)
 {
 	unregister_netdevice_notifier(&mirred_device_notifier);
 	tcf_unregister_action(&act_mirred_ops);
 }
 module_init(mirred_init_module);
 module_exit(mirred_cleanup_module);

net/sched/act_nat.c

Diff comments View file @ 651a649

 /*
  * Stateless NAT actions
  *
  * Copyright (c) 2007 Herbert Xu <herbert@gondor.apana.org.au>
  *
  * 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/errno.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/netfilter.h>
 #include <linux/rtnetlink.h>
 #include <linux/skbuff.h>
 #include <linux/slab.h>
 #include <linux/spinlock.h>
 #include <linux/string.h>
 #include <linux/tc_act/tc_nat.h>
 #include <net/act_api.h>
 #include <net/icmp.h>
 #include <net/ip.h>
 #include <net/netlink.h>
 #include <net/tc_act/tc_nat.h>
 #include <net/tcp.h>
 #include <net/udp.h>
 #define NAT_TAB_MASK	15
 static struct tcf_common *tcf_nat_ht[NAT_TAB_MASK + 1];
 static u32 nat_idx_gen;
 static DEFINE_RWLOCK(nat_lock);
 static struct tcf_hashinfo nat_hash_info = {
 	.htab	=	tcf_nat_ht,
 	.hmask	=	NAT_TAB_MASK,
 	.lock	=	&nat_lock,
 };
 static const struct nla_policy nat_policy[TCA_NAT_MAX + 1] = {
 	[TCA_NAT_PARMS]	= { .len = sizeof(struct tc_nat) },
 };
 static int tcf_nat_init(struct net *net, struct nlattr *nla, struct nlattr *est,
 			struct tc_action *a, int ovr, int bind)
 {
 	struct nlattr *tb[TCA_NAT_MAX + 1];
 	struct tc_nat *parm;
 	int ret = 0, err;
 	struct tcf_nat *p;
 	struct tcf_common *pc;
 	if (nla == NULL)
 		return -EINVAL;
 	err = nla_parse_nested(tb, TCA_NAT_MAX, nla, nat_policy);
 	if (err < 0)
 		return err;
 	if (tb[TCA_NAT_PARMS] == NULL)
 		return -EINVAL;
 	parm = nla_data(tb[TCA_NAT_PARMS]);
 	pc = tcf_hash_check(parm->index, a, bind, &nat_hash_info);
 	if (!pc) {
 		pc = tcf_hash_create(parm->index, est, a, sizeof(*p), bind,
 				     &nat_idx_gen, &nat_hash_info);
 		if (IS_ERR(pc))
 			return PTR_ERR(pc);
 		p = to_tcf_nat(pc);
 		ret = ACT_P_CREATED;
 	} else {
 		p = to_tcf_nat(pc);
 		if (!ovr) {
 			tcf_hash_release(pc, bind, &nat_hash_info);
 			return -EEXIST;
 		}
 	}
 	spin_lock_bh(&p->tcf_lock);
 	p->old_addr = parm->old_addr;
 	p->new_addr = parm->new_addr;
 	p->mask = parm->mask;
 	p->flags = parm->flags;
 	p->tcf_action = parm->action;
 	spin_unlock_bh(&p->tcf_lock);
 	if (ret == ACT_P_CREATED)
 		tcf_hash_insert(pc, &nat_hash_info);
 	return ret;
 }
 static int tcf_nat_cleanup(struct tc_action *a, int bind)
 {
 	struct tcf_nat *p = a->priv;
 	return tcf_hash_release(&p->common, bind, &nat_hash_info);
 }
 static int tcf_nat(struct sk_buff *skb, const struct tc_action *a,
 		   struct tcf_result *res)
 {
 	struct tcf_nat *p = a->priv;
 	struct iphdr *iph;
 	__be32 old_addr;
 	__be32 new_addr;
 	__be32 mask;
 	__be32 addr;
 	int egress;
 	int action;
 	int ihl;
 	int noff;
 	spin_lock(&p->tcf_lock);
 	p->tcf_tm.lastuse = jiffies;
 	old_addr = p->old_addr;
 	new_addr = p->new_addr;
 	mask = p->mask;
 	egress = p->flags & TCA_NAT_FLAG_EGRESS;
 	action = p->tcf_action;
 	bstats_update(&p->tcf_bstats, skb);
 	spin_unlock(&p->tcf_lock);
 	if (unlikely(action == TC_ACT_SHOT))
 		goto drop;
 	noff = skb_network_offset(skb);
 	if (!pskb_may_pull(skb, sizeof(*iph) + noff))
 		goto drop;
 	iph = ip_hdr(skb);
 	if (egress)
 		addr = iph->saddr;
 	else
 		addr = iph->daddr;
 	if (!((old_addr ^ addr) & mask)) {
 		if (skb_cloned(skb) &&
 		    !skb_clone_writable(skb, sizeof(*iph) + noff) &&
 		    pskb_expand_head(skb, 0, 0, GFP_ATOMIC))
 			goto drop;
 		new_addr &= mask;
 		new_addr |= addr & ~mask;
 		/* Rewrite IP header */
 		iph = ip_hdr(skb);
 		if (egress)
 			iph->saddr = new_addr;
 		else
 			iph->daddr = new_addr;
 		csum_replace4(&iph->check, addr, new_addr);
 	} else if ((iph->frag_off & htons(IP_OFFSET)) ||
 		   iph->protocol != IPPROTO_ICMP) {
 		goto out;
 	}
 	ihl = iph->ihl * 4;
 	/* It would be nice to share code with stateful NAT. */
 	switch (iph->frag_off & htons(IP_OFFSET) ? 0 : iph->protocol) {
 	case IPPROTO_TCP:
 	{
 		struct tcphdr *tcph;
 		if (!pskb_may_pull(skb, ihl + sizeof(*tcph) + noff) ||
 		    (skb_cloned(skb) &&
 		     !skb_clone_writable(skb, ihl + sizeof(*tcph) + noff) &&
 		     pskb_expand_head(skb, 0, 0, GFP_ATOMIC)))
 			goto drop;
 		tcph = (void *)(skb_network_header(skb) + ihl);
 		inet_proto_csum_replace4(&tcph->check, skb, addr, new_addr, 1);
 		break;
 	}
 	case IPPROTO_UDP:
 	{
 		struct udphdr *udph;
 		if (!pskb_may_pull(skb, ihl + sizeof(*udph) + noff) ||
 		    (skb_cloned(skb) &&
 		     !skb_clone_writable(skb, ihl + sizeof(*udph) + noff) &&
 		     pskb_expand_head(skb, 0, 0, GFP_ATOMIC)))
 			goto drop;
 		udph = (void *)(skb_network_header(skb) + ihl);
 		if (udph->check || skb->ip_summed == CHECKSUM_PARTIAL) {
 			inet_proto_csum_replace4(&udph->check, skb, addr,
 						 new_addr, 1);
 			if (!udph->check)
 				udph->check = CSUM_MANGLED_0;
 		}
 		break;
 	}
 	case IPPROTO_ICMP:
 	{
 		struct icmphdr *icmph;
 		if (!pskb_may_pull(skb, ihl + sizeof(*icmph) + noff))
 			goto drop;
 		icmph = (void *)(skb_network_header(skb) + ihl);
 		if ((icmph->type != ICMP_DEST_UNREACH) &&
 		    (icmph->type != ICMP_TIME_EXCEEDED) &&
 		    (icmph->type != ICMP_PARAMETERPROB))
 			break;
 		if (!pskb_may_pull(skb, ihl + sizeof(*icmph) + sizeof(*iph) +
 					noff))
 			goto drop;
 		icmph = (void *)(skb_network_header(skb) + ihl);
 		iph = (void *)(icmph + 1);
 		if (egress)
 			addr = iph->daddr;
 		else
 			addr = iph->saddr;
 		if ((old_addr ^ addr) & mask)
 			break;
 		if (skb_cloned(skb) &&
 		    !skb_clone_writable(skb, ihl + sizeof(*icmph) +
 					     sizeof(*iph) + noff) &&
 		    pskb_expand_head(skb, 0, 0, GFP_ATOMIC))
 			goto drop;
 		icmph = (void *)(skb_network_header(skb) + ihl);
 		iph = (void *)(icmph + 1);
 		new_addr &= mask;
 		new_addr |= addr & ~mask;
 		/* XXX Fix up the inner checksums. */
 		if (egress)
 			iph->daddr = new_addr;
 		else
 			iph->saddr = new_addr;
 		inet_proto_csum_replace4(&icmph->checksum, skb, addr, new_addr,
 					 0);
 		break;
 	}
 	default:
 		break;
 	}
 out:
 	return action;
 drop:
 	spin_lock(&p->tcf_lock);
 	p->tcf_qstats.drops++;
 	spin_unlock(&p->tcf_lock);
 	return TC_ACT_SHOT;
 }
 static int tcf_nat_dump(struct sk_buff *skb, struct tc_action *a,
 			int bind, int ref)
 {
 	unsigned char *b = skb_tail_pointer(skb);
 	struct tcf_nat *p = a->priv;
 	struct tc_nat opt = {
 		.old_addr = p->old_addr,
 		.new_addr = p->new_addr,
 		.mask     = p->mask,
 		.flags    = p->flags,
 		.index    = p->tcf_index,
 		.action   = p->tcf_action,
 		.refcnt   = p->tcf_refcnt - ref,
 		.bindcnt  = p->tcf_bindcnt - bind,
 	};
 	struct tcf_t t;
 	if (nla_put(skb, TCA_NAT_PARMS, sizeof(opt), &opt))
 		goto nla_put_failure;
 	t.install = jiffies_to_clock_t(jiffies - p->tcf_tm.install);
 	t.lastuse = jiffies_to_clock_t(jiffies - p->tcf_tm.lastuse);
 	t.expires = jiffies_to_clock_t(p->tcf_tm.expires);
 	if (nla_put(skb, TCA_NAT_TM, sizeof(t), &t))
 		goto nla_put_failure;
 	return skb->len;
 nla_put_failure:
 	nlmsg_trim(skb, b);
 	return -1;
 }
 static struct tc_action_ops act_nat_ops = {
 	.kind		=	"nat",
 	.hinfo		=	&nat_hash_info,
 	.type		=	TCA_ACT_NAT,
 	.capab		=	TCA_CAP_NONE,
 	.owner		=	THIS_MODULE,
 	.act		=	tcf_nat,
 	.dump		=	tcf_nat_dump,
 	.cleanup	=	tcf_nat_cleanup,
 	.init		=	tcf_nat_init,
-	.walk		=	tcf_generic_walker
 };
 MODULE_DESCRIPTION("Stateless NAT actions");
 MODULE_LICENSE("GPL");
 static int __init nat_init_module(void)
 {
 	return tcf_register_action(&act_nat_ops);
 }
 static void __exit nat_cleanup_module(void)
 {
 	tcf_unregister_action(&act_nat_ops);
 }
 module_init(nat_init_module);
 module_exit(nat_cleanup_module);

net/sched/act_pedit.c

Diff comments View file @ 651a649

 /*
  * net/sched/pedit.c	Generic packet editor
  *
  *		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.
  *
  * Authors:	Jamal Hadi Salim (2002-4)
  */
 #include <linux/types.h>
 #include <linux/kernel.h>
 #include <linux/string.h>
 #include <linux/errno.h>
 #include <linux/skbuff.h>
 #include <linux/rtnetlink.h>
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <net/netlink.h>
 #include <net/pkt_sched.h>
 #include <linux/tc_act/tc_pedit.h>
 #include <net/tc_act/tc_pedit.h>
 #define PEDIT_TAB_MASK	15
 static struct tcf_common *tcf_pedit_ht[PEDIT_TAB_MASK + 1];
 static u32 pedit_idx_gen;
 static DEFINE_RWLOCK(pedit_lock);
 static struct tcf_hashinfo pedit_hash_info = {
 	.htab	=	tcf_pedit_ht,
 	.hmask	=	PEDIT_TAB_MASK,
 	.lock	=	&pedit_lock,
 };
 static const struct nla_policy pedit_policy[TCA_PEDIT_MAX + 1] = {
 	[TCA_PEDIT_PARMS]	= { .len = sizeof(struct tc_pedit) },
 };
 static int tcf_pedit_init(struct net *net, struct nlattr *nla,
 			  struct nlattr *est, struct tc_action *a,
 			  int ovr, int bind)
 {
 	struct nlattr *tb[TCA_PEDIT_MAX + 1];
 	struct tc_pedit *parm;
 	int ret = 0, err;
 	struct tcf_pedit *p;
 	struct tcf_common *pc;
 	struct tc_pedit_key *keys = NULL;
 	int ksize;
 	if (nla == NULL)
 		return -EINVAL;
 	err = nla_parse_nested(tb, TCA_PEDIT_MAX, nla, pedit_policy);
 	if (err < 0)
 		return err;
 	if (tb[TCA_PEDIT_PARMS] == NULL)
 		return -EINVAL;
 	parm = nla_data(tb[TCA_PEDIT_PARMS]);
 	ksize = parm->nkeys * sizeof(struct tc_pedit_key);
 	if (nla_len(tb[TCA_PEDIT_PARMS]) < sizeof(*parm) + ksize)
 		return -EINVAL;
 	pc = tcf_hash_check(parm->index, a, bind, &pedit_hash_info);
 	if (!pc) {
 		if (!parm->nkeys)
 			return -EINVAL;
 		pc = tcf_hash_create(parm->index, est, a, sizeof(*p), bind,
 				     &pedit_idx_gen, &pedit_hash_info);
 		if (IS_ERR(pc))
 			return PTR_ERR(pc);
 		p = to_pedit(pc);
 		keys = kmalloc(ksize, GFP_KERNEL);
 		if (keys == NULL) {
 			if (est)
 				gen_kill_estimator(&pc->tcfc_bstats,
 						   &pc->tcfc_rate_est);
 			kfree_rcu(pc, tcfc_rcu);
 			return -ENOMEM;
 		}
 		ret = ACT_P_CREATED;
 	} else {
 		p = to_pedit(pc);
 		if (!ovr) {
 			tcf_hash_release(pc, bind, &pedit_hash_info);
 			return -EEXIST;
 		}
 		if (p->tcfp_nkeys && p->tcfp_nkeys != parm->nkeys) {
 			keys = kmalloc(ksize, GFP_KERNEL);
 			if (keys == NULL)
 				return -ENOMEM;
 		}
 	}
 	spin_lock_bh(&p->tcf_lock);
 	p->tcfp_flags = parm->flags;
 	p->tcf_action = parm->action;
 	if (keys) {
 		kfree(p->tcfp_keys);
 		p->tcfp_keys = keys;
 		p->tcfp_nkeys = parm->nkeys;
 	}
 	memcpy(p->tcfp_keys, parm->keys, ksize);
 	spin_unlock_bh(&p->tcf_lock);
 	if (ret == ACT_P_CREATED)
 		tcf_hash_insert(pc, &pedit_hash_info);
 	return ret;
 }
 static int tcf_pedit_cleanup(struct tc_action *a, int bind)
 {
 	struct tcf_pedit *p = a->priv;
 	if (p) {
 		struct tc_pedit_key *keys = p->tcfp_keys;
 		if (tcf_hash_release(&p->common, bind, &pedit_hash_info)) {
 			kfree(keys);
 			return 1;
 		}
 	}
 	return 0;
 }
 static int tcf_pedit(struct sk_buff *skb, const struct tc_action *a,
 		     struct tcf_result *res)
 {
 	struct tcf_pedit *p = a->priv;
 	int i, munged = 0;
 	unsigned int off;
 	if (skb_unclone(skb, GFP_ATOMIC))
 		return p->tcf_action;
 	off = skb_network_offset(skb);
 	spin_lock(&p->tcf_lock);
 	p->tcf_tm.lastuse = jiffies;
 	if (p->tcfp_nkeys > 0) {
 		struct tc_pedit_key *tkey = p->tcfp_keys;
 		for (i = p->tcfp_nkeys; i > 0; i--, tkey++) {
 			u32 *ptr, _data;
 			int offset = tkey->off;
 			if (tkey->offmask) {
 				char *d, _d;
 				d = skb_header_pointer(skb, off + tkey->at, 1,
 						       &_d);
 				if (!d)
 					goto bad;
 				offset += (*d & tkey->offmask) >> tkey->shift;
 			}
 			if (offset % 4) {
 				pr_info("tc filter pedit"
 					" offset must be on 32 bit boundaries\n");
 				goto bad;
 			}
 			if (offset > 0 && offset > skb->len) {
 				pr_info("tc filter pedit"
 					" offset %d can't exceed pkt length %d\n",
 				       offset, skb->len);
 				goto bad;
 			}
 			ptr = skb_header_pointer(skb, off + offset, 4, &_data);
 			if (!ptr)
 				goto bad;
 			/* just do it, baby */
 			*ptr = ((*ptr & tkey->mask) ^ tkey->val);
 			if (ptr == &_data)
 				skb_store_bits(skb, off + offset, ptr, 4);
 			munged++;
 		}
 		if (munged)
 			skb->tc_verd = SET_TC_MUNGED(skb->tc_verd);
 		goto done;
 	} else
 		WARN(1, "pedit BUG: index %d\n", p->tcf_index);
 bad:
 	p->tcf_qstats.overlimits++;
 done:
 	bstats_update(&p->tcf_bstats, skb);
 	spin_unlock(&p->tcf_lock);
 	return p->tcf_action;
 }
 static int tcf_pedit_dump(struct sk_buff *skb, struct tc_action *a,
 			  int bind, int ref)
 {
 	unsigned char *b = skb_tail_pointer(skb);
 	struct tcf_pedit *p = a->priv;
 	struct tc_pedit *opt;
 	struct tcf_t t;
 	int s;
 	s = sizeof(*opt) + p->tcfp_nkeys * sizeof(struct tc_pedit_key);
 	/* netlink spinlocks held above us - must use ATOMIC */
 	opt = kzalloc(s, GFP_ATOMIC);
 	if (unlikely(!opt))
 		return -ENOBUFS;
 	memcpy(opt->keys, p->tcfp_keys,
 	       p->tcfp_nkeys * sizeof(struct tc_pedit_key));
 	opt->index = p->tcf_index;
 	opt->nkeys = p->tcfp_nkeys;
 	opt->flags = p->tcfp_flags;
 	opt->action = p->tcf_action;
 	opt->refcnt = p->tcf_refcnt - ref;
 	opt->bindcnt = p->tcf_bindcnt - bind;
 	if (nla_put(skb, TCA_PEDIT_PARMS, s, opt))
 		goto nla_put_failure;
 	t.install = jiffies_to_clock_t(jiffies - p->tcf_tm.install);
 	t.lastuse = jiffies_to_clock_t(jiffies - p->tcf_tm.lastuse);
 	t.expires = jiffies_to_clock_t(p->tcf_tm.expires);
 	if (nla_put(skb, TCA_PEDIT_TM, sizeof(t), &t))
 		goto nla_put_failure;
 	kfree(opt);
 	return skb->len;
 nla_put_failure:
 	nlmsg_trim(skb, b);
 	kfree(opt);
 	return -1;
 }
 static struct tc_action_ops act_pedit_ops = {
 	.kind		=	"pedit",
 	.hinfo		=	&pedit_hash_info,
 	.type		=	TCA_ACT_PEDIT,
 	.capab		=	TCA_CAP_NONE,
 	.owner		=	THIS_MODULE,
 	.act		=	tcf_pedit,
 	.dump		=	tcf_pedit_dump,
 	.cleanup	=	tcf_pedit_cleanup,
 	.init		=	tcf_pedit_init,
-	.walk		=	tcf_generic_walker
 };
 MODULE_AUTHOR("Jamal Hadi Salim(2002-4)");
 MODULE_DESCRIPTION("Generic Packet Editor actions");
 MODULE_LICENSE("GPL");
 static int __init pedit_init_module(void)
 {
 	return tcf_register_action(&act_pedit_ops);
 }
 static void __exit pedit_cleanup_module(void)
 {
 	tcf_unregister_action(&act_pedit_ops);
 }
 module_init(pedit_init_module);
 module_exit(pedit_cleanup_module);

net/sched/act_simple.c

Diff comments View file @ 651a649

 /*
  * net/sched/simp.c	Simple example of an action
  *
  *		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.
  *
  * Authors:	Jamal Hadi Salim (2005-8)
  *
  */
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/skbuff.h>
 #include <linux/rtnetlink.h>
 #include <net/netlink.h>
 #include <net/pkt_sched.h>
 #define TCA_ACT_SIMP 22
 #include <linux/tc_act/tc_defact.h>
 #include <net/tc_act/tc_defact.h>
 #define SIMP_TAB_MASK     7
 static struct tcf_common *tcf_simp_ht[SIMP_TAB_MASK + 1];
 static u32 simp_idx_gen;
 static DEFINE_RWLOCK(simp_lock);
 static struct tcf_hashinfo simp_hash_info = {
 	.htab	=	tcf_simp_ht,
 	.hmask	=	SIMP_TAB_MASK,
 	.lock	=	&simp_lock,
 };
 #define SIMP_MAX_DATA	32
 static int tcf_simp(struct sk_buff *skb, const struct tc_action *a,
 		    struct tcf_result *res)
 {
 	struct tcf_defact *d = a->priv;
 	spin_lock(&d->tcf_lock);
 	d->tcf_tm.lastuse = jiffies;
 	bstats_update(&d->tcf_bstats, skb);
 	/* print policy string followed by _ then packet count
 	 * Example if this was the 3rd packet and the string was "hello"
 	 * then it would look like "hello_3" (without quotes)
 	 */
 	pr_info("simple: %s_%d\n",
 	       (char *)d->tcfd_defdata, d->tcf_bstats.packets);
 	spin_unlock(&d->tcf_lock);
 	return d->tcf_action;
 }
 static int tcf_simp_release(struct tcf_defact *d, int bind)
 {
 	int ret = 0;
 	if (d) {
 		if (bind)
 			d->tcf_bindcnt--;
 		d->tcf_refcnt--;
 		if (d->tcf_bindcnt <= 0 && d->tcf_refcnt <= 0) {
 			kfree(d->tcfd_defdata);
 			tcf_hash_destroy(&d->common, &simp_hash_info);
 			ret = 1;
 		}
 	}
 	return ret;
 }
 static int alloc_defdata(struct tcf_defact *d, char *defdata)
 {
 	d->tcfd_defdata = kzalloc(SIMP_MAX_DATA, GFP_KERNEL);
 	if (unlikely(!d->tcfd_defdata))
 		return -ENOMEM;
 	strlcpy(d->tcfd_defdata, defdata, SIMP_MAX_DATA);
 	return 0;
 }
 static void reset_policy(struct tcf_defact *d, char *defdata,
 			 struct tc_defact *p)
 {
 	spin_lock_bh(&d->tcf_lock);
 	d->tcf_action = p->action;
 	memset(d->tcfd_defdata, 0, SIMP_MAX_DATA);
 	strlcpy(d->tcfd_defdata, defdata, SIMP_MAX_DATA);
 	spin_unlock_bh(&d->tcf_lock);
 }
 static const struct nla_policy simple_policy[TCA_DEF_MAX + 1] = {
 	[TCA_DEF_PARMS]	= { .len = sizeof(struct tc_defact) },
 	[TCA_DEF_DATA]	= { .type = NLA_STRING, .len = SIMP_MAX_DATA },
 };
 static int tcf_simp_init(struct net *net, struct nlattr *nla,
 			 struct nlattr *est, struct tc_action *a,
 			 int ovr, int bind)
 {
 	struct nlattr *tb[TCA_DEF_MAX + 1];
 	struct tc_defact *parm;
 	struct tcf_defact *d;
 	struct tcf_common *pc;
 	char *defdata;
 	int ret = 0, err;
 	if (nla == NULL)
 		return -EINVAL;
 	err = nla_parse_nested(tb, TCA_DEF_MAX, nla, simple_policy);
 	if (err < 0)
 		return err;
 	if (tb[TCA_DEF_PARMS] == NULL)
 		return -EINVAL;
 	if (tb[TCA_DEF_DATA] == NULL)
 		return -EINVAL;
 	parm = nla_data(tb[TCA_DEF_PARMS]);
 	defdata = nla_data(tb[TCA_DEF_DATA]);
 	pc = tcf_hash_check(parm->index, a, bind, &simp_hash_info);
 	if (!pc) {
 		pc = tcf_hash_create(parm->index, est, a, sizeof(*d), bind,
 				     &simp_idx_gen, &simp_hash_info);
 		if (IS_ERR(pc))
 			return PTR_ERR(pc);
 		d = to_defact(pc);
 		ret = alloc_defdata(d, defdata);
 		if (ret < 0) {
 			if (est)
 				gen_kill_estimator(&pc->tcfc_bstats,
 						   &pc->tcfc_rate_est);
 			kfree_rcu(pc, tcfc_rcu);
 			return ret;
 		}
 		d->tcf_action = parm->action;
 		ret = ACT_P_CREATED;
 	} else {
 		d = to_defact(pc);
 		if (!ovr) {
 			tcf_simp_release(d, bind);
 			return -EEXIST;
 		}
 		reset_policy(d, defdata, parm);
 	}
 	if (ret == ACT_P_CREATED)
 		tcf_hash_insert(pc, &simp_hash_info);
 	return ret;
 }
 static int tcf_simp_cleanup(struct tc_action *a, int bind)
 {
 	struct tcf_defact *d = a->priv;
 	if (d)
 		return tcf_simp_release(d, bind);
 	return 0;
 }
 static int tcf_simp_dump(struct sk_buff *skb, struct tc_action *a,
 			 int bind, int ref)
 {
 	unsigned char *b = skb_tail_pointer(skb);
 	struct tcf_defact *d = a->priv;
 	struct tc_defact opt = {
 		.index   = d->tcf_index,
 		.refcnt  = d->tcf_refcnt - ref,
 		.bindcnt = d->tcf_bindcnt - bind,
 		.action  = d->tcf_action,
 	};
 	struct tcf_t t;
 	if (nla_put(skb, TCA_DEF_PARMS, sizeof(opt), &opt) ||
 	    nla_put_string(skb, TCA_DEF_DATA, d->tcfd_defdata))
 		goto nla_put_failure;
 	t.install = jiffies_to_clock_t(jiffies - d->tcf_tm.install);
 	t.lastuse = jiffies_to_clock_t(jiffies - d->tcf_tm.lastuse);
 	t.expires = jiffies_to_clock_t(d->tcf_tm.expires);
 	if (nla_put(skb, TCA_DEF_TM, sizeof(t), &t))
 		goto nla_put_failure;
 	return skb->len;
 nla_put_failure:
 	nlmsg_trim(skb, b);
 	return -1;
 }
 static struct tc_action_ops act_simp_ops = {
 	.kind		=	"simple",
 	.hinfo		=	&simp_hash_info,
 	.type		=	TCA_ACT_SIMP,
 	.capab		=	TCA_CAP_NONE,
 	.owner		=	THIS_MODULE,
 	.act		=	tcf_simp,
 	.dump		=	tcf_simp_dump,
 	.cleanup	=	tcf_simp_cleanup,
 	.init		=	tcf_simp_init,
-	.walk		=	tcf_generic_walker,
 };
 MODULE_AUTHOR("Jamal Hadi Salim(2005)");
 MODULE_DESCRIPTION("Simple example action");
 MODULE_LICENSE("GPL");
 static int __init simp_init_module(void)
 {
 	int ret = tcf_register_action(&act_simp_ops);
 	if (!ret)
 		pr_info("Simple TC action Loaded\n");
 	return ret;
 }
 static void __exit simp_cleanup_module(void)
 {
 	tcf_unregister_action(&act_simp_ops);
 }
 module_init(simp_init_module);
 module_exit(simp_cleanup_module);

net/sched/act_skbedit.c

Diff comments View file @ 651a649

 /*
  * Copyright (c) 2008, Intel Corporation.
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms and conditions of the GNU General Public License,
  * version 2, as published by the Free Software Foundation.
  *
  * This program is distributed in the hope it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  * more details.
  *
  * You should have received a copy of the GNU General Public License along with
  * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
  * Place - Suite 330, Boston, MA 02111-1307 USA.
  *
  * Author: Alexander Duyck <alexander.h.duyck@intel.com>
  */
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/skbuff.h>
 #include <linux/rtnetlink.h>
 #include <net/netlink.h>
 #include <net/pkt_sched.h>
 #include <linux/tc_act/tc_skbedit.h>
 #include <net/tc_act/tc_skbedit.h>
 #define SKBEDIT_TAB_MASK     15
 static struct tcf_common *tcf_skbedit_ht[SKBEDIT_TAB_MASK + 1];
 static u32 skbedit_idx_gen;
 static DEFINE_RWLOCK(skbedit_lock);
 static struct tcf_hashinfo skbedit_hash_info = {
 	.htab	=	tcf_skbedit_ht,
 	.hmask	=	SKBEDIT_TAB_MASK,
 	.lock	=	&skbedit_lock,
 };
 static int tcf_skbedit(struct sk_buff *skb, const struct tc_action *a,
 		       struct tcf_result *res)
 {
 	struct tcf_skbedit *d = a->priv;
 	spin_lock(&d->tcf_lock);
 	d->tcf_tm.lastuse = jiffies;
 	bstats_update(&d->tcf_bstats, skb);
 	if (d->flags & SKBEDIT_F_PRIORITY)
 		skb->priority = d->priority;
 	if (d->flags & SKBEDIT_F_QUEUE_MAPPING &&
 	    skb->dev->real_num_tx_queues > d->queue_mapping)
 		skb_set_queue_mapping(skb, d->queue_mapping);
 	if (d->flags & SKBEDIT_F_MARK)
 		skb->mark = d->mark;
 	spin_unlock(&d->tcf_lock);
 	return d->tcf_action;
 }
 static const struct nla_policy skbedit_policy[TCA_SKBEDIT_MAX + 1] = {
 	[TCA_SKBEDIT_PARMS]		= { .len = sizeof(struct tc_skbedit) },
 	[TCA_SKBEDIT_PRIORITY]		= { .len = sizeof(u32) },
 	[TCA_SKBEDIT_QUEUE_MAPPING]	= { .len = sizeof(u16) },
 	[TCA_SKBEDIT_MARK]		= { .len = sizeof(u32) },
 };
 static int tcf_skbedit_init(struct net *net, struct nlattr *nla,
 			    struct nlattr *est, struct tc_action *a,
 			    int ovr, int bind)
 {
 	struct nlattr *tb[TCA_SKBEDIT_MAX + 1];
 	struct tc_skbedit *parm;
 	struct tcf_skbedit *d;
 	struct tcf_common *pc;
 	u32 flags = 0, *priority = NULL, *mark = NULL;
 	u16 *queue_mapping = NULL;
 	int ret = 0, err;
 	if (nla == NULL)
 		return -EINVAL;
 	err = nla_parse_nested(tb, TCA_SKBEDIT_MAX, nla, skbedit_policy);
 	if (err < 0)
 		return err;
 	if (tb[TCA_SKBEDIT_PARMS] == NULL)
 		return -EINVAL;
 	if (tb[TCA_SKBEDIT_PRIORITY] != NULL) {
 		flags |= SKBEDIT_F_PRIORITY;
 		priority = nla_data(tb[TCA_SKBEDIT_PRIORITY]);
 	}
 	if (tb[TCA_SKBEDIT_QUEUE_MAPPING] != NULL) {
 		flags |= SKBEDIT_F_QUEUE_MAPPING;
 		queue_mapping = nla_data(tb[TCA_SKBEDIT_QUEUE_MAPPING]);
 	}
 	if (tb[TCA_SKBEDIT_MARK] != NULL) {
 		flags |= SKBEDIT_F_MARK;
 		mark = nla_data(tb[TCA_SKBEDIT_MARK]);
 	}
 	if (!flags)
 		return -EINVAL;
 	parm = nla_data(tb[TCA_SKBEDIT_PARMS]);
 	pc = tcf_hash_check(parm->index, a, bind, &skbedit_hash_info);
 	if (!pc) {
 		pc = tcf_hash_create(parm->index, est, a, sizeof(*d), bind,
 				     &skbedit_idx_gen, &skbedit_hash_info);
 		if (IS_ERR(pc))
 			return PTR_ERR(pc);
 		d = to_skbedit(pc);
 		ret = ACT_P_CREATED;
 	} else {
 		d = to_skbedit(pc);
 		if (!ovr) {
 			tcf_hash_release(pc, bind, &skbedit_hash_info);
 			return -EEXIST;
 		}
 	}
 	spin_lock_bh(&d->tcf_lock);
 	d->flags = flags;
 	if (flags & SKBEDIT_F_PRIORITY)
 		d->priority = *priority;
 	if (flags & SKBEDIT_F_QUEUE_MAPPING)
 		d->queue_mapping = *queue_mapping;
 	if (flags & SKBEDIT_F_MARK)
 		d->mark = *mark;
 	d->tcf_action = parm->action;
 	spin_unlock_bh(&d->tcf_lock);
 	if (ret == ACT_P_CREATED)
 		tcf_hash_insert(pc, &skbedit_hash_info);
 	return ret;
 }
 static int tcf_skbedit_cleanup(struct tc_action *a, int bind)
 {
 	struct tcf_skbedit *d = a->priv;
 	if (d)
 		return tcf_hash_release(&d->common, bind, &skbedit_hash_info);
 	return 0;
 }
 static int tcf_skbedit_dump(struct sk_buff *skb, struct tc_action *a,
 			    int bind, int ref)
 {
 	unsigned char *b = skb_tail_pointer(skb);
 	struct tcf_skbedit *d = a->priv;
 	struct tc_skbedit opt = {
 		.index   = d->tcf_index,
 		.refcnt  = d->tcf_refcnt - ref,
 		.bindcnt = d->tcf_bindcnt - bind,
 		.action  = d->tcf_action,
 	};
 	struct tcf_t t;
 	if (nla_put(skb, TCA_SKBEDIT_PARMS, sizeof(opt), &opt))
 		goto nla_put_failure;
 	if ((d->flags & SKBEDIT_F_PRIORITY) &&
 	    nla_put(skb, TCA_SKBEDIT_PRIORITY, sizeof(d->priority),
 		    &d->priority))
 		goto nla_put_failure;
 	if ((d->flags & SKBEDIT_F_QUEUE_MAPPING) &&
 	    nla_put(skb, TCA_SKBEDIT_QUEUE_MAPPING,
 		    sizeof(d->queue_mapping), &d->queue_mapping))
 		goto nla_put_failure;
 	if ((d->flags & SKBEDIT_F_MARK) &&
 	    nla_put(skb, TCA_SKBEDIT_MARK, sizeof(d->mark),
 		    &d->mark))
 		goto nla_put_failure;
 	t.install = jiffies_to_clock_t(jiffies - d->tcf_tm.install);
 	t.lastuse = jiffies_to_clock_t(jiffies - d->tcf_tm.lastuse);
 	t.expires = jiffies_to_clock_t(d->tcf_tm.expires);
 	if (nla_put(skb, TCA_SKBEDIT_TM, sizeof(t), &t))
 		goto nla_put_failure;
 	return skb->len;
 nla_put_failure:
 	nlmsg_trim(skb, b);
 	return -1;
 }
 static struct tc_action_ops act_skbedit_ops = {
 	.kind		=	"skbedit",
 	.hinfo		=	&skbedit_hash_info,
 	.type		=	TCA_ACT_SKBEDIT,
 	.capab		=	TCA_CAP_NONE,
 	.owner		=	THIS_MODULE,
 	.act		=	tcf_skbedit,
 	.dump		=	tcf_skbedit_dump,
 	.cleanup	=	tcf_skbedit_cleanup,
 	.init		=	tcf_skbedit_init,
-	.walk		=	tcf_generic_walker,
 };
 MODULE_AUTHOR("Alexander Duyck, <alexander.h.duyck@intel.com>");
 MODULE_DESCRIPTION("SKB Editing");
 MODULE_LICENSE("GPL");
 static int __init skbedit_init_module(void)
 {
 	return tcf_register_action(&act_skbedit_ops);
 }
 static void __exit skbedit_cleanup_module(void)
 {
 	tcf_unregister_action(&act_skbedit_ops);
 }
 module_init(skbedit_init_module);
 module_exit(skbedit_cleanup_module);