void check_attr_value_type_range(
_In_ const sai_attr_metadata_t* md)
{
META_LOG_ENTER();
META_ASSERT_NOT_NULL(sai_metadata_get_enum_value_name(&metadata_enum_sai_attr_value_type_t, md->attrvaluetype));
}
std::vector<swss::FieldValueTuple> serialize_counter_id_list(
_In_ const sai_enum_metadata_t *stats_enum,
_In_ uint32_t count,
_In_ const int32_t *counter_id_list)
{
SWSS_LOG_ENTER();
std::vector<swss::FieldValueTuple> values;
for (uint32_t i = 0; i < count; i++)
{
const char *name = sai_metadata_get_enum_value_name(stats_enum, counter_id_list[i]);
if (name == NULL)
{
SWSS_LOG_THROW("failed to find enum %d in %s", counter_id_list[i], stats_enum->name);
}
values.emplace_back(name, "");
}
return std::move(values);
}
sai_status_t redis_generic_stats_function(
_In_ sai_object_type_t object_type,
_In_ sai_object_id_t object_id,
_In_ const sai_enum_metadata_t *enum_metadata,
_In_ uint32_t number_of_counters,
_In_ const int32_t *counter_ids,
_In_ sai_stats_mode_t mode,
_Out_ uint64_t *counters)
{
SWSS_LOG_ENTER();
/*
* Do all parameter validation.
*/
if (object_id == SAI_NULL_OBJECT_ID)
{
SWSS_LOG_ERROR("object id is NULL");
return SAI_STATUS_INVALID_PARAMETER;
}
sai_object_type_t ot = sai_object_type_query(object_id);
if (ot != object_type)
{
SWSS_LOG_ERROR("object %s is %s but expected %s",
sai_serialize_object_id(object_id).c_str(),
sai_serialize_object_type(ot).c_str(),
sai_serialize_object_type(object_type).c_str());
return SAI_STATUS_INVALID_PARAMETER;
}
sai_object_id_t switch_id = sai_switch_id_query(object_id);
if (switch_id == SAI_NULL_OBJECT_ID)
{
SWSS_LOG_ERROR("object %s does not correspond to any switch object",
sai_serialize_object_id(object_id).c_str());
return SAI_STATUS_INVALID_PARAMETER;
}
uint32_t count = number_of_counters & ~REDIS_COUNTERS_COUNT_MSB;
if (count > REDIS_MAX_COUNTERS)
{
SWSS_LOG_ERROR("max supported counters to get/clear is %u, but %u given",
REDIS_MAX_COUNTERS,
count);
return SAI_STATUS_INVALID_PARAMETER;
}
if (counter_ids == NULL)
{
SWSS_LOG_ERROR("counter ids pointer is NULL");
return SAI_STATUS_INVALID_PARAMETER;
}
if (counters == NULL)
{
SWSS_LOG_ERROR("counters output pointer is NULL");
return SAI_STATUS_INVALID_PARAMETER;
}
if (enum_metadata == NULL)
{
SWSS_LOG_ERROR("enum metadata pointer is NULL, bug?");
return SAI_STATUS_FAILURE;
}
for (uint32_t i = 0; i < count; i++)
{
if (sai_metadata_get_enum_value_name(enum_metadata, counter_ids[i]) == NULL)
{
SWSS_LOG_ERROR("counter id %u is not allowed on %s", counter_ids[i], enum_metadata->name);
return SAI_STATUS_INVALID_PARAMETER;
}
}
switch (mode)
{
case SAI_STATS_MODE_READ:
case SAI_STATS_MODE_READ_AND_CLEAR:
break;
default:
SWSS_LOG_ERROR("counters mode is invalid %d", mode);
return SAI_STATUS_INVALID_PARAMETER;
}
return internal_redis_generic_stats_function(
object_type,
object_id,
switch_id,
enum_metadata,
number_of_counters,
counter_ids,
mode,
counters);
}
void check_attr_conditions(
_In_ const sai_attr_metadata_t* md)
{
META_LOG_ENTER();
switch (md->conditiontype)
{
case SAI_ATTR_CONDITION_TYPE_NONE:
case SAI_ATTR_CONDITION_TYPE_OR:
break;
default:
META_ASSERT_FAIL(md, "invalid condition type specified: %d", md->conditiontype);
}
bool conditional = md->conditiontype != SAI_ATTR_CONDITION_TYPE_NONE;
if (!conditional && md->conditions != NULL)
{
META_ASSERT_FAIL(md, "not conditional but conditions specified");
}
if (!conditional)
{
return;
}
if (md->conditions == NULL)
{
META_ASSERT_FAIL(md, "marked as conditional but no conditions specified");
}
switch ((int)md->flags)
{
case SAI_ATTR_FLAGS_MANDATORY_ON_CREATE | SAI_ATTR_FLAGS_CREATE_AND_SET:
if (md->objecttype != SAI_OBJECT_TYPE_MIRROR_SESSION)
{
META_ASSERT_FAIL(md, "marked as conditional on non mirror session, but invalid creation flags: 0x%u", md->flags);
}
break;
case SAI_ATTR_FLAGS_MANDATORY_ON_CREATE | SAI_ATTR_FLAGS_CREATE_ONLY:
case SAI_ATTR_FLAGS_CREATE_ONLY: /* will require default value, on some cases may be dynamic */
break;
default:
META_ASSERT_FAIL(md, "marked as conditional, but invalid creation flags: 0x%u", md->flags);
}
/* condition must be the same object type as attribue we check */
size_t index = 0;
for (; index < md->conditionslength; ++index)
{
const sai_attr_condition_t* c = md->conditions[index];
if (c->attrid == md->attrid)
{
META_ASSERT_FAIL(md, "conditional attr id %d is the same as condition attribute", c->attrid);
}
const sai_attr_metadata_t* cmd = sai_metadata_get_attr_metadata(md->objecttype, c->attrid);
if (cmd == NULL)
{
META_ASSERT_FAIL(md, "conditional attribute id %d was not defined yet in metadata", c->attrid);
}
switch (cmd->attrvaluetype)
{
case SAI_ATTR_VALUE_TYPE_BOOL:
META_LOG_INFO("attr id: %d cond.bool: %d", c->attrid, c->condition.booldata);
break;
case SAI_ATTR_VALUE_TYPE_INT32:
if (!cmd->isenum)
{
META_ASSERT_FAIL(md, "conditional attribute %d is not enum type", cmd->attrid);
}
META_LOG_INFO("attr id: %d cond.s32: %d ", c->attrid, c->condition.s32);
/* check if condition enum is in condition attribute range */
if (sai_metadata_get_enum_value_name(cmd->enummetadata, c->condition.s32) == NULL)
{
META_ASSERT_FAIL(md, "condition enum %d not found on condition attribute enum range", c->condition.s32);
}
break;
default:
META_ASSERT_FAIL(md, "attr value type %d of conditional attribute is not supported yet", cmd->attrvaluetype);
}
if (cmd->conditiontype != SAI_ATTR_CONDITION_TYPE_NONE)
{
if (cmd->flags == SAI_ATTR_FLAGS_CREATE_ONLY &&
cmd->attrvaluetype == SAI_ATTR_VALUE_TYPE_BOOL)
{
/* ok, that means there is default value (it may be depending on switch intenal) */
}
else
{
META_ASSERT_FAIL(md, "conditional attibute is also conditional, not allowed");
}
}
switch ((int)cmd->flags)
{
case SAI_ATTR_FLAGS_MANDATORY_ON_CREATE | SAI_ATTR_FLAGS_CREATE_ONLY | SAI_ATTR_FLAGS_KEY:
case SAI_ATTR_FLAGS_MANDATORY_ON_CREATE | SAI_ATTR_FLAGS_CREATE_ONLY:
case SAI_ATTR_FLAGS_CREATE_ONLY:
/*
* condition attribute must be create only since
* if it could change then other object may be required to pass
* on creation time that was not passed
*/
break;
default:
META_ASSERT_FAIL(md, "conditional attribute must be create only");
}
}
}
void check_attr_enums(
_In_ const sai_attr_metadata_t* md)
{
META_LOG_ENTER();
if (md->isenum)
{
switch (md->attrvaluetype)
{
case SAI_ATTR_VALUE_TYPE_INT32:
case SAI_ATTR_VALUE_TYPE_ACL_FIELD_DATA_INT32:
case SAI_ATTR_VALUE_TYPE_ACL_ACTION_DATA_INT32:
break;
default:
META_ASSERT_FAIL(md, "attribute is marked as enum, but attr value type is not enum compatible");
}
}
if (md->isenum && md->isenumlist)
{
META_ASSERT_FAIL(md, "attribute can't be marked as enum and enum list");
}
if ((md->isenum || md->isenumlist) && md->enummetadata == NULL)
{
META_ASSERT_FAIL(md, "is marked enum but missing enum metadata");
}
if (!(md->isenum || md->isenumlist) && md->enummetadata != NULL)
{
META_ASSERT_FAIL(md, "is not marked enum but has defined enum type string");
}
if ((md->isenum || md->isenumlist) && md->enummetadata->valuescount == 0)
{
META_ASSERT_FAIL(md, "is marked enum but missing enum allowed values");
}
bool requiredefault = (!HAS_FLAG_MANDATORY_ON_CREATE(md->flags)) &&
(HAS_FLAG_CREATE_ONLY(md->flags) || HAS_FLAG_CREATE_AND_SET(md->flags));
if (requiredefault && md->isenum)
{
if (md->defaultvalue == NULL)
{
if (sai_metadata_is_acl_field_or_action(md))
{
return;
}
META_ASSERT_FAIL(md, "marked as enum, and require default, but not provided");
}
int32_t enumdefault = md->defaultvalue->s32;
if (sai_metadata_get_enum_value_name(md->enummetadata, enumdefault) == NULL)
{
META_ASSERT_FAIL(md, "default enum value %d is not present on enum allowed values (%s)", enumdefault, md->enummetadata->name);
}
}
if (requiredefault && md->isenumlist)
{
if (md->defaultvalue != NULL)
{
META_ASSERT_FAIL(md, "default values on enum list are not supported yet");
}
}
}
