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