[sai_redis_interface_query] Add sairedis support for sai_query_attrib…

…ute_enum_values_capability (sonic-net#525)

* [sai_redis_interface_query] Add sairedis support for sai_query_attribute_enum_values_capability
* Add sai_query_attribute_enum_values_capability to libsairedis
* Add handler for sai_query_attribute_enum_values_capability to syncd
* Add sai_query_attribute_enum_values_capability implementation to virtual switch

Signed-off-by: Danny Allen <daall@microsoft.com>

lib/inc/sairedis.h

@@ -11,6 +11,9 @@ extern "C" {
 #define ASIC_STATE_TABLE "ASIC_STATE"
 #define TEMP_PREFIX "TEMP_"
 
+const std::string attrEnumValuesCapabilityQuery("attr_enum_values_capability_query");
+const std::string attrEnumValuesCapabilityResponse("attr_enum_values_capability_response");
+
 typedef enum _sai_redis_notify_syncd_t
 {
  SAI_REDIS_NOTIFY_SYNCD_INIT_VIEW,

lib/src/sai_redis_interfacequery.cpp

@@ -1,6 +1,8 @@
 #include "sai_redis.h"
 #include "sairedis.h"
 
+#include "meta/sai_serialize.h"
+
 #include "swss/selectableevent.h"
 #include <string.h>
 
@@ -258,3 +260,153 @@ sai_status_t sai_api_query(
  return SAI_STATUS_INVALID_PARAMETER;
  }
 }
+
+sai_status_t sai_query_attribute_enum_values_capability(
+ _In_ sai_object_id_t switch_id,
+ _In_ sai_object_type_t object_type,
+ _In_ sai_attr_id_t attr_id,
+ _Inout_ sai_s32_list_t *enum_values_capability)
+{
+ MUTEX();
+
+ SWSS_LOG_ENTER();
+
+ const std::string switch_id_str = sai_serialize_object_id(switch_id);
+ const std::string object_type_str = sai_serialize_object_type(object_type);
+
+ auto meta = sai_metadata_get_attr_metadata(object_type, attr_id);
+ if (meta == NULL)
+ {
+ SWSS_LOG_ERROR("Failed to find attribute metadata: object type %s, attr id %d", object_type_str.c_str(), attr_id);
+ return SAI_STATUS_INVALID_PARAMETER;
+ }
+
+ const std::string attr_id_str = sai_serialize_attr_id(*meta);
+ const std::string list_size = std::to_string(enum_values_capability->count);
+
+ const std::vector<swss::FieldValueTuple> query_arguments =
+ {
+ swss::FieldValueTuple("OBJECT_TYPE", object_type_str),
+ swss::FieldValueTuple("ATTR_ID", attr_id_str),
+ swss::FieldValueTuple("LIST_SIZE", list_size)
+ };
+
+ SWSS_LOG_DEBUG(
+ "Query arguments: switch %s, object type: %s, attribute: %s, count: %s",
+ switch_id_str.c_str(),
+ object_type_str.c_str(),
+ attr_id_str.c_str(),
+ list_size.c_str()
+ );
+
+ if (g_record)
+ {
+ recordLine("q|attribute_enum_values_capability|" + switch_id_str + "|" + joinFieldValues(query_arguments));
+ }
+
+ // This query will not put any data into the ASIC view, just into the
+ // message queue
+ g_asicState->set(switch_id_str, query_arguments, attrEnumValuesCapabilityQuery);
+
+ swss::Select callback;
+ callback.addSelectable(g_redisGetConsumer.get());
+
+ while (true)
+ {
+ SWSS_LOG_DEBUG("Waiting for a response");
+
+ swss::Selectable *sel;
+
+ auto result = callback.select(&sel, GET_RESPONSE_TIMEOUT);
+
+ if (result == swss::Select::OBJECT)
+ {
+ swss::KeyOpFieldsValuesTuple kco;
+
+ g_redisGetConsumer->pop(kco);
+
+ const std::string &message_type = kfvOp(kco);
+ const std::string &status_str = kfvKey(kco);
+
+ SWSS_LOG_DEBUG("Received response: op = %s, key = %s", message_type.c_str(), status_str.c_str());
+
+ // Ignore messages that are not in response to our query
+ if (message_type != attrEnumValuesCapabilityResponse)
+ {
+ continue;
+ }
+
+ sai_status_t status;
+ sai_deserialize_status(status_str, status);
+
+ if (status == SAI_STATUS_SUCCESS)
+ {
+ const std::vector<swss::FieldValueTuple> &values = kfvFieldsValues(kco);
+
+ if (values.size() != 2)
+ {
+ if (g_record)
+ {
+ recordLine("Q|attribute_enum_values_capability|SAI_STATUS_FAILURE");
+ }
+
+ SWSS_LOG_ERROR("Invalid response from syncd: expected 2 values, received %d", values.size());
+ return SAI_STATUS_FAILURE;
+ }
+
+ const std::string &capability_str = fvValue(values[0]);
+ const uint32_t num_capabilities = std::stoi(fvValue(values[1]));
+
+ SWSS_LOG_DEBUG("Received payload: capabilites = '%s', count = %d", capability_str.c_str(), num_capabilities);
+
+ enum_values_capability->count = num_capabilities;
+
+ size_t position = 0;
+ for (uint32_t i = 0; i < num_capabilities; i++)
+ {
+ size_t old_position = position;
+ position = capability_str.find(",", old_position);
+ std::string capability = capability_str.substr(old_position, position - old_position);
+ enum_values_capability->list[i] = std::stoi(capability);
+
+ // We have run out of values to add to our list
+ if (position == std::string::npos)
+ {
+ if (num_capabilities != i + 1)
+ {
+ SWSS_LOG_WARN("Query returned less attributes than expected: expected %d, recieved %d");
+ }
+
+ break;
+ }
+
+ // Skip the commas
+ position++;
+ }
+
+ if (g_record)
+ {
+ recordLine("Q|attribute_enum_values_capability|" + status_str + "|" + joinFieldValues(values));
+ }
+ }
+ else
+ {
+ if (g_record)
+ {
+ recordLine("Q|attribute_enum_values_capability|" + status_str);
+ }
+ }
+
+ SWSS_LOG_DEBUG("Status: %s", status_str.c_str());
+ return status;
+ }
+ }
+
+ if (g_record)
+ {
+ recordLine("Q|attribute_enum_values_capability|SAI_STATUS_FAILURE");
+ }
+
+ SWSS_LOG_ERROR("Failed to receive a response from syncd");
+ return SAI_STATUS_FAILURE;
+}

saiplayer/saiplayer.cpp

@@ -1210,6 +1210,11 @@ int replay(int argc, char **argv)
  case 'g':
  api = SAI_COMMON_API_GET;
  break;
+ case 'q':
+ // TODO: implement SAI player support for query commands
+ continue;
+ case 'Q':
+ continue; // skip over query responses
  case '#':
  case 'n':
  continue; // skip comment and notification

syncd/syncd.cpp

@@ -2867,6 +2867,72 @@ sai_status_t processFdbFlush(
  return status;
 }
 
+sai_status_t processAttrEnumValuesCapabilityQuery(
+ _In_ const swss::KeyOpFieldsValuesTuple &kco)
+{
+ SWSS_LOG_ENTER();
+
+ const std::string &switch_str_id = kfvKey(kco);
+
+ sai_object_id_t switch_vid;
+ sai_deserialize_object_id(switch_str_id, switch_vid);
+
+ const sai_object_id_t switch_rid = translate_vid_to_rid(switch_vid);
+
+ const std::vector<swss::FieldValueTuple> &values = kfvFieldsValues(kco);
+
+ if (values.size() != 3)
+ {
+ SWSS_LOG_ERROR("Invalid input: expected 3 arguments, received %d", values.size());
+ getResponse->set(sai_serialize_status(SAI_STATUS_INVALID_PARAMETER), {}, attrEnumValuesCapabilityResponse);
+ return SAI_STATUS_INVALID_PARAMETER;
+ }
+
+ sai_object_type_t object_type;
+ sai_deserialize_object_type(fvValue(values[0]), object_type);
+
+ sai_attr_id_t attr_id;
+ sai_deserialize_attr_id(fvValue(values[1]), attr_id);
+
+ const uint32_t list_size = std::stoi(fvValue(values[2]));
+ std::vector<int32_t> enum_capabilities_list(list_size);
+
+ sai_s32_list_t enum_values_capability;
+ enum_values_capability.count = list_size;
+ enum_values_capability.list = enum_capabilities_list.data();
+
+ sai_status_t status = sai_query_attribute_enum_values_capability(switch_rid, object_type, attr_id, &enum_values_capability);
+
+ std::vector<swss::FieldValueTuple> response_payload;
+
+ if (status == SAI_STATUS_SUCCESS)
+ {
+ std::string serialized_enum_capabilities;
+ for (uint32_t i = 0; i < enum_values_capability.count; i++)
+ {
+ // We will remove the leading comma before sending the response
+ serialized_enum_capabilities += ',';
+ serialized_enum_capabilities += std::to_string(enum_capabilities_list[i]);
+ }
+
+ if (!serialized_enum_capabilities.empty())
+ {
+ serialized_enum_capabilities = serialized_enum_capabilities.substr(1);
+ }
+
+ response_payload =
+ {
+ swss::FieldValueTuple("ENUM_CAPABILITIES", serialized_enum_capabilities),
+ swss::FieldValueTuple("ENUM_COUNT", std::to_string(enum_values_capability.count))
+ };
+
+ SWSS_LOG_DEBUG("Sending response: capabilities = '%s', count = %d", serialized_enum_capabilities.substr(1).c_str(), enum_values_capability.count);
+ }
+
+ getResponse->set(sai_serialize_status(status), response_payload, attrEnumValuesCapabilityResponse);
+ return status;
+}
+
 sai_status_t processEvent(
  _In_ swss::ConsumerTable &consumer)
 {
@@ -2959,6 +3025,10 @@ sai_status_t processEvent(
  {
  return processFdbFlush(kco);
  }
+ else if (op == attrEnumValuesCapabilityQuery)
+ {
+ return processAttrEnumValuesCapabilityQuery(kco);
+ }
  else
  {
  SWSS_LOG_THROW("api '%s' is not implemented", op.c_str());

tests/brcm.pl

@@ -518,6 +518,13 @@ sub test_brcm_warm_boot_port_create
  request_warm_shutdown;
 }
 
+sub test_brcm_query_attr_enum_values_capability
+{
+ fresh_start;
+
+ play "query_attr_enum_values_capability.rec";
+}
+
 # RUN TESTS
 
 test_brcm_warm_boot_port_remove;
@@ -568,5 +575,6 @@ sub test_brcm_warm_boot_port_create
 test_brcm_full_to_empty_no_queue_no_ipg;
 test_brcm_full_to_empty_hostif_remove_segfault;
 test_brcm_full_to_empty_no_queue_no_ipg_no_buffer_profile;
+test_brcm_query_attr_enum_values_capability;
 
 kill_syncd;

tests/brcm/query_attr_enum_values_capability.rec

@@ -0,0 +1,9 @@
+2019-10-25.04:21:31.884173|a|INIT_VIEW
+2019-10-25.04:21:31.884636|A|SAI_STATUS_SUCCESS
+2019-10-25.04:21:31.884882|c|SAI_OBJECT_TYPE_SWITCH:oid:0x21000000000000|SAI_SWITCH_ATTR_INIT_SWITCH=true|SAI_SWITCH_ATTR_SRC_MAC_ADDRESS=02:42:AC:11:00:02
+2019-10-25.04:21:32.853334|q|attribute_enum_values_capability|oid:0x21000000000000|OBJECT_TYPE=SAI_OBJECT_TYPE_DEBUG_COUNTER|ATTR_ID=SAI_DEBUG_COUNTER_ATTR_IN_DROP_REASON_LIST|LIST_SIZE=100
+2019-10-25.04:21:32.854651|Q|attribute_enum_values_capability|SAI_STATUS_SUCCESS|ENUM_CAPABILITIES=0,11,41|ENUM_COUNT=3
+2019-10-25.04:21:32.854730|q|attribute_enum_values_capability|oid:0x21000000000000|OBJECT_TYPE=SAI_OBJECT_TYPE_DEBUG_COUNTER|ATTR_ID=SAI_DEBUG_COUNTER_ATTR_OUT_DROP_REASON_LIST|LIST_SIZE=100
+2019-10-25.04:21:32.855398|Q|attribute_enum_values_capability|SAI_STATUS_SUCCESS|ENUM_CAPABILITIES=0,2|ENUM_COUNT=2
+2019-10-25.04:21:32.862373|a|APPLY_VIEW
+2019-10-25.04:21:32.863487|A|SAI_STATUS_SUCCESS

vslib/src/sai_vs_interfacequery.cpp

@@ -921,3 +921,45 @@ sai_status_t sai_api_query(
  return SAI_STATUS_INVALID_PARAMETER;
  }
 }
+
+sai_status_t sai_query_attribute_enum_values_capability(
+ _In_ sai_object_id_t switch_id,
+ _In_ sai_object_type_t object_type,
+ _In_ sai_attr_id_t attr_id,
+ _Inout_ sai_s32_list_t *enum_values_capability)
+{
+ SWSS_LOG_ENTER();
+
+ // TODO: We should generate this metadata for the virtual switch rather than hard-coding it here.
+ if (object_type == SAI_OBJECT_TYPE_DEBUG_COUNTER && attr_id == SAI_DEBUG_COUNTER_ATTR_IN_DROP_REASON_LIST)
+ {
+ if (enum_values_capability->count < 3)
+ {
+ return SAI_STATUS_BUFFER_OVERFLOW;
+ }
+
+ enum_values_capability->count = 3;
+ enum_values_capability->list[0] = SAI_IN_DROP_REASON_L2_ANY;
+ enum_values_capability->list[1] = SAI_IN_DROP_REASON_L3_ANY;
+ enum_values_capability->list[2] = SAI_IN_DROP_REASON_ACL_ANY;
+
+ return SAI_STATUS_SUCCESS;
+ }
+ else if (object_type == SAI_OBJECT_TYPE_DEBUG_COUNTER && attr_id == SAI_DEBUG_COUNTER_ATTR_OUT_DROP_REASON_LIST)
+ {
+ if (enum_values_capability->count < 2)
+ {
+ return SAI_STATUS_BUFFER_OVERFLOW;
+ }
+
+ enum_values_capability->count = 2;
+ enum_values_capability->list[0] = SAI_OUT_DROP_REASON_L2_ANY;
+ enum_values_capability->list[1] = SAI_OUT_DROP_REASON_L3_ANY;
+
+ return SAI_STATUS_SUCCESS;
+ }
+ else
+ {
+ return SAI_STATUS_NOT_SUPPORTED;
+ }
+}