1 /* 2 * net/sched/ife.c Inter-FE action based on ForCES WG InterFE LFB 3 * 4 * Refer to: 5 * draft-ietf-forces-interfelfb-03 6 * and 7 * netdev01 paper: 8 * "Distributing Linux Traffic Control Classifier-Action 9 * Subsystem" 10 * Authors: Jamal Hadi Salim and Damascene M. Joachimpillai 11 * 12 * This program is free software; you can redistribute it and/or 13 * modify it under the terms of the GNU General Public License 14 * as published by the Free Software Foundation; either version 15 * 2 of the License, or (at your option) any later version. 16 * 17 * copyright Jamal Hadi Salim (2015) 18 * 19 */ 20 21 #include <linux/types.h> 22 #include <linux/kernel.h> 23 #include <linux/string.h> 24 #include <linux/errno.h> 25 #include <linux/skbuff.h> 26 #include <linux/rtnetlink.h> 27 #include <linux/module.h> 28 #include <linux/init.h> 29 #include <net/net_namespace.h> 30 #include <net/netlink.h> 31 #include <net/pkt_sched.h> 32 #include <uapi/linux/tc_act/tc_ife.h> 33 #include <net/tc_act/tc_ife.h> 34 #include <linux/etherdevice.h> 35 36 #define IFE_TAB_MASK 15 37 38 static int ife_net_id; 39 static int max_metacnt = IFE_META_MAX + 1; 40 static struct tc_action_ops act_ife_ops; 41 42 static const struct nla_policy ife_policy[TCA_IFE_MAX + 1] = { 43 [TCA_IFE_PARMS] = { .len = sizeof(struct tc_ife)}, 44 [TCA_IFE_DMAC] = { .len = ETH_ALEN}, 45 [TCA_IFE_SMAC] = { .len = ETH_ALEN}, 46 [TCA_IFE_TYPE] = { .type = NLA_U16}, 47 }; 48 49 /* Caller takes care of presenting data in network order 50 */ 51 int ife_tlv_meta_encode(void *skbdata, u16 attrtype, u16 dlen, const void *dval) 52 { 53 u32 *tlv = (u32 *)(skbdata); 54 u16 totlen = nla_total_size(dlen); /*alignment + hdr */ 55 char *dptr = (char *)tlv + NLA_HDRLEN; 56 u32 htlv = attrtype << 16 | totlen; 57 58 *tlv = htonl(htlv); 59 memset(dptr, 0, totlen - NLA_HDRLEN); 60 memcpy(dptr, dval, dlen); 61 62 return totlen; 63 } 64 EXPORT_SYMBOL_GPL(ife_tlv_meta_encode); 65 66 int ife_get_meta_u32(struct sk_buff *skb, struct tcf_meta_info *mi) 67 { 68 if (mi->metaval) 69 return nla_put_u32(skb, mi->metaid, *(u32 *)mi->metaval); 70 else 71 return nla_put(skb, mi->metaid, 0, NULL); 72 } 73 EXPORT_SYMBOL_GPL(ife_get_meta_u32); 74 75 int ife_check_meta_u32(u32 metaval, struct tcf_meta_info *mi) 76 { 77 if (metaval || mi->metaval) 78 return 8; /* T+L+V == 2+2+4 */ 79 80 return 0; 81 } 82 EXPORT_SYMBOL_GPL(ife_check_meta_u32); 83 84 int ife_encode_meta_u32(u32 metaval, void *skbdata, struct tcf_meta_info *mi) 85 { 86 u32 edata = metaval; 87 88 if (mi->metaval) 89 edata = *(u32 *)mi->metaval; 90 else if (metaval) 91 edata = metaval; 92 93 if (!edata) /* will not encode */ 94 return 0; 95 96 edata = htonl(edata); 97 return ife_tlv_meta_encode(skbdata, mi->metaid, 4, &edata); 98 } 99 EXPORT_SYMBOL_GPL(ife_encode_meta_u32); 100 101 int ife_get_meta_u16(struct sk_buff *skb, struct tcf_meta_info *mi) 102 { 103 if (mi->metaval) 104 return nla_put_u16(skb, mi->metaid, *(u16 *)mi->metaval); 105 else 106 return nla_put(skb, mi->metaid, 0, NULL); 107 } 108 EXPORT_SYMBOL_GPL(ife_get_meta_u16); 109 110 int ife_alloc_meta_u32(struct tcf_meta_info *mi, void *metaval, gfp_t gfp) 111 { 112 mi->metaval = kmemdup(metaval, sizeof(u32), gfp); 113 if (!mi->metaval) 114 return -ENOMEM; 115 116 return 0; 117 } 118 EXPORT_SYMBOL_GPL(ife_alloc_meta_u32); 119 120 int ife_alloc_meta_u16(struct tcf_meta_info *mi, void *metaval, gfp_t gfp) 121 { 122 mi->metaval = kmemdup(metaval, sizeof(u16), gfp); 123 if (!mi->metaval) 124 return -ENOMEM; 125 126 return 0; 127 } 128 EXPORT_SYMBOL_GPL(ife_alloc_meta_u16); 129 130 void ife_release_meta_gen(struct tcf_meta_info *mi) 131 { 132 kfree(mi->metaval); 133 } 134 EXPORT_SYMBOL_GPL(ife_release_meta_gen); 135 136 int ife_validate_meta_u32(void *val, int len) 137 { 138 if (len == 4) 139 return 0; 140 141 return -EINVAL; 142 } 143 EXPORT_SYMBOL_GPL(ife_validate_meta_u32); 144 145 int ife_validate_meta_u16(void *val, int len) 146 { 147 /* length will include padding */ 148 if (len == NLA_ALIGN(2)) 149 return 0; 150 151 return -EINVAL; 152 } 153 EXPORT_SYMBOL_GPL(ife_validate_meta_u16); 154 155 static LIST_HEAD(ifeoplist); 156 static DEFINE_RWLOCK(ife_mod_lock); 157 158 static struct tcf_meta_ops *find_ife_oplist(u16 metaid) 159 { 160 struct tcf_meta_ops *o; 161 162 read_lock(&ife_mod_lock); 163 list_for_each_entry(o, &ifeoplist, list) { 164 if (o->metaid == metaid) { 165 if (!try_module_get(o->owner)) 166 o = NULL; 167 read_unlock(&ife_mod_lock); 168 return o; 169 } 170 } 171 read_unlock(&ife_mod_lock); 172 173 return NULL; 174 } 175 176 int register_ife_op(struct tcf_meta_ops *mops) 177 { 178 struct tcf_meta_ops *m; 179 180 if (!mops->metaid || !mops->metatype || !mops->name || 181 !mops->check_presence || !mops->encode || !mops->decode || 182 !mops->get || !mops->alloc) 183 return -EINVAL; 184 185 write_lock(&ife_mod_lock); 186 187 list_for_each_entry(m, &ifeoplist, list) { 188 if (m->metaid == mops->metaid || 189 (strcmp(mops->name, m->name) == 0)) { 190 write_unlock(&ife_mod_lock); 191 return -EEXIST; 192 } 193 } 194 195 if (!mops->release) 196 mops->release = ife_release_meta_gen; 197 198 list_add_tail(&mops->list, &ifeoplist); 199 write_unlock(&ife_mod_lock); 200 return 0; 201 } 202 EXPORT_SYMBOL_GPL(unregister_ife_op); 203 204 int unregister_ife_op(struct tcf_meta_ops *mops) 205 { 206 struct tcf_meta_ops *m; 207 int err = -ENOENT; 208 209 write_lock(&ife_mod_lock); 210 list_for_each_entry(m, &ifeoplist, list) { 211 if (m->metaid == mops->metaid) { 212 list_del(&mops->list); 213 err = 0; 214 break; 215 } 216 } 217 write_unlock(&ife_mod_lock); 218 219 return err; 220 } 221 EXPORT_SYMBOL_GPL(register_ife_op); 222 223 static int ife_validate_metatype(struct tcf_meta_ops *ops, void *val, int len) 224 { 225 int ret = 0; 226 /* XXX: unfortunately cant use nla_policy at this point 227 * because a length of 0 is valid in the case of 228 * "allow". "use" semantics do enforce for proper 229 * length and i couldve use nla_policy but it makes it hard 230 * to use it just for that.. 231 */ 232 if (ops->validate) 233 return ops->validate(val, len); 234 235 if (ops->metatype == NLA_U32) 236 ret = ife_validate_meta_u32(val, len); 237 else if (ops->metatype == NLA_U16) 238 ret = ife_validate_meta_u16(val, len); 239 240 return ret; 241 } 242 243 /* called when adding new meta information 244 * under ife->tcf_lock for existing action 245 */ 246 static int load_metaops_and_vet(struct tcf_ife_info *ife, u32 metaid, 247 void *val, int len, bool exists) 248 { 249 struct tcf_meta_ops *ops = find_ife_oplist(metaid); 250 int ret = 0; 251 252 if (!ops) { 253 ret = -ENOENT; 254 #ifdef CONFIG_MODULES 255 if (exists) 256 spin_unlock_bh(&ife->tcf_lock); 257 rtnl_unlock(); 258 request_module("ifemeta%u", metaid); 259 rtnl_lock(); 260 if (exists) 261 spin_lock_bh(&ife->tcf_lock); 262 ops = find_ife_oplist(metaid); 263 #endif 264 } 265 266 if (ops) { 267 ret = 0; 268 if (len) 269 ret = ife_validate_metatype(ops, val, len); 270 271 module_put(ops->owner); 272 } 273 274 return ret; 275 } 276 277 /* called when adding new meta information 278 * under ife->tcf_lock for existing action 279 */ 280 static int add_metainfo(struct tcf_ife_info *ife, u32 metaid, void *metaval, 281 int len, bool atomic) 282 { 283 struct tcf_meta_info *mi = NULL; 284 struct tcf_meta_ops *ops = find_ife_oplist(metaid); 285 int ret = 0; 286 287 if (!ops) 288 return -ENOENT; 289 290 mi = kzalloc(sizeof(*mi), atomic ? GFP_ATOMIC : GFP_KERNEL); 291 if (!mi) { 292 /*put back what find_ife_oplist took */ 293 module_put(ops->owner); 294 return -ENOMEM; 295 } 296 297 mi->metaid = metaid; 298 mi->ops = ops; 299 if (len > 0) { 300 ret = ops->alloc(mi, metaval, atomic ? GFP_ATOMIC : GFP_KERNEL); 301 if (ret != 0) { 302 kfree(mi); 303 module_put(ops->owner); 304 return ret; 305 } 306 } 307 308 list_add_tail(&mi->metalist, &ife->metalist); 309 310 return ret; 311 } 312 313 static int use_all_metadata(struct tcf_ife_info *ife) 314 { 315 struct tcf_meta_ops *o; 316 int rc = 0; 317 int installed = 0; 318 319 read_lock(&ife_mod_lock); 320 list_for_each_entry(o, &ifeoplist, list) { 321 rc = add_metainfo(ife, o->metaid, NULL, 0, true); 322 if (rc == 0) 323 installed += 1; 324 } 325 read_unlock(&ife_mod_lock); 326 327 if (installed) 328 return 0; 329 else 330 return -EINVAL; 331 } 332 333 static int dump_metalist(struct sk_buff *skb, struct tcf_ife_info *ife) 334 { 335 struct tcf_meta_info *e; 336 struct nlattr *nest; 337 unsigned char *b = skb_tail_pointer(skb); 338 int total_encoded = 0; 339 340 /*can only happen on decode */ 341 if (list_empty(&ife->metalist)) 342 return 0; 343 344 nest = nla_nest_start(skb, TCA_IFE_METALST); 345 if (!nest) 346 goto out_nlmsg_trim; 347 348 list_for_each_entry(e, &ife->metalist, metalist) { 349 if (!e->ops->get(skb, e)) 350 total_encoded += 1; 351 } 352 353 if (!total_encoded) 354 goto out_nlmsg_trim; 355 356 nla_nest_end(skb, nest); 357 358 return 0; 359 360 out_nlmsg_trim: 361 nlmsg_trim(skb, b); 362 return -1; 363 } 364 365 /* under ife->tcf_lock */ 366 static void _tcf_ife_cleanup(struct tc_action *a, int bind) 367 { 368 struct tcf_ife_info *ife = to_ife(a); 369 struct tcf_meta_info *e, *n; 370 371 list_for_each_entry_safe(e, n, &ife->metalist, metalist) { 372 module_put(e->ops->owner); 373 list_del(&e->metalist); 374 if (e->metaval) { 375 if (e->ops->release) 376 e->ops->release(e); 377 else 378 kfree(e->metaval); 379 } 380 kfree(e); 381 } 382 } 383 384 static void tcf_ife_cleanup(struct tc_action *a, int bind) 385 { 386 struct tcf_ife_info *ife = to_ife(a); 387 388 spin_lock_bh(&ife->tcf_lock); 389 _tcf_ife_cleanup(a, bind); 390 spin_unlock_bh(&ife->tcf_lock); 391 } 392 393 /* under ife->tcf_lock for existing action */ 394 static int populate_metalist(struct tcf_ife_info *ife, struct nlattr **tb, 395 bool exists) 396 { 397 int len = 0; 398 int rc = 0; 399 int i = 0; 400 void *val; 401 402 for (i = 1; i < max_metacnt; i++) { 403 if (tb[i]) { 404 val = nla_data(tb[i]); 405 len = nla_len(tb[i]); 406 407 rc = load_metaops_and_vet(ife, i, val, len, exists); 408 if (rc != 0) 409 return rc; 410 411 rc = add_metainfo(ife, i, val, len, exists); 412 if (rc) 413 return rc; 414 } 415 } 416 417 return rc; 418 } 419 420 static int tcf_ife_init(struct net *net, struct nlattr *nla, 421 struct nlattr *est, struct tc_action **a, 422 int ovr, int bind) 423 { 424 struct tc_action_net *tn = net_generic(net, ife_net_id); 425 struct nlattr *tb[TCA_IFE_MAX + 1]; 426 struct nlattr *tb2[IFE_META_MAX + 1]; 427 struct tcf_ife_info *ife; 428 struct tc_ife *parm; 429 u16 ife_type = 0; 430 u8 *daddr = NULL; 431 u8 *saddr = NULL; 432 bool exists = false; 433 int ret = 0; 434 int err; 435 436 err = nla_parse_nested(tb, TCA_IFE_MAX, nla, ife_policy); 437 if (err < 0) 438 return err; 439 440 if (!tb[TCA_IFE_PARMS]) 441 return -EINVAL; 442 443 parm = nla_data(tb[TCA_IFE_PARMS]); 444 445 exists = tcf_hash_check(tn, parm->index, a, bind); 446 if (exists && bind) 447 return 0; 448 449 if (parm->flags & IFE_ENCODE) { 450 /* Until we get issued the ethertype, we cant have 451 * a default.. 452 **/ 453 if (!tb[TCA_IFE_TYPE]) { 454 if (exists) 455 tcf_hash_release(*a, bind); 456 pr_info("You MUST pass etherype for encoding\n"); 457 return -EINVAL; 458 } 459 } 460 461 if (!exists) { 462 ret = tcf_hash_create(tn, parm->index, est, a, &act_ife_ops, 463 bind, false); 464 if (ret) 465 return ret; 466 ret = ACT_P_CREATED; 467 } else { 468 tcf_hash_release(*a, bind); 469 if (!ovr) 470 return -EEXIST; 471 } 472 473 ife = to_ife(*a); 474 ife->flags = parm->flags; 475 476 if (parm->flags & IFE_ENCODE) { 477 ife_type = nla_get_u16(tb[TCA_IFE_TYPE]); 478 if (tb[TCA_IFE_DMAC]) 479 daddr = nla_data(tb[TCA_IFE_DMAC]); 480 if (tb[TCA_IFE_SMAC]) 481 saddr = nla_data(tb[TCA_IFE_SMAC]); 482 } 483 484 if (exists) 485 spin_lock_bh(&ife->tcf_lock); 486 ife->tcf_action = parm->action; 487 488 if (parm->flags & IFE_ENCODE) { 489 if (daddr) 490 ether_addr_copy(ife->eth_dst, daddr); 491 else 492 eth_zero_addr(ife->eth_dst); 493 494 if (saddr) 495 ether_addr_copy(ife->eth_src, saddr); 496 else 497 eth_zero_addr(ife->eth_src); 498 499 ife->eth_type = ife_type; 500 } 501 502 if (ret == ACT_P_CREATED) 503 INIT_LIST_HEAD(&ife->metalist); 504 505 if (tb[TCA_IFE_METALST]) { 506 err = nla_parse_nested(tb2, IFE_META_MAX, tb[TCA_IFE_METALST], 507 NULL); 508 if (err) { 509 metadata_parse_err: 510 if (exists) 511 tcf_hash_release(*a, bind); 512 if (ret == ACT_P_CREATED) 513 _tcf_ife_cleanup(*a, bind); 514 515 if (exists) 516 spin_unlock_bh(&ife->tcf_lock); 517 return err; 518 } 519 520 err = populate_metalist(ife, tb2, exists); 521 if (err) 522 goto metadata_parse_err; 523 524 } else { 525 /* if no passed metadata allow list or passed allow-all 526 * then here we process by adding as many supported metadatum 527 * as we can. You better have at least one else we are 528 * going to bail out 529 */ 530 err = use_all_metadata(ife); 531 if (err) { 532 if (ret == ACT_P_CREATED) 533 _tcf_ife_cleanup(*a, bind); 534 535 if (exists) 536 spin_unlock_bh(&ife->tcf_lock); 537 return err; 538 } 539 } 540 541 if (exists) 542 spin_unlock_bh(&ife->tcf_lock); 543 544 if (ret == ACT_P_CREATED) 545 tcf_hash_insert(tn, *a); 546 547 return ret; 548 } 549 550 static int tcf_ife_dump(struct sk_buff *skb, struct tc_action *a, int bind, 551 int ref) 552 { 553 unsigned char *b = skb_tail_pointer(skb); 554 struct tcf_ife_info *ife = to_ife(a); 555 struct tc_ife opt = { 556 .index = ife->tcf_index, 557 .refcnt = ife->tcf_refcnt - ref, 558 .bindcnt = ife->tcf_bindcnt - bind, 559 .action = ife->tcf_action, 560 .flags = ife->flags, 561 }; 562 struct tcf_t t; 563 564 if (nla_put(skb, TCA_IFE_PARMS, sizeof(opt), &opt)) 565 goto nla_put_failure; 566 567 tcf_tm_dump(&t, &ife->tcf_tm); 568 if (nla_put_64bit(skb, TCA_IFE_TM, sizeof(t), &t, TCA_IFE_PAD)) 569 goto nla_put_failure; 570 571 if (!is_zero_ether_addr(ife->eth_dst)) { 572 if (nla_put(skb, TCA_IFE_DMAC, ETH_ALEN, ife->eth_dst)) 573 goto nla_put_failure; 574 } 575 576 if (!is_zero_ether_addr(ife->eth_src)) { 577 if (nla_put(skb, TCA_IFE_SMAC, ETH_ALEN, ife->eth_src)) 578 goto nla_put_failure; 579 } 580 581 if (nla_put(skb, TCA_IFE_TYPE, 2, &ife->eth_type)) 582 goto nla_put_failure; 583 584 if (dump_metalist(skb, ife)) { 585 /*ignore failure to dump metalist */ 586 pr_info("Failed to dump metalist\n"); 587 } 588 589 return skb->len; 590 591 nla_put_failure: 592 nlmsg_trim(skb, b); 593 return -1; 594 } 595 596 int find_decode_metaid(struct sk_buff *skb, struct tcf_ife_info *ife, 597 u16 metaid, u16 mlen, void *mdata) 598 { 599 struct tcf_meta_info *e; 600 601 /* XXX: use hash to speed up */ 602 list_for_each_entry(e, &ife->metalist, metalist) { 603 if (metaid == e->metaid) { 604 if (e->ops) { 605 /* We check for decode presence already */ 606 return e->ops->decode(skb, mdata, mlen); 607 } 608 } 609 } 610 611 return 0; 612 } 613 614 struct ifeheadr { 615 __be16 metalen; 616 u8 tlv_data[]; 617 }; 618 619 struct meta_tlvhdr { 620 __be16 type; 621 __be16 len; 622 }; 623 624 static int tcf_ife_decode(struct sk_buff *skb, const struct tc_action *a, 625 struct tcf_result *res) 626 { 627 struct tcf_ife_info *ife = to_ife(a); 628 int action = ife->tcf_action; 629 struct ifeheadr *ifehdr = (struct ifeheadr *)skb->data; 630 u16 ifehdrln = ifehdr->metalen; 631 struct meta_tlvhdr *tlv = (struct meta_tlvhdr *)(ifehdr->tlv_data); 632 633 spin_lock(&ife->tcf_lock); 634 bstats_update(&ife->tcf_bstats, skb); 635 tcf_lastuse_update(&ife->tcf_tm); 636 spin_unlock(&ife->tcf_lock); 637 638 ifehdrln = ntohs(ifehdrln); 639 if (unlikely(!pskb_may_pull(skb, ifehdrln))) { 640 spin_lock(&ife->tcf_lock); 641 ife->tcf_qstats.drops++; 642 spin_unlock(&ife->tcf_lock); 643 return TC_ACT_SHOT; 644 } 645 646 skb_set_mac_header(skb, ifehdrln); 647 __skb_pull(skb, ifehdrln); 648 skb->protocol = eth_type_trans(skb, skb->dev); 649 ifehdrln -= IFE_METAHDRLEN; 650 651 while (ifehdrln > 0) { 652 u8 *tlvdata = (u8 *)tlv; 653 u16 mtype = tlv->type; 654 u16 mlen = tlv->len; 655 656 mtype = ntohs(mtype); 657 mlen = ntohs(mlen); 658 659 if (find_decode_metaid(skb, ife, mtype, (mlen - 4), 660 (void *)(tlvdata + 4))) { 661 /* abuse overlimits to count when we receive metadata 662 * but dont have an ops for it 663 */ 664 pr_info_ratelimited("Unknown metaid %d alnlen %d\n", 665 mtype, mlen); 666 ife->tcf_qstats.overlimits++; 667 } 668 669 tlvdata += mlen; 670 ifehdrln -= mlen; 671 tlv = (struct meta_tlvhdr *)tlvdata; 672 } 673 674 skb_reset_network_header(skb); 675 return action; 676 } 677 678 /*XXX: check if we can do this at install time instead of current 679 * send data path 680 **/ 681 static int ife_get_sz(struct sk_buff *skb, struct tcf_ife_info *ife) 682 { 683 struct tcf_meta_info *e, *n; 684 int tot_run_sz = 0, run_sz = 0; 685 686 list_for_each_entry_safe(e, n, &ife->metalist, metalist) { 687 if (e->ops->check_presence) { 688 run_sz = e->ops->check_presence(skb, e); 689 tot_run_sz += run_sz; 690 } 691 } 692 693 return tot_run_sz; 694 } 695 696 static int tcf_ife_encode(struct sk_buff *skb, const struct tc_action *a, 697 struct tcf_result *res) 698 { 699 struct tcf_ife_info *ife = to_ife(a); 700 int action = ife->tcf_action; 701 struct ethhdr *oethh; /* outer ether header */ 702 struct ethhdr *iethh; /* inner eth header */ 703 struct tcf_meta_info *e; 704 /* 705 OUTERHDR:TOTMETALEN:{TLVHDR:Metadatum:TLVHDR..}:ORIGDATA 706 where ORIGDATA = original ethernet header ... 707 */ 708 u16 metalen = ife_get_sz(skb, ife); 709 int hdrm = metalen + skb->dev->hard_header_len + IFE_METAHDRLEN; 710 unsigned int skboff = skb->dev->hard_header_len; 711 u32 at = G_TC_AT(skb->tc_verd); 712 int new_len = skb->len + hdrm; 713 bool exceed_mtu = false; 714 int err; 715 716 if (at & AT_EGRESS) { 717 if (new_len > skb->dev->mtu) 718 exceed_mtu = true; 719 } 720 721 spin_lock(&ife->tcf_lock); 722 bstats_update(&ife->tcf_bstats, skb); 723 tcf_lastuse_update(&ife->tcf_tm); 724 725 if (!metalen) { /* no metadata to send */ 726 /* abuse overlimits to count when we allow packet 727 * with no metadata 728 */ 729 ife->tcf_qstats.overlimits++; 730 spin_unlock(&ife->tcf_lock); 731 return action; 732 } 733 /* could be stupid policy setup or mtu config 734 * so lets be conservative.. */ 735 if ((action == TC_ACT_SHOT) || exceed_mtu) { 736 ife->tcf_qstats.drops++; 737 spin_unlock(&ife->tcf_lock); 738 return TC_ACT_SHOT; 739 } 740 741 iethh = eth_hdr(skb); 742 743 err = skb_cow_head(skb, hdrm); 744 if (unlikely(err)) { 745 ife->tcf_qstats.drops++; 746 spin_unlock(&ife->tcf_lock); 747 return TC_ACT_SHOT; 748 } 749 750 if (!(at & AT_EGRESS)) 751 skb_push(skb, skb->dev->hard_header_len); 752 753 __skb_push(skb, hdrm); 754 memcpy(skb->data, iethh, skb->mac_len); 755 skb_reset_mac_header(skb); 756 oethh = eth_hdr(skb); 757 758 /*total metadata length */ 759 metalen += IFE_METAHDRLEN; 760 metalen = htons(metalen); 761 memcpy((skb->data + skboff), &metalen, IFE_METAHDRLEN); 762 skboff += IFE_METAHDRLEN; 763 764 /* XXX: we dont have a clever way of telling encode to 765 * not repeat some of the computations that are done by 766 * ops->presence_check... 767 */ 768 list_for_each_entry(e, &ife->metalist, metalist) { 769 if (e->ops->encode) { 770 err = e->ops->encode(skb, (void *)(skb->data + skboff), 771 e); 772 } 773 if (err < 0) { 774 /* too corrupt to keep around if overwritten */ 775 ife->tcf_qstats.drops++; 776 spin_unlock(&ife->tcf_lock); 777 return TC_ACT_SHOT; 778 } 779 skboff += err; 780 } 781 782 if (!is_zero_ether_addr(ife->eth_src)) 783 ether_addr_copy(oethh->h_source, ife->eth_src); 784 else 785 ether_addr_copy(oethh->h_source, iethh->h_source); 786 if (!is_zero_ether_addr(ife->eth_dst)) 787 ether_addr_copy(oethh->h_dest, ife->eth_dst); 788 else 789 ether_addr_copy(oethh->h_dest, iethh->h_dest); 790 oethh->h_proto = htons(ife->eth_type); 791 792 if (!(at & AT_EGRESS)) 793 skb_pull(skb, skb->dev->hard_header_len); 794 795 spin_unlock(&ife->tcf_lock); 796 797 return action; 798 } 799 800 static int tcf_ife_act(struct sk_buff *skb, const struct tc_action *a, 801 struct tcf_result *res) 802 { 803 struct tcf_ife_info *ife = to_ife(a); 804 805 if (ife->flags & IFE_ENCODE) 806 return tcf_ife_encode(skb, a, res); 807 808 if (!(ife->flags & IFE_ENCODE)) 809 return tcf_ife_decode(skb, a, res); 810 811 pr_info_ratelimited("unknown failure(policy neither de/encode\n"); 812 spin_lock(&ife->tcf_lock); 813 bstats_update(&ife->tcf_bstats, skb); 814 tcf_lastuse_update(&ife->tcf_tm); 815 ife->tcf_qstats.drops++; 816 spin_unlock(&ife->tcf_lock); 817 818 return TC_ACT_SHOT; 819 } 820 821 static int tcf_ife_walker(struct net *net, struct sk_buff *skb, 822 struct netlink_callback *cb, int type, 823 const struct tc_action_ops *ops) 824 { 825 struct tc_action_net *tn = net_generic(net, ife_net_id); 826 827 return tcf_generic_walker(tn, skb, cb, type, ops); 828 } 829 830 static int tcf_ife_search(struct net *net, struct tc_action **a, u32 index) 831 { 832 struct tc_action_net *tn = net_generic(net, ife_net_id); 833 834 return tcf_hash_search(tn, a, index); 835 } 836 837 static struct tc_action_ops act_ife_ops = { 838 .kind = "ife", 839 .type = TCA_ACT_IFE, 840 .owner = THIS_MODULE, 841 .act = tcf_ife_act, 842 .dump = tcf_ife_dump, 843 .cleanup = tcf_ife_cleanup, 844 .init = tcf_ife_init, 845 .walk = tcf_ife_walker, 846 .lookup = tcf_ife_search, 847 .size = sizeof(struct tcf_ife_info), 848 }; 849 850 static __net_init int ife_init_net(struct net *net) 851 { 852 struct tc_action_net *tn = net_generic(net, ife_net_id); 853 854 return tc_action_net_init(tn, &act_ife_ops, IFE_TAB_MASK); 855 } 856 857 static void __net_exit ife_exit_net(struct net *net) 858 { 859 struct tc_action_net *tn = net_generic(net, ife_net_id); 860 861 tc_action_net_exit(tn); 862 } 863 864 static struct pernet_operations ife_net_ops = { 865 .init = ife_init_net, 866 .exit = ife_exit_net, 867 .id = &ife_net_id, 868 .size = sizeof(struct tc_action_net), 869 }; 870 871 static int __init ife_init_module(void) 872 { 873 return tcf_register_action(&act_ife_ops, &ife_net_ops); 874 } 875 876 static void __exit ife_cleanup_module(void) 877 { 878 tcf_unregister_action(&act_ife_ops, &ife_net_ops); 879 } 880 881 module_init(ife_init_module); 882 module_exit(ife_cleanup_module); 883 884 MODULE_AUTHOR("Jamal Hadi Salim(2015)"); 885 MODULE_DESCRIPTION("Inter-FE LFB action"); 886 MODULE_LICENSE("GPL"); 887