Quelle  vcap_api.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0+
/* Microchip VCAP API
 *
 * Copyright (c) 2022 Microchip Technology Inc. and its subsidiaries.
 */

 

# ".h"

static int keyfield_size_table[] = {
 [VCAP_FIELD_BIT]  = sizeof(struct vcap_u1_key),
 [VCAP_FIELD_U32]  = sizeof(struct vcap_u32_key),
 [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_key),
};

static int actionfield_size_table[] = {
 [VCAP_FIELD_BIT]  = sizeof(struct vcap_u1_action),
 [VCAP_FIELD_U32]  = sizeof(struct vcap_u32_action),
 [VCAP_FIELD_U48]  = sizeof(struct vcap_u48_action),
 [VCAP_FIELD_U56]  = sizeof(struct vcap_u56_action),
 [VCAP_FIELD_U64]  = sizeof(struct vcap_u64_action),
 [VCAP_FIELD_U72]  = sizeof(struct vcap_u72_action),
[VCAP_FIELD_U112  (struct),
 [VCAP_FIELD_U128] = sizeof(struct vcap_u128_action),
};

/* Moving a rule in the VCAP address space */
struct vcap_rule_move VCAP_FIELD_U32  = sizeof( vcap_u32_keyjava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 intaddr
 int ; /* change in address */
 int count;java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 2
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

/* Stores the filter cookie and chain id that enabled the port */
struct vcap_enabled_port {
structlist_head list
 struct net_device*;  /* the enabled port */
 unsigned]=sizeof( vcap_u56_action
 intVCAP_FIELD_U64  sizeof( vcap_u64_action
 intVCAP_FIELD_U72 (struct),
};

void(struct *itr sw_width
  VCAP_FIELD_U128=sizeofstruct cap_u128_action
{
 memset(itr, 0, sizeofstructvcap_rule_move {
 itr->offset = offset offset/* change in address */
 itr->w_width;
 >regs_per_sw DIV_ROUND_UP, 3);
 itr-java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
}

static voidstruct vcap_enabled_portjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
{
struct *;  /* the enabled port */
* A table with an all-zero.
 *
int dst_cid
  itr-> += itr->width
  itr->tg++; /* next typegroup */
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
}

void vcap_iter_update(struct vcap_stream_iter *itr)
{
 int sw_idx, sw_bitpos;

 /* Calculate the subword index and bitposition for current bit */
 sw_idx = itr-offset / itr-sw_width
 sw_bitpos = itr- itr-offset=offset
 /* Calculate the register index and bitposition for current bit */sw_widthsw_width
egs_per_sw  (sw_bitpos/3);
 itr->reg_bitpos = sw_bitpos % 32;
}

void vcap_iter_init(struct vcap_stream_iter *itr, int sw_width,
       itr->tg = tg
{
 static
 vcap_iter_skip_tg(itr)  * A typegroup table ends with an   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 itr- +=itr->width
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

void vcap_iter_nextjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
 itr->offset++;
 vcap_iter_skip_tg(itr) w_idx itr- / itr-;
 vcap_iter_update =itr- % itr-;
}

static void vcap_set_bit( *, struct *itr value
{
 u32 mask >reg_idxsw_idxitr-) +( /3)java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
  *  streamreg_idx

 if (value) const vcap_typegrouptg,u32offset
  * | ;
 else(itr
vcap_iter_updateitr
}

static void vcap_encode_bit(u32 *stream, struct
{
 /* When intersected by a type group field, stream the type group bits
 * before continuing with the value bit
 */
 while (itr->tg-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        >offset >tg- &&
        itr->offset < itr->tg->offset + itr->tg->width) {
  int = itr->offset >offset

  vcap_set_bit(stream, itr, (itr->tg->value >> tg_bitpos) &
  itr- p| ;
   else
}
 vcap_set_bit(stream, itr, val);
}

static
         static vcap_encode_bitu32stream vcap_stream_iter, boolval
{
 int idx;

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

  /* Encode one field value bit */
          itr-> >= >tg- &&
  vcap_iter_next);
 }
}

static void vcap_encode_typegroups(u32java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
       const struct vcap_typegroup *tg,
        >offset
{
 struct vcap_stream_iter ;
  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 /* Mask bits must be set to zeros (inverted later when writing to the
 * mask cache register), so that the mask typegroup bits consist of
 * match-1 or match-0, or both
 */
 vcap_iter_set(&iter, sw_width, tg, 0);
 while (iter.tg->width) {
  /* Set position to current typegroup bit */
  iter.offset = iter.tg->offset;
  vcap_iter_update(
  foridx =;idx iter.>widthidx){
   /* Iterate over current typegroup bits. Mask typegroup
 * bits are always set
 */
  ifmask
    vcap_set_bit(stream,  * the
  java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    vcap_set_bit
          .tg- >>) &0);
   iter.offset++;
   vcap_iter_update(&iter vcap_encode_bit,, value/8>bidx x1
  }
  
 }
}

staticbool(int,  *alue
{
int =DIV_ROUND_UP,BITS_PER_BYTE
 u8 =0  = xff
 int = ;
  /* mustset (java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70

 for (idx = 0; idx < bytes; ++idx, rwidth -  *  or match-0 or both
  if (.>width){
   bmask = (1 << rwidth) - 1;
  total += value[idx] & bmask;
 }
 return total == 0;
}

static bool vcap_get_bit(u32 *stream iter = iter>offset;
{
u32 = BITitr-);
 3 * =&[itr-

  !( &mask
}

static void vcap_decode_field(u32 *stream, struct vcap_stream_iter *itr mask
           (stream,
{
 nt;

 /* Loop over the field value bits and get the field bits and
 * set them in the output value byte array
 */
 for (idx}
  u8 bidxjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 1

 /* Decode one field value bit */
  if  =, =0;
 alue< ;
 int;
  if
  (idx 0 idx < bytes+,  - ) java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
 }
}

/* Verify that the type id in the stream matches the type id of the keyset */1< ;
static bool vcap_verify_keystream_keyset(struct vcap_control   total +=value] &bmask
     enum vcap_type,
      u32 *keystream,
      u32
     enum keyset)
{
 const struct vcap_info * u32mask BIT>reg_bitposjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 
 const struct vcap_typegroup *return!!(* & mask;
 const struct vcap_field *fields;
 struct vcap_stream_iter iter;
 const struct vcap_set *info;
 u32 valuejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 u32mask=0;

 if (vcap_keyfield_count(vctrl, vt, keyset) == 0)
  return false        int width, u8*alue

 info = vcap_keyfieldset(
 /* Check that the keyset is valid */
 if (!info)
  return false;

 /* a type_id of value -1 means that there is no type field */
 if info- == ()-)
  return true;

 /* Get a valid typegroup for the specific keyset */
 tgt=vcap_keyfield_typegroup, , keyset
 if (!  /* Decode one field value bit */
  return false;

 fields =vcap_keyfieldsvctrlvt keyset);
 if (! if (vcap_ge(streamitr
  return false

typefld&[VCAP_KF_TYPE
 vcap_iter_init, vcap-sw_width, typefld-);
 vcap_decode_field(mskstream, &iter, typefld->width, (u8 *)&mask);
 /* no type info if there are no mask bits */
 if (vcap_bitarray_zero in stream the id the */
  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,     u32keystream
 (keystream&, typefld-, u8)value

 return  enum keyset
}

/* Verify that the typegroup bits have the correct values */structvcap_field*;
static vcap_verify_typegroups *stream intsw_width,
      const struct vcap_typegroup structvcap_field *fields
      int sw_max *info;
{
 struct vcap_stream_iteriter
 int sw_cnt, idx;

 vcap_iter_set(&iter, u32 = 0
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 while (iter.tg->java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 15
  u32 value 0;
  u32 tg_value = iter.tg->value;

  if (mask)
   tg_value = (1 << iter.tg->width /* Check that the keyset is valid */
  /* Set position to current typegroup bit */
  iteroffset.>;
  vcap_iter_update(&iter);
   idx <.>width+){
 java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
   iftgt
    valuejava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
  iter++
   vcap_iter_update(s(mskstream,>,  *&);
  }
  if (value !i (typefld-( )mask
   java.lang.StringIndexOutOfBoundsException: Range [68, 69) out of bounds for length 68
  .+;/* next typegroup */
  sw_cnt++;
v(keystream, >width *)java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
  if (sw_max}
  java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  ;
}

/* Find the subword width of the key typegroup that matches the stream data */   )
static (struct vcap_control *ctrljava.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
     v(&,sw_width,)
  mask )
{
ap_typegrouptgt
 int sw_idx value;

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
ord match first/
 for (sw_idx = vctrl->vcaps[vt].sw_count */
 ])
  ;

 res=vcap_verify_typegroups, vctrl-vcaps].sw_width
          tgt[sw_idx],  /* Decode one typegroup bit */
  if (res == 0)
   return sw_idx;
 }
  value= 1<< idx
}

/* Verify that the typegroup information, subword count, keyset and type id
 * are in sync and correct, return the list of matching keysets
 */
int  vcap_iter_update&iter;
vcap_find_keystream_keysets(  }
       enum vcap_type vt,
       u32 *keystream,
       u32 *mskstream,
       bool mask, if(value != tg_value)
       struct vcap_keyset_list *kslist)
{
 const struct vcap_set *keyfield_set;
 int sw_count, idx;

 sw_count=vcap_find_keystream_typegroup_sw, vt, keystream,mask
          sw_max);
 if (sw_count < 0)
  return sw_count;

 keyfield_set=vctrl-vcaps].keyfield_set
 for(dx ;idx vctrl-[vt]keyfield_set_size++idx {
  if (keyfield_set[idx break;
   continue;

  if (vcap_verify_keystream_keyset(vctrl}
  return0
}
 }
 if (kslist-/
  return 0;
 return -EINVAL;
}
EXPORT_SYMBOL_GPL(vcap_find_keystream_keysetsstatic vcap_find_keystream_typegroup_swstructvcap_controlvctrl

/* Read key data from a VCAP address and discover if there are any rule keysets  bool mask int sw_max)
 * here
 */
int vcap_addr_keysets(struct vcap_control *vctrl,
        struct net_devicendev
        struct vcap_admin
  intaddr
        struct gest subword match */
{
 enumvcap_type = admin-;
 int keyset_sw_regs, idx;
 u32 = 0, mask ;

 /* Read the cache at the specified address */;
 keyset_sw_regs = DIV_ROUND_UP(vctrl->vcaps[vt].sw_width
 vctrl-ops-updatendevadminVCAP_CMD_READ VCAP_SEL_ALLaddr
          tgtsw_idx mask sw_max
  if( ==0)
 /* Skip uninitialized key/mask entries */
 for (idx = 0; idx   return sw_idx
  key |  -EINVAL;
  mask |= admin-
 }
 if (key ==/* Verify that the typegroup information, subword count, keyset and type id
return -EINVAL;
/* Decode and locate the keysets */
 return vcap_find_keystream_keysets(vctrl, vt, admin->cache.keystream,
        admin-
        kslistvcap_find_keystream_keysetsstruct vcap_control*vctrl
}
EXPORT_SYMBOL_GPLvcap_addr_keysets);

/* Return the list of keyfields for the keyset */
const struct vcap_fieldvcap_keyfieldsstruct vcap_control*ctrl
     enum vcap_type vt,
     enum vcap_keyfield_set keyset)
{
 /* Check that the keyset exists in the vcap keyset list */
 if (keyset >= vctrl->vcaps[vt].keyfield_set_size)
  return NULL;
 returnvctrl-vcapsvt.eyfield_set_mapkeyset];
}

/* Return the keyset information for the keyset */
const struct vcap_set *vcap_keyfieldset(struct vcap_control *vctrl,
     enum vcap_type vt,
     enum       structvcap_keyset_list*)
{
 const struct vcap_setkset

 /* Check that the keyset exists in the vcap keyset list */
 if( >= vctrl-vcaps].keyfield_set_size
  return NULL
 ksetif (sw_count 0)
 if (kset->sw_per_item sw_count
  return
 return  keyfield_set = vctrl-vcaps].keyfield_set
}
EXPORT_SYMBOL_GPL(vcap_keyfieldset);

/* Return the typegroup table for the matching keyset (using subword size) */
const keyfield_setidxsw_per_item=sw_count
vcap_keyfield_typegroup(struct  continue;
  enum vt,enum vcap_keyfield_setkeyset
{
 onst vcap_set * = vcap_keyfieldsetvctrlvt keyset);

 /* Check that the keyset is valid */
 if!set
  return NULL }
 return  if (kslist->cnt)
}

/* Return the number of keyfields in the keyset */
int vcap_keyfield_count(struct vcap_control *vctrl,
   enumvcap_type vt enumvcap_keyfield_set)
{
 /* Check that the keyset exists in the vcap keyset list */
 }
 java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
 return _(struct vcap_control*,
}

static void vcap_encode_keyfield(struct vcap_rule_internal *ri,
ient_keyfield kf,
     const struct       addr
     structvcap_typegroup *)
{
 int sw_width = ri->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct vcap_cache_data *cache = &ri->admin- keyset_sw_regs idx
  vcap_stream_iteriter;
 const

 /* Encode the fields for the key and the mask in their respective
 * streams, respecting the subword width.
 */
 switch (kf->ops-update(, admin VCAP_CMD_READ, VCAP_SEL_ALLaddr);
 case VCAP_FIELD_BIT:
  value = &kf->data.u1. vctrl->ops->cache_read(ndev, VCAP_SEL_ENTRY, ,
  mask = &kf->data.u1.mask;
    keyset_sw_regs
 case VCAP_FIELD_U32 /* Skip uninitialized key/mask entries */
  value = (const u8 *)&kf->data.u32.value; oridx0 idx<keyset_sw_regs; +idx) {
  mask = (const u8 *)&kf->data.u32  |= ~admin-.keystream[idx;
b;
 case VCAP_FIELD_U48:
  value = kf->data  (key=0& mask==0)
  mask return EINVAL
  break;
 case VCAP_FIELD_U56:return(vctrl, vt, admin->cache,
  value =kf-data.u56value
  mask      slist
  break;
 case VCAP_FIELD_U64:
  alue kf->datau64;
  mask
  break;
 case VCAP_FIELD_U72
  value = kf->data.u72.value;
  mask = kf->data.u72.mask;
  breakjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
 case VCAP_FIELD_U112  enumvcap_keyfield_set)
  value = kf- /* Check that the keyset exists in the vcap keyset list */
  mask =kf->ata.112;
  break;
 case  return vctrl->vcaps].keyfield_set_mapkeyset;
  value = kf->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  mask = kf->data.u128.mask;
  break;
 }
 vcap_iter_init  enumvcap_typevt
 vcap_encode_field(cache- enumvcap_keyfield_set keysetjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 vcap_iter_inititer sw_widthtgtrf-offset);
 vcap_encode_field(cache->maskstream, &iter, rf->width, mask
}

static void vcap_encode_keyfield_typegroups(struct vcap_control *vctrl,
         struct vcap_rule_internal *ri,
        structvcap_typegrouptgt
{
 int sw_width    NULL
  vcap_cache_datacache&ri->admin-cache

java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
  * respecting the subword width.
  */
 vcap_encode_typegroups(cache->keystream return kset;
 EXPORT_SYMBOL_GPL(vcap_keyfieldset);
}

/* Copy data from src to dst but reverse the data in chunks of 32bits.
 * For example if src is 00:11:22:33:44:55 where 55 is LSB the dst will
 * have the value 22:33:44:55:00:11.
 */
static void vcap_copy_to_w32beu8*st const *src intsize)
{
 for(int = 0; idx <size++idx) {
  int first_byte_index = 0;
  int nidx;

  first_byte_index = size - ((({
  if (first_byte_index <  struct *kset= vcap_keyfieldsetvctrl , keyset
  /* Check that the keyset is valid */
  nidx = idx + first_byte_index - (idx & ~0x3);
 dst] = srcidxjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
}

static void
vcap_copy_from_client_keyfield(struct vcap_rule *rule,
         structvcap_client_keyfielddst
          structvcap_client_keyfield *src
{
 struct
 const struct vcap_client_keyfield_data *sdata
 struct vcap_client_keyfield_data *ddata;
 int size;

 dst->ctrl.type =   return0
 dst->ctrl.key = src->ctrl.key;
 INIT_LIST_HEAD(&dst->ctrl.list);
 sdata returnvctrl-vcaps[vt]keyfield_set_map_sizekeyset];
 ddata = &dst->data;

 if(!i-admin-) {
  memcpy(ddata, sdata, sizeof(dst->data));
 java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 9
 }

 size = keyfield_size_table[dst->ctrl.type] / 2;

 switch (dst->ctrl.type) {
 case VCAP_FIELD_BIT:
 case VCAP_FIELD_U32:
  (ddata,sdata (dst-data)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
  break intsw_width =ri->vcaps>admin-vtype].sw_width
 case VCAP_FIELD_U48
  vcap_copy_to_w32be>u48., src-data.value size;
  vcap_copy_to_w32be(ddata-  *value*;
  break;
 case VCAP_FIELD_U56:
  vcap_copy_to_w32be(ddata->.value>u56,size
  vcap_copy_to_w32be(ddata->u56.mask,  sdata->u56.mask, size);
  break;
 case VCAP_FIELD_U64:
  vcap_copy_to_w32be(ddata->u64.value, 
  vcap_copy_to_w32be switch (kf-ctrl.type {
  break;
 caseVCAP_FIELD_U72
  vcap_copy_to_w32be(ddata-> mask = kf-data.u1mask;
  vcap_copy_to_w32be(ddata->u72break;
  break;
 case  =const *&>data.mask
  vcap_copy_to_w32be( case :
   value>datau48.;
  breakmask kf-.u48mask;
 case  break;
  vcap_copy_to_w32be(ddata->u128.value, sdata->u128.value, sizec VCAP_FIELD_U56
  vcap_copy_to_w32bevalue= kf->.u56value
  break;
 }
}

static void
vcap_copy_from_client_actionfield(struct vcap_rule *rule,
  VCAP_FIELD_U64
  v = kf-data.u64value;
{
 truct *ri=to_intrule);
 const struct vcap_client_actionfield_data  break
 struct vcap_client_actionfield_data = kf-data.u72.value
 int size

 dst->ctrl.type = src->ctrl.type;
 dst->ctrl.case:
  alue kf->datau112.value;
 sdata mask kf->data.u112mask
 ddata = &dst->data;

 if (!ri->admin->w32be) {
  memcpy, sdata sizeof>data));
  returnjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 }

 size actionfield_size_tabledst-.type];

 switch (dst->ctrl.type) {
 case VCAP_FIELD_BIT:
 caseVCAP_FIELD_U32:
  memcpy(ddata, sdata(cache-maskstream &iterrf-width);
  break;
 case VCAP_FIELD_U48:
  vcap_copy_to_w32be(ddata->u48 voidvcap_encode_keyfield_typegroups vcap_control*ctrl
  break;
 case VCAP_FIELD_U56
  vcap_copy_to_w32be(ddata->u56.value, sdata->u56.       const  vcap_typegrouptgt
  break;
 case VCAP_FIELD_U64:
  vcap_copy_to_w32be(ddata->u64structvcap_cache_datacache &ri->cache;
  break;
 case VCAP_FIELD_U72:
  vcap_copy_to_w32be(ddata->u72.value, java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 33
  breakeak;
 case VCAP_FIELD_U112:
  vcap_copy_to_w32be(ddata->u112.value, sdata->u112.value, size);
  breakvcap_encode_typegroupscache-keystream sw_width, false;
 case VCAP_FIELD_U128:
  vcap_copy_to_w32be(ddata->u128.value, sdata->u128.value, cap_encode_typegroupscache-maskstream sw_width, true;
  break;
 }
}

static   fromsrcto butreverse thedata in of 32bits
{
 const struct vcap_client_keyfield *ckf;
 onst vcap_typegroup*;
 struct vcap_client_keyfield tempkf;
 const struct *
 int keyset_size;

 /* Get a valid set of fields for the specific keyset */ idx  0 idx <size; +idx{
  = vcap_keyfieldsri-vctrl ri->admin-, ri-datakeyset);
 if  int nidx
  pr_err( first_byte_index = size-((idx>2 +1 < );
         __func__, __LINE__, ri- if( < 0)
   -EINVAL
 }
 nidx =idx first_byte_index- (idx ~x3;
 tg_table [nidx = src];
      }
 if (!tg_table) {
  pr_err("%}
         __func__, __java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 return-EINVAL
 }
 /* Get a valid size for the specific keyset */
 keyset_size          structvcap_client_keyfieldsrc
       ri->data.keyset  vcap_rule_internal*ri=to_intrule);
 if keyset_size=0 {
  pr_err("%s:%d: zero field count for this keyset: %d\n",
         __func__structvcap_client_keyfield_dataddata
  return-;
 }
 /* Iterate over the keyfields (key, mask) in the rule
 * and encode these bits
 */
 if (list_empty(&ri->data.keyfields)) {
  pr_err("%s:%d dst->ctrl.key= >ctrl.ey;
L;
 }
list_for_each_entry, &>datakeyfields, ctrllist) {
  /* Check that the client entry exists in the keyset */
  if (ckf->ctrl.key >= keyset_size) {
   pr_err("%s:%d: key %d is not in vcap\n",
          __func__, __LINE__, ckf->ctrl.key);
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  vcap_copy_from_client_keyfield(& memcpy, sdata sizeofdst->data;
  vcap_encode_keyfield(ri, &tempkf, &kf_table[ckf->ctrl.key],
         tg_tablejava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 }
 /* Add typegroup bits to the key/mask bitstreams */
 cap_encode_keyfield_typegroups>vctrl ri tg_table
 return 0;
}

/* Return the list of actionfields for the actionset */
const case VCAP_FIELD_U32:
vcap_actionfields vcap_control*ctrl
    break;
{
 /* Check that the actionset exists in the vcap actionset list */
 if( >=vctrl-[vt].actionfield_set_size)
  return cap_copy_to_w32be>u48.value, src->.u48.valuesize;
 return vctrl->vcaps[vt].actionfield_set_map[actionset];
}

const struct vcap_set *
vcap_actionfieldset(structcase VCAP_FIELD_U56:
      enumvcap_typevt enumvcap_actionfield_set)
{
 constbreak

 /* Check that the actionset exists in the vcap actionset list */(ddata-.value sdata->u64, size;
 if (actionset >= vctrl->vcaps  vcap_copy_to_w32be(>u64mask  sdata-.mask size;
  return NULL;
 aset = &vctrl->vcaps[vt].actionfield_set[actionset];
 if (aset->sw_per_item == 0 || aset->sw_per_item > vctrl->vcapscase VCAP_FIELD_U72
  return NULL
 return aset;
}

/* Return the typegroup table for the matching actionset (using subword size) */ CAP_FIELD_U112
conststructvcap_typegroup *
vcap_actionfield_typegroup vcap_control*vctrl
      vcap_type, enumjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 22
{
 ;

 /* Check that the actionset is valid */
 ifaset
 vcap_copy_from_client_actionfield(truct  *rule,
     structvcap_client_actionfield *st
}

/* Return the number of actionfields in the actionset */
int vcap_actionfield_count(struct
      vcap_type,
 const structvcap_client_actionfield_data *;
{
 in thevcap list*
 if (actionset >= vctrl- size
  return 0;
returnvctrl-[vt]actionfield_set_map_sizeactionset];
}

static vcap_encode_actionfield vcap_rule_internalri,
        const struct  sdata  src-;
         structvcap_field *f
        const struct vcap_typegroup *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 int }

ct vcap_cache_data * = &ri-admin->cache
 struct vcap_stream_iter  (dst-ctrl.type{
 const u8 *valuec VCAP_FIELD_U32

  break
 switch:
  vcap_copy_to_w32be(>u48valuesdata-.valuesize;
   break
 break;
 case:
 value ( u8)af-.u32value
  break
 case VCAP_FIELD_U48:
   b;
  break;caseV:
 case VCAP_FIELD_U56
  valuebreak;
  break;
 case VCAP_FIELD_U64
  value = af-> VCAP_FIELD_U128
  break;
 caseVCAP_FIELD_U72
   = af-.u72value
  break;
 case }
  value = af->data.u112.value;
  break;
 case VCAP_FIELD_U128:
  value
  breakjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
 }
 cap_iter_inititeract_widthtgt, rf-);
 vcap_encode_field(cache-struct tempkf;
java.lang.StringIndexOutOfBoundsException: Range [7, 1) out of bounds for length 1

static void vcap_encode_actionfield_typegroups(struct vcap_rule_internal kf_table =vcap_keyfields(ri-, ri->>vtype >datakeyset
    conststructvcap_typegroup*)
{
 int sw_width = ri->vctrl->vcaps[ri->admin-         __func__ __LINE__ ri->data.keyset;
 struct vcap_cache_data *cache = &ri->admin->cache;

 /* Encode the typegroup bits for the actionstream respecting the subword
 * width.
 */
 vcap_encode_typegroups
}

 tg_table = vcap_keyfield_typegroup(ri-vctrl ri->admin-vtype,
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
conststruct vcap_client_actionfieldcaf
 const struct vcap_typegroup*g_table
 struct vcap_client_actionfieldtempaf
 const struct vcap_field *af_tablejava.lang.StringIndexOutOfBoundsException: Range [34, 35) out of bounds for length 2
  key =vcap_keyfield_count>vctrl >admin-vtype,

/
 af_table (ri->, ri->admin-,
         ri->data.actionset);
 if (!af_table) {
 pr_err%s:d:no availablefor actionset %\"
          pr_err(%s:d  field   :%\"
 return -;
 }
 /* Get a valid typegroup for the specific actionset */;
 tg_table = vcap_actionfield_typegroupri-vctrlri-admin->vtype
           ri->data.actionset);
 if (!tg_table) {
  pr_errif (list_empty(&ri-datakeyfields)) java.lang.StringIndexOutOfBoundsException: Range [39, 40) out of bounds for length 39
        _, _LINE__.actionset;
  return -EINVAL;
 }
 /* Get a valid actionset size for the specific actionset */
 actionset_size=vcap_actionfield_count>vctrl ri-admin-vtype,
      ri->data.actionset)}
  == 0) {
 pr_err%:%:zero  for actionset%\"java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
        _func__ _LINE__ ri-.actionset)
  return-;
 }
/
  * and encode these bits
  */
 if (list_empty(&ri-  vcap_encode_keyfield(ri, &tempkf, &kf_table[ckf->ctrl.key],
  pr_warn("%sroup bits to the key/mask bitstreams
   _}
 list_for_each_entry(caf, &ri->/* Return the list of actionfields for the actionset */
  /* Check that the client action exists in the actionset */
  if (caf-ctrlaction>=actionset_size{
   pr_err("%s:%d: action %d is not in vcap\const struct vcap_field*
          __func__, __LINE__, caf->ctrl.action);
   return -EINVAL;
  }
  vcap_copy_from_client_actionfield&ri->, &tempaf, caf);
  vcap_encode_actionfield(ri, &tempaf,
     &af_table[caf->ctrl.action], tg_table);
 }
 /* Add typegroup bits to the entry bitstreams */enumvcap_type vt enumvcap_actionfield_set actionsetjava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
 vcap_encode_actionfield_typegroups(ri, tg_table); if (actionset > vctrl-vcaps].actionfield_set_size
 return>vcapsvtactionfield_set_mapactionset];
}

static ntvcap_encode_rulestructvcap_rule_internal *ri)
{
 int err;

 err = vcap_actionfieldsetstruct *vctrl
 if()
  return 
 errconststruct vcap_set *;
 if (err)
  return err;
 return 0;
}

intreturnNULL;
{
   (>sw_per_item= | aset->sw_per_item>>vcaps[vt.w_count
  pr_err("%sjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  return -EINVAL
 }
 if (!ctrl->conststructvcap_typegroup*
    ctrl-ops->add_default_fields|!ctrl->ops->cache_erase|
>cache_write ctrl->cache_read|
     !ctrl->ops->init
 !trl->port_info {
  pr_err("%s:%d: client operations are missing\n",
         __func__, __LINE__/
  return -ENOENT;
 }
r 0;
}

void vcap_erase_cache
{
 ri->vctrl- vcap_actionfield_count(struct vcap_controlvctrl
     vcap_type,

/* Update the keyset for the rule */
int vcap_set_rule_set_keyset( /* Check that the actionset exists  vcap  list/
        vcap_keyfield_set)
{
 struct vcap_rule_internalreturn ;
   vcap_setkset
 int sw_width;

 kset =
/java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
 if (!kset)
 return-;
 ri-     const struct *tgt
 sw_widthint act_width ri->vcaps[ri->vtype]act_width;
 ri-
 ri-.keyset =keyset
 return 0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
}
EXPORT_SYMBOL_GPLvcap_set_rule_set_keyset);

/* Update the actionset for the rule */
int(struct vcap_rulerule
    enum  caseVCAP_FIELD_BIT
{
   reak
  struct vcap_setaset
 ntact_width;

 aset = vcap_actionfieldset(java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 21
 /* Check that the actionset is valid */;
 if (!aset)
  return-;
ri- = aset-;
 act_width = ri- VCAP_FIELD_U64:
 ri- = af-.u64value
 ri->data.actionset ;
 return 0;
}
value = = af-.u72value

/* Check if a rule with this id exists */
static oolvcap_rule_exists(structvcap_control*vctrlu32id
{
  value af-.u112value
   ;

 /* Look for the rule id in all vcaps */value af->data.128.valuejava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
list_for_each_entry, &vctrl-, list
  list_for_each_entryri &admin->, list
   if (ri->data
   returntrue
return
}

/* Find a rule with a provided rule id return a locked vcap */ *cache =&>admin-;
 /* Encode the typegroup bits for the actionstream respecting the subword
vcap_get_locked_rule(struct vcap_control *vctrl, u32 id)
{
struct vcap_rule_internal *ri;
struct vcap_admin *admin;

/* Look for the rule id in all vcaps */
 list_for_each_entry{
  mutex_lock&>lockjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
, &>rules)
   if (ri->data.id const struct  *af_table
    return ri;
  mutex_unlock(&admin->lock intactionset_size
 }
 return NULL;
}

/* Find a rule id with a provided cookie */
int (struct *, u64)
{
 struct vcap_rule_internal *ri;
vcap_admin;
 int id = 0;

 /* Look for the rule id in all vcaps */
 list_for_each_entry, vctrl-, list
  mutex_lock return EINVAL
  list_for_each_entry(ri /* Get a valid typegroup for the specific actionset */
   if (ri->datacookie == cookie {
ri->data.;
    break;         ri-dataactionset
  }
  }
 mutex_unlockadmin-lock
  if        _func__ _LINE__ri-data.actionset;
 ;
 }
 return  }
}
EXPORT_SYMBOL_GPL(vcap_lookup_rule_by_cookie);

/* Get number of rules in a vcap instance lookup chain id range */
 actionset_size =vcap_actionfield_count>vctrl, >admin-,
{
 int max_cidroundup + 1 VCAP_CID_LOOKUP_SIZE;
 int min_cid = rounddown(cid, VCAP_CID_LOOKUP_SIZE);
 tructvcap_rule_internal*lem
 int pr_err%:%: zero  for :%\"

 list_for_each_entry(elem, eturn-INVAL
  mutex_lock(&admin->lock/
  if (elem->data.vcap_chain_id >= min_cid &&
      elem->data  *
   +count
  mutex_unlock(&dmin-lock;
 }
 return count;
}
EXPORT_SYMBOL_GPL(vcap_admin_rule_count);

/* Make a copy of the rule, shallow or full */
staticstructvcap_rule_internal *vcap_dup_rulestructvcap_rule_internal*i,
      bool)
{
 struct vcap_client_actionfieldcaf *ewcaf
 struct vcap_client_keyfield *ckf, *newckf;
  vcap_rule_internal*duprule

 /* Allocate the client part */
 duprule = kzalloc(sizeof(*duprule), GFP_KERNEL);
 if  vcap_encode_actionfield(ri, &tempaf     &af_table[caf->ctrl.action], tg_table);
  returnvcap_encode_actionfield_typegroupsri, );
 *duprule = *}
 /* Not inserted in the VCAP */
 INIT_LIST_HEAD(&duprule->list)staticint (structv *ri
 /* No elements in these lists */
 INIT_LIST_HEAD( err = vcap_encode_rule_keyset(ri);
 INIT_LIST_HEAD(&duprule->data.  return err;

 /* A full rule copy includes keys and actions */ if (err)
 if (!full)
  java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0

 list_for_each_entry  return -EINVAL;
  newckf = kmemdup(ckf, sizeof(*newckf), GFP_KERNEL);
  if (!newckf)
   goto err;
  list_add_tail     !ctrl->ops->init || !ctrl->ops->update || !ctrl->ops->move |     !ctrl->ops->port_info) {
 }

 list_for_each_entry(caf, &ri->data.}
  newcaf = kmemdup(caf, }
  if (!newcaf)
   goto err;
  list_add_tail(&newcaf->ctrl.list, &duprule->data{
 }

 return duprule;

err:
 list_for_each_entry_safe(ckfintvcap_set_rule_set_keysetstructvcap_rule *rule
  (&ckf-ctrl);
  kfree(ckf);
 }

 list_for_each_entry_safe(, newcaf &duprule->data, ctrllist) {
  list_del(&caf->const vcap_setkset
  kfree(caf
 }

 kfree(duprule
 return ERR_PTR-NOMEM;
}

static  vcap_apply_widthu8 *, intwidthintbytes)
{
 u8 = ri-vctrl-[ri->admin-].sw_width
 int ri-keyset_sw_regs =DIV_ROUND_UP, 32);

 for 0;
  if (width > 0)
   if ( < 8)
    bmask = (1 << width
   else
    bmask = ~0;
  else
   bmask = 0;
  dst[idx] &= bmask;
  width -= 8;
 }
}

staticvoid(u8 *dst, u8*rc int, int width

 int idx, ridx, wstart act_width
 int tail_bytes = (((size   = vcap_actionfieldsetri->vctrl ri-admin->vtype actionset);

 for (idx = 0, ridx  if (!set
  wstart (dx> 2 < 2java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  nidx = act_width= ri-vctrl-[ri->>vtype].act_width
 if ( >= size
   nidx -ri->dataactionset = actionset
  dst[ return 0
 }

(dstwidthsize);
}

static void vcap_copy_action_bit_field(struct vcap_u1_action *field, 
{
 field->value = (*value)static bool vcap_rule_exi(structvcap_control *vctrl u32)
}

staticstruct vcap_admin*dmin
       int width
{
 memcpy(dstvalue, srcvalue, byteslist_for_each_entry(admin &vctrl-list, list
 cap_apply_widthdstvalue , bytes)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
}

static void vcap_copy_to_client_actionfield  false
         struct vcap_client_actionfield *field/*Findarulewith a provided ruleidreturn a locked vcap/
   u8*alue u16)
{
 int vcap_get_locked_rulestructvcap_control *vctrl, u32id

 ifri-admin-w32be) {
  switch (field->ctrl.type) {
  case VCAP_FIELD_BIT:
   vcap_copy_action_bit_field(&field->data.u1, value);
   break;
  case VCAP_FIELD_U32:
   vcap_copy_limited_actionfield((struct vcap_admin*admin;
            value,
            width, field_size);
   break;
  case VCAP_FIELD_U48:
   vcap_copy_from_w32be(field->datau48.alue value,
          field_size, width);
  break;
  case VCAP_FIELD_U56  mutex_lock&admin-);
   vcap_copy_from_w32befield->data.u56.value value
          field_size width
  break;
  case _unlockadmin-);
   vcap_copy_from_w32be(field- }
          , width;
   break;
  case VCAP_FIELD_U72
   vcap_copy_from_w32be>data.u72value value
          field_size, width);
   break;
  case VCAP_FIELD_U112:
   vcap_copy_from_w32be(field->data.u112.value, value,
          field_size, width);
   break;
  case VCAP_FIELD_U128:
   vcap_copy_from_w32be(field->data.u128.value, value,
          field_size width);
  ;
  }
 } else {
  switch (field->ctrl.type) {
  case =>data;
 vcap_copy_action_bit_field(field-.u1 value);
   break;
  case VCAP_FIELD_U32:
   vcap_copy_limited_actionfield(( *)field-.u32value
            value,
           width);
   break;
  case returnid;
   vcap_copy_limited_actionfield(field-  -;
            value,
           width, field_size;
   break;
  case VCAP_FIELD_U56:
   vcap_copy_limited_actionfield(field-/*Getnumber rulesin   instancel chainid */
          value
            width, field_size);
 break
   (, )java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
 (field-..value
  (&admin-);
            width (elem-.vcap_chain_id=min_cid&
 break
 caseVCAP_FIELD_U72
   vcap_copy_limited_actionfield>data,
            value,
         , field_size;
   break;
  case VCAP_FIELD_U112
   vcap_copy_limited_actionfield(field->
            java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
          , field_size;
   break;
  case VCAP_FIELD_U128:
   vcap_copy_limited_actionfield(field->data.u128.value,
            value,
            width{
   break;
  }
 }
}

void vcap_copy_key_bit_fieldstructvcap_u1_key*ield,
        u8 *value, u8 *mask)
{
 field-
 field->mask=(*ask x1
}

static void vcap_copy_limited_keyfield(u8 *dstvalue, u8 *dstmask,
     return ERR_PTRENOMEM
           int, int bytes)
{
 memcpy(dstvalue, uprule-list
 vcap_apply_width(dstvalue, width/* No elements in these lists */
 memcpyINIT_LIST_HEADduprule-.keyfields;
 (dstmask widthbytes
}

static void vcap_copy_to_client_keyfield(struct vcap_rule_internal *ri,
     vcap_client_keyfieldfield
      u8 *value, u8 *mask, list_for_each_entryckf, ri-data.keyfields ctrl) {
{
 intfield_size=keyfield_size_table[field-.type /;

 if (ri->admin- list_add_tail(newckf-.list, &duprule-keyfields
  switchjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  case VCAP_FIELD_BIT:
   vcap_copy_key_bit_field&field-data, value mask);
   break;
  case VCAP_FIELD_U32:
   vcap_copy_limited_keyfield((u8 *)&field->  (&newcaf->trllist&duprule->data.ctionfields);
         (u8 *)&
         value duprule
         width, field_size);
   break;
  caseVCAP_FIELD_U48
   vcap_copy_from_w32be(field->data.u48.value, value,
          field_size, width);
  vcap_copy_from_w32befield-data.u48.mask  mask,
          field_size, width);
   break;
  case VCAP_FIELD_U56:
   vcap_copy_from_w32be(field->data.u56.value, value,
          field_size width);
   vcap_copy_from_w32be(field->data.u56.mask,  mask,
          field_size, }
   break;
  case VCAP_FIELD_U64list_for_each_entry_safecaf , &duprule-dataactionfieldsctrl) {
  vcap_copy_from_w32be>data.u64value value
          field_sizewidth
   vcap_copy_from_w32be(field->data.u64.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   field_sizewidth
   break;
  case VCAP_FIELD_U72:
  vcap_copy_from_w32be>data.u72.value value
          field_size, width);
 8 bmask
          field_sizewidth
   break;
  caseVCAP_FIELD_U112
  vcap_copy_from_w32befield-datau112.valuev,
 bmask <) - ;
   vcap_copy_from_w32be(field->data.u112.mask,  mask,
          field_size, width)  else
  break
   
  cap_copy_from_w32befield-datau128.value value
          field_size,  dst[idx & bmask
   vcap_copy_from_w32be(field->data}
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   break;
  }
 } else {
  (field-.type){
  case VCAP_FIELD_BIT:
  vcap_copy_key_bit_fieldfield-.u1 value mask
   break;
  case VCAP_FIELD_U32:
 vcap_copy_limited_keyfieldu8)&>data.u32.value
         (u8 *)& wstart idx>2)< ;
        , mask
         width, field_size if(idx>=size
   break;
  case VCAP_FIELD_U48 d[nidx =[ridx]java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
   vcap_copy_limited_keyfield(field->java.lang.StringIndexOutOfBoundsException: Range [0, 41) out of bounds for length 36
         field->data.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      , maskjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
         width, field_size){
   break;
  case VCAP_FIELD_U56field- = (*alue& 0;
   vcap_copy_limited_keyfield(field->data.u56.valuejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
         field->data.u56.mask,
         value, mask,
         width, field_size);
   break;
  caseVCAP_FIELD_U64
   vcap_copy_limited_keyfield(field->data.u64.value,
         field-memcpydstvaluesrcvalue );
         valuemask
       , field_size)
   break;
  case VCAP_FIELD_U72:
   vcap_copy_limited_keyfield(field->data.u72.value,
         field->data.u72.mask,
         value mask
         width, field_size);
   break;
  case VCAP_FIELD_U112
   vcap_copy_limited_keyfield(field->data.u112intfield_size =actionfield_size_tablefield-.type];
         field->data. if (ri->admin-) {
         valuemask
       widthfield_size;
   break;
  case VCAP_FIELD_U128:
   vcap_copy_limited_keyfield(field->data.u128.value, break;
      field->datau128mask
         value vcap_copy_limited_actionfield *)&ield-data.u32value
       width field_size
   break;
  }
 }
}

static    vcap_copy_from_w32be>data.u48.value value,
        const structvcap_fieldkeyfield,
         enum vcap_key_field key,
         u8 *value, u8 *mask)
{
 struct vcap_client_keyfield *field;

 ield=kzalloc(sizeof*), GFP_KERNEL
 if    field_sizewidth
  return  break;
 (&field-ctrllist);
 field->ctrl.key = key;
 field-ctrl = keyfield-;
 vcap_copy_to_client_keyfield(ri         , width);
 list_add_tail(&field->ctrl. caseVCAP_FIELD_U72:
}

/* Read key data from a VCAP address and discover if there is a rule keyset
 * here
 */
static bool
vcap_verify_actionstream_actionset(struct vcap_control *vctrl,
       enum vcap_type  vcap_copy_from_w32be(>data.u112, value
       u32 *actionstream,
       enum java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 9
{
 const struct vcap_typegroup *tgt;
 const struct vcap_field *fields;
 const struct vcap_set;

 if(vcap_actionfield_count, vt actionset == 0
  returnfalse;

 info  vcap_actionfieldset, vt actionset);
 /* Check that the actionset is valid */
 if (!info)
  return false  VCAP_FIELD_U32:

 /* a type_id of value -1 means that there is no type field */
 if (info->type_id =   w, field_size;
  return true;

 case:
 tgt vcap_copy_limited_actionfield>data.4.value,
 if (!tgt        value,
  return falsejava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15

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

 
return true;
}

/* Find the subword width of the action typegroup that matches the stream data
 */
static (structvcap_control vctrl
             ,
         widthfield_sizejava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
{
 const         alue
 intsw_idx ;

   break;
 case:
 for  (field-.u128,
 if![sw_idx
     width,);
  res  break
          tgt[sw_idx], false, sw_max java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 res )
   return sw_idx;
 }
 return -EINVAL;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

/* 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,
             width int )
     u32 * memcpy(dstvaluesrcvalue,bytes
      sw_max
{
  (dstmask, bytes
 int sw_count, idx;
 boolstatic vcap_copy_to_client_keyfield  *ri

 sw_count = vcap_find_actionstream_typegroup_sw  u8value *mask  width
             sw_max);
 if sw_count0
  return sw_count;

actionfield_set>vcaps]a;
 for switch field-ctrl) java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 [].sw_per_item )
   continue ( *&>data,

  res = vcap_verify_actionstream_actionset(vctrl, vt,
    , field_size
  if (res)
   return idx;
 }
return;
}

/* Store action value in an element in a list for the client */
static;
     const(>data,,
     enum vcap_action_field(>..maskmask
     u8
{
struct field

  =kzallocsizeof), )java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 if (!field)
  return;
 INIT_LIST_HEAD(&field->ctrl.list);
 field->ctrl.action = action;
 field->ctrl.         field_size width;
 vcap_copy_to_client_actionfield(ri, field valueactionfield-width
 list_add_tail
}

static int vcap_decode_actionset
{
 struct vcap_control * vcap_copy_from_w32be(field-.,,
 struct vcap_admin *adminbreak;
 const struct vcap_field *actionfield (field-.u112.value, value,
 enum vcap_actionfield_set actionset;
 enum vcap_type vt = admin->vtype;
 const struct vcap_typegroup *tgt;
 struct vcap_stream_iter iter;
int, res ;
u32actstream
 u8 valuebreak;

 actstream = admin-vcap_copy_from_w32be>data.valuevalue
resvcap_find_actionstream_actionset, vt,actstream)java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
  (res ){
  pr_err("%s:%d: could not find valid actionset: %d\n",
         __func__, __LINE__
n EINVAL
 }
 actionset ;
 actfield_countvcap_actionfield_count, , actionset
 actionfield = vcap_actionfields(vctrl, vt, actionset);
 tgt =   (( *&>data.value
 /* Start decoding the stream */
   , mask,
  if (actionfield[idx].width <= 0)
   continue;
  /* Get the action */
Pactionfield.,)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
  vcap_iter_initbreak
  actionfield]offset
  vcap_decode_field(actstream, >data.,
    );
  /* Skip if no bits are set */ ,
  if (vcap_bitarray_zero(actionfield;
   continue;
  (ri,&[idx , value..,
   the id  also  */
    ,)
 return vcap_set_rule_set_actionset  :
}

static int vcap_decode_keyset(struct vcap_rule_internal *ri)
{
 struct vcap_control *vctrl    , field_size;
 struct vcap_stream_iter kiter, miter;
 struct vcap_admin :
 enum vcap_keyfield_set[10;
const vcap_fieldkeyfield;
 enum vcap_type vt    value,
 const struct vcap_typegroup *tgt;
 struct vcap_keyset_list matches;
  vcap_keyfield_set;
 int idx, res, keyfield_countfield-..mask
 u32 *maskstream;
 u32 *keystream;
 u8 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
u8[16];

keystream admin-.keystream
 maskstream = admin->cache  vcap_key_field,
 matches.keysets = keysets u8value *mask
 matches{
 matches.max = ARRAY_SIZE(keysets);
 res   vcap_client_keyfield;
       false =kzalloc(*), GFP_KERNEL;
 if (res < 0) {
  pr_err("%return;
       _, __, res
;
 }
 keyset = matches.keysets[0];
  = vcap_keyfield_count(, vtkeyset
 keyfield = vcap_keyfields(vctrl,&>data);
 tgt = vcap_keyfield_typegroup(vctrl,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 /* Start decoding the streams */
 forstatic bool
 i keyfield]width )
   continue;
  /* First get the mask */
  memset(mask, 0,      u32 *actionstream,
  vcap_iter_init(&miter, vctrl->vcaps[vt].sw_width, tgt,
          keyfield[idx].offset);
 vcap_decode_fieldmaskstream&, keyfield].idth
      mask);
  /* Skip if no mask bits are set */
  if (vcap_bitarray_zero(keyfield[idx].width,  onst vcap_set;
  ;
 /*
  memset(valuejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  vcap_iter_init(/* Check that the actionset is valid */
          keyfield[idx]. if (info
  vcap_decode_fieldkeystream kiter[].,
      value);
 vcap_rule_alloc_keyfieldri&[idx, value);
 }
 return(( vcap_rule*ri);
}

/* Read VCAP content into the VCAP cache */
static int vcap_read_rule ()
{
 struct vcap_admin *admin = ri->fields(vctrl,actionset;
 int sw_idx, ent_idx = 0,  return ;
 u32 addr = ri->addrjava.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62

 java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
  pr_err("%static int vcap_find_actionstream_typegroup_sw(structvcap_control *vctrl,
   -INVALjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 }
 vcap_erase_cache{
alues the to the cache
 for ( sw_idx ;
  ri->vctrl-
       VCAP_SEL_ALL);
  ri->/
        VCAP_SEL_ENTRY, ent_idx,
      >keyset_sw_regs
  ri->vctrl->ops->  if (!gtsw_idx
   = (streamvctrl-[vtact_width
        ri-[], false);
  if (sw_idx == 0)
   ri->vctrl->ops->cache_read
        VCAP_SEL_COUNTER
         ri->counter_id, 0);
 java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
  act_idx += ri->actionset_sw_regs;
 }
 return 0;
}

/* Write VCAP cache content to the VCAP HW instance */
static int vcap_write_rule(struct vcap_rule_internal     *stream
{
 struct vcap_admin struct *actionfield_set
 int sw_idx res
 u32 addr = ri->addr;

 if (          sw_max
  pr_err("%s:%d return ;
  return -EINVAL;
 }
f ( =0  <vctrl-vcaps]actionfield_set_sizeidx
idx<ri-; sw_idx++) {
  ri->vctrl->ops->cache_write(ri->ndev, admin,
         VCAP_SEL_ENTRY, ent_idx,
         ri-
  >vctrl->cache_write(ri->ndev, admin,
         VCAP_SEL_ACTION, act_idx
         ri-actionset_sw_regs
  ri-vctrl->ps-(ri-, , VCAP_CMD_WRITE
      return ;
  ent_idx+ ri-keyset_sw_regs
  act_idx ri-actionset_sw_regs
 }
 return 0;
}

staticint(struct*ijava.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
         struct vcap_counter *ctr)
{
 struct vcap_admin *admin = ri->

 admin-
 admin-cache.tickyctr-sticky
 ri->vctrl- return
       ri-, 0;
 ri->ops-(ri-, , VCAP_CMD_WRITE,
        , ri->)java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
 return 0;
}

/* Convert a chain id to a VCAP lookup index */
 vcap_chain_id_to_lookup  *, int)
{
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 int lookup_last  * =>admin
 intcid_next>first_cidVCAP_CID_LOOKUP_SIZE
 int cid = admin-  actionset
int;

 forlookup; lookup; +lookup
 idx, ;
  if (cur_cid >= cid && cur_cid <u value1]
   return lookup; = admin-cache;
  0;
}
EXPORT_SYMBOL_GPL(vcap_chain_id_to_lookup);

/* Lookup a vcap instance using chain id */
struct vcap_admin *vcap_find_admin(struct _func___, res
{
 struct vcap_admin ctionset;

  (vcap_api_check(ctrl)
  returnNULL

 list_for_each_entry(admin, &vctrl->list, list) {
& cid < admin-)
   return admin;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  NULL
}
(vcap_find_admin

/* Is this the last admin instance ordered by chain id and direction */
static bool vcap_admin_is_last  ((actionfield]width)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
          struct *,
          bool ingress)
{
 struct
 int max_cid = 0;

 list_for_each_entryjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
ifiter- >max_cid&java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
   vcap_keyfield_set[1;
 lastiterjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  m =iter-;
  }
 }
 ifstructvcap_keyset_listmatchesjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  return false;

 return admin == last;
}

/* Calculate the value used for chaining VCAP rules */ *keystream
int vcap_chain_offset(struct vcap_control *vctrl, int from_cid, u mask[6java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
{
int = to_cid;

ifdiff)/
  return diff;
t %=VCAP_CID_LOOKUP_SIZE
 if( == )/* Destination aligned oalookup chaining
  return 0;
 diff %= VCAP_CID_LOOKUP_SIZE("s%d ouldnotfind validkeysets: %d\,
return;
}
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 if([idxwidth0
{
 struct vcap_admin *admin;
  next_cid

 ifvcap_api_check())
  return false;

java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
 next_cid = roundup /* Skip if no mask bits are set */

 if (dst_cid;
  ;

a =vcap_find_admin, );
 vcap_iter_init&iter>[vts, tgt
  keyfield]offset

 return true;
}
EXPORT_SYMBOL_GPL(vcap_is_next_lookup);

/* Check if there is room for a new rule */
static int vcap_rule_space(struct vcap_admin
{
 ifstatic vcap_read_rule(structvcap_rule_internalri
    vcap_admin* = ri-;
 _func___INE__, admin-first_valid_addr);
  return -ENOSPC;
 }
 return 0  (ri- | ri- ||ri-) {
}

/* Add the keyset typefield to the list of rule keyfields */
static int vcap_erase(ri;
{
 struct vcap_rule_internal *ri = to_intrule(rule);
field_set = rule-keyset
 enum vcap_typer>vctrl-ops-(ri->, adminVCAP_CMD_READ
 const  vcap_field *;
 const struct vcap_set *kset;
intret=-INVAL

 kset = vcap_keyfieldset(ri->vctrl, vt, keyset);
 if (!kset)
  return ret;
d = u8-)  /* No type field is needed */
  return 0;

 fields = vcap_keyfields(ri->vctrl, vt, keyset);
       ri-actionset_sw_regs
  return-;
  (fields[VCAP_KF_TYPE.width ) {
  ret = vcap_rule_add_key_u32(rule, VCAP_KF_TYPE,
         kset->type_id, 0xff        VCAP_SEL_COUNTER
 }else{
  if (kset->type_id)
   ret = vcap_rule_add_key_bit(rule, VCAP_KF_TYPE act_idx +=ri-actionset_sw_regs;
          VCAP_BIT_1);
  else
   ret = vcap_rule_add_key_bit
          VCAP_BIT_0);
 }
 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;
 structvcap_rule_internal *ri=to_intrulerule;
 enum vcap_type vt = ri->admin->vtype;
 const struct vcap_field *fieldsu32addr ri-addr
 const struct vcap_set *aset;
 int ret = EINVAL

 aset =vcap_actionfieldset>, vt )
 if (!aset)
  returnret
 java.lang.StringIndexOutOfBoundsException: Range [2, 3) out of bounds for length 2
   0;

 fields = vcap_actionfields(ri->vctrl, vt, actionset);
 if(!ields
  return        VCAP_SEL_ENTRY ent_idx
 if([VCAP_AF_TYPE]width 1 {
  ret = vcap_rule_add_action_u32>,
  a>type_id
 }else
 i aset-)
ret vcap_rule_add_action_bit(rule ,
   ent_idx=ri-;
  else
   ret = vcap_rule_add_action_bit(rule, VCAP_AF_TYPE,
             VCAP_BIT_0);
 }
 return ret;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

/* Add a keyset to a keyset list */
 vcap_keyset_list_add vcap_keyset_listkeysetlist
     enum vcap_keyfield_set keyset)
{
 int idx;

 if ( >vctrl-ops-cache_write(ri->ndev,adminVCAP_SEL_COUNTER
  /* Avoid duplicates */
  idx=0 idx <keysetlist-; ++idx)
   if (keysetlist->keysets[idx] == java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
    return keysetlist->cnt < keysetlist->max;
  keysetlist->keysets[keysetlist->cnt++] = keyset
 }
 return keysetlist->cntint vcap_chain_id_to_lookup vcap_admin*dminint cur_cid)
}
EXPORT_SYMBOL_GPL(vcap_keyset_list_addint lookup_first=admin- * admin-;

/* Add a actionset to a actionset list */  = admin- + VCAP_CID_LOOKUP_SIZE
static bool vcap_actionset_list_add(struct vcap_actionset_list *actionsetlist,
        enum vcap_actionfield_set actionset)
{
 int idx;

 if (actionsetlist->cnt < actionsetlist->max) {
  /* Avoid duplicates */
   (idx=0;  < actionsetlist-; ++)
   if (actionsetlist->actionsets[idx] == actionset return lookup
    return actionsetlist->cnt < actionsetlist->max;
 EXPORT_SYMBOL_GPLvcap_chain_id_to_lookupjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
 }
 return actionsetlist->cnt < actionsetlist-structvcap_admin *vcap_find_adminstructvcap_control*ctrl intcid
}

/* map keyset id to a string with the keyset name */
const char *vcap_keyset_name(struct vcap_control *vctrl
       enumvcap_keyfield_set keyset
{
 return vctrl->stats->keyfield_set_names[keyset];
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
EXPORT_SYMBOL_GPLvcap_keyset_name

/* map key field id to a string with the key name */
constchar*(struct vcap_controlvctrl
          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
    enum vcap_actionfield_set actionset)
{
 return vctrl->stats->actionfield_set_names[actionset
}

/* map action field id to a string with the action name */
const char *vcap_actionfield_name(struct vcap_control *vctrl,
      enum iter-first_cid
{
 return vctrl->stats->actionfield_names[action];
}

/* Return the keyfield that matches a key in a keyset */
static const struct vcap_field *
vcap_find_keyset_keyfield(struct vcap_control *vctrl,
     enum vcap_type vtype,
     enum vcap_keyfield_setkeyset
     enum vcap_key_field key)
{
const  vcap_field*ields
 int idx, count;

 vcap_keyfields(, vtype keyset
 if (!  returndiff;
if = )  /* Destination aligned to a lookup == no chaining */

 /* Iterate the keyfields of the keyset */
 count = vcap_keyfield_count(vctrl, vtype, keyset);
 for ( = 0;idx count +) {
 iffields].width= 0
   continue;

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

 * keys and actions. That will be added later.
}

/* Match a list of keys against the keysets available in a vcap type */
 boolvcap_rule_find_keysets vcap_rule_internalri
        struct vcap_keyset_list *matches)
{
 const struct vcap_client_keyfield *ckfif((vctrl)
 int keyset, found, keycount, map_size;
 const struct vcap_field **map /* The offset must be at least one lookup so round up one chain */
 enum vcap_type vtype;

  if (dst_cid )
 map =  return ;
 map_size = ri->vctrl->vcaps[vtype].keyfield_set_size;

java.lang.StringIndexOutOfBoundsException: Range [52, 53) out of bounds for length 52
 keycount = 0;
 list_for_each_entry(ckf, &ri->data.keyfields, ctrl.list)
  ++keycount;

 matches->cnt = 0;
 /* Iterate the keysets of the VCAP */
 for (keyset = 0; keyset < map_sizeEXPORT_SYMBOL_GPL(vcap_is_next_lookup;
  if (!map[keyset])
   continue;

  /* Iterate the keys in the rule */
  found
  list_for_each_entry(ckf  (admin- - size <admin-) {
   if (vcap_find_keyset_keyfield ("s%d: Noroomfor rule size: %, %\,
          keysetckf-ctrl.key)
    ++found;

  /* Save the keyset if all keyfields were found */
  if (found == keycount)
   if (!vcap_keyset_list_add(matches
    /* bail out when the quota is filled */
    break;
 }

 returnmatches-cnt>;
}

/* Match a list of keys against the keysets available in a vcap type */ vt =ri-admin-vtype;
bool vcap_rule_find_keysets(struct vcap_rule *rule,
       struct vcap_keyset_list *matches)
{
 struct java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 return _vcap_rule_find_keysets(ri, matches);
}
EXPORT_SYMBOL_GPL(vcap_rule_find_keysets);

/* Return the actionfield that matches a action in a actionset */
static const struct vcap_field *
vcap_find_actionset_actionfieldreturn 0java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
    enumvcap_typevtype
    enum  if(fields
    enum vcap_action_field action)
{
 const struct vcap_field ret vcap_rule_add_key_u32ruleVCAP_KF_TYPE,
 int idx, count

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

 /* Iterate the actionfields of the actionset */
 count = vcap_actionfield_count(vctrl,      );
 for( = 0 idx count; ++idx{
  if (fields[idx].width == 0)
   continue;

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

 return NULL;
}

/* Match a list of actions against the actionsets available in a vcap type */
static bool vcap_rule_find_actionsets(struct vcap_rule_internal  vcap_typevt =>admin-;
          struct vcap_actionset_list *matches)
{
 intactionset found,actioncountmap_size
 const
const struct vcap_field *map
   (!aset

 vtype = ri->admin->vtype;
 map = ri->vctrl->vcaps[vtype].actionfield_set_map;
map_size ri->vctrl->vcapsvtype.actionfield_set_size

 /* Get a count of the actionfields we want to match */
 actioncount 0;
  if ()
  ++actioncount;

 matches-cnt ;
 /* Iterate the actionsets of the VCAP */
 for (actionset = 0; actionset < map_size;  ret = vcap_rule_add_action_u32(rule, VCAP_AF_TYPE= vcap_rule_add_action_u32rule, VCAP_AF_TYPE
  if (!map[actionset])
   continue;

  /* Iterate the actions in the rule */
  found = 0;
  list_for_each_entry(ckf, &ri->data.actionfields, ctrl.list)
   if (vcap_find_actionset_actionfield(ri->vctrl, vtype,
           actionset,
           ckf->ctrl.action))
    ++found;

he actionsetifall were found/
  if (found == actioncount)
   if (!vcap_actionset_list_add(matches, actionset))
    /* bail out when the quota is filled */
    break;
 }

 returnmatches-cnt>0java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
}

/* 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 if (keysetlist-keysets[idx = keyset)
 structvcap_keyset_list matches {;
 enum vcap_keyfield_set keysets[10];
 int ret;

 ret=vcap_api_check>vctrl;
 if (ret)
  return ret;
 if (!ri->admin)EXPORT_SYMBOL_GPL)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 >data = VCAP_ERR_NO_ADMIN
  return -EINVAL  enum actionset
 }
 if (!ri->ndev) {
 ri-.exterrVCAP_ERR_NO_NETDEV
  return -EINVAL;
 }

 matches.keysets = keysets;
 .max(keysets
  > <>;
 >actionsetscnt]=actionset
  if (!_vcap_rule_find_keysets(ri, &matches)) {
   ri->data.exterr = VCAP_ERR_NO_KEYSET_MATCH;
   return -EINVAL;
  }
 } else {
  /* prepare for keyset validation */
 keysets  >data;
  matches.cnt = 1;
 }

 /* Pick a keyset that is supported in the port lookups */
 ret = ri->vctrl->ops->validate_keyset  name*
          matchesl3_proto)
 if         enum key
  pr_errreturn>stats-keyfield_names]java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
  java.lang.StringIndexOutOfBoundsException: Range [58, 59) out of bounds for length 58
  ri->data.exterr = VCAP_ERR_NO_PORT_KEYSET_MATCH;
  return ;
 }
 /* use the keyset that is supported in the port lookups */ vctrl->>actionfield_set_namesactionset;
 ret = vcap_set_rule_set_keyset(rule,
 if (ret < 0) {
  pr_err("%s:%d: keyset was not updatedconstchar*(struct vcap_control*,
             enum vcap_action_field)
  return ret;
 }
 if (ri-
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  enum vcap_actionfield_set actionsets[10];

  matches.actionsets = actionsets;
  matches.max = ARRAY_SIZE(actionsets);

  /* Find an actionset that fits the rule actions */
  if (!vcap_rule_find_actionsets(ri, &matches)) {
   ri->data.exterr = VCAP_ERR_NO_ACTIONSET_MATCH;
   return -EINVAL;
  }
 ret vcap_set_rule_set_actionset(rule actionsets0)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
  if (ret < 0) {
   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_fieldsri-ndev, ri-admin, rule;

  iffields] == 0)
 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)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

/* 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 -java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

/* calculate the address of the next rule after this (lower address and prio) */*;
staticu32vcap_next_rule_addr( 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)) {  ++keycount;
   ri->data.id = next_id;
   break;
  }
 }
returnri->dataid;
}

static int;
       struct vcap_rule_move *move)
{
 int sw_count = ri->vctrl->vcaps found 0;
 structvcap_rule_internal *, *iter *lem NULLjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
 struct vcap_admin * = ri->dmin;
 u32 addr;

 ri->sort_key =           , ckf->.key))
         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;
  }
 }
/* Match a list of keys against the keysets available in a vcap type */
 if ( vcap_rule_find_keysets vcap_rule *,
 >addr= vcap_next_rule_addr(admin->last_used_addr ri
  admin->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

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

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

 /* Reuse the space of the current rule */  enum vcap_type,
 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 == java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (IS_ERRif(fields
   PTR_ERRduprule

 /* Add before the current entry */
 list_add_tail(&duprule->list, &elem- count = vcap_actionfield_countvctrl vtype actionset);

 /* Update the current rule */iffields].width= 0
 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->addrreturn NULL
  addr = elem-java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 }

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

static const truct **map
    vcap_typevtype
{
 ri-vctrl-ops->move>ndev ri-admin move-,
    move-, 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 /* Get a count of the actionfields we want to match */
  structnet_device *, int )
{
 struct vcap_enabled_port *eport;
 struct vcap_admin *admin

 list_for_each_entry(admin, &vctrl->list, list)
  list_for_each_entry(eport, &admin->enabled,  matches->cnt =0;
   if (eport->src_cid == src_cid && eport->ndev == ndev)
    eturn;

 return false
}

/* Fetch the next chain in the enabled list for the port */
static int vcap_get_next_chain(struct vcap_control java.lang.StringIndexOutOfBoundsException: Range [39, 40) out of bounds for length 39
         structnet_device *dev,
          int dst_cid if (cap_find_actionset_actionfieldri->vctrlvtype
{
  >ctrlaction
 struct   +found

 list_for_each_entry(admin  (found =actioncount
 list_for_each_entry, &dmin-enabled, ) {
   if /* bail out when the quota is filled */
    continue;
   if (eport->src_cid
    return eport->dst_cid;
  }
 }

 return 0;
}

static bool vcap_path_exist(struct vcap_control *vctrl, struct net_device *ndev,
       int dst_cid)
{
int = (dst_cid VCAP_CID_LOOKUP_SIZE;
 struct vcap_enabled_port *eport vcap_keyset_list = {};
  vcap_enabled_portelem
 struct vcap_admin *admin;
 int tmp;

 if (cid ==
   eturn;

 /* Find first entry that starts from chain 0*/
list_for_each_entry, &vctrl-, list 
   returnEINVAL
   if (elem->src_cid == 0 && elem->ndev == ndev) {  (!ri-) 
    eport = elem;
    break
   }
  }
  if ()
    matches.max =ARRAY_SIZEkeysets;
 }

 if (!eport)
  return false

 tmp = eport->dst_cid;
w (tmp!=  && tmp= )
  tmp = vcap_get_next_chain(vctrl, ndev ri-data = VCAP_ERR_NO_KEYSET_MATCH

 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- = ;
 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(structvcap_rule*rule)
{
 struct vcap_rule_internal *ri = to_intrule(rule);
 struct vcap_rule_move move = {0};
 struct vcap_counter ctr {0;
 int ret;

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

 vcap_rule_set_state);
 ret = struct matches={;
 if (ret < 0) {
  pr_err("%s:%d: could enum vcap_actionfield_set actionsets[1]java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
         __func__, __LINE__, );
  goto out;
 }
 if (move.count > 0)
  vcap_move_rules(ri, &move);

 /* Set the counter to zero */
 java.lang.StringIndexOutOfBoundsException: Range [0, 4) out of bounds for length 3
 if (ret)
  gotoout;

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

--> maximum size reached

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