1 /* 2 * net/sched/em_meta.c Metadata ematch 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: Thomas Graf <tgraf@suug.ch> 10 * 11 * ========================================================================== 12 * 13 * The metadata ematch compares two meta objects where each object 14 * represents either a meta value stored in the kernel or a static 15 * value provided by userspace. The objects are not provided by 16 * userspace itself but rather a definition providing the information 17 * to build them. Every object is of a certain type which must be 18 * equal to the object it is being compared to. 19 * 20 * The definition of a objects conists of the type (meta type), a 21 * identifier (meta id) and additional type specific information. 22 * The meta id is either TCF_META_TYPE_VALUE for values provided by 23 * userspace or a index to the meta operations table consisting of 24 * function pointers to type specific meta data collectors returning 25 * the value of the requested meta value. 26 * 27 * lvalue rvalue 28 * +-----------+ +-----------+ 29 * | type: INT | | type: INT | 30 * def | id: DEV | | id: VALUE | 31 * | data: | | data: 3 | 32 * +-----------+ +-----------+ 33 * | | 34 * ---> meta_ops[INT][DEV](...) | 35 * | | 36 * ----------- | 37 * V V 38 * +-----------+ +-----------+ 39 * | type: INT | | type: INT | 40 * obj | id: DEV | | id: VALUE | 41 * | data: 2 |<--data got filled out | data: 3 | 42 * +-----------+ +-----------+ 43 * | | 44 * --------------> 2 equals 3 <-------------- 45 * 46 * This is a simplified schema, the complexity varies depending 47 * on the meta type. Obviously, the length of the data must also 48 * be provided for non-numeric types. 49 * 50 * Additionaly, type dependant modifiers such as shift operators 51 * or mask may be applied to extend the functionaliy. As of now, 52 * the variable length type supports shifting the byte string to 53 * the right, eating up any number of octets and thus supporting 54 * wildcard interface name comparisons such as "ppp%" matching 55 * ppp0..9. 56 * 57 * NOTE: Certain meta values depend on other subsystems and are 58 * only available if that subsystem is enabled in the kernel. 59 */ 60 61 #include <linux/module.h> 62 #include <linux/types.h> 63 #include <linux/kernel.h> 64 #include <linux/sched.h> 65 #include <linux/string.h> 66 #include <linux/skbuff.h> 67 #include <linux/random.h> 68 #include <linux/if_vlan.h> 69 #include <linux/tc_ematch/tc_em_meta.h> 70 #include <net/dst.h> 71 #include <net/route.h> 72 #include <net/pkt_cls.h> 73 #include <net/sock.h> 74 75 struct meta_obj 76 { 77 unsigned long value; 78 unsigned int len; 79 }; 80 81 struct meta_value 82 { 83 struct tcf_meta_val hdr; 84 unsigned long val; 85 unsigned int len; 86 }; 87 88 struct meta_match 89 { 90 struct meta_value lvalue; 91 struct meta_value rvalue; 92 }; 93 94 static inline int meta_id(struct meta_value *v) 95 { 96 return TCF_META_ID(v->hdr.kind); 97 } 98 99 static inline int meta_type(struct meta_value *v) 100 { 101 return TCF_META_TYPE(v->hdr.kind); 102 } 103 104 #define META_COLLECTOR(FUNC) static void meta_##FUNC(struct sk_buff *skb, \ 105 struct tcf_pkt_info *info, struct meta_value *v, \ 106 struct meta_obj *dst, int *err) 107 108 /************************************************************************** 109 * System status & misc 110 **************************************************************************/ 111 112 META_COLLECTOR(int_random) 113 { 114 get_random_bytes(&dst->value, sizeof(dst->value)); 115 } 116 117 static inline unsigned long fixed_loadavg(int load) 118 { 119 int rnd_load = load + (FIXED_1/200); 120 int rnd_frac = ((rnd_load & (FIXED_1-1)) * 100) >> FSHIFT; 121 122 return ((rnd_load >> FSHIFT) * 100) + rnd_frac; 123 } 124 125 META_COLLECTOR(int_loadavg_0) 126 { 127 dst->value = fixed_loadavg(avenrun[0]); 128 } 129 130 META_COLLECTOR(int_loadavg_1) 131 { 132 dst->value = fixed_loadavg(avenrun[1]); 133 } 134 135 META_COLLECTOR(int_loadavg_2) 136 { 137 dst->value = fixed_loadavg(avenrun[2]); 138 } 139 140 /************************************************************************** 141 * Device names & indices 142 **************************************************************************/ 143 144 static inline int int_dev(struct net_device *dev, struct meta_obj *dst) 145 { 146 if (unlikely(dev == NULL)) 147 return -1; 148 149 dst->value = dev->ifindex; 150 return 0; 151 } 152 153 static inline int var_dev(struct net_device *dev, struct meta_obj *dst) 154 { 155 if (unlikely(dev == NULL)) 156 return -1; 157 158 dst->value = (unsigned long) dev->name; 159 dst->len = strlen(dev->name); 160 return 0; 161 } 162 163 META_COLLECTOR(int_dev) 164 { 165 *err = int_dev(skb->dev, dst); 166 } 167 168 META_COLLECTOR(var_dev) 169 { 170 *err = var_dev(skb->dev, dst); 171 } 172 173 /************************************************************************** 174 * vlan tag 175 **************************************************************************/ 176 177 META_COLLECTOR(int_vlan_tag) 178 { 179 unsigned short tag; 180 181 tag = vlan_tx_tag_get(skb); 182 if (!tag && __vlan_get_tag(skb, &tag)) 183 *err = -1; 184 else 185 dst->value = tag; 186 } 187 188 189 190 /************************************************************************** 191 * skb attributes 192 **************************************************************************/ 193 194 META_COLLECTOR(int_priority) 195 { 196 dst->value = skb->priority; 197 } 198 199 META_COLLECTOR(int_protocol) 200 { 201 /* Let userspace take care of the byte ordering */ 202 dst->value = skb->protocol; 203 } 204 205 META_COLLECTOR(int_pkttype) 206 { 207 dst->value = skb->pkt_type; 208 } 209 210 META_COLLECTOR(int_pktlen) 211 { 212 dst->value = skb->len; 213 } 214 215 META_COLLECTOR(int_datalen) 216 { 217 dst->value = skb->data_len; 218 } 219 220 META_COLLECTOR(int_maclen) 221 { 222 dst->value = skb->mac_len; 223 } 224 225 /************************************************************************** 226 * Netfilter 227 **************************************************************************/ 228 229 META_COLLECTOR(int_mark) 230 { 231 dst->value = skb->mark; 232 } 233 234 /************************************************************************** 235 * Traffic Control 236 **************************************************************************/ 237 238 META_COLLECTOR(int_tcindex) 239 { 240 dst->value = skb->tc_index; 241 } 242 243 /************************************************************************** 244 * Routing 245 **************************************************************************/ 246 247 META_COLLECTOR(int_rtclassid) 248 { 249 if (unlikely(skb_dst(skb) == NULL)) 250 *err = -1; 251 else 252 #ifdef CONFIG_NET_CLS_ROUTE 253 dst->value = skb_dst(skb)->tclassid; 254 #else 255 dst->value = 0; 256 #endif 257 } 258 259 META_COLLECTOR(int_rtiif) 260 { 261 if (unlikely(skb_rtable(skb) == NULL)) 262 *err = -1; 263 else 264 dst->value = skb_rtable(skb)->fl.iif; 265 } 266 267 /************************************************************************** 268 * Socket Attributes 269 **************************************************************************/ 270 271 #define SKIP_NONLOCAL(skb) \ 272 if (unlikely(skb->sk == NULL)) { \ 273 *err = -1; \ 274 return; \ 275 } 276 277 META_COLLECTOR(int_sk_family) 278 { 279 SKIP_NONLOCAL(skb); 280 dst->value = skb->sk->sk_family; 281 } 282 283 META_COLLECTOR(int_sk_state) 284 { 285 SKIP_NONLOCAL(skb); 286 dst->value = skb->sk->sk_state; 287 } 288 289 META_COLLECTOR(int_sk_reuse) 290 { 291 SKIP_NONLOCAL(skb); 292 dst->value = skb->sk->sk_reuse; 293 } 294 295 META_COLLECTOR(int_sk_bound_if) 296 { 297 SKIP_NONLOCAL(skb); 298 /* No error if bound_dev_if is 0, legal userspace check */ 299 dst->value = skb->sk->sk_bound_dev_if; 300 } 301 302 META_COLLECTOR(var_sk_bound_if) 303 { 304 SKIP_NONLOCAL(skb); 305 306 if (skb->sk->sk_bound_dev_if == 0) { 307 dst->value = (unsigned long) "any"; 308 dst->len = 3; 309 } else { 310 struct net_device *dev; 311 312 rcu_read_lock(); 313 dev = dev_get_by_index_rcu(sock_net(skb->sk), 314 skb->sk->sk_bound_dev_if); 315 *err = var_dev(dev, dst); 316 rcu_read_unlock(); 317 } 318 } 319 320 META_COLLECTOR(int_sk_refcnt) 321 { 322 SKIP_NONLOCAL(skb); 323 dst->value = atomic_read(&skb->sk->sk_refcnt); 324 } 325 326 META_COLLECTOR(int_sk_rcvbuf) 327 { 328 SKIP_NONLOCAL(skb); 329 dst->value = skb->sk->sk_rcvbuf; 330 } 331 332 META_COLLECTOR(int_sk_shutdown) 333 { 334 SKIP_NONLOCAL(skb); 335 dst->value = skb->sk->sk_shutdown; 336 } 337 338 META_COLLECTOR(int_sk_proto) 339 { 340 SKIP_NONLOCAL(skb); 341 dst->value = skb->sk->sk_protocol; 342 } 343 344 META_COLLECTOR(int_sk_type) 345 { 346 SKIP_NONLOCAL(skb); 347 dst->value = skb->sk->sk_type; 348 } 349 350 META_COLLECTOR(int_sk_rmem_alloc) 351 { 352 SKIP_NONLOCAL(skb); 353 dst->value = sk_rmem_alloc_get(skb->sk); 354 } 355 356 META_COLLECTOR(int_sk_wmem_alloc) 357 { 358 SKIP_NONLOCAL(skb); 359 dst->value = sk_wmem_alloc_get(skb->sk); 360 } 361 362 META_COLLECTOR(int_sk_omem_alloc) 363 { 364 SKIP_NONLOCAL(skb); 365 dst->value = atomic_read(&skb->sk->sk_omem_alloc); 366 } 367 368 META_COLLECTOR(int_sk_rcv_qlen) 369 { 370 SKIP_NONLOCAL(skb); 371 dst->value = skb->sk->sk_receive_queue.qlen; 372 } 373 374 META_COLLECTOR(int_sk_snd_qlen) 375 { 376 SKIP_NONLOCAL(skb); 377 dst->value = skb->sk->sk_write_queue.qlen; 378 } 379 380 META_COLLECTOR(int_sk_wmem_queued) 381 { 382 SKIP_NONLOCAL(skb); 383 dst->value = skb->sk->sk_wmem_queued; 384 } 385 386 META_COLLECTOR(int_sk_fwd_alloc) 387 { 388 SKIP_NONLOCAL(skb); 389 dst->value = skb->sk->sk_forward_alloc; 390 } 391 392 META_COLLECTOR(int_sk_sndbuf) 393 { 394 SKIP_NONLOCAL(skb); 395 dst->value = skb->sk->sk_sndbuf; 396 } 397 398 META_COLLECTOR(int_sk_alloc) 399 { 400 SKIP_NONLOCAL(skb); 401 dst->value = skb->sk->sk_allocation; 402 } 403 404 META_COLLECTOR(int_sk_route_caps) 405 { 406 SKIP_NONLOCAL(skb); 407 dst->value = skb->sk->sk_route_caps; 408 } 409 410 META_COLLECTOR(int_sk_hash) 411 { 412 SKIP_NONLOCAL(skb); 413 dst->value = skb->sk->sk_hash; 414 } 415 416 META_COLLECTOR(int_sk_lingertime) 417 { 418 SKIP_NONLOCAL(skb); 419 dst->value = skb->sk->sk_lingertime / HZ; 420 } 421 422 META_COLLECTOR(int_sk_err_qlen) 423 { 424 SKIP_NONLOCAL(skb); 425 dst->value = skb->sk->sk_error_queue.qlen; 426 } 427 428 META_COLLECTOR(int_sk_ack_bl) 429 { 430 SKIP_NONLOCAL(skb); 431 dst->value = skb->sk->sk_ack_backlog; 432 } 433 434 META_COLLECTOR(int_sk_max_ack_bl) 435 { 436 SKIP_NONLOCAL(skb); 437 dst->value = skb->sk->sk_max_ack_backlog; 438 } 439 440 META_COLLECTOR(int_sk_prio) 441 { 442 SKIP_NONLOCAL(skb); 443 dst->value = skb->sk->sk_priority; 444 } 445 446 META_COLLECTOR(int_sk_rcvlowat) 447 { 448 SKIP_NONLOCAL(skb); 449 dst->value = skb->sk->sk_rcvlowat; 450 } 451 452 META_COLLECTOR(int_sk_rcvtimeo) 453 { 454 SKIP_NONLOCAL(skb); 455 dst->value = skb->sk->sk_rcvtimeo / HZ; 456 } 457 458 META_COLLECTOR(int_sk_sndtimeo) 459 { 460 SKIP_NONLOCAL(skb); 461 dst->value = skb->sk->sk_sndtimeo / HZ; 462 } 463 464 META_COLLECTOR(int_sk_sendmsg_off) 465 { 466 SKIP_NONLOCAL(skb); 467 dst->value = skb->sk->sk_sndmsg_off; 468 } 469 470 META_COLLECTOR(int_sk_write_pend) 471 { 472 SKIP_NONLOCAL(skb); 473 dst->value = skb->sk->sk_write_pending; 474 } 475 476 /************************************************************************** 477 * Meta value collectors assignment table 478 **************************************************************************/ 479 480 struct meta_ops 481 { 482 void (*get)(struct sk_buff *, struct tcf_pkt_info *, 483 struct meta_value *, struct meta_obj *, int *); 484 }; 485 486 #define META_ID(name) TCF_META_ID_##name 487 #define META_FUNC(name) { .get = meta_##name } 488 489 /* Meta value operations table listing all meta value collectors and 490 * assigns them to a type and meta id. */ 491 static struct meta_ops __meta_ops[TCF_META_TYPE_MAX+1][TCF_META_ID_MAX+1] = { 492 [TCF_META_TYPE_VAR] = { 493 [META_ID(DEV)] = META_FUNC(var_dev), 494 [META_ID(SK_BOUND_IF)] = META_FUNC(var_sk_bound_if), 495 }, 496 [TCF_META_TYPE_INT] = { 497 [META_ID(RANDOM)] = META_FUNC(int_random), 498 [META_ID(LOADAVG_0)] = META_FUNC(int_loadavg_0), 499 [META_ID(LOADAVG_1)] = META_FUNC(int_loadavg_1), 500 [META_ID(LOADAVG_2)] = META_FUNC(int_loadavg_2), 501 [META_ID(DEV)] = META_FUNC(int_dev), 502 [META_ID(PRIORITY)] = META_FUNC(int_priority), 503 [META_ID(PROTOCOL)] = META_FUNC(int_protocol), 504 [META_ID(PKTTYPE)] = META_FUNC(int_pkttype), 505 [META_ID(PKTLEN)] = META_FUNC(int_pktlen), 506 [META_ID(DATALEN)] = META_FUNC(int_datalen), 507 [META_ID(MACLEN)] = META_FUNC(int_maclen), 508 [META_ID(NFMARK)] = META_FUNC(int_mark), 509 [META_ID(TCINDEX)] = META_FUNC(int_tcindex), 510 [META_ID(RTCLASSID)] = META_FUNC(int_rtclassid), 511 [META_ID(RTIIF)] = META_FUNC(int_rtiif), 512 [META_ID(SK_FAMILY)] = META_FUNC(int_sk_family), 513 [META_ID(SK_STATE)] = META_FUNC(int_sk_state), 514 [META_ID(SK_REUSE)] = META_FUNC(int_sk_reuse), 515 [META_ID(SK_BOUND_IF)] = META_FUNC(int_sk_bound_if), 516 [META_ID(SK_REFCNT)] = META_FUNC(int_sk_refcnt), 517 [META_ID(SK_RCVBUF)] = META_FUNC(int_sk_rcvbuf), 518 [META_ID(SK_SNDBUF)] = META_FUNC(int_sk_sndbuf), 519 [META_ID(SK_SHUTDOWN)] = META_FUNC(int_sk_shutdown), 520 [META_ID(SK_PROTO)] = META_FUNC(int_sk_proto), 521 [META_ID(SK_TYPE)] = META_FUNC(int_sk_type), 522 [META_ID(SK_RMEM_ALLOC)] = META_FUNC(int_sk_rmem_alloc), 523 [META_ID(SK_WMEM_ALLOC)] = META_FUNC(int_sk_wmem_alloc), 524 [META_ID(SK_OMEM_ALLOC)] = META_FUNC(int_sk_omem_alloc), 525 [META_ID(SK_WMEM_QUEUED)] = META_FUNC(int_sk_wmem_queued), 526 [META_ID(SK_RCV_QLEN)] = META_FUNC(int_sk_rcv_qlen), 527 [META_ID(SK_SND_QLEN)] = META_FUNC(int_sk_snd_qlen), 528 [META_ID(SK_ERR_QLEN)] = META_FUNC(int_sk_err_qlen), 529 [META_ID(SK_FORWARD_ALLOCS)] = META_FUNC(int_sk_fwd_alloc), 530 [META_ID(SK_ALLOCS)] = META_FUNC(int_sk_alloc), 531 [META_ID(SK_ROUTE_CAPS)] = META_FUNC(int_sk_route_caps), 532 [META_ID(SK_HASH)] = META_FUNC(int_sk_hash), 533 [META_ID(SK_LINGERTIME)] = META_FUNC(int_sk_lingertime), 534 [META_ID(SK_ACK_BACKLOG)] = META_FUNC(int_sk_ack_bl), 535 [META_ID(SK_MAX_ACK_BACKLOG)] = META_FUNC(int_sk_max_ack_bl), 536 [META_ID(SK_PRIO)] = META_FUNC(int_sk_prio), 537 [META_ID(SK_RCVLOWAT)] = META_FUNC(int_sk_rcvlowat), 538 [META_ID(SK_RCVTIMEO)] = META_FUNC(int_sk_rcvtimeo), 539 [META_ID(SK_SNDTIMEO)] = META_FUNC(int_sk_sndtimeo), 540 [META_ID(SK_SENDMSG_OFF)] = META_FUNC(int_sk_sendmsg_off), 541 [META_ID(SK_WRITE_PENDING)] = META_FUNC(int_sk_write_pend), 542 [META_ID(VLAN_TAG)] = META_FUNC(int_vlan_tag), 543 } 544 }; 545 546 static inline struct meta_ops * meta_ops(struct meta_value *val) 547 { 548 return &__meta_ops[meta_type(val)][meta_id(val)]; 549 } 550 551 /************************************************************************** 552 * Type specific operations for TCF_META_TYPE_VAR 553 **************************************************************************/ 554 555 static int meta_var_compare(struct meta_obj *a, struct meta_obj *b) 556 { 557 int r = a->len - b->len; 558 559 if (r == 0) 560 r = memcmp((void *) a->value, (void *) b->value, a->len); 561 562 return r; 563 } 564 565 static int meta_var_change(struct meta_value *dst, struct nlattr *nla) 566 { 567 int len = nla_len(nla); 568 569 dst->val = (unsigned long)kmemdup(nla_data(nla), len, GFP_KERNEL); 570 if (dst->val == 0UL) 571 return -ENOMEM; 572 dst->len = len; 573 return 0; 574 } 575 576 static void meta_var_destroy(struct meta_value *v) 577 { 578 kfree((void *) v->val); 579 } 580 581 static void meta_var_apply_extras(struct meta_value *v, 582 struct meta_obj *dst) 583 { 584 int shift = v->hdr.shift; 585 586 if (shift && shift < dst->len) 587 dst->len -= shift; 588 } 589 590 static int meta_var_dump(struct sk_buff *skb, struct meta_value *v, int tlv) 591 { 592 if (v->val && v->len) 593 NLA_PUT(skb, tlv, v->len, (void *) v->val); 594 return 0; 595 596 nla_put_failure: 597 return -1; 598 } 599 600 /************************************************************************** 601 * Type specific operations for TCF_META_TYPE_INT 602 **************************************************************************/ 603 604 static int meta_int_compare(struct meta_obj *a, struct meta_obj *b) 605 { 606 /* Let gcc optimize it, the unlikely is not really based on 607 * some numbers but jump free code for mismatches seems 608 * more logical. */ 609 if (unlikely(a->value == b->value)) 610 return 0; 611 else if (a->value < b->value) 612 return -1; 613 else 614 return 1; 615 } 616 617 static int meta_int_change(struct meta_value *dst, struct nlattr *nla) 618 { 619 if (nla_len(nla) >= sizeof(unsigned long)) { 620 dst->val = *(unsigned long *) nla_data(nla); 621 dst->len = sizeof(unsigned long); 622 } else if (nla_len(nla) == sizeof(u32)) { 623 dst->val = nla_get_u32(nla); 624 dst->len = sizeof(u32); 625 } else 626 return -EINVAL; 627 628 return 0; 629 } 630 631 static void meta_int_apply_extras(struct meta_value *v, 632 struct meta_obj *dst) 633 { 634 if (v->hdr.shift) 635 dst->value >>= v->hdr.shift; 636 637 if (v->val) 638 dst->value &= v->val; 639 } 640 641 static int meta_int_dump(struct sk_buff *skb, struct meta_value *v, int tlv) 642 { 643 if (v->len == sizeof(unsigned long)) 644 NLA_PUT(skb, tlv, sizeof(unsigned long), &v->val); 645 else if (v->len == sizeof(u32)) { 646 NLA_PUT_U32(skb, tlv, v->val); 647 } 648 649 return 0; 650 651 nla_put_failure: 652 return -1; 653 } 654 655 /************************************************************************** 656 * Type specific operations table 657 **************************************************************************/ 658 659 struct meta_type_ops 660 { 661 void (*destroy)(struct meta_value *); 662 int (*compare)(struct meta_obj *, struct meta_obj *); 663 int (*change)(struct meta_value *, struct nlattr *); 664 void (*apply_extras)(struct meta_value *, struct meta_obj *); 665 int (*dump)(struct sk_buff *, struct meta_value *, int); 666 }; 667 668 static struct meta_type_ops __meta_type_ops[TCF_META_TYPE_MAX+1] = { 669 [TCF_META_TYPE_VAR] = { 670 .destroy = meta_var_destroy, 671 .compare = meta_var_compare, 672 .change = meta_var_change, 673 .apply_extras = meta_var_apply_extras, 674 .dump = meta_var_dump 675 }, 676 [TCF_META_TYPE_INT] = { 677 .compare = meta_int_compare, 678 .change = meta_int_change, 679 .apply_extras = meta_int_apply_extras, 680 .dump = meta_int_dump 681 } 682 }; 683 684 static inline struct meta_type_ops * meta_type_ops(struct meta_value *v) 685 { 686 return &__meta_type_ops[meta_type(v)]; 687 } 688 689 /************************************************************************** 690 * Core 691 **************************************************************************/ 692 693 static int meta_get(struct sk_buff *skb, struct tcf_pkt_info *info, 694 struct meta_value *v, struct meta_obj *dst) 695 { 696 int err = 0; 697 698 if (meta_id(v) == TCF_META_ID_VALUE) { 699 dst->value = v->val; 700 dst->len = v->len; 701 return 0; 702 } 703 704 meta_ops(v)->get(skb, info, v, dst, &err); 705 if (err < 0) 706 return err; 707 708 if (meta_type_ops(v)->apply_extras) 709 meta_type_ops(v)->apply_extras(v, dst); 710 711 return 0; 712 } 713 714 static int em_meta_match(struct sk_buff *skb, struct tcf_ematch *m, 715 struct tcf_pkt_info *info) 716 { 717 int r; 718 struct meta_match *meta = (struct meta_match *) m->data; 719 struct meta_obj l_value, r_value; 720 721 if (meta_get(skb, info, &meta->lvalue, &l_value) < 0 || 722 meta_get(skb, info, &meta->rvalue, &r_value) < 0) 723 return 0; 724 725 r = meta_type_ops(&meta->lvalue)->compare(&l_value, &r_value); 726 727 switch (meta->lvalue.hdr.op) { 728 case TCF_EM_OPND_EQ: 729 return !r; 730 case TCF_EM_OPND_LT: 731 return r < 0; 732 case TCF_EM_OPND_GT: 733 return r > 0; 734 } 735 736 return 0; 737 } 738 739 static void meta_delete(struct meta_match *meta) 740 { 741 if (meta) { 742 struct meta_type_ops *ops = meta_type_ops(&meta->lvalue); 743 744 if (ops && ops->destroy) { 745 ops->destroy(&meta->lvalue); 746 ops->destroy(&meta->rvalue); 747 } 748 } 749 750 kfree(meta); 751 } 752 753 static inline int meta_change_data(struct meta_value *dst, struct nlattr *nla) 754 { 755 if (nla) { 756 if (nla_len(nla) == 0) 757 return -EINVAL; 758 759 return meta_type_ops(dst)->change(dst, nla); 760 } 761 762 return 0; 763 } 764 765 static inline int meta_is_supported(struct meta_value *val) 766 { 767 return (!meta_id(val) || meta_ops(val)->get); 768 } 769 770 static const struct nla_policy meta_policy[TCA_EM_META_MAX + 1] = { 771 [TCA_EM_META_HDR] = { .len = sizeof(struct tcf_meta_hdr) }, 772 }; 773 774 static int em_meta_change(struct tcf_proto *tp, void *data, int len, 775 struct tcf_ematch *m) 776 { 777 int err; 778 struct nlattr *tb[TCA_EM_META_MAX + 1]; 779 struct tcf_meta_hdr *hdr; 780 struct meta_match *meta = NULL; 781 782 err = nla_parse(tb, TCA_EM_META_MAX, data, len, meta_policy); 783 if (err < 0) 784 goto errout; 785 786 err = -EINVAL; 787 if (tb[TCA_EM_META_HDR] == NULL) 788 goto errout; 789 hdr = nla_data(tb[TCA_EM_META_HDR]); 790 791 if (TCF_META_TYPE(hdr->left.kind) != TCF_META_TYPE(hdr->right.kind) || 792 TCF_META_TYPE(hdr->left.kind) > TCF_META_TYPE_MAX || 793 TCF_META_ID(hdr->left.kind) > TCF_META_ID_MAX || 794 TCF_META_ID(hdr->right.kind) > TCF_META_ID_MAX) 795 goto errout; 796 797 meta = kzalloc(sizeof(*meta), GFP_KERNEL); 798 if (meta == NULL) 799 goto errout; 800 801 memcpy(&meta->lvalue.hdr, &hdr->left, sizeof(hdr->left)); 802 memcpy(&meta->rvalue.hdr, &hdr->right, sizeof(hdr->right)); 803 804 if (!meta_is_supported(&meta->lvalue) || 805 !meta_is_supported(&meta->rvalue)) { 806 err = -EOPNOTSUPP; 807 goto errout; 808 } 809 810 if (meta_change_data(&meta->lvalue, tb[TCA_EM_META_LVALUE]) < 0 || 811 meta_change_data(&meta->rvalue, tb[TCA_EM_META_RVALUE]) < 0) 812 goto errout; 813 814 m->datalen = sizeof(*meta); 815 m->data = (unsigned long) meta; 816 817 err = 0; 818 errout: 819 if (err && meta) 820 meta_delete(meta); 821 return err; 822 } 823 824 static void em_meta_destroy(struct tcf_proto *tp, struct tcf_ematch *m) 825 { 826 if (m) 827 meta_delete((struct meta_match *) m->data); 828 } 829 830 static int em_meta_dump(struct sk_buff *skb, struct tcf_ematch *em) 831 { 832 struct meta_match *meta = (struct meta_match *) em->data; 833 struct tcf_meta_hdr hdr; 834 struct meta_type_ops *ops; 835 836 memset(&hdr, 0, sizeof(hdr)); 837 memcpy(&hdr.left, &meta->lvalue.hdr, sizeof(hdr.left)); 838 memcpy(&hdr.right, &meta->rvalue.hdr, sizeof(hdr.right)); 839 840 NLA_PUT(skb, TCA_EM_META_HDR, sizeof(hdr), &hdr); 841 842 ops = meta_type_ops(&meta->lvalue); 843 if (ops->dump(skb, &meta->lvalue, TCA_EM_META_LVALUE) < 0 || 844 ops->dump(skb, &meta->rvalue, TCA_EM_META_RVALUE) < 0) 845 goto nla_put_failure; 846 847 return 0; 848 849 nla_put_failure: 850 return -1; 851 } 852 853 static struct tcf_ematch_ops em_meta_ops = { 854 .kind = TCF_EM_META, 855 .change = em_meta_change, 856 .match = em_meta_match, 857 .destroy = em_meta_destroy, 858 .dump = em_meta_dump, 859 .owner = THIS_MODULE, 860 .link = LIST_HEAD_INIT(em_meta_ops.link) 861 }; 862 863 static int __init init_em_meta(void) 864 { 865 return tcf_em_register(&em_meta_ops); 866 } 867 868 static void __exit exit_em_meta(void) 869 { 870 tcf_em_unregister(&em_meta_ops); 871 } 872 873 MODULE_LICENSE("GPL"); 874 875 module_init(init_em_meta); 876 module_exit(exit_em_meta); 877 878 MODULE_ALIAS_TCF_EMATCH(TCF_EM_META); 879