1 /* 2 * net/sched/act_pedit.c Generic packet editor 3 * 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. 8 * 9 * Authors: Jamal Hadi Salim (2002-4) 10 */ 11 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> 25 26 #define PEDIT_TAB_MASK 15 27 28 static int pedit_net_id; 29 30 static const struct nla_policy pedit_policy[TCA_PEDIT_MAX + 1] = { 31 [TCA_PEDIT_PARMS] = { .len = sizeof(struct tc_pedit) }, 32 }; 33 34 static int tcf_pedit_init(struct net *net, struct nlattr *nla, 35 struct nlattr *est, struct tc_action *a, 36 int ovr, int bind) 37 { 38 struct tc_action_net *tn = net_generic(net, pedit_net_id); 39 struct nlattr *tb[TCA_PEDIT_MAX + 1]; 40 struct tc_pedit *parm; 41 int ret = 0, err; 42 struct tcf_pedit *p; 43 struct tc_pedit_key *keys = NULL; 44 int ksize; 45 46 if (nla == NULL) 47 return -EINVAL; 48 49 err = nla_parse_nested(tb, TCA_PEDIT_MAX, nla, pedit_policy); 50 if (err < 0) 51 return err; 52 53 if (tb[TCA_PEDIT_PARMS] == NULL) 54 return -EINVAL; 55 parm = nla_data(tb[TCA_PEDIT_PARMS]); 56 ksize = parm->nkeys * sizeof(struct tc_pedit_key); 57 if (nla_len(tb[TCA_PEDIT_PARMS]) < sizeof(*parm) + ksize) 58 return -EINVAL; 59 60 if (!tcf_hash_check(tn, parm->index, a, bind)) { 61 if (!parm->nkeys) 62 return -EINVAL; 63 ret = tcf_hash_create(tn, parm->index, est, a, 64 sizeof(*p), bind, false); 65 if (ret) 66 return ret; 67 p = to_pedit(a); 68 keys = kmalloc(ksize, GFP_KERNEL); 69 if (keys == NULL) { 70 tcf_hash_cleanup(a, est); 71 return -ENOMEM; 72 } 73 ret = ACT_P_CREATED; 74 } else { 75 if (bind) 76 return 0; 77 tcf_hash_release(a, bind); 78 if (!ovr) 79 return -EEXIST; 80 p = to_pedit(a); 81 if (p->tcfp_nkeys && p->tcfp_nkeys != parm->nkeys) { 82 keys = kmalloc(ksize, GFP_KERNEL); 83 if (keys == NULL) 84 return -ENOMEM; 85 } 86 } 87 88 spin_lock_bh(&p->tcf_lock); 89 p->tcfp_flags = parm->flags; 90 p->tcf_action = parm->action; 91 if (keys) { 92 kfree(p->tcfp_keys); 93 p->tcfp_keys = keys; 94 p->tcfp_nkeys = parm->nkeys; 95 } 96 memcpy(p->tcfp_keys, parm->keys, ksize); 97 spin_unlock_bh(&p->tcf_lock); 98 if (ret == ACT_P_CREATED) 99 tcf_hash_insert(tn, a); 100 return ret; 101 } 102 103 static void tcf_pedit_cleanup(struct tc_action *a, int bind) 104 { 105 struct tcf_pedit *p = a->priv; 106 struct tc_pedit_key *keys = p->tcfp_keys; 107 kfree(keys); 108 } 109 110 static int tcf_pedit(struct sk_buff *skb, const struct tc_action *a, 111 struct tcf_result *res) 112 { 113 struct tcf_pedit *p = a->priv; 114 int i; 115 unsigned int off; 116 117 if (skb_unclone(skb, GFP_ATOMIC)) 118 return p->tcf_action; 119 120 off = skb_network_offset(skb); 121 122 spin_lock(&p->tcf_lock); 123 124 p->tcf_tm.lastuse = jiffies; 125 126 if (p->tcfp_nkeys > 0) { 127 struct tc_pedit_key *tkey = p->tcfp_keys; 128 129 for (i = p->tcfp_nkeys; i > 0; i--, tkey++) { 130 u32 *ptr, _data; 131 int offset = tkey->off; 132 133 if (tkey->offmask) { 134 char *d, _d; 135 136 d = skb_header_pointer(skb, off + tkey->at, 1, 137 &_d); 138 if (!d) 139 goto bad; 140 offset += (*d & tkey->offmask) >> tkey->shift; 141 } 142 143 if (offset % 4) { 144 pr_info("tc filter pedit" 145 " offset must be on 32 bit boundaries\n"); 146 goto bad; 147 } 148 if (offset > 0 && offset > skb->len) { 149 pr_info("tc filter pedit" 150 " offset %d can't exceed pkt length %d\n", 151 offset, skb->len); 152 goto bad; 153 } 154 155 ptr = skb_header_pointer(skb, off + offset, 4, &_data); 156 if (!ptr) 157 goto bad; 158 /* just do it, baby */ 159 *ptr = ((*ptr & tkey->mask) ^ tkey->val); 160 if (ptr == &_data) 161 skb_store_bits(skb, off + offset, ptr, 4); 162 } 163 164 goto done; 165 } else 166 WARN(1, "pedit BUG: index %d\n", p->tcf_index); 167 168 bad: 169 p->tcf_qstats.overlimits++; 170 done: 171 bstats_update(&p->tcf_bstats, skb); 172 spin_unlock(&p->tcf_lock); 173 return p->tcf_action; 174 } 175 176 static int tcf_pedit_dump(struct sk_buff *skb, struct tc_action *a, 177 int bind, int ref) 178 { 179 unsigned char *b = skb_tail_pointer(skb); 180 struct tcf_pedit *p = a->priv; 181 struct tc_pedit *opt; 182 struct tcf_t t; 183 int s; 184 185 s = sizeof(*opt) + p->tcfp_nkeys * sizeof(struct tc_pedit_key); 186 187 /* netlink spinlocks held above us - must use ATOMIC */ 188 opt = kzalloc(s, GFP_ATOMIC); 189 if (unlikely(!opt)) 190 return -ENOBUFS; 191 192 memcpy(opt->keys, p->tcfp_keys, 193 p->tcfp_nkeys * sizeof(struct tc_pedit_key)); 194 opt->index = p->tcf_index; 195 opt->nkeys = p->tcfp_nkeys; 196 opt->flags = p->tcfp_flags; 197 opt->action = p->tcf_action; 198 opt->refcnt = p->tcf_refcnt - ref; 199 opt->bindcnt = p->tcf_bindcnt - bind; 200 201 if (nla_put(skb, TCA_PEDIT_PARMS, s, opt)) 202 goto nla_put_failure; 203 t.install = jiffies_to_clock_t(jiffies - p->tcf_tm.install); 204 t.lastuse = jiffies_to_clock_t(jiffies - p->tcf_tm.lastuse); 205 t.expires = jiffies_to_clock_t(p->tcf_tm.expires); 206 if (nla_put_64bit(skb, TCA_PEDIT_TM, sizeof(t), &t, TCA_PEDIT_PAD)) 207 goto nla_put_failure; 208 kfree(opt); 209 return skb->len; 210 211 nla_put_failure: 212 nlmsg_trim(skb, b); 213 kfree(opt); 214 return -1; 215 } 216 217 static int tcf_pedit_walker(struct net *net, struct sk_buff *skb, 218 struct netlink_callback *cb, int type, 219 struct tc_action *a) 220 { 221 struct tc_action_net *tn = net_generic(net, pedit_net_id); 222 223 return tcf_generic_walker(tn, skb, cb, type, a); 224 } 225 226 static int tcf_pedit_search(struct net *net, struct tc_action *a, u32 index) 227 { 228 struct tc_action_net *tn = net_generic(net, pedit_net_id); 229 230 return tcf_hash_search(tn, a, index); 231 } 232 233 static struct tc_action_ops act_pedit_ops = { 234 .kind = "pedit", 235 .type = TCA_ACT_PEDIT, 236 .owner = THIS_MODULE, 237 .act = tcf_pedit, 238 .dump = tcf_pedit_dump, 239 .cleanup = tcf_pedit_cleanup, 240 .init = tcf_pedit_init, 241 .walk = tcf_pedit_walker, 242 .lookup = tcf_pedit_search, 243 }; 244 245 static __net_init int pedit_init_net(struct net *net) 246 { 247 struct tc_action_net *tn = net_generic(net, pedit_net_id); 248 249 return tc_action_net_init(tn, &act_pedit_ops, PEDIT_TAB_MASK); 250 } 251 252 static void __net_exit pedit_exit_net(struct net *net) 253 { 254 struct tc_action_net *tn = net_generic(net, pedit_net_id); 255 256 tc_action_net_exit(tn); 257 } 258 259 static struct pernet_operations pedit_net_ops = { 260 .init = pedit_init_net, 261 .exit = pedit_exit_net, 262 .id = &pedit_net_id, 263 .size = sizeof(struct tc_action_net), 264 }; 265 266 MODULE_AUTHOR("Jamal Hadi Salim(2002-4)"); 267 MODULE_DESCRIPTION("Generic Packet Editor actions"); 268 MODULE_LICENSE("GPL"); 269 270 static int __init pedit_init_module(void) 271 { 272 return tcf_register_action(&act_pedit_ops, &pedit_net_ops); 273 } 274 275 static void __exit pedit_cleanup_module(void) 276 { 277 tcf_unregister_action(&act_pedit_ops, &pedit_net_ops); 278 } 279 280 module_init(pedit_init_module); 281 module_exit(pedit_cleanup_module); 282 283