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