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