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 <net/netlink.h>
21 #include <net/pkt_sched.h>
22 #include <linux/tc_act/tc_pedit.h>
23 #include <net/tc_act/tc_pedit.h>
25 #define PEDIT_TAB_MASK 15
26 static struct tcf_common
*tcf_pedit_ht
[PEDIT_TAB_MASK
+ 1];
27 static u32 pedit_idx_gen
;
28 static DEFINE_RWLOCK(pedit_lock
);
30 static struct tcf_hashinfo pedit_hash_info
= {
32 .hmask
= PEDIT_TAB_MASK
,
36 static int tcf_pedit_init(struct nlattr
*nla
, struct nlattr
*est
,
37 struct tc_action
*a
, int ovr
, int bind
)
39 struct nlattr
*tb
[TCA_PEDIT_MAX
+ 1];
40 struct tc_pedit
*parm
;
43 struct tcf_common
*pc
;
44 struct tc_pedit_key
*keys
= NULL
;
50 err
= nla_parse_nested(tb
, TCA_PEDIT_MAX
, nla
, NULL
);
54 if (tb
[TCA_PEDIT_PARMS
] == NULL
||
55 nla_len(tb
[TCA_PEDIT_PARMS
]) < sizeof(*parm
))
57 parm
= nla_data(tb
[TCA_PEDIT_PARMS
]);
58 ksize
= parm
->nkeys
* sizeof(struct tc_pedit_key
);
59 if (nla_len(tb
[TCA_PEDIT_PARMS
]) < sizeof(*parm
) + ksize
)
62 pc
= tcf_hash_check(parm
->index
, a
, bind
, &pedit_hash_info
);
66 pc
= tcf_hash_create(parm
->index
, est
, a
, sizeof(*p
), bind
,
67 &pedit_idx_gen
, &pedit_hash_info
);
71 keys
= kmalloc(ksize
, GFP_KERNEL
);
80 tcf_hash_release(pc
, bind
, &pedit_hash_info
);
83 if (p
->tcfp_nkeys
&& p
->tcfp_nkeys
!= parm
->nkeys
) {
84 keys
= kmalloc(ksize
, GFP_KERNEL
);
90 spin_lock_bh(&p
->tcf_lock
);
91 p
->tcfp_flags
= parm
->flags
;
92 p
->tcf_action
= parm
->action
;
96 p
->tcfp_nkeys
= parm
->nkeys
;
98 memcpy(p
->tcfp_keys
, parm
->keys
, ksize
);
99 spin_unlock_bh(&p
->tcf_lock
);
100 if (ret
== ACT_P_CREATED
)
101 tcf_hash_insert(pc
, &pedit_hash_info
);
105 static int tcf_pedit_cleanup(struct tc_action
*a
, int bind
)
107 struct tcf_pedit
*p
= a
->priv
;
110 struct tc_pedit_key
*keys
= p
->tcfp_keys
;
111 if (tcf_hash_release(&p
->common
, bind
, &pedit_hash_info
)) {
119 static int tcf_pedit(struct sk_buff
*skb
, struct tc_action
*a
,
120 struct tcf_result
*res
)
122 struct tcf_pedit
*p
= a
->priv
;
126 if (!(skb
->tc_verd
& TC_OK2MUNGE
)) {
127 /* should we set skb->cloned? */
128 if (pskb_expand_head(skb
, 0, 0, GFP_ATOMIC
)) {
129 return p
->tcf_action
;
133 pptr
= skb_network_header(skb
);
135 spin_lock(&p
->tcf_lock
);
137 p
->tcf_tm
.lastuse
= jiffies
;
139 if (p
->tcfp_nkeys
> 0) {
140 struct tc_pedit_key
*tkey
= p
->tcfp_keys
;
142 for (i
= p
->tcfp_nkeys
; i
> 0; i
--, tkey
++) {
144 int offset
= tkey
->off
;
147 if (skb
->len
> tkey
->at
) {
148 char *j
= pptr
+ tkey
->at
;
149 offset
+= ((*j
& tkey
->offmask
) >>
157 printk("offset must be on 32 bit boundaries\n");
160 if (offset
> 0 && offset
> skb
->len
) {
161 printk("offset %d cant exceed pkt length %d\n",
166 ptr
= (u32
*)(pptr
+offset
);
167 /* just do it, baby */
168 *ptr
= ((*ptr
& tkey
->mask
) ^ tkey
->val
);
173 skb
->tc_verd
= SET_TC_MUNGED(skb
->tc_verd
);
176 printk("pedit BUG: index %d\n", p
->tcf_index
);
180 p
->tcf_qstats
.overlimits
++;
182 p
->tcf_bstats
.bytes
+= skb
->len
;
183 p
->tcf_bstats
.packets
++;
184 spin_unlock(&p
->tcf_lock
);
185 return p
->tcf_action
;
188 static int tcf_pedit_dump(struct sk_buff
*skb
, struct tc_action
*a
,
191 unsigned char *b
= skb_tail_pointer(skb
);
192 struct tcf_pedit
*p
= a
->priv
;
193 struct tc_pedit
*opt
;
197 s
= sizeof(*opt
) + p
->tcfp_nkeys
* sizeof(struct tc_pedit_key
);
199 /* netlink spinlocks held above us - must use ATOMIC */
200 opt
= kzalloc(s
, GFP_ATOMIC
);
204 memcpy(opt
->keys
, p
->tcfp_keys
,
205 p
->tcfp_nkeys
* sizeof(struct tc_pedit_key
));
206 opt
->index
= p
->tcf_index
;
207 opt
->nkeys
= p
->tcfp_nkeys
;
208 opt
->flags
= p
->tcfp_flags
;
209 opt
->action
= p
->tcf_action
;
210 opt
->refcnt
= p
->tcf_refcnt
- ref
;
211 opt
->bindcnt
= p
->tcf_bindcnt
- bind
;
213 NLA_PUT(skb
, TCA_PEDIT_PARMS
, s
, opt
);
214 t
.install
= jiffies_to_clock_t(jiffies
- p
->tcf_tm
.install
);
215 t
.lastuse
= jiffies_to_clock_t(jiffies
- p
->tcf_tm
.lastuse
);
216 t
.expires
= jiffies_to_clock_t(p
->tcf_tm
.expires
);
217 NLA_PUT(skb
, TCA_PEDIT_TM
, sizeof(t
), &t
);
227 static struct tc_action_ops act_pedit_ops
= {
229 .hinfo
= &pedit_hash_info
,
230 .type
= TCA_ACT_PEDIT
,
231 .capab
= TCA_CAP_NONE
,
232 .owner
= THIS_MODULE
,
234 .dump
= tcf_pedit_dump
,
235 .cleanup
= tcf_pedit_cleanup
,
236 .lookup
= tcf_hash_search
,
237 .init
= tcf_pedit_init
,
238 .walk
= tcf_generic_walker
241 MODULE_AUTHOR("Jamal Hadi Salim(2002-4)");
242 MODULE_DESCRIPTION("Generic Packet Editor actions");
243 MODULE_LICENSE("GPL");
245 static int __init
pedit_init_module(void)
247 return tcf_register_action(&act_pedit_ops
);
250 static void __exit
pedit_cleanup_module(void)
252 tcf_unregister_action(&act_pedit_ops
);
255 module_init(pedit_init_module
);
256 module_exit(pedit_cleanup_module
);