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"); } } }