1 /* 2 * net/sched/cls_u32.c Ugly (or Universal) 32bit key Packet Classifier. 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 * The filters are packed to hash tables of key nodes 12 * with a set of 32bit key/mask pairs at every node. 13 * Nodes reference next level hash tables etc. 14 * 15 * This scheme is the best universal classifier I managed to 16 * invent; it is not super-fast, but it is not slow (provided you 17 * program it correctly), and general enough. And its relative 18 * speed grows as the number of rules becomes larger. 19 * 20 * It seems that it represents the best middle point between 21 * speed and manageability both by human and by machine. 22 * 23 * It is especially useful for link sharing combined with QoS; 24 * pure RSVP doesn't need such a general approach and can use 25 * much simpler (and faster) schemes, sort of cls_rsvp.c. 26 * 27 * JHS: We should remove the CONFIG_NET_CLS_IND from here 28 * eventually when the meta match extension is made available 29 * 30 * nfmark match added by Catalin(ux aka Dino) BOIE <catab at umbrella.ro> 31 */ 32 33 #include <linux/module.h> 34 #include <linux/types.h> 35 #include <linux/kernel.h> 36 #include <linux/string.h> 37 #include <linux/errno.h> 38 #include <linux/rtnetlink.h> 39 #include <linux/skbuff.h> 40 #include <net/netlink.h> 41 #include <net/act_api.h> 42 #include <net/pkt_cls.h> 43 44 struct tc_u_knode 45 { 46 struct tc_u_knode *next; 47 u32 handle; 48 struct tc_u_hnode *ht_up; 49 struct tcf_exts exts; 50 #ifdef CONFIG_NET_CLS_IND 51 char indev[IFNAMSIZ]; 52 #endif 53 u8 fshift; 54 struct tcf_result res; 55 struct tc_u_hnode *ht_down; 56 #ifdef CONFIG_CLS_U32_PERF 57 struct tc_u32_pcnt *pf; 58 #endif 59 #ifdef CONFIG_CLS_U32_MARK 60 struct tc_u32_mark mark; 61 #endif 62 struct tc_u32_sel sel; 63 }; 64 65 struct tc_u_hnode 66 { 67 struct tc_u_hnode *next; 68 u32 handle; 69 u32 prio; 70 struct tc_u_common *tp_c; 71 int refcnt; 72 unsigned divisor; 73 struct tc_u_knode *ht[1]; 74 }; 75 76 struct tc_u_common 77 { 78 struct tc_u_hnode *hlist; 79 struct Qdisc *q; 80 int refcnt; 81 u32 hgenerator; 82 }; 83 84 static const struct tcf_ext_map u32_ext_map = { 85 .action = TCA_U32_ACT, 86 .police = TCA_U32_POLICE 87 }; 88 89 static __inline__ unsigned u32_hash_fold(__be32 key, struct tc_u32_sel *sel, u8 fshift) 90 { 91 unsigned h = ntohl(key & sel->hmask)>>fshift; 92 93 return h; 94 } 95 96 static int u32_classify(struct sk_buff *skb, struct tcf_proto *tp, struct tcf_result *res) 97 { 98 struct { 99 struct tc_u_knode *knode; 100 u8 *ptr; 101 } stack[TC_U32_MAXDEPTH]; 102 103 struct tc_u_hnode *ht = (struct tc_u_hnode*)tp->root; 104 u8 *ptr = skb_network_header(skb); 105 struct tc_u_knode *n; 106 int sdepth = 0; 107 int off2 = 0; 108 int sel = 0; 109 #ifdef CONFIG_CLS_U32_PERF 110 int j; 111 #endif 112 int i, r; 113 114 next_ht: 115 n = ht->ht[sel]; 116 117 next_knode: 118 if (n) { 119 struct tc_u32_key *key = n->sel.keys; 120 121 #ifdef CONFIG_CLS_U32_PERF 122 n->pf->rcnt +=1; 123 j = 0; 124 #endif 125 126 #ifdef CONFIG_CLS_U32_MARK 127 if ((skb->mark & n->mark.mask) != n->mark.val) { 128 n = n->next; 129 goto next_knode; 130 } else { 131 n->mark.success++; 132 } 133 #endif 134 135 for (i = n->sel.nkeys; i>0; i--, key++) { 136 137 if ((*(__be32*)(ptr+key->off+(off2&key->offmask))^key->val)&key->mask) { 138 n = n->next; 139 goto next_knode; 140 } 141 #ifdef CONFIG_CLS_U32_PERF 142 n->pf->kcnts[j] +=1; 143 j++; 144 #endif 145 } 146 if (n->ht_down == NULL) { 147 check_terminal: 148 if (n->sel.flags&TC_U32_TERMINAL) { 149 150 *res = n->res; 151 #ifdef CONFIG_NET_CLS_IND 152 if (!tcf_match_indev(skb, n->indev)) { 153 n = n->next; 154 goto next_knode; 155 } 156 #endif 157 #ifdef CONFIG_CLS_U32_PERF 158 n->pf->rhit +=1; 159 #endif 160 r = tcf_exts_exec(skb, &n->exts, res); 161 if (r < 0) { 162 n = n->next; 163 goto next_knode; 164 } 165 166 return r; 167 } 168 n = n->next; 169 goto next_knode; 170 } 171 172 /* PUSH */ 173 if (sdepth >= TC_U32_MAXDEPTH) 174 goto deadloop; 175 stack[sdepth].knode = n; 176 stack[sdepth].ptr = ptr; 177 sdepth++; 178 179 ht = n->ht_down; 180 sel = 0; 181 if (ht->divisor) 182 sel = ht->divisor&u32_hash_fold(*(__be32*)(ptr+n->sel.hoff), &n->sel,n->fshift); 183 184 if (!(n->sel.flags&(TC_U32_VAROFFSET|TC_U32_OFFSET|TC_U32_EAT))) 185 goto next_ht; 186 187 if (n->sel.flags&(TC_U32_OFFSET|TC_U32_VAROFFSET)) { 188 off2 = n->sel.off + 3; 189 if (n->sel.flags&TC_U32_VAROFFSET) 190 off2 += ntohs(n->sel.offmask & *(__be16*)(ptr+n->sel.offoff)) >>n->sel.offshift; 191 off2 &= ~3; 192 } 193 if (n->sel.flags&TC_U32_EAT) { 194 ptr += off2; 195 off2 = 0; 196 } 197 198 if (ptr < skb_tail_pointer(skb)) 199 goto next_ht; 200 } 201 202 /* POP */ 203 if (sdepth--) { 204 n = stack[sdepth].knode; 205 ht = n->ht_up; 206 ptr = stack[sdepth].ptr; 207 goto check_terminal; 208 } 209 return -1; 210 211 deadloop: 212 if (net_ratelimit()) 213 printk("cls_u32: dead loop\n"); 214 return -1; 215 } 216 217 static __inline__ struct tc_u_hnode * 218 u32_lookup_ht(struct tc_u_common *tp_c, u32 handle) 219 { 220 struct tc_u_hnode *ht; 221 222 for (ht = tp_c->hlist; ht; ht = ht->next) 223 if (ht->handle == handle) 224 break; 225 226 return ht; 227 } 228 229 static __inline__ struct tc_u_knode * 230 u32_lookup_key(struct tc_u_hnode *ht, u32 handle) 231 { 232 unsigned sel; 233 struct tc_u_knode *n = NULL; 234 235 sel = TC_U32_HASH(handle); 236 if (sel > ht->divisor) 237 goto out; 238 239 for (n = ht->ht[sel]; n; n = n->next) 240 if (n->handle == handle) 241 break; 242 out: 243 return n; 244 } 245 246 247 static unsigned long u32_get(struct tcf_proto *tp, u32 handle) 248 { 249 struct tc_u_hnode *ht; 250 struct tc_u_common *tp_c = tp->data; 251 252 if (TC_U32_HTID(handle) == TC_U32_ROOT) 253 ht = tp->root; 254 else 255 ht = u32_lookup_ht(tp_c, TC_U32_HTID(handle)); 256 257 if (!ht) 258 return 0; 259 260 if (TC_U32_KEY(handle) == 0) 261 return (unsigned long)ht; 262 263 return (unsigned long)u32_lookup_key(ht, handle); 264 } 265 266 static void u32_put(struct tcf_proto *tp, unsigned long f) 267 { 268 } 269 270 static u32 gen_new_htid(struct tc_u_common *tp_c) 271 { 272 int i = 0x800; 273 274 do { 275 if (++tp_c->hgenerator == 0x7FF) 276 tp_c->hgenerator = 1; 277 } while (--i>0 && u32_lookup_ht(tp_c, (tp_c->hgenerator|0x800)<<20)); 278 279 return i > 0 ? (tp_c->hgenerator|0x800)<<20 : 0; 280 } 281 282 static int u32_init(struct tcf_proto *tp) 283 { 284 struct tc_u_hnode *root_ht; 285 struct tc_u_common *tp_c; 286 287 tp_c = tp->q->u32_node; 288 289 root_ht = kzalloc(sizeof(*root_ht), GFP_KERNEL); 290 if (root_ht == NULL) 291 return -ENOBUFS; 292 293 root_ht->divisor = 0; 294 root_ht->refcnt++; 295 root_ht->handle = tp_c ? gen_new_htid(tp_c) : 0x80000000; 296 root_ht->prio = tp->prio; 297 298 if (tp_c == NULL) { 299 tp_c = kzalloc(sizeof(*tp_c), GFP_KERNEL); 300 if (tp_c == NULL) { 301 kfree(root_ht); 302 return -ENOBUFS; 303 } 304 tp_c->q = tp->q; 305 tp->q->u32_node = tp_c; 306 } 307 308 tp_c->refcnt++; 309 root_ht->next = tp_c->hlist; 310 tp_c->hlist = root_ht; 311 root_ht->tp_c = tp_c; 312 313 tp->root = root_ht; 314 tp->data = tp_c; 315 return 0; 316 } 317 318 static int u32_destroy_key(struct tcf_proto *tp, struct tc_u_knode *n) 319 { 320 tcf_unbind_filter(tp, &n->res); 321 tcf_exts_destroy(tp, &n->exts); 322 if (n->ht_down) 323 n->ht_down->refcnt--; 324 #ifdef CONFIG_CLS_U32_PERF 325 kfree(n->pf); 326 #endif 327 kfree(n); 328 return 0; 329 } 330 331 static int u32_delete_key(struct tcf_proto *tp, struct tc_u_knode* key) 332 { 333 struct tc_u_knode **kp; 334 struct tc_u_hnode *ht = key->ht_up; 335 336 if (ht) { 337 for (kp = &ht->ht[TC_U32_HASH(key->handle)]; *kp; kp = &(*kp)->next) { 338 if (*kp == key) { 339 tcf_tree_lock(tp); 340 *kp = key->next; 341 tcf_tree_unlock(tp); 342 343 u32_destroy_key(tp, key); 344 return 0; 345 } 346 } 347 } 348 WARN_ON(1); 349 return 0; 350 } 351 352 static void u32_clear_hnode(struct tcf_proto *tp, struct tc_u_hnode *ht) 353 { 354 struct tc_u_knode *n; 355 unsigned h; 356 357 for (h=0; h<=ht->divisor; h++) { 358 while ((n = ht->ht[h]) != NULL) { 359 ht->ht[h] = n->next; 360 361 u32_destroy_key(tp, n); 362 } 363 } 364 } 365 366 static int u32_destroy_hnode(struct tcf_proto *tp, struct tc_u_hnode *ht) 367 { 368 struct tc_u_common *tp_c = tp->data; 369 struct tc_u_hnode **hn; 370 371 WARN_ON(ht->refcnt); 372 373 u32_clear_hnode(tp, ht); 374 375 for (hn = &tp_c->hlist; *hn; hn = &(*hn)->next) { 376 if (*hn == ht) { 377 *hn = ht->next; 378 kfree(ht); 379 return 0; 380 } 381 } 382 383 WARN_ON(1); 384 return -ENOENT; 385 } 386 387 static void u32_destroy(struct tcf_proto *tp) 388 { 389 struct tc_u_common *tp_c = tp->data; 390 struct tc_u_hnode *root_ht = xchg(&tp->root, NULL); 391 392 WARN_ON(root_ht == NULL); 393 394 if (root_ht && --root_ht->refcnt == 0) 395 u32_destroy_hnode(tp, root_ht); 396 397 if (--tp_c->refcnt == 0) { 398 struct tc_u_hnode *ht; 399 400 tp->q->u32_node = NULL; 401 402 for (ht = tp_c->hlist; ht; ht = ht->next) { 403 ht->refcnt--; 404 u32_clear_hnode(tp, ht); 405 } 406 407 while ((ht = tp_c->hlist) != NULL) { 408 tp_c->hlist = ht->next; 409 410 WARN_ON(ht->refcnt != 0); 411 412 kfree(ht); 413 } 414 415 kfree(tp_c); 416 } 417 418 tp->data = NULL; 419 } 420 421 static int u32_delete(struct tcf_proto *tp, unsigned long arg) 422 { 423 struct tc_u_hnode *ht = (struct tc_u_hnode*)arg; 424 425 if (ht == NULL) 426 return 0; 427 428 if (TC_U32_KEY(ht->handle)) 429 return u32_delete_key(tp, (struct tc_u_knode*)ht); 430 431 if (tp->root == ht) 432 return -EINVAL; 433 434 if (ht->refcnt == 1) { 435 ht->refcnt--; 436 u32_destroy_hnode(tp, ht); 437 } else { 438 return -EBUSY; 439 } 440 441 return 0; 442 } 443 444 static u32 gen_new_kid(struct tc_u_hnode *ht, u32 handle) 445 { 446 struct tc_u_knode *n; 447 unsigned i = 0x7FF; 448 449 for (n=ht->ht[TC_U32_HASH(handle)]; n; n = n->next) 450 if (i < TC_U32_NODE(n->handle)) 451 i = TC_U32_NODE(n->handle); 452 i++; 453 454 return handle|(i>0xFFF ? 0xFFF : i); 455 } 456 457 static const struct nla_policy u32_policy[TCA_U32_MAX + 1] = { 458 [TCA_U32_CLASSID] = { .type = NLA_U32 }, 459 [TCA_U32_HASH] = { .type = NLA_U32 }, 460 [TCA_U32_LINK] = { .type = NLA_U32 }, 461 [TCA_U32_DIVISOR] = { .type = NLA_U32 }, 462 [TCA_U32_SEL] = { .len = sizeof(struct tc_u32_sel) }, 463 [TCA_U32_INDEV] = { .type = NLA_STRING, .len = IFNAMSIZ }, 464 [TCA_U32_MARK] = { .len = sizeof(struct tc_u32_mark) }, 465 }; 466 467 static int u32_set_parms(struct tcf_proto *tp, unsigned long base, 468 struct tc_u_hnode *ht, 469 struct tc_u_knode *n, struct nlattr **tb, 470 struct nlattr *est) 471 { 472 int err; 473 struct tcf_exts e; 474 475 err = tcf_exts_validate(tp, tb, est, &e, &u32_ext_map); 476 if (err < 0) 477 return err; 478 479 err = -EINVAL; 480 if (tb[TCA_U32_LINK]) { 481 u32 handle = nla_get_u32(tb[TCA_U32_LINK]); 482 struct tc_u_hnode *ht_down = NULL; 483 484 if (TC_U32_KEY(handle)) 485 goto errout; 486 487 if (handle) { 488 ht_down = u32_lookup_ht(ht->tp_c, handle); 489 490 if (ht_down == NULL) 491 goto errout; 492 ht_down->refcnt++; 493 } 494 495 tcf_tree_lock(tp); 496 ht_down = xchg(&n->ht_down, ht_down); 497 tcf_tree_unlock(tp); 498 499 if (ht_down) 500 ht_down->refcnt--; 501 } 502 if (tb[TCA_U32_CLASSID]) { 503 n->res.classid = nla_get_u32(tb[TCA_U32_CLASSID]); 504 tcf_bind_filter(tp, &n->res, base); 505 } 506 507 #ifdef CONFIG_NET_CLS_IND 508 if (tb[TCA_U32_INDEV]) { 509 err = tcf_change_indev(tp, n->indev, tb[TCA_U32_INDEV]); 510 if (err < 0) 511 goto errout; 512 } 513 #endif 514 tcf_exts_change(tp, &n->exts, &e); 515 516 return 0; 517 errout: 518 tcf_exts_destroy(tp, &e); 519 return err; 520 } 521 522 static int u32_change(struct tcf_proto *tp, unsigned long base, u32 handle, 523 struct nlattr **tca, 524 unsigned long *arg) 525 { 526 struct tc_u_common *tp_c = tp->data; 527 struct tc_u_hnode *ht; 528 struct tc_u_knode *n; 529 struct tc_u32_sel *s; 530 struct nlattr *opt = tca[TCA_OPTIONS]; 531 struct nlattr *tb[TCA_U32_MAX + 1]; 532 u32 htid; 533 int err; 534 535 if (opt == NULL) 536 return handle ? -EINVAL : 0; 537 538 err = nla_parse_nested(tb, TCA_U32_MAX, opt, u32_policy); 539 if (err < 0) 540 return err; 541 542 if ((n = (struct tc_u_knode*)*arg) != NULL) { 543 if (TC_U32_KEY(n->handle) == 0) 544 return -EINVAL; 545 546 return u32_set_parms(tp, base, n->ht_up, n, tb, tca[TCA_RATE]); 547 } 548 549 if (tb[TCA_U32_DIVISOR]) { 550 unsigned divisor = nla_get_u32(tb[TCA_U32_DIVISOR]); 551 552 if (--divisor > 0x100) 553 return -EINVAL; 554 if (TC_U32_KEY(handle)) 555 return -EINVAL; 556 if (handle == 0) { 557 handle = gen_new_htid(tp->data); 558 if (handle == 0) 559 return -ENOMEM; 560 } 561 ht = kzalloc(sizeof(*ht) + divisor*sizeof(void*), GFP_KERNEL); 562 if (ht == NULL) 563 return -ENOBUFS; 564 ht->tp_c = tp_c; 565 ht->refcnt = 1; 566 ht->divisor = divisor; 567 ht->handle = handle; 568 ht->prio = tp->prio; 569 ht->next = tp_c->hlist; 570 tp_c->hlist = ht; 571 *arg = (unsigned long)ht; 572 return 0; 573 } 574 575 if (tb[TCA_U32_HASH]) { 576 htid = nla_get_u32(tb[TCA_U32_HASH]); 577 if (TC_U32_HTID(htid) == TC_U32_ROOT) { 578 ht = tp->root; 579 htid = ht->handle; 580 } else { 581 ht = u32_lookup_ht(tp->data, TC_U32_HTID(htid)); 582 if (ht == NULL) 583 return -EINVAL; 584 } 585 } else { 586 ht = tp->root; 587 htid = ht->handle; 588 } 589 590 if (ht->divisor < TC_U32_HASH(htid)) 591 return -EINVAL; 592 593 if (handle) { 594 if (TC_U32_HTID(handle) && TC_U32_HTID(handle^htid)) 595 return -EINVAL; 596 handle = htid | TC_U32_NODE(handle); 597 } else 598 handle = gen_new_kid(ht, htid); 599 600 if (tb[TCA_U32_SEL] == NULL) 601 return -EINVAL; 602 603 s = nla_data(tb[TCA_U32_SEL]); 604 605 n = kzalloc(sizeof(*n) + s->nkeys*sizeof(struct tc_u32_key), GFP_KERNEL); 606 if (n == NULL) 607 return -ENOBUFS; 608 609 #ifdef CONFIG_CLS_U32_PERF 610 n->pf = kzalloc(sizeof(struct tc_u32_pcnt) + s->nkeys*sizeof(u64), GFP_KERNEL); 611 if (n->pf == NULL) { 612 kfree(n); 613 return -ENOBUFS; 614 } 615 #endif 616 617 memcpy(&n->sel, s, sizeof(*s) + s->nkeys*sizeof(struct tc_u32_key)); 618 n->ht_up = ht; 619 n->handle = handle; 620 n->fshift = s->hmask ? ffs(ntohl(s->hmask)) - 1 : 0; 621 622 #ifdef CONFIG_CLS_U32_MARK 623 if (tb[TCA_U32_MARK]) { 624 struct tc_u32_mark *mark; 625 626 mark = nla_data(tb[TCA_U32_MARK]); 627 memcpy(&n->mark, mark, sizeof(struct tc_u32_mark)); 628 n->mark.success = 0; 629 } 630 #endif 631 632 err = u32_set_parms(tp, base, ht, n, tb, tca[TCA_RATE]); 633 if (err == 0) { 634 struct tc_u_knode **ins; 635 for (ins = &ht->ht[TC_U32_HASH(handle)]; *ins; ins = &(*ins)->next) 636 if (TC_U32_NODE(handle) < TC_U32_NODE((*ins)->handle)) 637 break; 638 639 n->next = *ins; 640 wmb(); 641 *ins = n; 642 643 *arg = (unsigned long)n; 644 return 0; 645 } 646 #ifdef CONFIG_CLS_U32_PERF 647 kfree(n->pf); 648 #endif 649 kfree(n); 650 return err; 651 } 652 653 static void u32_walk(struct tcf_proto *tp, struct tcf_walker *arg) 654 { 655 struct tc_u_common *tp_c = tp->data; 656 struct tc_u_hnode *ht; 657 struct tc_u_knode *n; 658 unsigned h; 659 660 if (arg->stop) 661 return; 662 663 for (ht = tp_c->hlist; ht; ht = ht->next) { 664 if (ht->prio != tp->prio) 665 continue; 666 if (arg->count >= arg->skip) { 667 if (arg->fn(tp, (unsigned long)ht, arg) < 0) { 668 arg->stop = 1; 669 return; 670 } 671 } 672 arg->count++; 673 for (h = 0; h <= ht->divisor; h++) { 674 for (n = ht->ht[h]; n; n = n->next) { 675 if (arg->count < arg->skip) { 676 arg->count++; 677 continue; 678 } 679 if (arg->fn(tp, (unsigned long)n, arg) < 0) { 680 arg->stop = 1; 681 return; 682 } 683 arg->count++; 684 } 685 } 686 } 687 } 688 689 static int u32_dump(struct tcf_proto *tp, unsigned long fh, 690 struct sk_buff *skb, struct tcmsg *t) 691 { 692 struct tc_u_knode *n = (struct tc_u_knode*)fh; 693 struct nlattr *nest; 694 695 if (n == NULL) 696 return skb->len; 697 698 t->tcm_handle = n->handle; 699 700 nest = nla_nest_start(skb, TCA_OPTIONS); 701 if (nest == NULL) 702 goto nla_put_failure; 703 704 if (TC_U32_KEY(n->handle) == 0) { 705 struct tc_u_hnode *ht = (struct tc_u_hnode*)fh; 706 u32 divisor = ht->divisor+1; 707 NLA_PUT_U32(skb, TCA_U32_DIVISOR, divisor); 708 } else { 709 NLA_PUT(skb, TCA_U32_SEL, 710 sizeof(n->sel) + n->sel.nkeys*sizeof(struct tc_u32_key), 711 &n->sel); 712 if (n->ht_up) { 713 u32 htid = n->handle & 0xFFFFF000; 714 NLA_PUT_U32(skb, TCA_U32_HASH, htid); 715 } 716 if (n->res.classid) 717 NLA_PUT_U32(skb, TCA_U32_CLASSID, n->res.classid); 718 if (n->ht_down) 719 NLA_PUT_U32(skb, TCA_U32_LINK, n->ht_down->handle); 720 721 #ifdef CONFIG_CLS_U32_MARK 722 if (n->mark.val || n->mark.mask) 723 NLA_PUT(skb, TCA_U32_MARK, sizeof(n->mark), &n->mark); 724 #endif 725 726 if (tcf_exts_dump(skb, &n->exts, &u32_ext_map) < 0) 727 goto nla_put_failure; 728 729 #ifdef CONFIG_NET_CLS_IND 730 if(strlen(n->indev)) 731 NLA_PUT_STRING(skb, TCA_U32_INDEV, n->indev); 732 #endif 733 #ifdef CONFIG_CLS_U32_PERF 734 NLA_PUT(skb, TCA_U32_PCNT, 735 sizeof(struct tc_u32_pcnt) + n->sel.nkeys*sizeof(u64), 736 n->pf); 737 #endif 738 } 739 740 nla_nest_end(skb, nest); 741 742 if (TC_U32_KEY(n->handle)) 743 if (tcf_exts_dump_stats(skb, &n->exts, &u32_ext_map) < 0) 744 goto nla_put_failure; 745 return skb->len; 746 747 nla_put_failure: 748 nla_nest_cancel(skb, nest); 749 return -1; 750 } 751 752 static struct tcf_proto_ops cls_u32_ops __read_mostly = { 753 .kind = "u32", 754 .classify = u32_classify, 755 .init = u32_init, 756 .destroy = u32_destroy, 757 .get = u32_get, 758 .put = u32_put, 759 .change = u32_change, 760 .delete = u32_delete, 761 .walk = u32_walk, 762 .dump = u32_dump, 763 .owner = THIS_MODULE, 764 }; 765 766 static int __init init_u32(void) 767 { 768 printk("u32 classifier\n"); 769 #ifdef CONFIG_CLS_U32_PERF 770 printk(" Performance counters on\n"); 771 #endif 772 #ifdef CONFIG_NET_CLS_IND 773 printk(" input device check on \n"); 774 #endif 775 #ifdef CONFIG_NET_CLS_ACT 776 printk(" Actions configured \n"); 777 #endif 778 return register_tcf_proto_ops(&cls_u32_ops); 779 } 780 781 static void __exit exit_u32(void) 782 { 783 unregister_tcf_proto_ops(&cls_u32_ops); 784 } 785 786 module_init(init_u32) 787 module_exit(exit_u32) 788 MODULE_LICENSE("GPL"); 789