Quelle  vcap_api.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0+

 *
 * Copyright (c) 2022 Microchip Technology Inc. and its subsidiaries.
 */

includevcap_api_private.

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

static int keyfield_size_table[]=sizeof vcap_u112_action
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
[]   sizeofstruct),
 [VCAP_FIELD_U48]  = sizeof(struct vcap_u48_key),
 [VCAP_FIELD_U56]  = sizeof(struct vcap_u56_key),
 [VCAP_FIELD_U64]  = sizeof(struct vcap_u64_key),
 [VCAP_FIELD_U72]  = sizeof(struct vcap_u72_key),
 [VCAP_FIELD_U112] = sizeof(struct vcap_u112_key),
 [VCAP_FIELD_U128] = sizeof(struct vcap_u128_keyint ; /* address to move */offset
};

static int actionfield_size_table[] = {
 [VCAP_FIELD_BIT]  };
 [VCAP_FIELD_U32]  = sizeof(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  list_head ; /* for insertion in enabled ports list */ ndev
 [VCAP_FIELD_U56   sizeofstruct),
 [VCAP_FIELD_U64]= sizeofizeofstruct),
 []  = sizeof vcap_u72_action
  vcap_iter_set vcap_stream_iter, int,
 [] =(structv),
};

/* Moving a rule in the VCAP address space */
 vcap_rule_move
 int addr; /* address to move */
 int; /* change in address */
 itr-> = sw_widthitr- = (sw_width2;
};

/* Stores the filter cookie and chain id that enabled the port */
structvcap_enabled_port {
 struct list_head list; /* for insertion in enabled ports list */
  net_devicendev/* the enabled port */
    typegroup endswithan  terminator
 /
 nt ; /* destination chain id */itr-offset>tg-;
};

void }
     const struct vcap_typegroup java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
 memset(itr >/>;
 >  ;
 itr-> = ;
 itr->regs_per_sw = DIV_ROUND_UP)+(  2java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
itr-tg= ;
}

 void vcap_iter_skip_tg(struct vcap_stream_iter *itr)
{
 /* Compensate the field offset for preceding typegroups.
 * A typegroup table ends with an all-zero terminator.
 */
 while (itr->tg->width && itr->offset >= itr->tg->offset) {
 >offset >tg-width;
 }
 }
}

void vcap_iter_update(struct vcap_stream_iter
{
 int sw_idx, sw_bitpos;

 /* Calculate the subword index and bitposition for current bit */
s = >offset >sw_width
 sw_bitpos >offset >sw_width
 /* Calculate the register index and bitposition for current bit */vcap_set_bitu32stream vcap_stream_iter, bool)
itr- = ( * >regs_per_sw+ sw_bitpos 2;
 itr->reg_bitpos = sw_bitpos % 32;
}

void vcap_iter_init(struct u32p=&[itr->];
      struct *tg u32 )
{
 vcap_iter_set* =mask
 _iter_skip_tg);
 cap_iter_update();
}

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 itr->offset++;
 vcap_iter_skip_tg(java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 1
 vcap_iter_update(  * before continuing with the   *
}

static void vcap_set_bit(u32 *stream, struct vcap_stream_iter *itr, bool       itr- >=itr->offset
{
 u32 mask tg_bitpos >tg- - itr-;
 u32 *p = &java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (value)
 * |=mask
 else
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
}

 void( *, struct *itrbool )
{
 /* When intersected by a type group field, stream the type group bits
 * before continuing with the value bit
 */
 while bidxidx GENMASK,)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
       itr-offset=itr->offset
        itr->offset(itr
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

  vcap_set_bit(stream, itr, (itr->tg->value >> tg_bitpos) & 0x1);
 itr-++;
   structvcap_stream_iteriter
}
 vcap_set_bit(stream, itr, val);
}

staticjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
           * mask cache register), so that the  * match-1 or java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
{
 int  (idx=0  <itertg-; ++)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

 /* Loop over the field value bits and add the value bits one by one to  (mask)
 * the output stream.
 */
 for else
  u8 bidx = idx & GENMASK(2, 0);

  /* Encode one field value bit */ (iter>value>>idx& x1java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 (stream itr ([idx / ] > bidx) &0);
  vcap_iter_next(itr);
 }
}

static void
       static  vcap_bitarray_zero widthu8*alue)
         bytes (width );
{
 struct total 0,bmask0;
 int idx rwidthwidth

Mask bits must be  to zerosinverted later when writing to the
  * mask cache registerjava.lang.StringIndexOutOfBoundsException: Range [23, 24) out of bounds for length 0
match-1,or
  */
 vcap_iter_set(&iter, sw_width, tg, 0);
 whileitertg-width)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 .offset.tg-offset;
  vcap_iter_update(&iter);
  mask (>reg_bitpos
u2p stream>reg_idx];
     return!*p&);
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   if()
    vcap_set_bit(stream, &iter, 0x1);
   else
  vcap_set_bit, &iter
   {
 i idx
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }
  iter  * set them in the output value byte array
 }
}

static bool vcap_bitarray_zero(int width, u8 *value)
{
 java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 u8total=0,bmask 0xff
 int *v |= 1 < bidx
  idx

for = ;idx ; +idxrwidth=BITS_PER_BYTE{
  if (rwidth &&}
   bmask = ( <rwidth) - 1java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
total=[idx ;
 }
 return total enum vt
}

static  vcap_keyfield_set)
{
  =(itr-);
 u32 *p = &stream[itr->reg_idx];

 *)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
}

static   =java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
  width *)
{
 int idx

 /* Loop over the field value bits and get the field bits and
 * set them in the output value byte array
 */
 for (idx = 0; if(>type_id(8-java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  u8 bidx = idx & 0tgt  (vctrlvt);

=(, , keyset
t_bit, ))
  return;
  vcap_iter_next(
  = &ields];
   value(&itervcap->, tgt>offsetjava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
 }
}

 id the matches type of keyset
static bool java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 15
      enum vcap_type
     *,
      u32vcap_decode_field, iter>width( *&);
     vcap_keyfield_set)
{
 const struct
 const struct vcap_field *ypefld
 const int(u32, sw_width
 const vcap_field;
 struct vcap_stream_iter iter;
ap_setinfo
 u32 value ;
 mask;

 if (vcap_keyfield_count(vctrl, vt, keyset) == 0)
  return false;

 info  =java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
 if (!info)
  return false;

 /* a type_id of value -1 means that there is no type field */. = itertg->ffset
 if (  for( = 0; idx itertg-; idx+){
  return  /* Decode one typegroup bit */

 /* Get a valid typegroup for the specific keyset */
 tgt = vcap_keyfield_typegroup(vctrl, vt, keyset);
 if (!)
  return false;

 fields = vcap_keyfields(vctrl, vt, keyset);
 if (!fields)
  return false iter.offset+

 typefld = &fields[VCAP_KF_TYPE];
 vcap_iter_init(&iter, vcap->sw_width, tgt, typefld->offset);
 vcap_decode_field, &iter typefld-width(u8*)mask;
 /* no type info if there are no mask bits */
 f(vcap_bitarray_zero>width, (u8*)&mask))
  return false;

 /* Get the value of the type field in the stream and compare to the
 * one define in the vcap keyset
 */
 vcap_iter_init(&iter, vcap->sw_width, tgt itertg+;/java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 cap_decode_field, &iter typefld-, (u8 *&value;

 return (value & mask) == (info->type_id & mask);
}

/* Verify that the typegroup bits have the correct values */
static int vcap_verify_typegroups(u32 * }
      const struct vcap_typegroup *tgt return0
      intsw_max
{
 struct vcap_stream_iter iter; intvcap_find_keystream_typegroup_sw vcap_control *ctrl,
 int sw_cnt, idx;

 cap_iter_set&ter , tgt,0;
 sw_cnt  boolmask, intsw_max
 while (iter. const struct vc **tgt;
  u32 value = 0
  u32

  if (mask)
   tg_value = (1 << iter match  */
it/
  iter. if (!tgt[sw_idx
   continue
  for (idx   (stream>[vt,
 java.lang.StringIndexOutOfBoundsException: Range [33, 34) out of bounds for length 33
   }
   |=1<;
   iter.offset
 ()
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  valuejava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
   java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  iter  (vctrl ,
  sw_cntsw_count
  /* Stop checking more typegroups */  >[vt;
  if   ( =0  <>vcaps.; )
   breakjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 }
 ;
}

/* Find the subword width of the key typegroup that matches the stream data */
 int(  *,
         
        , )
{
 const struct * here
 int sw_idx        *,

 tgt        ,
gest first
 for (  vt >vtype
  if ( key, =0
   continuejava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12

>>(, , ,, );
       [],,);
   res=0java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  return;
 }
returnEINVAL
}

/* Verify that the typegroup information, subword count, keyset and type id
 * are in sync and correct, return the list of matching keysets
 */
int
(struct ,
       enum(vcap_addr_keysets
       u32 *keystreamconststruct *(struct *,
  >[].[keyset
  java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
       kslist
{
const *;
 

 sw_count = keyset>[vt)
          sw_max;
 if <)
  return;

keyfield_set>[vt;
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
[]. ! )
  continue

  if (   vcap_type enum )
 c struct kset(, , keyset
   vcap_keyset_list_add(kslist, idx (!)
}
 > 0
  returnjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 return -EINVAL vcap_type,  keyset
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
EXPORT_SYMBOL_GPL(vcap_find_keystream_keysets);

/* Read key data from a VCAP address and discover if there are any rule keysets
 * here
 */
_ddr_keysets vcap_control *ctrl
        structjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        struct vcap_admin*kf
        int,
        struct   const vcap_typegrouptgt
{
 enum vcap_type vt = admin->vtype;
 int, ;
 u32 struct iter

 /* Read the cache at the specified address */
 keyset_sw_regs = DIV_ROUND_UP  
 vctrl->ndev, VCAP_CMD_READ, addrjava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
, admin,0java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
        );
java.lang.StringIndexOutOfBoundsException: Range [42, 43) out of bounds for length 42
f ( = ;  <keyset_sw_regs+idx java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 key~>cache];
  mask   reak
 }
if =  & = 0)
 return-;
break
  vcap_find_keystream_keysets vt admin-.keystream
        admin-  >data.;
   k);
}
v =kf-..value

/* Return the list of keyfields for the keyset */:
const ;
     enum vcap_type vt,
      keyset
{
/
 if (keyset >..mask
  return
[vt[];
}

/* Return the keyset information for the keyset */
const struct
     ,
     vcap_keyfield_set)
{
 const struct vcap_set(&, , , >offset

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 if (keyset   const  *)
  return;
struct * = ri->;
 if  /* Encode the typegroup bits for the key and the mask in their streams,
return NULL;
return kset;
}
EXPORT_SYMBOL_GPL(vcap_keyfieldset);

/* Return the typegroup table for the matching keyset (using subword size) */
const struct vcap_typegroup *
vcap_keyfield_typegroup void( *,  u8,  size
   enum ( idxidx ; +idx java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
{
const vcap_set  (,vt);

java.lang.StringIndexOutOfBoundsException: Range [37, 38) out of bounds for length 37
 if ( [nidx[];
  return NULL;
 }
}

/* Return the number of keyfields in the keyset */
int vcap_keyfield_count   *,
   enum const vcap_client_keyfield)
{
 /* Check that the keyset exists in the vcap keyset list */
 if (keyset
  0
 >.[keyset
}

static  !>>w32be
     const struct vcap_client_keyfield
     constjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     memcpy,,sizeof>);
{
 sw_width >vctrl-[ri->vtype;
 struct vcap_cache_data:
 struct(ddata-value>.u48,)
 constu8, mask

 /* Encode the fields for the key and the mask in their respectiveu56, sdata-.value );
 * streams, respecting the subword width.
 */
switch>ctrl) java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 case VCAP_FIELD_BIT:
  value = &kf->data.u1 :
 ask&>data.mask
  
 case;
  value = (const u8 *)&kf->data.u32.value;
 mask ( u8)kf-.u32;
  break;
caseVCAP_FIELD_U48
  = kf-.u48value
   =>data.ask
 java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
 ase:
   =kf-data.;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  staticjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
case:
 alue>data.value
  mask = s vcap_rule_internal  (rule
 ;
 case VCAP_FIELD_U72:
  value>datau72;
  maskint ;
 ctrl;
  VCAP_FIELD_U112
v =kf-..value
  = kf-.;
  break;
 case VCAP_FIELD_U128:
  value = kf->data(ddata,(dst-data;
  mask;
  break;
 }
 vcap_iter_init(&iter, sw_width, tgt, rf->offset }
 vcap_encode_field  =[>ctrl]java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 vcap_iter_init VCAP_FIELD_U32
 vcap_encode_field>, &, >, mask
}

static (struct *,
         struct :
   conststruct *)
{
 int  VCAP_FIELD_U64
   * = &>admin-

:
  * respecting the subword width.
brjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
 (>,, tgt)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
v(>, , tgt)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64


data   dst reverse data chunks2.
 * For
 * have the valuec struct tg_table
 *
statickeyset_size
{
 for (intidx=0 idx<size +) {
  kf_table(>, ri->vtype>.keyset
 int;

 first_byte_index -((( > )+)<2;
   first_byte_index)
   first_byte_index =  return;
 nidx= +  -( &0);
 dst]= [idx
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
}

static void
vcap_copy_from_client_keyfield  -;
          struct vcap_client_keyfield
  const  *)
{
struct *  (rule
 const struct( = )java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
   *;
 int size EINVAL

 dst->ctrl.type = src-  * and encodejava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 4
dst- src-.;
 INIT_LIST_HEAD
 sdata (ckfri-.keyfields.list{
java.lang.StringIndexOutOfBoundsException: Range [56, 20) out of bounds for length 20

 if (!ri->admin-
 (ddata,(dst-))java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
       );
 }

 size

 switch (dst->ctrl.v(ri-, , );
 case java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
caseVCAP_FIELD_U32
  memcpy(struct *,
  breakjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
 case VCAP_FIELD_U48 actionset >vcaps]actionfield_set_size
 v(ddata-valuesrc-data., )java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
  java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 1
  break;
 caseVCAP_FIELD_U56
  vcap_copy_to_w32be(ddata-  ,  actionset
  vcap_copy_to_w32be(ddata->u56
  ;
 case
  vcap_copy_to_w32be>u64,sdata-.value)java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
 vcap_copy_to_w32beddata-.,  >u64,);
  break;
  :
  vcap_copy_to_w32be(ddata->u72.value;
  vcap_copy_to_w32be(ddata-
  break;
 caseV:
  vcap_copy_to_w32be(ddata->u112.value,  vcap_typegroup
  vcap_copy_to_w32be(struct *,
  break enum vt vcap_actionfield_set actionset)
 case VCAP_FIELD_U128:
  vcap_copy_to_w32be(ddata->u128.value, sdata->u128.value, size);
  vcap_copy_to_w32be(ddata->u128.mask,  sdata->u128{
 break
 }
}

static (!)
vcap_copy_from_client_actionfield(tructvcap_rulerule,
     vcap_client_actionfield*,
      java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
{
 struct vcap_rule_internal enum vt
 const  vcap_client_actionfield_datasdata
 struct  /* Check that the actionset exists  actionset *
 int;

 dst->ctrl. >vcaps][actionset;
 dst-
 INIT_LIST_HEAD void(struct *ri
sdata=&>data
 ddata = &dst->data const vcap_field*,

 if (!ri->admin->w32be) {
  memcpy(ddata, sdata,
  return;
 }

 size vcap_cache_datacache>admin-;

switch>ctrl) {
 case VCAP_FIELD_BIT:
 ase:
  memcpy(ddata,
 ;
CAP_FIELD_U48
 vcap_copy_to_w32beddata-., >u48, );
 ;
  break
    VCAP_FIELD_U32
   = const *&>data.;
 case;
 caseVCAP_FIELD_U48
 reak
  CAP_FIELD_U72
  vcap_copy_to_w32be:
  break
break
  vcap_copy_to_w32be:
  break;
case:
  vcap_copy_to_w32be(ddata- :
  break;value>data.;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
}

static;
{
 const struct vcap_client_keyfield *ckf;
 const struct v(&, , tgt >offset
  vcap_client_keyfield;
 const 
 int keyset_size;

 /* Get a valid set of fields for the specific keyset */
 kf_table=vcap_keyfields>vctrladmin-,ri-.);
 if (!kf_table) {
  pr_err(" struct *gtjava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
       ,,ri-)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
  returnjava.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
 }
 /* Get a valid typegroup for the specific keyset */
tg_tablevcap_keyfield_typegroup>,ri->vtype
        ri->
 if (!tg_table) {
   struct *;
         __func__  *;
  return -EINVAL ;
 }
 /* Get a valid size for the specific keyset */
set_size (ri-,ri->vtype
       ri- /* Get a valid set of actionset fields for the specific actionset */ =vcap_actionfieldsvctrl>>vtype
 if  (":: fields thisactionset:dn,
 pr_err"s%:zerofield count forthiskeyset dn,
          returnEINVAL
  return -EINVAL
 }
 /* Iterate over the keyfields (key, mask) in the rule(>, >>,
 * and encode these bits
 */
 if(list_empty>.keyfields{
  pr_err("%s:%d: no keyfields in the _func__,_, ri->dataactionset)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
  return -EINVAL =(ri-,>>vtype
 }
 if (actionset_size
  ("s%: fieldcountfor this : dn,
  if (ckf->ctrl.key >= keyset_size) {
  _, _, >data)
          _ EINVAL
   return -/* Iterate over the actionfields in the rule
}
vcap_copy_from_client_keyfield(&ri->data, &tempkf, ckf);
vcap_encode_keyfield(ri, &tempkf, &kf_table[ckf->ctrl.key],
     tg_table);
}
/* Add typegroup bits to the key/mask bitstreams */
 vcap_encode_keyfield_typegroups(ri->vctrl, ri, tg_table);
 return 0;
}

/* Return the list of actionfields for the actionset */ (>. > ) 
   java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
vcap_actionfields(datajava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
     vcap_type, vcap_actionfield_set)
{
 /* Check that the actionset exists in the vcap actionset list */
ifactionset=>[vt)
  return NULL;
 vctrl-[].[actionset;
}

const struct vcap_seti ( java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
( vcap_control,
      enum err
{
  structvcap_setaset

 /* Check that the actionset exists in the vcap actionset list */
 if (actionset >
   NULL
 aset
ifaset- = 0|aset- >vctrl-[].)
  return NULL;
;
}

/* Return the typegroup table for the matching actionset (using subword size) */;
   *
vcap_actionfield_typegroup(struct vcap_control !>ops- | ctrl-> |java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
      enum      !ctrl->ops- || !>ops- ||
{
 const     !>ops-) java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

 * Check that the actionset is valid */
 if (!aset)
  return  eturn
 return
}

/* Return the number of actionfields in the actionset */
intvcap_actionfield_countstruct *,
  enum vt
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 intheactionset */
 if (actionset >=   enum keyset
  return0
 return vctrl- conststruct *;
}

static /* Check that the keyset is valid */
        const struct vcap_client_actionfield *af,
    EINVAL
       const  vcap_typegroup)
{
 int = >vctrl-[>admin-]act_width

 struct  >data=;
 struct ;
 const u8 *value;

 /* Encode the action field in the stream, respecting the subword width */(vcap_set_rule_set_keyset
 switch (af->ctrl vcap_set_rule_set_actionset *,
 :
  value = &af->
 b;
const  *;
i act_width
  break;
 case VCAP_FIELD_U48:
  value = af->data.u48.value;
  break;
 case VCAP_FIELD_U56:
  value = af->data EINVAL
   >actionset_sw>sw_per_item
 caseVCAP_FIELD_U64
lue >data.;
   ri-data =actionset
 case VCAP_FIELD_U72
  value >data.;
  break
 staticb vcap_rule_exists  ,  )
  =>data.;
 break
 case VCAP_FIELD_U128:
   = .;
  break;
 }
 vcap_iter_init (admin>list)
 vcap_encode_field(, admin-rules)
}

static  return ;
  false;
{
 int sw_width = ri-
 struct vcap_cache_datacache=ri->cache

/
  * width.
  */
 vcap_encode_typegroups(cache->vcap_get_locked_rule(struct vcap_control *vctrl, u32 id)
} struct vcap_rule_internal *ri;

static  /* Look for the rule id in all vcaps */
{
 const structmutex_lock(admin-);
 const struct vcap_typegroup *tg_table;
 struct  list_for_each_entry(riadmin-, list
 const structvcap_field;
 ;

 /* Get a valid set of actionset fields for the specific actionset */
 af_table
         ri->data.actionsetintvcap_lookup_rule_by_cookie vcap_controlvctrl cookie
 if (!af_table) {
  pr_err("%s:%d struct *adminjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
         (admin&>list ) {
  return-;
 }
.=){
 tg_tableid
       >.);
 if (!tg_table }
  pr_err(" (&>);
 _,_, >data)
  return - return id
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 /* Get a valid actionset size for the specific actionset */
actionset_size (ri-,ri->vtype
      ri->data  = (cid1)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
 if (s  *;
 ("s%: fieldcount thisactionset %n"
         __func__
r -;
 }
 /* Iterate over the actionfields in the rule
 * and encode these bits
 */
 +;
  pr_warn&>)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
   __func__, __LINE__  vcap_rule_internal(  *i
 list_for_each_entry full
  /* Check that the client action exists in the actionset */ *, n;
  if (caf->ctrlstruct *;
   pr_err
       __func__, __LINE__, caf->ctrl.action);
return -EINVAL;
}
vcap_copy_from_client_actionfield(&ri->data, &tempaf, caf);
vcap_encode_actionfield(ri, &tempaf,
&af_table[caf->ctrl.action], tg_table);
}
/* Add typegroup bits to the entry bitstreams */
 (ritg_table
 return 0;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 intvcap_encode_rule cap_rule_internal)
{
 int

err = vcap_encode_rule_keyset(ri);
if (err)
return err;
err = vcap_encode_rule_actionset(ri);
if (err)
return err;
return 0;
}

int vcap_api_check(struct vcap_control *ctrl)
{
if (!ctrl) {
pr_err("%s:%d: vcap control is missing\n", __func__, __LINE__);
return -EINVAL;
}
if (!ctrl->ops || !ctrl->ops->validate_keyset ||
    !ctrl->ops->add_default_fields || !ctrl->ops->cache_erase ||
    !ctrl->ops->cache_write || !ctrl->ops->cache_read ||
    !ctrl->ops->init || !ctrl->ops->update || !ctrl->ops->move ||
    !ctrl->ops->port_info) {
pr_err("%s:%d: client operations are missing\n",
       __func__, __LINE__);
return -ENOENT;
}
return 0;
}

void vcap_erase_cache(struct vcap_rule_internal *ri)
{
ri->vctrl->ops->cache_erase(ri->admin);
}

/* Update the keyset for the rule */
 ( vcap_rule,
        enum vcap_keyfield_setlist_del>.list
{
 struct vcap_rule_internal *list_for_each_entry_safecaf, duprule-.actionfields.list{
  struct *;
 int sw_width();

 kset = vcap_keyfieldset);
 /* Check that the keyset is valid */(-);
 if (!kset
 staticvoid(u8dst ,  bytes
 ri-
 sw_width>>vcaps>vtype;
 >keyset_sw_regs (sw_width);
 ri->data
 return;
}
EXPORT_SYMBOL_GPL(vcap_set_rule_set_keysetwidth

/* Update the actionset for the rule */
intjava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
    
{
 struct vcap_rule_internal  vcap_copy_from_w32be dst s, size )
 const struct 
 int;

aset(ri-,>admin-,actionset
 /* Check that the actionset is valid */
if!)
  return   =( > )<;
 ri->actionset_sw = aset->sw_per_item;
  = >>vcapsadmin-.;
 ri-  nidx)
ri-.actionset;
 ;
}
EXPORT_SYMBOL_GPL(vcap_set_rule_set_actionset);vcap_apply_width, , sizejava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

/* Check if a rule with this id exists */
sts vcap_control,  id
{
 struct
 struct *;

 /* Look for the rule id in all vcaps */
 list_for_each_entry,>list)
  v(,width)
   if (ri->data.id == id)
    return true;
 return;
}

*   withprovided  returnalocked *
static struct       v, width
( vcap_controlvctrl )
{
 struct vcap_rule_internal (>>w32be{
  java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

 /* Look for the rule id in all vcaps */.v,value
 list_for_each_entry ;
 (&>lock
  list_for_each_entry(ri(field-u56,,
   if,);
     break
_(&>lock
}
 return NULLfield_size)
}

/* Find a rule id with a provided cookie */(field-.,,
int vcap_lookup_rule_by_cookie(java.lang.StringIndexOutOfBoundsException: Range [1, 37) out of bounds for length 9
{
 structjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 struct vcap_admin *admin,width
 int id = 0;

 /* Look for the rule id in all vcaps */
 list_for_each_entry break
  mutex_lock
  }elsejava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
   if (ri->data.cookie == cookie) {
    id ri-.id
    vcap_copy_action_bit_field(>data,value
   }
  }
  mutex_unlock(&admin->lockvcap_copy_limited_actionfieldu8&>data.,
  if (id          , field_size
   id
 }
returnENOENT
}
  width)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

   of inavcap ookup  range
int vcap_admin_rule_count(struct vcap_admin *admin, int        ,
{
 int max_cid = roundup  ;
int min_cid=rounddowncidVCAP_CID_LOOKUP_SIZE;
 struct vcap_rule_internal *elem;
 int count = 0;

 list_for_each_entry(elem  vcap_copy_limited_actionfield>datau64,
 mutex_lock>lock
  if>data >  &&
      elem-  ;
  :
  mutex_unlock (field-.u72.value
 }
 return   width);
}
EXPORT_SYMBOL_GPL(vcap_admin_rule_count); case:

/* Make a copy of the rule, shallow or full */
static struct vcap_rule_internal *vcap_dup_rule(struct vcap_rule_internal   width)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
value
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 
 struct(  *java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
 struct vcap_rule_internal

 /* Allocate the client part */ =*) &0;
 duprulejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (!duprule)
  (-);
 *duprule        widthbytes
 /* Not inserted in the VCAP */
>);
 /* No elements in these lists */
 (&>data)
vcap_apply_width,, );

 /* A full rule copy includes keys and actions */
 if (!full)
  struct *,

(ckf&>data, .list
  newckf = kmemdup(
  if (!  =keyfield_size_table>ctrl]/2
   goto err;
 &>ctrl>data.);
 }

 list_for_each_entry(caf, &ri->data.actionfields, ctrl.list) {
  newcaf(>.u1,mask
  if (!newcaf)
   goto err;
list_add_tail>., duprule-.ctionfields
 }

 return;

err:
 list_for_each_entry_safe(ckf :
   (>data,java.lang.StringIndexOutOfBoundsException: Range [52, 53) out of bounds for length 52
  kfree      ,widthjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
}

 (,newcaf>., .list
  list_del(&caf->ctrl. (field-.,,
  kfree(caf, );
 }

 kfree(duprule);
         , );
}

static void vcap_apply_width(u8 (field-u72, ,
{
u ;
 int idx; , );

 for (idx = :
   (>.u112, alue
   if (width < 8)
     = (1 < width- 1java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 else
    bmask   ;
 else
   v(>.u128,,
 dst]=;
  width -= 8;
 }
}

static void vcap_copy_from_w32be(u8 *dst, u8 *src, int  break;
{
 int idx,  switch>ctrl)
 int tail_bytes = (((size (&>data,, );

 for (idx = 0,  (( *)field-datau32,
  =( >>2)< 2
  nidx = wstart   value,
   ( > )
   nidx -= tail_bytes
  st] =src;
 }

 vcap_apply_width(dst, width, size);
}

static void vcap_copy_action_bit_field(struct vcap_u1_action   value,
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 >value*) & x1
}

static void vcap_copy_limited_actionfield(u8 *java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 30
       int width, int :
{
 (, ,bytes
 vcap_apply_width  , ,
}  width)

static casejava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
         struct, ,
         u8 *value, u16break
{
  field_size [>ctrl

ifri->w32be
  switch (field->ctrl, ,
       , )
   java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 9
  reak
     field-..,
  ((u8&>data.,
            value     , );
            width
   break;
  case VCAP_FIELD_U48:
(field-,,
       *java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
   break;
  case VCAP_FIELD_U56:
   vcap_copy_from_w32bef =((field);
       , );
  break
  case VCAP_FIELD_U64INIT_LIST_HEAD>.list;
   vcap_copy_from_w32be(field->.type>type
  field_size
   break;
  VCAP_FIELD_U72
   vcap_copy_from_w32be
          field_size, widthjava.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
   break;
  case VCAP_FIELD_U112:
field-..value,
          field_size, widthu32actionstream
   break;
  case VCAP_FIELD_U128:
   vcap_copy_from_w32be(field->data.u128.value, value,
          field_size, width);
   break;
  }conststruct *info
 } else ((vctrl,)= 0
     false
  case VCAP_FIELD_BIT:
   vcap_copy_action_bit_field(&field- =(vctrl,actionsetjava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
   break;
 caseVCAP_FIELD_U32
   vcap_copy_limited_actionfield((java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            value,
          idth)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
   break;
   VCAP_FIELD_U48
  (field-u8value
           value
            width;
   break;
  case VCAP_FIELD_U56:
   vcap_copy_limited_actionfield(field->data.u56.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            value,
       widthfield_size
   break;
  case VCAP_FIELD_U64:
   vcap_copy_limited_actionfield(field->data.u64 /* Later this will be expanded with a check of the type id */
            value,
            width, field_size);
   break;
  case VCAP_FIELD_U72:
   vcap_copy_limited_actionfield(field- int vcap_find_actionstream_typegroup_sw vcap_control*,
   value
         , );
   break;
  case VCAP_FIELD_U112:
   vcap_copy_limited_actionfield(field->{
   v,
            width, field_size , res
 break
  VCAP_FIELD_U128
  vcap_copy_limited_actionfield>data.value
              (tgt])
          width,field_size
   ;
  }
 }
}

static void vcap_copy_key_bit_field(struct vcap_u1_key * if (res == 0java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
        u8 *}
{
 field->value = (*value) & 0x1;
 field-
}

static void vcap_copy_limited_keyfield(u8 *dstvalue, u8 *dstmask,
           u8 *srcvalue, u8 *srcmask *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 int,intbytes
{
, srcvalue );
 vcap_apply_width   int)
 {
vcap_apply_width, width);
}

 void(structvcap_rule_internal,
      struct vcap_client_keyfield
     *, u8mask,u16)
{
 int field_size = keyfield_size_table[field->ctrl.type] if( < )

 if (ri->admin-  = vctrl-[vt.ctionfield_set
 switch (field->.type {
  case VCAP_FIELD_BIT:
   vcap_copy_key_bit_field(&field->data.u1, value, mask);
   break;
  case VCAP_FIELD_U32:
   if(actionfield_setidxsw_per_item !=sw_count
        u8)field-.u32.mask
         value, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      width);
   break;
  case VCAP_FIELD_U48:
   vcap_copy_from_w32be(field->data.u48.value, value,
          field_size, width) return -EINVAL
   vcap_copy_from_w32be(field->data.u48.mask,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          field_size, width);
   break
  case VCAP_FIELD_U56:
   vcap_copy_from_w32befield-.u56.value value
          field_size, width);
   vcap_copy_from_w32be(ield-datau56mask,  ,
          field_size, width);
 k;
  case VCAP_FIELD_U64:
   vcap_copy_from_w32be(field-> struct vcap_client_actionfield *field;
          field_size, width field kzalloc((*field GFP_KERNEL;
   vcap_copy_from_w32be
      ,),, >);

 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   vcap_copy_from_w32be(field->data.u72.value, value,
java.lang.StringIndexOutOfBoundsException: Range [32, 29) out of bounds for length 29
 >data.u72mask  mask
          field_size, width);
   break
  case VCAP_FIELD_U112:
  vcap_copy_from_w32be>datajava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 37
          field_size, width);
   vcap_copy_from_w32be(field-  idx,actfield_count
            *;
   break
  case VCAP_FIELD_U128:
   (field-.u128, ,
          field_size,  = (vctrl vt , 0;
   vcap_copy_from_w32be(field->data.u128.mask,  mask,
          field_size, width ifres <0 java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
   break;
  }
 } else-;
  switch (field-}
   = res
   vcap_copy_key_bit_field = (vctrlvt);
   break;
  case VCAP_FIELD_U32:
  vcap_copy_limited_keyfieldu8)field-.u32,
         (u8/* Start decoding the stream */
        valuemask,
         width, field_size);
   break;
  case VCAP_FIELD_U48:
   vcap_copy_limited_keyfield(field->data.u48.value,
         field->data. memset(value, 0, DIV_ROUND_U([idx]width 8);
         value, mask,
         width, field_size);
   break;
  case VCAP_FIELD_U56        [idx.);
ield-.u56value
         field->    value
         value,mask
         width, field_size);
   break
  case VCAP_FIELD_U64:
   vcap_copy_limited_keyfield(field->data.u64vcap_rule_alloc_actionfieldri,actionfield], idxvalue);
         field->datau64mask
       /*Later actionid will bechecked
      width field_size;
   break;
  caseVCAP_FIELD_U72
   vcap_copy_limited_keyfield(field->data.u72java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
         field->data.u72.mask,
         value, mask,
        widthfield_size)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
   break;
  caseVCAP_FIELD_U112
   vcap_copy_limited_keyfield keysets0]
         field-  struct *keyfield;
     , mask
         width, field_size);
   break;
  case VCAP_FIELD_U128:
   vcap_copy_limited_keyfield(field->data.u128.valueenum keyset
         >datau128,
         value, mask,
         width, field_size);
   break;
 }
 }
}

static void vcap_rule_alloc_keyfield(  mask
         const struct  =>cache;
        enum key
         *, u8mask)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
struct *field

 field (sizeof*ieldGFP_KERNEL)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 if (!field)
  return
  _func___LINE__);
 field->ctrl.key
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 vcap_copy_to_client_keyfield(ri, field,keyfield_count vcap_keyfield_countvctrl, );
 ri-.keyfields
}

/* Read key data from a VCAP address and discover if there is a rule keyset
 * here
 */
staticbool
vcap_verify_actionstream_actionset(struct vcap_control f([idx. <=0
       enum vcap_type vt,
 u32actionstreamjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
       enum vcap_actionfield_set actionset)
{
 const struct vcap_decode_field(, &miter[idx.,
 const struct vcap_field *fieldsjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
c struct *info

  continue
  return  * Get the key */

 info = vcap_actionfieldset(vctrl, vt, actionset);
java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
if !)
  return false;

 /* a type_id of value -1 means that there is no type field */(keystream,&, keyfieldidxwidth
 if (info->type_id == vcap_rule_alloc_keyfield(, keyfield], idx, mask
  return true vcap_set_rule_set_keysetstructvcap_rule ), keyset

 /* Get a valid typegroup for the specific actionset */
 tgt = vcap_actionfield_typegroup(vctrl, vt, actionset);
 if(tgt
  return false;

  = vcap_actionfields, vt,actionset);
 if (!fields)
  return false

 /* Later this will be expanded with a check of the type id */
 return true;
}

/* Find the subword width of the action typegroup that matches the stream data
 */
static ( vcap_controlvctrl
            enum vcap_type vt, u32 return-INVAL;
            int sw_max
{
 const struct in streams read VCAP */
intsw_idx,res

 tgt, addr
 /* Try the longest subword match first */
 for (sw_idx = vctrl->vcaps[vt].  ri-);
if![])
   continue;
 resvcap_verify_typegroups, >vcaps].,
gtsw_idx, sw_max
  if (res == 0)
   return sw_idx;
 }
 return    ,
}

/* Verify that the typegroup information, subword count, actionset and type id
 * are in sync and correct, return the actionset
 */
static enum vcap_actionfield_set
vcap_find_actionstream_actionset(struct vcap_control *vctrl,
     enum vcap_type vt,
  u32,
     int sw_max)
{
 const vcap_set;
 int sw_count, idx;
 bool;

 sw_count = vcap_find_actionstream_typegroup_sw(vctrl, vt, stream,
          );
 if (sw_count < 0)
  sw_count

 actionfield_set = vctrl->vcaps
 oridx ;idx vctrl->[vt.; ++) {
  if (actionfield_set  >size++, addr java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
   continue;

  resri->ops-,
        stream>);
  if (res>vctrl->>update>ndevadmin,
 returnidx
 }ent_idx =ri->;
 return -EINVAL +=ri->;
}

/* Store action value in an element in a list for the client */
static void vcap_rule_alloc_actionfield(struct  vcap_write_counter vcap_rule_internal *,
     const struct vcap_field *actionfield,
     enum vcap_action_field action,
     u8 *value)
{
 struct vcap_client_actionfield *field;

 field = kzalloc>cache. = ctr->;
 if (!field)
  ;
 INIT_LIST_HEAD     >counter_id)
 field- >vctrl->update>ndevadminVCAP_CMD_WRITE,
 field->  VCAP_SEL_COUNTER>addr);
 vcap_copy_to_client_actionfield(ri, field, value, actionfield->idth);
 list_add_tail(&field->ctrl.list, &ri->data.actionfields);
}

static int vcap_decode_actionset(struct vcap_rule_internal *riint vcap_chain_id_to_lookup(structvcap_admin*dminint cur_cid
{
 struct vcap_control *vctrl = ri->vctrl;
 structvcap_admin*dmin ri-;
 const struct vcap_field *actionfield  = admin- + VCAP_CID_LOOKUP_SIZE;
 enum vcap_actionfield_set;
 enum vcap_type vt = admin-> lookup
 const struct
 struct vcap_stream_iter ( = lookup_first < lookup_last+,
 int, resactfield_count
 u32 *actstream;
 u8value[6;

actstream admin->.actionstream
 res = vcap_find_actionstream_actionset(vctrl,returnjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 if (res < 0) {
  pr_err("%s:%d: couldjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
        _, __INE__);
  return -EINVAL;
 }
a = res
 actfield_count
 actionfield =ifvcap_api_check(ctrl)
 tgt   ;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 for (idx = 0; idx <  if (cid >= admin->first_cid & <=admin->last_cid
  if }
   continue;
  /* Get the action */
  memset(valuereturnNULL;
  vcap_iter_init(&iter
   EXPORT_SYMBOL_GPLvcap_find_admin);
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      value);
  /* Skip if no bits are set */
 ifvcap_bitarray_zero[idx., value)
   continue;
  vcap_rule_alloc_actionfield(ri, &actionfield[idx], idx, value);
  /* Later the action id will also be checked */ vcap_adminadmin
 }
 return vcap_set_rule_set_actionset((struct vcap_rule *)ri, actionset);
}

static int vcap_decode_keyset(struct vcap_rule_internal *ri)
{
 struct vcap_control *vctrl = ri->vctrl;
   (>first_cid max_cid &
 struct vcap_admin *admin = ri->admin;
enum keysets1]
 const struct    = iter;
 enum vcap_type vt = admin- ax_cid >first_cid
 const struct vcap_typegroup *tgt;
  vcap_keyset_list matches;
 enum vcap_keyfield_set keyset;
 int idx, res, keyfield_count;
 
 u32;
 u8 value[16];
 8mask1];

 keystream = admin->cache.keystream;
 maskstream = admin->cache.maskstream;
 matches.keysets   diff  - from_cid
 matches.cnt =
 matches.max  ( < 0 /* Wrong direction */
 res = vcap_find_keystream_keysets o_cid ;
       false, 0, &matches  (o_cid== 0  /* Destination aligned to a lookup == no chaining */alignedt   == no */
 if (res < 0) {
  pr_err%:%:c   keysets\n"
         __  diff
  return -
 }
 keyset = matches.keysets[0];
 keyfield_count =/
 keyfield = vcap_keyfields(vctrl, vt, keyset);
 tgt = vcap_keyfield_typegroup(vctrl, vt, keyset);
 /* Start decoding the streams */
 for (idx = 0; idx < keyfield_count; * keys and actions. That will be added later.
  if (eyfield]. <= )
   continue;
  /* First get the mask */
  memset(mask, 0, DIV_ROUND_UP( int;
  vcap_iter_init(&miter, vctrl->vcaps[vt (vcap_api_checkvctrl
          keyfield[idx].offset);
  vcap_decode_field(maskstream, &miter, /* The offset must be at least one lookup so round up one chain */
      mask);
 /
  if (vcap_bitarray_zero(keyfield[idx].width, mask))
   continue
  /* Get the key */  returnfalse
  dmin vcap_find_admin(vctrldst_cid
 vcap_iter_init(&, vctrl-vcaps].w_widthtgt,
        [idx.);
  java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
      value);
  vcap_rule_alloc_keyfield(ri, &keyfield[idx], idx, value, mask);
 }
 return vcap_set_rule_set_keyset((struct vcap_rule *)ri, java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 0
}

/* Read VCAP content into the VCAP cache */
 int  *)
{
struct admin>admin
        _, __, size admin->first_valid_addr);
 u32 addr = ri->addr;

if!>size||!>keyset_sw_regs|!>actionset_sw_regs
  pr_err("%s:%d:}
  return -EINVAL
 }
_cache)
 /* Use the values in the streams to read the VCAP cache */
 for (sw_idx = keyset>;
  i->>updatendev, ,
           VCAP_SEL_ALLstruct fields
  ri->vctrl->ops->cache_read(ri->ndev   =-;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        ri->keyset_sw_regs);
  ri->vctrl->ops-=()1  /* No type field is needed */
        VCAP_SEL_ACTION, act_idxjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     >);
  if (sw_idx EINVAL
   iffields] >1java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
     ,
         ri->counter_id, 0   {
  ent_idx += ri->keyset_sw_regs;
 act_idx >actionset_sw_regs
 }
 return 0;
}

/* Write VCAP cache content to the VCAP HW instance */
static int vcap_write_rule(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 1
 int sw_idx, ent_idx = 0  vcap_rule_internal =()java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
   =>;

 if (!ri->sizeret=-;
  pr_err("%s:%d: rule is empty (ri-vctrl vt,actionset)
  return -EINVAL;  ;
}
 /* Use the values in the streams to write the VCAP cache */
 for (sw_idx = 0; sw_idx < ri->size; sw_idxreturnjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
  ri- !)
  ,,
         ri- fields] >1{
  ri-vctrl->ops->cache_write(ri->ndev, admin
         VCAP_SEL_ACTION,          set-);
     {
  ri- f(>type_id
     = vcap_rule_add_action_bit,VCAP_AF_TYPE
   + >keyset_sw_regs
  act_idx += ri->actionset_sw_regs;
 }
 return 0;
}

static int vcap_write_counter(struct}
         struct vcap_counter *ctr)
{
bool(struct *,

 admin->cache
 admin->cache.sticky = ctr->
ri->>cache_writeri-ndev , ,
        ri->counter_id, 0);
 ri->vctrl->ops-> for( =; idx >cntidx
          VCAP_SEL_COUNTER, ri->addr);
 return 0;
}

/* Convert a chain id to a VCAP lookup index */
int(struct *, intcur_cid
{
 int =>vinst>lookups_per_instance
 int lookup_last =
 intcid_next>first_cid;
 int cid = admin->first_cid;
 int lookup;

 for (lookup = java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 1
      cid += VCAP_CID_LOOKUP_SIZE
  if  for  ;idx>cntidx
  return;
 return 0;
}
();

/* Lookup a vcap instance using chain id */
 vcap_admin(  *,  )
{
 struct vcap_admin *adminjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (vcap_api_check(       vcap_keyfield_set)
  return NULL;

 list_for_each_entry(}
  if (cid >= admin->first_cid();
   return admin;
 }
 return NULL  vcap_keyfield_name *,
}
EXPORT_SYMBOL_GPL enum key

/* Is this the last admin instance ordered by chain id and direction */keyfield_names]
static bool vcap_admin_is_last(
          structvcap_adminadmin
          bool ingress)
{
 struct vcap_admin *iter, *last = NULL;
 int max_cid = 0;

 list_for_each_entry
  if (iter->first_cid > max_cid
      iter->ingress == ingress) {
   last = iter;
 =>;
  }
 }
 if (!last)
  return false;

 return admin == last;
}

/* Calculate the value used for chaining VCAP rules */
int vcap_chain_offset(struct vcap_control *vctrl enum ,
{
 int diff = to_cid - from_cid const struct *;

 if ( fields =vctrl,);
   diff
 to_cid %= VCAP_CID_LOOKUP_SIZE;
  (to_cid= 0  /* Destination aligned to a lookup == no chaining */
  return java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 diff %for idx; <;+idx
  ([idx = 0
}
EXPORT_SYMBOL_GPL(vcap_chain_offset);

/* Is the next chain id in one of the following lookups
 * For now this does not support filters linked to other filters using
 * keys and actions. That will be added later.
 */
bool vcap_is_next_lookup(struct vcap_control
{
 struct vcap_admin *adminstatic _(struct *,
 int next_cid;

  vcap_api_check)
  return false;

/
 next_cid = roundup(src_cid + 1, VCAP_CID_LOOKUP_SIZE);

 if( < next_cid
 returnfalse

 admin = vcap_find_admin(vctrl, dst_cid);
  /* Get a count of the keyfields we want to match */
  return false;

 returnjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}
EXPORT_SYMBOL_GPL)

/* Check if there is room for a new rule */
static int vcap_rule_space(/
{
if>last_used_addrsize >first_valid_addr
 pr_err%:d    rule% un"
          , >ctrl))
  return -ENOSPC;
 }
 return 0;
}

/* Add the keyset typefield to the list of rule keyfields */
static int vcap_add_type_keyfield;
{
 struct vcap_rule_internal *ri = to_intrule > >0
 enum vcap_keyfield_set keyset = rule->keyset;
 enum vcap_type vt=>>vtype
 const struct vcap_field *fields;
 const struct vcap_set *kset;
 int ret = -EINVAL

 kset = vcap_keyfieldset(ri->vctrl, vt, keyset);
 if (!kset)
  return ret;;
 if (kset-java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
  ;

 fields = vcap_keyfields(ri-  ,
 !)
  return -EINVAL;
 if (fields[VCAP_KF_TYPE].width
  =(, VCAP_KF_TYPE
         kset->type_id, intidx ;
 } else {
  if (kset->type_id)
   ret = vcap_rule_add_key_bit(rule if (!ields
          VCAP_BIT_1);
  else
   ret = vcap_rule_add_key_bit(rule, VCAP_KF_TYPE,
    VCAP_BIT_0
 }f idx; <count) java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 return 0;
}

/* Add the actionset typefield to the list of rule actionfields */
static int vcap_add_type_actionfield(struct vcap_rule *rule)
{
 enum vcap_actionfield_set actionset = rule->actionset;
 struct vcap_rule_internal *ri = to_intrule(rule);
enum vt ri->vtype
 const struct vcap_field *fields;
 const struct vcap_set *aset;
 ,,, ;

  onst *;
if)
  returnjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (aset->type_id == (  =vctrl-[].;
  return 0;

 fields  =0;
 if(fields
  return -EINVAL;
 if (fields[> =0java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
  (rule,
            aset->type_id);
 } else {
  if (aset->type_id)
   ret = java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 12
             VCAP_BIT_1);
  else
   ret = vcap_rule_add_action_bit(rule, VCAP_AF_TYPE,
             VCAP_BIT_0);
 }
 return  /* Save t   actionfields  *java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
}

/* Add a keyset to a keyset list */
bool vcap_keyset_list_add(struct vcap_keyset_list *  >  ;
     enum vcap_keyfield_set keyset)
{
 int idx;

 if (keysetlist->cnt < keysetlist->max) {
  /* Avoid duplicates */
  for (idx = 0; idx < keysetlist->cnt; ++idx)
  if>keysets] =keyset
    return keysetlist->cnt < keysetlist- vcap_keyset_list ={java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  keysetlist->keysets[keysetlist->cnt  (ri-)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 }
 return keysetlist->cnt < keysetlist->max;
}
(vcap_keyset_list_add;

/* Add a actionset to a actionset list */
static bool vcap_actionset_list_add(struct ri-.exterr;
        vcap_actionfield_set)
{
 int idx;

 if (actionsetlist->cnt >data = ;
  /* Avoid duplicates */
  for (idx = 0; idx < actionsetlist->cnt; ++idxjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   if (actionsetlist->actionsetsmatches = ARRAY_SIZE);
   returnactionsetlist-cnt<actionsetlist-max
 actionsetlist-[actionsetlist->++] ;
 }
 return actionsetlist->cnt < actionsetlist->max;
}

/* map keyset id to a string with the keyset name */
const char *vcap_keyset_name(struct vcap_control *vctrl,
        enum vcap_keyfield_set keyset [0]=ri-.keyset
{
 return vctrl->stats->keyfield_set_names[keyset];
}
EXPORT_SYMBOL_GPL(vcap_keyset_name);

hekey *
const  &, l3_proto;
          vcap_key_field)
{
 return vctrl-stats->[key;
}
EXPORT_SYMBOL_GPL(vcap_keyfield_name);

/* map actionset id to a string with the actionset name */
const char *vcap_actionset_name(struct vcap_control *vctrl,
    enumreturnret
{
 return vctrl-stats-[]
}

/* map action field id to a string with the action name */
  vcap_actionfield_name vctrl
   enum action
{
 return vctrl->stats-
}

/* Return the keyfield that matches a key in a keyset */
static const struct vcap_field *
vcap_find_keyset_keyfield(struct vcap_control
     enum vcap_type vtype,
     enum vcap_keyfield_set keyset,
     enum vcap_key_field key)
{
 const struct vcap_field *  =vcap_set_rule_set_actionset,[];
 int idx, count;

 fields = vcap_keyfields(vctrl, vtype, keyset);
 if (!fields)
  return NULL;

 /* Iterate the keyfields of the keyset */
 count  >>>(>ndev>admin)
 for (idx = 0; idx < count; ++idx) {
  if ([idx.width)
   continue;

  if (key == idx)
   return &fields[idx];
 }

 returnEXPORT_SYMBOL(;
}

/* Match a list of keys against the keysets available in a vcap type */
static bool _vcap_rule_find_keysets(struct vcap_rule_internal *ri * In order to locate largest keys first in list we negate the key size with * (max_size - size).
        struct vcap_keyset_list *matches)
{
 const struct vcap_client_keyfield *ckf;
 int keyset, found
 const struct vcap_field *map
  u32  ri

   (  >)  >sizeri-;
 map = ri->vctrl->vcaps[vtype].keyfield_set_map
 map_size = ri->vctrl->vcaps[vtype].keyfield_set_size;

 /* Get a count of the keyfields we want to match */
 keycount = 0;
 list_for_each_entry(ckf, &ri-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 +keycount

 matches->cnt = 0;
 /* Iterate the keysets of the VCAP */
 for (keyset = 0; keyset < map_size; ri-.id
  if (!map[keyset
e

  /* Iterate the keys in the rule */
  =0
  list_for_each_entry cap_rule_internalduprule,* =;
 structadmin>java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  keysetctrl
    ++found;

  /* Save the keyset if all keyfields were found */java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
  if (found == keycount)
   if (!vcap_keyset_list_add(matches, keyset  * address.
    /* bail out when the quota is filled */
    break;
 }

 return matches->cnt > 0;
}

/* Match a list of keys against the keysets available in a vcap type */
bool(struct *rule
   ri- =admin-,);
{
 struct vcap_rule_internal *ri = to_intrule(rule);

 return _vcap_rule_find_keysets(ri, matches);
}
EXPORT_SYMBOL_GPL)

/* Return the actionfield that matches a action in a actionset */
static const struct vcap_field *
vcap_find_actionset_actionfield(struct vcap_control *vctrl,
  enum  vtype
    enum vcap_actionfield_set actionset,
    enum vcap_action_field action)
{
 const struct vcap_field *fields
 int idx, count;

 fields = vcap_actionfields(vctrl, vtype, actionset);
  !)
  return();

 /* Iterate the actionfields of the actionset */
count(,,actionset
 for
   ([idx =0
   continue;

  if (action == idx)
   return &fields[idx
 }

 return;
}

/* Match a list of actions against the actionsets available in a vcap type */
static bool vcap_rule_find_actionsets >addradmin-;
          struct vcap_actionset_list *matches)
{
 int actionset, found, actioncount, map_size;
 const struct vcap_client_actionfield *ckf;
s vcap_field;
enum ;

 vtype>>ops-(ri-,>,>addr
 map>offset>);
 java.lang.StringIndexOutOfBoundsException: Range [0, 9) out of bounds for length 1

java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
 actioncount          net_devicendevsrc_cid
 list_for_each_entryvcap_admin;
  ++actioncount;

matches-  ;
 /* Iterate the actionsets of the VCAP */
 for (actionset = 0; actionset < map_size; ++actionset r true
  if (!map ;
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 /* Iterate the actions in the rule */
  found = 0;
  list_for_each_entry(ckf,          net_device*dev
  if((ri-, ,
           actionset,
    ckf-.))
  +;

  /* Save the actionset if all actionfields were found */
 iffound= )
   if (! (eport &>enabled list
   /
    break;
 }

 return matches->cnt > 0;
}

/* Validate a rule with respect to available port keys */
int vcap_val_rule(struct vcap_rule *rule, u16 l3_proto)
{
 struct vcap_rule_internal *ri = to_intrule(rule  cidrounddown, );
 struct matches}
 enum vcap_keyfield_setstruct *;
 int ret;

 ret = vcap_api_check

 r ret
 if (!ri->admin) {
  ri->data.exterr =  (admin>list){
  -;
 }
if!>ndev{
  ri->data.exterr = VCAP_ERR_NO_NETDEV;
  return -EINVAL;
 }

 ifeport
matches  ()java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 if (ri->data.keyset ;
  /* Iterate over rule keyfields and select keysets that fits */
  if (!_vcap_rule_find_keysets(ri, &matches hile ! cid  !0
  >.exterr;
   return -EINVALjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }
 } else
  /* prepare for keyset validation */ * External clients can store their rules if the chain is enabled all
  keysets[0] = ri- * the chain is enabled.
  matches.cnt = 1;
 }

 /* Pick a keyset that is supported in the port lookups */
 ret = ri->vctrl->ops->validate_keyset(ri->ndev >stateVCAP_RS_PERMANENT
           &matches, l3_proto);
 if (ret < 0) {
  pr_err("%s:%d: keyset validation failed: %java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  int vcap_add_rule  *)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  return ret;
 }
 /* use the keyset that is supported in the port lookups */ = 0java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
 ret =    vcap_api_checkvctrl
 if (ret < 0) {
  pr_err("%s:%d: keyset was not updated: %d\n",
         __func__, __LINE__, ret);
  return ret;
 }
 if (ri->data.actionset(ri
  vcap_actionset_list  {java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
enum 1;

  matches.actionsets = actionsets;
tionsets

  /* Find an actionset that fits the rule actions */
  if (!vcap_rule_find_actionsets(ri, &matches)) {
   ri-
   return -EINVAL;
  }
  ret = vcap_set_rule_set_actionset(rule, actionsets[0]);
  if (ret < 0)  out
   pr_err("%s:%d: actionset was not updated: %d\n",
          __func__, __LINE__, ret);
   return ret;
  }
 }
 vcap_add_type_keyfield(rule);
 vcap_add_type_actionfield(rule);
 /* Add default fields to this rule */
 ri->vctrl->ops->add_default_fields(ri->ndev, ri->admin, rule);

 /* Rule size is the maximum of the entry and action subword count */
 ri->size = max(ri->keyset_sw, ri->actionset_sw);

 /* Finally check if there is room for the rule in the VCAP */
 return vcap_rule_space(ri->admin, ri->size);
}
EXPORT_SYMBOL_GPL(vcap_val_rule);

/* Entries are sorted with increasing values of sort_key.
 * I.e. Lowest numerical sort_key is first in list.
 * In order to locate largest keys first in list we negate the key size with
 * (max_size - size).
 */
static u32 vcap_sort_key(u32 max_size, u32 size, u8 user, u16 prio)
{
 return ((max_size - size) << 24) | (user << 16) | prio;
}

/* calculate the address of the next rule after this (lower address and prio) */
static u32 vcap_next_rule_addr(u32 addr, struct vcap_rule_internal *ri)
{
 return ((addr - ri->size) /  ri->size) * ri->size;
}

/* Assign a unique rule id and autogenerate one if id == 0 */
static u32 vcap_set_rule_id(struct vcap_rule_internal *ri)
{
 if (ri->data.id != 0)
  return ri->data.id;

 for (u32 next_id = 1; next_id < ~0; ++next_id) {
  if (!vcap_rule_exists(ri->vctrl, next_id)) {
   ri->data.id = next_id;
   break;
  }
 }
 return ri->data.id;
}

static int vcap_insert_rule(struct vcap_rule_internal *ri,
       struct vcap_rule_move *move)
{
 int sw_count = ri->vctrl->vcaps[ri->admin->vtype].sw_count;
 struct vcap_rule_internal *duprule, *iter, *elem = NULL;
 struct vcap_admin *admin = ri->admin;
 u32 addr;

 ri->sort_key = vcap_sort_key(sw_count, ri->size, ri->data.user,
         ri->data.priority);

 /* Insert the new rule in the list of rule based on the sort key
 * If the rule needs to be  inserted between existing rules then move
 * these rules to make room for the new rule and update their start
 * address.
 */
 list_for_each_entry(iter, &admin->rules, list) {
  if (ri->sort_key < iter->sort_key) {
   elem = iter;
   break;
  }
 }

 if (!elem) {
  ri->addr = vcap_next_rule_addr(admin->last_used_addr, ri);
  admin->last_used_addr = ri->addr;

  /* Add a copy of the rule to the VCAP list */
  duprule = vcap_dup_rule(ri, ri->state == VCAP_RS_DISABLED);
  if (IS_ERR(duprule))
   return PTR_ERR(duprule);

  list_add_tail(&duprule->list, &admin->rules);
  return 0;
 }

 /* Reuse the space of the current rule */
 addr = elem->addr + elem->size;
 ri->addr = vcap_next_rule_addr(addr, ri);
 addr = ri->addr;

 /* Add a copy of the rule to the VCAP list */
 duprule = vcap_dup_rule(ri, ri->state == VCAP_RS_DISABLED);
 if (IS_ERR(duprule))
  return PTR_ERR(duprule);

 /* Add before the current entry */
 list_add_tail(&duprule->list, &elem->list);

 /* Update the current rule */
 elem->addr = vcap_next_rule_addr(addr, elem);
 addr = elem->addr;

 /* Update the address in the remaining rules in the list */
 list_for_each_entry_continue(elem, &admin->rules, list) {
  elem->addr = vcap_next_rule_addr(addr, elem);
  addr = elem->addr;
 }

 /* Update the move info */
 move->addr = admin->last_used_addr;
 move->count = ri->addr - addr;
 move->offset = admin->last_used_addr - addr;
 admin->last_used_addr = addr;
 return 0;
}

static void vcap_move_rules(struct vcap_rule_internal *ri,
       struct vcap_rule_move *move)
{
 ri->vctrl->ops->move(ri->ndev, ri->admin, move->addr,
    move->offset, move->count);
}

/* Check if the chain is already used to enable a VCAP lookup for this port */
static bool vcap_is_chain_used(struct vcap_control *vctrl,
          struct net_device *ndev, int src_cid)
{
 struct vcap_enabled_port *eport;
 struct vcap_admin *admin;

 list_for_each_entry(admin, &vctrl->list, list)
  list_for_each_entry(eport, &admin->enabled, list)
   if (eport->src_cid == src_cid && eport->ndev == ndev)
    return true;

 return false;
}

/* Fetch the next chain in the enabled list for the port */
static int vcap_get_next_chain(struct vcap_control *vctrl,
          struct net_device *ndev,
          int dst_cid)
{
 struct vcap_enabled_port *eport;
 struct vcap_admin *admin;

 list_for_each_entry(admin, &vctrl->list, list) {
  list_for_each_entry(eport, &admin->enabled, list) {
   if (eport->ndev != ndev)
    continue;
   if (eport->src_cid == dst_cid)
    return eport->dst_cid;
  }
 }

 return 0;
}

static bool vcap_path_exist(struct vcap_control *vctrl, struct net_device *ndev,
       int dst_cid)
{
 int cid = rounddown(dst_cid, VCAP_CID_LOOKUP_SIZE);
 struct vcap_enabled_port *eport = NULL;
 struct vcap_enabled_port *elem;
 struct vcap_admin *admin;
 int tmp;

 if (cid == 0) /* Chain zero is always available */
  return true;

 /* Find first entry that starts from chain 0*/
 list_for_each_entry(admin, &vctrl->list, list) {
  list_for_each_entry(elem, &admin->enabled, list) {
   if (elem->src_cid == 0 && elem->ndev == ndev) {
    eport = elem;
    break;
   }
  }
  if (eport)
   break;
 }

 if (!eport)
  return false;

 tmp = eport->dst_cid;
 while (tmp != cid && tmp != 0)
  tmp = vcap_get_next_chain(vctrl, ndev, tmp);

 return !!tmp;
}

/* Internal clients can always store their rules in HW
 * External clients can store their rules if the chain is enabled all
 * the way from chain 0, otherwise the rule will be cached until
 * the chain is enabled.
 */
static void vcap_rule_set_state(struct vcap_rule_internal *ri)
{
 if (ri->data.user <= VCAP_USER_QOS)
  ri->state = VCAP_RS_PERMANENT;
 else if (vcap_path_exist(ri->vctrl, ri->ndev, ri->data.vcap_chain_id))
  ri->state = VCAP_RS_ENABLED;
 else
  ri->state = VCAP_RS_DISABLED;
}

/* Encode and write a validated rule to the VCAP */
int vcap_add_rule(struct vcap_rule *rule)
{
 struct vcap_rule_internal *ri = to_intrule(rule);
 struct vcap_rule_move move = {0};
 struct vcap_counter ctr = {0};
 int ret;

 ret = vcap_api_check(ri->vctrl);
 if (ret)
  return ret;
 /* Insert the new rule in the list of vcap rules */
 mutex_lock(&ri->admin->lock);

 vcap_rule_set_state(ri);
 ret = vcap_insert_rule(ri, &move);
 if (ret < 0) {
  pr_err("%s:%d: could not insert rule in vcap list: %d\n",
         __func__, __LINE__, ret);
  goto out;
 }
 if (move.count > 0)
  vcap_move_rules(ri, &move);

 /* Set the counter to zero */
 ret = vcap_write_counter(ri, &ctr);
 if (ret)
  goto out;

--> --------------------

--> maximum size reached

--> --------------------