2 * net/sched/pedit.c Generic packet editor
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version
7 * 2 of the License, or (at your option) any later version.
9 * Authors: Jamal Hadi Salim (2002-4)
12 #include <linux/types.h>
13 #include <linux/kernel.h>
14 #include <linux/string.h>
15 #include <linux/errno.h>
16 #include <linux/skbuff.h>
17 #include <linux/rtnetlink.h>
18 #include <linux/module.h>
19 #include <linux/init.h>
20 #include <linux/slab.h>
21 #include <net/netlink.h>
22 #include <net/pkt_sched.h>
23 #include <linux/tc_act/tc_pedit.h>
24 #include <net/tc_act/tc_pedit.h>
26 #define PEDIT_TAB_MASK 15
27 static struct tcf_common
*tcf_pedit_ht
[PEDIT_TAB_MASK
+ 1];
28 static u32 pedit_idx_gen
;
29 static DEFINE_RWLOCK(pedit_lock
);
31 static struct tcf_hashinfo pedit_hash_info
= {
33 .hmask
= PEDIT_TAB_MASK
,
37 static const struct nla_policy pedit_policy
[TCA_PEDIT_MAX
+ 1] = {
38 [TCA_PEDIT_PARMS
] = { .len
= sizeof(struct tc_pedit
) },
41 static int tcf_pedit_init(struct net
*net
, struct nlattr
*nla
,
42 struct nlattr
*est
, struct tc_action
*a
,
45 struct nlattr
*tb
[TCA_PEDIT_MAX
+ 1];
46 struct tc_pedit
*parm
;
49 struct tcf_common
*pc
;
50 struct tc_pedit_key
*keys
= NULL
;
56 err
= nla_parse_nested(tb
, TCA_PEDIT_MAX
, nla
, pedit_policy
);
60 if (tb
[TCA_PEDIT_PARMS
] == NULL
)
62 parm
= nla_data(tb
[TCA_PEDIT_PARMS
]);
63 ksize
= parm
->nkeys
* sizeof(struct tc_pedit_key
);
64 if (nla_len(tb
[TCA_PEDIT_PARMS
]) < sizeof(*parm
) + ksize
)
67 pc
= tcf_hash_check(parm
->index
, a
, bind
, &pedit_hash_info
);
71 pc
= tcf_hash_create(parm
->index
, est
, a
, sizeof(*p
), bind
,
72 &pedit_idx_gen
, &pedit_hash_info
);
76 keys
= kmalloc(ksize
, GFP_KERNEL
);
79 gen_kill_estimator(&pc
->tcfc_bstats
,
81 kfree_rcu(pc
, tcfc_rcu
);
88 tcf_hash_release(pc
, bind
, &pedit_hash_info
);
91 if (p
->tcfp_nkeys
&& p
->tcfp_nkeys
!= parm
->nkeys
) {
92 keys
= kmalloc(ksize
, GFP_KERNEL
);
98 spin_lock_bh(&p
->tcf_lock
);
99 p
->tcfp_flags
= parm
->flags
;
100 p
->tcf_action
= parm
->action
;
104 p
->tcfp_nkeys
= parm
->nkeys
;
106 memcpy(p
->tcfp_keys
, parm
->keys
, ksize
);
107 spin_unlock_bh(&p
->tcf_lock
);
108 if (ret
== ACT_P_CREATED
)
109 tcf_hash_insert(pc
, &pedit_hash_info
);
113 static int tcf_pedit_cleanup(struct tc_action
*a
, int bind
)
115 struct tcf_pedit
*p
= a
->priv
;
118 struct tc_pedit_key
*keys
= p
->tcfp_keys
;
119 if (tcf_hash_release(&p
->common
, bind
, &pedit_hash_info
)) {
127 static int tcf_pedit(struct sk_buff
*skb
, const struct tc_action
*a
,
128 struct tcf_result
*res
)
130 struct tcf_pedit
*p
= a
->priv
;
134 if (skb_cloned(skb
) &&
135 pskb_expand_head(skb
, 0, 0, GFP_ATOMIC
))
136 return p
->tcf_action
;
138 off
= skb_network_offset(skb
);
140 spin_lock(&p
->tcf_lock
);
142 p
->tcf_tm
.lastuse
= jiffies
;
144 if (p
->tcfp_nkeys
> 0) {
145 struct tc_pedit_key
*tkey
= p
->tcfp_keys
;
147 for (i
= p
->tcfp_nkeys
; i
> 0; i
--, tkey
++) {
149 int offset
= tkey
->off
;
154 d
= skb_header_pointer(skb
, off
+ tkey
->at
, 1,
158 offset
+= (*d
& tkey
->offmask
) >> tkey
->shift
;
162 pr_info("tc filter pedit"
163 " offset must be on 32 bit boundaries\n");
166 if (offset
> 0 && offset
> skb
->len
) {
167 pr_info("tc filter pedit"
168 " offset %d can't exceed pkt length %d\n",
173 ptr
= skb_header_pointer(skb
, off
+ offset
, 4, &_data
);
176 /* just do it, baby */
177 *ptr
= ((*ptr
& tkey
->mask
) ^ tkey
->val
);
179 skb_store_bits(skb
, off
+ offset
, ptr
, 4);
184 skb
->tc_verd
= SET_TC_MUNGED(skb
->tc_verd
);
187 WARN(1, "pedit BUG: index %d\n", p
->tcf_index
);
190 p
->tcf_qstats
.overlimits
++;
192 bstats_update(&p
->tcf_bstats
, skb
);
193 spin_unlock(&p
->tcf_lock
);
194 return p
->tcf_action
;
197 static int tcf_pedit_dump(struct sk_buff
*skb
, struct tc_action
*a
,
200 unsigned char *b
= skb_tail_pointer(skb
);
201 struct tcf_pedit
*p
= a
->priv
;
202 struct tc_pedit
*opt
;
206 s
= sizeof(*opt
) + p
->tcfp_nkeys
* sizeof(struct tc_pedit_key
);
208 /* netlink spinlocks held above us - must use ATOMIC */
209 opt
= kzalloc(s
, GFP_ATOMIC
);
213 memcpy(opt
->keys
, p
->tcfp_keys
,
214 p
->tcfp_nkeys
* sizeof(struct tc_pedit_key
));
215 opt
->index
= p
->tcf_index
;
216 opt
->nkeys
= p
->tcfp_nkeys
;
217 opt
->flags
= p
->tcfp_flags
;
218 opt
->action
= p
->tcf_action
;
219 opt
->refcnt
= p
->tcf_refcnt
- ref
;
220 opt
->bindcnt
= p
->tcf_bindcnt
- bind
;
222 if (nla_put(skb
, TCA_PEDIT_PARMS
, s
, opt
))
223 goto nla_put_failure
;
224 t
.install
= jiffies_to_clock_t(jiffies
- p
->tcf_tm
.install
);
225 t
.lastuse
= jiffies_to_clock_t(jiffies
- p
->tcf_tm
.lastuse
);
226 t
.expires
= jiffies_to_clock_t(p
->tcf_tm
.expires
);
227 if (nla_put(skb
, TCA_PEDIT_TM
, sizeof(t
), &t
))
228 goto nla_put_failure
;
238 static struct tc_action_ops act_pedit_ops
= {
240 .hinfo
= &pedit_hash_info
,
241 .type
= TCA_ACT_PEDIT
,
242 .capab
= TCA_CAP_NONE
,
243 .owner
= THIS_MODULE
,
245 .dump
= tcf_pedit_dump
,
246 .cleanup
= tcf_pedit_cleanup
,
247 .lookup
= tcf_hash_search
,
248 .init
= tcf_pedit_init
,
249 .walk
= tcf_generic_walker
252 MODULE_AUTHOR("Jamal Hadi Salim(2002-4)");
253 MODULE_DESCRIPTION("Generic Packet Editor actions");
254 MODULE_LICENSE("GPL");
256 static int __init
pedit_init_module(void)
258 return tcf_register_action(&act_pedit_ops
);
261 static void __exit
pedit_cleanup_module(void)
263 tcf_unregister_action(&act_pedit_ops
);
266 module_init(pedit_init_module
);
267 module_exit(pedit_cleanup_module
);