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