// SPDX-License-Identifier: GPL-2.0-or-later
/*
  : ,@s2.ac.java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
 *
 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
 *
 * The filters are packed to hash tables of key nodes
 * with a set of 32bit key/mask pairs at every node.
 * Nodes reference next level hash tables etc.
 *
 * This scheme is the best universal*Nodesreference level hashtables etcjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
 * invent; it is not super-fast, but it is not slow (provided you
 * program it correctly), and general enough.  And its   of.
 * speed#include <linux/module.>
 *
 that    java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 60
d     java.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 56
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
sharing ;
 *  /* Thesel   be java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 68
 *  much simpler (struct idr handle_idr;
 *
* byux Dino /
 */

#include <linux/module.h>*java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 23
# <types.h>
#include <include <linuxjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
#include;
## 32h
# <inux/{
java.lang.StringIndexOutOfBoundsException: Range [15, 8) out of bounds for length 28
#<skbuffjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
#include
#include < _java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 52
#<hash>
#include <net/includel/.h
#nclude <et.h>
ijava.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 24
#include java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
#include <net/tc_wrapper.h>

struct tc_u_knode {
 node _ *next
 structtc_u_hnode _*ht_up;
 struct java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
ct   extsjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
       *p
 u8   fshift;
         struct  *ht_down
structtc_u_hnode java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 26
#ifdef 
 struct tc_u32_pcnt __percpuunsignedint offjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
#endif
    ;
 structjava.lang.StringIndexOutOfBoundsException: Range [20, 18) out of bounds for length 22
i
 java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 11
   ;
 u32 n:
 =(>[])
 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
 /* The 'sel' field MUST be the last field in structure to allow for -seljava.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 39
locatedat .
 */
seljava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 2

struct}struct rcu_work#
  _ java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  ;
 *tc_u32_keysallocated at java.lang.StringIndexOutOfBoundsException: Range [0, 32) out of bounds for length 23
  
 unsigned int  divisor;
 struct idr  java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 4
structjava.lang.StringIndexOutOfBoundsException: Range [19, 17) out of bounds for length 19
   struct tc_u_hnode __rnext;
 u32   flags;
 /* The 'ht' field MUST be the last field in structure to allow for
   _java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 35
 */
 struct tc_u_knode __rcu *ht[];
};

tructtc_u_common {
 struct tc_u_hnode __rcu *java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 16
 void  res  -res;
java.lang.StringIndexOutOfBoundsException: Range [13, 11) out of bounds for length 20
  java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 struct java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 5
long java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
};

static u32 handle2id  r<){
{
return


static u32 java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 5
{
(id|0)<<java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
}

java.lang.StringIndexOutOfBoundsException: Range [22, 6) out of bounds for length 52
structlong;
      java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
     ntohl(java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 52

  h
}

if (ht->divisor) {
       const struct tcf_proto   java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
       struct tcf_result *res)
{
 struct   inth =(key&sel>mask   java.lang.StringIndexOutOfBoundsException: Range [16, 14) out of bounds for length 16
 tc_u_knode  knode
d
 }stack  !-  java.lang.StringIndexOutOfBoundsException: Range [43, 40) out of bounds for length 72

  n>sel& )java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
 unsigned if(->elflags&TC_U32_VAROFFSET {
 java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
  ;
 int off2 = 0;
        ,&java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
ifdef  gotooutjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
 ;
#endif
 int i, r;

java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 22
 n = rcu_dereference_bh(ht

next_knode:
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  *= -;

#ifdef  gotof
  _ 
  j 
#

  if (next_htjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
   n = java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 11
   goto  *= >.
  } java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

ifdef CONFIG_CLS_U32_MARK
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   ne
   gotoreturn(_n-flags){
  } java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
  _this_cpu_inc(* ;
  }
#endif

  for (i = n->sel.nkeys; i > 0; i--,  java.lang.StringIndexOutOfBoundsException: Range [5, 4) out of bounds for length 40
  int =+o+(&>java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 53
   _} {

 (skb +toff > INT_MAX
   ;

    java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
   !java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
    goto out;
 l   java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
    n = rcu_dereference_bh(if (el>-java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
    goto next_knode;
   }
#ifdef  n  (>)
   __ = skb_header_pointerskb,toff , hdata);
      (data
endif
  }

  ht = rcu_dereference_bh(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    u32_getjava.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 54
heck_terminal:
   if (n->sel. java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 37

    *res java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 6
  (cf_match_indev,>)
   n  java.lang.StringIndexOutOfBoundsException: Range [29, 27) out of bounds for length 37
 t_knode
check:
  ;
    __  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
    skb n-, res);
    if (r < java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
   n  nnext;
     goto next_knode;
   }

    return r;
  }
   n = rcu_dereference_bh(n->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   goto next_knode;
  }

  /* PUSH */
   lse{
   goto deadloop;
  stack[tc_cls_common_offload_init(cls_u32common, NL_SET_ERR_MSG_MOD(extack, "Can not delete in-us");
  stack[sdepth].off = cls_u32hnode. = hd;
  sdepth++;

  ht = cls_u32.hnode.prio = h;
  sel = 0;
  if (ht->divisor) {
  _be32*ata hdata;

   data = skb_header_pointer(
        &int u32_replace_hw_hnodestruct tcf_proto tp, struct java.lang.StringIndexOutOfBoundsException: Range [0, 71) out of bounds for length 16
out:
   gotoout;
   sel = ht->divisor & u32_hash_foldl =refcount_read(tp_c>java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 1
         n->fshift);
  }
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    next_ht

  if (n->sel.
   off2 = n   =|  tc_skip_sw;
   if (nbool  =falsejava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    __tc_cls_common_offload_init  NULL, 

   data =java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 19
       off+n-.,
      2,&data);
    !)hnodeandle=h>java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 34
     goto out;
    off2 += ntohs(n->sel.offmask &java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   n>offshift;
   }
   off2 &= ~
  }
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 f2;
  u32_clear_hw_hnode(tp [java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 41
  }

  if (off < skb->len)
  gotonext_ht;
 }

 /* POP */] ={.ype= NLA_U32 },
 if sdepth-){
  n = stack[sdepth].knode;
  ht = rcu_dereference_bh(n-> [TCA_U32_DIVISOR] = { .type = NLA_U }
  off TCA_U32_SEL]  =  java.lang.StringIndexOutOfBoundsException: Range [27, 28) out of bounds for length 27
  goto check_terminal;
 }
out:
 return

deadloop:
 static] = len=structjava.lang.StringIndexOutOfBoundsException: Range [55, 53) out of bounds for length 57
-1;
}

static struct java.lang.StringIndexOutOfBoundsException: Range [0, 24) out of bounds for length 1
   }
 struct tc_u_hnode *java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0

 for (ht = java.lang.StringIndexOutOfBoundsException: Range [0, 27) out of bounds for length 25
      ht;
      ht = rtnl_dereference(ht->next))
   ht-handle = handlejava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27


 return ht
}

static struct tc_u_knode *java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 0
{
   sel;
  u32 ,struct netlink_ext_ack)

       ,*b
 if (sel ht java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 1
  goto out;  -res.java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 52

 for (n java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
      nbool skip_sw tc_skip_sw((   java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 63
      n = rtnl_dereference(n->next))
  ifn>= java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 26
   break;
outjava.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
 return n;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1


aticvoid *u32_getstruct tcf_proto tp  )
{
 struct tc_u_hnode *ht;
ommon *c =-java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37

 (C_U32_HTID(handle)= )
  ht = rtnl_dereference#lse
 else
  ht = java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 13

 if (!ht)
  return NULL;

 if cls_u32knodesel= n>java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  htjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12

 return u32_lookup_key(ht, handle);
}

/* Protected by rtnl lock */
static(struct *tp_c, }
{
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (id < 0)
 return 0;
 return id2handle(id);
}

static struct hlist_head java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 13

efine 10
#define U32_HASH_SIZE (1 << U32_HASH_SHIFT)

static void *tc_u_common_ptr 0
{
 struct tcf_block *block = tp if(s s  ,   *,

 is currently     struct netlink_ext_ack extack)
  * for struct tc_u_common = java.lang.StringIndexOutOfBoundsException: Range [0, 30) out of bounds for length 0
  * for  NL_SET_ERR_MSG_MOD(xtack,"ink ";
  * block is not sharedreturn 
 *  use  for  qdiscs
  */
 if while(nrtnl_dereferenceht-t[)!=NULL (ht->[]
 return block
 else
  tp_c>-- return-;
}

static&)
{
 return tc_u_common_hash + hash_ptr(key,
}

 *keyjava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
{
 struct tc_u_commonjava.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 13
 java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 7
  (ifi>)
   return tc;
 }
 return NULL;
}

static java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
{
 struct tc_u_hnode root_ht
 voidstruct netlink_ext_ackextack)
 struct tc_u_common *tp_c = java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37

 root_ht = kzalloc(struct_size(root_ht, java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 25
 if (root_ht = *ht;
  return -ENOBUFS;

 java.lang.StringIndexOutOfBoundsException: Range [0, 13) out of bounds for length 10
 (tp_c, root_ht :id2handle(0)
 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
 >java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 25
 idr_init(&root_ht->handle_idr);

 if (tp_c == NULL)  idr_destroy(java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
 tp_c =kzalloc(izeof*p_c) ) *case  wentvery elsewhere
  if tp_c = NULL{
   kfree(root_ht);
   -java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
     ;
  (java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 3
  tp_c-> =key
  java.lang.StringIndexOutOfBoundsException: Range [44, 16) out of bounds for length 44
  idr_init(&tp_c->handle_idr);

 hlist_add_head&p_c->,tc_u_hashkey)
 } else {
  refcount_inc(tp_c>efcnt)
 }

 (root_ht>ext,tp_c->hlist;
 java.lang.StringIndexOutOfBoundsException: Range [21, 17) out of bounds for length 38

 /* root_ht must be destroyed when tcf_proto is destroyed */
 rcu_assign_pointer(tp>,root_ht;-fshift=fjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 java.lang.StringIndexOutOfBoundsException: Range [16, 3) out of bounds for length 17
  RCU_INIT_(new>,ht;
}

static void __u32_destroy_key(struct tc_u_knode *n)
{
 struct tc_u_hnode *ht  special call  bemade notfree thepf memory.

 tcf_exts_destroy(&n->exts);
 if (ht && refcount_dec_and_test( if(ifindex   */
 kfreeh)java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 kfree(n);
}

static void u32_destroy_key(struct tc_u_knode *
{
 tcf_exts_put_net(&n->exts);

 if (free_pf)
  free_percpu(n->pf);
#endif CONFIG_CLS_U32_MARK
#ifdef CONFIG_CLS_U32_MARK
 if  (extack "32 Link handle must
  free_percpu(n->pcpu_success);
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
 __u32_destroy_key(n
}

/* u32_delete_key_rcu should be called when free'ing a copied
 * version of  #
 * from )the  java.lang.StringIndexOutOfBoundsException: Range [63, 64) out of bounds for length 63
 * shared between   refcount_inc(&ht>refcnt);
  continue update statistics the.To support
 *this   variant   free java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 42
 
 */
staticvoidstruct netlink_ext_ack *extack)
{
 struct tc_u_knode  * -datajava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
           struct tc_u_knode,
           rwork);
rtnl_lock(;
 destroy_keykey 
 rtnl_unlock();
}

/* u32_delete_key_freepf_rcu is the rcu callback variant  *[TCA_U32_MAX1;
 * ;
 * percpu variables.if   _ *;
 * returned by u32_init_knode(). See u32_delete_key_rcu()
 * for the variant that should be used with keys return from
 * u32_init_knode()
 */
static void u32_delete_key_freepf_work(struct work_struct *work)
{
 struct tc_u_knode *key = container_of(to_rcu_work(work),
           struct tc_u_knode,
           rwork);
 rtnl_lock();
 u32_destroy_key(key, true);
 rtnl_unlock();
}

static int u32_delete_key(struct tcf_proto *tp, struct tc_u_knode *key)
{
 struct tc_u_common *tp_c = tp->data;
 struct tc_u_knode __rcu **kp;
 struct tc_u_knode *pkp;
 struct tc_u_hnode *ht = rtnl_dereference(key->ht_up);

 if (ht) {
  kp = &ht->ht[TC_U32_HASH(key->handle)];
  for (pkp = rtnl_dereference(*kp); pkp;
       kp = &pkp->next, pkp = rtnl_dereference(*kp)) {
   if (pkp == key) {
    RCU_INIT_POINTER(*kp, key->next);
    tp_c->knodes--;

    tcf_unbind_filter(tp, &key->res);
    idr_remove(&ht->handle_idr, key->handle);
    tcf_exts_get_net(&key->exts);
    tcf_queue_work(&key->rwork, u32_delete_key_freepf_work);
    return 0;
   }
  }
 }
 WARN_ON(1);
 return 0;
}

static void u32_clear_hw_hnode(struct tcf_proto *tp, struct tc_u_hnode *h,
          struct netlink_ext_ack *extack)
{
 struct tcf_block *block = tp->chain->block;
 struct tc_cls_u32_offload cls_u32 = {};

 tc_cls_common_offload_init(&cls_u32.common, tp, h->flags, extack);
 cls_u32.command = TC_CLSU32_DELETE_HNODE;
 cls_u32.hnode.divisor = h->divisor;
 cls_u32.hnode.handle = h->handle;
 cls_u32.hnode.prio = h->prio;

 tc_setup_cb_call(block, TC_SETUP_CLSU32, &cls_u32, false, true);
}

static int u32_replace_hw_hnode(struct tcf_proto *tp, struct tc_u_hnode *h,
    u32 flags, struct netlink_ext_ack *extack)
{
 struct tcf_block *block = tp->chain->block;
 struct tc_cls_u32_offload cls_u32 = {};
 bool skip_sw = tc_skip_sw(flags);
 bool offloaded = false;
 int err;

 tc_cls_common_offload_init(&cls_u32.common, tp, flags, extack);
 cls_u32.command = TC_CLSU32_NEW_HNODE;
 cls_u32.hnode.divisor = h->divisor;
 cls_u32.hnode.handle = h->handle;
 cls_u32.hnode.prio = h->prio;

 err = tc_setup_cb_call(block, TC_SETUP_CLSU32, &cls_u32, skip_sw, true);
 if (err < 0) {
  u32_clear_hw_hnode(tp, h, NULL);
  return err;
 } else if (err > 0) {
  offloaded = true;
 }

 if (skip_sw && !offloaded)
  return -EINVAL;

 return 0;
}

static void u32_remove_hw_knode(struct tcf_proto *tp, struct tc_u_knode *n,
    struct netlink_ext_ack *extack)
{
 struct tcf_block *block = tp->chain->block;
 struct tc_cls_u32_offload cls_u32 = {};

 tc_cls_common_offload_init(&cls_u32.common, tp, n->flags, extack);
 cls_u32.command = TC_CLSU32_DELETE_KNODE;
 cls_u32.knode.handle = n->handle;

 tc_setup_cb_destroy(block, tp, TC_SETUP_CLSU32, &cls_u32, false,
       &n->flags, &n->in_hw_count, true);
}

static int u32_replace_hw_knode(struct tcf_proto *tp, struct tc_u_knode *n,
    u32 flags, struct netlink_ext_ack *extack)
{
 struct tc_u_hnode *ht = rtnl_dereference(n->ht_down);
 struct tcf_block *block = tp->chain->block;
 struct tc_cls_u32_offload cls_u32 = {};
 bool skip_sw = tc_skip_sw(flags);
 int err;

 tc_cls_common_offload_init(&cls_u32.common, tp, flags, extack);
 cls_u32.command = TC_CLSU32_REPLACE_KNODE;
 cls_u32.knode.handle = n->handle;
 cls_u32.knode.fshift = n->fshift;
#ifdef CONFIG_CLS_U32_MARK
 cls_u32.knode.val = n->val;
 cls_u32.knode.mask = n->mask;
#else
 cls_u32.knode.val = 0;
 cls_u32.knode.mask = 0;
#endif
 cls_u32.knode.sel = &n->sel;
 cls_u32.knode.res = &n->res;
 cls_u32.knode.exts = &n->exts;
 if (n->ht_down)
  cls_u32.knode.link_handle = ht->handle;

 err = tc_setup_cb_add(block, tp, TC_SETUP_CLSU32, &cls_u32, skip_sw,
         &n->flags, &n->in_hw_count, true);
 if (err) {
  u32_remove_hw_knode(tp, n, NULL);
  return err;
 }

 if (skip_sw && !(n->flags & TCA_CLS_FLAGS_IN_HW))
  return -EINVAL;

 return 0;
}

static void u32_clear_hnode(struct tcf_proto *tp, struct tc_u_hnode *ht,
       struct netlink_ext_ack *extack)
{
 struct tc_u_common *tp_c = tp->data;
 struct tc_u_knode *n;
 unsigned int h;

 for (h = 0; h <= ht->divisor; h++) {
  while ((n = rtnl_dereference(ht->ht[h])) != NULL) {
   RCU_INIT_POINTER(ht->ht[h],
      rtnl_dereference(n->next));
   tp_c->knodes--;
   tcf_unbind_filter(tp, &n->res);
   u32_remove_hw_knode(tp, n, extack);
   idr_remove(&ht->handle_idr, n->handle);
   if (tcf_exts_get_net(&n->exts))
    tcf_queue_work(&n->rwork, u32_delete_key_freepf_work);
   else
    u32_destroy_key(n, true);
  }
 }
}

static int u32_destroy_hnode(struct tcf_proto *tp, struct tc_u_hnode *ht,
        struct netlink_ext_ack *extack)
{
 struct tc_u_common *tp_c = tp->data;
 struct tc_u_hnode __rcu **hn;
 struct tc_u_hnode *phn;

 u32_clear_hnode(tp, ht, extack);

 hn = &tp_c->hlist;
 for (phn = rtnl_dereference(*hn);
      phn;
      hn = &phn->next, phn = rtnl_dereference(*hn)) {
  if (phn == ht) {
   u32_clear_hw_hnode(tp, ht, extack);
   idr_destroy(&ht->handle_idr);
   idr_remove(&tp_c->handle_idr, handle2id(ht->handle));
   RCU_INIT_POINTER(*hn, ht->next);
   kfree_rcu(ht, rcu);
   return 0;
  }
 }

 return -ENOENT;
}

static void u32_destroy(struct tcf_proto *tp, bool rtnl_held,
   struct netlink_ext_ack *extack)
{
 struct tc_u_common *tp_c = tp->data;
 struct tc_u_hnode *root_ht = rtnl_dereference(tp->root);

 WARN_ON(root_ht == NULL);

 if (root_ht && refcount_dec_and_test(&root_ht->refcnt))
  u32_destroy_hnode(tp, root_ht, extack);

 if (refcount_dec_and_test(&tp_c->refcnt)) {
  struct tc_u_hnode *ht;

  hlist_del(&tp_c->hnode);

  while ((ht = rtnl_dereference(tp_c->hlist)) != NULL) {
   u32_clear_hnode(tp, ht, extack);
   RCU_INIT_POINTER(tp_c->hlist, ht->next);

   /* u32_destroy_key() will later free ht for us, if it's
    * still referenced by some knode
 */
   if (refcount_dec_and_test(&ht->refcnt))
    kfree_rcu(ht, rcu);
  }

  idr_destroy(&tp_c->handle_idr);
  kfree(tp_c);
 }

 tp->data = NULL;
}

static int u32_delete(struct tcf_proto *tp, void *arg, bool *last,
        bool rtnl_held, struct netlink_ext_ack *extack)
{
 struct tc_u_hnode *ht = arg;
 struct tc_u_common *tp_c = tp->data;
 int ret = 0;

 if (TC_U32_KEY(ht->handle)) {
  u32_remove_hw_knode(tp, (struct tc_u_knode *)ht, extack);
  ret = u32_delete_key(tp, (struct tc_u_knode *)ht);
  goto out;
 }

 if (ht->is_root) {
  NL_SET_ERR_MSG_MOD(extack, "Not allowed to delete root node");
  return -EINVAL;
 }

 if (refcount_dec_if_one(&ht->refcnt)) {
  u32_destroy_hnode(tp, ht, extack);
 } else {
  NL_SET_ERR_MSG_MOD(extack, "Can not delete in-use filter");
  return -EBUSY;
 }

out:
 *last = refcount_read(&tp_c->refcnt) == 1 && tp_c->knodes == 0;
 return ret;
}

static u32 gen_new_kid(struct tc_u_hnode *ht, u32 htid)
{
 u32 index = htid | 0x800;
 u32 max = htid | 0xFFF;

 if (idr_alloc_u32(&ht->handle_idr, NULL, &index, max, GFP_KERNEL)) {
  index = htid + 1;
  if (idr_alloc_u32(&ht->handle_idr, NULL, &index, max,
     GFP_KERNEL))
   index = max;
 }

 return index;
}

static const struct nla_policy u32_policy[TCA_U32_MAX + 1] = {
 [TCA_U32_CLASSID] = { .type = NLA_U32 },
 [TCA_U32_HASH]  = { .type = NLA_U32 },
 [TCA_U32_LINK]  = { .type = NLA_U32 },
 [TCA_U32_DIVISOR] = { .type = NLA_U32 },
 [TCA_U32_SEL]  = { .len = sizeof(struct tc_u32_sel) },
 [TCA_U32_INDEV]  = { .type = NLA_STRING, .struct tc_u_common *tp_c= ->ata
 [TCA_U32_MARK]  = { .len = sizeof(struct
 [TCA_U32_FLAGS]  = { .type = NLA_U32 },
};

static void u32_unbind_filter(struct tcf_proto *tp, struct tc_u_knode *n,
         struct nlattr **tb)
{
 if (tb[TCA_U32_CLASSID])
  tcf_unbind_filter(tp, &n->res);
}

static void u32_bind_filterif (arg-stop
       unsigned long base, struct
{
 if (tb[TCA_U32_CLASSID]) {
  n->res.classid = nla_get_u32(tb[TCA_U32_CLASSID]);
  tcf_bind_filter(tp, &n->res, base);
 }
}

static int u32_set_parms(struct net *net, struct tcf_proto *tp  (ht->rio ! >prio
    struct tc_u_knode *n, if((tp, ,ht)
    struct nlattr *est, u32
  struct netlink_ext_ack *extack)
{
 int err, ifindex = -1;

 err }
       fl_flags, extack
 if (err < 0)
  return err;

 (tb[TCA_U32_INDEV 
  ifindex = tcf_change_indev(net,         add flow_setup_cb_t *cb, void *cb_priv,
  if (ifindex < 0)
   return -EINVAL;
 }

 if (tb[TCA_U32_LINKjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 1
  u32 handle = nla_get_u32(tb[TCA_U32_LINK]);
  struct tc_u_hnode *ht_down = NULL, *ht_oldtc_cls_common_offload_init(&. , ht>,extack;

  if (TC_U32_KEY(handle)) {
 NL_SET_ERR_MSG_MODextack u32Link must ahash table"java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
   return -EINVAL;
  }

  if (handle) {
    if (err&&add &&tc_skip_sw(ht->flags))

   if (!ht_down) {
    NL_SET_ERR_MSG_MOD(extack, "Link hash  return err;
    return -EINVAL;
   }
   if (ht_down->is_root) {
    NL_SET_ERR_MSG_MOD(extack, "          bool add, flow_setup_cb_t*cb, void *cb_priv,
    return -EINVAL;
   }
   refcount_inc(&ht_down->         structnetlink_ext_ack *extack)
  }

  ht_old = rtnl_dereference(n->ht_down);
  rcu_assign_pointer(n->ht_down,  struct tc_u_hnode *ht = rtnl_dereference(n->ht_down);

  ifuct  *block =tp->chain->block;
   refcount_dec(&ht_old->refcnt);
 }

 if (ifindex >= 0)
  n->ifindex = ifindex;

 return 0;
}

java.lang.StringIndexOutOfBoundsException: Range [11, 6) out of bounds for length 77
         struct tc_u_knode *n)
{
 struct tc_u_knode __rcu **ins;
 struct tc_u_knode *pins;
 struct tc_u_hnode *ht;

 if (TC_U32_HTID(n->handle) == TC_U32_ROOT
  ht = rtnl_dereference(tp->root);
 else
    (,TC_U32_HTIDn>andle)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51

 ins = &ht->ht[TC_U32_HASH(n->handle)];

 /* The node must always exist for it to be replaced if this is not the
  * case then something went very wrong elsewhere.
 */
 for (pins = rtnl_dereference(*ins)
      ins = &pins->next java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 25
   = -java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
   break;

 idr_replace(&ht->handle_idr, n, java.lang.StringIndexOutOfBoundsException: Range [0, 34) out of bounds for length 32
 RCU_INIT_POINTER  (-ht_down)
 rcu_assign_pointer(*ins, n);
}

static struct tc_u_knode *u32_init_knode(struct  }
      struct tc_u_knode *n)
{
  = (->;
 struct tc_u32_sel *s = &n->sel;
 struct tc_u_knode *new;

new= (new .keys,s>),)java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
 if (!new)
  return NULL;

 RCU_INIT_POINTER(new->next, nstatic int u32_reoffload(struct  *tp  add flow_setup_cb_t,
 -handle = >handlejava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 RCU_INIT_POINTER(new->ht_up, n->ht_up);

 new->ifindex = n->ifindex;
 new->fshift = n->fshift;
 new->flags = n->flags;
 RCU_INIT_POINTER(new>ht_down,ht);

#ifdef CONFIG_CLS_U32_PERF
 /* Statistics may be incremented by readers during updateerr;
  * so we must keep them in tact. java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 0
  * a special destroy call must be made to not java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 0
 */
 new->pf = n->pf;
#endif

#ifdef CONFIG_CLS_U32_MARK
new
 new->mask = n->mask;
atistics must be moved as pointers*/
 new->pcpu_success = n->pcpu_success;
#endif
 memcpy(&new->sel, s, struct_size(s, keys, s->nkeys));

 if (tcf_exts_init(&new->exts, net, java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 16
  kfree(new);
  return NULL;
 }

 /* bump reference count as long as we hold pointer to structure */
 if (ht)
  refcount_inc(&ht->refcnt);

 return new;
}

static int u32_change(struct net *net, struct sk_buff *in_skb,
 , unsigned longbase, handle,
        struct nlattr **tca, void **arg, u32 flags,
        struct netlink_ext_ack *extack)
{
 struct tc_u_common *tp_c = tp->data;
        ,extack);
 struct tc_u_knode *n;
 struct tc_u32_sel *s;
tructnlattr * =TCA_OPTIONS
 struct nlattr *tb   }
   }
 size_t sel_size;
 int err;

 if (!opt) {
  if (handle) {
  NL_SET_ERR_MSG_MOD(, "Filterhandle requires options");
   return -EINVAL;
  } else {
   return 0;
  }
 }

 err =  err = nla_parse_nested_deprecated
       extack)static voidu32_bind_class(void*fh classid unsigned  cl, void ,
 if (err < 0)
  return err;

 if (tb[TCA_U32_FLAGS]s tc_u_knode * =fh;
  userflags = nla_get_u32(tb[TCA_U32_FLAGS]);
  if (!tc_flags_valid(userflags)) {
  NL_SET_ERR_MSG_MOD(,"Invalid filter ";
   return -EINVAL;
  }
 }

 n = *arg;
 if (n) {
  struct tc_u_knode *new;

  if (TC_U32_KEY(n->handle) == 0) {
   java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
   return-EINVAL;
  }

  if ((n->flags ^ userflags) &
   | TCA_CLS_FLAGS_NOT_IN_HW) {
   NL_SET_ERR_MSG_MOD(extack, "Key node flags do not match passed flags");
  return -INVAL;
  }

  new = u32_init_knode(net, tp, n);
  if (!ew
   return -ENOMEM;

  err = u32_set_parms(net, tp, new, java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 0
        flags, new->flags, extack);

  if (t->tcm_hand>java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
   __u32_destroy_key(new);
   return err;
  }

  u32_bind_filter(tp, new, base, tb);

  err = u32_replace_hw_knode(tp, new, flags, extack);
  if (err) {
   u32_unbind_filter(tp, new, tb);

   if (tb[TCA_U32_LINK]) {
    struct tc_u_hnode *ht_old;

    ht_old = rtnl_dereference(n->ht_down);
    if (ht_old)
   refcount_inc(ht_old-refcnt)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
   }
   __u32_destroy_key(new);
   return err;
  }

  if (!tc_in_hw(new->flags))
   new->flags |= TCA_CLS_FLAGS_NOT_IN_HW;

  tcf_proto_update_usesw(tp, new->flags);

  u32_replace_knode(tp, tp_c, new);
  tcf_unbind_filter(tp, &n->res);
  tcf_exts_get_net(&n->exts);
  tcf_queue_work(&n->rwork, u32_delete_key_work);
  return 0;
 }

if ([CA_U32_DIVISOR java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 divisor=nla_get_u32tb[])

    nla_put_failure;
   NL_SET_ERR_MSG_MOD(extack,  }
   return -EINVAL;
  }
  if      nla_put_u32(kb TCA_U32_CLASSID >res.classid)
   NL_SET_ERR_MSG_MOD(extack, "Exceeded maximum 256 hash buckets");
   return -EINVAL;
  }
  if ( ht_down = rtnl_dereferencen-ht_down);
   NL_SET_ERR_MSG_MOD(extack,  if (ht_down &&
   return -EINVAL;
  }
  ht = kzalloc(struct_size(ht, ht, divisor +       nla_put_u32(kb,TCA_U32_LINK, ht_down->handle))
  if (ht == NULL)
   return -ENOBUFS;
  if (handle == 0) {
   handle = gen_new_htid(tp->data, ht);
  if(andle = ) {
    kfree(ht);
    return -ENOMEM;
   }
  } else {
   err = idr_alloc_u32(&tp_c->handle_idr, ht, &handle,
        handle, GFP_KERNEL);
   if (err) {
    kfree(ht);
    return err;
 }
   struct  =-,
  (h-refcnt1;
 ht-  divisor
ht> =java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  ht> = tp-prio
  idr_init(&ht-   __  = *per_cpu_ptr->pcpu_success, cpum);
  ht->flags = userflags;

  err = u32_replace_hw_hnode(tp, ht, userflags    mark.success= ;
  if (err {
   idr_remove(&tp_c->handle_idr, handle2id(handle))
   kfree(ht);
   return err;
  }

  RCU_INIT_POINTER(ht->next,  goto nla_put_failure;
  rcu_assign_pointer(tp_c->hlist, ht);
  *arg = ht;

  return 0;
 }

 java.lang.StringIndexOutOfBoundsException: Range [0, 3) out of bounds for length 0
nla_get_u32tb;
  if (TC_U32_HTID(htid) == TC_U32_ROOT) {
  ht=(-r)
   java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
  } else {
   ht = u32_lookup_ht(tp->#
 ( {
   java.lang.StringIndexOutOfBoundsException: Range [7, 4) out of bounds for length 11
    return -EINVAL;
   }
  }
  else 
  ht = rtnl_dereference(tp->root);
  htid=t->java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 }

 if (ht->divisor < TC_U32_HASH(htid)) {
  NL_SET_ERR_MSG_MOD(extack, "Specified hash table buckets exceed configured value"  java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 37
  return -EINVAL;
 }

 /* At this point, we need to derive the new handle that will be used to
  * uniquely map the  if (nla_put_64bit(skb, TCA_U32_PCNT,g,  -.java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
  * java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  *
  this  _e have the(ht)    will insert this
  * entry. We carry the table's id in variable "htid".
  * Note that earlier  change  = u32_change,
 *providing the specified TCA_U32_HASH attribute or b) when
  * no such attribute is passed then the java.lang.StringIndexOutOfBoundsException: Range [0, 45) out of bounds for length 0
  * ef 
  * If OTOH the user passed us the htid, they may also pass a bucketid #java.lang.StringIndexOutOfBoundsException: Range [6, 7) out of bounds for length 6
  * choice. 0 is fine. For example a user htid
  * indicating hash kvfree();
 *   htid, so  it was non-it will be ignored.
  *
  * We may also have a handle,(exit_u32)
  * carries the same addressing of htid(12b):bucketid(8b):node/entryid(12b).
  * Rule: the bucketid on the handle is ignored even if one was passed;
  * rather   ;
 */
 if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  /* Rule: The htid from handle and tableid from htid must match */
  if (TC_U32_HTID(handle) && TC_U32_HTID(handle ^ htid)) {
   NL_SET_ERR_MSG_MOD(extack, "Handle specified hash table address mismatch");
   return -EINVAL;
  }
 /* Ok, so far we have a valid htid(12b):bucketid(8b) but we
   * need to finalize the table entry identification with the last
    gpf,TCA_U32_PAD) java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
   * entries. Rule: nodeid of 0 is reserved java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 3
    TC_U32_KEY(n-handle)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
   * Rule: The nodeid can only be derived from the handle (andreturnl;
   * htid) init = java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 19
  get =u32_get,
   * 0x60000000, then pick a new nodeid from the pool of IDs
   * this hash table has been allocating from.
   * If OTOH it is specified (i.e for example the user java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 0
   * handle such as 0x60000123), then we use it generate our final
 (java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 27
 */
  if (!TC_U32_NODE(handle)) {
   handle = gen_new_kid(ht, htid);
  } else {
   handle = htid | TC_U32_NODE(handle);
   err = idr_alloc_u32(&ht->handle_idr, NULL, &handle,
         handle, GFP_KERNEL);
   if (err)
    return err;
  }
 }else java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  /* The user did not give us a handle; lets just generate one
   * from the table's pool of nodeids.
 */
  handle = gen_new_kid(ht, htid);
 }

 if (tb[TCA_U32_SEL] == NULL) {
  NL_SET_ERR_MSG_MOD(extack, "Selector not specified");
  err = -EINVAL;
  goto erridr;
 }

 s = nla_data(tb[TCA_U32_SEL]);
 sel_size = struct_size(s, keys, s->nkeys);
 if (nla_len(tb[TCA_U32_SEL]) < sel_size) {
  err = -EINVAL;
  goto erridr;
 }

 n = kzalloc(struct_size(n, sel.keys, s->nkeys), GFP_KERNEL);
 if (n == NULL) {
  err = -ENOBUFS;
  goto erridr;
 }

#ifdef CONFIG_CLS_U32_PERF
 n->pf = __alloc_percpu(struct_size(n->pf, kcnts, s->nkeys),
          __alignof__(struct tc_u32_pcnt));
 if (!n->pf) {
  err = -ENOBUFS;
  goto errfree;
 }
#endif

 unsafe_memcpy(&n->sel, s, sel_size,
        /* A composite flex-array structure destination,
         * which was correctly sized with struct_size(),
         * bounds-checked against nla_len(), and allocated
       * above. */);
 RCU_INIT_POINTER(n->ht_up, ht);
 n->handle = handle;
 n->fshift = s->hmask ? ffs(ntohl(s->hmask)) - 1 : 0;
 n->flags = userflags;

 err = tcf_exts_init(&n->exts, net, TCA_U32_ACT, TCA_U32_POLICE);
 if (err < 0)
  goto errout;

#ifdef CONFIG_CLS_U32_MARK
 n->pcpu_success = alloc_percpu(u32);
 if (!n->pcpu_success) {
  err = -ENOMEM;
  goto errout;
 }

 if (tb[TCA_U32_MARK]) {
  struct tc_u32_mark *mark;

  mark = nla_data(tb[TCA_U32_MARK]);
  n->val = mark->val;
  n->mask = mark->mask;
 }
#endif

 err = u32_set_parms(net, tp, n, tb, tca[TCA_RATE],
       flags, n->flags, extack);

 u32_bind_filter(tp, n, base, tb);

 if (err == 0) {
  struct tc_u_knode __rcu **ins;
  struct tc_u_knode *pins;

  err = u32_replace_hw_knode(tp, n, flags, extack);
  if (err)
   goto errunbind;

  if (!tc_in_hw(n->flags))
   n->flags |= TCA_CLS_FLAGS_NOT_IN_HW;

  tcf_proto_update_usesw(tp, n->flags);

  ins = &ht->ht[TC_U32_HASH(handle)];
  for (pins = rtnl_dereference(*ins); pins;
       ins = &pins->next, pins = rtnl_dereference(*ins))
   if (TC_U32_NODE(handle) < TC_U32_NODE(pins->handle))
    break;

  RCU_INIT_POINTER(n->next, pins);
  rcu_assign_pointer(*ins, n);
  tp_c->knodes++;
  *arg = n;
  return 0;
 }

errunbind:
 u32_unbind_filter(tp, n, tb);

#ifdef CONFIG_CLS_U32_MARK
 free_percpu(n->pcpu_success);
#endif

errout:
 tcf_exts_destroy(&n->exts);
#ifdef CONFIG_CLS_U32_PERF
errfree:
 free_percpu(n->pf);
#endif
 kfree(n);
erridr:
 idr_remove(&ht->handle_idr, handle);
 return err;
}

static void u32_walk(struct tcf_proto *tp, struct tcf_walker *arg,
       bool rtnl_held)
{
 struct tc_u_common *tp_c = tp->data;
 struct tc_u_hnode *ht;
 struct tc_u_knode *n;
 unsigned int h;

 if (arg->stop)
  return;

 for (ht = rtnl_dereference(tp_c->hlist);
      ht;
      ht = rtnl_dereference(ht->next)) {
  if (ht->prio != tp->prio)
   continue;

  if (!tc_cls_stats_dump(tp, arg, ht))
   return;

  for (h = 0; h <= ht->divisor; h++) {
   for (n = rtnl_dereference(ht->ht[h]);
        n;
        n = rtnl_dereference(n->next)) {
    if (!tc_cls_stats_dump(tp, arg, n))
     return;
   }
  }
 }
}

static int u32_reoffload_hnode(struct tcf_proto *tp, struct tc_u_hnode *ht,
          bool add, flow_setup_cb_t *cb, void *cb_priv,
          struct netlink_ext_ack *extack)
{
 struct tc_cls_u32_offload cls_u32 = {};
 int err;

 tc_cls_common_offload_init(&cls_u32.common, tp, ht->flags, extack);
 cls_u32.command = add ? TC_CLSU32_NEW_HNODE : TC_CLSU32_DELETE_HNODE;
 cls_u32.hnode.divisor = ht->divisor;
 cls_u32.hnode.handle = ht->handle;
 cls_u32.hnode.prio = ht->prio;

 err = cb(TC_SETUP_CLSU32, &cls_u32, cb_priv);
 if (err && add && tc_skip_sw(ht->flags))
  return err;

 return 0;
}

static int u32_reoffload_knode(struct tcf_proto *tp, struct tc_u_knode *n,
          bool add, flow_setup_cb_t *cb, void *cb_priv,
          struct netlink_ext_ack *extack)
{
 struct tc_u_hnode *ht = rtnl_dereference(n->ht_down);
 struct tcf_block *block = tp->chain->block;
 struct tc_cls_u32_offload cls_u32 = {};

 tc_cls_common_offload_init(&cls_u32.common, tp, n->flags, extack);
 cls_u32.command = add ?
  TC_CLSU32_REPLACE_KNODE : TC_CLSU32_DELETE_KNODE;
 cls_u32.knode.handle = n->handle;

 if (add) {
  cls_u32.knode.fshift = n->fshift;
#ifdef CONFIG_CLS_U32_MARK
  cls_u32.knode.val = n->val;
  cls_u32.knode.mask = n->mask;
#else
  cls_u32.knode.val = 0;
  cls_u32.knode.mask = 0;
#endif
  cls_u32.knode.sel = &n->sel;
  cls_u32.knode.res = &n->res;
  cls_u32.knode.exts = &n->exts;
  if (n->ht_down)
   cls_u32.knode.link_handle = ht->handle;
 }

 return tc_setup_cb_reoffload(block, tp, add, cb, TC_SETUP_CLSU32,
         &cls_u32, cb_priv, &n->flags,
         &n->in_hw_count);
}

static int u32_reoffload(struct tcf_proto *tp, bool add, flow_setup_cb_t *cb,
    void *cb_priv, struct netlink_ext_ack *extack)
{
 struct tc_u_common *tp_c = tp->data;
 struct tc_u_hnode *ht;
 struct tc_u_knode *n;
 unsigned int h;
 int err;

 for (ht = rtnl_dereference(tp_c->hlist);
      ht;
      ht = rtnl_dereference(ht->next)) {
  if (ht->prio != tp->prio)
   continue;

  /* When adding filters to a new dev, try to offload the
   * hashtable first. When removing, do the filters before the
   * hashtable.
 */
  if (add && !tc_skip_hw(ht->flags)) {
   err = u32_reoffload_hnode(tp, ht, add, cb, cb_priv,
        extack);
   if (err)
    return err;
  }

  for (h = 0; h <= ht->divisor; h++) {
   for (n = rtnl_dereference(ht->ht[h]);
        n;
        n = rtnl_dereference(n->next)) {
    if (tc_skip_hw(n->flags))
     continue;

    err = u32_reoffload_knode(tp, n, add, cb,
         cb_priv, extack);
    if (err)
     return err;
   }
  }

  if (!add && !tc_skip_hw(ht->flags))
   u32_reoffload_hnode(tp, ht, add, cb, cb_priv, extack);
 }

 return 0;
}

static void u32_bind_class(void *fh, u32 classid, unsigned long cl, void *q,
      unsigned long base)
{
 struct tc_u_knode *n = fh;

 tc_cls_bind_class(classid, cl, q, &n->res, base);
}

static int u32_dump(struct net *net, struct tcf_proto *tp, void *fh,
      struct sk_buff *skb, struct tcmsg *t, bool rtnl_held)
{
 struct tc_u_knode *n = fh;
 struct tc_u_hnode *ht_up, *ht_down;
 struct nlattr *nest;

 if (n == NULL)
  return skb->len;

 t->tcm_handle = n->handle;

 nest = nla_nest_start_noflag(skb, TCA_OPTIONS);
 if (nest == NULL)
  goto nla_put_failure;

 if (TC_U32_KEY(n->handle) == 0) {
  struct tc_u_hnode *ht = fh;
  u32 divisor = ht->divisor + 1;

  if (nla_put_u32(skb, TCA_U32_DIVISOR, divisor))
   goto nla_put_failure;
 } else {
#ifdef CONFIG_CLS_U32_PERF
  struct tc_u32_pcnt *gpf;
  int cpu;
#endif

  if (nla_put(skb, TCA_U32_SEL, struct_size(&n->sel, keys, n->sel.nkeys),
       &n->sel))
   goto nla_put_failure;

  ht_up = rtnl_dereference(n->ht_up);
  if (ht_up) {
   u32 htid = n->handle & 0xFFFFF000;
   if (nla_put_u32(skb, TCA_U32_HASH, htid))
    goto nla_put_failure;
  }
  if (n->res.classid &&
      nla_put_u32(skb, TCA_U32_CLASSID, n->res.classid))
   goto nla_put_failure;

  ht_down = rtnl_dereference(n->ht_down);
  if (ht_down &&
      nla_put_u32(skb, TCA_U32_LINK, ht_down->handle))
   goto nla_put_failure;

  if (n->flags && nla_put_u32(skb, TCA_U32_FLAGS, n->flags))
   goto nla_put_failure;

#ifdef CONFIG_CLS_U32_MARK
  if ((n->val || n->mask)) {
   struct tc_u32_mark mark = {.val = n->val,
         .mask = n->mask,
         .success = 0};
   int cpum;

   for_each_possible_cpu(cpum) {
    __u32 cnt = *per_cpu_ptr(n->pcpu_success, cpum);

    mark.success += cnt;
   }

   if (nla_put(skb, TCA_U32_MARK, sizeof(mark), &mark))
    goto nla_put_failure;
  }
#endif

  if (tcf_exts_dump(skb, &n->exts) < 0)
   goto nla_put_failure;

  if (n->ifindex) {
   struct net_device *dev;
   dev = __dev_get_by_index(net, n->ifindex);
   if (dev && nla_put_string(skb, TCA_U32_INDEV, dev->name))
    goto nla_put_failure;
  }
#ifdef CONFIG_CLS_U32_PERF
  gpf = kzalloc(struct_size(gpf, kcnts, n->sel.nkeys), GFP_KERNEL);
  if (!gpf)
   goto nla_put_failure;

  for_each_possible_cpu(cpu) {
   int i;
   struct tc_u32_pcnt *pf = per_cpu_ptr(n->pf, cpu);

   gpf->rcnt += pf->rcnt;
   gpf->rhit += pf->rhit;
   for (i = 0; i < n->sel.nkeys; i++)
    gpf->kcnts[i] += pf->kcnts[i];
  }

  if (nla_put_64bit(skb, TCA_U32_PCNT, struct_size(gpf, kcnts, n->sel.nkeys),
      gpf, TCA_U32_PAD)) {
   kfree(gpf);
   goto nla_put_failure;
  }
  kfree(gpf);
#endif
 }

 nla_nest_end(skb, nest);

 if (TC_U32_KEY(n->handle))
  if (tcf_exts_dump_stats(skb, &n->exts) < 0)
   goto nla_put_failure;
 return skb->len;

nla_put_failure:
 nla_nest_cancel(skb, nest);
 return -1;
}

static struct tcf_proto_ops cls_u32_ops __read_mostly = {
 .kind  = "u32",
 .classify = u32_classify,
 .init  = u32_init,
 .destroy = u32_destroy,
 .get  = u32_get,
 .change  = u32_change,
 .delete  = u32_delete,
 .walk  = u32_walk,
 .reoffload = u32_reoffload,
 .dump  = u32_dump,
 .bind_class = u32_bind_class,
 .owner  = THIS_MODULE,
};
MODULE_ALIAS_NET_CLS("u32");

static int __init init_u32(void)
{
 int i, ret;

 pr_info("u32 classifier\n");
#ifdef CONFIG_CLS_U32_PERF
 pr_info("    Performance counters on\n");
#endif
 pr_info("    input device check on\n");
#ifdef CONFIG_NET_CLS_ACT
 pr_info("    Actions configured\n");
#endif
 tc_u_common_hash = kvmalloc_array(U32_HASH_SIZE,
       sizeof(struct hlist_head),
       GFP_KERNEL);
 if (!tc_u_common_hash)
  return -ENOMEM;

 for (i = 0; i < U32_HASH_SIZE; i++)
  INIT_HLIST_HEAD(&tc_u_common_hash[i]);

 ret = register_tcf_proto_ops(&cls_u32_ops);
 if (ret)
  kvfree(tc_u_common_hash);
 return ret;
}

static void __exit exit_u32(void)
{
 unregister_tcf_proto_ops(&cls_u32_ops);
 kvfree(tc_u_common_hash);
}

module_init(init_u32)
module_exit(exit_u32)
MODULE_DESCRIPTION("Universal 32bit based TC Classifier");
MODULE_LICENSE("GPL");