// SPDX-License-Identifier: GPL-2.0+ /* Microchip VCAP API * * Copyright (c) 2022 Microchip Technology Inc. and its subsidiaries. */ #include <linux/types.h> #include "vcap_api_private.h" static int keyfield_size_table[] = …; static int actionfield_size_table[] = …; /* Moving a rule in the VCAP address space */ struct vcap_rule_move { … }; /* Stores the filter cookie and chain id that enabled the port */ struct vcap_enabled_port { … }; void vcap_iter_set(struct vcap_stream_iter *itr, int sw_width, const struct vcap_typegroup *tg, u32 offset) { … } static void vcap_iter_skip_tg(struct vcap_stream_iter *itr) { … } void vcap_iter_update(struct vcap_stream_iter *itr) { … } void vcap_iter_init(struct vcap_stream_iter *itr, int sw_width, const struct vcap_typegroup *tg, u32 offset) { … } void vcap_iter_next(struct vcap_stream_iter *itr) { … } static void vcap_set_bit(u32 *stream, struct vcap_stream_iter *itr, bool value) { … } static void vcap_encode_bit(u32 *stream, struct vcap_stream_iter *itr, bool val) { … } static void vcap_encode_field(u32 *stream, struct vcap_stream_iter *itr, int width, const u8 *value) { … } static void vcap_encode_typegroups(u32 *stream, int sw_width, const struct vcap_typegroup *tg, bool mask) { … } static bool vcap_bitarray_zero(int width, u8 *value) { … } static bool vcap_get_bit(u32 *stream, struct vcap_stream_iter *itr) { … } static void vcap_decode_field(u32 *stream, struct vcap_stream_iter *itr, int width, u8 *value) { … } /* Verify that the type id in the stream matches the type id of the keyset */ static bool vcap_verify_keystream_keyset(struct vcap_control *vctrl, enum vcap_type vt, u32 *keystream, u32 *mskstream, enum vcap_keyfield_set keyset) { … } /* Verify that the typegroup bits have the correct values */ static int vcap_verify_typegroups(u32 *stream, int sw_width, const struct vcap_typegroup *tgt, bool mask, int sw_max) { … } /* Find the subword width of the key typegroup that matches the stream data */ static int vcap_find_keystream_typegroup_sw(struct vcap_control *vctrl, enum vcap_type vt, u32 *stream, bool mask, int sw_max) { … } /* Verify that the typegroup information, subword count, keyset and type id * are in sync and correct, return the list of matching keysets */ int vcap_find_keystream_keysets(struct vcap_control *vctrl, enum vcap_type vt, u32 *keystream, u32 *mskstream, bool mask, int sw_max, struct vcap_keyset_list *kslist) { … } EXPORT_SYMBOL_GPL(…); /* Read key data from a VCAP address and discover if there are any rule keysets * here */ int vcap_addr_keysets(struct vcap_control *vctrl, struct net_device *ndev, struct vcap_admin *admin, int addr, struct vcap_keyset_list *kslist) { … } EXPORT_SYMBOL_GPL(…); /* Return the list of keyfields for the keyset */ const struct vcap_field *vcap_keyfields(struct vcap_control *vctrl, enum vcap_type vt, enum vcap_keyfield_set keyset) { … } /* Return the keyset information for the keyset */ const struct vcap_set *vcap_keyfieldset(struct vcap_control *vctrl, enum vcap_type vt, enum vcap_keyfield_set keyset) { … } EXPORT_SYMBOL_GPL(…); /* Return the typegroup table for the matching keyset (using subword size) */ const struct vcap_typegroup * vcap_keyfield_typegroup(struct vcap_control *vctrl, enum vcap_type vt, enum vcap_keyfield_set keyset) { … } /* Return the number of keyfields in the keyset */ int vcap_keyfield_count(struct vcap_control *vctrl, enum vcap_type vt, enum vcap_keyfield_set keyset) { … } static void vcap_encode_keyfield(struct vcap_rule_internal *ri, const struct vcap_client_keyfield *kf, const struct vcap_field *rf, const struct vcap_typegroup *tgt) { … } static void vcap_encode_keyfield_typegroups(struct vcap_control *vctrl, struct vcap_rule_internal *ri, const struct vcap_typegroup *tgt) { … } /* Copy data from src to dst but reverse the data in chunks of 32bits. * For example if src is 00:11:22:33:44:55 where 55 is LSB the dst will * have the value 22:33:44:55:00:11. */ static void vcap_copy_to_w32be(u8 *dst, const u8 *src, int size) { … } static void vcap_copy_from_client_keyfield(struct vcap_rule *rule, struct vcap_client_keyfield *dst, const struct vcap_client_keyfield *src) { … } static void vcap_copy_from_client_actionfield(struct vcap_rule *rule, struct vcap_client_actionfield *dst, const struct vcap_client_actionfield *src) { … } static int vcap_encode_rule_keyset(struct vcap_rule_internal *ri) { … } /* Return the list of actionfields for the actionset */ const struct vcap_field * vcap_actionfields(struct vcap_control *vctrl, enum vcap_type vt, enum vcap_actionfield_set actionset) { … } const struct vcap_set * vcap_actionfieldset(struct vcap_control *vctrl, enum vcap_type vt, enum vcap_actionfield_set actionset) { … } /* Return the typegroup table for the matching actionset (using subword size) */ const struct vcap_typegroup * vcap_actionfield_typegroup(struct vcap_control *vctrl, enum vcap_type vt, enum vcap_actionfield_set actionset) { … } /* Return the number of actionfields in the actionset */ int vcap_actionfield_count(struct vcap_control *vctrl, enum vcap_type vt, enum vcap_actionfield_set actionset) { … } static void vcap_encode_actionfield(struct vcap_rule_internal *ri, const struct vcap_client_actionfield *af, const struct vcap_field *rf, const struct vcap_typegroup *tgt) { … } static void vcap_encode_actionfield_typegroups(struct vcap_rule_internal *ri, const struct vcap_typegroup *tgt) { … } static int vcap_encode_rule_actionset(struct vcap_rule_internal *ri) { … } static int vcap_encode_rule(struct vcap_rule_internal *ri) { … } int vcap_api_check(struct vcap_control *ctrl) { … } void vcap_erase_cache(struct vcap_rule_internal *ri) { … } /* Update the keyset for the rule */ int vcap_set_rule_set_keyset(struct vcap_rule *rule, enum vcap_keyfield_set keyset) { … } EXPORT_SYMBOL_GPL(…); /* Update the actionset for the rule */ int vcap_set_rule_set_actionset(struct vcap_rule *rule, enum vcap_actionfield_set actionset) { … } EXPORT_SYMBOL_GPL(…); /* Check if a rule with this id exists */ static bool vcap_rule_exists(struct vcap_control *vctrl, u32 id) { … } /* Find a rule with a provided rule id return a locked vcap */ static struct vcap_rule_internal * vcap_get_locked_rule(struct vcap_control *vctrl, u32 id) { … } /* Find a rule id with a provided cookie */ int vcap_lookup_rule_by_cookie(struct vcap_control *vctrl, u64 cookie) { … } EXPORT_SYMBOL_GPL(…); /* Get number of rules in a vcap instance lookup chain id range */ int vcap_admin_rule_count(struct vcap_admin *admin, int cid) { … } EXPORT_SYMBOL_GPL(…); /* Make a copy of the rule, shallow or full */ static struct vcap_rule_internal *vcap_dup_rule(struct vcap_rule_internal *ri, bool full) { … } static void vcap_apply_width(u8 *dst, int width, int bytes) { … } static void vcap_copy_from_w32be(u8 *dst, u8 *src, int size, int width) { … } static void vcap_copy_action_bit_field(struct vcap_u1_action *field, u8 *value) { … } static void vcap_copy_limited_actionfield(u8 *dstvalue, u8 *srcvalue, int width, int bytes) { … } static void vcap_copy_to_client_actionfield(struct vcap_rule_internal *ri, struct vcap_client_actionfield *field, u8 *value, u16 width) { … } static void vcap_copy_key_bit_field(struct vcap_u1_key *field, u8 *value, u8 *mask) { … } static void vcap_copy_limited_keyfield(u8 *dstvalue, u8 *dstmask, u8 *srcvalue, u8 *srcmask, int width, int bytes) { … } static void vcap_copy_to_client_keyfield(struct vcap_rule_internal *ri, struct vcap_client_keyfield *field, u8 *value, u8 *mask, u16 width) { … } static void vcap_rule_alloc_keyfield(struct vcap_rule_internal *ri, const struct vcap_field *keyfield, enum vcap_key_field key, u8 *value, u8 *mask) { … } /* Read key data from a VCAP address and discover if there is a rule keyset * here */ static bool vcap_verify_actionstream_actionset(struct vcap_control *vctrl, enum vcap_type vt, u32 *actionstream, enum vcap_actionfield_set actionset) { … } /* Find the subword width of the action typegroup that matches the stream data */ static int vcap_find_actionstream_typegroup_sw(struct vcap_control *vctrl, enum vcap_type vt, u32 *stream, int sw_max) { … } /* Verify that the typegroup information, subword count, actionset and type id * are in sync and correct, return the actionset */ static enum vcap_actionfield_set vcap_find_actionstream_actionset(struct vcap_control *vctrl, enum vcap_type vt, u32 *stream, int sw_max) { … } /* Store action value in an element in a list for the client */ static void vcap_rule_alloc_actionfield(struct vcap_rule_internal *ri, const struct vcap_field *actionfield, enum vcap_action_field action, u8 *value) { … } static int vcap_decode_actionset(struct vcap_rule_internal *ri) { … } static int vcap_decode_keyset(struct vcap_rule_internal *ri) { … } /* Read VCAP content into the VCAP cache */ static int vcap_read_rule(struct vcap_rule_internal *ri) { … } /* Write VCAP cache content to the VCAP HW instance */ static int vcap_write_rule(struct vcap_rule_internal *ri) { … } static int vcap_write_counter(struct vcap_rule_internal *ri, struct vcap_counter *ctr) { … } /* Convert a chain id to a VCAP lookup index */ int vcap_chain_id_to_lookup(struct vcap_admin *admin, int cur_cid) { … } EXPORT_SYMBOL_GPL(…); /* Lookup a vcap instance using chain id */ struct vcap_admin *vcap_find_admin(struct vcap_control *vctrl, int cid) { … } EXPORT_SYMBOL_GPL(…); /* Is this the last admin instance ordered by chain id and direction */ static bool vcap_admin_is_last(struct vcap_control *vctrl, struct vcap_admin *admin, bool ingress) { … } /* Calculate the value used for chaining VCAP rules */ int vcap_chain_offset(struct vcap_control *vctrl, int from_cid, int to_cid) { … } EXPORT_SYMBOL_GPL(…); /* Is the next chain id in one of the following lookups * For now this does not support filters linked to other filters using * keys and actions. That will be added later. */ bool vcap_is_next_lookup(struct vcap_control *vctrl, int src_cid, int dst_cid) { … } EXPORT_SYMBOL_GPL(…); /* Check if there is room for a new rule */ static int vcap_rule_space(struct vcap_admin *admin, int size) { … } /* Add the keyset typefield to the list of rule keyfields */ static int vcap_add_type_keyfield(struct vcap_rule *rule) { … } /* Add the actionset typefield to the list of rule actionfields */ static int vcap_add_type_actionfield(struct vcap_rule *rule) { … } /* Add a keyset to a keyset list */ bool vcap_keyset_list_add(struct vcap_keyset_list *keysetlist, enum vcap_keyfield_set keyset) { … } EXPORT_SYMBOL_GPL(…); /* Add a actionset to a actionset list */ static bool vcap_actionset_list_add(struct vcap_actionset_list *actionsetlist, enum vcap_actionfield_set actionset) { … } /* map keyset id to a string with the keyset name */ const char *vcap_keyset_name(struct vcap_control *vctrl, enum vcap_keyfield_set keyset) { … } EXPORT_SYMBOL_GPL(…); /* map key field id to a string with the key name */ const char *vcap_keyfield_name(struct vcap_control *vctrl, enum vcap_key_field key) { … } EXPORT_SYMBOL_GPL(…); /* map actionset id to a string with the actionset name */ const char *vcap_actionset_name(struct vcap_control *vctrl, enum vcap_actionfield_set actionset) { … } /* map action field id to a string with the action name */ const char *vcap_actionfield_name(struct vcap_control *vctrl, enum vcap_action_field action) { … } /* Return the keyfield that matches a key in a keyset */ static const struct vcap_field * vcap_find_keyset_keyfield(struct vcap_control *vctrl, enum vcap_type vtype, enum vcap_keyfield_set keyset, enum vcap_key_field key) { … } /* Match a list of keys against the keysets available in a vcap type */ static bool _vcap_rule_find_keysets(struct vcap_rule_internal *ri, struct vcap_keyset_list *matches) { … } /* Match a list of keys against the keysets available in a vcap type */ bool vcap_rule_find_keysets(struct vcap_rule *rule, struct vcap_keyset_list *matches) { … } EXPORT_SYMBOL_GPL(…); /* Return the actionfield that matches a action in a actionset */ static const struct vcap_field * vcap_find_actionset_actionfield(struct vcap_control *vctrl, enum vcap_type vtype, enum vcap_actionfield_set actionset, enum vcap_action_field action) { … } /* Match a list of actions against the actionsets available in a vcap type */ static bool vcap_rule_find_actionsets(struct vcap_rule_internal *ri, struct vcap_actionset_list *matches) { … } /* Validate a rule with respect to available port keys */ int vcap_val_rule(struct vcap_rule *rule, u16 l3_proto) { … } EXPORT_SYMBOL_GPL(…); /* Entries are sorted with increasing values of sort_key. * I.e. Lowest numerical sort_key is first in list. * In order to locate largest keys first in list we negate the key size with * (max_size - size). */ static u32 vcap_sort_key(u32 max_size, u32 size, u8 user, u16 prio) { … } /* calculate the address of the next rule after this (lower address and prio) */ static u32 vcap_next_rule_addr(u32 addr, struct vcap_rule_internal *ri) { … } /* Assign a unique rule id and autogenerate one if id == 0 */ static u32 vcap_set_rule_id(struct vcap_rule_internal *ri) { … } static int vcap_insert_rule(struct vcap_rule_internal *ri, struct vcap_rule_move *move) { … } static void vcap_move_rules(struct vcap_rule_internal *ri, struct vcap_rule_move *move) { … } /* Check if the chain is already used to enable a VCAP lookup for this port */ static bool vcap_is_chain_used(struct vcap_control *vctrl, struct net_device *ndev, int src_cid) { … } /* Fetch the next chain in the enabled list for the port */ static int vcap_get_next_chain(struct vcap_control *vctrl, struct net_device *ndev, int dst_cid) { … } static bool vcap_path_exist(struct vcap_control *vctrl, struct net_device *ndev, int dst_cid) { … } /* Internal clients can always store their rules in HW * External clients can store their rules if the chain is enabled all * the way from chain 0, otherwise the rule will be cached until * the chain is enabled. */ static void vcap_rule_set_state(struct vcap_rule_internal *ri) { … } /* Encode and write a validated rule to the VCAP */ int vcap_add_rule(struct vcap_rule *rule) { … } EXPORT_SYMBOL_GPL(…); /* Allocate a new rule with the provided arguments */ struct vcap_rule *vcap_alloc_rule(struct vcap_control *vctrl, struct net_device *ndev, int vcap_chain_id, enum vcap_user user, u16 priority, u32 id) { … } EXPORT_SYMBOL_GPL(…); /* Free mem of a rule owned by client after the rule as been added to the VCAP */ void vcap_free_rule(struct vcap_rule *rule) { … } EXPORT_SYMBOL_GPL(…); /* Decode a rule from the VCAP cache and return a copy */ struct vcap_rule *vcap_decode_rule(struct vcap_rule_internal *elem) { … } struct vcap_rule *vcap_get_rule(struct vcap_control *vctrl, u32 id) { … } EXPORT_SYMBOL_GPL(…); /* Update existing rule */ int vcap_mod_rule(struct vcap_rule *rule) { … } EXPORT_SYMBOL_GPL(…); /* Return the alignment offset for a new rule address */ static int vcap_valid_rule_move(struct vcap_rule_internal *el, int offset) { … } /* Update the rule address with an offset */ static void vcap_adjust_rule_addr(struct vcap_rule_internal *el, int offset) { … } /* Rules needs to be moved to fill the gap of the deleted rule */ static int vcap_fill_rule_gap(struct vcap_rule_internal *ri) { … } /* Delete rule in a VCAP instance */ int vcap_del_rule(struct vcap_control *vctrl, struct net_device *ndev, u32 id) { … } EXPORT_SYMBOL_GPL(…); /* Delete all rules in the VCAP instance */ int vcap_del_rules(struct vcap_control *vctrl, struct vcap_admin *admin) { … } EXPORT_SYMBOL_GPL(…); /* Find a client key field in a rule */ static struct vcap_client_keyfield * vcap_find_keyfield(struct vcap_rule *rule, enum vcap_key_field key) { … } /* Find information on a key field in a rule */ const struct vcap_field *vcap_lookup_keyfield(struct vcap_rule *rule, enum vcap_key_field key) { … } EXPORT_SYMBOL_GPL(…); /* Check if the keyfield is already in the rule */ static bool vcap_keyfield_unique(struct vcap_rule *rule, enum vcap_key_field key) { … } /* Check if the keyfield is in the keyset */ static bool vcap_keyfield_match_keyset(struct vcap_rule *rule, enum vcap_key_field key) { … } static int vcap_rule_add_key(struct vcap_rule *rule, enum vcap_key_field key, enum vcap_field_type ftype, struct vcap_client_keyfield_data *data) { … } static void vcap_rule_set_key_bitsize(struct vcap_u1_key *u1, enum vcap_bit val) { … } /* Add a bit key with value and mask to the rule */ int vcap_rule_add_key_bit(struct vcap_rule *rule, enum vcap_key_field key, enum vcap_bit val) { … } EXPORT_SYMBOL_GPL(…); /* Add a 32 bit key field with value and mask to the rule */ int vcap_rule_add_key_u32(struct vcap_rule *rule, enum vcap_key_field key, u32 value, u32 mask) { … } EXPORT_SYMBOL_GPL(…); /* Add a 48 bit key with value and mask to the rule */ int vcap_rule_add_key_u48(struct vcap_rule *rule, enum vcap_key_field key, struct vcap_u48_key *fieldval) { … } EXPORT_SYMBOL_GPL(…); /* Add a 72 bit key with value and mask to the rule */ int vcap_rule_add_key_u72(struct vcap_rule *rule, enum vcap_key_field key, struct vcap_u72_key *fieldval) { … } EXPORT_SYMBOL_GPL(…); /* Add a 128 bit key with value and mask to the rule */ int vcap_rule_add_key_u128(struct vcap_rule *rule, enum vcap_key_field key, struct vcap_u128_key *fieldval) { … } EXPORT_SYMBOL_GPL(…); int vcap_rule_get_key_u32(struct vcap_rule *rule, enum vcap_key_field key, u32 *value, u32 *mask) { … } EXPORT_SYMBOL_GPL(…); /* Find a client action field in a rule */ struct vcap_client_actionfield * vcap_find_actionfield(struct vcap_rule *rule, enum vcap_action_field act) { … } EXPORT_SYMBOL_GPL(…); /* Check if the actionfield is already in the rule */ static bool vcap_actionfield_unique(struct vcap_rule *rule, enum vcap_action_field act) { … } /* Check if the actionfield is in the actionset */ static bool vcap_actionfield_match_actionset(struct vcap_rule *rule, enum vcap_action_field action) { … } static int vcap_rule_add_action(struct vcap_rule *rule, enum vcap_action_field action, enum vcap_field_type ftype, struct vcap_client_actionfield_data *data) { … } static void vcap_rule_set_action_bitsize(struct vcap_u1_action *u1, enum vcap_bit val) { … } /* Add a bit action with value to the rule */ int vcap_rule_add_action_bit(struct vcap_rule *rule, enum vcap_action_field action, enum vcap_bit val) { … } EXPORT_SYMBOL_GPL(…); /* Add a 32 bit action field with value to the rule */ int vcap_rule_add_action_u32(struct vcap_rule *rule, enum vcap_action_field action, u32 value) { … } EXPORT_SYMBOL_GPL(…); /* Add a 72 bit action field with value to the rule */ int vcap_rule_add_action_u72(struct vcap_rule *rule, enum vcap_action_field action, struct vcap_u72_action *fieldval) { … } EXPORT_SYMBOL_GPL(…); static int vcap_read_counter(struct vcap_rule_internal *ri, struct vcap_counter *ctr) { … } /* Copy to host byte order */ void vcap_netbytes_copy(u8 *dst, u8 *src, int count) { … } EXPORT_SYMBOL_GPL(…); /* Convert validation error code into tc extack error message */ void vcap_set_tc_exterr(struct flow_cls_offload *fco, struct vcap_rule *vrule) { … } EXPORT_SYMBOL_GPL(…); /* Write a rule to VCAP HW to enable it */ static int vcap_enable_rule(struct vcap_rule_internal *ri) { … } /* Enable all disabled rules for a specific chain/port in the VCAP HW */ static int vcap_enable_rules(struct vcap_control *vctrl, struct net_device *ndev, int chain) { … } /* Read and erase a rule from VCAP HW to disable it */ static int vcap_disable_rule(struct vcap_rule_internal *ri) { … } /* Disable all enabled rules for a specific chain/port in the VCAP HW */ static int vcap_disable_rules(struct vcap_control *vctrl, struct net_device *ndev, int chain) { … } /* Check if this port is already enabled for this VCAP instance */ static bool vcap_is_enabled(struct vcap_control *vctrl, struct net_device *ndev, int dst_cid) { … } /* Enable this port and chain id in a VCAP instance */ static int vcap_enable(struct vcap_control *vctrl, struct net_device *ndev, unsigned long cookie, int src_cid, int dst_cid) { … } /* Disable this port and chain id for a VCAP instance */ static int vcap_disable(struct vcap_control *vctrl, struct net_device *ndev, unsigned long cookie) { … } /* Enable/Disable the VCAP instance lookups */ int vcap_enable_lookups(struct vcap_control *vctrl, struct net_device *ndev, int src_cid, int dst_cid, unsigned long cookie, bool enable) { … } EXPORT_SYMBOL_GPL(…); /* Is this chain id the last lookup of all VCAPs */ bool vcap_is_last_chain(struct vcap_control *vctrl, int cid, bool ingress) { … } EXPORT_SYMBOL_GPL(…); /* Set a rule counter id (for certain vcaps only) */ void vcap_rule_set_counter_id(struct vcap_rule *rule, u32 counter_id) { … } EXPORT_SYMBOL_GPL(…); int vcap_rule_set_counter(struct vcap_rule *rule, struct vcap_counter *ctr) { … } EXPORT_SYMBOL_GPL(…); int vcap_rule_get_counter(struct vcap_rule *rule, struct vcap_counter *ctr) { … } EXPORT_SYMBOL_GPL(…); /* Get a copy of a client key field */ static int vcap_rule_get_key(struct vcap_rule *rule, enum vcap_key_field key, struct vcap_client_keyfield *ckf) { … } /* Find a keyset having the same size as the provided rule, where the keyset * does not have a type id. */ static int vcap_rule_get_untyped_keyset(struct vcap_rule_internal *ri, struct vcap_keyset_list *matches) { … } /* Get the keysets that matches the rule key type/mask */ int vcap_rule_get_keysets(struct vcap_rule_internal *ri, struct vcap_keyset_list *matches) { … } /* Collect packet counts from all rules with the same cookie */ int vcap_get_rule_count_by_cookie(struct vcap_control *vctrl, struct vcap_counter *ctr, u64 cookie) { … } EXPORT_SYMBOL_GPL(…); static int vcap_rule_mod_key(struct vcap_rule *rule, enum vcap_key_field key, enum vcap_field_type ftype, struct vcap_client_keyfield_data *data) { … } /* Modify a 32 bit key field with value and mask in the rule */ int vcap_rule_mod_key_u32(struct vcap_rule *rule, enum vcap_key_field key, u32 value, u32 mask) { … } EXPORT_SYMBOL_GPL(…); /* Remove a key field with value and mask in the rule */ int vcap_rule_rem_key(struct vcap_rule *rule, enum vcap_key_field key) { … } EXPORT_SYMBOL_GPL(…); static int vcap_rule_mod_action(struct vcap_rule *rule, enum vcap_action_field action, enum vcap_field_type ftype, struct vcap_client_actionfield_data *data) { … } /* Modify a 32 bit action field with value in the rule */ int vcap_rule_mod_action_u32(struct vcap_rule *rule, enum vcap_action_field action, u32 value) { … } EXPORT_SYMBOL_GPL(…); /* Drop keys in a keylist and any keys that are not supported by the keyset */ int vcap_filter_rule_keys(struct vcap_rule *rule, enum vcap_key_field keylist[], int length, bool drop_unsupported) { … } EXPORT_SYMBOL_GPL(…); /* Select the keyset from the list that results in the smallest rule size */ enum vcap_keyfield_set vcap_select_min_rule_keyset(struct vcap_control *vctrl, enum vcap_type vtype, struct vcap_keyset_list *kslist) { … } EXPORT_SYMBOL_GPL(…); /* Make a full copy of an existing rule with a new rule id */ struct vcap_rule *vcap_copy_rule(struct vcap_rule *erule) { … } EXPORT_SYMBOL_GPL(…); #ifdef CONFIG_VCAP_KUNIT_TEST #include "vcap_api_kunit.c" #endif
Codebase Browser
linux