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 (PAGE_SIZE/sizeof(struct fw_filter *)) 33 34struct fw_head 35{ 36 struct fw_filter *ht[HTSIZE]; 37 u32 mask; 38}; 39 40struct fw_filter 41{ 42 struct fw_filter *next; 43 u32 id; 44 struct tcf_result res; 45#ifdef CONFIG_NET_CLS_IND 46 char indev[IFNAMSIZ]; 47#endif /* CONFIG_NET_CLS_IND */ 48 struct tcf_exts exts; 49}; 50 51static const struct tcf_ext_map fw_ext_map = { 52 .action = TCA_FW_ACT, 53 .police = TCA_FW_POLICE 54}; 55 56static __inline__ int fw_hash(u32 handle) 57{ 58 if (HTSIZE == 4096) 59 return ((handle >> 24) & 0xFFF) ^ 60 ((handle >> 12) & 0xFFF) ^ 61 (handle & 0xFFF); 62 else if (HTSIZE == 2048) 63 return ((handle >> 22) & 0x7FF) ^ 64 ((handle >> 11) & 0x7FF) ^ 65 (handle & 0x7FF); 66 else if (HTSIZE == 1024) 67 return ((handle >> 20) & 0x3FF) ^ 68 ((handle >> 10) & 0x3FF) ^ 69 (handle & 0x3FF); 70 else if (HTSIZE == 512) 71 return (handle >> 27) ^ 72 ((handle >> 18) & 0x1FF) ^ 73 ((handle >> 9) & 0x1FF) ^ 74 (handle & 0x1FF); 75 else if (HTSIZE == 256) { 76 u8 *t = (u8 *) &handle; 77 return t[0] ^ t[1] ^ t[2] ^ t[3]; 78 } else 79 return handle & (HTSIZE - 1); 80} 81 82static int fw_classify(struct sk_buff *skb, struct tcf_proto *tp, 83 struct tcf_result *res) 84{ 85 struct fw_head *head = (struct fw_head*)tp->root; 86 struct fw_filter *f; 87 int r; 88 u32 id = skb->mark; 89 90 if (head != NULL) { 91 id &= head->mask; 92 for (f=head->ht[fw_hash(id)]; f; f=f->next) { 93 if (f->id == id) { 94 *res = f->res; 95#ifdef CONFIG_NET_CLS_IND 96 if (!tcf_match_indev(skb, f->indev)) 97 continue; 98#endif /* CONFIG_NET_CLS_IND */ 99 r = tcf_exts_exec(skb, &f->exts, res); 100 if (r < 0) 101 continue; 102 103 return r; 104 } 105 } 106 } else { 107 /* old method */ 108 if (id && (TC_H_MAJ(id) == 0 || !(TC_H_MAJ(id^tp->q->handle)))) { 109 res->classid = id; 110 res->class = 0; 111 return 0; 112 } 113 } 114 115 return -1; 116} 117 118static unsigned long fw_get(struct tcf_proto *tp, u32 handle) 119{ 120 struct fw_head *head = (struct fw_head*)tp->root; 121 struct fw_filter *f; 122 123 if (head == NULL) 124 return 0; 125 126 for (f=head->ht[fw_hash(handle)]; f; f=f->next) { 127 if (f->id == handle) 128 return (unsigned long)f; 129 } 130 return 0; 131} 132 133static void fw_put(struct tcf_proto *tp, unsigned long f) 134{ 135} 136 137static int fw_init(struct tcf_proto *tp) 138{ 139 return 0; 140} 141 142static inline void 143fw_delete_filter(struct tcf_proto *tp, struct fw_filter *f) 144{ 145 tcf_unbind_filter(tp, &f->res); 146 tcf_exts_destroy(tp, &f->exts); 147 kfree(f); 148} 149 150static void fw_destroy(struct tcf_proto *tp) 151{ 152 struct fw_head *head = tp->root; 153 struct fw_filter *f; 154 int h; 155 156 if (head == NULL) 157 return; 158 159 for (h=0; h<HTSIZE; h++) { 160 while ((f=head->ht[h]) != NULL) { 161 head->ht[h] = f->next; 162 fw_delete_filter(tp, f); 163 } 164 } 165 kfree(head); 166} 167 168static int fw_delete(struct tcf_proto *tp, unsigned long arg) 169{ 170 struct fw_head *head = (struct fw_head*)tp->root; 171 struct fw_filter *f = (struct fw_filter*)arg; 172 struct fw_filter **fp; 173 174 if (head == NULL || f == NULL) 175 goto out; 176 177 for (fp=&head->ht[fw_hash(f->id)]; *fp; fp = &(*fp)->next) { 178 if (*fp == f) { 179 tcf_tree_lock(tp); 180 *fp = f->next; 181 tcf_tree_unlock(tp); 182 fw_delete_filter(tp, f); 183 return 0; 184 } 185 } 186out: 187 return -EINVAL; 188} 189 190static const struct nla_policy fw_policy[TCA_FW_MAX + 1] = { 191 [TCA_FW_CLASSID] = { .type = NLA_U32 }, 192 [TCA_FW_INDEV] = { .type = NLA_STRING, .len = IFNAMSIZ }, 193 [TCA_FW_MASK] = { .type = NLA_U32 }, 194}; 195 196static int 197fw_change_attrs(struct tcf_proto *tp, struct fw_filter *f, 198 struct nlattr **tb, struct nlattr **tca, unsigned long base) 199{ 200 struct fw_head *head = (struct fw_head *)tp->root; 201 struct tcf_exts e; 202 u32 mask; 203 int err; 204 205 err = tcf_exts_validate(tp, tb, tca[TCA_RATE], &e, &fw_ext_map); 206 if (err < 0) 207 return err; 208 209 err = -EINVAL; 210 if (tb[TCA_FW_CLASSID]) { 211 f->res.classid = nla_get_u32(tb[TCA_FW_CLASSID]); 212 tcf_bind_filter(tp, &f->res, base); 213 } 214 215#ifdef CONFIG_NET_CLS_IND 216 if (tb[TCA_FW_INDEV]) { 217 err = tcf_change_indev(tp, f->indev, tb[TCA_FW_INDEV]); 218 if (err < 0) 219 goto errout; 220 } 221#endif /* CONFIG_NET_CLS_IND */ 222 223 if (tb[TCA_FW_MASK]) { 224 mask = nla_get_u32(tb[TCA_FW_MASK]); 225 if (mask != head->mask) 226 goto errout; 227 } else if (head->mask != 0xFFFFFFFF) 228 goto errout; 229 230 tcf_exts_change(tp, &f->exts, &e); 231 232 return 0; 233errout: 234 tcf_exts_destroy(tp, &e); 235 return err; 236} 237 238static int fw_change(struct tcf_proto *tp, unsigned long base, 239 u32 handle, 240 struct nlattr **tca, 241 unsigned long *arg) 242{ 243 struct fw_head *head = (struct fw_head*)tp->root; 244 struct fw_filter *f = (struct fw_filter *) *arg; 245 struct nlattr *opt = tca[TCA_OPTIONS]; 246 struct nlattr *tb[TCA_FW_MAX + 1]; 247 int err; 248 249 if (!opt) 250 return handle ? -EINVAL : 0; 251 252 err = nla_parse_nested(tb, TCA_FW_MAX, opt, fw_policy); 253 if (err < 0) 254 return err; 255 256 if (f != NULL) { 257 if (f->id != handle && handle) 258 return -EINVAL; 259 return fw_change_attrs(tp, f, tb, tca, base); 260 } 261 262 if (!handle) 263 return -EINVAL; 264 265 if (head == NULL) { 266 u32 mask = 0xFFFFFFFF; 267 if (tb[TCA_FW_MASK]) 268 mask = nla_get_u32(tb[TCA_FW_MASK]); 269 270 head = kzalloc(sizeof(struct fw_head), GFP_KERNEL); 271 if (head == NULL) 272 return -ENOBUFS; 273 head->mask = mask; 274 275 tcf_tree_lock(tp); 276 tp->root = head; 277 tcf_tree_unlock(tp); 278 } 279 280 f = kzalloc(sizeof(struct fw_filter), GFP_KERNEL); 281 if (f == NULL) 282 return -ENOBUFS; 283 284 f->id = handle; 285 286 err = fw_change_attrs(tp, f, tb, tca, base); 287 if (err < 0) 288 goto errout; 289 290 f->next = head->ht[fw_hash(handle)]; 291 tcf_tree_lock(tp); 292 head->ht[fw_hash(handle)] = f; 293 tcf_tree_unlock(tp); 294 295 *arg = (unsigned long)f; 296 return 0; 297 298errout: 299 kfree(f); 300 return err; 301} 302 303static void fw_walk(struct tcf_proto *tp, struct tcf_walker *arg) 304{ 305 struct fw_head *head = (struct fw_head*)tp->root; 306 int h; 307 308 if (head == NULL) 309 arg->stop = 1; 310 311 if (arg->stop) 312 return; 313 314 for (h = 0; h < HTSIZE; h++) { 315 struct fw_filter *f; 316 317 for (f = head->ht[h]; f; f = f->next) { 318 if (arg->count < arg->skip) { 319 arg->count++; 320 continue; 321 } 322 if (arg->fn(tp, (unsigned long)f, arg) < 0) { 323 arg->stop = 1; 324 return; 325 } 326 arg->count++; 327 } 328 } 329} 330 331static int fw_dump(struct tcf_proto *tp, unsigned long fh, 332 struct sk_buff *skb, struct tcmsg *t) 333{ 334 struct fw_head *head = (struct fw_head *)tp->root; 335 struct fw_filter *f = (struct fw_filter*)fh; 336 unsigned char *b = skb_tail_pointer(skb); 337 struct nlattr *nest; 338 339 if (f == NULL) 340 return skb->len; 341 342 t->tcm_handle = f->id; 343 344 if (!f->res.classid && !tcf_exts_is_available(&f->exts)) 345 return skb->len; 346 347 nest = nla_nest_start(skb, TCA_OPTIONS); 348 if (nest == NULL) 349 goto nla_put_failure; 350 351 if (f->res.classid) 352 NLA_PUT_U32(skb, TCA_FW_CLASSID, f->res.classid); 353#ifdef CONFIG_NET_CLS_IND 354 if (strlen(f->indev)) 355 NLA_PUT_STRING(skb, TCA_FW_INDEV, f->indev); 356#endif /* CONFIG_NET_CLS_IND */ 357 if (head->mask != 0xFFFFFFFF) 358 NLA_PUT_U32(skb, TCA_FW_MASK, head->mask); 359 360 if (tcf_exts_dump(skb, &f->exts, &fw_ext_map) < 0) 361 goto nla_put_failure; 362 363 nla_nest_end(skb, nest); 364 365 if (tcf_exts_dump_stats(skb, &f->exts, &fw_ext_map) < 0) 366 goto nla_put_failure; 367 368 return skb->len; 369 370nla_put_failure: 371 nlmsg_trim(skb, b); 372 return -1; 373} 374 375static struct tcf_proto_ops cls_fw_ops __read_mostly = { 376 .kind = "fw", 377 .classify = fw_classify, 378 .init = fw_init, 379 .destroy = fw_destroy, 380 .get = fw_get, 381 .put = fw_put, 382 .change = fw_change, 383 .delete = fw_delete, 384 .walk = fw_walk, 385 .dump = fw_dump, 386 .owner = THIS_MODULE, 387}; 388 389static int __init init_fw(void) 390{ 391 return register_tcf_proto_ops(&cls_fw_ops); 392} 393 394static void __exit exit_fw(void) 395{ 396 unregister_tcf_proto_ops(&cls_fw_ops); 397} 398 399module_init(init_fw) 400module_exit(exit_fw) 401MODULE_LICENSE("GPL"); 402