sched/act_pedit.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * net/sched/act_pedit.c        Generic packet editor
   4  *
   5  * Authors:     Jamal Hadi Salim (2002-4)
   6  */
   7
   8 #include <linux/types.h>
   9 #include <linux/kernel.h>
  10 #include <linux/string.h>
  11 #include <linux/errno.h>
  12 #include <linux/skbuff.h>
  13 #include <linux/rtnetlink.h>
  14 #include <linux/module.h>
  15 #include <linux/init.h>
  16 #include <linux/ip.h>
  17 #include <linux/ipv6.h>
  18 #include <linux/slab.h>
  19 #include <net/ipv6.h>
  20 #include <net/netlink.h>
  21 #include <net/pkt_sched.h>
  22 #include <linux/tc_act/tc_pedit.h>
  23 #include <net/tc_act/tc_pedit.h>
  24 #include <uapi/linux/tc_act/tc_pedit.h>
  25 #include <net/pkt_cls.h>
  26 #include <net/tc_wrapper.h>
  27
  28 static struct tc_action_ops act_pedit_ops;
  29
  30 static const struct nla_policy pedit_policy[TCA_PEDIT_MAX + 1] = {
  31         [TCA_PEDIT_PARMS]       = { .len = sizeof(struct tc_pedit) },
  32         [TCA_PEDIT_PARMS_EX]    = { .len = sizeof(struct tc_pedit) },
  33         [TCA_PEDIT_KEYS_EX]   = { .type = NLA_NESTED },
  34 };
  35
  36 static const struct nla_policy pedit_key_ex_policy[TCA_PEDIT_KEY_EX_MAX + 1] = {
  37         [TCA_PEDIT_KEY_EX_HTYPE] =
  38                 NLA_POLICY_MAX(NLA_U16, TCA_PEDIT_HDR_TYPE_MAX),
  39         [TCA_PEDIT_KEY_EX_CMD] = NLA_POLICY_MAX(NLA_U16, TCA_PEDIT_CMD_MAX),
  40 };
  41
  42 static struct tcf_pedit_key_ex *tcf_pedit_keys_ex_parse(struct nlattr *nla,
  43                                                         u8 n, struct netlink_ext_ack *extack)
  44 {
  45         struct tcf_pedit_key_ex *keys_ex;
  46         struct tcf_pedit_key_ex *k;
  47         const struct nlattr *ka;
  48         int err = -EINVAL;
  49         int rem;
  50
  51         if (!nla)
  52                 return NULL;
  53
  54         keys_ex = kcalloc(n, sizeof(*k), GFP_KERNEL);
  55         if (!keys_ex)
  56                 return ERR_PTR(-ENOMEM);
  57
  58         k = keys_ex;
  59
  60         nla_for_each_nested(ka, nla, rem) {
  61                 struct nlattr *tb[TCA_PEDIT_KEY_EX_MAX + 1];
  62
  63                 if (!n) {
  64                         NL_SET_ERR_MSG_MOD(extack, "Can't parse more extended keys than requested");
  65                         err = -EINVAL;
  66                         goto err_out;
  67                 }
  68                 n--;
  69
  70                 if (nla_type(ka) != TCA_PEDIT_KEY_EX) {
  71                         NL_SET_ERR_MSG_ATTR(extack, ka, "Unknown attribute, expected extended key");
  72                         err = -EINVAL;
  73                         goto err_out;
  74                 }
  75
  76                 err = nla_parse_nested_deprecated(tb, TCA_PEDIT_KEY_EX_MAX,
  77                                                   ka, pedit_key_ex_policy,
  78                                                   NULL);
  79                 if (err)
  80                         goto err_out;
  81
  82                 if (NL_REQ_ATTR_CHECK(extack, nla, tb, TCA_PEDIT_KEY_EX_HTYPE)) {
  83                         NL_SET_ERR_MSG(extack, "Missing required attribute");
  84                         err = -EINVAL;
  85                         goto err_out;
  86                 }
  87
  88                 if (NL_REQ_ATTR_CHECK(extack, nla, tb, TCA_PEDIT_KEY_EX_CMD)) {
  89                         NL_SET_ERR_MSG(extack, "Missing required attribute");
  90                         err = -EINVAL;
  91                         goto err_out;
  92                 }
  93
  94                 k->htype = nla_get_u16(tb[TCA_PEDIT_KEY_EX_HTYPE]);
  95                 k->cmd = nla_get_u16(tb[TCA_PEDIT_KEY_EX_CMD]);
  96
  97                 k++;
  98         }
  99
 100         if (n) {
 101                 NL_SET_ERR_MSG_MOD(extack, "Not enough extended keys to parse");
 102                 err = -EINVAL;
 103                 goto err_out;
 104         }
 105
 106         return keys_ex;
 107
 108 err_out:
 109         kfree(keys_ex);
 110         return ERR_PTR(err);
 111 }
 112
 113 static int tcf_pedit_key_ex_dump(struct sk_buff *skb,
 114                                  struct tcf_pedit_key_ex *keys_ex, int n)
 115 {
 116         struct nlattr *keys_start = nla_nest_start_noflag(skb,
 117                                                           TCA_PEDIT_KEYS_EX);
 118
 119         if (!keys_start)
 120                 goto nla_failure;
 121         for (; n > 0; n--) {
 122                 struct nlattr *key_start;
 123
 124                 key_start = nla_nest_start_noflag(skb, TCA_PEDIT_KEY_EX);
 125                 if (!key_start)
 126                         goto nla_failure;
 127
 128                 if (nla_put_u16(skb, TCA_PEDIT_KEY_EX_HTYPE, keys_ex->htype) ||
 129                     nla_put_u16(skb, TCA_PEDIT_KEY_EX_CMD, keys_ex->cmd))
 130                         goto nla_failure;
 131
 132                 nla_nest_end(skb, key_start);
 133
 134                 keys_ex++;
 135         }
 136
 137         nla_nest_end(skb, keys_start);
 138
 139         return 0;
 140 nla_failure:
 141         nla_nest_cancel(skb, keys_start);
 142         return -EINVAL;
 143 }
 144
 145 static void tcf_pedit_cleanup_rcu(struct rcu_head *head)
 146 {
 147         struct tcf_pedit_parms *parms =
 148                 container_of(head, struct tcf_pedit_parms, rcu);
 149
 150         kfree(parms->tcfp_keys_ex);
 151         kfree(parms->tcfp_keys);
 152
 153         kfree(parms);
 154 }
 155
 156 static int tcf_pedit_init(struct net *net, struct nlattr *nla,
 157                           struct nlattr *est, struct tc_action **a,
 158                           struct tcf_proto *tp, u32 flags,
 159                           struct netlink_ext_ack *extack)
 160 {
 161         struct tc_action_net *tn = net_generic(net, act_pedit_ops.net_id);
 162         bool bind = flags & TCA_ACT_FLAGS_BIND;
 163         struct tcf_chain *goto_ch = NULL;
 164         struct tcf_pedit_parms *oparms, *nparms;
 165         struct nlattr *tb[TCA_PEDIT_MAX + 1];
 166         struct tc_pedit *parm;
 167         struct nlattr *pattr;
 168         struct tcf_pedit *p;
 169         int ret = 0, err;
 170         int i, ksize;
 171         u32 index;
 172
 173         if (!nla) {
 174                 NL_SET_ERR_MSG_MOD(extack, "Pedit requires attributes to be passed");
 175                 return -EINVAL;
 176         }
 177
 178         err = nla_parse_nested_deprecated(tb, TCA_PEDIT_MAX, nla,
 179                                           pedit_policy, NULL);
 180         if (err < 0)
 181                 return err;
 182
 183         pattr = tb[TCA_PEDIT_PARMS];
 184         if (!pattr)
 185                 pattr = tb[TCA_PEDIT_PARMS_EX];
 186         if (!pattr) {
 187                 NL_SET_ERR_MSG_MOD(extack, "Missing required TCA_PEDIT_PARMS or TCA_PEDIT_PARMS_EX pedit attribute");
 188                 return -EINVAL;
 189         }
 190
 191         parm = nla_data(pattr);
 192
 193         index = parm->index;
 194         err = tcf_idr_check_alloc(tn, &index, a, bind);
 195         if (!err) {
 196                 ret = tcf_idr_create_from_flags(tn, index, est, a,
 197                                                 &act_pedit_ops, bind, flags);
 198                 if (ret) {
 199                         tcf_idr_cleanup(tn, index);
 200                         return ret;
 201                 }
 202                 ret = ACT_P_CREATED;
 203         } else if (err > 0) {
 204                 if (bind)
 205                         return ACT_P_BOUND;
 206                 if (!(flags & TCA_ACT_FLAGS_REPLACE)) {
 207                         ret = -EEXIST;
 208                         goto out_release;
 209                 }
 210         } else {
 211                 return err;
 212         }
 213
 214         if (!parm->nkeys) {
 215                 NL_SET_ERR_MSG_MOD(extack, "Pedit requires keys to be passed");
 216                 ret = -EINVAL;
 217                 goto out_release;
 218         }
 219         ksize = parm->nkeys * sizeof(struct tc_pedit_key);
 220         if (nla_len(pattr) < sizeof(*parm) + ksize) {
 221                 NL_SET_ERR_MSG_ATTR(extack, pattr, "Length of TCA_PEDIT_PARMS or TCA_PEDIT_PARMS_EX pedit attribute is invalid");
 222                 ret = -EINVAL;
 223                 goto out_release;
 224         }
 225
 226         nparms = kzalloc(sizeof(*nparms), GFP_KERNEL);
 227         if (!nparms) {
 228                 ret = -ENOMEM;
 229                 goto out_release;
 230         }
 231
 232         nparms->tcfp_keys_ex =
 233                 tcf_pedit_keys_ex_parse(tb[TCA_PEDIT_KEYS_EX], parm->nkeys, extack);
 234         if (IS_ERR(nparms->tcfp_keys_ex)) {
 235                 ret = PTR_ERR(nparms->tcfp_keys_ex);
 236                 goto out_free;
 237         }
 238
 239         err = tcf_action_check_ctrlact(parm->action, tp, &goto_ch, extack);
 240         if (err < 0) {
 241                 ret = err;
 242                 goto out_free_ex;
 243         }
 244
 245         nparms->tcfp_off_max_hint = 0;
 246         nparms->tcfp_flags = parm->flags;
 247         nparms->tcfp_nkeys = parm->nkeys;
 248
 249         nparms->tcfp_keys = kmemdup(parm->keys, ksize, GFP_KERNEL);
 250         if (!nparms->tcfp_keys) {
 251                 ret = -ENOMEM;
 252                 goto put_chain;
 253         }
 254
 255         for (i = 0; i < nparms->tcfp_nkeys; ++i) {
 256                 u32 offmask = nparms->tcfp_keys[i].offmask;
 257                 u32 cur = nparms->tcfp_keys[i].off;
 258
 259                 /* The AT option can be added to static offsets in the datapath */
 260                 if (!offmask && cur % 4) {
 261                         NL_SET_ERR_MSG_MOD(extack, "Offsets must be on 32bit boundaries");
 262                         ret = -EINVAL;
 263                         goto out_free_keys;
 264                 }
 265
 266                 /* sanitize the shift value for any later use */
 267                 nparms->tcfp_keys[i].shift = min_t(size_t,
 268                                                    BITS_PER_TYPE(int) - 1,
 269                                                    nparms->tcfp_keys[i].shift);
 270
 271                 /* The AT option can read a single byte, we can bound the actual
 272                  * value with uchar max.
 273                  */
 274                 cur += (0xff & offmask) >> nparms->tcfp_keys[i].shift;
 275
 276                 /* Each key touches 4 bytes starting from the computed offset */
 277                 nparms->tcfp_off_max_hint =
 278                         max(nparms->tcfp_off_max_hint, cur + 4);
 279         }
 280
 281         p = to_pedit(*a);
 282
 283         spin_lock_bh(&p->tcf_lock);
 284         goto_ch = tcf_action_set_ctrlact(*a, parm->action, goto_ch);
 285         oparms = rcu_replace_pointer(p->parms, nparms, 1);
 286         spin_unlock_bh(&p->tcf_lock);
 287
 288         if (oparms)
 289                 call_rcu(&oparms->rcu, tcf_pedit_cleanup_rcu);
 290
 291         if (goto_ch)
 292                 tcf_chain_put_by_act(goto_ch);
 293
 294         return ret;
 295
 296 out_free_keys:
 297         kfree(nparms->tcfp_keys);
 298 put_chain:
 299         if (goto_ch)
 300                 tcf_chain_put_by_act(goto_ch);
 301 out_free_ex:
 302         kfree(nparms->tcfp_keys_ex);
 303 out_free:
 304         kfree(nparms);
 305 out_release:
 306         tcf_idr_release(*a, bind);
 307         return ret;
 308 }
 309
 310 static void tcf_pedit_cleanup(struct tc_action *a)
 311 {
 312         struct tcf_pedit *p = to_pedit(a);
 313         struct tcf_pedit_parms *parms;
 314
 315         parms = rcu_dereference_protected(p->parms, 1);
 316
 317         if (parms)
 318                 call_rcu(&parms->rcu, tcf_pedit_cleanup_rcu);
 319 }
 320
 321 static bool offset_valid(struct sk_buff *skb, int offset)
 322 {
 323         if (offset > 0 && offset > skb->len)
 324                 return false;
 325
 326         if  (offset < 0 && -offset > skb_headroom(skb))
 327                 return false;
 328
 329         return true;
 330 }
 331
 332 static int pedit_l4_skb_offset(struct sk_buff *skb, int *hoffset, const int header_type)
 333 {
 334         const int noff = skb_network_offset(skb);
 335         int ret = -EINVAL;
 336         struct iphdr _iph;
 337
 338         switch (skb->protocol) {
 339         case htons(ETH_P_IP): {
 340                 const struct iphdr *iph = skb_header_pointer(skb, noff, sizeof(_iph), &_iph);
 341
 342                 if (!iph)
 343                         goto out;
 344                 *hoffset = noff + iph->ihl * 4;
 345                 ret = 0;
 346                 break;
 347         }
 348         case htons(ETH_P_IPV6):
 349                 ret = ipv6_find_hdr(skb, hoffset, header_type, NULL, NULL) == header_type ? 0 : -EINVAL;
 350                 break;
 351         }
 352 out:
 353         return ret;
 354 }
 355
 356 static int pedit_skb_hdr_offset(struct sk_buff *skb,
 357                                  enum pedit_header_type htype, int *hoffset)
 358 {
 359         int ret = -EINVAL;
 360         /* 'htype' is validated in the netlink parsing */
 361         switch (htype) {
 362         case TCA_PEDIT_KEY_EX_HDR_TYPE_ETH:
 363                 if (skb_mac_header_was_set(skb)) {
 364                         *hoffset = skb_mac_offset(skb);
 365                         ret = 0;
 366                 }
 367                 break;
 368         case TCA_PEDIT_KEY_EX_HDR_TYPE_NETWORK:
 369         case TCA_PEDIT_KEY_EX_HDR_TYPE_IP4:
 370         case TCA_PEDIT_KEY_EX_HDR_TYPE_IP6:
 371                 *hoffset = skb_network_offset(skb);
 372                 ret = 0;
 373                 break;
 374         case TCA_PEDIT_KEY_EX_HDR_TYPE_TCP:
 375                 ret = pedit_l4_skb_offset(skb, hoffset, IPPROTO_TCP);
 376                 break;
 377         case TCA_PEDIT_KEY_EX_HDR_TYPE_UDP:
 378                 ret = pedit_l4_skb_offset(skb, hoffset, IPPROTO_UDP);
 379                 break;
 380         default:
 381                 break;
 382         }
 383         return ret;
 384 }
 385
 386 TC_INDIRECT_SCOPE int tcf_pedit_act(struct sk_buff *skb,
 387                                     const struct tc_action *a,
 388                                     struct tcf_result *res)
 389 {
 390         enum pedit_header_type htype = TCA_PEDIT_KEY_EX_HDR_TYPE_NETWORK;
 391         enum pedit_cmd cmd = TCA_PEDIT_KEY_EX_CMD_SET;
 392         struct tcf_pedit *p = to_pedit(a);
 393         struct tcf_pedit_key_ex *tkey_ex;
 394         struct tcf_pedit_parms *parms;
 395         struct tc_pedit_key *tkey;
 396         u32 max_offset;
 397         int i;
 398
 399         parms = rcu_dereference_bh(p->parms);
 400
 401         max_offset = (skb_transport_header_was_set(skb) ?
 402                       skb_transport_offset(skb) :
 403                       skb_network_offset(skb)) +
 404                      parms->tcfp_off_max_hint;
 405         if (skb_ensure_writable(skb, min(skb->len, max_offset)))
 406                 goto done;
 407
 408         tcf_lastuse_update(&p->tcf_tm);
 409         tcf_action_update_bstats(&p->common, skb);
 410
 411         tkey = parms->tcfp_keys;
 412         tkey_ex = parms->tcfp_keys_ex;
 413
 414         for (i = parms->tcfp_nkeys; i > 0; i--, tkey++) {
 415                 int offset = tkey->off;
 416                 int hoffset = 0;
 417                 u32 *ptr, hdata;
 418                 u32 val;
 419                 int rc;
 420
 421                 if (tkey_ex) {
 422                         htype = tkey_ex->htype;
 423                         cmd = tkey_ex->cmd;
 424
 425                         tkey_ex++;
 426                 }
 427
 428                 rc = pedit_skb_hdr_offset(skb, htype, &hoffset);
 429                 if (rc) {
 430                         pr_info_ratelimited("tc action pedit unable to extract header offset for header type (0x%x)\n", htype);
 431                         goto bad;
 432                 }
 433
 434                 if (tkey->offmask) {
 435                         u8 *d, _d;
 436
 437                         if (!offset_valid(skb, hoffset + tkey->at)) {
 438                                 pr_info_ratelimited("tc action pedit 'at' offset %d out of bounds\n",
 439                                                     hoffset + tkey->at);
 440                                 goto bad;
 441                         }
 442                         d = skb_header_pointer(skb, hoffset + tkey->at,
 443                                                sizeof(_d), &_d);
 444                         if (!d)
 445                                 goto bad;
 446
 447                         offset += (*d & tkey->offmask) >> tkey->shift;
 448                         if (offset % 4) {
 449                                 pr_info_ratelimited("tc action pedit offset must be on 32 bit boundaries\n");
 450                                 goto bad;
 451                         }
 452                 }
 453
 454                 if (!offset_valid(skb, hoffset + offset)) {
 455                         pr_info_ratelimited("tc action pedit offset %d out of bounds\n", hoffset + offset);
 456                         goto bad;
 457                 }
 458
 459                 ptr = skb_header_pointer(skb, hoffset + offset,
 460                                          sizeof(hdata), &hdata);
 461                 if (!ptr)
 462                         goto bad;
 463                 /* just do it, baby */
 464                 switch (cmd) {
 465                 case TCA_PEDIT_KEY_EX_CMD_SET:
 466                         val = tkey->val;
 467                         break;
 468                 case TCA_PEDIT_KEY_EX_CMD_ADD:
 469                         val = (*ptr + tkey->val) & ~tkey->mask;
 470                         break;
 471                 default:
 472                         pr_info_ratelimited("tc action pedit bad command (%d)\n", cmd);
 473                         goto bad;
 474                 }
 475
 476                 *ptr = ((*ptr & tkey->mask) ^ val);
 477                 if (ptr == &hdata)
 478                         skb_store_bits(skb, hoffset + offset, ptr, 4);
 479         }
 480
 481         goto done;
 482
 483 bad:
 484         tcf_action_inc_overlimit_qstats(&p->common);
 485 done:
 486         return p->tcf_action;
 487 }
 488
 489 static void tcf_pedit_stats_update(struct tc_action *a, u64 bytes, u64 packets,
 490                                    u64 drops, u64 lastuse, bool hw)
 491 {
 492         struct tcf_pedit *d = to_pedit(a);
 493         struct tcf_t *tm = &d->tcf_tm;
 494
 495         tcf_action_update_stats(a, bytes, packets, drops, hw);
 496         tm->lastuse = max_t(u64, tm->lastuse, lastuse);
 497 }
 498
 499 static int tcf_pedit_dump(struct sk_buff *skb, struct tc_action *a,
 500                           int bind, int ref)
 501 {
 502         unsigned char *b = skb_tail_pointer(skb);
 503         struct tcf_pedit *p = to_pedit(a);
 504         struct tcf_pedit_parms *parms;
 505         struct tc_pedit *opt;
 506         struct tcf_t t;
 507         int s;
 508
 509         spin_lock_bh(&p->tcf_lock);
 510         parms = rcu_dereference_protected(p->parms, 1);
 511         s = struct_size(opt, keys, parms->tcfp_nkeys);
 512
 513         opt = kzalloc(s, GFP_ATOMIC);
 514         if (unlikely(!opt)) {
 515                 spin_unlock_bh(&p->tcf_lock);
 516                 return -ENOBUFS;
 517         }
 518
 519         memcpy(opt->keys, parms->tcfp_keys,
 520                flex_array_size(opt, keys, parms->tcfp_nkeys));
 521         opt->index = p->tcf_index;
 522         opt->nkeys = parms->tcfp_nkeys;
 523         opt->flags = parms->tcfp_flags;
 524         opt->action = p->tcf_action;
 525         opt->refcnt = refcount_read(&p->tcf_refcnt) - ref;
 526         opt->bindcnt = atomic_read(&p->tcf_bindcnt) - bind;
 527
 528         if (parms->tcfp_keys_ex) {
 529                 if (tcf_pedit_key_ex_dump(skb, parms->tcfp_keys_ex,
 530                                           parms->tcfp_nkeys))
 531                         goto nla_put_failure;
 532
 533                 if (nla_put(skb, TCA_PEDIT_PARMS_EX, s, opt))
 534                         goto nla_put_failure;
 535         } else {
 536                 if (nla_put(skb, TCA_PEDIT_PARMS, s, opt))
 537                         goto nla_put_failure;
 538         }
 539
 540         tcf_tm_dump(&t, &p->tcf_tm);
 541         if (nla_put_64bit(skb, TCA_PEDIT_TM, sizeof(t), &t, TCA_PEDIT_PAD))
 542                 goto nla_put_failure;
 543         spin_unlock_bh(&p->tcf_lock);
 544
 545         kfree(opt);
 546         return skb->len;
 547
 548 nla_put_failure:
 549         spin_unlock_bh(&p->tcf_lock);
 550         nlmsg_trim(skb, b);
 551         kfree(opt);
 552         return -1;
 553 }
 554
 555 static int tcf_pedit_offload_act_setup(struct tc_action *act, void *entry_data,
 556                                        u32 *index_inc, bool bind,
 557                                        struct netlink_ext_ack *extack)
 558 {
 559         if (bind) {
 560                 struct flow_action_entry *entry = entry_data;
 561                 int k;
 562
 563                 for (k = 0; k < tcf_pedit_nkeys(act); k++) {
 564                         switch (tcf_pedit_cmd(act, k)) {
 565                         case TCA_PEDIT_KEY_EX_CMD_SET:
 566                                 entry->id = FLOW_ACTION_MANGLE;
 567                                 break;
 568                         case TCA_PEDIT_KEY_EX_CMD_ADD:
 569                                 entry->id = FLOW_ACTION_ADD;
 570                                 break;
 571                         default:
 572                                 NL_SET_ERR_MSG_MOD(extack, "Unsupported pedit command offload");
 573                                 return -EOPNOTSUPP;
 574                         }
 575                         entry->mangle.htype = tcf_pedit_htype(act, k);
 576                         entry->mangle.mask = tcf_pedit_mask(act, k);
 577                         entry->mangle.val = tcf_pedit_val(act, k);
 578                         entry->mangle.offset = tcf_pedit_offset(act, k);
 579                         entry->hw_stats = tc_act_hw_stats(act->hw_stats);
 580                         entry++;
 581                 }
 582                 *index_inc = k;
 583         } else {
 584                 struct flow_offload_action *fl_action = entry_data;
 585                 u32 cmd = tcf_pedit_cmd(act, 0);
 586                 int k;
 587
 588                 switch (cmd) {
 589                 case TCA_PEDIT_KEY_EX_CMD_SET:
 590                         fl_action->id = FLOW_ACTION_MANGLE;
 591                         break;
 592                 case TCA_PEDIT_KEY_EX_CMD_ADD:
 593                         fl_action->id = FLOW_ACTION_ADD;
 594                         break;
 595                 default:
 596                         NL_SET_ERR_MSG_MOD(extack, "Unsupported pedit command offload");
 597                         return -EOPNOTSUPP;
 598                 }
 599
 600                 for (k = 1; k < tcf_pedit_nkeys(act); k++) {
 601                         if (cmd != tcf_pedit_cmd(act, k)) {
 602                                 NL_SET_ERR_MSG_MOD(extack, "Unsupported pedit command offload");
 603                                 return -EOPNOTSUPP;
 604                         }
 605                 }
 606         }
 607
 608         return 0;
 609 }
 610
 611 static struct tc_action_ops act_pedit_ops = {
 612         .kind           =       "pedit",
 613         .id             =       TCA_ID_PEDIT,
 614         .owner          =       THIS_MODULE,
 615         .act            =       tcf_pedit_act,
 616         .stats_update   =       tcf_pedit_stats_update,
 617         .dump           =       tcf_pedit_dump,
 618         .cleanup        =       tcf_pedit_cleanup,
 619         .init           =       tcf_pedit_init,
 620         .offload_act_setup =    tcf_pedit_offload_act_setup,
 621         .size           =       sizeof(struct tcf_pedit),
 622 };
 623
 624 static __net_init int pedit_init_net(struct net *net)
 625 {
 626         struct tc_action_net *tn = net_generic(net, act_pedit_ops.net_id);
 627
 628         return tc_action_net_init(net, tn, &act_pedit_ops);
 629 }
 630
 631 static void __net_exit pedit_exit_net(struct list_head *net_list)
 632 {
 633         tc_action_net_exit(net_list, act_pedit_ops.net_id);
 634 }
 635
 636 static struct pernet_operations pedit_net_ops = {
 637         .init = pedit_init_net,
 638         .exit_batch = pedit_exit_net,
 639         .id   = &act_pedit_ops.net_id,
 640         .size = sizeof(struct tc_action_net),
 641 };
 642
 643 MODULE_AUTHOR("Jamal Hadi Salim(2002-4)");
 644 MODULE_DESCRIPTION("Generic Packet Editor actions");
 645 MODULE_LICENSE("GPL");
 646
 647 static int __init pedit_init_module(void)
 648 {
 649         return tcf_register_action(&act_pedit_ops, &pedit_net_ops);
 650 }
 651
 652 static void __exit pedit_cleanup_module(void)
 653 {
 654         tcf_unregister_action(&act_pedit_ops, &pedit_net_ops);
 655 }
 656
 657 module_init(pedit_init_module);
 658 module_exit(pedit_cleanup_module);