net/sched/act_ife.c

   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");