1c9da1ac1SSteen Hegelund // SPDX-License-Identifier: GPL-2.0+ 2c9da1ac1SSteen Hegelund /* Microchip VCAP API 3c9da1ac1SSteen Hegelund * 4c9da1ac1SSteen Hegelund * Copyright (c) 2022 Microchip Technology Inc. and its subsidiaries. 5c9da1ac1SSteen Hegelund */ 6c9da1ac1SSteen Hegelund 7c9da1ac1SSteen Hegelund #include <linux/types.h> 8c9da1ac1SSteen Hegelund 9d4134d41SSteen Hegelund #include "vcap_api_private.h" 10c9da1ac1SSteen Hegelund 114f141e36SHoratiu Vultur static int keyfield_size_table[] = { 124f141e36SHoratiu Vultur [VCAP_FIELD_BIT] = sizeof(struct vcap_u1_key), 134f141e36SHoratiu Vultur [VCAP_FIELD_U32] = sizeof(struct vcap_u32_key), 144f141e36SHoratiu Vultur [VCAP_FIELD_U48] = sizeof(struct vcap_u48_key), 154f141e36SHoratiu Vultur [VCAP_FIELD_U56] = sizeof(struct vcap_u56_key), 164f141e36SHoratiu Vultur [VCAP_FIELD_U64] = sizeof(struct vcap_u64_key), 174f141e36SHoratiu Vultur [VCAP_FIELD_U72] = sizeof(struct vcap_u72_key), 184f141e36SHoratiu Vultur [VCAP_FIELD_U112] = sizeof(struct vcap_u112_key), 194f141e36SHoratiu Vultur [VCAP_FIELD_U128] = sizeof(struct vcap_u128_key), 204f141e36SHoratiu Vultur }; 214f141e36SHoratiu Vultur 224f141e36SHoratiu Vultur static int actionfield_size_table[] = { 234f141e36SHoratiu Vultur [VCAP_FIELD_BIT] = sizeof(struct vcap_u1_action), 244f141e36SHoratiu Vultur [VCAP_FIELD_U32] = sizeof(struct vcap_u32_action), 254f141e36SHoratiu Vultur [VCAP_FIELD_U48] = sizeof(struct vcap_u48_action), 264f141e36SHoratiu Vultur [VCAP_FIELD_U56] = sizeof(struct vcap_u56_action), 274f141e36SHoratiu Vultur [VCAP_FIELD_U64] = sizeof(struct vcap_u64_action), 284f141e36SHoratiu Vultur [VCAP_FIELD_U72] = sizeof(struct vcap_u72_action), 294f141e36SHoratiu Vultur [VCAP_FIELD_U112] = sizeof(struct vcap_u112_action), 304f141e36SHoratiu Vultur [VCAP_FIELD_U128] = sizeof(struct vcap_u128_action), 314f141e36SHoratiu Vultur }; 324f141e36SHoratiu Vultur 338e10490bSSteen Hegelund /* Moving a rule in the VCAP address space */ 348e10490bSSteen Hegelund struct vcap_rule_move { 358e10490bSSteen Hegelund int addr; /* address to move */ 368e10490bSSteen Hegelund int offset; /* change in address */ 378e10490bSSteen Hegelund int count; /* blocksize of addresses to move */ 388e10490bSSteen Hegelund }; 398e10490bSSteen Hegelund 40cfd9e7b7SSteen Hegelund /* Stores the filter cookie and chain id that enabled the port */ 4167456717SSteen Hegelund struct vcap_enabled_port { 4267456717SSteen Hegelund struct list_head list; /* for insertion in enabled ports list */ 4367456717SSteen Hegelund struct net_device *ndev; /* the enabled port */ 4467456717SSteen Hegelund unsigned long cookie; /* filter that enabled the port */ 45cfd9e7b7SSteen Hegelund int src_cid; /* source chain id */ 46cfd9e7b7SSteen Hegelund int dst_cid; /* destination chain id */ 4767456717SSteen Hegelund }; 4867456717SSteen Hegelund 49d4134d41SSteen Hegelund void vcap_iter_set(struct vcap_stream_iter *itr, int sw_width, 50683e05c0SSteen Hegelund const struct vcap_typegroup *tg, u32 offset) 51683e05c0SSteen Hegelund { 52683e05c0SSteen Hegelund memset(itr, 0, sizeof(*itr)); 53683e05c0SSteen Hegelund itr->offset = offset; 54683e05c0SSteen Hegelund itr->sw_width = sw_width; 55683e05c0SSteen Hegelund itr->regs_per_sw = DIV_ROUND_UP(sw_width, 32); 56683e05c0SSteen Hegelund itr->tg = tg; 57683e05c0SSteen Hegelund } 58683e05c0SSteen Hegelund 59683e05c0SSteen Hegelund static void vcap_iter_skip_tg(struct vcap_stream_iter *itr) 60683e05c0SSteen Hegelund { 61683e05c0SSteen Hegelund /* Compensate the field offset for preceding typegroups. 62683e05c0SSteen Hegelund * A typegroup table ends with an all-zero terminator. 63683e05c0SSteen Hegelund */ 64683e05c0SSteen Hegelund while (itr->tg->width && itr->offset >= itr->tg->offset) { 65683e05c0SSteen Hegelund itr->offset += itr->tg->width; 66683e05c0SSteen Hegelund itr->tg++; /* next typegroup */ 67683e05c0SSteen Hegelund } 68683e05c0SSteen Hegelund } 69683e05c0SSteen Hegelund 70d4134d41SSteen Hegelund void vcap_iter_update(struct vcap_stream_iter *itr) 71683e05c0SSteen Hegelund { 72683e05c0SSteen Hegelund int sw_idx, sw_bitpos; 73683e05c0SSteen Hegelund 74683e05c0SSteen Hegelund /* Calculate the subword index and bitposition for current bit */ 75683e05c0SSteen Hegelund sw_idx = itr->offset / itr->sw_width; 76683e05c0SSteen Hegelund sw_bitpos = itr->offset % itr->sw_width; 77683e05c0SSteen Hegelund /* Calculate the register index and bitposition for current bit */ 78683e05c0SSteen Hegelund itr->reg_idx = (sw_idx * itr->regs_per_sw) + (sw_bitpos / 32); 79683e05c0SSteen Hegelund itr->reg_bitpos = sw_bitpos % 32; 80683e05c0SSteen Hegelund } 81683e05c0SSteen Hegelund 82d4134d41SSteen Hegelund void vcap_iter_init(struct vcap_stream_iter *itr, int sw_width, 83683e05c0SSteen Hegelund const struct vcap_typegroup *tg, u32 offset) 84683e05c0SSteen Hegelund { 85683e05c0SSteen Hegelund vcap_iter_set(itr, sw_width, tg, offset); 86683e05c0SSteen Hegelund vcap_iter_skip_tg(itr); 87683e05c0SSteen Hegelund vcap_iter_update(itr); 88683e05c0SSteen Hegelund } 89683e05c0SSteen Hegelund 90d4134d41SSteen Hegelund void vcap_iter_next(struct vcap_stream_iter *itr) 91683e05c0SSteen Hegelund { 92683e05c0SSteen Hegelund itr->offset++; 93683e05c0SSteen Hegelund vcap_iter_skip_tg(itr); 94683e05c0SSteen Hegelund vcap_iter_update(itr); 95683e05c0SSteen Hegelund } 96683e05c0SSteen Hegelund 97683e05c0SSteen Hegelund static void vcap_set_bit(u32 *stream, struct vcap_stream_iter *itr, bool value) 98683e05c0SSteen Hegelund { 99683e05c0SSteen Hegelund u32 mask = BIT(itr->reg_bitpos); 100683e05c0SSteen Hegelund u32 *p = &stream[itr->reg_idx]; 101683e05c0SSteen Hegelund 102683e05c0SSteen Hegelund if (value) 103683e05c0SSteen Hegelund *p |= mask; 104683e05c0SSteen Hegelund else 105683e05c0SSteen Hegelund *p &= ~mask; 106683e05c0SSteen Hegelund } 107683e05c0SSteen Hegelund 108683e05c0SSteen Hegelund static void vcap_encode_bit(u32 *stream, struct vcap_stream_iter *itr, bool val) 109683e05c0SSteen Hegelund { 110683e05c0SSteen Hegelund /* When intersected by a type group field, stream the type group bits 111683e05c0SSteen Hegelund * before continuing with the value bit 112683e05c0SSteen Hegelund */ 113683e05c0SSteen Hegelund while (itr->tg->width && 114683e05c0SSteen Hegelund itr->offset >= itr->tg->offset && 115683e05c0SSteen Hegelund itr->offset < itr->tg->offset + itr->tg->width) { 116683e05c0SSteen Hegelund int tg_bitpos = itr->tg->offset - itr->offset; 117683e05c0SSteen Hegelund 118683e05c0SSteen Hegelund vcap_set_bit(stream, itr, (itr->tg->value >> tg_bitpos) & 0x1); 119683e05c0SSteen Hegelund itr->offset++; 120683e05c0SSteen Hegelund vcap_iter_update(itr); 121683e05c0SSteen Hegelund } 122683e05c0SSteen Hegelund vcap_set_bit(stream, itr, val); 123683e05c0SSteen Hegelund } 124683e05c0SSteen Hegelund 125683e05c0SSteen Hegelund static void vcap_encode_field(u32 *stream, struct vcap_stream_iter *itr, 126683e05c0SSteen Hegelund int width, const u8 *value) 127683e05c0SSteen Hegelund { 128683e05c0SSteen Hegelund int idx; 129683e05c0SSteen Hegelund 130683e05c0SSteen Hegelund /* Loop over the field value bits and add the value bits one by one to 131683e05c0SSteen Hegelund * the output stream. 132683e05c0SSteen Hegelund */ 133683e05c0SSteen Hegelund for (idx = 0; idx < width; idx++) { 134683e05c0SSteen Hegelund u8 bidx = idx & GENMASK(2, 0); 135683e05c0SSteen Hegelund 136683e05c0SSteen Hegelund /* Encode one field value bit */ 137683e05c0SSteen Hegelund vcap_encode_bit(stream, itr, (value[idx / 8] >> bidx) & 0x1); 138683e05c0SSteen Hegelund vcap_iter_next(itr); 139683e05c0SSteen Hegelund } 140683e05c0SSteen Hegelund } 141683e05c0SSteen Hegelund 142683e05c0SSteen Hegelund static void vcap_encode_typegroups(u32 *stream, int sw_width, 143683e05c0SSteen Hegelund const struct vcap_typegroup *tg, 144683e05c0SSteen Hegelund bool mask) 145683e05c0SSteen Hegelund { 146683e05c0SSteen Hegelund struct vcap_stream_iter iter; 147683e05c0SSteen Hegelund int idx; 148683e05c0SSteen Hegelund 149683e05c0SSteen Hegelund /* Mask bits must be set to zeros (inverted later when writing to the 150683e05c0SSteen Hegelund * mask cache register), so that the mask typegroup bits consist of 151683e05c0SSteen Hegelund * match-1 or match-0, or both 152683e05c0SSteen Hegelund */ 153683e05c0SSteen Hegelund vcap_iter_set(&iter, sw_width, tg, 0); 154683e05c0SSteen Hegelund while (iter.tg->width) { 155683e05c0SSteen Hegelund /* Set position to current typegroup bit */ 156683e05c0SSteen Hegelund iter.offset = iter.tg->offset; 157683e05c0SSteen Hegelund vcap_iter_update(&iter); 158683e05c0SSteen Hegelund for (idx = 0; idx < iter.tg->width; idx++) { 159683e05c0SSteen Hegelund /* Iterate over current typegroup bits. Mask typegroup 160683e05c0SSteen Hegelund * bits are always set 161683e05c0SSteen Hegelund */ 162683e05c0SSteen Hegelund if (mask) 163683e05c0SSteen Hegelund vcap_set_bit(stream, &iter, 0x1); 164683e05c0SSteen Hegelund else 165683e05c0SSteen Hegelund vcap_set_bit(stream, &iter, 166683e05c0SSteen Hegelund (iter.tg->value >> idx) & 0x1); 167683e05c0SSteen Hegelund iter.offset++; 168683e05c0SSteen Hegelund vcap_iter_update(&iter); 169683e05c0SSteen Hegelund } 170683e05c0SSteen Hegelund iter.tg++; /* next typegroup */ 171683e05c0SSteen Hegelund } 172683e05c0SSteen Hegelund } 173683e05c0SSteen Hegelund 174610c32b2SHoratiu Vultur static bool vcap_bitarray_zero(int width, u8 *value) 175610c32b2SHoratiu Vultur { 176610c32b2SHoratiu Vultur int bytes = DIV_ROUND_UP(width, BITS_PER_BYTE); 177610c32b2SHoratiu Vultur u8 total = 0, bmask = 0xff; 178610c32b2SHoratiu Vultur int rwidth = width; 179610c32b2SHoratiu Vultur int idx; 180610c32b2SHoratiu Vultur 181610c32b2SHoratiu Vultur for (idx = 0; idx < bytes; ++idx, rwidth -= BITS_PER_BYTE) { 182610c32b2SHoratiu Vultur if (rwidth && rwidth < BITS_PER_BYTE) 183610c32b2SHoratiu Vultur bmask = (1 << rwidth) - 1; 184610c32b2SHoratiu Vultur total += value[idx] & bmask; 185610c32b2SHoratiu Vultur } 186610c32b2SHoratiu Vultur return total == 0; 187610c32b2SHoratiu Vultur } 188610c32b2SHoratiu Vultur 189610c32b2SHoratiu Vultur static bool vcap_get_bit(u32 *stream, struct vcap_stream_iter *itr) 190610c32b2SHoratiu Vultur { 191610c32b2SHoratiu Vultur u32 mask = BIT(itr->reg_bitpos); 192610c32b2SHoratiu Vultur u32 *p = &stream[itr->reg_idx]; 193610c32b2SHoratiu Vultur 194610c32b2SHoratiu Vultur return !!(*p & mask); 195610c32b2SHoratiu Vultur } 196610c32b2SHoratiu Vultur 197610c32b2SHoratiu Vultur static void vcap_decode_field(u32 *stream, struct vcap_stream_iter *itr, 198610c32b2SHoratiu Vultur int width, u8 *value) 199610c32b2SHoratiu Vultur { 200610c32b2SHoratiu Vultur int idx; 201610c32b2SHoratiu Vultur 202610c32b2SHoratiu Vultur /* Loop over the field value bits and get the field bits and 203610c32b2SHoratiu Vultur * set them in the output value byte array 204610c32b2SHoratiu Vultur */ 205610c32b2SHoratiu Vultur for (idx = 0; idx < width; idx++) { 206610c32b2SHoratiu Vultur u8 bidx = idx & 0x7; 207610c32b2SHoratiu Vultur 208610c32b2SHoratiu Vultur /* Decode one field value bit */ 209610c32b2SHoratiu Vultur if (vcap_get_bit(stream, itr)) 210610c32b2SHoratiu Vultur *value |= 1 << bidx; 211610c32b2SHoratiu Vultur vcap_iter_next(itr); 212610c32b2SHoratiu Vultur if (bidx == 7) 213610c32b2SHoratiu Vultur value++; 214610c32b2SHoratiu Vultur } 215610c32b2SHoratiu Vultur } 216610c32b2SHoratiu Vultur 217610c32b2SHoratiu Vultur /* Verify that the type id in the stream matches the type id of the keyset */ 218610c32b2SHoratiu Vultur static bool vcap_verify_keystream_keyset(struct vcap_control *vctrl, 219610c32b2SHoratiu Vultur enum vcap_type vt, 220610c32b2SHoratiu Vultur u32 *keystream, 221610c32b2SHoratiu Vultur u32 *mskstream, 222610c32b2SHoratiu Vultur enum vcap_keyfield_set keyset) 223610c32b2SHoratiu Vultur { 224610c32b2SHoratiu Vultur const struct vcap_info *vcap = &vctrl->vcaps[vt]; 225610c32b2SHoratiu Vultur const struct vcap_field *typefld; 226610c32b2SHoratiu Vultur const struct vcap_typegroup *tgt; 227610c32b2SHoratiu Vultur const struct vcap_field *fields; 228610c32b2SHoratiu Vultur struct vcap_stream_iter iter; 229610c32b2SHoratiu Vultur const struct vcap_set *info; 230610c32b2SHoratiu Vultur u32 value = 0; 231610c32b2SHoratiu Vultur u32 mask = 0; 232610c32b2SHoratiu Vultur 233610c32b2SHoratiu Vultur if (vcap_keyfield_count(vctrl, vt, keyset) == 0) 234610c32b2SHoratiu Vultur return false; 235610c32b2SHoratiu Vultur 236610c32b2SHoratiu Vultur info = vcap_keyfieldset(vctrl, vt, keyset); 237610c32b2SHoratiu Vultur /* Check that the keyset is valid */ 238610c32b2SHoratiu Vultur if (!info) 239610c32b2SHoratiu Vultur return false; 240610c32b2SHoratiu Vultur 241610c32b2SHoratiu Vultur /* a type_id of value -1 means that there is no type field */ 242610c32b2SHoratiu Vultur if (info->type_id == (u8)-1) 243610c32b2SHoratiu Vultur return true; 244610c32b2SHoratiu Vultur 245610c32b2SHoratiu Vultur /* Get a valid typegroup for the specific keyset */ 246610c32b2SHoratiu Vultur tgt = vcap_keyfield_typegroup(vctrl, vt, keyset); 247610c32b2SHoratiu Vultur if (!tgt) 248610c32b2SHoratiu Vultur return false; 249610c32b2SHoratiu Vultur 250610c32b2SHoratiu Vultur fields = vcap_keyfields(vctrl, vt, keyset); 251610c32b2SHoratiu Vultur if (!fields) 252610c32b2SHoratiu Vultur return false; 253610c32b2SHoratiu Vultur 254610c32b2SHoratiu Vultur typefld = &fields[VCAP_KF_TYPE]; 255610c32b2SHoratiu Vultur vcap_iter_init(&iter, vcap->sw_width, tgt, typefld->offset); 256610c32b2SHoratiu Vultur vcap_decode_field(mskstream, &iter, typefld->width, (u8 *)&mask); 257610c32b2SHoratiu Vultur /* no type info if there are no mask bits */ 258610c32b2SHoratiu Vultur if (vcap_bitarray_zero(typefld->width, (u8 *)&mask)) 259610c32b2SHoratiu Vultur return false; 260610c32b2SHoratiu Vultur 261610c32b2SHoratiu Vultur /* Get the value of the type field in the stream and compare to the 262610c32b2SHoratiu Vultur * one define in the vcap keyset 263610c32b2SHoratiu Vultur */ 264610c32b2SHoratiu Vultur vcap_iter_init(&iter, vcap->sw_width, tgt, typefld->offset); 265610c32b2SHoratiu Vultur vcap_decode_field(keystream, &iter, typefld->width, (u8 *)&value); 266610c32b2SHoratiu Vultur 267610c32b2SHoratiu Vultur return (value & mask) == (info->type_id & mask); 268610c32b2SHoratiu Vultur } 269610c32b2SHoratiu Vultur 270610c32b2SHoratiu Vultur /* Verify that the typegroup bits have the correct values */ 271610c32b2SHoratiu Vultur static int vcap_verify_typegroups(u32 *stream, int sw_width, 272610c32b2SHoratiu Vultur const struct vcap_typegroup *tgt, bool mask, 273610c32b2SHoratiu Vultur int sw_max) 274610c32b2SHoratiu Vultur { 275610c32b2SHoratiu Vultur struct vcap_stream_iter iter; 276610c32b2SHoratiu Vultur int sw_cnt, idx; 277610c32b2SHoratiu Vultur 278610c32b2SHoratiu Vultur vcap_iter_set(&iter, sw_width, tgt, 0); 279610c32b2SHoratiu Vultur sw_cnt = 0; 280610c32b2SHoratiu Vultur while (iter.tg->width) { 281610c32b2SHoratiu Vultur u32 value = 0; 282610c32b2SHoratiu Vultur u32 tg_value = iter.tg->value; 283610c32b2SHoratiu Vultur 284610c32b2SHoratiu Vultur if (mask) 285610c32b2SHoratiu Vultur tg_value = (1 << iter.tg->width) - 1; 286610c32b2SHoratiu Vultur /* Set position to current typegroup bit */ 287610c32b2SHoratiu Vultur iter.offset = iter.tg->offset; 288610c32b2SHoratiu Vultur vcap_iter_update(&iter); 289610c32b2SHoratiu Vultur for (idx = 0; idx < iter.tg->width; idx++) { 290610c32b2SHoratiu Vultur /* Decode one typegroup bit */ 291610c32b2SHoratiu Vultur if (vcap_get_bit(stream, &iter)) 292610c32b2SHoratiu Vultur value |= 1 << idx; 293610c32b2SHoratiu Vultur iter.offset++; 294610c32b2SHoratiu Vultur vcap_iter_update(&iter); 295610c32b2SHoratiu Vultur } 296610c32b2SHoratiu Vultur if (value != tg_value) 297610c32b2SHoratiu Vultur return -EINVAL; 298610c32b2SHoratiu Vultur iter.tg++; /* next typegroup */ 299610c32b2SHoratiu Vultur sw_cnt++; 300610c32b2SHoratiu Vultur /* Stop checking more typegroups */ 301610c32b2SHoratiu Vultur if (sw_max && sw_cnt >= sw_max) 302610c32b2SHoratiu Vultur break; 303610c32b2SHoratiu Vultur } 304610c32b2SHoratiu Vultur return 0; 305610c32b2SHoratiu Vultur } 306610c32b2SHoratiu Vultur 307610c32b2SHoratiu Vultur /* Find the subword width of the key typegroup that matches the stream data */ 308610c32b2SHoratiu Vultur static int vcap_find_keystream_typegroup_sw(struct vcap_control *vctrl, 309610c32b2SHoratiu Vultur enum vcap_type vt, u32 *stream, 310610c32b2SHoratiu Vultur bool mask, int sw_max) 311610c32b2SHoratiu Vultur { 312610c32b2SHoratiu Vultur const struct vcap_typegroup **tgt; 313610c32b2SHoratiu Vultur int sw_idx, res; 314610c32b2SHoratiu Vultur 315610c32b2SHoratiu Vultur tgt = vctrl->vcaps[vt].keyfield_set_typegroups; 316610c32b2SHoratiu Vultur /* Try the longest subword match first */ 317610c32b2SHoratiu Vultur for (sw_idx = vctrl->vcaps[vt].sw_count; sw_idx >= 0; sw_idx--) { 318610c32b2SHoratiu Vultur if (!tgt[sw_idx]) 319610c32b2SHoratiu Vultur continue; 320610c32b2SHoratiu Vultur 321610c32b2SHoratiu Vultur res = vcap_verify_typegroups(stream, vctrl->vcaps[vt].sw_width, 322610c32b2SHoratiu Vultur tgt[sw_idx], mask, sw_max); 323610c32b2SHoratiu Vultur if (res == 0) 324610c32b2SHoratiu Vultur return sw_idx; 325610c32b2SHoratiu Vultur } 326610c32b2SHoratiu Vultur return -EINVAL; 327610c32b2SHoratiu Vultur } 328610c32b2SHoratiu Vultur 329610c32b2SHoratiu Vultur /* Verify that the typegroup information, subword count, keyset and type id 330610c32b2SHoratiu Vultur * are in sync and correct, return the list of matchin keysets 331610c32b2SHoratiu Vultur */ 332610c32b2SHoratiu Vultur int 333610c32b2SHoratiu Vultur vcap_find_keystream_keysets(struct vcap_control *vctrl, 334610c32b2SHoratiu Vultur enum vcap_type vt, 335610c32b2SHoratiu Vultur u32 *keystream, 336610c32b2SHoratiu Vultur u32 *mskstream, 337610c32b2SHoratiu Vultur bool mask, int sw_max, 338610c32b2SHoratiu Vultur struct vcap_keyset_list *kslist) 339610c32b2SHoratiu Vultur { 340610c32b2SHoratiu Vultur const struct vcap_set *keyfield_set; 341610c32b2SHoratiu Vultur int sw_count, idx; 342610c32b2SHoratiu Vultur 343610c32b2SHoratiu Vultur sw_count = vcap_find_keystream_typegroup_sw(vctrl, vt, keystream, mask, 344610c32b2SHoratiu Vultur sw_max); 345610c32b2SHoratiu Vultur if (sw_count < 0) 346610c32b2SHoratiu Vultur return sw_count; 347610c32b2SHoratiu Vultur 348610c32b2SHoratiu Vultur keyfield_set = vctrl->vcaps[vt].keyfield_set; 349610c32b2SHoratiu Vultur for (idx = 0; idx < vctrl->vcaps[vt].keyfield_set_size; ++idx) { 350610c32b2SHoratiu Vultur if (keyfield_set[idx].sw_per_item != sw_count) 351610c32b2SHoratiu Vultur continue; 352610c32b2SHoratiu Vultur 353610c32b2SHoratiu Vultur if (vcap_verify_keystream_keyset(vctrl, vt, keystream, 354610c32b2SHoratiu Vultur mskstream, idx)) 355610c32b2SHoratiu Vultur vcap_keyset_list_add(kslist, idx); 356610c32b2SHoratiu Vultur } 357610c32b2SHoratiu Vultur if (kslist->cnt > 0) 358610c32b2SHoratiu Vultur return 0; 359610c32b2SHoratiu Vultur return -EINVAL; 360610c32b2SHoratiu Vultur } 361610c32b2SHoratiu Vultur EXPORT_SYMBOL_GPL(vcap_find_keystream_keysets); 362610c32b2SHoratiu Vultur 363610c32b2SHoratiu Vultur /* Read key data from a VCAP address and discover if there are any rule keysets 364610c32b2SHoratiu Vultur * here 365610c32b2SHoratiu Vultur */ 366610c32b2SHoratiu Vultur int vcap_addr_keysets(struct vcap_control *vctrl, 367610c32b2SHoratiu Vultur struct net_device *ndev, 368610c32b2SHoratiu Vultur struct vcap_admin *admin, 369610c32b2SHoratiu Vultur int addr, 370610c32b2SHoratiu Vultur struct vcap_keyset_list *kslist) 371610c32b2SHoratiu Vultur { 372610c32b2SHoratiu Vultur enum vcap_type vt = admin->vtype; 373610c32b2SHoratiu Vultur int keyset_sw_regs, idx; 374610c32b2SHoratiu Vultur u32 key = 0, mask = 0; 375610c32b2SHoratiu Vultur 376610c32b2SHoratiu Vultur /* Read the cache at the specified address */ 377610c32b2SHoratiu Vultur keyset_sw_regs = DIV_ROUND_UP(vctrl->vcaps[vt].sw_width, 32); 378610c32b2SHoratiu Vultur vctrl->ops->update(ndev, admin, VCAP_CMD_READ, VCAP_SEL_ALL, addr); 379610c32b2SHoratiu Vultur vctrl->ops->cache_read(ndev, admin, VCAP_SEL_ENTRY, 0, 380610c32b2SHoratiu Vultur keyset_sw_regs); 381610c32b2SHoratiu Vultur /* Skip uninitialized key/mask entries */ 382610c32b2SHoratiu Vultur for (idx = 0; idx < keyset_sw_regs; ++idx) { 383610c32b2SHoratiu Vultur key |= ~admin->cache.keystream[idx]; 384610c32b2SHoratiu Vultur mask |= admin->cache.maskstream[idx]; 385610c32b2SHoratiu Vultur } 386610c32b2SHoratiu Vultur if (key == 0 && mask == 0) 387610c32b2SHoratiu Vultur return -EINVAL; 388610c32b2SHoratiu Vultur /* Decode and locate the keysets */ 389610c32b2SHoratiu Vultur return vcap_find_keystream_keysets(vctrl, vt, admin->cache.keystream, 390610c32b2SHoratiu Vultur admin->cache.maskstream, false, 0, 391610c32b2SHoratiu Vultur kslist); 392610c32b2SHoratiu Vultur } 393610c32b2SHoratiu Vultur EXPORT_SYMBOL_GPL(vcap_addr_keysets); 394610c32b2SHoratiu Vultur 39546be056eSSteen Hegelund /* Return the list of keyfields for the keyset */ 396d4134d41SSteen Hegelund const struct vcap_field *vcap_keyfields(struct vcap_control *vctrl, 39746be056eSSteen Hegelund enum vcap_type vt, 39846be056eSSteen Hegelund enum vcap_keyfield_set keyset) 39946be056eSSteen Hegelund { 40046be056eSSteen Hegelund /* Check that the keyset exists in the vcap keyset list */ 40146be056eSSteen Hegelund if (keyset >= vctrl->vcaps[vt].keyfield_set_size) 40246be056eSSteen Hegelund return NULL; 40346be056eSSteen Hegelund return vctrl->vcaps[vt].keyfield_set_map[keyset]; 40446be056eSSteen Hegelund } 40546be056eSSteen Hegelund 4068e10490bSSteen Hegelund /* Return the keyset information for the keyset */ 407d4134d41SSteen Hegelund const struct vcap_set *vcap_keyfieldset(struct vcap_control *vctrl, 4088e10490bSSteen Hegelund enum vcap_type vt, 4098e10490bSSteen Hegelund enum vcap_keyfield_set keyset) 4108e10490bSSteen Hegelund { 4118e10490bSSteen Hegelund const struct vcap_set *kset; 4128e10490bSSteen Hegelund 4138e10490bSSteen Hegelund /* Check that the keyset exists in the vcap keyset list */ 4148e10490bSSteen Hegelund if (keyset >= vctrl->vcaps[vt].keyfield_set_size) 4158e10490bSSteen Hegelund return NULL; 4168e10490bSSteen Hegelund kset = &vctrl->vcaps[vt].keyfield_set[keyset]; 4178e10490bSSteen Hegelund if (kset->sw_per_item == 0 || kset->sw_per_item > vctrl->vcaps[vt].sw_count) 4188e10490bSSteen Hegelund return NULL; 4198e10490bSSteen Hegelund return kset; 4208e10490bSSteen Hegelund } 421465a38a2SSteen Hegelund EXPORT_SYMBOL_GPL(vcap_keyfieldset); 4228e10490bSSteen Hegelund 423683e05c0SSteen Hegelund /* Return the typegroup table for the matching keyset (using subword size) */ 424d4134d41SSteen Hegelund const struct vcap_typegroup * 425683e05c0SSteen Hegelund vcap_keyfield_typegroup(struct vcap_control *vctrl, 426683e05c0SSteen Hegelund enum vcap_type vt, enum vcap_keyfield_set keyset) 427683e05c0SSteen Hegelund { 428683e05c0SSteen Hegelund const struct vcap_set *kset = vcap_keyfieldset(vctrl, vt, keyset); 429683e05c0SSteen Hegelund 430683e05c0SSteen Hegelund /* Check that the keyset is valid */ 431683e05c0SSteen Hegelund if (!kset) 432683e05c0SSteen Hegelund return NULL; 433683e05c0SSteen Hegelund return vctrl->vcaps[vt].keyfield_set_typegroups[kset->sw_per_item]; 434683e05c0SSteen Hegelund } 435683e05c0SSteen Hegelund 436683e05c0SSteen Hegelund /* Return the number of keyfields in the keyset */ 437d4134d41SSteen Hegelund int vcap_keyfield_count(struct vcap_control *vctrl, 438683e05c0SSteen Hegelund enum vcap_type vt, enum vcap_keyfield_set keyset) 439683e05c0SSteen Hegelund { 440683e05c0SSteen Hegelund /* Check that the keyset exists in the vcap keyset list */ 441683e05c0SSteen Hegelund if (keyset >= vctrl->vcaps[vt].keyfield_set_size) 442683e05c0SSteen Hegelund return 0; 443683e05c0SSteen Hegelund return vctrl->vcaps[vt].keyfield_set_map_size[keyset]; 444683e05c0SSteen Hegelund } 445683e05c0SSteen Hegelund 446683e05c0SSteen Hegelund static void vcap_encode_keyfield(struct vcap_rule_internal *ri, 447683e05c0SSteen Hegelund const struct vcap_client_keyfield *kf, 448683e05c0SSteen Hegelund const struct vcap_field *rf, 449683e05c0SSteen Hegelund const struct vcap_typegroup *tgt) 450683e05c0SSteen Hegelund { 451683e05c0SSteen Hegelund int sw_width = ri->vctrl->vcaps[ri->admin->vtype].sw_width; 452683e05c0SSteen Hegelund struct vcap_cache_data *cache = &ri->admin->cache; 453683e05c0SSteen Hegelund struct vcap_stream_iter iter; 454683e05c0SSteen Hegelund const u8 *value, *mask; 455683e05c0SSteen Hegelund 456683e05c0SSteen Hegelund /* Encode the fields for the key and the mask in their respective 457683e05c0SSteen Hegelund * streams, respecting the subword width. 458683e05c0SSteen Hegelund */ 459683e05c0SSteen Hegelund switch (kf->ctrl.type) { 460683e05c0SSteen Hegelund case VCAP_FIELD_BIT: 461683e05c0SSteen Hegelund value = &kf->data.u1.value; 462683e05c0SSteen Hegelund mask = &kf->data.u1.mask; 463683e05c0SSteen Hegelund break; 464683e05c0SSteen Hegelund case VCAP_FIELD_U32: 465683e05c0SSteen Hegelund value = (const u8 *)&kf->data.u32.value; 466683e05c0SSteen Hegelund mask = (const u8 *)&kf->data.u32.mask; 467683e05c0SSteen Hegelund break; 468683e05c0SSteen Hegelund case VCAP_FIELD_U48: 469683e05c0SSteen Hegelund value = kf->data.u48.value; 470683e05c0SSteen Hegelund mask = kf->data.u48.mask; 471683e05c0SSteen Hegelund break; 472683e05c0SSteen Hegelund case VCAP_FIELD_U56: 473683e05c0SSteen Hegelund value = kf->data.u56.value; 474683e05c0SSteen Hegelund mask = kf->data.u56.mask; 475683e05c0SSteen Hegelund break; 476683e05c0SSteen Hegelund case VCAP_FIELD_U64: 477683e05c0SSteen Hegelund value = kf->data.u64.value; 478683e05c0SSteen Hegelund mask = kf->data.u64.mask; 479683e05c0SSteen Hegelund break; 480683e05c0SSteen Hegelund case VCAP_FIELD_U72: 481683e05c0SSteen Hegelund value = kf->data.u72.value; 482683e05c0SSteen Hegelund mask = kf->data.u72.mask; 483683e05c0SSteen Hegelund break; 484683e05c0SSteen Hegelund case VCAP_FIELD_U112: 485683e05c0SSteen Hegelund value = kf->data.u112.value; 486683e05c0SSteen Hegelund mask = kf->data.u112.mask; 487683e05c0SSteen Hegelund break; 488683e05c0SSteen Hegelund case VCAP_FIELD_U128: 489683e05c0SSteen Hegelund value = kf->data.u128.value; 490683e05c0SSteen Hegelund mask = kf->data.u128.mask; 491683e05c0SSteen Hegelund break; 492683e05c0SSteen Hegelund } 493683e05c0SSteen Hegelund vcap_iter_init(&iter, sw_width, tgt, rf->offset); 494683e05c0SSteen Hegelund vcap_encode_field(cache->keystream, &iter, rf->width, value); 495683e05c0SSteen Hegelund vcap_iter_init(&iter, sw_width, tgt, rf->offset); 496683e05c0SSteen Hegelund vcap_encode_field(cache->maskstream, &iter, rf->width, mask); 497683e05c0SSteen Hegelund } 498683e05c0SSteen Hegelund 499683e05c0SSteen Hegelund static void vcap_encode_keyfield_typegroups(struct vcap_control *vctrl, 500683e05c0SSteen Hegelund struct vcap_rule_internal *ri, 501683e05c0SSteen Hegelund const struct vcap_typegroup *tgt) 502683e05c0SSteen Hegelund { 503683e05c0SSteen Hegelund int sw_width = vctrl->vcaps[ri->admin->vtype].sw_width; 504683e05c0SSteen Hegelund struct vcap_cache_data *cache = &ri->admin->cache; 505683e05c0SSteen Hegelund 506683e05c0SSteen Hegelund /* Encode the typegroup bits for the key and the mask in their streams, 507683e05c0SSteen Hegelund * respecting the subword width. 508683e05c0SSteen Hegelund */ 509683e05c0SSteen Hegelund vcap_encode_typegroups(cache->keystream, sw_width, tgt, false); 510683e05c0SSteen Hegelund vcap_encode_typegroups(cache->maskstream, sw_width, tgt, true); 511683e05c0SSteen Hegelund } 512683e05c0SSteen Hegelund 51333e3a273SSteen Hegelund /* Copy data from src to dst but reverse the data in chunks of 32bits. 51433e3a273SSteen Hegelund * For example if src is 00:11:22:33:44:55 where 55 is LSB the dst will 51533e3a273SSteen Hegelund * have the value 22:33:44:55:00:11. 51633e3a273SSteen Hegelund */ 51733e3a273SSteen Hegelund static void vcap_copy_to_w32be(u8 *dst, const u8 *src, int size) 51833e3a273SSteen Hegelund { 51933e3a273SSteen Hegelund for (int idx = 0; idx < size; ++idx) { 52033e3a273SSteen Hegelund int first_byte_index = 0; 52133e3a273SSteen Hegelund int nidx; 52233e3a273SSteen Hegelund 52333e3a273SSteen Hegelund first_byte_index = size - (((idx >> 2) + 1) << 2); 52433e3a273SSteen Hegelund if (first_byte_index < 0) 52533e3a273SSteen Hegelund first_byte_index = 0; 52633e3a273SSteen Hegelund nidx = idx + first_byte_index - (idx & ~0x3); 52733e3a273SSteen Hegelund dst[nidx] = src[idx]; 52833e3a273SSteen Hegelund } 52933e3a273SSteen Hegelund } 53033e3a273SSteen Hegelund 53133e3a273SSteen Hegelund static void 53233e3a273SSteen Hegelund vcap_copy_from_client_keyfield(struct vcap_rule *rule, 53333e3a273SSteen Hegelund struct vcap_client_keyfield *dst, 53433e3a273SSteen Hegelund const struct vcap_client_keyfield *src) 53533e3a273SSteen Hegelund { 53633e3a273SSteen Hegelund struct vcap_rule_internal *ri = to_intrule(rule); 53733e3a273SSteen Hegelund const struct vcap_client_keyfield_data *sdata; 53833e3a273SSteen Hegelund struct vcap_client_keyfield_data *ddata; 53933e3a273SSteen Hegelund int size; 54033e3a273SSteen Hegelund 54133e3a273SSteen Hegelund dst->ctrl.type = src->ctrl.type; 54233e3a273SSteen Hegelund dst->ctrl.key = src->ctrl.key; 54333e3a273SSteen Hegelund INIT_LIST_HEAD(&dst->ctrl.list); 54433e3a273SSteen Hegelund sdata = &src->data; 54533e3a273SSteen Hegelund ddata = &dst->data; 54633e3a273SSteen Hegelund 54733e3a273SSteen Hegelund if (!ri->admin->w32be) { 54833e3a273SSteen Hegelund memcpy(ddata, sdata, sizeof(dst->data)); 54933e3a273SSteen Hegelund return; 55033e3a273SSteen Hegelund } 55133e3a273SSteen Hegelund 55233e3a273SSteen Hegelund size = keyfield_size_table[dst->ctrl.type] / 2; 55333e3a273SSteen Hegelund 55433e3a273SSteen Hegelund switch (dst->ctrl.type) { 55533e3a273SSteen Hegelund case VCAP_FIELD_BIT: 55633e3a273SSteen Hegelund case VCAP_FIELD_U32: 55733e3a273SSteen Hegelund memcpy(ddata, sdata, sizeof(dst->data)); 55833e3a273SSteen Hegelund break; 55933e3a273SSteen Hegelund case VCAP_FIELD_U48: 56033e3a273SSteen Hegelund vcap_copy_to_w32be(ddata->u48.value, src->data.u48.value, size); 56133e3a273SSteen Hegelund vcap_copy_to_w32be(ddata->u48.mask, src->data.u48.mask, size); 56233e3a273SSteen Hegelund break; 56333e3a273SSteen Hegelund case VCAP_FIELD_U56: 56433e3a273SSteen Hegelund vcap_copy_to_w32be(ddata->u56.value, sdata->u56.value, size); 56533e3a273SSteen Hegelund vcap_copy_to_w32be(ddata->u56.mask, sdata->u56.mask, size); 56633e3a273SSteen Hegelund break; 56733e3a273SSteen Hegelund case VCAP_FIELD_U64: 56833e3a273SSteen Hegelund vcap_copy_to_w32be(ddata->u64.value, sdata->u64.value, size); 56933e3a273SSteen Hegelund vcap_copy_to_w32be(ddata->u64.mask, sdata->u64.mask, size); 57033e3a273SSteen Hegelund break; 57133e3a273SSteen Hegelund case VCAP_FIELD_U72: 57233e3a273SSteen Hegelund vcap_copy_to_w32be(ddata->u72.value, sdata->u72.value, size); 57333e3a273SSteen Hegelund vcap_copy_to_w32be(ddata->u72.mask, sdata->u72.mask, size); 57433e3a273SSteen Hegelund break; 57533e3a273SSteen Hegelund case VCAP_FIELD_U112: 57633e3a273SSteen Hegelund vcap_copy_to_w32be(ddata->u112.value, sdata->u112.value, size); 57733e3a273SSteen Hegelund vcap_copy_to_w32be(ddata->u112.mask, sdata->u112.mask, size); 57833e3a273SSteen Hegelund break; 57933e3a273SSteen Hegelund case VCAP_FIELD_U128: 58033e3a273SSteen Hegelund vcap_copy_to_w32be(ddata->u128.value, sdata->u128.value, size); 58133e3a273SSteen Hegelund vcap_copy_to_w32be(ddata->u128.mask, sdata->u128.mask, size); 58233e3a273SSteen Hegelund break; 58333e3a273SSteen Hegelund } 58433e3a273SSteen Hegelund } 58533e3a273SSteen Hegelund 58633e3a273SSteen Hegelund static void 58733e3a273SSteen Hegelund vcap_copy_from_client_actionfield(struct vcap_rule *rule, 58833e3a273SSteen Hegelund struct vcap_client_actionfield *dst, 58933e3a273SSteen Hegelund const struct vcap_client_actionfield *src) 59033e3a273SSteen Hegelund { 59133e3a273SSteen Hegelund struct vcap_rule_internal *ri = to_intrule(rule); 59233e3a273SSteen Hegelund const struct vcap_client_actionfield_data *sdata; 59333e3a273SSteen Hegelund struct vcap_client_actionfield_data *ddata; 59433e3a273SSteen Hegelund int size; 59533e3a273SSteen Hegelund 59633e3a273SSteen Hegelund dst->ctrl.type = src->ctrl.type; 59733e3a273SSteen Hegelund dst->ctrl.action = src->ctrl.action; 59833e3a273SSteen Hegelund INIT_LIST_HEAD(&dst->ctrl.list); 59933e3a273SSteen Hegelund sdata = &src->data; 60033e3a273SSteen Hegelund ddata = &dst->data; 60133e3a273SSteen Hegelund 60233e3a273SSteen Hegelund if (!ri->admin->w32be) { 60333e3a273SSteen Hegelund memcpy(ddata, sdata, sizeof(dst->data)); 60433e3a273SSteen Hegelund return; 60533e3a273SSteen Hegelund } 60633e3a273SSteen Hegelund 60733e3a273SSteen Hegelund size = actionfield_size_table[dst->ctrl.type]; 60833e3a273SSteen Hegelund 60933e3a273SSteen Hegelund switch (dst->ctrl.type) { 61033e3a273SSteen Hegelund case VCAP_FIELD_BIT: 61133e3a273SSteen Hegelund case VCAP_FIELD_U32: 61233e3a273SSteen Hegelund memcpy(ddata, sdata, sizeof(dst->data)); 61333e3a273SSteen Hegelund break; 61433e3a273SSteen Hegelund case VCAP_FIELD_U48: 61533e3a273SSteen Hegelund vcap_copy_to_w32be(ddata->u48.value, sdata->u48.value, size); 61633e3a273SSteen Hegelund break; 61733e3a273SSteen Hegelund case VCAP_FIELD_U56: 61833e3a273SSteen Hegelund vcap_copy_to_w32be(ddata->u56.value, sdata->u56.value, size); 61933e3a273SSteen Hegelund break; 62033e3a273SSteen Hegelund case VCAP_FIELD_U64: 62133e3a273SSteen Hegelund vcap_copy_to_w32be(ddata->u64.value, sdata->u64.value, size); 62233e3a273SSteen Hegelund break; 62333e3a273SSteen Hegelund case VCAP_FIELD_U72: 62433e3a273SSteen Hegelund vcap_copy_to_w32be(ddata->u72.value, sdata->u72.value, size); 62533e3a273SSteen Hegelund break; 62633e3a273SSteen Hegelund case VCAP_FIELD_U112: 62733e3a273SSteen Hegelund vcap_copy_to_w32be(ddata->u112.value, sdata->u112.value, size); 62833e3a273SSteen Hegelund break; 62933e3a273SSteen Hegelund case VCAP_FIELD_U128: 63033e3a273SSteen Hegelund vcap_copy_to_w32be(ddata->u128.value, sdata->u128.value, size); 63133e3a273SSteen Hegelund break; 63233e3a273SSteen Hegelund } 63333e3a273SSteen Hegelund } 63433e3a273SSteen Hegelund 635683e05c0SSteen Hegelund static int vcap_encode_rule_keyset(struct vcap_rule_internal *ri) 636683e05c0SSteen Hegelund { 637683e05c0SSteen Hegelund const struct vcap_client_keyfield *ckf; 638683e05c0SSteen Hegelund const struct vcap_typegroup *tg_table; 63933e3a273SSteen Hegelund struct vcap_client_keyfield tempkf; 640683e05c0SSteen Hegelund const struct vcap_field *kf_table; 641683e05c0SSteen Hegelund int keyset_size; 642683e05c0SSteen Hegelund 643683e05c0SSteen Hegelund /* Get a valid set of fields for the specific keyset */ 644683e05c0SSteen Hegelund kf_table = vcap_keyfields(ri->vctrl, ri->admin->vtype, ri->data.keyset); 645683e05c0SSteen Hegelund if (!kf_table) { 646683e05c0SSteen Hegelund pr_err("%s:%d: no fields available for this keyset: %d\n", 647683e05c0SSteen Hegelund __func__, __LINE__, ri->data.keyset); 648683e05c0SSteen Hegelund return -EINVAL; 649683e05c0SSteen Hegelund } 650683e05c0SSteen Hegelund /* Get a valid typegroup for the specific keyset */ 651683e05c0SSteen Hegelund tg_table = vcap_keyfield_typegroup(ri->vctrl, ri->admin->vtype, 652683e05c0SSteen Hegelund ri->data.keyset); 653683e05c0SSteen Hegelund if (!tg_table) { 654683e05c0SSteen Hegelund pr_err("%s:%d: no typegroups available for this keyset: %d\n", 655683e05c0SSteen Hegelund __func__, __LINE__, ri->data.keyset); 656683e05c0SSteen Hegelund return -EINVAL; 657683e05c0SSteen Hegelund } 658683e05c0SSteen Hegelund /* Get a valid size for the specific keyset */ 659683e05c0SSteen Hegelund keyset_size = vcap_keyfield_count(ri->vctrl, ri->admin->vtype, 660683e05c0SSteen Hegelund ri->data.keyset); 661683e05c0SSteen Hegelund if (keyset_size == 0) { 662683e05c0SSteen Hegelund pr_err("%s:%d: zero field count for this keyset: %d\n", 663683e05c0SSteen Hegelund __func__, __LINE__, ri->data.keyset); 664683e05c0SSteen Hegelund return -EINVAL; 665683e05c0SSteen Hegelund } 666683e05c0SSteen Hegelund /* Iterate over the keyfields (key, mask) in the rule 667683e05c0SSteen Hegelund * and encode these bits 668683e05c0SSteen Hegelund */ 669683e05c0SSteen Hegelund if (list_empty(&ri->data.keyfields)) { 670683e05c0SSteen Hegelund pr_err("%s:%d: no keyfields in the rule\n", __func__, __LINE__); 671683e05c0SSteen Hegelund return -EINVAL; 672683e05c0SSteen Hegelund } 673683e05c0SSteen Hegelund list_for_each_entry(ckf, &ri->data.keyfields, ctrl.list) { 674683e05c0SSteen Hegelund /* Check that the client entry exists in the keyset */ 675683e05c0SSteen Hegelund if (ckf->ctrl.key >= keyset_size) { 676683e05c0SSteen Hegelund pr_err("%s:%d: key %d is not in vcap\n", 677683e05c0SSteen Hegelund __func__, __LINE__, ckf->ctrl.key); 678683e05c0SSteen Hegelund return -EINVAL; 679683e05c0SSteen Hegelund } 68033e3a273SSteen Hegelund vcap_copy_from_client_keyfield(&ri->data, &tempkf, ckf); 68133e3a273SSteen Hegelund vcap_encode_keyfield(ri, &tempkf, &kf_table[ckf->ctrl.key], 68233e3a273SSteen Hegelund tg_table); 683683e05c0SSteen Hegelund } 684683e05c0SSteen Hegelund /* Add typegroup bits to the key/mask bitstreams */ 685683e05c0SSteen Hegelund vcap_encode_keyfield_typegroups(ri->vctrl, ri, tg_table); 686683e05c0SSteen Hegelund return 0; 687683e05c0SSteen Hegelund } 688683e05c0SSteen Hegelund 689683e05c0SSteen Hegelund /* Return the list of actionfields for the actionset */ 69072d84dd6SSteen Hegelund const struct vcap_field * 691683e05c0SSteen Hegelund vcap_actionfields(struct vcap_control *vctrl, 692683e05c0SSteen Hegelund enum vcap_type vt, enum vcap_actionfield_set actionset) 693683e05c0SSteen Hegelund { 694683e05c0SSteen Hegelund /* Check that the actionset exists in the vcap actionset list */ 695683e05c0SSteen Hegelund if (actionset >= vctrl->vcaps[vt].actionfield_set_size) 696683e05c0SSteen Hegelund return NULL; 697683e05c0SSteen Hegelund return vctrl->vcaps[vt].actionfield_set_map[actionset]; 698683e05c0SSteen Hegelund } 699683e05c0SSteen Hegelund 70072d84dd6SSteen Hegelund const struct vcap_set * 7018e10490bSSteen Hegelund vcap_actionfieldset(struct vcap_control *vctrl, 7028e10490bSSteen Hegelund enum vcap_type vt, enum vcap_actionfield_set actionset) 7038e10490bSSteen Hegelund { 7048e10490bSSteen Hegelund const struct vcap_set *aset; 7058e10490bSSteen Hegelund 7068e10490bSSteen Hegelund /* Check that the actionset exists in the vcap actionset list */ 7078e10490bSSteen Hegelund if (actionset >= vctrl->vcaps[vt].actionfield_set_size) 7088e10490bSSteen Hegelund return NULL; 7098e10490bSSteen Hegelund aset = &vctrl->vcaps[vt].actionfield_set[actionset]; 7108e10490bSSteen Hegelund if (aset->sw_per_item == 0 || aset->sw_per_item > vctrl->vcaps[vt].sw_count) 7118e10490bSSteen Hegelund return NULL; 7128e10490bSSteen Hegelund return aset; 7138e10490bSSteen Hegelund } 7148e10490bSSteen Hegelund 715683e05c0SSteen Hegelund /* Return the typegroup table for the matching actionset (using subword size) */ 71672d84dd6SSteen Hegelund const struct vcap_typegroup * 717683e05c0SSteen Hegelund vcap_actionfield_typegroup(struct vcap_control *vctrl, 718683e05c0SSteen Hegelund enum vcap_type vt, enum vcap_actionfield_set actionset) 719683e05c0SSteen Hegelund { 720683e05c0SSteen Hegelund const struct vcap_set *aset = vcap_actionfieldset(vctrl, vt, actionset); 721683e05c0SSteen Hegelund 722683e05c0SSteen Hegelund /* Check that the actionset is valid */ 723683e05c0SSteen Hegelund if (!aset) 724683e05c0SSteen Hegelund return NULL; 725683e05c0SSteen Hegelund return vctrl->vcaps[vt].actionfield_set_typegroups[aset->sw_per_item]; 726683e05c0SSteen Hegelund } 727683e05c0SSteen Hegelund 728683e05c0SSteen Hegelund /* Return the number of actionfields in the actionset */ 72972d84dd6SSteen Hegelund int vcap_actionfield_count(struct vcap_control *vctrl, 730683e05c0SSteen Hegelund enum vcap_type vt, 731683e05c0SSteen Hegelund enum vcap_actionfield_set actionset) 732683e05c0SSteen Hegelund { 733683e05c0SSteen Hegelund /* Check that the actionset exists in the vcap actionset list */ 734683e05c0SSteen Hegelund if (actionset >= vctrl->vcaps[vt].actionfield_set_size) 735683e05c0SSteen Hegelund return 0; 736683e05c0SSteen Hegelund return vctrl->vcaps[vt].actionfield_set_map_size[actionset]; 737683e05c0SSteen Hegelund } 738683e05c0SSteen Hegelund 739683e05c0SSteen Hegelund static void vcap_encode_actionfield(struct vcap_rule_internal *ri, 740683e05c0SSteen Hegelund const struct vcap_client_actionfield *af, 741683e05c0SSteen Hegelund const struct vcap_field *rf, 742683e05c0SSteen Hegelund const struct vcap_typegroup *tgt) 743683e05c0SSteen Hegelund { 744683e05c0SSteen Hegelund int act_width = ri->vctrl->vcaps[ri->admin->vtype].act_width; 745683e05c0SSteen Hegelund 746683e05c0SSteen Hegelund struct vcap_cache_data *cache = &ri->admin->cache; 747683e05c0SSteen Hegelund struct vcap_stream_iter iter; 748683e05c0SSteen Hegelund const u8 *value; 749683e05c0SSteen Hegelund 750683e05c0SSteen Hegelund /* Encode the action field in the stream, respecting the subword width */ 751683e05c0SSteen Hegelund switch (af->ctrl.type) { 752683e05c0SSteen Hegelund case VCAP_FIELD_BIT: 753683e05c0SSteen Hegelund value = &af->data.u1.value; 754683e05c0SSteen Hegelund break; 755683e05c0SSteen Hegelund case VCAP_FIELD_U32: 756683e05c0SSteen Hegelund value = (const u8 *)&af->data.u32.value; 757683e05c0SSteen Hegelund break; 758683e05c0SSteen Hegelund case VCAP_FIELD_U48: 759683e05c0SSteen Hegelund value = af->data.u48.value; 760683e05c0SSteen Hegelund break; 761683e05c0SSteen Hegelund case VCAP_FIELD_U56: 762683e05c0SSteen Hegelund value = af->data.u56.value; 763683e05c0SSteen Hegelund break; 764683e05c0SSteen Hegelund case VCAP_FIELD_U64: 765683e05c0SSteen Hegelund value = af->data.u64.value; 766683e05c0SSteen Hegelund break; 767683e05c0SSteen Hegelund case VCAP_FIELD_U72: 768683e05c0SSteen Hegelund value = af->data.u72.value; 769683e05c0SSteen Hegelund break; 770683e05c0SSteen Hegelund case VCAP_FIELD_U112: 771683e05c0SSteen Hegelund value = af->data.u112.value; 772683e05c0SSteen Hegelund break; 773683e05c0SSteen Hegelund case VCAP_FIELD_U128: 774683e05c0SSteen Hegelund value = af->data.u128.value; 775683e05c0SSteen Hegelund break; 776683e05c0SSteen Hegelund } 777683e05c0SSteen Hegelund vcap_iter_init(&iter, act_width, tgt, rf->offset); 778683e05c0SSteen Hegelund vcap_encode_field(cache->actionstream, &iter, rf->width, value); 779683e05c0SSteen Hegelund } 780683e05c0SSteen Hegelund 781683e05c0SSteen Hegelund static void vcap_encode_actionfield_typegroups(struct vcap_rule_internal *ri, 782683e05c0SSteen Hegelund const struct vcap_typegroup *tgt) 783683e05c0SSteen Hegelund { 784683e05c0SSteen Hegelund int sw_width = ri->vctrl->vcaps[ri->admin->vtype].act_width; 785683e05c0SSteen Hegelund struct vcap_cache_data *cache = &ri->admin->cache; 786683e05c0SSteen Hegelund 787683e05c0SSteen Hegelund /* Encode the typegroup bits for the actionstream respecting the subword 788683e05c0SSteen Hegelund * width. 789683e05c0SSteen Hegelund */ 790683e05c0SSteen Hegelund vcap_encode_typegroups(cache->actionstream, sw_width, tgt, false); 791683e05c0SSteen Hegelund } 792683e05c0SSteen Hegelund 793683e05c0SSteen Hegelund static int vcap_encode_rule_actionset(struct vcap_rule_internal *ri) 794683e05c0SSteen Hegelund { 795683e05c0SSteen Hegelund const struct vcap_client_actionfield *caf; 796683e05c0SSteen Hegelund const struct vcap_typegroup *tg_table; 79733e3a273SSteen Hegelund struct vcap_client_actionfield tempaf; 798683e05c0SSteen Hegelund const struct vcap_field *af_table; 799683e05c0SSteen Hegelund int actionset_size; 800683e05c0SSteen Hegelund 801683e05c0SSteen Hegelund /* Get a valid set of actionset fields for the specific actionset */ 802683e05c0SSteen Hegelund af_table = vcap_actionfields(ri->vctrl, ri->admin->vtype, 803683e05c0SSteen Hegelund ri->data.actionset); 804683e05c0SSteen Hegelund if (!af_table) { 805683e05c0SSteen Hegelund pr_err("%s:%d: no fields available for this actionset: %d\n", 806683e05c0SSteen Hegelund __func__, __LINE__, ri->data.actionset); 807683e05c0SSteen Hegelund return -EINVAL; 808683e05c0SSteen Hegelund } 809683e05c0SSteen Hegelund /* Get a valid typegroup for the specific actionset */ 810683e05c0SSteen Hegelund tg_table = vcap_actionfield_typegroup(ri->vctrl, ri->admin->vtype, 811683e05c0SSteen Hegelund ri->data.actionset); 812683e05c0SSteen Hegelund if (!tg_table) { 813683e05c0SSteen Hegelund pr_err("%s:%d: no typegroups available for this actionset: %d\n", 814683e05c0SSteen Hegelund __func__, __LINE__, ri->data.actionset); 815683e05c0SSteen Hegelund return -EINVAL; 816683e05c0SSteen Hegelund } 817683e05c0SSteen Hegelund /* Get a valid actionset size for the specific actionset */ 818683e05c0SSteen Hegelund actionset_size = vcap_actionfield_count(ri->vctrl, ri->admin->vtype, 819683e05c0SSteen Hegelund ri->data.actionset); 820683e05c0SSteen Hegelund if (actionset_size == 0) { 821683e05c0SSteen Hegelund pr_err("%s:%d: zero field count for this actionset: %d\n", 822683e05c0SSteen Hegelund __func__, __LINE__, ri->data.actionset); 823683e05c0SSteen Hegelund return -EINVAL; 824683e05c0SSteen Hegelund } 825683e05c0SSteen Hegelund /* Iterate over the actionfields in the rule 826683e05c0SSteen Hegelund * and encode these bits 827683e05c0SSteen Hegelund */ 828683e05c0SSteen Hegelund if (list_empty(&ri->data.actionfields)) 829683e05c0SSteen Hegelund pr_warn("%s:%d: no actionfields in the rule\n", 830683e05c0SSteen Hegelund __func__, __LINE__); 831683e05c0SSteen Hegelund list_for_each_entry(caf, &ri->data.actionfields, ctrl.list) { 832683e05c0SSteen Hegelund /* Check that the client action exists in the actionset */ 833683e05c0SSteen Hegelund if (caf->ctrl.action >= actionset_size) { 834683e05c0SSteen Hegelund pr_err("%s:%d: action %d is not in vcap\n", 835683e05c0SSteen Hegelund __func__, __LINE__, caf->ctrl.action); 836683e05c0SSteen Hegelund return -EINVAL; 837683e05c0SSteen Hegelund } 83833e3a273SSteen Hegelund vcap_copy_from_client_actionfield(&ri->data, &tempaf, caf); 83933e3a273SSteen Hegelund vcap_encode_actionfield(ri, &tempaf, 84033e3a273SSteen Hegelund &af_table[caf->ctrl.action], tg_table); 841683e05c0SSteen Hegelund } 842683e05c0SSteen Hegelund /* Add typegroup bits to the entry bitstreams */ 843683e05c0SSteen Hegelund vcap_encode_actionfield_typegroups(ri, tg_table); 844683e05c0SSteen Hegelund return 0; 845683e05c0SSteen Hegelund } 846683e05c0SSteen Hegelund 8478e10490bSSteen Hegelund static int vcap_encode_rule(struct vcap_rule_internal *ri) 8488e10490bSSteen Hegelund { 849683e05c0SSteen Hegelund int err; 850683e05c0SSteen Hegelund 851683e05c0SSteen Hegelund err = vcap_encode_rule_keyset(ri); 852683e05c0SSteen Hegelund if (err) 853683e05c0SSteen Hegelund return err; 854683e05c0SSteen Hegelund err = vcap_encode_rule_actionset(ri); 855683e05c0SSteen Hegelund if (err) 856683e05c0SSteen Hegelund return err; 8578e10490bSSteen Hegelund return 0; 8588e10490bSSteen Hegelund } 8598e10490bSSteen Hegelund 860d4134d41SSteen Hegelund int vcap_api_check(struct vcap_control *ctrl) 8618e10490bSSteen Hegelund { 8628e10490bSSteen Hegelund if (!ctrl) { 8638e10490bSSteen Hegelund pr_err("%s:%d: vcap control is missing\n", __func__, __LINE__); 8648e10490bSSteen Hegelund return -EINVAL; 8658e10490bSSteen Hegelund } 8668e10490bSSteen Hegelund if (!ctrl->ops || !ctrl->ops->validate_keyset || 8678e10490bSSteen Hegelund !ctrl->ops->add_default_fields || !ctrl->ops->cache_erase || 8688e10490bSSteen Hegelund !ctrl->ops->cache_write || !ctrl->ops->cache_read || 8698e10490bSSteen Hegelund !ctrl->ops->init || !ctrl->ops->update || !ctrl->ops->move || 87001ef75a2SSteen Hegelund !ctrl->ops->port_info) { 8718e10490bSSteen Hegelund pr_err("%s:%d: client operations are missing\n", 8728e10490bSSteen Hegelund __func__, __LINE__); 8738e10490bSSteen Hegelund return -ENOENT; 8748e10490bSSteen Hegelund } 8758e10490bSSteen Hegelund return 0; 8768e10490bSSteen Hegelund } 8778e10490bSSteen Hegelund 8783a792156SSteen Hegelund void vcap_erase_cache(struct vcap_rule_internal *ri) 8798e10490bSSteen Hegelund { 8808e10490bSSteen Hegelund ri->vctrl->ops->cache_erase(ri->admin); 8818e10490bSSteen Hegelund } 8828e10490bSSteen Hegelund 883c9da1ac1SSteen Hegelund /* Update the keyset for the rule */ 884c9da1ac1SSteen Hegelund int vcap_set_rule_set_keyset(struct vcap_rule *rule, 885c9da1ac1SSteen Hegelund enum vcap_keyfield_set keyset) 886c9da1ac1SSteen Hegelund { 8878e10490bSSteen Hegelund struct vcap_rule_internal *ri = to_intrule(rule); 8888e10490bSSteen Hegelund const struct vcap_set *kset; 8898e10490bSSteen Hegelund int sw_width; 8908e10490bSSteen Hegelund 8918e10490bSSteen Hegelund kset = vcap_keyfieldset(ri->vctrl, ri->admin->vtype, keyset); 8928e10490bSSteen Hegelund /* Check that the keyset is valid */ 8938e10490bSSteen Hegelund if (!kset) 8948e10490bSSteen Hegelund return -EINVAL; 8958e10490bSSteen Hegelund ri->keyset_sw = kset->sw_per_item; 8968e10490bSSteen Hegelund sw_width = ri->vctrl->vcaps[ri->admin->vtype].sw_width; 8978e10490bSSteen Hegelund ri->keyset_sw_regs = DIV_ROUND_UP(sw_width, 32); 8988e10490bSSteen Hegelund ri->data.keyset = keyset; 899c9da1ac1SSteen Hegelund return 0; 900c9da1ac1SSteen Hegelund } 901c9da1ac1SSteen Hegelund EXPORT_SYMBOL_GPL(vcap_set_rule_set_keyset); 902c9da1ac1SSteen Hegelund 903c9da1ac1SSteen Hegelund /* Update the actionset for the rule */ 904c9da1ac1SSteen Hegelund int vcap_set_rule_set_actionset(struct vcap_rule *rule, 905c9da1ac1SSteen Hegelund enum vcap_actionfield_set actionset) 906c9da1ac1SSteen Hegelund { 9078e10490bSSteen Hegelund struct vcap_rule_internal *ri = to_intrule(rule); 9088e10490bSSteen Hegelund const struct vcap_set *aset; 9098e10490bSSteen Hegelund int act_width; 9108e10490bSSteen Hegelund 9118e10490bSSteen Hegelund aset = vcap_actionfieldset(ri->vctrl, ri->admin->vtype, actionset); 9128e10490bSSteen Hegelund /* Check that the actionset is valid */ 9138e10490bSSteen Hegelund if (!aset) 9148e10490bSSteen Hegelund return -EINVAL; 9158e10490bSSteen Hegelund ri->actionset_sw = aset->sw_per_item; 9168e10490bSSteen Hegelund act_width = ri->vctrl->vcaps[ri->admin->vtype].act_width; 9178e10490bSSteen Hegelund ri->actionset_sw_regs = DIV_ROUND_UP(act_width, 32); 9188e10490bSSteen Hegelund ri->data.actionset = actionset; 919c9da1ac1SSteen Hegelund return 0; 920c9da1ac1SSteen Hegelund } 921c9da1ac1SSteen Hegelund EXPORT_SYMBOL_GPL(vcap_set_rule_set_actionset); 922c9da1ac1SSteen Hegelund 923975d86acSSteen Hegelund /* Check if a rule with this id exists */ 924975d86acSSteen Hegelund static bool vcap_rule_exists(struct vcap_control *vctrl, u32 id) 925975d86acSSteen Hegelund { 926975d86acSSteen Hegelund struct vcap_rule_internal *ri; 927975d86acSSteen Hegelund struct vcap_admin *admin; 928975d86acSSteen Hegelund 929975d86acSSteen Hegelund /* Look for the rule id in all vcaps */ 930975d86acSSteen Hegelund list_for_each_entry(admin, &vctrl->list, list) 931975d86acSSteen Hegelund list_for_each_entry(ri, &admin->rules, list) 932975d86acSSteen Hegelund if (ri->data.id == id) 933975d86acSSteen Hegelund return true; 934975d86acSSteen Hegelund return false; 935975d86acSSteen Hegelund } 936975d86acSSteen Hegelund 9371972b6d9SSteen Hegelund /* Find a rule with a provided rule id return a locked vcap */ 9381972b6d9SSteen Hegelund static struct vcap_rule_internal * 9391972b6d9SSteen Hegelund vcap_get_locked_rule(struct vcap_control *vctrl, u32 id) 940c9da1ac1SSteen Hegelund { 941c9da1ac1SSteen Hegelund struct vcap_rule_internal *ri; 942c9da1ac1SSteen Hegelund struct vcap_admin *admin; 943c9da1ac1SSteen Hegelund 944c9da1ac1SSteen Hegelund /* Look for the rule id in all vcaps */ 9451972b6d9SSteen Hegelund list_for_each_entry(admin, &vctrl->list, list) { 9461972b6d9SSteen Hegelund mutex_lock(&admin->lock); 947c9da1ac1SSteen Hegelund list_for_each_entry(ri, &admin->rules, list) 948c9da1ac1SSteen Hegelund if (ri->data.id == id) 949c9da1ac1SSteen Hegelund return ri; 9501972b6d9SSteen Hegelund mutex_unlock(&admin->lock); 9511972b6d9SSteen Hegelund } 952c9da1ac1SSteen Hegelund return NULL; 953c9da1ac1SSteen Hegelund } 954c9da1ac1SSteen Hegelund 955c9da1ac1SSteen Hegelund /* Find a rule id with a provided cookie */ 956c9da1ac1SSteen Hegelund int vcap_lookup_rule_by_cookie(struct vcap_control *vctrl, u64 cookie) 957c9da1ac1SSteen Hegelund { 958c9da1ac1SSteen Hegelund struct vcap_rule_internal *ri; 959c9da1ac1SSteen Hegelund struct vcap_admin *admin; 9601972b6d9SSteen Hegelund int id = 0; 961c9da1ac1SSteen Hegelund 962c9da1ac1SSteen Hegelund /* Look for the rule id in all vcaps */ 9631972b6d9SSteen Hegelund list_for_each_entry(admin, &vctrl->list, list) { 9641972b6d9SSteen Hegelund mutex_lock(&admin->lock); 9651972b6d9SSteen Hegelund list_for_each_entry(ri, &admin->rules, list) { 9661972b6d9SSteen Hegelund if (ri->data.cookie == cookie) { 9671972b6d9SSteen Hegelund id = ri->data.id; 9681972b6d9SSteen Hegelund break; 9691972b6d9SSteen Hegelund } 9701972b6d9SSteen Hegelund } 9711972b6d9SSteen Hegelund mutex_unlock(&admin->lock); 9721972b6d9SSteen Hegelund if (id) 9731972b6d9SSteen Hegelund return id; 9741972b6d9SSteen Hegelund } 975c9da1ac1SSteen Hegelund return -ENOENT; 976c9da1ac1SSteen Hegelund } 977c9da1ac1SSteen Hegelund EXPORT_SYMBOL_GPL(vcap_lookup_rule_by_cookie); 978c9da1ac1SSteen Hegelund 979bfcb94aaSSteen Hegelund /* Get number of rules in a vcap instance lookup chain id range */ 980bfcb94aaSSteen Hegelund int vcap_admin_rule_count(struct vcap_admin *admin, int cid) 981bfcb94aaSSteen Hegelund { 982bfcb94aaSSteen Hegelund int max_cid = roundup(cid + 1, VCAP_CID_LOOKUP_SIZE); 983bfcb94aaSSteen Hegelund int min_cid = rounddown(cid, VCAP_CID_LOOKUP_SIZE); 984bfcb94aaSSteen Hegelund struct vcap_rule_internal *elem; 985bfcb94aaSSteen Hegelund int count = 0; 986bfcb94aaSSteen Hegelund 987bfcb94aaSSteen Hegelund list_for_each_entry(elem, &admin->rules, list) { 988bfcb94aaSSteen Hegelund mutex_lock(&admin->lock); 989bfcb94aaSSteen Hegelund if (elem->data.vcap_chain_id >= min_cid && 990bfcb94aaSSteen Hegelund elem->data.vcap_chain_id < max_cid) 991bfcb94aaSSteen Hegelund ++count; 992bfcb94aaSSteen Hegelund mutex_unlock(&admin->lock); 993bfcb94aaSSteen Hegelund } 994bfcb94aaSSteen Hegelund return count; 995bfcb94aaSSteen Hegelund } 996bfcb94aaSSteen Hegelund EXPORT_SYMBOL_GPL(vcap_admin_rule_count); 997bfcb94aaSSteen Hegelund 998814e7693SSteen Hegelund /* Make a copy of the rule, shallow or full */ 999814e7693SSteen Hegelund static struct vcap_rule_internal *vcap_dup_rule(struct vcap_rule_internal *ri, 1000814e7693SSteen Hegelund bool full) 10018e10490bSSteen Hegelund { 1002814e7693SSteen Hegelund struct vcap_client_actionfield *caf, *newcaf; 1003814e7693SSteen Hegelund struct vcap_client_keyfield *ckf, *newckf; 10048e10490bSSteen Hegelund struct vcap_rule_internal *duprule; 10058e10490bSSteen Hegelund 10068e10490bSSteen Hegelund /* Allocate the client part */ 10078e10490bSSteen Hegelund duprule = kzalloc(sizeof(*duprule), GFP_KERNEL); 10088e10490bSSteen Hegelund if (!duprule) 10098e10490bSSteen Hegelund return ERR_PTR(-ENOMEM); 10108e10490bSSteen Hegelund *duprule = *ri; 10118e10490bSSteen Hegelund /* Not inserted in the VCAP */ 10128e10490bSSteen Hegelund INIT_LIST_HEAD(&duprule->list); 10138e10490bSSteen Hegelund /* No elements in these lists */ 10148e10490bSSteen Hegelund INIT_LIST_HEAD(&duprule->data.keyfields); 10158e10490bSSteen Hegelund INIT_LIST_HEAD(&duprule->data.actionfields); 1016814e7693SSteen Hegelund 1017814e7693SSteen Hegelund /* A full rule copy includes keys and actions */ 1018814e7693SSteen Hegelund if (!full) 1019814e7693SSteen Hegelund return duprule; 1020814e7693SSteen Hegelund 1021814e7693SSteen Hegelund list_for_each_entry(ckf, &ri->data.keyfields, ctrl.list) { 10225e64f59aSYang Yingliang newckf = kmemdup(ckf, sizeof(*newckf), GFP_KERNEL); 1023814e7693SSteen Hegelund if (!newckf) 1024814e7693SSteen Hegelund return ERR_PTR(-ENOMEM); 1025814e7693SSteen Hegelund list_add_tail(&newckf->ctrl.list, &duprule->data.keyfields); 1026814e7693SSteen Hegelund } 1027814e7693SSteen Hegelund 1028814e7693SSteen Hegelund list_for_each_entry(caf, &ri->data.actionfields, ctrl.list) { 10295e64f59aSYang Yingliang newcaf = kmemdup(caf, sizeof(*newcaf), GFP_KERNEL); 1030814e7693SSteen Hegelund if (!newcaf) 1031814e7693SSteen Hegelund return ERR_PTR(-ENOMEM); 1032814e7693SSteen Hegelund list_add_tail(&newcaf->ctrl.list, &duprule->data.actionfields); 1033814e7693SSteen Hegelund } 1034814e7693SSteen Hegelund 10358e10490bSSteen Hegelund return duprule; 10368e10490bSSteen Hegelund } 10378e10490bSSteen Hegelund 1038610c32b2SHoratiu Vultur static void vcap_apply_width(u8 *dst, int width, int bytes) 1039610c32b2SHoratiu Vultur { 1040610c32b2SHoratiu Vultur u8 bmask; 1041610c32b2SHoratiu Vultur int idx; 1042610c32b2SHoratiu Vultur 1043610c32b2SHoratiu Vultur for (idx = 0; idx < bytes; idx++) { 1044610c32b2SHoratiu Vultur if (width > 0) 1045610c32b2SHoratiu Vultur if (width < 8) 1046610c32b2SHoratiu Vultur bmask = (1 << width) - 1; 1047610c32b2SHoratiu Vultur else 1048610c32b2SHoratiu Vultur bmask = ~0; 1049610c32b2SHoratiu Vultur else 1050610c32b2SHoratiu Vultur bmask = 0; 1051610c32b2SHoratiu Vultur dst[idx] &= bmask; 1052610c32b2SHoratiu Vultur width -= 8; 1053610c32b2SHoratiu Vultur } 1054610c32b2SHoratiu Vultur } 1055610c32b2SHoratiu Vultur 1056610c32b2SHoratiu Vultur static void vcap_copy_from_w32be(u8 *dst, u8 *src, int size, int width) 1057610c32b2SHoratiu Vultur { 1058610c32b2SHoratiu Vultur int idx, ridx, wstart, nidx; 1059610c32b2SHoratiu Vultur int tail_bytes = (((size + 4) >> 2) << 2) - size; 1060610c32b2SHoratiu Vultur 1061610c32b2SHoratiu Vultur for (idx = 0, ridx = size - 1; idx < size; ++idx, --ridx) { 1062610c32b2SHoratiu Vultur wstart = (idx >> 2) << 2; 1063610c32b2SHoratiu Vultur nidx = wstart + 3 - (idx & 0x3); 1064610c32b2SHoratiu Vultur if (nidx >= size) 1065610c32b2SHoratiu Vultur nidx -= tail_bytes; 1066610c32b2SHoratiu Vultur dst[nidx] = src[ridx]; 1067610c32b2SHoratiu Vultur } 1068610c32b2SHoratiu Vultur 1069610c32b2SHoratiu Vultur vcap_apply_width(dst, width, size); 1070610c32b2SHoratiu Vultur } 1071610c32b2SHoratiu Vultur 1072610c32b2SHoratiu Vultur static void vcap_copy_action_bit_field(struct vcap_u1_action *field, u8 *value) 1073610c32b2SHoratiu Vultur { 1074610c32b2SHoratiu Vultur field->value = (*value) & 0x1; 1075610c32b2SHoratiu Vultur } 1076610c32b2SHoratiu Vultur 1077610c32b2SHoratiu Vultur static void vcap_copy_limited_actionfield(u8 *dstvalue, u8 *srcvalue, 1078610c32b2SHoratiu Vultur int width, int bytes) 1079610c32b2SHoratiu Vultur { 1080610c32b2SHoratiu Vultur memcpy(dstvalue, srcvalue, bytes); 1081610c32b2SHoratiu Vultur vcap_apply_width(dstvalue, width, bytes); 1082610c32b2SHoratiu Vultur } 1083610c32b2SHoratiu Vultur 1084610c32b2SHoratiu Vultur static void vcap_copy_to_client_actionfield(struct vcap_rule_internal *ri, 1085610c32b2SHoratiu Vultur struct vcap_client_actionfield *field, 1086610c32b2SHoratiu Vultur u8 *value, u16 width) 1087610c32b2SHoratiu Vultur { 1088610c32b2SHoratiu Vultur int field_size = actionfield_size_table[field->ctrl.type]; 1089610c32b2SHoratiu Vultur 1090610c32b2SHoratiu Vultur if (ri->admin->w32be) { 1091610c32b2SHoratiu Vultur switch (field->ctrl.type) { 1092610c32b2SHoratiu Vultur case VCAP_FIELD_BIT: 1093610c32b2SHoratiu Vultur vcap_copy_action_bit_field(&field->data.u1, value); 1094610c32b2SHoratiu Vultur break; 1095610c32b2SHoratiu Vultur case VCAP_FIELD_U32: 1096610c32b2SHoratiu Vultur vcap_copy_limited_actionfield((u8 *)&field->data.u32.value, 1097610c32b2SHoratiu Vultur value, 1098610c32b2SHoratiu Vultur width, field_size); 1099610c32b2SHoratiu Vultur break; 1100610c32b2SHoratiu Vultur case VCAP_FIELD_U48: 1101610c32b2SHoratiu Vultur vcap_copy_from_w32be(field->data.u48.value, value, 1102610c32b2SHoratiu Vultur field_size, width); 1103610c32b2SHoratiu Vultur break; 1104610c32b2SHoratiu Vultur case VCAP_FIELD_U56: 1105610c32b2SHoratiu Vultur vcap_copy_from_w32be(field->data.u56.value, value, 1106610c32b2SHoratiu Vultur field_size, width); 1107610c32b2SHoratiu Vultur break; 1108610c32b2SHoratiu Vultur case VCAP_FIELD_U64: 1109610c32b2SHoratiu Vultur vcap_copy_from_w32be(field->data.u64.value, value, 1110610c32b2SHoratiu Vultur field_size, width); 1111610c32b2SHoratiu Vultur break; 1112610c32b2SHoratiu Vultur case VCAP_FIELD_U72: 1113610c32b2SHoratiu Vultur vcap_copy_from_w32be(field->data.u72.value, value, 1114610c32b2SHoratiu Vultur field_size, width); 1115610c32b2SHoratiu Vultur break; 1116610c32b2SHoratiu Vultur case VCAP_FIELD_U112: 1117610c32b2SHoratiu Vultur vcap_copy_from_w32be(field->data.u112.value, value, 1118610c32b2SHoratiu Vultur field_size, width); 1119610c32b2SHoratiu Vultur break; 1120610c32b2SHoratiu Vultur case VCAP_FIELD_U128: 1121610c32b2SHoratiu Vultur vcap_copy_from_w32be(field->data.u128.value, value, 1122610c32b2SHoratiu Vultur field_size, width); 1123610c32b2SHoratiu Vultur break; 1124*c515a444SAnup Sharma } 1125610c32b2SHoratiu Vultur } else { 1126610c32b2SHoratiu Vultur switch (field->ctrl.type) { 1127610c32b2SHoratiu Vultur case VCAP_FIELD_BIT: 1128610c32b2SHoratiu Vultur vcap_copy_action_bit_field(&field->data.u1, value); 1129610c32b2SHoratiu Vultur break; 1130610c32b2SHoratiu Vultur case VCAP_FIELD_U32: 1131610c32b2SHoratiu Vultur vcap_copy_limited_actionfield((u8 *)&field->data.u32.value, 1132610c32b2SHoratiu Vultur value, 1133610c32b2SHoratiu Vultur width, field_size); 1134610c32b2SHoratiu Vultur break; 1135610c32b2SHoratiu Vultur case VCAP_FIELD_U48: 1136610c32b2SHoratiu Vultur vcap_copy_limited_actionfield(field->data.u48.value, 1137610c32b2SHoratiu Vultur value, 1138610c32b2SHoratiu Vultur width, field_size); 1139610c32b2SHoratiu Vultur break; 1140610c32b2SHoratiu Vultur case VCAP_FIELD_U56: 1141610c32b2SHoratiu Vultur vcap_copy_limited_actionfield(field->data.u56.value, 1142610c32b2SHoratiu Vultur value, 1143610c32b2SHoratiu Vultur width, field_size); 1144610c32b2SHoratiu Vultur break; 1145610c32b2SHoratiu Vultur case VCAP_FIELD_U64: 1146610c32b2SHoratiu Vultur vcap_copy_limited_actionfield(field->data.u64.value, 1147610c32b2SHoratiu Vultur value, 1148610c32b2SHoratiu Vultur width, field_size); 1149610c32b2SHoratiu Vultur break; 1150610c32b2SHoratiu Vultur case VCAP_FIELD_U72: 1151610c32b2SHoratiu Vultur vcap_copy_limited_actionfield(field->data.u72.value, 1152610c32b2SHoratiu Vultur value, 1153610c32b2SHoratiu Vultur width, field_size); 1154610c32b2SHoratiu Vultur break; 1155610c32b2SHoratiu Vultur case VCAP_FIELD_U112: 1156610c32b2SHoratiu Vultur vcap_copy_limited_actionfield(field->data.u112.value, 1157610c32b2SHoratiu Vultur value, 1158610c32b2SHoratiu Vultur width, field_size); 1159610c32b2SHoratiu Vultur break; 1160610c32b2SHoratiu Vultur case VCAP_FIELD_U128: 1161610c32b2SHoratiu Vultur vcap_copy_limited_actionfield(field->data.u128.value, 1162610c32b2SHoratiu Vultur value, 1163610c32b2SHoratiu Vultur width, field_size); 1164610c32b2SHoratiu Vultur break; 1165*c515a444SAnup Sharma } 1166610c32b2SHoratiu Vultur } 1167610c32b2SHoratiu Vultur } 1168610c32b2SHoratiu Vultur 1169610c32b2SHoratiu Vultur static void vcap_copy_key_bit_field(struct vcap_u1_key *field, 1170610c32b2SHoratiu Vultur u8 *value, u8 *mask) 1171610c32b2SHoratiu Vultur { 1172610c32b2SHoratiu Vultur field->value = (*value) & 0x1; 1173610c32b2SHoratiu Vultur field->mask = (*mask) & 0x1; 1174610c32b2SHoratiu Vultur } 1175610c32b2SHoratiu Vultur 1176610c32b2SHoratiu Vultur static void vcap_copy_limited_keyfield(u8 *dstvalue, u8 *dstmask, 1177610c32b2SHoratiu Vultur u8 *srcvalue, u8 *srcmask, 1178610c32b2SHoratiu Vultur int width, int bytes) 1179610c32b2SHoratiu Vultur { 1180610c32b2SHoratiu Vultur memcpy(dstvalue, srcvalue, bytes); 1181610c32b2SHoratiu Vultur vcap_apply_width(dstvalue, width, bytes); 1182610c32b2SHoratiu Vultur memcpy(dstmask, srcmask, bytes); 1183610c32b2SHoratiu Vultur vcap_apply_width(dstmask, width, bytes); 1184610c32b2SHoratiu Vultur } 1185610c32b2SHoratiu Vultur 1186610c32b2SHoratiu Vultur static void vcap_copy_to_client_keyfield(struct vcap_rule_internal *ri, 1187610c32b2SHoratiu Vultur struct vcap_client_keyfield *field, 1188610c32b2SHoratiu Vultur u8 *value, u8 *mask, u16 width) 1189610c32b2SHoratiu Vultur { 1190610c32b2SHoratiu Vultur int field_size = keyfield_size_table[field->ctrl.type] / 2; 1191610c32b2SHoratiu Vultur 1192610c32b2SHoratiu Vultur if (ri->admin->w32be) { 1193610c32b2SHoratiu Vultur switch (field->ctrl.type) { 1194610c32b2SHoratiu Vultur case VCAP_FIELD_BIT: 1195610c32b2SHoratiu Vultur vcap_copy_key_bit_field(&field->data.u1, value, mask); 1196610c32b2SHoratiu Vultur break; 1197610c32b2SHoratiu Vultur case VCAP_FIELD_U32: 1198610c32b2SHoratiu Vultur vcap_copy_limited_keyfield((u8 *)&field->data.u32.value, 1199610c32b2SHoratiu Vultur (u8 *)&field->data.u32.mask, 1200610c32b2SHoratiu Vultur value, mask, 1201610c32b2SHoratiu Vultur width, field_size); 1202610c32b2SHoratiu Vultur break; 1203610c32b2SHoratiu Vultur case VCAP_FIELD_U48: 1204610c32b2SHoratiu Vultur vcap_copy_from_w32be(field->data.u48.value, value, 1205610c32b2SHoratiu Vultur field_size, width); 1206610c32b2SHoratiu Vultur vcap_copy_from_w32be(field->data.u48.mask, mask, 1207610c32b2SHoratiu Vultur field_size, width); 1208610c32b2SHoratiu Vultur break; 1209610c32b2SHoratiu Vultur case VCAP_FIELD_U56: 1210610c32b2SHoratiu Vultur vcap_copy_from_w32be(field->data.u56.value, value, 1211610c32b2SHoratiu Vultur field_size, width); 1212610c32b2SHoratiu Vultur vcap_copy_from_w32be(field->data.u56.mask, mask, 1213610c32b2SHoratiu Vultur field_size, width); 1214610c32b2SHoratiu Vultur break; 1215610c32b2SHoratiu Vultur case VCAP_FIELD_U64: 1216610c32b2SHoratiu Vultur vcap_copy_from_w32be(field->data.u64.value, value, 1217610c32b2SHoratiu Vultur field_size, width); 1218610c32b2SHoratiu Vultur vcap_copy_from_w32be(field->data.u64.mask, mask, 1219610c32b2SHoratiu Vultur field_size, width); 1220610c32b2SHoratiu Vultur break; 1221610c32b2SHoratiu Vultur case VCAP_FIELD_U72: 1222610c32b2SHoratiu Vultur vcap_copy_from_w32be(field->data.u72.value, value, 1223610c32b2SHoratiu Vultur field_size, width); 1224610c32b2SHoratiu Vultur vcap_copy_from_w32be(field->data.u72.mask, mask, 1225610c32b2SHoratiu Vultur field_size, width); 1226610c32b2SHoratiu Vultur break; 1227610c32b2SHoratiu Vultur case VCAP_FIELD_U112: 1228610c32b2SHoratiu Vultur vcap_copy_from_w32be(field->data.u112.value, value, 1229610c32b2SHoratiu Vultur field_size, width); 1230610c32b2SHoratiu Vultur vcap_copy_from_w32be(field->data.u112.mask, mask, 1231610c32b2SHoratiu Vultur field_size, width); 1232610c32b2SHoratiu Vultur break; 1233610c32b2SHoratiu Vultur case VCAP_FIELD_U128: 1234610c32b2SHoratiu Vultur vcap_copy_from_w32be(field->data.u128.value, value, 1235610c32b2SHoratiu Vultur field_size, width); 1236610c32b2SHoratiu Vultur vcap_copy_from_w32be(field->data.u128.mask, mask, 1237610c32b2SHoratiu Vultur field_size, width); 1238610c32b2SHoratiu Vultur break; 1239*c515a444SAnup Sharma } 1240610c32b2SHoratiu Vultur } else { 1241610c32b2SHoratiu Vultur switch (field->ctrl.type) { 1242610c32b2SHoratiu Vultur case VCAP_FIELD_BIT: 1243610c32b2SHoratiu Vultur vcap_copy_key_bit_field(&field->data.u1, value, mask); 1244610c32b2SHoratiu Vultur break; 1245610c32b2SHoratiu Vultur case VCAP_FIELD_U32: 1246610c32b2SHoratiu Vultur vcap_copy_limited_keyfield((u8 *)&field->data.u32.value, 1247610c32b2SHoratiu Vultur (u8 *)&field->data.u32.mask, 1248610c32b2SHoratiu Vultur value, mask, 1249610c32b2SHoratiu Vultur width, field_size); 1250610c32b2SHoratiu Vultur break; 1251610c32b2SHoratiu Vultur case VCAP_FIELD_U48: 1252610c32b2SHoratiu Vultur vcap_copy_limited_keyfield(field->data.u48.value, 1253610c32b2SHoratiu Vultur field->data.u48.mask, 1254610c32b2SHoratiu Vultur value, mask, 1255610c32b2SHoratiu Vultur width, field_size); 1256610c32b2SHoratiu Vultur break; 1257610c32b2SHoratiu Vultur case VCAP_FIELD_U56: 1258610c32b2SHoratiu Vultur vcap_copy_limited_keyfield(field->data.u56.value, 1259610c32b2SHoratiu Vultur field->data.u56.mask, 1260610c32b2SHoratiu Vultur value, mask, 1261610c32b2SHoratiu Vultur width, field_size); 1262610c32b2SHoratiu Vultur break; 1263610c32b2SHoratiu Vultur case VCAP_FIELD_U64: 1264610c32b2SHoratiu Vultur vcap_copy_limited_keyfield(field->data.u64.value, 1265610c32b2SHoratiu Vultur field->data.u64.mask, 1266610c32b2SHoratiu Vultur value, mask, 1267610c32b2SHoratiu Vultur width, field_size); 1268610c32b2SHoratiu Vultur break; 1269610c32b2SHoratiu Vultur case VCAP_FIELD_U72: 1270610c32b2SHoratiu Vultur vcap_copy_limited_keyfield(field->data.u72.value, 1271610c32b2SHoratiu Vultur field->data.u72.mask, 1272610c32b2SHoratiu Vultur value, mask, 1273610c32b2SHoratiu Vultur width, field_size); 1274610c32b2SHoratiu Vultur break; 1275610c32b2SHoratiu Vultur case VCAP_FIELD_U112: 1276610c32b2SHoratiu Vultur vcap_copy_limited_keyfield(field->data.u112.value, 1277610c32b2SHoratiu Vultur field->data.u112.mask, 1278610c32b2SHoratiu Vultur value, mask, 1279610c32b2SHoratiu Vultur width, field_size); 1280610c32b2SHoratiu Vultur break; 1281610c32b2SHoratiu Vultur case VCAP_FIELD_U128: 1282610c32b2SHoratiu Vultur vcap_copy_limited_keyfield(field->data.u128.value, 1283610c32b2SHoratiu Vultur field->data.u128.mask, 1284610c32b2SHoratiu Vultur value, mask, 1285610c32b2SHoratiu Vultur width, field_size); 1286610c32b2SHoratiu Vultur break; 1287*c515a444SAnup Sharma } 1288610c32b2SHoratiu Vultur } 1289610c32b2SHoratiu Vultur } 1290610c32b2SHoratiu Vultur 1291610c32b2SHoratiu Vultur static void vcap_rule_alloc_keyfield(struct vcap_rule_internal *ri, 1292610c32b2SHoratiu Vultur const struct vcap_field *keyfield, 1293610c32b2SHoratiu Vultur enum vcap_key_field key, 1294610c32b2SHoratiu Vultur u8 *value, u8 *mask) 1295610c32b2SHoratiu Vultur { 1296610c32b2SHoratiu Vultur struct vcap_client_keyfield *field; 1297610c32b2SHoratiu Vultur 1298610c32b2SHoratiu Vultur field = kzalloc(sizeof(*field), GFP_KERNEL); 1299610c32b2SHoratiu Vultur if (!field) 1300610c32b2SHoratiu Vultur return; 1301610c32b2SHoratiu Vultur INIT_LIST_HEAD(&field->ctrl.list); 1302610c32b2SHoratiu Vultur field->ctrl.key = key; 1303610c32b2SHoratiu Vultur field->ctrl.type = keyfield->type; 1304610c32b2SHoratiu Vultur vcap_copy_to_client_keyfield(ri, field, value, mask, keyfield->width); 1305610c32b2SHoratiu Vultur list_add_tail(&field->ctrl.list, &ri->data.keyfields); 1306610c32b2SHoratiu Vultur } 1307610c32b2SHoratiu Vultur 1308610c32b2SHoratiu Vultur /* Read key data from a VCAP address and discover if there is a rule keyset 1309610c32b2SHoratiu Vultur * here 1310610c32b2SHoratiu Vultur */ 1311610c32b2SHoratiu Vultur static bool 1312610c32b2SHoratiu Vultur vcap_verify_actionstream_actionset(struct vcap_control *vctrl, 1313610c32b2SHoratiu Vultur enum vcap_type vt, 1314610c32b2SHoratiu Vultur u32 *actionstream, 1315610c32b2SHoratiu Vultur enum vcap_actionfield_set actionset) 1316610c32b2SHoratiu Vultur { 1317610c32b2SHoratiu Vultur const struct vcap_typegroup *tgt; 1318610c32b2SHoratiu Vultur const struct vcap_field *fields; 1319610c32b2SHoratiu Vultur const struct vcap_set *info; 1320610c32b2SHoratiu Vultur 1321610c32b2SHoratiu Vultur if (vcap_actionfield_count(vctrl, vt, actionset) == 0) 1322610c32b2SHoratiu Vultur return false; 1323610c32b2SHoratiu Vultur 1324610c32b2SHoratiu Vultur info = vcap_actionfieldset(vctrl, vt, actionset); 1325610c32b2SHoratiu Vultur /* Check that the actionset is valid */ 1326610c32b2SHoratiu Vultur if (!info) 1327610c32b2SHoratiu Vultur return false; 1328610c32b2SHoratiu Vultur 1329610c32b2SHoratiu Vultur /* a type_id of value -1 means that there is no type field */ 1330610c32b2SHoratiu Vultur if (info->type_id == (u8)-1) 1331610c32b2SHoratiu Vultur return true; 1332610c32b2SHoratiu Vultur 1333610c32b2SHoratiu Vultur /* Get a valid typegroup for the specific actionset */ 1334610c32b2SHoratiu Vultur tgt = vcap_actionfield_typegroup(vctrl, vt, actionset); 1335610c32b2SHoratiu Vultur if (!tgt) 1336610c32b2SHoratiu Vultur return false; 1337610c32b2SHoratiu Vultur 1338610c32b2SHoratiu Vultur fields = vcap_actionfields(vctrl, vt, actionset); 1339610c32b2SHoratiu Vultur if (!fields) 1340610c32b2SHoratiu Vultur return false; 1341610c32b2SHoratiu Vultur 1342610c32b2SHoratiu Vultur /* Later this will be expanded with a check of the type id */ 1343610c32b2SHoratiu Vultur return true; 1344610c32b2SHoratiu Vultur } 1345610c32b2SHoratiu Vultur 1346610c32b2SHoratiu Vultur /* Find the subword width of the action typegroup that matches the stream data 1347610c32b2SHoratiu Vultur */ 1348610c32b2SHoratiu Vultur static int vcap_find_actionstream_typegroup_sw(struct vcap_control *vctrl, 1349610c32b2SHoratiu Vultur enum vcap_type vt, u32 *stream, 1350610c32b2SHoratiu Vultur int sw_max) 1351610c32b2SHoratiu Vultur { 1352610c32b2SHoratiu Vultur const struct vcap_typegroup **tgt; 1353610c32b2SHoratiu Vultur int sw_idx, res; 1354610c32b2SHoratiu Vultur 1355610c32b2SHoratiu Vultur tgt = vctrl->vcaps[vt].actionfield_set_typegroups; 1356610c32b2SHoratiu Vultur /* Try the longest subword match first */ 1357610c32b2SHoratiu Vultur for (sw_idx = vctrl->vcaps[vt].sw_count; sw_idx >= 0; sw_idx--) { 1358610c32b2SHoratiu Vultur if (!tgt[sw_idx]) 1359610c32b2SHoratiu Vultur continue; 1360610c32b2SHoratiu Vultur res = vcap_verify_typegroups(stream, vctrl->vcaps[vt].act_width, 1361610c32b2SHoratiu Vultur tgt[sw_idx], false, sw_max); 1362610c32b2SHoratiu Vultur if (res == 0) 1363610c32b2SHoratiu Vultur return sw_idx; 1364610c32b2SHoratiu Vultur } 1365610c32b2SHoratiu Vultur return -EINVAL; 1366610c32b2SHoratiu Vultur } 1367610c32b2SHoratiu Vultur 1368610c32b2SHoratiu Vultur /* Verify that the typegroup information, subword count, actionset and type id 1369610c32b2SHoratiu Vultur * are in sync and correct, return the actionset 1370610c32b2SHoratiu Vultur */ 1371610c32b2SHoratiu Vultur static enum vcap_actionfield_set 1372610c32b2SHoratiu Vultur vcap_find_actionstream_actionset(struct vcap_control *vctrl, 1373610c32b2SHoratiu Vultur enum vcap_type vt, 1374610c32b2SHoratiu Vultur u32 *stream, 1375610c32b2SHoratiu Vultur int sw_max) 1376610c32b2SHoratiu Vultur { 1377610c32b2SHoratiu Vultur const struct vcap_set *actionfield_set; 1378610c32b2SHoratiu Vultur int sw_count, idx; 1379610c32b2SHoratiu Vultur bool res; 1380610c32b2SHoratiu Vultur 1381610c32b2SHoratiu Vultur sw_count = vcap_find_actionstream_typegroup_sw(vctrl, vt, stream, 1382610c32b2SHoratiu Vultur sw_max); 1383610c32b2SHoratiu Vultur if (sw_count < 0) 1384610c32b2SHoratiu Vultur return sw_count; 1385610c32b2SHoratiu Vultur 1386610c32b2SHoratiu Vultur actionfield_set = vctrl->vcaps[vt].actionfield_set; 1387610c32b2SHoratiu Vultur for (idx = 0; idx < vctrl->vcaps[vt].actionfield_set_size; ++idx) { 1388610c32b2SHoratiu Vultur if (actionfield_set[idx].sw_per_item != sw_count) 1389610c32b2SHoratiu Vultur continue; 1390610c32b2SHoratiu Vultur 1391610c32b2SHoratiu Vultur res = vcap_verify_actionstream_actionset(vctrl, vt, 1392610c32b2SHoratiu Vultur stream, idx); 1393610c32b2SHoratiu Vultur if (res) 1394610c32b2SHoratiu Vultur return idx; 1395610c32b2SHoratiu Vultur } 1396610c32b2SHoratiu Vultur return -EINVAL; 1397610c32b2SHoratiu Vultur } 1398610c32b2SHoratiu Vultur 1399610c32b2SHoratiu Vultur /* Store action value in an element in a list for the client */ 1400610c32b2SHoratiu Vultur static void vcap_rule_alloc_actionfield(struct vcap_rule_internal *ri, 1401610c32b2SHoratiu Vultur const struct vcap_field *actionfield, 1402610c32b2SHoratiu Vultur enum vcap_action_field action, 1403610c32b2SHoratiu Vultur u8 *value) 1404610c32b2SHoratiu Vultur { 1405610c32b2SHoratiu Vultur struct vcap_client_actionfield *field; 1406610c32b2SHoratiu Vultur 1407610c32b2SHoratiu Vultur field = kzalloc(sizeof(*field), GFP_KERNEL); 1408610c32b2SHoratiu Vultur if (!field) 1409610c32b2SHoratiu Vultur return; 1410610c32b2SHoratiu Vultur INIT_LIST_HEAD(&field->ctrl.list); 1411610c32b2SHoratiu Vultur field->ctrl.action = action; 1412610c32b2SHoratiu Vultur field->ctrl.type = actionfield->type; 1413610c32b2SHoratiu Vultur vcap_copy_to_client_actionfield(ri, field, value, actionfield->width); 1414610c32b2SHoratiu Vultur list_add_tail(&field->ctrl.list, &ri->data.actionfields); 1415610c32b2SHoratiu Vultur } 1416610c32b2SHoratiu Vultur 1417610c32b2SHoratiu Vultur static int vcap_decode_actionset(struct vcap_rule_internal *ri) 1418610c32b2SHoratiu Vultur { 1419610c32b2SHoratiu Vultur struct vcap_control *vctrl = ri->vctrl; 1420610c32b2SHoratiu Vultur struct vcap_admin *admin = ri->admin; 1421610c32b2SHoratiu Vultur const struct vcap_field *actionfield; 1422610c32b2SHoratiu Vultur enum vcap_actionfield_set actionset; 1423610c32b2SHoratiu Vultur enum vcap_type vt = admin->vtype; 1424610c32b2SHoratiu Vultur const struct vcap_typegroup *tgt; 1425610c32b2SHoratiu Vultur struct vcap_stream_iter iter; 1426610c32b2SHoratiu Vultur int idx, res, actfield_count; 1427610c32b2SHoratiu Vultur u32 *actstream; 1428610c32b2SHoratiu Vultur u8 value[16]; 1429610c32b2SHoratiu Vultur 1430610c32b2SHoratiu Vultur actstream = admin->cache.actionstream; 1431610c32b2SHoratiu Vultur res = vcap_find_actionstream_actionset(vctrl, vt, actstream, 0); 1432610c32b2SHoratiu Vultur if (res < 0) { 1433610c32b2SHoratiu Vultur pr_err("%s:%d: could not find valid actionset: %d\n", 1434610c32b2SHoratiu Vultur __func__, __LINE__, res); 1435610c32b2SHoratiu Vultur return -EINVAL; 1436610c32b2SHoratiu Vultur } 1437610c32b2SHoratiu Vultur actionset = res; 1438610c32b2SHoratiu Vultur actfield_count = vcap_actionfield_count(vctrl, vt, actionset); 1439610c32b2SHoratiu Vultur actionfield = vcap_actionfields(vctrl, vt, actionset); 1440610c32b2SHoratiu Vultur tgt = vcap_actionfield_typegroup(vctrl, vt, actionset); 1441610c32b2SHoratiu Vultur /* Start decoding the stream */ 1442610c32b2SHoratiu Vultur for (idx = 0; idx < actfield_count; ++idx) { 1443610c32b2SHoratiu Vultur if (actionfield[idx].width <= 0) 1444610c32b2SHoratiu Vultur continue; 1445610c32b2SHoratiu Vultur /* Get the action */ 1446610c32b2SHoratiu Vultur memset(value, 0, DIV_ROUND_UP(actionfield[idx].width, 8)); 1447610c32b2SHoratiu Vultur vcap_iter_init(&iter, vctrl->vcaps[vt].act_width, tgt, 1448610c32b2SHoratiu Vultur actionfield[idx].offset); 1449610c32b2SHoratiu Vultur vcap_decode_field(actstream, &iter, actionfield[idx].width, 1450610c32b2SHoratiu Vultur value); 1451610c32b2SHoratiu Vultur /* Skip if no bits are set */ 1452610c32b2SHoratiu Vultur if (vcap_bitarray_zero(actionfield[idx].width, value)) 1453610c32b2SHoratiu Vultur continue; 1454610c32b2SHoratiu Vultur vcap_rule_alloc_actionfield(ri, &actionfield[idx], idx, value); 1455610c32b2SHoratiu Vultur /* Later the action id will also be checked */ 1456610c32b2SHoratiu Vultur } 1457610c32b2SHoratiu Vultur return vcap_set_rule_set_actionset((struct vcap_rule *)ri, actionset); 1458610c32b2SHoratiu Vultur } 1459610c32b2SHoratiu Vultur 1460610c32b2SHoratiu Vultur static int vcap_decode_keyset(struct vcap_rule_internal *ri) 1461610c32b2SHoratiu Vultur { 1462610c32b2SHoratiu Vultur struct vcap_control *vctrl = ri->vctrl; 1463610c32b2SHoratiu Vultur struct vcap_stream_iter kiter, miter; 1464610c32b2SHoratiu Vultur struct vcap_admin *admin = ri->admin; 1465610c32b2SHoratiu Vultur enum vcap_keyfield_set keysets[10]; 1466610c32b2SHoratiu Vultur const struct vcap_field *keyfield; 1467610c32b2SHoratiu Vultur enum vcap_type vt = admin->vtype; 1468610c32b2SHoratiu Vultur const struct vcap_typegroup *tgt; 1469610c32b2SHoratiu Vultur struct vcap_keyset_list matches; 1470610c32b2SHoratiu Vultur enum vcap_keyfield_set keyset; 1471610c32b2SHoratiu Vultur int idx, res, keyfield_count; 1472610c32b2SHoratiu Vultur u32 *maskstream; 1473610c32b2SHoratiu Vultur u32 *keystream; 1474610c32b2SHoratiu Vultur u8 value[16]; 1475610c32b2SHoratiu Vultur u8 mask[16]; 1476610c32b2SHoratiu Vultur 1477610c32b2SHoratiu Vultur keystream = admin->cache.keystream; 1478610c32b2SHoratiu Vultur maskstream = admin->cache.maskstream; 1479610c32b2SHoratiu Vultur matches.keysets = keysets; 1480610c32b2SHoratiu Vultur matches.cnt = 0; 1481610c32b2SHoratiu Vultur matches.max = ARRAY_SIZE(keysets); 1482610c32b2SHoratiu Vultur res = vcap_find_keystream_keysets(vctrl, vt, keystream, maskstream, 1483610c32b2SHoratiu Vultur false, 0, &matches); 1484610c32b2SHoratiu Vultur if (res < 0) { 1485610c32b2SHoratiu Vultur pr_err("%s:%d: could not find valid keysets: %d\n", 1486610c32b2SHoratiu Vultur __func__, __LINE__, res); 1487610c32b2SHoratiu Vultur return -EINVAL; 1488610c32b2SHoratiu Vultur } 1489610c32b2SHoratiu Vultur keyset = matches.keysets[0]; 1490610c32b2SHoratiu Vultur keyfield_count = vcap_keyfield_count(vctrl, vt, keyset); 1491610c32b2SHoratiu Vultur keyfield = vcap_keyfields(vctrl, vt, keyset); 1492610c32b2SHoratiu Vultur tgt = vcap_keyfield_typegroup(vctrl, vt, keyset); 1493610c32b2SHoratiu Vultur /* Start decoding the streams */ 1494610c32b2SHoratiu Vultur for (idx = 0; idx < keyfield_count; ++idx) { 1495610c32b2SHoratiu Vultur if (keyfield[idx].width <= 0) 1496610c32b2SHoratiu Vultur continue; 1497610c32b2SHoratiu Vultur /* First get the mask */ 1498610c32b2SHoratiu Vultur memset(mask, 0, DIV_ROUND_UP(keyfield[idx].width, 8)); 1499610c32b2SHoratiu Vultur vcap_iter_init(&miter, vctrl->vcaps[vt].sw_width, tgt, 1500610c32b2SHoratiu Vultur keyfield[idx].offset); 1501610c32b2SHoratiu Vultur vcap_decode_field(maskstream, &miter, keyfield[idx].width, 1502610c32b2SHoratiu Vultur mask); 1503610c32b2SHoratiu Vultur /* Skip if no mask bits are set */ 1504610c32b2SHoratiu Vultur if (vcap_bitarray_zero(keyfield[idx].width, mask)) 1505610c32b2SHoratiu Vultur continue; 1506610c32b2SHoratiu Vultur /* Get the key */ 1507610c32b2SHoratiu Vultur memset(value, 0, DIV_ROUND_UP(keyfield[idx].width, 8)); 1508610c32b2SHoratiu Vultur vcap_iter_init(&kiter, vctrl->vcaps[vt].sw_width, tgt, 1509610c32b2SHoratiu Vultur keyfield[idx].offset); 1510610c32b2SHoratiu Vultur vcap_decode_field(keystream, &kiter, keyfield[idx].width, 1511610c32b2SHoratiu Vultur value); 1512610c32b2SHoratiu Vultur vcap_rule_alloc_keyfield(ri, &keyfield[idx], idx, value, mask); 1513610c32b2SHoratiu Vultur } 1514610c32b2SHoratiu Vultur return vcap_set_rule_set_keyset((struct vcap_rule *)ri, keyset); 1515610c32b2SHoratiu Vultur } 1516610c32b2SHoratiu Vultur 1517610c32b2SHoratiu Vultur /* Read VCAP content into the VCAP cache */ 1518610c32b2SHoratiu Vultur static int vcap_read_rule(struct vcap_rule_internal *ri) 1519610c32b2SHoratiu Vultur { 1520610c32b2SHoratiu Vultur struct vcap_admin *admin = ri->admin; 1521610c32b2SHoratiu Vultur int sw_idx, ent_idx = 0, act_idx = 0; 1522610c32b2SHoratiu Vultur u32 addr = ri->addr; 1523610c32b2SHoratiu Vultur 1524610c32b2SHoratiu Vultur if (!ri->size || !ri->keyset_sw_regs || !ri->actionset_sw_regs) { 1525610c32b2SHoratiu Vultur pr_err("%s:%d: rule is empty\n", __func__, __LINE__); 1526610c32b2SHoratiu Vultur return -EINVAL; 1527610c32b2SHoratiu Vultur } 1528610c32b2SHoratiu Vultur vcap_erase_cache(ri); 1529610c32b2SHoratiu Vultur /* Use the values in the streams to read the VCAP cache */ 1530610c32b2SHoratiu Vultur for (sw_idx = 0; sw_idx < ri->size; sw_idx++, addr++) { 1531610c32b2SHoratiu Vultur ri->vctrl->ops->update(ri->ndev, admin, VCAP_CMD_READ, 1532610c32b2SHoratiu Vultur VCAP_SEL_ALL, addr); 1533610c32b2SHoratiu Vultur ri->vctrl->ops->cache_read(ri->ndev, admin, 1534610c32b2SHoratiu Vultur VCAP_SEL_ENTRY, ent_idx, 1535610c32b2SHoratiu Vultur ri->keyset_sw_regs); 1536610c32b2SHoratiu Vultur ri->vctrl->ops->cache_read(ri->ndev, admin, 1537610c32b2SHoratiu Vultur VCAP_SEL_ACTION, act_idx, 1538610c32b2SHoratiu Vultur ri->actionset_sw_regs); 1539610c32b2SHoratiu Vultur if (sw_idx == 0) 1540610c32b2SHoratiu Vultur ri->vctrl->ops->cache_read(ri->ndev, admin, 1541610c32b2SHoratiu Vultur VCAP_SEL_COUNTER, 1542610c32b2SHoratiu Vultur ri->counter_id, 0); 1543610c32b2SHoratiu Vultur ent_idx += ri->keyset_sw_regs; 1544610c32b2SHoratiu Vultur act_idx += ri->actionset_sw_regs; 1545610c32b2SHoratiu Vultur } 1546610c32b2SHoratiu Vultur return 0; 1547610c32b2SHoratiu Vultur } 1548610c32b2SHoratiu Vultur 15498e10490bSSteen Hegelund /* Write VCAP cache content to the VCAP HW instance */ 15508e10490bSSteen Hegelund static int vcap_write_rule(struct vcap_rule_internal *ri) 15518e10490bSSteen Hegelund { 15528e10490bSSteen Hegelund struct vcap_admin *admin = ri->admin; 15538e10490bSSteen Hegelund int sw_idx, ent_idx = 0, act_idx = 0; 15548e10490bSSteen Hegelund u32 addr = ri->addr; 15558e10490bSSteen Hegelund 15568e10490bSSteen Hegelund if (!ri->size || !ri->keyset_sw_regs || !ri->actionset_sw_regs) { 15578e10490bSSteen Hegelund pr_err("%s:%d: rule is empty\n", __func__, __LINE__); 15588e10490bSSteen Hegelund return -EINVAL; 15598e10490bSSteen Hegelund } 15608e10490bSSteen Hegelund /* Use the values in the streams to write the VCAP cache */ 15618e10490bSSteen Hegelund for (sw_idx = 0; sw_idx < ri->size; sw_idx++, addr++) { 15628e10490bSSteen Hegelund ri->vctrl->ops->cache_write(ri->ndev, admin, 15638e10490bSSteen Hegelund VCAP_SEL_ENTRY, ent_idx, 15648e10490bSSteen Hegelund ri->keyset_sw_regs); 15658e10490bSSteen Hegelund ri->vctrl->ops->cache_write(ri->ndev, admin, 15668e10490bSSteen Hegelund VCAP_SEL_ACTION, act_idx, 15678e10490bSSteen Hegelund ri->actionset_sw_regs); 15688e10490bSSteen Hegelund ri->vctrl->ops->update(ri->ndev, admin, VCAP_CMD_WRITE, 15698e10490bSSteen Hegelund VCAP_SEL_ALL, addr); 15708e10490bSSteen Hegelund ent_idx += ri->keyset_sw_regs; 15718e10490bSSteen Hegelund act_idx += ri->actionset_sw_regs; 15728e10490bSSteen Hegelund } 15738e10490bSSteen Hegelund return 0; 15748e10490bSSteen Hegelund } 15758e10490bSSteen Hegelund 1576f13230a4SSteen Hegelund static int vcap_write_counter(struct vcap_rule_internal *ri, 1577f13230a4SSteen Hegelund struct vcap_counter *ctr) 1578f13230a4SSteen Hegelund { 1579f13230a4SSteen Hegelund struct vcap_admin *admin = ri->admin; 1580f13230a4SSteen Hegelund 1581f13230a4SSteen Hegelund admin->cache.counter = ctr->value; 1582f13230a4SSteen Hegelund admin->cache.sticky = ctr->sticky; 1583f13230a4SSteen Hegelund ri->vctrl->ops->cache_write(ri->ndev, admin, VCAP_SEL_COUNTER, 1584f13230a4SSteen Hegelund ri->counter_id, 0); 1585f13230a4SSteen Hegelund ri->vctrl->ops->update(ri->ndev, admin, VCAP_CMD_WRITE, 1586f13230a4SSteen Hegelund VCAP_SEL_COUNTER, ri->addr); 1587f13230a4SSteen Hegelund return 0; 1588f13230a4SSteen Hegelund } 1589f13230a4SSteen Hegelund 15907de1dcadSSteen Hegelund /* Convert a chain id to a VCAP lookup index */ 15917de1dcadSSteen Hegelund int vcap_chain_id_to_lookup(struct vcap_admin *admin, int cur_cid) 15927de1dcadSSteen Hegelund { 15937de1dcadSSteen Hegelund int lookup_first = admin->vinst * admin->lookups_per_instance; 15947de1dcadSSteen Hegelund int lookup_last = lookup_first + admin->lookups_per_instance; 15957de1dcadSSteen Hegelund int cid_next = admin->first_cid + VCAP_CID_LOOKUP_SIZE; 15967de1dcadSSteen Hegelund int cid = admin->first_cid; 15977de1dcadSSteen Hegelund int lookup; 15987de1dcadSSteen Hegelund 15997de1dcadSSteen Hegelund for (lookup = lookup_first; lookup < lookup_last; ++lookup, 16007de1dcadSSteen Hegelund cid += VCAP_CID_LOOKUP_SIZE, cid_next += VCAP_CID_LOOKUP_SIZE) 16017de1dcadSSteen Hegelund if (cur_cid >= cid && cur_cid < cid_next) 16027de1dcadSSteen Hegelund return lookup; 16037de1dcadSSteen Hegelund return 0; 16047de1dcadSSteen Hegelund } 16057de1dcadSSteen Hegelund EXPORT_SYMBOL_GPL(vcap_chain_id_to_lookup); 16067de1dcadSSteen Hegelund 1607c9da1ac1SSteen Hegelund /* Lookup a vcap instance using chain id */ 1608c9da1ac1SSteen Hegelund struct vcap_admin *vcap_find_admin(struct vcap_control *vctrl, int cid) 1609c9da1ac1SSteen Hegelund { 1610c9da1ac1SSteen Hegelund struct vcap_admin *admin; 1611c9da1ac1SSteen Hegelund 16128e10490bSSteen Hegelund if (vcap_api_check(vctrl)) 16138e10490bSSteen Hegelund return NULL; 16148e10490bSSteen Hegelund 1615c9da1ac1SSteen Hegelund list_for_each_entry(admin, &vctrl->list, list) { 1616c9da1ac1SSteen Hegelund if (cid >= admin->first_cid && cid <= admin->last_cid) 1617c9da1ac1SSteen Hegelund return admin; 1618c9da1ac1SSteen Hegelund } 1619c9da1ac1SSteen Hegelund return NULL; 1620c9da1ac1SSteen Hegelund } 1621c9da1ac1SSteen Hegelund EXPORT_SYMBOL_GPL(vcap_find_admin); 1622c9da1ac1SSteen Hegelund 1623e7e3f514SSteen Hegelund /* Is this the last admin instance ordered by chain id and direction */ 162488bd9ea7SSteen Hegelund static bool vcap_admin_is_last(struct vcap_control *vctrl, 1625e7e3f514SSteen Hegelund struct vcap_admin *admin, 1626e7e3f514SSteen Hegelund bool ingress) 162788bd9ea7SSteen Hegelund { 162888bd9ea7SSteen Hegelund struct vcap_admin *iter, *last = NULL; 162988bd9ea7SSteen Hegelund int max_cid = 0; 163088bd9ea7SSteen Hegelund 163188bd9ea7SSteen Hegelund list_for_each_entry(iter, &vctrl->list, list) { 1632e7e3f514SSteen Hegelund if (iter->first_cid > max_cid && 1633e7e3f514SSteen Hegelund iter->ingress == ingress) { 163488bd9ea7SSteen Hegelund last = iter; 163588bd9ea7SSteen Hegelund max_cid = iter->first_cid; 163688bd9ea7SSteen Hegelund } 163788bd9ea7SSteen Hegelund } 163888bd9ea7SSteen Hegelund if (!last) 163988bd9ea7SSteen Hegelund return false; 164088bd9ea7SSteen Hegelund 164188bd9ea7SSteen Hegelund return admin == last; 164288bd9ea7SSteen Hegelund } 164388bd9ea7SSteen Hegelund 164488bd9ea7SSteen Hegelund /* Calculate the value used for chaining VCAP rules */ 164588bd9ea7SSteen Hegelund int vcap_chain_offset(struct vcap_control *vctrl, int from_cid, int to_cid) 164688bd9ea7SSteen Hegelund { 164788bd9ea7SSteen Hegelund int diff = to_cid - from_cid; 164888bd9ea7SSteen Hegelund 164988bd9ea7SSteen Hegelund if (diff < 0) /* Wrong direction */ 165088bd9ea7SSteen Hegelund return diff; 165188bd9ea7SSteen Hegelund to_cid %= VCAP_CID_LOOKUP_SIZE; 165288bd9ea7SSteen Hegelund if (to_cid == 0) /* Destination aligned to a lookup == no chaining */ 165388bd9ea7SSteen Hegelund return 0; 165488bd9ea7SSteen Hegelund diff %= VCAP_CID_LOOKUP_SIZE; /* Limit to a value within a lookup */ 165588bd9ea7SSteen Hegelund return diff; 165688bd9ea7SSteen Hegelund } 165788bd9ea7SSteen Hegelund EXPORT_SYMBOL_GPL(vcap_chain_offset); 165888bd9ea7SSteen Hegelund 1659784c3067SSteen Hegelund /* Is the next chain id in one of the following lookups 1660784c3067SSteen Hegelund * For now this does not support filters linked to other filters using 1661784c3067SSteen Hegelund * keys and actions. That will be added later. 1662784c3067SSteen Hegelund */ 1663784c3067SSteen Hegelund bool vcap_is_next_lookup(struct vcap_control *vctrl, int src_cid, int dst_cid) 1664392d0ab0SSteen Hegelund { 1665784c3067SSteen Hegelund struct vcap_admin *admin; 1666784c3067SSteen Hegelund int next_cid; 1667392d0ab0SSteen Hegelund 1668392d0ab0SSteen Hegelund if (vcap_api_check(vctrl)) 1669392d0ab0SSteen Hegelund return false; 1670392d0ab0SSteen Hegelund 16710518e914SSteen Hegelund /* The offset must be at least one lookup so round up one chain */ 16720518e914SSteen Hegelund next_cid = roundup(src_cid + 1, VCAP_CID_LOOKUP_SIZE); 1673784c3067SSteen Hegelund 1674784c3067SSteen Hegelund if (dst_cid < next_cid) 1675784c3067SSteen Hegelund return false; 1676784c3067SSteen Hegelund 1677784c3067SSteen Hegelund admin = vcap_find_admin(vctrl, dst_cid); 1678392d0ab0SSteen Hegelund if (!admin) 1679392d0ab0SSteen Hegelund return false; 1680392d0ab0SSteen Hegelund 1681784c3067SSteen Hegelund return true; 1682392d0ab0SSteen Hegelund } 1683392d0ab0SSteen Hegelund EXPORT_SYMBOL_GPL(vcap_is_next_lookup); 1684392d0ab0SSteen Hegelund 16858e10490bSSteen Hegelund /* Check if there is room for a new rule */ 16868e10490bSSteen Hegelund static int vcap_rule_space(struct vcap_admin *admin, int size) 16878e10490bSSteen Hegelund { 16888e10490bSSteen Hegelund if (admin->last_used_addr - size < admin->first_valid_addr) { 16898e10490bSSteen Hegelund pr_err("%s:%d: No room for rule size: %u, %u\n", 16908e10490bSSteen Hegelund __func__, __LINE__, size, admin->first_valid_addr); 16918e10490bSSteen Hegelund return -ENOSPC; 16928e10490bSSteen Hegelund } 16938e10490bSSteen Hegelund return 0; 16948e10490bSSteen Hegelund } 16958e10490bSSteen Hegelund 16968e10490bSSteen Hegelund /* Add the keyset typefield to the list of rule keyfields */ 16978e10490bSSteen Hegelund static int vcap_add_type_keyfield(struct vcap_rule *rule) 16988e10490bSSteen Hegelund { 16998e10490bSSteen Hegelund struct vcap_rule_internal *ri = to_intrule(rule); 17008e10490bSSteen Hegelund enum vcap_keyfield_set keyset = rule->keyset; 17018e10490bSSteen Hegelund enum vcap_type vt = ri->admin->vtype; 17028e10490bSSteen Hegelund const struct vcap_field *fields; 17038e10490bSSteen Hegelund const struct vcap_set *kset; 17048e10490bSSteen Hegelund int ret = -EINVAL; 17058e10490bSSteen Hegelund 17068e10490bSSteen Hegelund kset = vcap_keyfieldset(ri->vctrl, vt, keyset); 17078e10490bSSteen Hegelund if (!kset) 17088e10490bSSteen Hegelund return ret; 17098e10490bSSteen Hegelund if (kset->type_id == (u8)-1) /* No type field is needed */ 17108e10490bSSteen Hegelund return 0; 17118e10490bSSteen Hegelund 17128e10490bSSteen Hegelund fields = vcap_keyfields(ri->vctrl, vt, keyset); 17138e10490bSSteen Hegelund if (!fields) 17148e10490bSSteen Hegelund return -EINVAL; 17158e10490bSSteen Hegelund if (fields[VCAP_KF_TYPE].width > 1) { 17168e10490bSSteen Hegelund ret = vcap_rule_add_key_u32(rule, VCAP_KF_TYPE, 17178e10490bSSteen Hegelund kset->type_id, 0xff); 17188e10490bSSteen Hegelund } else { 17198e10490bSSteen Hegelund if (kset->type_id) 17208e10490bSSteen Hegelund ret = vcap_rule_add_key_bit(rule, VCAP_KF_TYPE, 17218e10490bSSteen Hegelund VCAP_BIT_1); 17228e10490bSSteen Hegelund else 17238e10490bSSteen Hegelund ret = vcap_rule_add_key_bit(rule, VCAP_KF_TYPE, 17248e10490bSSteen Hegelund VCAP_BIT_0); 17258e10490bSSteen Hegelund } 17268e10490bSSteen Hegelund return 0; 17278e10490bSSteen Hegelund } 17288e10490bSSteen Hegelund 17297306fcd1SSteen Hegelund /* Add the actionset typefield to the list of rule actionfields */ 17307306fcd1SSteen Hegelund static int vcap_add_type_actionfield(struct vcap_rule *rule) 17317306fcd1SSteen Hegelund { 17327306fcd1SSteen Hegelund enum vcap_actionfield_set actionset = rule->actionset; 17337306fcd1SSteen Hegelund struct vcap_rule_internal *ri = to_intrule(rule); 17347306fcd1SSteen Hegelund enum vcap_type vt = ri->admin->vtype; 17357306fcd1SSteen Hegelund const struct vcap_field *fields; 17367306fcd1SSteen Hegelund const struct vcap_set *aset; 17377306fcd1SSteen Hegelund int ret = -EINVAL; 17387306fcd1SSteen Hegelund 17397306fcd1SSteen Hegelund aset = vcap_actionfieldset(ri->vctrl, vt, actionset); 17407306fcd1SSteen Hegelund if (!aset) 17417306fcd1SSteen Hegelund return ret; 17427306fcd1SSteen Hegelund if (aset->type_id == (u8)-1) /* No type field is needed */ 17437306fcd1SSteen Hegelund return 0; 17447306fcd1SSteen Hegelund 17457306fcd1SSteen Hegelund fields = vcap_actionfields(ri->vctrl, vt, actionset); 17467306fcd1SSteen Hegelund if (!fields) 17477306fcd1SSteen Hegelund return -EINVAL; 17487306fcd1SSteen Hegelund if (fields[VCAP_AF_TYPE].width > 1) { 17497306fcd1SSteen Hegelund ret = vcap_rule_add_action_u32(rule, VCAP_AF_TYPE, 17507306fcd1SSteen Hegelund aset->type_id); 17517306fcd1SSteen Hegelund } else { 17527306fcd1SSteen Hegelund if (aset->type_id) 17537306fcd1SSteen Hegelund ret = vcap_rule_add_action_bit(rule, VCAP_AF_TYPE, 17547306fcd1SSteen Hegelund VCAP_BIT_1); 17557306fcd1SSteen Hegelund else 17567306fcd1SSteen Hegelund ret = vcap_rule_add_action_bit(rule, VCAP_AF_TYPE, 17577306fcd1SSteen Hegelund VCAP_BIT_0); 17587306fcd1SSteen Hegelund } 17597306fcd1SSteen Hegelund return ret; 17607306fcd1SSteen Hegelund } 17617306fcd1SSteen Hegelund 1762abc4010dSSteen Hegelund /* Add a keyset to a keyset list */ 1763abc4010dSSteen Hegelund bool vcap_keyset_list_add(struct vcap_keyset_list *keysetlist, 1764abc4010dSSteen Hegelund enum vcap_keyfield_set keyset) 1765abc4010dSSteen Hegelund { 1766abc4010dSSteen Hegelund int idx; 1767abc4010dSSteen Hegelund 1768abc4010dSSteen Hegelund if (keysetlist->cnt < keysetlist->max) { 1769abc4010dSSteen Hegelund /* Avoid duplicates */ 1770abc4010dSSteen Hegelund for (idx = 0; idx < keysetlist->cnt; ++idx) 1771abc4010dSSteen Hegelund if (keysetlist->keysets[idx] == keyset) 1772abc4010dSSteen Hegelund return keysetlist->cnt < keysetlist->max; 1773abc4010dSSteen Hegelund keysetlist->keysets[keysetlist->cnt++] = keyset; 1774abc4010dSSteen Hegelund } 1775abc4010dSSteen Hegelund return keysetlist->cnt < keysetlist->max; 1776abc4010dSSteen Hegelund } 1777abc4010dSSteen Hegelund EXPORT_SYMBOL_GPL(vcap_keyset_list_add); 1778abc4010dSSteen Hegelund 177981e164c4SSteen Hegelund /* Add a actionset to a actionset list */ 178081e164c4SSteen Hegelund static bool vcap_actionset_list_add(struct vcap_actionset_list *actionsetlist, 178181e164c4SSteen Hegelund enum vcap_actionfield_set actionset) 178281e164c4SSteen Hegelund { 178381e164c4SSteen Hegelund int idx; 178481e164c4SSteen Hegelund 178581e164c4SSteen Hegelund if (actionsetlist->cnt < actionsetlist->max) { 178681e164c4SSteen Hegelund /* Avoid duplicates */ 178781e164c4SSteen Hegelund for (idx = 0; idx < actionsetlist->cnt; ++idx) 178881e164c4SSteen Hegelund if (actionsetlist->actionsets[idx] == actionset) 178981e164c4SSteen Hegelund return actionsetlist->cnt < actionsetlist->max; 179081e164c4SSteen Hegelund actionsetlist->actionsets[actionsetlist->cnt++] = actionset; 179181e164c4SSteen Hegelund } 179281e164c4SSteen Hegelund return actionsetlist->cnt < actionsetlist->max; 179381e164c4SSteen Hegelund } 179481e164c4SSteen Hegelund 1795abc4010dSSteen Hegelund /* map keyset id to a string with the keyset name */ 1796abc4010dSSteen Hegelund const char *vcap_keyset_name(struct vcap_control *vctrl, 1797abc4010dSSteen Hegelund enum vcap_keyfield_set keyset) 1798abc4010dSSteen Hegelund { 1799abc4010dSSteen Hegelund return vctrl->stats->keyfield_set_names[keyset]; 1800abc4010dSSteen Hegelund } 1801abc4010dSSteen Hegelund EXPORT_SYMBOL_GPL(vcap_keyset_name); 1802abc4010dSSteen Hegelund 1803abc4010dSSteen Hegelund /* map key field id to a string with the key name */ 1804abc4010dSSteen Hegelund const char *vcap_keyfield_name(struct vcap_control *vctrl, 1805abc4010dSSteen Hegelund enum vcap_key_field key) 1806abc4010dSSteen Hegelund { 1807abc4010dSSteen Hegelund return vctrl->stats->keyfield_names[key]; 1808abc4010dSSteen Hegelund } 1809abc4010dSSteen Hegelund EXPORT_SYMBOL_GPL(vcap_keyfield_name); 1810abc4010dSSteen Hegelund 18113a792156SSteen Hegelund /* map actionset id to a string with the actionset name */ 18123a792156SSteen Hegelund const char *vcap_actionset_name(struct vcap_control *vctrl, 18133a792156SSteen Hegelund enum vcap_actionfield_set actionset) 18143a792156SSteen Hegelund { 18153a792156SSteen Hegelund return vctrl->stats->actionfield_set_names[actionset]; 18163a792156SSteen Hegelund } 18173a792156SSteen Hegelund 1818242df4f7SSteen Hegelund /* map action field id to a string with the action name */ 18193a792156SSteen Hegelund const char *vcap_actionfield_name(struct vcap_control *vctrl, 1820242df4f7SSteen Hegelund enum vcap_action_field action) 1821242df4f7SSteen Hegelund { 1822242df4f7SSteen Hegelund return vctrl->stats->actionfield_names[action]; 1823242df4f7SSteen Hegelund } 1824242df4f7SSteen Hegelund 1825abc4010dSSteen Hegelund /* Return the keyfield that matches a key in a keyset */ 1826abc4010dSSteen Hegelund static const struct vcap_field * 1827abc4010dSSteen Hegelund vcap_find_keyset_keyfield(struct vcap_control *vctrl, 1828abc4010dSSteen Hegelund enum vcap_type vtype, 1829abc4010dSSteen Hegelund enum vcap_keyfield_set keyset, 1830abc4010dSSteen Hegelund enum vcap_key_field key) 1831abc4010dSSteen Hegelund { 1832abc4010dSSteen Hegelund const struct vcap_field *fields; 1833abc4010dSSteen Hegelund int idx, count; 1834abc4010dSSteen Hegelund 1835abc4010dSSteen Hegelund fields = vcap_keyfields(vctrl, vtype, keyset); 1836abc4010dSSteen Hegelund if (!fields) 1837abc4010dSSteen Hegelund return NULL; 1838abc4010dSSteen Hegelund 1839abc4010dSSteen Hegelund /* Iterate the keyfields of the keyset */ 1840abc4010dSSteen Hegelund count = vcap_keyfield_count(vctrl, vtype, keyset); 1841abc4010dSSteen Hegelund for (idx = 0; idx < count; ++idx) { 1842abc4010dSSteen Hegelund if (fields[idx].width == 0) 1843abc4010dSSteen Hegelund continue; 1844abc4010dSSteen Hegelund 1845abc4010dSSteen Hegelund if (key == idx) 1846abc4010dSSteen Hegelund return &fields[idx]; 1847abc4010dSSteen Hegelund } 1848abc4010dSSteen Hegelund 1849abc4010dSSteen Hegelund return NULL; 1850abc4010dSSteen Hegelund } 1851abc4010dSSteen Hegelund 1852abc4010dSSteen Hegelund /* Match a list of keys against the keysets available in a vcap type */ 1853465a38a2SSteen Hegelund static bool _vcap_rule_find_keysets(struct vcap_rule_internal *ri, 1854abc4010dSSteen Hegelund struct vcap_keyset_list *matches) 1855abc4010dSSteen Hegelund { 1856abc4010dSSteen Hegelund const struct vcap_client_keyfield *ckf; 1857abc4010dSSteen Hegelund int keyset, found, keycount, map_size; 1858abc4010dSSteen Hegelund const struct vcap_field **map; 1859abc4010dSSteen Hegelund enum vcap_type vtype; 1860abc4010dSSteen Hegelund 1861abc4010dSSteen Hegelund vtype = ri->admin->vtype; 1862abc4010dSSteen Hegelund map = ri->vctrl->vcaps[vtype].keyfield_set_map; 1863abc4010dSSteen Hegelund map_size = ri->vctrl->vcaps[vtype].keyfield_set_size; 1864abc4010dSSteen Hegelund 1865abc4010dSSteen Hegelund /* Get a count of the keyfields we want to match */ 1866abc4010dSSteen Hegelund keycount = 0; 1867abc4010dSSteen Hegelund list_for_each_entry(ckf, &ri->data.keyfields, ctrl.list) 1868abc4010dSSteen Hegelund ++keycount; 1869abc4010dSSteen Hegelund 1870abc4010dSSteen Hegelund matches->cnt = 0; 1871abc4010dSSteen Hegelund /* Iterate the keysets of the VCAP */ 1872abc4010dSSteen Hegelund for (keyset = 0; keyset < map_size; ++keyset) { 1873abc4010dSSteen Hegelund if (!map[keyset]) 1874abc4010dSSteen Hegelund continue; 1875abc4010dSSteen Hegelund 1876abc4010dSSteen Hegelund /* Iterate the keys in the rule */ 1877abc4010dSSteen Hegelund found = 0; 1878abc4010dSSteen Hegelund list_for_each_entry(ckf, &ri->data.keyfields, ctrl.list) 1879abc4010dSSteen Hegelund if (vcap_find_keyset_keyfield(ri->vctrl, vtype, 1880abc4010dSSteen Hegelund keyset, ckf->ctrl.key)) 1881abc4010dSSteen Hegelund ++found; 1882abc4010dSSteen Hegelund 1883abc4010dSSteen Hegelund /* Save the keyset if all keyfields were found */ 1884abc4010dSSteen Hegelund if (found == keycount) 1885abc4010dSSteen Hegelund if (!vcap_keyset_list_add(matches, keyset)) 1886abc4010dSSteen Hegelund /* bail out when the quota is filled */ 1887abc4010dSSteen Hegelund break; 1888abc4010dSSteen Hegelund } 1889abc4010dSSteen Hegelund 1890abc4010dSSteen Hegelund return matches->cnt > 0; 1891abc4010dSSteen Hegelund } 1892abc4010dSSteen Hegelund 1893465a38a2SSteen Hegelund /* Match a list of keys against the keysets available in a vcap type */ 1894465a38a2SSteen Hegelund bool vcap_rule_find_keysets(struct vcap_rule *rule, 1895465a38a2SSteen Hegelund struct vcap_keyset_list *matches) 1896465a38a2SSteen Hegelund { 1897465a38a2SSteen Hegelund struct vcap_rule_internal *ri = to_intrule(rule); 1898465a38a2SSteen Hegelund 1899465a38a2SSteen Hegelund return _vcap_rule_find_keysets(ri, matches); 1900465a38a2SSteen Hegelund } 1901465a38a2SSteen Hegelund EXPORT_SYMBOL_GPL(vcap_rule_find_keysets); 1902465a38a2SSteen Hegelund 190381e164c4SSteen Hegelund /* Return the actionfield that matches a action in a actionset */ 190481e164c4SSteen Hegelund static const struct vcap_field * 190581e164c4SSteen Hegelund vcap_find_actionset_actionfield(struct vcap_control *vctrl, 190681e164c4SSteen Hegelund enum vcap_type vtype, 190781e164c4SSteen Hegelund enum vcap_actionfield_set actionset, 190881e164c4SSteen Hegelund enum vcap_action_field action) 190981e164c4SSteen Hegelund { 191081e164c4SSteen Hegelund const struct vcap_field *fields; 191181e164c4SSteen Hegelund int idx, count; 191281e164c4SSteen Hegelund 191381e164c4SSteen Hegelund fields = vcap_actionfields(vctrl, vtype, actionset); 191481e164c4SSteen Hegelund if (!fields) 191581e164c4SSteen Hegelund return NULL; 191681e164c4SSteen Hegelund 191781e164c4SSteen Hegelund /* Iterate the actionfields of the actionset */ 191881e164c4SSteen Hegelund count = vcap_actionfield_count(vctrl, vtype, actionset); 191981e164c4SSteen Hegelund for (idx = 0; idx < count; ++idx) { 192081e164c4SSteen Hegelund if (fields[idx].width == 0) 192181e164c4SSteen Hegelund continue; 192281e164c4SSteen Hegelund 192381e164c4SSteen Hegelund if (action == idx) 192481e164c4SSteen Hegelund return &fields[idx]; 192581e164c4SSteen Hegelund } 192681e164c4SSteen Hegelund 192781e164c4SSteen Hegelund return NULL; 192881e164c4SSteen Hegelund } 192981e164c4SSteen Hegelund 193081e164c4SSteen Hegelund /* Match a list of actions against the actionsets available in a vcap type */ 193181e164c4SSteen Hegelund static bool vcap_rule_find_actionsets(struct vcap_rule_internal *ri, 193281e164c4SSteen Hegelund struct vcap_actionset_list *matches) 193381e164c4SSteen Hegelund { 193481e164c4SSteen Hegelund int actionset, found, actioncount, map_size; 193581e164c4SSteen Hegelund const struct vcap_client_actionfield *ckf; 193681e164c4SSteen Hegelund const struct vcap_field **map; 193781e164c4SSteen Hegelund enum vcap_type vtype; 193881e164c4SSteen Hegelund 193981e164c4SSteen Hegelund vtype = ri->admin->vtype; 194081e164c4SSteen Hegelund map = ri->vctrl->vcaps[vtype].actionfield_set_map; 194181e164c4SSteen Hegelund map_size = ri->vctrl->vcaps[vtype].actionfield_set_size; 194281e164c4SSteen Hegelund 194381e164c4SSteen Hegelund /* Get a count of the actionfields we want to match */ 194481e164c4SSteen Hegelund actioncount = 0; 194581e164c4SSteen Hegelund list_for_each_entry(ckf, &ri->data.actionfields, ctrl.list) 194681e164c4SSteen Hegelund ++actioncount; 194781e164c4SSteen Hegelund 194881e164c4SSteen Hegelund matches->cnt = 0; 194981e164c4SSteen Hegelund /* Iterate the actionsets of the VCAP */ 195081e164c4SSteen Hegelund for (actionset = 0; actionset < map_size; ++actionset) { 195181e164c4SSteen Hegelund if (!map[actionset]) 195281e164c4SSteen Hegelund continue; 195381e164c4SSteen Hegelund 195481e164c4SSteen Hegelund /* Iterate the actions in the rule */ 195581e164c4SSteen Hegelund found = 0; 195681e164c4SSteen Hegelund list_for_each_entry(ckf, &ri->data.actionfields, ctrl.list) 195781e164c4SSteen Hegelund if (vcap_find_actionset_actionfield(ri->vctrl, vtype, 195881e164c4SSteen Hegelund actionset, 195981e164c4SSteen Hegelund ckf->ctrl.action)) 196081e164c4SSteen Hegelund ++found; 196181e164c4SSteen Hegelund 196281e164c4SSteen Hegelund /* Save the actionset if all actionfields were found */ 196381e164c4SSteen Hegelund if (found == actioncount) 196481e164c4SSteen Hegelund if (!vcap_actionset_list_add(matches, actionset)) 196581e164c4SSteen Hegelund /* bail out when the quota is filled */ 196681e164c4SSteen Hegelund break; 196781e164c4SSteen Hegelund } 196881e164c4SSteen Hegelund 196981e164c4SSteen Hegelund return matches->cnt > 0; 197081e164c4SSteen Hegelund } 197181e164c4SSteen Hegelund 1972c9da1ac1SSteen Hegelund /* Validate a rule with respect to available port keys */ 1973c9da1ac1SSteen Hegelund int vcap_val_rule(struct vcap_rule *rule, u16 l3_proto) 1974c9da1ac1SSteen Hegelund { 1975c9da1ac1SSteen Hegelund struct vcap_rule_internal *ri = to_intrule(rule); 1976abc4010dSSteen Hegelund struct vcap_keyset_list matches = {}; 19778e10490bSSteen Hegelund enum vcap_keyfield_set keysets[10]; 19788e10490bSSteen Hegelund int ret; 1979c9da1ac1SSteen Hegelund 19808e10490bSSteen Hegelund ret = vcap_api_check(ri->vctrl); 19818e10490bSSteen Hegelund if (ret) 19828e10490bSSteen Hegelund return ret; 1983c9da1ac1SSteen Hegelund if (!ri->admin) { 1984c9da1ac1SSteen Hegelund ri->data.exterr = VCAP_ERR_NO_ADMIN; 1985c9da1ac1SSteen Hegelund return -EINVAL; 1986c9da1ac1SSteen Hegelund } 1987c9da1ac1SSteen Hegelund if (!ri->ndev) { 1988c9da1ac1SSteen Hegelund ri->data.exterr = VCAP_ERR_NO_NETDEV; 1989c9da1ac1SSteen Hegelund return -EINVAL; 1990c9da1ac1SSteen Hegelund } 1991abc4010dSSteen Hegelund 1992abc4010dSSteen Hegelund matches.keysets = keysets; 1993abc4010dSSteen Hegelund matches.max = ARRAY_SIZE(keysets); 1994c9da1ac1SSteen Hegelund if (ri->data.keyset == VCAP_KFS_NO_VALUE) { 1995abc4010dSSteen Hegelund /* Iterate over rule keyfields and select keysets that fits */ 1996465a38a2SSteen Hegelund if (!_vcap_rule_find_keysets(ri, &matches)) { 1997c9da1ac1SSteen Hegelund ri->data.exterr = VCAP_ERR_NO_KEYSET_MATCH; 1998c9da1ac1SSteen Hegelund return -EINVAL; 1999c9da1ac1SSteen Hegelund } 2000abc4010dSSteen Hegelund } else { 20018e10490bSSteen Hegelund /* prepare for keyset validation */ 20028e10490bSSteen Hegelund keysets[0] = ri->data.keyset; 2003abc4010dSSteen Hegelund matches.cnt = 1; 2004abc4010dSSteen Hegelund } 2005abc4010dSSteen Hegelund 20068e10490bSSteen Hegelund /* Pick a keyset that is supported in the port lookups */ 2007abc4010dSSteen Hegelund ret = ri->vctrl->ops->validate_keyset(ri->ndev, ri->admin, rule, 2008abc4010dSSteen Hegelund &matches, l3_proto); 20098e10490bSSteen Hegelund if (ret < 0) { 20108e10490bSSteen Hegelund pr_err("%s:%d: keyset validation failed: %d\n", 20118e10490bSSteen Hegelund __func__, __LINE__, ret); 20128e10490bSSteen Hegelund ri->data.exterr = VCAP_ERR_NO_PORT_KEYSET_MATCH; 20138e10490bSSteen Hegelund return ret; 20148e10490bSSteen Hegelund } 2015abc4010dSSteen Hegelund /* use the keyset that is supported in the port lookups */ 2016abc4010dSSteen Hegelund ret = vcap_set_rule_set_keyset(rule, ret); 2017abc4010dSSteen Hegelund if (ret < 0) { 2018abc4010dSSteen Hegelund pr_err("%s:%d: keyset was not updated: %d\n", 2019abc4010dSSteen Hegelund __func__, __LINE__, ret); 2020abc4010dSSteen Hegelund return ret; 2021abc4010dSSteen Hegelund } 2022c9da1ac1SSteen Hegelund if (ri->data.actionset == VCAP_AFS_NO_VALUE) { 202381e164c4SSteen Hegelund struct vcap_actionset_list matches = {}; 202481e164c4SSteen Hegelund enum vcap_actionfield_set actionsets[10]; 202581e164c4SSteen Hegelund 202681e164c4SSteen Hegelund matches.actionsets = actionsets; 202781e164c4SSteen Hegelund matches.max = ARRAY_SIZE(actionsets); 202881e164c4SSteen Hegelund 202981e164c4SSteen Hegelund /* Find an actionset that fits the rule actions */ 203081e164c4SSteen Hegelund if (!vcap_rule_find_actionsets(ri, &matches)) { 2031c9da1ac1SSteen Hegelund ri->data.exterr = VCAP_ERR_NO_ACTIONSET_MATCH; 2032c9da1ac1SSteen Hegelund return -EINVAL; 2033c9da1ac1SSteen Hegelund } 203481e164c4SSteen Hegelund ret = vcap_set_rule_set_actionset(rule, actionsets[0]); 203581e164c4SSteen Hegelund if (ret < 0) { 203681e164c4SSteen Hegelund pr_err("%s:%d: actionset was not updated: %d\n", 203781e164c4SSteen Hegelund __func__, __LINE__, ret); 203881e164c4SSteen Hegelund return ret; 203981e164c4SSteen Hegelund } 204081e164c4SSteen Hegelund } 20418e10490bSSteen Hegelund vcap_add_type_keyfield(rule); 20427306fcd1SSteen Hegelund vcap_add_type_actionfield(rule); 20438e10490bSSteen Hegelund /* Add default fields to this rule */ 20448e10490bSSteen Hegelund ri->vctrl->ops->add_default_fields(ri->ndev, ri->admin, rule); 20458e10490bSSteen Hegelund 20468e10490bSSteen Hegelund /* Rule size is the maximum of the entry and action subword count */ 20478e10490bSSteen Hegelund ri->size = max(ri->keyset_sw, ri->actionset_sw); 20488e10490bSSteen Hegelund 20498e10490bSSteen Hegelund /* Finally check if there is room for the rule in the VCAP */ 20508e10490bSSteen Hegelund return vcap_rule_space(ri->admin, ri->size); 2051c9da1ac1SSteen Hegelund } 2052c9da1ac1SSteen Hegelund EXPORT_SYMBOL_GPL(vcap_val_rule); 2053c9da1ac1SSteen Hegelund 2054990e4839SSteen Hegelund /* Entries are sorted with increasing values of sort_key. 2055990e4839SSteen Hegelund * I.e. Lowest numerical sort_key is first in list. 2056990e4839SSteen Hegelund * In order to locate largest keys first in list we negate the key size with 2057990e4839SSteen Hegelund * (max_size - size). 2058990e4839SSteen Hegelund */ 2059990e4839SSteen Hegelund static u32 vcap_sort_key(u32 max_size, u32 size, u8 user, u16 prio) 2060990e4839SSteen Hegelund { 2061990e4839SSteen Hegelund return ((max_size - size) << 24) | (user << 16) | prio; 2062990e4839SSteen Hegelund } 2063990e4839SSteen Hegelund 20648e10490bSSteen Hegelund /* calculate the address of the next rule after this (lower address and prio) */ 20658e10490bSSteen Hegelund static u32 vcap_next_rule_addr(u32 addr, struct vcap_rule_internal *ri) 20668e10490bSSteen Hegelund { 20678e10490bSSteen Hegelund return ((addr - ri->size) / ri->size) * ri->size; 20688e10490bSSteen Hegelund } 20698e10490bSSteen Hegelund 2070c9da1ac1SSteen Hegelund /* Assign a unique rule id and autogenerate one if id == 0 */ 2071c9da1ac1SSteen Hegelund static u32 vcap_set_rule_id(struct vcap_rule_internal *ri) 2072c9da1ac1SSteen Hegelund { 2073c9da1ac1SSteen Hegelund if (ri->data.id != 0) 2074c9da1ac1SSteen Hegelund return ri->data.id; 2075c9da1ac1SSteen Hegelund 2076c1d8e3fbSHoratiu Vultur for (u32 next_id = 1; next_id < ~0; ++next_id) { 2077975d86acSSteen Hegelund if (!vcap_rule_exists(ri->vctrl, next_id)) { 2078c9da1ac1SSteen Hegelund ri->data.id = next_id; 2079c9da1ac1SSteen Hegelund break; 2080c9da1ac1SSteen Hegelund } 2081c9da1ac1SSteen Hegelund } 2082c9da1ac1SSteen Hegelund return ri->data.id; 2083c9da1ac1SSteen Hegelund } 2084c9da1ac1SSteen Hegelund 20858e10490bSSteen Hegelund static int vcap_insert_rule(struct vcap_rule_internal *ri, 20868e10490bSSteen Hegelund struct vcap_rule_move *move) 20878e10490bSSteen Hegelund { 2088990e4839SSteen Hegelund int sw_count = ri->vctrl->vcaps[ri->admin->vtype].sw_count; 2089990e4839SSteen Hegelund struct vcap_rule_internal *duprule, *iter, *elem = NULL; 20908e10490bSSteen Hegelund struct vcap_admin *admin = ri->admin; 2091990e4839SSteen Hegelund u32 addr; 20928e10490bSSteen Hegelund 2093990e4839SSteen Hegelund ri->sort_key = vcap_sort_key(sw_count, ri->size, ri->data.user, 2094990e4839SSteen Hegelund ri->data.priority); 2095990e4839SSteen Hegelund 2096990e4839SSteen Hegelund /* Insert the new rule in the list of rule based on the sort key 2097990e4839SSteen Hegelund * If the rule needs to be inserted between existing rules then move 2098990e4839SSteen Hegelund * these rules to make room for the new rule and update their start 2099990e4839SSteen Hegelund * address. 2100990e4839SSteen Hegelund */ 2101990e4839SSteen Hegelund list_for_each_entry(iter, &admin->rules, list) { 2102990e4839SSteen Hegelund if (ri->sort_key < iter->sort_key) { 2103990e4839SSteen Hegelund elem = iter; 2104990e4839SSteen Hegelund break; 2105990e4839SSteen Hegelund } 2106990e4839SSteen Hegelund } 2107990e4839SSteen Hegelund 2108990e4839SSteen Hegelund if (!elem) { 21098e10490bSSteen Hegelund ri->addr = vcap_next_rule_addr(admin->last_used_addr, ri); 21108e10490bSSteen Hegelund admin->last_used_addr = ri->addr; 2111990e4839SSteen Hegelund 2112814e7693SSteen Hegelund /* Add a copy of the rule to the VCAP list */ 2113814e7693SSteen Hegelund duprule = vcap_dup_rule(ri, ri->state == VCAP_RS_DISABLED); 21148e10490bSSteen Hegelund if (IS_ERR(duprule)) 21158e10490bSSteen Hegelund return PTR_ERR(duprule); 2116990e4839SSteen Hegelund 21178e10490bSSteen Hegelund list_add_tail(&duprule->list, &admin->rules); 21188e10490bSSteen Hegelund return 0; 21198e10490bSSteen Hegelund } 21208e10490bSSteen Hegelund 2121990e4839SSteen Hegelund /* Reuse the space of the current rule */ 2122990e4839SSteen Hegelund addr = elem->addr + elem->size; 2123990e4839SSteen Hegelund ri->addr = vcap_next_rule_addr(addr, ri); 2124990e4839SSteen Hegelund addr = ri->addr; 2125990e4839SSteen Hegelund 2126814e7693SSteen Hegelund /* Add a copy of the rule to the VCAP list */ 2127814e7693SSteen Hegelund duprule = vcap_dup_rule(ri, ri->state == VCAP_RS_DISABLED); 2128990e4839SSteen Hegelund if (IS_ERR(duprule)) 2129990e4839SSteen Hegelund return PTR_ERR(duprule); 2130990e4839SSteen Hegelund 2131990e4839SSteen Hegelund /* Add before the current entry */ 2132990e4839SSteen Hegelund list_add_tail(&duprule->list, &elem->list); 2133990e4839SSteen Hegelund 2134990e4839SSteen Hegelund /* Update the current rule */ 2135990e4839SSteen Hegelund elem->addr = vcap_next_rule_addr(addr, elem); 2136990e4839SSteen Hegelund addr = elem->addr; 2137990e4839SSteen Hegelund 2138990e4839SSteen Hegelund /* Update the address in the remaining rules in the list */ 2139990e4839SSteen Hegelund list_for_each_entry_continue(elem, &admin->rules, list) { 2140990e4839SSteen Hegelund elem->addr = vcap_next_rule_addr(addr, elem); 2141990e4839SSteen Hegelund addr = elem->addr; 2142990e4839SSteen Hegelund } 2143990e4839SSteen Hegelund 2144990e4839SSteen Hegelund /* Update the move info */ 2145990e4839SSteen Hegelund move->addr = admin->last_used_addr; 2146990e4839SSteen Hegelund move->count = ri->addr - addr; 2147990e4839SSteen Hegelund move->offset = admin->last_used_addr - addr; 2148990e4839SSteen Hegelund admin->last_used_addr = addr; 2149990e4839SSteen Hegelund return 0; 2150990e4839SSteen Hegelund } 2151990e4839SSteen Hegelund 21528e10490bSSteen Hegelund static void vcap_move_rules(struct vcap_rule_internal *ri, 21538e10490bSSteen Hegelund struct vcap_rule_move *move) 21548e10490bSSteen Hegelund { 21558e10490bSSteen Hegelund ri->vctrl->ops->move(ri->ndev, ri->admin, move->addr, 21568e10490bSSteen Hegelund move->offset, move->count); 21578e10490bSSteen Hegelund } 21588e10490bSSteen Hegelund 2159cfd9e7b7SSteen Hegelund /* Check if the chain is already used to enable a VCAP lookup for this port */ 2160cfd9e7b7SSteen Hegelund static bool vcap_is_chain_used(struct vcap_control *vctrl, 2161cfd9e7b7SSteen Hegelund struct net_device *ndev, int src_cid) 2162cfd9e7b7SSteen Hegelund { 2163cfd9e7b7SSteen Hegelund struct vcap_enabled_port *eport; 2164cfd9e7b7SSteen Hegelund struct vcap_admin *admin; 2165cfd9e7b7SSteen Hegelund 2166cfd9e7b7SSteen Hegelund list_for_each_entry(admin, &vctrl->list, list) 2167cfd9e7b7SSteen Hegelund list_for_each_entry(eport, &admin->enabled, list) 2168cfd9e7b7SSteen Hegelund if (eport->src_cid == src_cid && eport->ndev == ndev) 2169cfd9e7b7SSteen Hegelund return true; 2170cfd9e7b7SSteen Hegelund 2171cfd9e7b7SSteen Hegelund return false; 2172cfd9e7b7SSteen Hegelund } 2173cfd9e7b7SSteen Hegelund 2174814e7693SSteen Hegelund /* Fetch the next chain in the enabled list for the port */ 2175814e7693SSteen Hegelund static int vcap_get_next_chain(struct vcap_control *vctrl, 2176814e7693SSteen Hegelund struct net_device *ndev, 2177814e7693SSteen Hegelund int dst_cid) 2178814e7693SSteen Hegelund { 2179814e7693SSteen Hegelund struct vcap_enabled_port *eport; 2180814e7693SSteen Hegelund struct vcap_admin *admin; 2181814e7693SSteen Hegelund 2182814e7693SSteen Hegelund list_for_each_entry(admin, &vctrl->list, list) { 2183814e7693SSteen Hegelund list_for_each_entry(eport, &admin->enabled, list) { 2184814e7693SSteen Hegelund if (eport->ndev != ndev) 2185814e7693SSteen Hegelund continue; 2186814e7693SSteen Hegelund if (eport->src_cid == dst_cid) 2187814e7693SSteen Hegelund return eport->dst_cid; 2188814e7693SSteen Hegelund } 2189814e7693SSteen Hegelund } 2190814e7693SSteen Hegelund 2191814e7693SSteen Hegelund return 0; 2192814e7693SSteen Hegelund } 2193814e7693SSteen Hegelund 2194814e7693SSteen Hegelund static bool vcap_path_exist(struct vcap_control *vctrl, struct net_device *ndev, 2195814e7693SSteen Hegelund int dst_cid) 2196814e7693SSteen Hegelund { 21970518e914SSteen Hegelund int cid = rounddown(dst_cid, VCAP_CID_LOOKUP_SIZE); 21983bee9b57SDan Carpenter struct vcap_enabled_port *eport = NULL; 21993bee9b57SDan Carpenter struct vcap_enabled_port *elem; 2200814e7693SSteen Hegelund struct vcap_admin *admin; 2201814e7693SSteen Hegelund int tmp; 2202814e7693SSteen Hegelund 22030518e914SSteen Hegelund if (cid == 0) /* Chain zero is always available */ 220418a15c76SSteen Hegelund return true; 220518a15c76SSteen Hegelund 2206814e7693SSteen Hegelund /* Find first entry that starts from chain 0*/ 2207814e7693SSteen Hegelund list_for_each_entry(admin, &vctrl->list, list) { 2208814e7693SSteen Hegelund list_for_each_entry(elem, &admin->enabled, list) { 2209814e7693SSteen Hegelund if (elem->src_cid == 0 && elem->ndev == ndev) { 2210814e7693SSteen Hegelund eport = elem; 2211814e7693SSteen Hegelund break; 2212814e7693SSteen Hegelund } 2213814e7693SSteen Hegelund } 2214814e7693SSteen Hegelund if (eport) 2215814e7693SSteen Hegelund break; 2216814e7693SSteen Hegelund } 2217814e7693SSteen Hegelund 2218814e7693SSteen Hegelund if (!eport) 2219814e7693SSteen Hegelund return false; 2220814e7693SSteen Hegelund 2221814e7693SSteen Hegelund tmp = eport->dst_cid; 22220518e914SSteen Hegelund while (tmp != cid && tmp != 0) 2223814e7693SSteen Hegelund tmp = vcap_get_next_chain(vctrl, ndev, tmp); 2224814e7693SSteen Hegelund 2225814e7693SSteen Hegelund return !!tmp; 2226814e7693SSteen Hegelund } 2227814e7693SSteen Hegelund 2228814e7693SSteen Hegelund /* Internal clients can always store their rules in HW 2229814e7693SSteen Hegelund * External clients can store their rules if the chain is enabled all 2230814e7693SSteen Hegelund * the way from chain 0, otherwise the rule will be cached until 2231814e7693SSteen Hegelund * the chain is enabled. 2232814e7693SSteen Hegelund */ 2233814e7693SSteen Hegelund static void vcap_rule_set_state(struct vcap_rule_internal *ri) 2234814e7693SSteen Hegelund { 2235814e7693SSteen Hegelund if (ri->data.user <= VCAP_USER_QOS) 2236814e7693SSteen Hegelund ri->state = VCAP_RS_PERMANENT; 2237814e7693SSteen Hegelund else if (vcap_path_exist(ri->vctrl, ri->ndev, ri->data.vcap_chain_id)) 2238814e7693SSteen Hegelund ri->state = VCAP_RS_ENABLED; 2239814e7693SSteen Hegelund else 2240814e7693SSteen Hegelund ri->state = VCAP_RS_DISABLED; 2241814e7693SSteen Hegelund } 2242814e7693SSteen Hegelund 2243c9da1ac1SSteen Hegelund /* Encode and write a validated rule to the VCAP */ 2244c9da1ac1SSteen Hegelund int vcap_add_rule(struct vcap_rule *rule) 2245c9da1ac1SSteen Hegelund { 22468e10490bSSteen Hegelund struct vcap_rule_internal *ri = to_intrule(rule); 22478e10490bSSteen Hegelund struct vcap_rule_move move = {0}; 224895fa7414SSteen Hegelund struct vcap_counter ctr = {0}; 22498e10490bSSteen Hegelund int ret; 22508e10490bSSteen Hegelund 22518e10490bSSteen Hegelund ret = vcap_api_check(ri->vctrl); 22528e10490bSSteen Hegelund if (ret) 22538e10490bSSteen Hegelund return ret; 22548e10490bSSteen Hegelund /* Insert the new rule in the list of vcap rules */ 225571c9de99SSteen Hegelund mutex_lock(&ri->admin->lock); 2256814e7693SSteen Hegelund 2257814e7693SSteen Hegelund vcap_rule_set_state(ri); 22588e10490bSSteen Hegelund ret = vcap_insert_rule(ri, &move); 22598e10490bSSteen Hegelund if (ret < 0) { 22608e10490bSSteen Hegelund pr_err("%s:%d: could not insert rule in vcap list: %d\n", 22618e10490bSSteen Hegelund __func__, __LINE__, ret); 22628e10490bSSteen Hegelund goto out; 22638e10490bSSteen Hegelund } 22648e10490bSSteen Hegelund if (move.count > 0) 22658e10490bSSteen Hegelund vcap_move_rules(ri, &move); 2266814e7693SSteen Hegelund 2267d7953da4SSteen Hegelund /* Set the counter to zero */ 2268d7953da4SSteen Hegelund ret = vcap_write_counter(ri, &ctr); 2269d7953da4SSteen Hegelund if (ret) 2270d7953da4SSteen Hegelund goto out; 2271d7953da4SSteen Hegelund 2272814e7693SSteen Hegelund if (ri->state == VCAP_RS_DISABLED) { 2273814e7693SSteen Hegelund /* Erase the rule area */ 2274814e7693SSteen Hegelund ri->vctrl->ops->init(ri->ndev, ri->admin, ri->addr, ri->size); 2275814e7693SSteen Hegelund goto out; 2276814e7693SSteen Hegelund } 2277814e7693SSteen Hegelund 22786573f71aSSteen Hegelund vcap_erase_cache(ri); 22798e10490bSSteen Hegelund ret = vcap_encode_rule(ri); 22808e10490bSSteen Hegelund if (ret) { 22818e10490bSSteen Hegelund pr_err("%s:%d: rule encoding error: %d\n", __func__, __LINE__, ret); 22828e10490bSSteen Hegelund goto out; 22838e10490bSSteen Hegelund } 22848e10490bSSteen Hegelund 22858e10490bSSteen Hegelund ret = vcap_write_rule(ri); 228695fa7414SSteen Hegelund if (ret) { 22878e10490bSSteen Hegelund pr_err("%s:%d: rule write error: %d\n", __func__, __LINE__, ret); 228895fa7414SSteen Hegelund goto out; 228995fa7414SSteen Hegelund } 22908e10490bSSteen Hegelund out: 229171c9de99SSteen Hegelund mutex_unlock(&ri->admin->lock); 22928e10490bSSteen Hegelund return ret; 2293c9da1ac1SSteen Hegelund } 2294c9da1ac1SSteen Hegelund EXPORT_SYMBOL_GPL(vcap_add_rule); 2295c9da1ac1SSteen Hegelund 2296c9da1ac1SSteen Hegelund /* Allocate a new rule with the provided arguments */ 2297c9da1ac1SSteen Hegelund struct vcap_rule *vcap_alloc_rule(struct vcap_control *vctrl, 2298c9da1ac1SSteen Hegelund struct net_device *ndev, int vcap_chain_id, 2299c9da1ac1SSteen Hegelund enum vcap_user user, u16 priority, 2300c9da1ac1SSteen Hegelund u32 id) 2301c9da1ac1SSteen Hegelund { 2302c9da1ac1SSteen Hegelund struct vcap_rule_internal *ri; 2303c9da1ac1SSteen Hegelund struct vcap_admin *admin; 2304990e4839SSteen Hegelund int err, maxsize; 2305c9da1ac1SSteen Hegelund 2306990e4839SSteen Hegelund err = vcap_api_check(vctrl); 2307990e4839SSteen Hegelund if (err) 2308990e4839SSteen Hegelund return ERR_PTR(err); 2309c9da1ac1SSteen Hegelund if (!ndev) 2310c9da1ac1SSteen Hegelund return ERR_PTR(-ENODEV); 2311c9da1ac1SSteen Hegelund /* Get the VCAP instance */ 2312c9da1ac1SSteen Hegelund admin = vcap_find_admin(vctrl, vcap_chain_id); 2313c9da1ac1SSteen Hegelund if (!admin) 2314c9da1ac1SSteen Hegelund return ERR_PTR(-ENOENT); 23158e10490bSSteen Hegelund /* Sanity check that this VCAP is supported on this platform */ 23168e10490bSSteen Hegelund if (vctrl->vcaps[admin->vtype].rows == 0) 23178e10490bSSteen Hegelund return ERR_PTR(-EINVAL); 23181972b6d9SSteen Hegelund 23191972b6d9SSteen Hegelund mutex_lock(&admin->lock); 23208e10490bSSteen Hegelund /* Check if a rule with this id already exists */ 23211972b6d9SSteen Hegelund if (vcap_rule_exists(vctrl, id)) { 23221972b6d9SSteen Hegelund err = -EINVAL; 23231972b6d9SSteen Hegelund goto out_unlock; 23241972b6d9SSteen Hegelund } 23251972b6d9SSteen Hegelund 23268e10490bSSteen Hegelund /* Check if there is room for the rule in the block(s) of the VCAP */ 23278e10490bSSteen Hegelund maxsize = vctrl->vcaps[admin->vtype].sw_count; /* worst case rule size */ 23281972b6d9SSteen Hegelund if (vcap_rule_space(admin, maxsize)) { 23291972b6d9SSteen Hegelund err = -ENOSPC; 23301972b6d9SSteen Hegelund goto out_unlock; 23311972b6d9SSteen Hegelund } 23321972b6d9SSteen Hegelund 2333c9da1ac1SSteen Hegelund /* Create a container for the rule and return it */ 2334c9da1ac1SSteen Hegelund ri = kzalloc(sizeof(*ri), GFP_KERNEL); 23351972b6d9SSteen Hegelund if (!ri) { 23361972b6d9SSteen Hegelund err = -ENOMEM; 23371972b6d9SSteen Hegelund goto out_unlock; 23381972b6d9SSteen Hegelund } 23391972b6d9SSteen Hegelund 2340c9da1ac1SSteen Hegelund ri->data.vcap_chain_id = vcap_chain_id; 2341c9da1ac1SSteen Hegelund ri->data.user = user; 2342c9da1ac1SSteen Hegelund ri->data.priority = priority; 2343c9da1ac1SSteen Hegelund ri->data.id = id; 2344c9da1ac1SSteen Hegelund ri->data.keyset = VCAP_KFS_NO_VALUE; 2345c9da1ac1SSteen Hegelund ri->data.actionset = VCAP_AFS_NO_VALUE; 2346c9da1ac1SSteen Hegelund INIT_LIST_HEAD(&ri->list); 2347c9da1ac1SSteen Hegelund INIT_LIST_HEAD(&ri->data.keyfields); 2348c9da1ac1SSteen Hegelund INIT_LIST_HEAD(&ri->data.actionfields); 2349c9da1ac1SSteen Hegelund ri->ndev = ndev; 2350c9da1ac1SSteen Hegelund ri->admin = admin; /* refer to the vcap instance */ 2351c9da1ac1SSteen Hegelund ri->vctrl = vctrl; /* refer to the client */ 23521972b6d9SSteen Hegelund 23531972b6d9SSteen Hegelund if (vcap_set_rule_id(ri) == 0) { 23541972b6d9SSteen Hegelund err = -EINVAL; 2355c9da1ac1SSteen Hegelund goto out_free; 23561972b6d9SSteen Hegelund } 23571972b6d9SSteen Hegelund 23581972b6d9SSteen Hegelund mutex_unlock(&admin->lock); 2359c9da1ac1SSteen Hegelund return (struct vcap_rule *)ri; 2360c9da1ac1SSteen Hegelund 2361c9da1ac1SSteen Hegelund out_free: 2362c9da1ac1SSteen Hegelund kfree(ri); 23631972b6d9SSteen Hegelund out_unlock: 23641972b6d9SSteen Hegelund mutex_unlock(&admin->lock); 23651972b6d9SSteen Hegelund return ERR_PTR(err); 23661972b6d9SSteen Hegelund 2367c9da1ac1SSteen Hegelund } 2368c9da1ac1SSteen Hegelund EXPORT_SYMBOL_GPL(vcap_alloc_rule); 2369c9da1ac1SSteen Hegelund 2370c9da1ac1SSteen Hegelund /* Free mem of a rule owned by client after the rule as been added to the VCAP */ 2371c9da1ac1SSteen Hegelund void vcap_free_rule(struct vcap_rule *rule) 2372c9da1ac1SSteen Hegelund { 2373c9da1ac1SSteen Hegelund struct vcap_rule_internal *ri = to_intrule(rule); 2374c9da1ac1SSteen Hegelund struct vcap_client_actionfield *caf, *next_caf; 2375c9da1ac1SSteen Hegelund struct vcap_client_keyfield *ckf, *next_ckf; 2376c9da1ac1SSteen Hegelund 2377c9da1ac1SSteen Hegelund /* Deallocate the list of keys and actions */ 2378c9da1ac1SSteen Hegelund list_for_each_entry_safe(ckf, next_ckf, &ri->data.keyfields, ctrl.list) { 2379c9da1ac1SSteen Hegelund list_del(&ckf->ctrl.list); 2380c9da1ac1SSteen Hegelund kfree(ckf); 2381c9da1ac1SSteen Hegelund } 2382c9da1ac1SSteen Hegelund list_for_each_entry_safe(caf, next_caf, &ri->data.actionfields, ctrl.list) { 2383c9da1ac1SSteen Hegelund list_del(&caf->ctrl.list); 2384c9da1ac1SSteen Hegelund kfree(caf); 2385c9da1ac1SSteen Hegelund } 2386c9da1ac1SSteen Hegelund /* Deallocate the rule */ 2387c9da1ac1SSteen Hegelund kfree(rule); 2388c9da1ac1SSteen Hegelund } 2389c9da1ac1SSteen Hegelund EXPORT_SYMBOL_GPL(vcap_free_rule); 2390c9da1ac1SSteen Hegelund 23919579e2c2SSteen Hegelund /* Decode a rule from the VCAP cache and return a copy */ 23929579e2c2SSteen Hegelund struct vcap_rule *vcap_decode_rule(struct vcap_rule_internal *elem) 2393610c32b2SHoratiu Vultur { 2394610c32b2SHoratiu Vultur struct vcap_rule_internal *ri; 2395610c32b2SHoratiu Vultur int err; 2396610c32b2SHoratiu Vultur 23979579e2c2SSteen Hegelund ri = vcap_dup_rule(elem, elem->state == VCAP_RS_DISABLED); 23989579e2c2SSteen Hegelund if (IS_ERR(ri)) 23999579e2c2SSteen Hegelund return ERR_PTR(PTR_ERR(ri)); 24009579e2c2SSteen Hegelund 24019579e2c2SSteen Hegelund if (ri->state == VCAP_RS_DISABLED) 24029579e2c2SSteen Hegelund goto out; 24039579e2c2SSteen Hegelund 24049579e2c2SSteen Hegelund err = vcap_read_rule(ri); 24059579e2c2SSteen Hegelund if (err) 24069579e2c2SSteen Hegelund return ERR_PTR(err); 24079579e2c2SSteen Hegelund 24089579e2c2SSteen Hegelund err = vcap_decode_keyset(ri); 24099579e2c2SSteen Hegelund if (err) 24109579e2c2SSteen Hegelund return ERR_PTR(err); 24119579e2c2SSteen Hegelund 24129579e2c2SSteen Hegelund err = vcap_decode_actionset(ri); 24139579e2c2SSteen Hegelund if (err) 24149579e2c2SSteen Hegelund return ERR_PTR(err); 24159579e2c2SSteen Hegelund 24169579e2c2SSteen Hegelund out: 24179579e2c2SSteen Hegelund return &ri->data; 24189579e2c2SSteen Hegelund } 24199579e2c2SSteen Hegelund 24209579e2c2SSteen Hegelund struct vcap_rule *vcap_get_rule(struct vcap_control *vctrl, u32 id) 24219579e2c2SSteen Hegelund { 24229579e2c2SSteen Hegelund struct vcap_rule_internal *elem; 24239579e2c2SSteen Hegelund struct vcap_rule *rule; 24249579e2c2SSteen Hegelund int err; 2425610c32b2SHoratiu Vultur 2426610c32b2SHoratiu Vultur err = vcap_api_check(vctrl); 2427610c32b2SHoratiu Vultur if (err) 2428610c32b2SHoratiu Vultur return ERR_PTR(err); 24299579e2c2SSteen Hegelund 24301972b6d9SSteen Hegelund elem = vcap_get_locked_rule(vctrl, id); 2431610c32b2SHoratiu Vultur if (!elem) 2432610c32b2SHoratiu Vultur return NULL; 24339579e2c2SSteen Hegelund 24349579e2c2SSteen Hegelund rule = vcap_decode_rule(elem); 2435610c32b2SHoratiu Vultur mutex_unlock(&elem->admin->lock); 24369579e2c2SSteen Hegelund return rule; 2437610c32b2SHoratiu Vultur } 2438610c32b2SHoratiu Vultur EXPORT_SYMBOL_GPL(vcap_get_rule); 2439610c32b2SHoratiu Vultur 24402662b3f9SHoratiu Vultur /* Update existing rule */ 24412662b3f9SHoratiu Vultur int vcap_mod_rule(struct vcap_rule *rule) 24422662b3f9SHoratiu Vultur { 24432662b3f9SHoratiu Vultur struct vcap_rule_internal *ri = to_intrule(rule); 24442662b3f9SHoratiu Vultur struct vcap_counter ctr; 24452662b3f9SHoratiu Vultur int err; 24462662b3f9SHoratiu Vultur 24472662b3f9SHoratiu Vultur err = vcap_api_check(ri->vctrl); 24482662b3f9SHoratiu Vultur if (err) 24492662b3f9SHoratiu Vultur return err; 24502662b3f9SHoratiu Vultur 24511972b6d9SSteen Hegelund if (!vcap_get_locked_rule(ri->vctrl, ri->data.id)) 24522662b3f9SHoratiu Vultur return -ENOENT; 24532662b3f9SHoratiu Vultur 2454814e7693SSteen Hegelund vcap_rule_set_state(ri); 2455814e7693SSteen Hegelund if (ri->state == VCAP_RS_DISABLED) 2456814e7693SSteen Hegelund goto out; 2457814e7693SSteen Hegelund 24582662b3f9SHoratiu Vultur /* Encode the bitstreams to the VCAP cache */ 24592662b3f9SHoratiu Vultur vcap_erase_cache(ri); 24602662b3f9SHoratiu Vultur err = vcap_encode_rule(ri); 24612662b3f9SHoratiu Vultur if (err) 24622662b3f9SHoratiu Vultur goto out; 24632662b3f9SHoratiu Vultur 24642662b3f9SHoratiu Vultur err = vcap_write_rule(ri); 24652662b3f9SHoratiu Vultur if (err) 24662662b3f9SHoratiu Vultur goto out; 24672662b3f9SHoratiu Vultur 24682662b3f9SHoratiu Vultur memset(&ctr, 0, sizeof(ctr)); 24692662b3f9SHoratiu Vultur err = vcap_write_counter(ri, &ctr); 24702662b3f9SHoratiu Vultur 24712662b3f9SHoratiu Vultur out: 24722662b3f9SHoratiu Vultur mutex_unlock(&ri->admin->lock); 24732662b3f9SHoratiu Vultur return err; 24742662b3f9SHoratiu Vultur } 24752662b3f9SHoratiu Vultur EXPORT_SYMBOL_GPL(vcap_mod_rule); 24762662b3f9SHoratiu Vultur 2477990e4839SSteen Hegelund /* Return the alignment offset for a new rule address */ 2478990e4839SSteen Hegelund static int vcap_valid_rule_move(struct vcap_rule_internal *el, int offset) 2479990e4839SSteen Hegelund { 2480990e4839SSteen Hegelund return (el->addr + offset) % el->size; 2481990e4839SSteen Hegelund } 2482990e4839SSteen Hegelund 2483990e4839SSteen Hegelund /* Update the rule address with an offset */ 2484990e4839SSteen Hegelund static void vcap_adjust_rule_addr(struct vcap_rule_internal *el, int offset) 2485990e4839SSteen Hegelund { 2486990e4839SSteen Hegelund el->addr += offset; 2487990e4839SSteen Hegelund } 2488990e4839SSteen Hegelund 2489990e4839SSteen Hegelund /* Rules needs to be moved to fill the gap of the deleted rule */ 2490990e4839SSteen Hegelund static int vcap_fill_rule_gap(struct vcap_rule_internal *ri) 2491990e4839SSteen Hegelund { 2492990e4839SSteen Hegelund struct vcap_admin *admin = ri->admin; 2493990e4839SSteen Hegelund struct vcap_rule_internal *elem; 2494990e4839SSteen Hegelund struct vcap_rule_move move; 2495990e4839SSteen Hegelund int gap = 0, offset = 0; 2496990e4839SSteen Hegelund 2497990e4839SSteen Hegelund /* If the first rule is deleted: Move other rules to the top */ 2498990e4839SSteen Hegelund if (list_is_first(&ri->list, &admin->rules)) 2499990e4839SSteen Hegelund offset = admin->last_valid_addr + 1 - ri->addr - ri->size; 2500990e4839SSteen Hegelund 2501990e4839SSteen Hegelund /* Locate gaps between odd size rules and adjust the move */ 2502990e4839SSteen Hegelund elem = ri; 2503990e4839SSteen Hegelund list_for_each_entry_continue(elem, &admin->rules, list) 2504990e4839SSteen Hegelund gap += vcap_valid_rule_move(elem, ri->size); 2505990e4839SSteen Hegelund 2506990e4839SSteen Hegelund /* Update the address in the remaining rules in the list */ 2507990e4839SSteen Hegelund elem = ri; 2508990e4839SSteen Hegelund list_for_each_entry_continue(elem, &admin->rules, list) 2509990e4839SSteen Hegelund vcap_adjust_rule_addr(elem, ri->size + gap + offset); 2510990e4839SSteen Hegelund 2511990e4839SSteen Hegelund /* Update the move info */ 2512990e4839SSteen Hegelund move.addr = admin->last_used_addr; 2513990e4839SSteen Hegelund move.count = ri->addr - admin->last_used_addr - gap; 2514990e4839SSteen Hegelund move.offset = -(ri->size + gap + offset); 2515990e4839SSteen Hegelund 2516990e4839SSteen Hegelund /* Do the actual move operation */ 2517990e4839SSteen Hegelund vcap_move_rules(ri, &move); 2518990e4839SSteen Hegelund 2519990e4839SSteen Hegelund return gap + offset; 2520990e4839SSteen Hegelund } 2521990e4839SSteen Hegelund 2522c9da1ac1SSteen Hegelund /* Delete rule in a VCAP instance */ 2523c9da1ac1SSteen Hegelund int vcap_del_rule(struct vcap_control *vctrl, struct net_device *ndev, u32 id) 2524c9da1ac1SSteen Hegelund { 2525c9da1ac1SSteen Hegelund struct vcap_rule_internal *ri, *elem; 2526c9da1ac1SSteen Hegelund struct vcap_admin *admin; 2527990e4839SSteen Hegelund int gap = 0, err; 2528c9da1ac1SSteen Hegelund 2529c9da1ac1SSteen Hegelund /* This will later also handle rule moving */ 2530c9da1ac1SSteen Hegelund if (!ndev) 2531c9da1ac1SSteen Hegelund return -ENODEV; 25328e10490bSSteen Hegelund err = vcap_api_check(vctrl); 25338e10490bSSteen Hegelund if (err) 25348e10490bSSteen Hegelund return err; 2535c9da1ac1SSteen Hegelund /* Look for the rule id in all vcaps */ 25361972b6d9SSteen Hegelund ri = vcap_get_locked_rule(vctrl, id); 2537c9da1ac1SSteen Hegelund if (!ri) 25381972b6d9SSteen Hegelund return -ENOENT; 25391972b6d9SSteen Hegelund 2540c9da1ac1SSteen Hegelund admin = ri->admin; 25418e10490bSSteen Hegelund 2542990e4839SSteen Hegelund if (ri->addr > admin->last_used_addr) 2543990e4839SSteen Hegelund gap = vcap_fill_rule_gap(ri); 2544990e4839SSteen Hegelund 2545990e4839SSteen Hegelund /* Delete the rule from the list of rules and the cache */ 2546990e4839SSteen Hegelund list_del(&ri->list); 2547990e4839SSteen Hegelund vctrl->ops->init(ndev, admin, admin->last_used_addr, ri->size + gap); 2548814e7693SSteen Hegelund vcap_free_rule(&ri->data); 2549990e4839SSteen Hegelund 2550277e9179SSteen Hegelund /* Update the last used address, set to default when no rules */ 2551c9da1ac1SSteen Hegelund if (list_empty(&admin->rules)) { 2552277e9179SSteen Hegelund admin->last_used_addr = admin->last_valid_addr + 1; 2553c9da1ac1SSteen Hegelund } else { 2554990e4839SSteen Hegelund elem = list_last_entry(&admin->rules, struct vcap_rule_internal, 2555990e4839SSteen Hegelund list); 2556c9da1ac1SSteen Hegelund admin->last_used_addr = elem->addr; 2557c9da1ac1SSteen Hegelund } 25581972b6d9SSteen Hegelund 25591972b6d9SSteen Hegelund mutex_unlock(&admin->lock); 25601972b6d9SSteen Hegelund return err; 2561c9da1ac1SSteen Hegelund } 2562c9da1ac1SSteen Hegelund EXPORT_SYMBOL_GPL(vcap_del_rule); 2563c9da1ac1SSteen Hegelund 25648e10490bSSteen Hegelund /* Delete all rules in the VCAP instance */ 25658e10490bSSteen Hegelund int vcap_del_rules(struct vcap_control *vctrl, struct vcap_admin *admin) 25668e10490bSSteen Hegelund { 256767456717SSteen Hegelund struct vcap_enabled_port *eport, *next_eport; 25688e10490bSSteen Hegelund struct vcap_rule_internal *ri, *next_ri; 25698e10490bSSteen Hegelund int ret = vcap_api_check(vctrl); 25708e10490bSSteen Hegelund 25718e10490bSSteen Hegelund if (ret) 25728e10490bSSteen Hegelund return ret; 257371c9de99SSteen Hegelund 257471c9de99SSteen Hegelund mutex_lock(&admin->lock); 25758e10490bSSteen Hegelund list_for_each_entry_safe(ri, next_ri, &admin->rules, list) { 25768e10490bSSteen Hegelund vctrl->ops->init(ri->ndev, admin, ri->addr, ri->size); 25778e10490bSSteen Hegelund list_del(&ri->list); 2578814e7693SSteen Hegelund vcap_free_rule(&ri->data); 25798e10490bSSteen Hegelund } 25808e10490bSSteen Hegelund admin->last_used_addr = admin->last_valid_addr; 258167456717SSteen Hegelund 258267456717SSteen Hegelund /* Remove list of enabled ports */ 258367456717SSteen Hegelund list_for_each_entry_safe(eport, next_eport, &admin->enabled, list) { 258467456717SSteen Hegelund list_del(&eport->list); 258567456717SSteen Hegelund kfree(eport); 258667456717SSteen Hegelund } 258771c9de99SSteen Hegelund mutex_unlock(&admin->lock); 258867456717SSteen Hegelund 25898e10490bSSteen Hegelund return 0; 25908e10490bSSteen Hegelund } 25918e10490bSSteen Hegelund EXPORT_SYMBOL_GPL(vcap_del_rules); 25928e10490bSSteen Hegelund 2593465a38a2SSteen Hegelund /* Find a client key field in a rule */ 2594465a38a2SSteen Hegelund static struct vcap_client_keyfield * 2595465a38a2SSteen Hegelund vcap_find_keyfield(struct vcap_rule *rule, enum vcap_key_field key) 2596465a38a2SSteen Hegelund { 2597465a38a2SSteen Hegelund struct vcap_rule_internal *ri = to_intrule(rule); 2598465a38a2SSteen Hegelund struct vcap_client_keyfield *ckf; 2599465a38a2SSteen Hegelund 2600465a38a2SSteen Hegelund list_for_each_entry(ckf, &ri->data.keyfields, ctrl.list) 2601465a38a2SSteen Hegelund if (ckf->ctrl.key == key) 2602465a38a2SSteen Hegelund return ckf; 2603465a38a2SSteen Hegelund return NULL; 2604465a38a2SSteen Hegelund } 2605465a38a2SSteen Hegelund 260646be056eSSteen Hegelund /* Find information on a key field in a rule */ 260746be056eSSteen Hegelund const struct vcap_field *vcap_lookup_keyfield(struct vcap_rule *rule, 260846be056eSSteen Hegelund enum vcap_key_field key) 260946be056eSSteen Hegelund { 26108e10490bSSteen Hegelund struct vcap_rule_internal *ri = to_intrule(rule); 261146be056eSSteen Hegelund enum vcap_keyfield_set keyset = rule->keyset; 261246be056eSSteen Hegelund enum vcap_type vt = ri->admin->vtype; 261346be056eSSteen Hegelund const struct vcap_field *fields; 261446be056eSSteen Hegelund 261546be056eSSteen Hegelund if (keyset == VCAP_KFS_NO_VALUE) 261646be056eSSteen Hegelund return NULL; 261746be056eSSteen Hegelund fields = vcap_keyfields(ri->vctrl, vt, keyset); 261846be056eSSteen Hegelund if (!fields) 261946be056eSSteen Hegelund return NULL; 262046be056eSSteen Hegelund return &fields[key]; 262146be056eSSteen Hegelund } 262246be056eSSteen Hegelund EXPORT_SYMBOL_GPL(vcap_lookup_keyfield); 262346be056eSSteen Hegelund 2624242df4f7SSteen Hegelund /* Check if the keyfield is already in the rule */ 2625242df4f7SSteen Hegelund static bool vcap_keyfield_unique(struct vcap_rule *rule, 2626242df4f7SSteen Hegelund enum vcap_key_field key) 2627242df4f7SSteen Hegelund { 2628242df4f7SSteen Hegelund struct vcap_rule_internal *ri = to_intrule(rule); 2629242df4f7SSteen Hegelund const struct vcap_client_keyfield *ckf; 2630242df4f7SSteen Hegelund 2631242df4f7SSteen Hegelund list_for_each_entry(ckf, &ri->data.keyfields, ctrl.list) 2632242df4f7SSteen Hegelund if (ckf->ctrl.key == key) 2633242df4f7SSteen Hegelund return false; 2634242df4f7SSteen Hegelund return true; 2635242df4f7SSteen Hegelund } 2636242df4f7SSteen Hegelund 2637242df4f7SSteen Hegelund /* Check if the keyfield is in the keyset */ 2638242df4f7SSteen Hegelund static bool vcap_keyfield_match_keyset(struct vcap_rule *rule, 2639242df4f7SSteen Hegelund enum vcap_key_field key) 2640242df4f7SSteen Hegelund { 2641242df4f7SSteen Hegelund struct vcap_rule_internal *ri = to_intrule(rule); 2642242df4f7SSteen Hegelund enum vcap_keyfield_set keyset = rule->keyset; 2643242df4f7SSteen Hegelund enum vcap_type vt = ri->admin->vtype; 2644242df4f7SSteen Hegelund const struct vcap_field *fields; 2645242df4f7SSteen Hegelund 2646242df4f7SSteen Hegelund /* the field is accepted if the rule has no keyset yet */ 2647242df4f7SSteen Hegelund if (keyset == VCAP_KFS_NO_VALUE) 2648242df4f7SSteen Hegelund return true; 2649242df4f7SSteen Hegelund fields = vcap_keyfields(ri->vctrl, vt, keyset); 2650242df4f7SSteen Hegelund if (!fields) 2651242df4f7SSteen Hegelund return false; 2652242df4f7SSteen Hegelund /* if there is a width there is a way */ 2653242df4f7SSteen Hegelund return fields[key].width > 0; 2654242df4f7SSteen Hegelund } 2655242df4f7SSteen Hegelund 2656c9da1ac1SSteen Hegelund static int vcap_rule_add_key(struct vcap_rule *rule, 2657c9da1ac1SSteen Hegelund enum vcap_key_field key, 2658c9da1ac1SSteen Hegelund enum vcap_field_type ftype, 2659c9da1ac1SSteen Hegelund struct vcap_client_keyfield_data *data) 2660c9da1ac1SSteen Hegelund { 2661242df4f7SSteen Hegelund struct vcap_rule_internal *ri = to_intrule(rule); 2662c9da1ac1SSteen Hegelund struct vcap_client_keyfield *field; 2663c9da1ac1SSteen Hegelund 2664242df4f7SSteen Hegelund if (!vcap_keyfield_unique(rule, key)) { 2665242df4f7SSteen Hegelund pr_warn("%s:%d: keyfield %s is already in the rule\n", 2666242df4f7SSteen Hegelund __func__, __LINE__, 2667242df4f7SSteen Hegelund vcap_keyfield_name(ri->vctrl, key)); 2668242df4f7SSteen Hegelund return -EINVAL; 2669242df4f7SSteen Hegelund } 2670242df4f7SSteen Hegelund 2671242df4f7SSteen Hegelund if (!vcap_keyfield_match_keyset(rule, key)) { 2672242df4f7SSteen Hegelund pr_err("%s:%d: keyfield %s does not belong in the rule keyset\n", 2673242df4f7SSteen Hegelund __func__, __LINE__, 2674242df4f7SSteen Hegelund vcap_keyfield_name(ri->vctrl, key)); 2675242df4f7SSteen Hegelund return -EINVAL; 2676242df4f7SSteen Hegelund } 2677242df4f7SSteen Hegelund 2678c9da1ac1SSteen Hegelund field = kzalloc(sizeof(*field), GFP_KERNEL); 2679c9da1ac1SSteen Hegelund if (!field) 2680c9da1ac1SSteen Hegelund return -ENOMEM; 268133e3a273SSteen Hegelund memcpy(&field->data, data, sizeof(field->data)); 2682c9da1ac1SSteen Hegelund field->ctrl.key = key; 2683c9da1ac1SSteen Hegelund field->ctrl.type = ftype; 2684c9da1ac1SSteen Hegelund list_add_tail(&field->ctrl.list, &rule->keyfields); 2685c9da1ac1SSteen Hegelund return 0; 2686c9da1ac1SSteen Hegelund } 2687c9da1ac1SSteen Hegelund 268846be056eSSteen Hegelund static void vcap_rule_set_key_bitsize(struct vcap_u1_key *u1, enum vcap_bit val) 268946be056eSSteen Hegelund { 269046be056eSSteen Hegelund switch (val) { 269146be056eSSteen Hegelund case VCAP_BIT_0: 269246be056eSSteen Hegelund u1->value = 0; 269346be056eSSteen Hegelund u1->mask = 1; 269446be056eSSteen Hegelund break; 269546be056eSSteen Hegelund case VCAP_BIT_1: 269646be056eSSteen Hegelund u1->value = 1; 269746be056eSSteen Hegelund u1->mask = 1; 269846be056eSSteen Hegelund break; 269946be056eSSteen Hegelund case VCAP_BIT_ANY: 270046be056eSSteen Hegelund u1->value = 0; 270146be056eSSteen Hegelund u1->mask = 0; 270246be056eSSteen Hegelund break; 270346be056eSSteen Hegelund } 270446be056eSSteen Hegelund } 270546be056eSSteen Hegelund 270646be056eSSteen Hegelund /* Add a bit key with value and mask to the rule */ 270746be056eSSteen Hegelund int vcap_rule_add_key_bit(struct vcap_rule *rule, enum vcap_key_field key, 270846be056eSSteen Hegelund enum vcap_bit val) 270946be056eSSteen Hegelund { 271046be056eSSteen Hegelund struct vcap_client_keyfield_data data; 271146be056eSSteen Hegelund 271246be056eSSteen Hegelund vcap_rule_set_key_bitsize(&data.u1, val); 271346be056eSSteen Hegelund return vcap_rule_add_key(rule, key, VCAP_FIELD_BIT, &data); 271446be056eSSteen Hegelund } 271546be056eSSteen Hegelund EXPORT_SYMBOL_GPL(vcap_rule_add_key_bit); 271646be056eSSteen Hegelund 271746be056eSSteen Hegelund /* Add a 32 bit key field with value and mask to the rule */ 271846be056eSSteen Hegelund int vcap_rule_add_key_u32(struct vcap_rule *rule, enum vcap_key_field key, 271946be056eSSteen Hegelund u32 value, u32 mask) 272046be056eSSteen Hegelund { 272146be056eSSteen Hegelund struct vcap_client_keyfield_data data; 272246be056eSSteen Hegelund 272346be056eSSteen Hegelund data.u32.value = value; 272446be056eSSteen Hegelund data.u32.mask = mask; 272546be056eSSteen Hegelund return vcap_rule_add_key(rule, key, VCAP_FIELD_U32, &data); 272646be056eSSteen Hegelund } 272746be056eSSteen Hegelund EXPORT_SYMBOL_GPL(vcap_rule_add_key_u32); 272846be056eSSteen Hegelund 2729c9da1ac1SSteen Hegelund /* Add a 48 bit key with value and mask to the rule */ 2730c9da1ac1SSteen Hegelund int vcap_rule_add_key_u48(struct vcap_rule *rule, enum vcap_key_field key, 2731c9da1ac1SSteen Hegelund struct vcap_u48_key *fieldval) 2732c9da1ac1SSteen Hegelund { 2733c9da1ac1SSteen Hegelund struct vcap_client_keyfield_data data; 2734c9da1ac1SSteen Hegelund 2735c9da1ac1SSteen Hegelund memcpy(&data.u48, fieldval, sizeof(data.u48)); 2736c9da1ac1SSteen Hegelund return vcap_rule_add_key(rule, key, VCAP_FIELD_U48, &data); 2737c9da1ac1SSteen Hegelund } 2738c9da1ac1SSteen Hegelund EXPORT_SYMBOL_GPL(vcap_rule_add_key_u48); 2739c9da1ac1SSteen Hegelund 274046be056eSSteen Hegelund /* Add a 72 bit key with value and mask to the rule */ 274146be056eSSteen Hegelund int vcap_rule_add_key_u72(struct vcap_rule *rule, enum vcap_key_field key, 274246be056eSSteen Hegelund struct vcap_u72_key *fieldval) 274346be056eSSteen Hegelund { 274446be056eSSteen Hegelund struct vcap_client_keyfield_data data; 274546be056eSSteen Hegelund 274646be056eSSteen Hegelund memcpy(&data.u72, fieldval, sizeof(data.u72)); 274746be056eSSteen Hegelund return vcap_rule_add_key(rule, key, VCAP_FIELD_U72, &data); 274846be056eSSteen Hegelund } 274946be056eSSteen Hegelund EXPORT_SYMBOL_GPL(vcap_rule_add_key_u72); 275046be056eSSteen Hegelund 2751d6c2964dSSteen Hegelund /* Add a 128 bit key with value and mask to the rule */ 2752d6c2964dSSteen Hegelund int vcap_rule_add_key_u128(struct vcap_rule *rule, enum vcap_key_field key, 2753d6c2964dSSteen Hegelund struct vcap_u128_key *fieldval) 2754d6c2964dSSteen Hegelund { 2755d6c2964dSSteen Hegelund struct vcap_client_keyfield_data data; 2756d6c2964dSSteen Hegelund 2757d6c2964dSSteen Hegelund memcpy(&data.u128, fieldval, sizeof(data.u128)); 2758d6c2964dSSteen Hegelund return vcap_rule_add_key(rule, key, VCAP_FIELD_U128, &data); 2759d6c2964dSSteen Hegelund } 2760d6c2964dSSteen Hegelund EXPORT_SYMBOL_GPL(vcap_rule_add_key_u128); 2761d6c2964dSSteen Hegelund 27626009b61fSHoratiu Vultur int vcap_rule_get_key_u32(struct vcap_rule *rule, enum vcap_key_field key, 27636009b61fSHoratiu Vultur u32 *value, u32 *mask) 27646009b61fSHoratiu Vultur { 27656009b61fSHoratiu Vultur struct vcap_client_keyfield *ckf; 27666009b61fSHoratiu Vultur 27676009b61fSHoratiu Vultur ckf = vcap_find_keyfield(rule, key); 27686009b61fSHoratiu Vultur if (!ckf) 27696009b61fSHoratiu Vultur return -ENOENT; 27706009b61fSHoratiu Vultur 27716009b61fSHoratiu Vultur *value = ckf->data.u32.value; 27726009b61fSHoratiu Vultur *mask = ckf->data.u32.mask; 27736009b61fSHoratiu Vultur 27746009b61fSHoratiu Vultur return 0; 27756009b61fSHoratiu Vultur } 27766009b61fSHoratiu Vultur EXPORT_SYMBOL_GPL(vcap_rule_get_key_u32); 27776009b61fSHoratiu Vultur 2778465a38a2SSteen Hegelund /* Find a client action field in a rule */ 27796ebf182bSDaniel Machon struct vcap_client_actionfield * 2780465a38a2SSteen Hegelund vcap_find_actionfield(struct vcap_rule *rule, enum vcap_action_field act) 2781465a38a2SSteen Hegelund { 2782465a38a2SSteen Hegelund struct vcap_rule_internal *ri = (struct vcap_rule_internal *)rule; 2783465a38a2SSteen Hegelund struct vcap_client_actionfield *caf; 2784465a38a2SSteen Hegelund 2785465a38a2SSteen Hegelund list_for_each_entry(caf, &ri->data.actionfields, ctrl.list) 2786465a38a2SSteen Hegelund if (caf->ctrl.action == act) 2787465a38a2SSteen Hegelund return caf; 2788465a38a2SSteen Hegelund return NULL; 2789465a38a2SSteen Hegelund } 27906ebf182bSDaniel Machon EXPORT_SYMBOL_GPL(vcap_find_actionfield); 2791465a38a2SSteen Hegelund 2792242df4f7SSteen Hegelund /* Check if the actionfield is already in the rule */ 2793242df4f7SSteen Hegelund static bool vcap_actionfield_unique(struct vcap_rule *rule, 2794242df4f7SSteen Hegelund enum vcap_action_field act) 2795242df4f7SSteen Hegelund { 2796242df4f7SSteen Hegelund struct vcap_rule_internal *ri = to_intrule(rule); 2797242df4f7SSteen Hegelund const struct vcap_client_actionfield *caf; 2798242df4f7SSteen Hegelund 2799242df4f7SSteen Hegelund list_for_each_entry(caf, &ri->data.actionfields, ctrl.list) 2800242df4f7SSteen Hegelund if (caf->ctrl.action == act) 2801242df4f7SSteen Hegelund return false; 2802242df4f7SSteen Hegelund return true; 2803242df4f7SSteen Hegelund } 2804242df4f7SSteen Hegelund 2805242df4f7SSteen Hegelund /* Check if the actionfield is in the actionset */ 2806242df4f7SSteen Hegelund static bool vcap_actionfield_match_actionset(struct vcap_rule *rule, 2807242df4f7SSteen Hegelund enum vcap_action_field action) 2808242df4f7SSteen Hegelund { 2809242df4f7SSteen Hegelund enum vcap_actionfield_set actionset = rule->actionset; 2810242df4f7SSteen Hegelund struct vcap_rule_internal *ri = to_intrule(rule); 2811242df4f7SSteen Hegelund enum vcap_type vt = ri->admin->vtype; 2812242df4f7SSteen Hegelund const struct vcap_field *fields; 2813242df4f7SSteen Hegelund 2814242df4f7SSteen Hegelund /* the field is accepted if the rule has no actionset yet */ 2815242df4f7SSteen Hegelund if (actionset == VCAP_AFS_NO_VALUE) 2816242df4f7SSteen Hegelund return true; 2817242df4f7SSteen Hegelund fields = vcap_actionfields(ri->vctrl, vt, actionset); 2818242df4f7SSteen Hegelund if (!fields) 2819242df4f7SSteen Hegelund return false; 2820242df4f7SSteen Hegelund /* if there is a width there is a way */ 2821242df4f7SSteen Hegelund return fields[action].width > 0; 2822242df4f7SSteen Hegelund } 2823242df4f7SSteen Hegelund 2824c9da1ac1SSteen Hegelund static int vcap_rule_add_action(struct vcap_rule *rule, 2825c9da1ac1SSteen Hegelund enum vcap_action_field action, 2826c9da1ac1SSteen Hegelund enum vcap_field_type ftype, 2827c9da1ac1SSteen Hegelund struct vcap_client_actionfield_data *data) 2828c9da1ac1SSteen Hegelund { 2829242df4f7SSteen Hegelund struct vcap_rule_internal *ri = to_intrule(rule); 2830c9da1ac1SSteen Hegelund struct vcap_client_actionfield *field; 2831c9da1ac1SSteen Hegelund 2832242df4f7SSteen Hegelund if (!vcap_actionfield_unique(rule, action)) { 2833242df4f7SSteen Hegelund pr_warn("%s:%d: actionfield %s is already in the rule\n", 2834242df4f7SSteen Hegelund __func__, __LINE__, 2835242df4f7SSteen Hegelund vcap_actionfield_name(ri->vctrl, action)); 2836242df4f7SSteen Hegelund return -EINVAL; 2837242df4f7SSteen Hegelund } 2838242df4f7SSteen Hegelund 2839242df4f7SSteen Hegelund if (!vcap_actionfield_match_actionset(rule, action)) { 2840242df4f7SSteen Hegelund pr_err("%s:%d: actionfield %s does not belong in the rule actionset\n", 2841242df4f7SSteen Hegelund __func__, __LINE__, 2842242df4f7SSteen Hegelund vcap_actionfield_name(ri->vctrl, action)); 2843242df4f7SSteen Hegelund return -EINVAL; 2844242df4f7SSteen Hegelund } 2845242df4f7SSteen Hegelund 2846c9da1ac1SSteen Hegelund field = kzalloc(sizeof(*field), GFP_KERNEL); 2847c9da1ac1SSteen Hegelund if (!field) 2848c9da1ac1SSteen Hegelund return -ENOMEM; 284933e3a273SSteen Hegelund memcpy(&field->data, data, sizeof(field->data)); 2850c9da1ac1SSteen Hegelund field->ctrl.action = action; 2851c9da1ac1SSteen Hegelund field->ctrl.type = ftype; 2852c9da1ac1SSteen Hegelund list_add_tail(&field->ctrl.list, &rule->actionfields); 2853c9da1ac1SSteen Hegelund return 0; 2854c9da1ac1SSteen Hegelund } 2855c9da1ac1SSteen Hegelund 2856c9da1ac1SSteen Hegelund static void vcap_rule_set_action_bitsize(struct vcap_u1_action *u1, 2857c9da1ac1SSteen Hegelund enum vcap_bit val) 2858c9da1ac1SSteen Hegelund { 2859c9da1ac1SSteen Hegelund switch (val) { 2860c9da1ac1SSteen Hegelund case VCAP_BIT_0: 2861c9da1ac1SSteen Hegelund u1->value = 0; 2862c9da1ac1SSteen Hegelund break; 2863c9da1ac1SSteen Hegelund case VCAP_BIT_1: 2864c9da1ac1SSteen Hegelund u1->value = 1; 2865c9da1ac1SSteen Hegelund break; 2866c9da1ac1SSteen Hegelund case VCAP_BIT_ANY: 2867c9da1ac1SSteen Hegelund u1->value = 0; 2868c9da1ac1SSteen Hegelund break; 2869c9da1ac1SSteen Hegelund } 2870c9da1ac1SSteen Hegelund } 2871c9da1ac1SSteen Hegelund 2872c9da1ac1SSteen Hegelund /* Add a bit action with value to the rule */ 2873c9da1ac1SSteen Hegelund int vcap_rule_add_action_bit(struct vcap_rule *rule, 2874c9da1ac1SSteen Hegelund enum vcap_action_field action, 2875c9da1ac1SSteen Hegelund enum vcap_bit val) 2876c9da1ac1SSteen Hegelund { 2877c9da1ac1SSteen Hegelund struct vcap_client_actionfield_data data; 2878c9da1ac1SSteen Hegelund 2879c9da1ac1SSteen Hegelund vcap_rule_set_action_bitsize(&data.u1, val); 2880c9da1ac1SSteen Hegelund return vcap_rule_add_action(rule, action, VCAP_FIELD_BIT, &data); 2881c9da1ac1SSteen Hegelund } 2882c9da1ac1SSteen Hegelund EXPORT_SYMBOL_GPL(vcap_rule_add_action_bit); 2883c9da1ac1SSteen Hegelund 2884c9da1ac1SSteen Hegelund /* Add a 32 bit action field with value to the rule */ 2885c9da1ac1SSteen Hegelund int vcap_rule_add_action_u32(struct vcap_rule *rule, 2886c9da1ac1SSteen Hegelund enum vcap_action_field action, 2887c9da1ac1SSteen Hegelund u32 value) 2888c9da1ac1SSteen Hegelund { 2889c9da1ac1SSteen Hegelund struct vcap_client_actionfield_data data; 2890c9da1ac1SSteen Hegelund 2891c9da1ac1SSteen Hegelund data.u32.value = value; 2892c9da1ac1SSteen Hegelund return vcap_rule_add_action(rule, action, VCAP_FIELD_U32, &data); 2893c9da1ac1SSteen Hegelund } 2894c9da1ac1SSteen Hegelund EXPORT_SYMBOL_GPL(vcap_rule_add_action_u32); 2895c9da1ac1SSteen Hegelund 2896f13230a4SSteen Hegelund static int vcap_read_counter(struct vcap_rule_internal *ri, 2897f13230a4SSteen Hegelund struct vcap_counter *ctr) 2898f13230a4SSteen Hegelund { 2899f13230a4SSteen Hegelund struct vcap_admin *admin = ri->admin; 2900f13230a4SSteen Hegelund 2901f13230a4SSteen Hegelund ri->vctrl->ops->update(ri->ndev, admin, VCAP_CMD_READ, VCAP_SEL_COUNTER, 2902f13230a4SSteen Hegelund ri->addr); 2903f13230a4SSteen Hegelund ri->vctrl->ops->cache_read(ri->ndev, admin, VCAP_SEL_COUNTER, 2904f13230a4SSteen Hegelund ri->counter_id, 0); 2905f13230a4SSteen Hegelund ctr->value = admin->cache.counter; 2906f13230a4SSteen Hegelund ctr->sticky = admin->cache.sticky; 2907f13230a4SSteen Hegelund return 0; 2908f13230a4SSteen Hegelund } 2909f13230a4SSteen Hegelund 2910c9da1ac1SSteen Hegelund /* Copy to host byte order */ 2911c9da1ac1SSteen Hegelund void vcap_netbytes_copy(u8 *dst, u8 *src, int count) 2912c9da1ac1SSteen Hegelund { 2913c9da1ac1SSteen Hegelund int idx; 2914c9da1ac1SSteen Hegelund 2915c9da1ac1SSteen Hegelund for (idx = 0; idx < count; ++idx, ++dst) 2916c9da1ac1SSteen Hegelund *dst = src[count - idx - 1]; 2917c9da1ac1SSteen Hegelund } 2918c9da1ac1SSteen Hegelund EXPORT_SYMBOL_GPL(vcap_netbytes_copy); 2919c9da1ac1SSteen Hegelund 2920c9da1ac1SSteen Hegelund /* Convert validation error code into tc extact error message */ 2921c9da1ac1SSteen Hegelund void vcap_set_tc_exterr(struct flow_cls_offload *fco, struct vcap_rule *vrule) 2922c9da1ac1SSteen Hegelund { 2923c9da1ac1SSteen Hegelund switch (vrule->exterr) { 2924c9da1ac1SSteen Hegelund case VCAP_ERR_NONE: 2925c9da1ac1SSteen Hegelund break; 2926c9da1ac1SSteen Hegelund case VCAP_ERR_NO_ADMIN: 2927c9da1ac1SSteen Hegelund NL_SET_ERR_MSG_MOD(fco->common.extack, 2928c9da1ac1SSteen Hegelund "Missing VCAP instance"); 2929c9da1ac1SSteen Hegelund break; 2930c9da1ac1SSteen Hegelund case VCAP_ERR_NO_NETDEV: 2931c9da1ac1SSteen Hegelund NL_SET_ERR_MSG_MOD(fco->common.extack, 2932c9da1ac1SSteen Hegelund "Missing network interface"); 2933c9da1ac1SSteen Hegelund break; 2934c9da1ac1SSteen Hegelund case VCAP_ERR_NO_KEYSET_MATCH: 2935c9da1ac1SSteen Hegelund NL_SET_ERR_MSG_MOD(fco->common.extack, 2936c9da1ac1SSteen Hegelund "No keyset matched the filter keys"); 2937c9da1ac1SSteen Hegelund break; 2938c9da1ac1SSteen Hegelund case VCAP_ERR_NO_ACTIONSET_MATCH: 2939c9da1ac1SSteen Hegelund NL_SET_ERR_MSG_MOD(fco->common.extack, 2940c9da1ac1SSteen Hegelund "No actionset matched the filter actions"); 2941c9da1ac1SSteen Hegelund break; 2942c9da1ac1SSteen Hegelund case VCAP_ERR_NO_PORT_KEYSET_MATCH: 2943c9da1ac1SSteen Hegelund NL_SET_ERR_MSG_MOD(fco->common.extack, 2944c9da1ac1SSteen Hegelund "No port keyset matched the filter keys"); 2945c9da1ac1SSteen Hegelund break; 2946c9da1ac1SSteen Hegelund } 2947c9da1ac1SSteen Hegelund } 2948c9da1ac1SSteen Hegelund EXPORT_SYMBOL_GPL(vcap_set_tc_exterr); 294967d63751SSteen Hegelund 295018a15c76SSteen Hegelund /* Write a rule to VCAP HW to enable it */ 295118a15c76SSteen Hegelund static int vcap_enable_rule(struct vcap_rule_internal *ri) 295218a15c76SSteen Hegelund { 295318a15c76SSteen Hegelund struct vcap_client_actionfield *af, *naf; 295418a15c76SSteen Hegelund struct vcap_client_keyfield *kf, *nkf; 295518a15c76SSteen Hegelund int err; 295618a15c76SSteen Hegelund 295718a15c76SSteen Hegelund vcap_erase_cache(ri); 295818a15c76SSteen Hegelund err = vcap_encode_rule(ri); 295918a15c76SSteen Hegelund if (err) 296018a15c76SSteen Hegelund goto out; 296118a15c76SSteen Hegelund err = vcap_write_rule(ri); 296218a15c76SSteen Hegelund if (err) 296318a15c76SSteen Hegelund goto out; 296418a15c76SSteen Hegelund 296518a15c76SSteen Hegelund /* Deallocate the list of keys and actions */ 296618a15c76SSteen Hegelund list_for_each_entry_safe(kf, nkf, &ri->data.keyfields, ctrl.list) { 296718a15c76SSteen Hegelund list_del(&kf->ctrl.list); 296818a15c76SSteen Hegelund kfree(kf); 296918a15c76SSteen Hegelund } 297018a15c76SSteen Hegelund list_for_each_entry_safe(af, naf, &ri->data.actionfields, ctrl.list) { 297118a15c76SSteen Hegelund list_del(&af->ctrl.list); 297218a15c76SSteen Hegelund kfree(af); 297318a15c76SSteen Hegelund } 297418a15c76SSteen Hegelund ri->state = VCAP_RS_ENABLED; 297518a15c76SSteen Hegelund out: 297618a15c76SSteen Hegelund return err; 297718a15c76SSteen Hegelund } 297818a15c76SSteen Hegelund 297918a15c76SSteen Hegelund /* Enable all disabled rules for a specific chain/port in the VCAP HW */ 298018a15c76SSteen Hegelund static int vcap_enable_rules(struct vcap_control *vctrl, 298118a15c76SSteen Hegelund struct net_device *ndev, int chain) 298218a15c76SSteen Hegelund { 298388bd9ea7SSteen Hegelund int next_chain = chain + VCAP_CID_LOOKUP_SIZE; 298418a15c76SSteen Hegelund struct vcap_rule_internal *ri; 298518a15c76SSteen Hegelund struct vcap_admin *admin; 298618a15c76SSteen Hegelund int err = 0; 298718a15c76SSteen Hegelund 298818a15c76SSteen Hegelund list_for_each_entry(admin, &vctrl->list, list) { 298918a15c76SSteen Hegelund if (!(chain >= admin->first_cid && chain <= admin->last_cid)) 299018a15c76SSteen Hegelund continue; 299118a15c76SSteen Hegelund 299218a15c76SSteen Hegelund /* Found the admin, now find the offloadable rules */ 299318a15c76SSteen Hegelund mutex_lock(&admin->lock); 299418a15c76SSteen Hegelund list_for_each_entry(ri, &admin->rules, list) { 299588bd9ea7SSteen Hegelund /* Is the rule in the lookup defined by the chain */ 299688bd9ea7SSteen Hegelund if (!(ri->data.vcap_chain_id >= chain && 299788bd9ea7SSteen Hegelund ri->data.vcap_chain_id < next_chain)) { 299818a15c76SSteen Hegelund continue; 299988bd9ea7SSteen Hegelund } 300018a15c76SSteen Hegelund 300118a15c76SSteen Hegelund if (ri->ndev != ndev) 300218a15c76SSteen Hegelund continue; 300318a15c76SSteen Hegelund 300418a15c76SSteen Hegelund if (ri->state != VCAP_RS_DISABLED) 300518a15c76SSteen Hegelund continue; 300618a15c76SSteen Hegelund 300718a15c76SSteen Hegelund err = vcap_enable_rule(ri); 300818a15c76SSteen Hegelund if (err) 300918a15c76SSteen Hegelund break; 301018a15c76SSteen Hegelund } 301118a15c76SSteen Hegelund mutex_unlock(&admin->lock); 301218a15c76SSteen Hegelund if (err) 301318a15c76SSteen Hegelund break; 301418a15c76SSteen Hegelund } 301518a15c76SSteen Hegelund return err; 301618a15c76SSteen Hegelund } 301718a15c76SSteen Hegelund 301818a15c76SSteen Hegelund /* Read and erase a rule from VCAP HW to disable it */ 301918a15c76SSteen Hegelund static int vcap_disable_rule(struct vcap_rule_internal *ri) 302018a15c76SSteen Hegelund { 302118a15c76SSteen Hegelund int err; 302218a15c76SSteen Hegelund 302318a15c76SSteen Hegelund err = vcap_read_rule(ri); 302418a15c76SSteen Hegelund if (err) 302518a15c76SSteen Hegelund return err; 302618a15c76SSteen Hegelund err = vcap_decode_keyset(ri); 302718a15c76SSteen Hegelund if (err) 302818a15c76SSteen Hegelund return err; 302918a15c76SSteen Hegelund err = vcap_decode_actionset(ri); 303018a15c76SSteen Hegelund if (err) 303118a15c76SSteen Hegelund return err; 303218a15c76SSteen Hegelund 303318a15c76SSteen Hegelund ri->state = VCAP_RS_DISABLED; 303418a15c76SSteen Hegelund ri->vctrl->ops->init(ri->ndev, ri->admin, ri->addr, ri->size); 303518a15c76SSteen Hegelund return 0; 303618a15c76SSteen Hegelund } 303718a15c76SSteen Hegelund 303818a15c76SSteen Hegelund /* Disable all enabled rules for a specific chain/port in the VCAP HW */ 303918a15c76SSteen Hegelund static int vcap_disable_rules(struct vcap_control *vctrl, 304018a15c76SSteen Hegelund struct net_device *ndev, int chain) 304118a15c76SSteen Hegelund { 304218a15c76SSteen Hegelund struct vcap_rule_internal *ri; 304318a15c76SSteen Hegelund struct vcap_admin *admin; 304418a15c76SSteen Hegelund int err = 0; 304518a15c76SSteen Hegelund 304618a15c76SSteen Hegelund list_for_each_entry(admin, &vctrl->list, list) { 304718a15c76SSteen Hegelund if (!(chain >= admin->first_cid && chain <= admin->last_cid)) 304818a15c76SSteen Hegelund continue; 304918a15c76SSteen Hegelund 305018a15c76SSteen Hegelund /* Found the admin, now find the rules on the chain */ 305118a15c76SSteen Hegelund mutex_lock(&admin->lock); 305218a15c76SSteen Hegelund list_for_each_entry(ri, &admin->rules, list) { 305318a15c76SSteen Hegelund if (ri->data.vcap_chain_id != chain) 305418a15c76SSteen Hegelund continue; 305518a15c76SSteen Hegelund 305618a15c76SSteen Hegelund if (ri->ndev != ndev) 305718a15c76SSteen Hegelund continue; 305818a15c76SSteen Hegelund 305918a15c76SSteen Hegelund if (ri->state != VCAP_RS_ENABLED) 306018a15c76SSteen Hegelund continue; 306118a15c76SSteen Hegelund 306218a15c76SSteen Hegelund err = vcap_disable_rule(ri); 306318a15c76SSteen Hegelund if (err) 306418a15c76SSteen Hegelund break; 306518a15c76SSteen Hegelund } 306618a15c76SSteen Hegelund mutex_unlock(&admin->lock); 306718a15c76SSteen Hegelund if (err) 306818a15c76SSteen Hegelund break; 306918a15c76SSteen Hegelund } 307018a15c76SSteen Hegelund return err; 307118a15c76SSteen Hegelund } 307218a15c76SSteen Hegelund 307367456717SSteen Hegelund /* Check if this port is already enabled for this VCAP instance */ 3074cfd9e7b7SSteen Hegelund static bool vcap_is_enabled(struct vcap_control *vctrl, struct net_device *ndev, 3075cfd9e7b7SSteen Hegelund int dst_cid) 307667456717SSteen Hegelund { 307767456717SSteen Hegelund struct vcap_enabled_port *eport; 3078cfd9e7b7SSteen Hegelund struct vcap_admin *admin; 307967456717SSteen Hegelund 3080cfd9e7b7SSteen Hegelund list_for_each_entry(admin, &vctrl->list, list) 308167456717SSteen Hegelund list_for_each_entry(eport, &admin->enabled, list) 3082cfd9e7b7SSteen Hegelund if (eport->dst_cid == dst_cid && eport->ndev == ndev) 308367456717SSteen Hegelund return true; 308467456717SSteen Hegelund 308567456717SSteen Hegelund return false; 308667456717SSteen Hegelund } 308767456717SSteen Hegelund 3088cfd9e7b7SSteen Hegelund /* Enable this port and chain id in a VCAP instance */ 3089cfd9e7b7SSteen Hegelund static int vcap_enable(struct vcap_control *vctrl, struct net_device *ndev, 3090cfd9e7b7SSteen Hegelund unsigned long cookie, int src_cid, int dst_cid) 309167456717SSteen Hegelund { 309267456717SSteen Hegelund struct vcap_enabled_port *eport; 3093cfd9e7b7SSteen Hegelund struct vcap_admin *admin; 3094cfd9e7b7SSteen Hegelund 3095cfd9e7b7SSteen Hegelund if (src_cid >= dst_cid) 3096cfd9e7b7SSteen Hegelund return -EFAULT; 3097cfd9e7b7SSteen Hegelund 3098cfd9e7b7SSteen Hegelund admin = vcap_find_admin(vctrl, dst_cid); 3099cfd9e7b7SSteen Hegelund if (!admin) 3100cfd9e7b7SSteen Hegelund return -ENOENT; 310167456717SSteen Hegelund 310267456717SSteen Hegelund eport = kzalloc(sizeof(*eport), GFP_KERNEL); 310367456717SSteen Hegelund if (!eport) 310467456717SSteen Hegelund return -ENOMEM; 310567456717SSteen Hegelund 310667456717SSteen Hegelund eport->ndev = ndev; 310767456717SSteen Hegelund eport->cookie = cookie; 3108cfd9e7b7SSteen Hegelund eport->src_cid = src_cid; 3109cfd9e7b7SSteen Hegelund eport->dst_cid = dst_cid; 3110cfd9e7b7SSteen Hegelund mutex_lock(&admin->lock); 311167456717SSteen Hegelund list_add_tail(&eport->list, &admin->enabled); 3112cfd9e7b7SSteen Hegelund mutex_unlock(&admin->lock); 311367456717SSteen Hegelund 311418a15c76SSteen Hegelund if (vcap_path_exist(vctrl, ndev, src_cid)) { 311518a15c76SSteen Hegelund /* Enable chained lookups */ 311618a15c76SSteen Hegelund while (dst_cid) { 311718a15c76SSteen Hegelund admin = vcap_find_admin(vctrl, dst_cid); 311818a15c76SSteen Hegelund if (!admin) 311918a15c76SSteen Hegelund return -ENOENT; 312018a15c76SSteen Hegelund 312118a15c76SSteen Hegelund vcap_enable_rules(vctrl, ndev, dst_cid); 312218a15c76SSteen Hegelund dst_cid = vcap_get_next_chain(vctrl, ndev, dst_cid); 312318a15c76SSteen Hegelund } 312418a15c76SSteen Hegelund } 312567456717SSteen Hegelund return 0; 312667456717SSteen Hegelund } 312767456717SSteen Hegelund 3128cfd9e7b7SSteen Hegelund /* Disable this port and chain id for a VCAP instance */ 3129cfd9e7b7SSteen Hegelund static int vcap_disable(struct vcap_control *vctrl, struct net_device *ndev, 313067456717SSteen Hegelund unsigned long cookie) 313167456717SSteen Hegelund { 3132cfd9e7b7SSteen Hegelund struct vcap_enabled_port *elem, *eport = NULL; 3133cfd9e7b7SSteen Hegelund struct vcap_admin *found = NULL, *admin; 313418a15c76SSteen Hegelund int dst_cid; 313567456717SSteen Hegelund 3136cfd9e7b7SSteen Hegelund list_for_each_entry(admin, &vctrl->list, list) { 3137cfd9e7b7SSteen Hegelund list_for_each_entry(elem, &admin->enabled, list) { 3138cfd9e7b7SSteen Hegelund if (elem->cookie == cookie && elem->ndev == ndev) { 3139cfd9e7b7SSteen Hegelund eport = elem; 3140cfd9e7b7SSteen Hegelund found = admin; 3141cfd9e7b7SSteen Hegelund break; 3142cfd9e7b7SSteen Hegelund } 3143cfd9e7b7SSteen Hegelund } 3144cfd9e7b7SSteen Hegelund if (eport) 3145cfd9e7b7SSteen Hegelund break; 3146cfd9e7b7SSteen Hegelund } 3147cfd9e7b7SSteen Hegelund 3148cfd9e7b7SSteen Hegelund if (!eport) 3149cfd9e7b7SSteen Hegelund return -ENOENT; 3150cfd9e7b7SSteen Hegelund 315118a15c76SSteen Hegelund /* Disable chained lookups */ 315218a15c76SSteen Hegelund dst_cid = eport->dst_cid; 315318a15c76SSteen Hegelund while (dst_cid) { 315418a15c76SSteen Hegelund admin = vcap_find_admin(vctrl, dst_cid); 315518a15c76SSteen Hegelund if (!admin) 315618a15c76SSteen Hegelund return -ENOENT; 315718a15c76SSteen Hegelund 315818a15c76SSteen Hegelund vcap_disable_rules(vctrl, ndev, dst_cid); 315918a15c76SSteen Hegelund dst_cid = vcap_get_next_chain(vctrl, ndev, dst_cid); 316018a15c76SSteen Hegelund } 316118a15c76SSteen Hegelund 3162cfd9e7b7SSteen Hegelund mutex_lock(&found->lock); 316367456717SSteen Hegelund list_del(&eport->list); 3164cfd9e7b7SSteen Hegelund mutex_unlock(&found->lock); 316567456717SSteen Hegelund kfree(eport); 316667456717SSteen Hegelund return 0; 316767456717SSteen Hegelund } 316867456717SSteen Hegelund 3169cfd9e7b7SSteen Hegelund /* Enable/Disable the VCAP instance lookups */ 317067456717SSteen Hegelund int vcap_enable_lookups(struct vcap_control *vctrl, struct net_device *ndev, 3171cfd9e7b7SSteen Hegelund int src_cid, int dst_cid, unsigned long cookie, 3172cfd9e7b7SSteen Hegelund bool enable) 317367456717SSteen Hegelund { 317467456717SSteen Hegelund int err; 317567456717SSteen Hegelund 317667456717SSteen Hegelund err = vcap_api_check(vctrl); 317767456717SSteen Hegelund if (err) 317867456717SSteen Hegelund return err; 317967456717SSteen Hegelund 318067456717SSteen Hegelund if (!ndev) 318167456717SSteen Hegelund return -ENODEV; 318267456717SSteen Hegelund 3183cfd9e7b7SSteen Hegelund /* Source and destination must be the first chain in a lookup */ 3184cfd9e7b7SSteen Hegelund if (src_cid % VCAP_CID_LOOKUP_SIZE) 3185cfd9e7b7SSteen Hegelund return -EFAULT; 3186cfd9e7b7SSteen Hegelund if (dst_cid % VCAP_CID_LOOKUP_SIZE) 318767456717SSteen Hegelund return -EFAULT; 318867456717SSteen Hegelund 3189cfd9e7b7SSteen Hegelund if (enable) { 3190cfd9e7b7SSteen Hegelund if (vcap_is_enabled(vctrl, ndev, dst_cid)) 319167456717SSteen Hegelund return -EADDRINUSE; 3192cfd9e7b7SSteen Hegelund if (vcap_is_chain_used(vctrl, ndev, src_cid)) 3193cfd9e7b7SSteen Hegelund return -EADDRNOTAVAIL; 3194cfd9e7b7SSteen Hegelund err = vcap_enable(vctrl, ndev, cookie, src_cid, dst_cid); 319567456717SSteen Hegelund } else { 3196cfd9e7b7SSteen Hegelund err = vcap_disable(vctrl, ndev, cookie); 319767456717SSteen Hegelund } 319867456717SSteen Hegelund 3199cfd9e7b7SSteen Hegelund return err; 320067456717SSteen Hegelund } 320167456717SSteen Hegelund EXPORT_SYMBOL_GPL(vcap_enable_lookups); 320267456717SSteen Hegelund 3203784c3067SSteen Hegelund /* Is this chain id the last lookup of all VCAPs */ 3204e7e3f514SSteen Hegelund bool vcap_is_last_chain(struct vcap_control *vctrl, int cid, bool ingress) 3205784c3067SSteen Hegelund { 3206784c3067SSteen Hegelund struct vcap_admin *admin; 3207784c3067SSteen Hegelund int lookup; 3208784c3067SSteen Hegelund 3209784c3067SSteen Hegelund if (vcap_api_check(vctrl)) 3210784c3067SSteen Hegelund return false; 3211784c3067SSteen Hegelund 3212784c3067SSteen Hegelund admin = vcap_find_admin(vctrl, cid); 3213784c3067SSteen Hegelund if (!admin) 3214784c3067SSteen Hegelund return false; 3215784c3067SSteen Hegelund 3216e7e3f514SSteen Hegelund if (!vcap_admin_is_last(vctrl, admin, ingress)) 321788bd9ea7SSteen Hegelund return false; 321888bd9ea7SSteen Hegelund 3219784c3067SSteen Hegelund /* This must be the last lookup in this VCAP type */ 3220784c3067SSteen Hegelund lookup = vcap_chain_id_to_lookup(admin, cid); 3221784c3067SSteen Hegelund return lookup == admin->lookups - 1; 3222784c3067SSteen Hegelund } 3223784c3067SSteen Hegelund EXPORT_SYMBOL_GPL(vcap_is_last_chain); 3224784c3067SSteen Hegelund 3225f13230a4SSteen Hegelund /* Set a rule counter id (for certain vcaps only) */ 3226f13230a4SSteen Hegelund void vcap_rule_set_counter_id(struct vcap_rule *rule, u32 counter_id) 3227f13230a4SSteen Hegelund { 3228f13230a4SSteen Hegelund struct vcap_rule_internal *ri = to_intrule(rule); 3229f13230a4SSteen Hegelund 3230f13230a4SSteen Hegelund ri->counter_id = counter_id; 3231f13230a4SSteen Hegelund } 3232f13230a4SSteen Hegelund EXPORT_SYMBOL_GPL(vcap_rule_set_counter_id); 3233f13230a4SSteen Hegelund 3234f13230a4SSteen Hegelund int vcap_rule_set_counter(struct vcap_rule *rule, struct vcap_counter *ctr) 3235f13230a4SSteen Hegelund { 3236f13230a4SSteen Hegelund struct vcap_rule_internal *ri = to_intrule(rule); 3237f13230a4SSteen Hegelund int err; 3238f13230a4SSteen Hegelund 3239f13230a4SSteen Hegelund err = vcap_api_check(ri->vctrl); 3240f13230a4SSteen Hegelund if (err) 3241f13230a4SSteen Hegelund return err; 3242f13230a4SSteen Hegelund if (!ctr) { 3243f13230a4SSteen Hegelund pr_err("%s:%d: counter is missing\n", __func__, __LINE__); 3244f13230a4SSteen Hegelund return -EINVAL; 3245f13230a4SSteen Hegelund } 32461972b6d9SSteen Hegelund 32471972b6d9SSteen Hegelund mutex_lock(&ri->admin->lock); 32481972b6d9SSteen Hegelund err = vcap_write_counter(ri, ctr); 32491972b6d9SSteen Hegelund mutex_unlock(&ri->admin->lock); 32501972b6d9SSteen Hegelund 32511972b6d9SSteen Hegelund return err; 3252f13230a4SSteen Hegelund } 3253f13230a4SSteen Hegelund EXPORT_SYMBOL_GPL(vcap_rule_set_counter); 3254f13230a4SSteen Hegelund 3255f13230a4SSteen Hegelund int vcap_rule_get_counter(struct vcap_rule *rule, struct vcap_counter *ctr) 3256f13230a4SSteen Hegelund { 3257f13230a4SSteen Hegelund struct vcap_rule_internal *ri = to_intrule(rule); 3258f13230a4SSteen Hegelund int err; 3259f13230a4SSteen Hegelund 3260f13230a4SSteen Hegelund err = vcap_api_check(ri->vctrl); 3261f13230a4SSteen Hegelund if (err) 3262f13230a4SSteen Hegelund return err; 3263f13230a4SSteen Hegelund if (!ctr) { 3264f13230a4SSteen Hegelund pr_err("%s:%d: counter is missing\n", __func__, __LINE__); 3265f13230a4SSteen Hegelund return -EINVAL; 3266f13230a4SSteen Hegelund } 32671972b6d9SSteen Hegelund 32681972b6d9SSteen Hegelund mutex_lock(&ri->admin->lock); 32691972b6d9SSteen Hegelund err = vcap_read_counter(ri, ctr); 32701972b6d9SSteen Hegelund mutex_unlock(&ri->admin->lock); 32711972b6d9SSteen Hegelund 32721972b6d9SSteen Hegelund return err; 3273f13230a4SSteen Hegelund } 3274f13230a4SSteen Hegelund EXPORT_SYMBOL_GPL(vcap_rule_get_counter); 3275f13230a4SSteen Hegelund 327618a15c76SSteen Hegelund /* Get a copy of a client key field */ 327718a15c76SSteen Hegelund static int vcap_rule_get_key(struct vcap_rule *rule, 327818a15c76SSteen Hegelund enum vcap_key_field key, 327918a15c76SSteen Hegelund struct vcap_client_keyfield *ckf) 328018a15c76SSteen Hegelund { 328118a15c76SSteen Hegelund struct vcap_client_keyfield *field; 328218a15c76SSteen Hegelund 328318a15c76SSteen Hegelund field = vcap_find_keyfield(rule, key); 328418a15c76SSteen Hegelund if (!field) 328518a15c76SSteen Hegelund return -EINVAL; 328618a15c76SSteen Hegelund memcpy(ckf, field, sizeof(*ckf)); 328718a15c76SSteen Hegelund INIT_LIST_HEAD(&ckf->ctrl.list); 328818a15c76SSteen Hegelund return 0; 328918a15c76SSteen Hegelund } 329018a15c76SSteen Hegelund 3291c02b19edSSteen Hegelund /* Find a keyset having the same size as the provided rule, where the keyset 3292c02b19edSSteen Hegelund * does not have a type id. 3293c02b19edSSteen Hegelund */ 3294c02b19edSSteen Hegelund static int vcap_rule_get_untyped_keyset(struct vcap_rule_internal *ri, 3295c02b19edSSteen Hegelund struct vcap_keyset_list *matches) 3296c02b19edSSteen Hegelund { 3297c02b19edSSteen Hegelund struct vcap_control *vctrl = ri->vctrl; 3298c02b19edSSteen Hegelund enum vcap_type vt = ri->admin->vtype; 3299c02b19edSSteen Hegelund const struct vcap_set *keyfield_set; 3300c02b19edSSteen Hegelund int idx; 3301c02b19edSSteen Hegelund 3302c02b19edSSteen Hegelund keyfield_set = vctrl->vcaps[vt].keyfield_set; 3303c02b19edSSteen Hegelund for (idx = 0; idx < vctrl->vcaps[vt].keyfield_set_size; ++idx) { 3304c02b19edSSteen Hegelund if (keyfield_set[idx].sw_per_item == ri->keyset_sw && 3305c02b19edSSteen Hegelund keyfield_set[idx].type_id == (u8)-1) { 3306c02b19edSSteen Hegelund vcap_keyset_list_add(matches, idx); 3307c02b19edSSteen Hegelund return 0; 3308c02b19edSSteen Hegelund } 3309c02b19edSSteen Hegelund } 3310c02b19edSSteen Hegelund return -EINVAL; 3311c02b19edSSteen Hegelund } 3312c02b19edSSteen Hegelund 331318a15c76SSteen Hegelund /* Get the keysets that matches the rule key type/mask */ 331418a15c76SSteen Hegelund int vcap_rule_get_keysets(struct vcap_rule_internal *ri, 331518a15c76SSteen Hegelund struct vcap_keyset_list *matches) 331618a15c76SSteen Hegelund { 331718a15c76SSteen Hegelund struct vcap_control *vctrl = ri->vctrl; 331818a15c76SSteen Hegelund enum vcap_type vt = ri->admin->vtype; 331918a15c76SSteen Hegelund const struct vcap_set *keyfield_set; 332018a15c76SSteen Hegelund struct vcap_client_keyfield kf = {}; 332118a15c76SSteen Hegelund u32 value, mask; 332218a15c76SSteen Hegelund int err, idx; 332318a15c76SSteen Hegelund 332418a15c76SSteen Hegelund err = vcap_rule_get_key(&ri->data, VCAP_KF_TYPE, &kf); 332518a15c76SSteen Hegelund if (err) 3326c02b19edSSteen Hegelund return vcap_rule_get_untyped_keyset(ri, matches); 332718a15c76SSteen Hegelund 332818a15c76SSteen Hegelund if (kf.ctrl.type == VCAP_FIELD_BIT) { 332918a15c76SSteen Hegelund value = kf.data.u1.value; 333018a15c76SSteen Hegelund mask = kf.data.u1.mask; 333118a15c76SSteen Hegelund } else if (kf.ctrl.type == VCAP_FIELD_U32) { 333218a15c76SSteen Hegelund value = kf.data.u32.value; 333318a15c76SSteen Hegelund mask = kf.data.u32.mask; 333418a15c76SSteen Hegelund } else { 333518a15c76SSteen Hegelund return -EINVAL; 333618a15c76SSteen Hegelund } 333718a15c76SSteen Hegelund 333818a15c76SSteen Hegelund keyfield_set = vctrl->vcaps[vt].keyfield_set; 333918a15c76SSteen Hegelund for (idx = 0; idx < vctrl->vcaps[vt].keyfield_set_size; ++idx) { 334018a15c76SSteen Hegelund if (keyfield_set[idx].sw_per_item != ri->keyset_sw) 334118a15c76SSteen Hegelund continue; 334218a15c76SSteen Hegelund 334318a15c76SSteen Hegelund if (keyfield_set[idx].type_id == (u8)-1) { 334418a15c76SSteen Hegelund vcap_keyset_list_add(matches, idx); 334518a15c76SSteen Hegelund continue; 334618a15c76SSteen Hegelund } 334718a15c76SSteen Hegelund 334818a15c76SSteen Hegelund if ((keyfield_set[idx].type_id & mask) == value) 334918a15c76SSteen Hegelund vcap_keyset_list_add(matches, idx); 335018a15c76SSteen Hegelund } 335118a15c76SSteen Hegelund if (matches->cnt > 0) 335218a15c76SSteen Hegelund return 0; 335318a15c76SSteen Hegelund 335418a15c76SSteen Hegelund return -EINVAL; 335518a15c76SSteen Hegelund } 335618a15c76SSteen Hegelund 335727d293ccSSteen Hegelund /* Collect packet counts from all rules with the same cookie */ 335827d293ccSSteen Hegelund int vcap_get_rule_count_by_cookie(struct vcap_control *vctrl, 335927d293ccSSteen Hegelund struct vcap_counter *ctr, u64 cookie) 336027d293ccSSteen Hegelund { 336127d293ccSSteen Hegelund struct vcap_rule_internal *ri; 336227d293ccSSteen Hegelund struct vcap_counter temp = {}; 336327d293ccSSteen Hegelund struct vcap_admin *admin; 336427d293ccSSteen Hegelund int err; 336527d293ccSSteen Hegelund 336627d293ccSSteen Hegelund err = vcap_api_check(vctrl); 336727d293ccSSteen Hegelund if (err) 336827d293ccSSteen Hegelund return err; 336927d293ccSSteen Hegelund 337027d293ccSSteen Hegelund /* Iterate all rules in each VCAP instance */ 337127d293ccSSteen Hegelund list_for_each_entry(admin, &vctrl->list, list) { 337227d293ccSSteen Hegelund mutex_lock(&admin->lock); 337327d293ccSSteen Hegelund list_for_each_entry(ri, &admin->rules, list) { 337427d293ccSSteen Hegelund if (ri->data.cookie != cookie) 337527d293ccSSteen Hegelund continue; 337627d293ccSSteen Hegelund 337727d293ccSSteen Hegelund err = vcap_read_counter(ri, &temp); 337827d293ccSSteen Hegelund if (err) 337927d293ccSSteen Hegelund goto unlock; 338027d293ccSSteen Hegelund ctr->value += temp.value; 338127d293ccSSteen Hegelund 338227d293ccSSteen Hegelund /* Reset the rule counter */ 338327d293ccSSteen Hegelund temp.value = 0; 338427d293ccSSteen Hegelund temp.sticky = 0; 338527d293ccSSteen Hegelund err = vcap_write_counter(ri, &temp); 338627d293ccSSteen Hegelund if (err) 338727d293ccSSteen Hegelund goto unlock; 338827d293ccSSteen Hegelund } 338927d293ccSSteen Hegelund mutex_unlock(&admin->lock); 339027d293ccSSteen Hegelund } 339127d293ccSSteen Hegelund return err; 339227d293ccSSteen Hegelund 339327d293ccSSteen Hegelund unlock: 339427d293ccSSteen Hegelund mutex_unlock(&admin->lock); 339527d293ccSSteen Hegelund return err; 339627d293ccSSteen Hegelund } 339727d293ccSSteen Hegelund EXPORT_SYMBOL_GPL(vcap_get_rule_count_by_cookie); 339827d293ccSSteen Hegelund 3399465a38a2SSteen Hegelund static int vcap_rule_mod_key(struct vcap_rule *rule, 3400465a38a2SSteen Hegelund enum vcap_key_field key, 3401465a38a2SSteen Hegelund enum vcap_field_type ftype, 3402465a38a2SSteen Hegelund struct vcap_client_keyfield_data *data) 3403465a38a2SSteen Hegelund { 3404465a38a2SSteen Hegelund struct vcap_client_keyfield *field; 3405465a38a2SSteen Hegelund 3406465a38a2SSteen Hegelund field = vcap_find_keyfield(rule, key); 3407465a38a2SSteen Hegelund if (!field) 3408465a38a2SSteen Hegelund return vcap_rule_add_key(rule, key, ftype, data); 340933e3a273SSteen Hegelund memcpy(&field->data, data, sizeof(field->data)); 3410465a38a2SSteen Hegelund return 0; 3411465a38a2SSteen Hegelund } 3412465a38a2SSteen Hegelund 3413465a38a2SSteen Hegelund /* Modify a 32 bit key field with value and mask in the rule */ 3414465a38a2SSteen Hegelund int vcap_rule_mod_key_u32(struct vcap_rule *rule, enum vcap_key_field key, 3415465a38a2SSteen Hegelund u32 value, u32 mask) 3416465a38a2SSteen Hegelund { 3417465a38a2SSteen Hegelund struct vcap_client_keyfield_data data; 3418465a38a2SSteen Hegelund 3419465a38a2SSteen Hegelund data.u32.value = value; 3420465a38a2SSteen Hegelund data.u32.mask = mask; 3421465a38a2SSteen Hegelund return vcap_rule_mod_key(rule, key, VCAP_FIELD_U32, &data); 3422465a38a2SSteen Hegelund } 3423465a38a2SSteen Hegelund EXPORT_SYMBOL_GPL(vcap_rule_mod_key_u32); 3424465a38a2SSteen Hegelund 3425bfcb94aaSSteen Hegelund /* Remove a key field with value and mask in the rule */ 3426bfcb94aaSSteen Hegelund int vcap_rule_rem_key(struct vcap_rule *rule, enum vcap_key_field key) 3427bfcb94aaSSteen Hegelund { 3428bfcb94aaSSteen Hegelund struct vcap_rule_internal *ri = to_intrule(rule); 3429bfcb94aaSSteen Hegelund struct vcap_client_keyfield *field; 3430bfcb94aaSSteen Hegelund 3431bfcb94aaSSteen Hegelund field = vcap_find_keyfield(rule, key); 3432bfcb94aaSSteen Hegelund if (!field) { 3433bfcb94aaSSteen Hegelund pr_err("%s:%d: key %s is not in the rule\n", 3434bfcb94aaSSteen Hegelund __func__, __LINE__, vcap_keyfield_name(ri->vctrl, key)); 3435bfcb94aaSSteen Hegelund return -EINVAL; 3436bfcb94aaSSteen Hegelund } 3437bfcb94aaSSteen Hegelund /* Deallocate the key field */ 3438bfcb94aaSSteen Hegelund list_del(&field->ctrl.list); 3439bfcb94aaSSteen Hegelund kfree(field); 3440bfcb94aaSSteen Hegelund return 0; 3441bfcb94aaSSteen Hegelund } 3442bfcb94aaSSteen Hegelund EXPORT_SYMBOL_GPL(vcap_rule_rem_key); 3443bfcb94aaSSteen Hegelund 3444465a38a2SSteen Hegelund static int vcap_rule_mod_action(struct vcap_rule *rule, 3445465a38a2SSteen Hegelund enum vcap_action_field action, 3446465a38a2SSteen Hegelund enum vcap_field_type ftype, 3447465a38a2SSteen Hegelund struct vcap_client_actionfield_data *data) 3448465a38a2SSteen Hegelund { 3449465a38a2SSteen Hegelund struct vcap_client_actionfield *field; 3450465a38a2SSteen Hegelund 3451465a38a2SSteen Hegelund field = vcap_find_actionfield(rule, action); 3452465a38a2SSteen Hegelund if (!field) 3453465a38a2SSteen Hegelund return vcap_rule_add_action(rule, action, ftype, data); 345433e3a273SSteen Hegelund memcpy(&field->data, data, sizeof(field->data)); 3455465a38a2SSteen Hegelund return 0; 3456465a38a2SSteen Hegelund } 3457465a38a2SSteen Hegelund 3458465a38a2SSteen Hegelund /* Modify a 32 bit action field with value in the rule */ 3459465a38a2SSteen Hegelund int vcap_rule_mod_action_u32(struct vcap_rule *rule, 3460465a38a2SSteen Hegelund enum vcap_action_field action, 3461465a38a2SSteen Hegelund u32 value) 3462465a38a2SSteen Hegelund { 3463465a38a2SSteen Hegelund struct vcap_client_actionfield_data data; 3464465a38a2SSteen Hegelund 3465465a38a2SSteen Hegelund data.u32.value = value; 3466465a38a2SSteen Hegelund return vcap_rule_mod_action(rule, action, VCAP_FIELD_U32, &data); 3467465a38a2SSteen Hegelund } 3468465a38a2SSteen Hegelund EXPORT_SYMBOL_GPL(vcap_rule_mod_action_u32); 3469465a38a2SSteen Hegelund 3470465a38a2SSteen Hegelund /* Drop keys in a keylist and any keys that are not supported by the keyset */ 3471465a38a2SSteen Hegelund int vcap_filter_rule_keys(struct vcap_rule *rule, 3472465a38a2SSteen Hegelund enum vcap_key_field keylist[], int length, 3473465a38a2SSteen Hegelund bool drop_unsupported) 3474465a38a2SSteen Hegelund { 3475465a38a2SSteen Hegelund struct vcap_rule_internal *ri = to_intrule(rule); 3476465a38a2SSteen Hegelund struct vcap_client_keyfield *ckf, *next_ckf; 3477465a38a2SSteen Hegelund const struct vcap_field *fields; 3478465a38a2SSteen Hegelund enum vcap_key_field key; 3479465a38a2SSteen Hegelund int err = 0; 3480465a38a2SSteen Hegelund int idx; 3481465a38a2SSteen Hegelund 3482465a38a2SSteen Hegelund if (length > 0) { 3483465a38a2SSteen Hegelund err = -EEXIST; 3484465a38a2SSteen Hegelund list_for_each_entry_safe(ckf, next_ckf, 3485465a38a2SSteen Hegelund &ri->data.keyfields, ctrl.list) { 3486465a38a2SSteen Hegelund key = ckf->ctrl.key; 3487465a38a2SSteen Hegelund for (idx = 0; idx < length; ++idx) 3488465a38a2SSteen Hegelund if (key == keylist[idx]) { 3489465a38a2SSteen Hegelund list_del(&ckf->ctrl.list); 3490465a38a2SSteen Hegelund kfree(ckf); 3491465a38a2SSteen Hegelund idx++; 3492465a38a2SSteen Hegelund err = 0; 3493465a38a2SSteen Hegelund } 3494465a38a2SSteen Hegelund } 3495465a38a2SSteen Hegelund } 3496465a38a2SSteen Hegelund if (drop_unsupported) { 3497465a38a2SSteen Hegelund err = -EEXIST; 3498465a38a2SSteen Hegelund fields = vcap_keyfields(ri->vctrl, ri->admin->vtype, 3499465a38a2SSteen Hegelund rule->keyset); 3500465a38a2SSteen Hegelund if (!fields) 3501465a38a2SSteen Hegelund return err; 3502465a38a2SSteen Hegelund list_for_each_entry_safe(ckf, next_ckf, 3503465a38a2SSteen Hegelund &ri->data.keyfields, ctrl.list) { 3504465a38a2SSteen Hegelund key = ckf->ctrl.key; 3505465a38a2SSteen Hegelund if (fields[key].width == 0) { 3506465a38a2SSteen Hegelund list_del(&ckf->ctrl.list); 3507465a38a2SSteen Hegelund kfree(ckf); 3508465a38a2SSteen Hegelund err = 0; 3509465a38a2SSteen Hegelund } 3510465a38a2SSteen Hegelund } 3511465a38a2SSteen Hegelund } 3512465a38a2SSteen Hegelund return err; 3513465a38a2SSteen Hegelund } 3514465a38a2SSteen Hegelund EXPORT_SYMBOL_GPL(vcap_filter_rule_keys); 3515465a38a2SSteen Hegelund 3516bfcb94aaSSteen Hegelund /* Select the keyset from the list that results in the smallest rule size */ 3517bfcb94aaSSteen Hegelund enum vcap_keyfield_set 3518bfcb94aaSSteen Hegelund vcap_select_min_rule_keyset(struct vcap_control *vctrl, 3519bfcb94aaSSteen Hegelund enum vcap_type vtype, 3520bfcb94aaSSteen Hegelund struct vcap_keyset_list *kslist) 3521bfcb94aaSSteen Hegelund { 3522bfcb94aaSSteen Hegelund enum vcap_keyfield_set ret = VCAP_KFS_NO_VALUE; 3523bfcb94aaSSteen Hegelund const struct vcap_set *kset; 3524bfcb94aaSSteen Hegelund int max = 100, idx; 3525bfcb94aaSSteen Hegelund 3526bfcb94aaSSteen Hegelund for (idx = 0; idx < kslist->cnt; ++idx) { 3527bfcb94aaSSteen Hegelund kset = vcap_keyfieldset(vctrl, vtype, kslist->keysets[idx]); 3528bfcb94aaSSteen Hegelund if (!kset) 3529bfcb94aaSSteen Hegelund continue; 3530bfcb94aaSSteen Hegelund if (kset->sw_per_item >= max) 3531bfcb94aaSSteen Hegelund continue; 3532bfcb94aaSSteen Hegelund max = kset->sw_per_item; 3533bfcb94aaSSteen Hegelund ret = kslist->keysets[idx]; 3534bfcb94aaSSteen Hegelund } 3535bfcb94aaSSteen Hegelund return ret; 3536bfcb94aaSSteen Hegelund } 3537bfcb94aaSSteen Hegelund EXPORT_SYMBOL_GPL(vcap_select_min_rule_keyset); 3538bfcb94aaSSteen Hegelund 3539465a38a2SSteen Hegelund /* Make a full copy of an existing rule with a new rule id */ 3540465a38a2SSteen Hegelund struct vcap_rule *vcap_copy_rule(struct vcap_rule *erule) 3541465a38a2SSteen Hegelund { 3542465a38a2SSteen Hegelund struct vcap_rule_internal *ri = to_intrule(erule); 3543465a38a2SSteen Hegelund struct vcap_client_actionfield *caf; 3544465a38a2SSteen Hegelund struct vcap_client_keyfield *ckf; 3545465a38a2SSteen Hegelund struct vcap_rule *rule; 3546465a38a2SSteen Hegelund int err; 3547465a38a2SSteen Hegelund 3548465a38a2SSteen Hegelund err = vcap_api_check(ri->vctrl); 3549465a38a2SSteen Hegelund if (err) 3550465a38a2SSteen Hegelund return ERR_PTR(err); 3551465a38a2SSteen Hegelund 3552465a38a2SSteen Hegelund rule = vcap_alloc_rule(ri->vctrl, ri->ndev, ri->data.vcap_chain_id, 3553465a38a2SSteen Hegelund ri->data.user, ri->data.priority, 0); 3554465a38a2SSteen Hegelund if (IS_ERR(rule)) 3555465a38a2SSteen Hegelund return rule; 3556465a38a2SSteen Hegelund 3557465a38a2SSteen Hegelund list_for_each_entry(ckf, &ri->data.keyfields, ctrl.list) { 3558465a38a2SSteen Hegelund /* Add a key duplicate in the new rule */ 3559465a38a2SSteen Hegelund err = vcap_rule_add_key(rule, 3560465a38a2SSteen Hegelund ckf->ctrl.key, 3561465a38a2SSteen Hegelund ckf->ctrl.type, 3562465a38a2SSteen Hegelund &ckf->data); 3563465a38a2SSteen Hegelund if (err) 3564465a38a2SSteen Hegelund goto err; 3565465a38a2SSteen Hegelund } 3566465a38a2SSteen Hegelund 3567465a38a2SSteen Hegelund list_for_each_entry(caf, &ri->data.actionfields, ctrl.list) { 3568465a38a2SSteen Hegelund /* Add a action duplicate in the new rule */ 3569465a38a2SSteen Hegelund err = vcap_rule_add_action(rule, 3570465a38a2SSteen Hegelund caf->ctrl.action, 3571465a38a2SSteen Hegelund caf->ctrl.type, 3572465a38a2SSteen Hegelund &caf->data); 3573465a38a2SSteen Hegelund if (err) 3574465a38a2SSteen Hegelund goto err; 3575465a38a2SSteen Hegelund } 3576465a38a2SSteen Hegelund return rule; 3577465a38a2SSteen Hegelund err: 3578465a38a2SSteen Hegelund vcap_free_rule(rule); 3579465a38a2SSteen Hegelund return ERR_PTR(err); 3580465a38a2SSteen Hegelund } 3581465a38a2SSteen Hegelund EXPORT_SYMBOL_GPL(vcap_copy_rule); 3582465a38a2SSteen Hegelund 358367d63751SSteen Hegelund #ifdef CONFIG_VCAP_KUNIT_TEST 358467d63751SSteen Hegelund #include "vcap_api_kunit.c" 358567d63751SSteen Hegelund #endif 3586