1 /* 2 * net/sched/cls_fw.c Classifier mapping ipchains' fwmark to traffic class. 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: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru> 10 * 11 * Changes: 12 * Karlis Peisenieks <karlis@mt.lv> : 990415 : fw_walk off by one 13 * Karlis Peisenieks <karlis@mt.lv> : 990415 : fw_delete killed all the filter (and kernel). 14 * Alex <alex@pilotsoft.com> : 2004xxyy: Added Action extension 15 * 16 * JHS: We should remove the CONFIG_NET_CLS_IND from here 17 * eventually when the meta match extension is made available 18 * 19 */ 20 21 #include <linux/module.h> 22 #include <linux/slab.h> 23 #include <linux/types.h> 24 #include <linux/kernel.h> 25 #include <linux/string.h> 26 #include <linux/errno.h> 27 #include <linux/skbuff.h> 28 #include <net/netlink.h> 29 #include <net/act_api.h> 30 #include <net/pkt_cls.h> 31 32 #define HTSIZE 256 33 34 struct fw_head { 35 u32 mask; 36 struct fw_filter __rcu *ht[HTSIZE]; 37 struct rcu_head rcu; 38 }; 39 40 struct fw_filter { 41 struct fw_filter __rcu *next; 42 u32 id; 43 struct tcf_result res; 44 #ifdef CONFIG_NET_CLS_IND 45 int ifindex; 46 #endif /* CONFIG_NET_CLS_IND */ 47 struct tcf_exts exts; 48 struct tcf_proto *tp; 49 struct rcu_head rcu; 50 }; 51 52 static u32 fw_hash(u32 handle) 53 { 54 handle ^= (handle >> 16); 55 handle ^= (handle >> 8); 56 return handle % HTSIZE; 57 } 58 59 static int fw_classify(struct sk_buff *skb, const struct tcf_proto *tp, 60 struct tcf_result *res) 61 { 62 struct fw_head *head = rcu_dereference_bh(tp->root); 63 struct fw_filter *f; 64 int r; 65 u32 id = skb->mark; 66 67 if (head != NULL) { 68 id &= head->mask; 69 70 for (f = rcu_dereference_bh(head->ht[fw_hash(id)]); f; 71 f = rcu_dereference_bh(f->next)) { 72 if (f->id == id) { 73 *res = f->res; 74 #ifdef CONFIG_NET_CLS_IND 75 if (!tcf_match_indev(skb, f->ifindex)) 76 continue; 77 #endif /* CONFIG_NET_CLS_IND */ 78 r = tcf_exts_exec(skb, &f->exts, res); 79 if (r < 0) 80 continue; 81 82 return r; 83 } 84 } 85 } else { 86 /* old method */ 87 if (id && (TC_H_MAJ(id) == 0 || 88 !(TC_H_MAJ(id ^ tp->q->handle)))) { 89 res->classid = id; 90 res->class = 0; 91 return 0; 92 } 93 } 94 95 return -1; 96 } 97 98 static unsigned long fw_get(struct tcf_proto *tp, u32 handle) 99 { 100 struct fw_head *head = rtnl_dereference(tp->root); 101 struct fw_filter *f; 102 103 if (head == NULL) 104 return 0; 105 106 f = rtnl_dereference(head->ht[fw_hash(handle)]); 107 for (; f; f = rtnl_dereference(f->next)) { 108 if (f->id == handle) 109 return (unsigned long)f; 110 } 111 return 0; 112 } 113 114 static void fw_put(struct tcf_proto *tp, unsigned long f) 115 { 116 } 117 118 static int fw_init(struct tcf_proto *tp) 119 { 120 return 0; 121 } 122 123 static void fw_delete_filter(struct rcu_head *head) 124 { 125 struct fw_filter *f = container_of(head, struct fw_filter, rcu); 126 127 tcf_exts_destroy(&f->exts); 128 kfree(f); 129 } 130 131 static void fw_destroy(struct tcf_proto *tp) 132 { 133 struct fw_head *head = rtnl_dereference(tp->root); 134 struct fw_filter *f; 135 int h; 136 137 if (head == NULL) 138 return; 139 140 for (h = 0; h < HTSIZE; h++) { 141 while ((f = rtnl_dereference(head->ht[h])) != NULL) { 142 RCU_INIT_POINTER(head->ht[h], 143 rtnl_dereference(f->next)); 144 tcf_unbind_filter(tp, &f->res); 145 call_rcu(&f->rcu, fw_delete_filter); 146 } 147 } 148 RCU_INIT_POINTER(tp->root, NULL); 149 kfree_rcu(head, rcu); 150 } 151 152 static int fw_delete(struct tcf_proto *tp, unsigned long arg) 153 { 154 struct fw_head *head = rtnl_dereference(tp->root); 155 struct fw_filter *f = (struct fw_filter *)arg; 156 struct fw_filter __rcu **fp; 157 struct fw_filter *pfp; 158 159 if (head == NULL || f == NULL) 160 goto out; 161 162 fp = &head->ht[fw_hash(f->id)]; 163 164 for (pfp = rtnl_dereference(*fp); pfp; 165 fp = &pfp->next, pfp = rtnl_dereference(*fp)) { 166 if (pfp == f) { 167 RCU_INIT_POINTER(*fp, rtnl_dereference(f->next)); 168 tcf_unbind_filter(tp, &f->res); 169 call_rcu(&f->rcu, fw_delete_filter); 170 return 0; 171 } 172 } 173 out: 174 return -EINVAL; 175 } 176 177 static const struct nla_policy fw_policy[TCA_FW_MAX + 1] = { 178 [TCA_FW_CLASSID] = { .type = NLA_U32 }, 179 [TCA_FW_INDEV] = { .type = NLA_STRING, .len = IFNAMSIZ }, 180 [TCA_FW_MASK] = { .type = NLA_U32 }, 181 }; 182 183 static int 184 fw_change_attrs(struct net *net, struct tcf_proto *tp, struct fw_filter *f, 185 struct nlattr **tb, struct nlattr **tca, unsigned long base, bool ovr) 186 { 187 struct fw_head *head = rtnl_dereference(tp->root); 188 struct tcf_exts e; 189 u32 mask; 190 int err; 191 192 tcf_exts_init(&e, TCA_FW_ACT, TCA_FW_POLICE); 193 err = tcf_exts_validate(net, tp, tb, tca[TCA_RATE], &e, ovr); 194 if (err < 0) 195 return err; 196 197 if (tb[TCA_FW_CLASSID]) { 198 f->res.classid = nla_get_u32(tb[TCA_FW_CLASSID]); 199 tcf_bind_filter(tp, &f->res, base); 200 } 201 202 #ifdef CONFIG_NET_CLS_IND 203 if (tb[TCA_FW_INDEV]) { 204 int ret; 205 ret = tcf_change_indev(net, tb[TCA_FW_INDEV]); 206 if (ret < 0) { 207 err = ret; 208 goto errout; 209 } 210 f->ifindex = ret; 211 } 212 #endif /* CONFIG_NET_CLS_IND */ 213 214 err = -EINVAL; 215 if (tb[TCA_FW_MASK]) { 216 mask = nla_get_u32(tb[TCA_FW_MASK]); 217 if (mask != head->mask) 218 goto errout; 219 } else if (head->mask != 0xFFFFFFFF) 220 goto errout; 221 222 tcf_exts_change(tp, &f->exts, &e); 223 224 return 0; 225 errout: 226 tcf_exts_destroy(&e); 227 return err; 228 } 229 230 static int fw_change(struct net *net, struct sk_buff *in_skb, 231 struct tcf_proto *tp, unsigned long base, 232 u32 handle, 233 struct nlattr **tca, 234 unsigned long *arg, bool ovr) 235 { 236 struct fw_head *head = rtnl_dereference(tp->root); 237 struct fw_filter *f = (struct fw_filter *) *arg; 238 struct nlattr *opt = tca[TCA_OPTIONS]; 239 struct nlattr *tb[TCA_FW_MAX + 1]; 240 int err; 241 242 if (!opt) 243 return handle ? -EINVAL : 0; 244 245 err = nla_parse_nested(tb, TCA_FW_MAX, opt, fw_policy); 246 if (err < 0) 247 return err; 248 249 if (f) { 250 struct fw_filter *pfp, *fnew; 251 struct fw_filter __rcu **fp; 252 253 if (f->id != handle && handle) 254 return -EINVAL; 255 256 fnew = kzalloc(sizeof(struct fw_filter), GFP_KERNEL); 257 if (!fnew) 258 return -ENOBUFS; 259 260 fnew->id = f->id; 261 fnew->res = f->res; 262 #ifdef CONFIG_NET_CLS_IND 263 fnew->ifindex = f->ifindex; 264 #endif /* CONFIG_NET_CLS_IND */ 265 fnew->tp = f->tp; 266 267 tcf_exts_init(&fnew->exts, TCA_FW_ACT, TCA_FW_POLICE); 268 269 err = fw_change_attrs(net, tp, fnew, tb, tca, base, ovr); 270 if (err < 0) { 271 kfree(fnew); 272 return err; 273 } 274 275 fp = &head->ht[fw_hash(fnew->id)]; 276 for (pfp = rtnl_dereference(*fp); pfp; 277 fp = &pfp->next, pfp = rtnl_dereference(*fp)) 278 if (pfp == f) 279 break; 280 281 RCU_INIT_POINTER(fnew->next, rtnl_dereference(pfp->next)); 282 rcu_assign_pointer(*fp, fnew); 283 tcf_unbind_filter(tp, &f->res); 284 call_rcu(&f->rcu, fw_delete_filter); 285 286 *arg = (unsigned long)fnew; 287 return err; 288 } 289 290 if (!handle) 291 return -EINVAL; 292 293 if (head == NULL) { 294 u32 mask = 0xFFFFFFFF; 295 if (tb[TCA_FW_MASK]) 296 mask = nla_get_u32(tb[TCA_FW_MASK]); 297 298 head = kzalloc(sizeof(struct fw_head), GFP_KERNEL); 299 if (head == NULL) 300 return -ENOBUFS; 301 head->mask = mask; 302 303 rcu_assign_pointer(tp->root, head); 304 } 305 306 f = kzalloc(sizeof(struct fw_filter), GFP_KERNEL); 307 if (f == NULL) 308 return -ENOBUFS; 309 310 tcf_exts_init(&f->exts, TCA_FW_ACT, TCA_FW_POLICE); 311 f->id = handle; 312 f->tp = tp; 313 314 err = fw_change_attrs(net, tp, f, tb, tca, base, ovr); 315 if (err < 0) 316 goto errout; 317 318 RCU_INIT_POINTER(f->next, head->ht[fw_hash(handle)]); 319 rcu_assign_pointer(head->ht[fw_hash(handle)], f); 320 321 *arg = (unsigned long)f; 322 return 0; 323 324 errout: 325 kfree(f); 326 return err; 327 } 328 329 static void fw_walk(struct tcf_proto *tp, struct tcf_walker *arg) 330 { 331 struct fw_head *head = rtnl_dereference(tp->root); 332 int h; 333 334 if (head == NULL) 335 arg->stop = 1; 336 337 if (arg->stop) 338 return; 339 340 for (h = 0; h < HTSIZE; h++) { 341 struct fw_filter *f; 342 343 for (f = rtnl_dereference(head->ht[h]); f; 344 f = rtnl_dereference(f->next)) { 345 if (arg->count < arg->skip) { 346 arg->count++; 347 continue; 348 } 349 if (arg->fn(tp, (unsigned long)f, arg) < 0) { 350 arg->stop = 1; 351 return; 352 } 353 arg->count++; 354 } 355 } 356 } 357 358 static int fw_dump(struct net *net, struct tcf_proto *tp, unsigned long fh, 359 struct sk_buff *skb, struct tcmsg *t) 360 { 361 struct fw_head *head = rtnl_dereference(tp->root); 362 struct fw_filter *f = (struct fw_filter *)fh; 363 unsigned char *b = skb_tail_pointer(skb); 364 struct nlattr *nest; 365 366 if (f == NULL) 367 return skb->len; 368 369 t->tcm_handle = f->id; 370 371 if (!f->res.classid && !tcf_exts_is_available(&f->exts)) 372 return skb->len; 373 374 nest = nla_nest_start(skb, TCA_OPTIONS); 375 if (nest == NULL) 376 goto nla_put_failure; 377 378 if (f->res.classid && 379 nla_put_u32(skb, TCA_FW_CLASSID, f->res.classid)) 380 goto nla_put_failure; 381 #ifdef CONFIG_NET_CLS_IND 382 if (f->ifindex) { 383 struct net_device *dev; 384 dev = __dev_get_by_index(net, f->ifindex); 385 if (dev && nla_put_string(skb, TCA_FW_INDEV, dev->name)) 386 goto nla_put_failure; 387 } 388 #endif /* CONFIG_NET_CLS_IND */ 389 if (head->mask != 0xFFFFFFFF && 390 nla_put_u32(skb, TCA_FW_MASK, head->mask)) 391 goto nla_put_failure; 392 393 if (tcf_exts_dump(skb, &f->exts) < 0) 394 goto nla_put_failure; 395 396 nla_nest_end(skb, nest); 397 398 if (tcf_exts_dump_stats(skb, &f->exts) < 0) 399 goto nla_put_failure; 400 401 return skb->len; 402 403 nla_put_failure: 404 nlmsg_trim(skb, b); 405 return -1; 406 } 407 408 static struct tcf_proto_ops cls_fw_ops __read_mostly = { 409 .kind = "fw", 410 .classify = fw_classify, 411 .init = fw_init, 412 .destroy = fw_destroy, 413 .get = fw_get, 414 .put = fw_put, 415 .change = fw_change, 416 .delete = fw_delete, 417 .walk = fw_walk, 418 .dump = fw_dump, 419 .owner = THIS_MODULE, 420 }; 421 422 static int __init init_fw(void) 423 { 424 return register_tcf_proto_ops(&cls_fw_ops); 425 } 426 427 static void __exit exit_fw(void) 428 { 429 unregister_tcf_proto_ops(&cls_fw_ops); 430 } 431 432 module_init(init_fw) 433 module_exit(exit_fw) 434 MODULE_LICENSE("GPL"); 435