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