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: classify the packet using its skb mark. */ 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 int fw_init(struct tcf_proto *tp) 115 { 116 /* We don't allocate fw_head here, because in the old method 117 * we don't need it at all. 118 */ 119 return 0; 120 } 121 122 static void fw_delete_filter(struct rcu_head *head) 123 { 124 struct fw_filter *f = container_of(head, struct fw_filter, rcu); 125 126 tcf_exts_destroy(&f->exts); 127 kfree(f); 128 } 129 130 static bool fw_destroy(struct tcf_proto *tp, bool force) 131 { 132 struct fw_head *head = rtnl_dereference(tp->root); 133 struct fw_filter *f; 134 int h; 135 136 if (head == NULL) 137 return true; 138 139 if (!force) { 140 for (h = 0; h < HTSIZE; h++) 141 if (rcu_access_pointer(head->ht[h])) 142 return false; 143 } 144 145 for (h = 0; h < HTSIZE; h++) { 146 while ((f = rtnl_dereference(head->ht[h])) != NULL) { 147 RCU_INIT_POINTER(head->ht[h], 148 rtnl_dereference(f->next)); 149 tcf_unbind_filter(tp, &f->res); 150 call_rcu(&f->rcu, fw_delete_filter); 151 } 152 } 153 RCU_INIT_POINTER(tp->root, NULL); 154 kfree_rcu(head, rcu); 155 return true; 156 } 157 158 static int fw_delete(struct tcf_proto *tp, unsigned long arg) 159 { 160 struct fw_head *head = rtnl_dereference(tp->root); 161 struct fw_filter *f = (struct fw_filter *)arg; 162 struct fw_filter __rcu **fp; 163 struct fw_filter *pfp; 164 165 if (head == NULL || f == NULL) 166 goto out; 167 168 fp = &head->ht[fw_hash(f->id)]; 169 170 for (pfp = rtnl_dereference(*fp); pfp; 171 fp = &pfp->next, pfp = rtnl_dereference(*fp)) { 172 if (pfp == f) { 173 RCU_INIT_POINTER(*fp, rtnl_dereference(f->next)); 174 tcf_unbind_filter(tp, &f->res); 175 call_rcu(&f->rcu, fw_delete_filter); 176 return 0; 177 } 178 } 179 out: 180 return -EINVAL; 181 } 182 183 static const struct nla_policy fw_policy[TCA_FW_MAX + 1] = { 184 [TCA_FW_CLASSID] = { .type = NLA_U32 }, 185 [TCA_FW_INDEV] = { .type = NLA_STRING, .len = IFNAMSIZ }, 186 [TCA_FW_MASK] = { .type = NLA_U32 }, 187 }; 188 189 static int 190 fw_change_attrs(struct net *net, struct tcf_proto *tp, struct fw_filter *f, 191 struct nlattr **tb, struct nlattr **tca, unsigned long base, bool ovr) 192 { 193 struct fw_head *head = rtnl_dereference(tp->root); 194 struct tcf_exts e; 195 u32 mask; 196 int err; 197 198 tcf_exts_init(&e, TCA_FW_ACT, TCA_FW_POLICE); 199 err = tcf_exts_validate(net, tp, tb, tca[TCA_RATE], &e, ovr); 200 if (err < 0) 201 return err; 202 203 if (tb[TCA_FW_CLASSID]) { 204 f->res.classid = nla_get_u32(tb[TCA_FW_CLASSID]); 205 tcf_bind_filter(tp, &f->res, base); 206 } 207 208 #ifdef CONFIG_NET_CLS_IND 209 if (tb[TCA_FW_INDEV]) { 210 int ret; 211 ret = tcf_change_indev(net, tb[TCA_FW_INDEV]); 212 if (ret < 0) { 213 err = ret; 214 goto errout; 215 } 216 f->ifindex = ret; 217 } 218 #endif /* CONFIG_NET_CLS_IND */ 219 220 err = -EINVAL; 221 if (tb[TCA_FW_MASK]) { 222 mask = nla_get_u32(tb[TCA_FW_MASK]); 223 if (mask != head->mask) 224 goto errout; 225 } else if (head->mask != 0xFFFFFFFF) 226 goto errout; 227 228 tcf_exts_change(tp, &f->exts, &e); 229 230 return 0; 231 errout: 232 tcf_exts_destroy(&e); 233 return err; 234 } 235 236 static int fw_change(struct net *net, struct sk_buff *in_skb, 237 struct tcf_proto *tp, unsigned long base, 238 u32 handle, 239 struct nlattr **tca, 240 unsigned long *arg, bool ovr) 241 { 242 struct fw_head *head = rtnl_dereference(tp->root); 243 struct fw_filter *f = (struct fw_filter *) *arg; 244 struct nlattr *opt = tca[TCA_OPTIONS]; 245 struct nlattr *tb[TCA_FW_MAX + 1]; 246 int err; 247 248 if (!opt) 249 return handle ? -EINVAL : 0; /* Succeed if it is old method. */ 250 251 err = nla_parse_nested(tb, TCA_FW_MAX, opt, fw_policy); 252 if (err < 0) 253 return err; 254 255 if (f) { 256 struct fw_filter *pfp, *fnew; 257 struct fw_filter __rcu **fp; 258 259 if (f->id != handle && handle) 260 return -EINVAL; 261 262 fnew = kzalloc(sizeof(struct fw_filter), GFP_KERNEL); 263 if (!fnew) 264 return -ENOBUFS; 265 266 fnew->id = f->id; 267 fnew->res = f->res; 268 #ifdef CONFIG_NET_CLS_IND 269 fnew->ifindex = f->ifindex; 270 #endif /* CONFIG_NET_CLS_IND */ 271 fnew->tp = f->tp; 272 273 tcf_exts_init(&fnew->exts, TCA_FW_ACT, TCA_FW_POLICE); 274 275 err = fw_change_attrs(net, tp, fnew, tb, tca, base, ovr); 276 if (err < 0) { 277 kfree(fnew); 278 return err; 279 } 280 281 fp = &head->ht[fw_hash(fnew->id)]; 282 for (pfp = rtnl_dereference(*fp); pfp; 283 fp = &pfp->next, pfp = rtnl_dereference(*fp)) 284 if (pfp == f) 285 break; 286 287 RCU_INIT_POINTER(fnew->next, rtnl_dereference(pfp->next)); 288 rcu_assign_pointer(*fp, fnew); 289 tcf_unbind_filter(tp, &f->res); 290 call_rcu(&f->rcu, fw_delete_filter); 291 292 *arg = (unsigned long)fnew; 293 return err; 294 } 295 296 if (!handle) 297 return -EINVAL; 298 299 if (!head) { 300 u32 mask = 0xFFFFFFFF; 301 if (tb[TCA_FW_MASK]) 302 mask = nla_get_u32(tb[TCA_FW_MASK]); 303 304 head = kzalloc(sizeof(*head), GFP_KERNEL); 305 if (!head) 306 return -ENOBUFS; 307 head->mask = mask; 308 309 rcu_assign_pointer(tp->root, head); 310 } 311 312 f = kzalloc(sizeof(struct fw_filter), GFP_KERNEL); 313 if (f == NULL) 314 return -ENOBUFS; 315 316 tcf_exts_init(&f->exts, TCA_FW_ACT, TCA_FW_POLICE); 317 f->id = handle; 318 f->tp = tp; 319 320 err = fw_change_attrs(net, tp, f, tb, tca, base, ovr); 321 if (err < 0) 322 goto errout; 323 324 RCU_INIT_POINTER(f->next, head->ht[fw_hash(handle)]); 325 rcu_assign_pointer(head->ht[fw_hash(handle)], f); 326 327 *arg = (unsigned long)f; 328 return 0; 329 330 errout: 331 kfree(f); 332 return err; 333 } 334 335 static void fw_walk(struct tcf_proto *tp, struct tcf_walker *arg) 336 { 337 struct fw_head *head = rtnl_dereference(tp->root); 338 int h; 339 340 if (head == NULL) 341 arg->stop = 1; 342 343 if (arg->stop) 344 return; 345 346 for (h = 0; h < HTSIZE; h++) { 347 struct fw_filter *f; 348 349 for (f = rtnl_dereference(head->ht[h]); f; 350 f = rtnl_dereference(f->next)) { 351 if (arg->count < arg->skip) { 352 arg->count++; 353 continue; 354 } 355 if (arg->fn(tp, (unsigned long)f, arg) < 0) { 356 arg->stop = 1; 357 return; 358 } 359 arg->count++; 360 } 361 } 362 } 363 364 static int fw_dump(struct net *net, struct tcf_proto *tp, unsigned long fh, 365 struct sk_buff *skb, struct tcmsg *t) 366 { 367 struct fw_head *head = rtnl_dereference(tp->root); 368 struct fw_filter *f = (struct fw_filter *)fh; 369 struct nlattr *nest; 370 371 if (f == NULL) 372 return skb->len; 373 374 t->tcm_handle = f->id; 375 376 if (!f->res.classid && !tcf_exts_is_available(&f->exts)) 377 return skb->len; 378 379 nest = nla_nest_start(skb, TCA_OPTIONS); 380 if (nest == NULL) 381 goto nla_put_failure; 382 383 if (f->res.classid && 384 nla_put_u32(skb, TCA_FW_CLASSID, f->res.classid)) 385 goto nla_put_failure; 386 #ifdef CONFIG_NET_CLS_IND 387 if (f->ifindex) { 388 struct net_device *dev; 389 dev = __dev_get_by_index(net, f->ifindex); 390 if (dev && nla_put_string(skb, TCA_FW_INDEV, dev->name)) 391 goto nla_put_failure; 392 } 393 #endif /* CONFIG_NET_CLS_IND */ 394 if (head->mask != 0xFFFFFFFF && 395 nla_put_u32(skb, TCA_FW_MASK, head->mask)) 396 goto nla_put_failure; 397 398 if (tcf_exts_dump(skb, &f->exts) < 0) 399 goto nla_put_failure; 400 401 nla_nest_end(skb, nest); 402 403 if (tcf_exts_dump_stats(skb, &f->exts) < 0) 404 goto nla_put_failure; 405 406 return skb->len; 407 408 nla_put_failure: 409 nla_nest_cancel(skb, nest); 410 return -1; 411 } 412 413 static struct tcf_proto_ops cls_fw_ops __read_mostly = { 414 .kind = "fw", 415 .classify = fw_classify, 416 .init = fw_init, 417 .destroy = fw_destroy, 418 .get = fw_get, 419 .change = fw_change, 420 .delete = fw_delete, 421 .walk = fw_walk, 422 .dump = fw_dump, 423 .owner = THIS_MODULE, 424 }; 425 426 static int __init init_fw(void) 427 { 428 return register_tcf_proto_ops(&cls_fw_ops); 429 } 430 431 static void __exit exit_fw(void) 432 { 433 unregister_tcf_proto_ops(&cls_fw_ops); 434 } 435 436 module_init(init_fw) 437 module_exit(exit_fw) 438 MODULE_LICENSE("GPL"); 439