diff --git a/common/redisclient.cpp b/common/redisclient.cpp new file mode 100644 index 000000000..78ccd737c --- /dev/null +++ b/common/redisclient.cpp @@ -0,0 +1,262 @@ +#include "redisclient.h" + +namespace swss +{ + +RedisClient::RedisClient(swss::DBConnector *db): + m_db(db) +{ +} + +int64_t RedisClient::del(std::string key) +{ + char *temp; + int len = redisFormatCommand(&temp, "DEL %s", key.c_str()); + std::string del(temp, len); + free(temp); + + RedisReply r(m_db, del, REDIS_REPLY_INTEGER, true); + + if (r.getContext()->type != REDIS_REPLY_INTEGER) + throw std::runtime_error("DEL operation failed"); + + return r.getContext()->integer; +} + +int64_t RedisClient::hdel(std::string key, std::string field) +{ + char *temp; + int len = redisFormatCommand(&temp, "HDEL %s %s", key.c_str(), field.c_str()); + std::string hdel(temp, len); + free(temp); + + RedisReply r(m_db, hdel, REDIS_REPLY_INTEGER, true); + + if (r.getContext()->type != REDIS_REPLY_INTEGER) + throw std::runtime_error("HDEL operation failed"); + + return r.getContext()->integer; +} + +void RedisClient::hset(std::string key, std::string field, std::string value) +{ + char *temp; + int len = redisFormatCommand(&temp, "HSET %s %s %s", key.c_str(), field.c_str(), value.c_str()); + std::string hset(temp, len); + free(temp); + + RedisReply r(m_db, hset, REDIS_REPLY_INTEGER, true); + + if (r.getContext()->type != REDIS_REPLY_INTEGER) + throw std::runtime_error("HSET operation failed"); +} + +void RedisClient::set(std::string key, std::string value) +{ + char *temp; + int len = redisFormatCommand(&temp, "SET %s %s", key.c_str(), value.c_str()); + std::string set(temp, len); + free(temp); + + RedisReply r(m_db, set, REDIS_REPLY_STATUS, true); + + if (r.getContext()->type != REDIS_REPLY_STATUS) + throw std::runtime_error("SET operation failed"); +} + +std::unordered_map RedisClient::hgetall(std::string key) +{ + std::unordered_map map; + + char *temp; + int len = redisFormatCommand(&temp, "HGETALL %s", key.c_str()); + + std::string incr(temp, len); + free(temp); + + RedisReply r(m_db, incr, REDIS_REPLY_ARRAY, true); + + if (r.getContext()->type != REDIS_REPLY_ARRAY) + throw std::runtime_error("HGETALL operation failed"); + + auto ctx = r.getContext(); + + for (unsigned int i = 0; i < ctx->elements; i += 2) + map[std::string(ctx->element[i]->str)] = std::string(ctx->element[i+1]->str); + + return map; +} + +std::vector RedisClient::keys(std::string key) +{ + std::vector list; + + char *temp; + int len = redisFormatCommand(&temp, "KEYS %s", key.c_str()); + + std::string keys(temp, len); + free(temp); + + RedisReply r(m_db, keys, REDIS_REPLY_ARRAY, true); + + if (r.getContext()->type != REDIS_REPLY_ARRAY) + throw std::runtime_error("KEYS operation failed"); + + auto ctx = r.getContext(); + + for (unsigned int i = 0; i < ctx->elements; i++) + list.push_back(ctx->element[i]->str); + + return list; +} + +int64_t RedisClient::incr(std::string key) +{ + char *temp; + int len = redisFormatCommand(&temp, "INCR %s", key.c_str()); + + std::string incr(temp, len); + free(temp); + + RedisReply r(m_db, incr, REDIS_REPLY_INTEGER, true); + + if (r.getContext()->type != REDIS_REPLY_INTEGER) + throw std::runtime_error("INCR command failed"); + + return r.getContext()->integer; +} + +int64_t RedisClient::decr(std::string key) +{ + char *temp; + int len = redisFormatCommand(&temp, "DECR %s", key.c_str()); + + std::string decr(temp, len); + free(temp); + + RedisReply r(m_db, decr, REDIS_REPLY_INTEGER, true); + + if (r.getContext()->type != REDIS_REPLY_INTEGER) + throw std::runtime_error("DECR command failed"); + + return r.getContext()->integer; +} + +std::shared_ptr RedisClient::get(std::string key) +{ + char *temp; + int len = redisFormatCommand(&temp, "GET %s", key.c_str()); + + std::string get(temp, len); + free(temp); + + redisReply *reply; + + redisAppendFormattedCommand(m_db->getContext(), get.c_str(), get.length()); + redisGetReply(m_db->getContext(), (void**)&reply); + + if (!reply) + throw std::runtime_error("GET failed, memory exception"); + + if (reply->type == REDIS_REPLY_NIL) + { + freeReplyObject(reply); + return std::shared_ptr(NULL); + } + + if (reply->type == REDIS_REPLY_STRING) + { + std::shared_ptr ptr(new std::string(reply->str)); + freeReplyObject(reply); + return ptr; + } + + freeReplyObject(reply); + + throw std::runtime_error("GET failed, memory exception"); +} + +std::shared_ptr RedisClient::hget(std::string key, std::string field) +{ + char *temp; + int len = redisFormatCommand(&temp, "HGET %s %s", key.c_str(), field.c_str()); + + std::string hget(temp, len); + free(temp); + + redisReply *reply; + + redisAppendFormattedCommand(m_db->getContext(), hget.c_str(), hget.length()); + redisGetReply(m_db->getContext(), (void**)&reply); + + if (!reply) + throw std::runtime_error("HGET failed, memory exception"); + + if (reply->type == REDIS_REPLY_NIL) + { + freeReplyObject(reply); + return std::shared_ptr(NULL); + } + + if (reply->type == REDIS_REPLY_STRING) + { + std::shared_ptr ptr(new std::string(reply->str)); + freeReplyObject(reply); + return ptr; + } + + freeReplyObject(reply); + + throw std::runtime_error("HGET failed, memory exception"); +} + +int64_t RedisClient::rpush(std::string list, std::string item) +{ + char *temp; + int len = redisFormatCommand(&temp, "RPUSH %s %s", list.c_str(), item.c_str()); + + std::string rpush(temp, len); + free(temp); + + RedisReply r(m_db, rpush, REDIS_REPLY_INTEGER, true); + + if (r.getContext()->type != REDIS_REPLY_INTEGER) + throw std::runtime_error("RPUSH command failed"); + + return r.getContext()->integer; +} + +std::shared_ptr RedisClient::blpop(std::string list, int timeout) +{ + char *temp; + int len = redisFormatCommand(&temp, "BLPOP %s %d", list.c_str(), timeout); + + std::string blpop(temp, len); + free(temp); + + redisReply *reply; + + redisAppendFormattedCommand(m_db->getContext(), blpop.c_str(), blpop.length()); + redisGetReply(m_db->getContext(), (void**)&reply); + + if (!reply) + throw std::runtime_error("BLPOP failed, memory exception"); + + if (reply->type == REDIS_REPLY_NIL) + { + freeReplyObject(reply); + return std::shared_ptr(NULL); + } + + if (reply->type == REDIS_REPLY_STRING) + { + std::shared_ptr ptr(new std::string(reply->str)); + freeReplyObject(reply); + return ptr; + } + + freeReplyObject(reply); + + throw std::runtime_error("GET failed, memory exception"); +} +} diff --git a/common/redisclient.h b/common/redisclient.h new file mode 100644 index 000000000..378099dc5 --- /dev/null +++ b/common/redisclient.h @@ -0,0 +1,67 @@ +#ifndef __REDISCLIENT_H__ +#define __REDISCLIENT_H__ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "swss/dbconnector.h" +#include "swss/redisreply.h" + +namespace swss +{ + +class RedisClient +{ + public: + + RedisClient(swss::DBConnector *db); + + int64_t del(std::string key); + + int64_t hdel(std::string key, std::string field); + + std::unordered_map hgetall(std::string key); + + std::vector keys(std::string key); + + std::vector hkeys(std::string key); + + void set(std::string key, std::string value); + + void hset(std::string key, std::string field, std::string value); + + void mset(std::unordered_map map); + + void hmset(std::string key, std::unordered_map map); + + std::shared_ptr get(std::string key); + + std::shared_ptr hget(std::string key, std::string field); + + std::vector> mget(std::vector keys); + + std::vector> hmget(std::string key, std::vector fields); + + int64_t incr(std::string key); + + int64_t decr(std::string key); + + int64_t rpush(std::string list, std::string item); + + std::shared_ptr blpop(std::string list, int timeout); + + private: + swss::DBConnector *m_db; +}; + +} + +#endif // __REDISCLIENT_H__ diff --git a/common/saiattributelist.cpp b/common/saiattributelist.cpp index e2a61a61b..4709ff814 100644 --- a/common/saiattributelist.cpp +++ b/common/saiattributelist.cpp @@ -12,8 +12,11 @@ SaiAttributeList::SaiAttributeList( const std::string &str_attr_id = fvField(values[i]); const std::string &str_attr_value = fvValue(values[i]); + if (str_attr_id == "NULL") + continue; + sai_attribute_t attr; - memset(&attr, 1, sizeof(sai_attribute_t)); + memset(&attr, 0, sizeof(sai_attribute_t)); int index = 0; sai_deserialize_primitive(str_attr_id, index, attr.id); diff --git a/common/saiattributelist.h b/common/saiattributelist.h index 4a25adcef..0f34fbbd6 100644 --- a/common/saiattributelist.h +++ b/common/saiattributelist.h @@ -7,6 +7,7 @@ #include #include "swss/dbconnector.h" #include "swss/table.h" +#include "swss/logger.h" #include "sai.h" #include "saiserialize.h" #include "string.h" diff --git a/common/saiserialize.cpp b/common/saiserialize.cpp index ab3e168b7..38690cf2b 100644 --- a/common/saiserialize.cpp +++ b/common/saiserialize.cpp @@ -5,6 +5,8 @@ sai_object_type_to_string_map_t g_object_type_map = sai_get_object_type_map(); sai_serialization_map_t sai_get_serialization_map() { + SWSS_LOG_ENTER(); + sai_serialization_map_t map; map[SAI_OBJECT_TYPE_ACL_TABLE][SAI_ACL_TABLE_ATTR_PRIORITY] = SAI_SERIALIZATION_TYPE_UINT32; @@ -27,7 +29,7 @@ sai_serialization_map_t sai_get_serialization_map() map[SAI_OBJECT_TYPE_ROUTER_INTERFACE][SAI_ROUTER_INTERFACE_ATTR_VIRTUAL_ROUTER_ID] = SAI_SERIALIZATION_TYPE_OBJECT_ID; map[SAI_OBJECT_TYPE_ROUTER_INTERFACE][SAI_ROUTER_INTERFACE_ATTR_TYPE] = SAI_SERIALIZATION_TYPE_INT32; map[SAI_OBJECT_TYPE_ROUTER_INTERFACE][SAI_ROUTER_INTERFACE_ATTR_SRC_MAC_ADDRESS] = SAI_SERIALIZATION_TYPE_MAC; - map[SAI_OBJECT_TYPE_ROUTER_INTERFACE][SAI_ROUTER_INTERFACE_ATTR_VLAN_ID] = SAI_SERIALIZATION_TYPE_MAC; + map[SAI_OBJECT_TYPE_ROUTER_INTERFACE][SAI_ROUTER_INTERFACE_ATTR_VLAN_ID] = SAI_SERIALIZATION_TYPE_UINT16; map[SAI_OBJECT_TYPE_HOST_INTERFACE][SAI_HOSTIF_ATTR_TYPE] = SAI_SERIALIZATION_TYPE_INT32; map[SAI_OBJECT_TYPE_HOST_INTERFACE][SAI_HOSTIF_ATTR_RIF_OR_PORT_ID] = SAI_SERIALIZATION_TYPE_OBJECT_ID; @@ -49,6 +51,7 @@ sai_serialization_map_t sai_get_serialization_map() map[SAI_OBJECT_TYPE_SWITCH][SAI_SWITCH_ATTR_DEFAULT_VIRTUAL_ROUTER_ID] = SAI_SERIALIZATION_TYPE_OBJECT_ID; map[SAI_OBJECT_TYPE_FDB][SAI_FDB_ENTRY_ATTR_TYPE] = SAI_SERIALIZATION_TYPE_INT32; + map[SAI_OBJECT_TYPE_FDB][SAI_FDB_ENTRY_ATTR_PORT_ID] = SAI_SERIALIZATION_TYPE_OBJECT_ID; map[SAI_OBJECT_TYPE_VLAN][SAI_VLAN_ATTR_MAX_LEARNED_ADDRESSES] = SAI_SERIALIZATION_TYPE_UINT32; @@ -62,6 +65,8 @@ sai_serialization_map_t sai_get_serialization_map() sai_object_type_to_string_map_t sai_get_object_type_map() { + SWSS_LOG_ENTER(); + sai_object_type_to_string_map_t map; map[SAI_OBJECT_TYPE_NULL] = TO_STR(SAI_OBJECT_TYPE_NULL); @@ -111,7 +116,8 @@ sai_status_t sai_get_object_type_string(sai_object_type_t object_type, std::stri if (it == g_object_type_map.end()) { - fprintf(stderr, "serialization object not found type not found"); + SWSS_LOG_ERROR("serialization object not found %x", object_type); + return SAI_STATUS_NOT_IMPLEMENTED; } @@ -129,7 +135,8 @@ sai_status_t sai_get_serialization_type( if (it == g_serialization_map.end()) { - fprintf(stderr, "serialization object not found type not found"); + SWSS_LOG_ERROR("serialization object not found %x", object_type); + return SAI_STATUS_NOT_IMPLEMENTED; } @@ -139,7 +146,8 @@ sai_status_t sai_get_serialization_type( if (mit == map.end()) { - fprintf(stderr, "serialization attribute not found"); + SWSS_LOG_ERROR("serialization attribute id not found %u", attr_id); + return SAI_STATUS_NOT_IMPLEMENTED; } @@ -263,7 +271,7 @@ sai_status_t sai_serialize_attr_value( break; case SAI_SERIALIZATION_TYPE_IP_ADDRESS: - sai_serialize_primitive(attr.value.ipaddr, s); + sai_serialize_ip_address(attr.value.ipaddr, s); break; case SAI_SERIALIZATION_TYPE_OBJECT_ID: @@ -482,10 +490,9 @@ int char_to_int( if (c >= 'a' && c <= 'f') return c - 'a' + 10; - std::stringstream ss; - ss << "Unable to convert char '" << c << "' (" << (int)c << ") to int"; + SWSS_LOG_ERROR("Unable to convert char %d to int", c); - throw ss.str(); + exit(EXIT_FAILURE); } sai_status_t sai_deserialize_attr_value( @@ -550,7 +557,7 @@ sai_status_t sai_deserialize_attr_value( break; case SAI_SERIALIZATION_TYPE_IP_ADDRESS: - sai_deserialize_primitive(s, index, attr.value.ipaddr); + sai_deserialize_ip_address(s, index, attr.value.ipaddr); break; case SAI_SERIALIZATION_TYPE_OBJECT_ID: @@ -937,7 +944,7 @@ sai_status_t sai_serialize_fdb_event_notification_data( _In_ sai_fdb_event_notification_data_t *fdb, _Out_ std::string &s) { - SERIALIZE_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_serialize_primitive(fdb->event_type, s); sai_serialize_primitive(fdb->fdb_entry, s); @@ -947,36 +954,34 @@ sai_status_t sai_serialize_fdb_event_notification_data( { const sai_attribute_t *attr = &fdb->attr[i]; + sai_serialize_primitive(attr->id, s); + sai_attr_serialization_type_t serialization_type; sai_status_t status = sai_get_serialization_type(SAI_OBJECT_TYPE_FDB, attr->id, serialization_type); if (status != SAI_STATUS_SUCCESS) { - SERIALIZE_LOG_ERR("Unable to find serialization type for object type: %u and attribute id: %u, status: %u", + SWSS_LOG_ERROR("Unable to find serialization type for object type: %x and attribute id: %u, status: %u", SAI_OBJECT_TYPE_FDB, attr->id, status); - SERIALIZE_LOG_EXIT(); - return status; + exit(EXIT_FAILURE); } status = sai_serialize_attr_value(serialization_type, *attr, s, false); if (status != SAI_STATUS_SUCCESS) { - SERIALIZE_LOG_ERR("Unable to serialize attribute for object type: %u and attribute id: %u, status: %u", + SWSS_LOG_ERROR("Unable to serialize attribute for object type: %x and attribute id: %u, status: %u", SAI_OBJECT_TYPE_FDB, attr->id, status); - SERIALIZE_LOG_EXIT(); - return status; + exit(EXIT_FAILURE); } } - SERIALIZE_LOG_EXIT(); - return SAI_STATUS_SUCCESS; } @@ -985,6 +990,8 @@ sai_status_t sai_deserialize_fdb_event_notification_data( _In_ int index, _Out_ sai_fdb_event_notification_data_t *fdb) { + SWSS_LOG_ENTER(); + sai_deserialize_primitive(s, index, fdb->event_type); sai_deserialize_primitive(s, index, fdb->fdb_entry); sai_deserialize_primitive(s, index, fdb->attr_count); @@ -995,17 +1002,18 @@ sai_status_t sai_deserialize_fdb_event_notification_data( { sai_attribute_t *attr = &fdb->attr[i]; + sai_deserialize_primitive(s, index, attr->id); + sai_attr_serialization_type_t serialization_type; sai_status_t status = sai_get_serialization_type(SAI_OBJECT_TYPE_FDB, attr->id, serialization_type); if (status != SAI_STATUS_SUCCESS) { - SERIALIZE_LOG_ERR("Unable to find serialization type for object type: %u and attribute id: %u, status: %u", + SWSS_LOG_ERROR("Unable to find serialization type for object type: %x and attribute id: %u, status: %u", SAI_OBJECT_TYPE_FDB, attr->id, status); - SERIALIZE_LOG_EXIT(); return status; } @@ -1013,12 +1021,11 @@ sai_status_t sai_deserialize_fdb_event_notification_data( if (status != SAI_STATUS_SUCCESS) { - SERIALIZE_LOG_ERR("Unable to deserialize attribute for object type: %u and attribute id: %u, status: %u", + SWSS_LOG_ERROR("Unable to deserialize attribute for object type: %x and attribute id: %u, status: %u", SAI_OBJECT_TYPE_FDB, attr->id, status); - SERIALIZE_LOG_EXIT(); return status; } } @@ -1029,7 +1036,7 @@ sai_status_t sai_deserialize_fdb_event_notification_data( sai_status_t sai_deserialize_free_fdb_event_notification_data( _In_ sai_fdb_event_notification_data_t *fdb) { - SERIALIZE_LOG_ENTER(); + SWSS_LOG_ENTER(); // NOTE: on any failure we have memory leak since we don't // know which serialization type was used, we dont know what @@ -1044,12 +1051,11 @@ sai_status_t sai_deserialize_free_fdb_event_notification_data( if (status != SAI_STATUS_SUCCESS) { - SERIALIZE_LOG_ERR("Unable to find serialization type for object type: %u and attribute id: %u, status: %u", + SWSS_LOG_ERROR("Unable to find serialization type for object type: %x and attribute id: %u, status: %u", SAI_OBJECT_TYPE_FDB, attr->id, status); - SERIALIZE_LOG_EXIT(); return status; } @@ -1057,20 +1063,17 @@ sai_status_t sai_deserialize_free_fdb_event_notification_data( if (status != SAI_STATUS_SUCCESS) { - SERIALIZE_LOG_ERR("Unable to free attribute for object type: %u and attribute id: %u, status: %u", + SWSS_LOG_ERROR("Unable to free attribute for object type: %x and attribute id: %u, status: %u", SAI_OBJECT_TYPE_FDB, attr->id, status); - SERIALIZE_LOG_EXIT(); return status; } } sai_dealloc_array(fdb->attr); - SERIALIZE_LOG_EXIT(); - return SAI_STATUS_SUCCESS; } @@ -1347,8 +1350,119 @@ void transfer_attributes( sai_status_t status = sai_get_serialization_type(object_type, src_attr.id, serialization_type); if (status != SAI_STATUS_SUCCESS) - throw std::runtime_error("unable to find serialization type"); + { + SWSS_LOG_ERROR("Unable to find serialization type object type: %x and attribute id: %u, status: %u", + SAI_OBJECT_TYPE_FDB, + src_attr.id, + status); + + exit(EXIT_FAILURE); + } transfer_attribute(serialization_type, src_attr, dst_attr, countOnly); } } + +void sai_serialize_ip_address( + _In_ const sai_ip_address_t &ip_address, + _Out_ std::string &s) +{ + sai_serialize_primitive(ip_address.addr_family, s); + + if (ip_address.addr_family == SAI_IP_ADDR_FAMILY_IPV4) + sai_serialize_primitive(ip_address.addr.ip4, s); + + if (ip_address.addr_family == SAI_IP_ADDR_FAMILY_IPV6) + sai_serialize_primitive(ip_address.addr.ip6, s); +} + +void sai_serialize_neighbor_entry( + _In_ const sai_neighbor_entry_t &ne, + _Out_ std::string &s) +{ + sai_serialize_primitive(ne.rif_id, s); + + sai_serialize_ip_address(ne.ip_address, s); +} + +void sai_deserialize_ip_address( + _In_ const std::string & s, + _In_ int &index, + _Out_ sai_ip_address_t &ip_address) +{ + sai_deserialize_primitive(s, index, ip_address.addr_family); + + if (ip_address.addr_family == SAI_IP_ADDR_FAMILY_IPV4) + sai_deserialize_primitive(s, index, ip_address.addr.ip4); + + if (ip_address.addr_family == SAI_IP_ADDR_FAMILY_IPV6) + sai_deserialize_primitive(s, index, ip_address.addr.ip6); +} + +void sai_deserialize_neighbor_entry( + _In_ const std::string & s, + _In_ int &index, + _Out_ sai_neighbor_entry_t &ne) +{ + sai_deserialize_primitive(s, index, ne.rif_id); + + sai_deserialize_ip_address(s, index, ne.ip_address); +} + +void sai_serialize_ip_prefix( + _In_ const sai_ip_prefix_t &ip_prefix, + _Out_ std::string &s) +{ + sai_serialize_primitive(ip_prefix.addr_family, s); + + if (ip_prefix.addr_family == SAI_IP_ADDR_FAMILY_IPV4) + { + sai_serialize_primitive(ip_prefix.addr.ip4, s); + sai_serialize_primitive(ip_prefix.mask.ip4, s); + } + + if (ip_prefix.addr_family == SAI_IP_ADDR_FAMILY_IPV6) + { + sai_serialize_primitive(ip_prefix.addr.ip6, s); + sai_serialize_primitive(ip_prefix.mask.ip6, s); + } +} + +void sai_serialize_route_entry( + _In_ const sai_unicast_route_entry_t &re, + _Out_ std::string &s) +{ + sai_serialize_primitive(re.vr_id, s); + + sai_serialize_ip_prefix(re.destination, s); +} + +void sai_deserialize_ip_prefix( + _In_ const std::string & s, + _In_ int &index, + _Out_ sai_ip_prefix_t &ip_prefix) +{ + sai_deserialize_primitive(s, index, ip_prefix.addr_family); + + if (ip_prefix.addr_family == SAI_IP_ADDR_FAMILY_IPV4) + { + sai_deserialize_primitive(s, index, ip_prefix.addr.ip4); + sai_deserialize_primitive(s, index, ip_prefix.mask.ip4); + } + + if (ip_prefix.addr_family == SAI_IP_ADDR_FAMILY_IPV6) + { + sai_deserialize_primitive(s, index, ip_prefix.addr.ip6); + sai_deserialize_primitive(s, index, ip_prefix.mask.ip6); + } +} + +void sai_deserialize_route_entry( + _In_ const std::string & s, + _In_ int &index, + _Out_ sai_unicast_route_entry_t &re) +{ + sai_deserialize_primitive(s, index, re.vr_id); + + sai_deserialize_ip_prefix(s, index, re.destination); +} diff --git a/common/saiserialize.h b/common/saiserialize.h index 3950baec6..06f44e122 100644 --- a/common/saiserialize.h +++ b/common/saiserialize.h @@ -12,22 +12,10 @@ #include #include #include +#include "swss/logger.h" #define TO_STR(x) #x -#define SERIALIZE_LOG(level, fmt, arg ...) {\ - fprintf(stderr, "%d: ", level); \ - fprintf(stderr, fmt, ##arg); \ - fprintf(stderr, "\n"); } - -#define SERIALIZE_LOG_ENTER() SERIALIZE_LOG(SAI_LOG_DEBUG, "%s: >", __FUNCTION__) -#define SERIALIZE_LOG_EXIT() SERIALIZE_LOG(SAI_LOG_DEBUG, "%s: <", __FUNCTION__) -#define SERIALIZE_LOG_DBG(fmt, arg ...) SERIALIZE_LOG(SAI_LOG_DEBUG, fmt, ##arg) -#define SERIALIZE_LOG_INF(fmt, arg ...) SERIALIZE_LOG(SAI_LOG_INFO, fmt, ##arg) -#define SERIALIZE_LOG_WRN(fmt, arg ...) SERIALIZE_LOG(SAI_LOG_WARN, fmt, ##arg) -#define SERIALIZE_LOG_ERR(fmt, arg ...) SERIALIZE_LOG(SAI_LOG_ERROR, fmt, ##arg) -#define SERIALIZE_LOG_NTC(fmt, arg ...) SERIALIZE_LOG(SAI_LOG_NOTICE, fmt, ##arg) - typedef enum _sai_attr_serialization_type_t { SAI_SERIALIZATION_TYPE_BOOL, @@ -252,6 +240,42 @@ void transfer_list( } } +void sai_serialize_ip_address( + _In_ const sai_ip_address_t &ip_address, + _Out_ std::string &s); + +void sai_deserialize_ip_address( + _In_ const std::string & s, + _In_ int &index, + _Out_ sai_ip_address_t &ip_address); + +void sai_serialize_ip_prefix( + _In_ const sai_ip_prefix_t &ip_prefix, + _Out_ std::string &s); + +void sai_deserialize_ip_prefix( + _In_ const std::string & s, + _In_ int &index, + _Out_ sai_ip_prefix_t &ip_prefix); + +void sai_serialize_neighbor_entry( + _In_ const sai_neighbor_entry_t &ne, + _Out_ std::string &s); + +void sai_deserialize_neighbor_entry( + _In_ const std::string & s, + _In_ int &index, + _Out_ sai_neighbor_entry_t &ne); + +void sai_serialize_route_entry( + _In_ const sai_unicast_route_entry_t &ne, + _Out_ std::string &s); + +void sai_deserialize_route_entry( + _In_ const std::string & s, + _In_ int &index, + _Out_ sai_unicast_route_entry_t &ne); + sai_status_t sai_deserialize_attr_value( _In_ const std::string &s, _In_ int &index, diff --git a/lib/inc/sai_redis.h b/lib/inc/sai_redis.h index 3e396cfaa..76b299708 100644 --- a/lib/inc/sai_redis.h +++ b/lib/inc/sai_redis.h @@ -9,6 +9,7 @@ extern "C" { } #include "saiserialize.h" #include "saiattributelist.h" +#include "redisclient.h" #include "swss/dbconnector.h" #include "swss/producertable.h" @@ -29,6 +30,8 @@ extern swss::ConsumerTable *g_redisNotifications; extern swss::Table *g_vidToRid; extern swss::Table *g_ridToVid; +extern swss::RedisClient *g_redisClient; + extern const sai_acl_api_t redis_acl_api; extern const sai_buffer_api_t redis_buffer_api; extern const sai_fdb_api_t redis_fdb_api; @@ -59,15 +62,6 @@ extern sai_switch_notification_t redis_switch_notifications; #define UNREFERENCED_PARAMETER(X) -#define REDIS_LOG_ERR(MSG, ...) swss::Logger::getInstance().write(swss::Logger::SWSS_ERROR, MSG, ##__VA_ARGS__) -#define REDIS_LOG_WRN(MSG, ...) swss::Logger::getInstance().write(swss::Logger::SWSS_WARN, MSG, ##__VA_ARGS__) -#define REDIS_LOG_NTC(MSG, ...) swss::Logger::getInstance().write(swss::Logger::SWSS_NOTICE, MSG, ##__VA_ARGS__) -#define REDIS_LOG_INF(MSG, ...) swss::Logger::getInstance().write(swss::Logger::SWSS_INFO, MSG, ##__VA_ARGS__) -#define REDIS_LOG_DBG(MSG, ...) swss::Logger::getInstance().write(swss::Logger::SWSS_DEBUG, MSG, ##__VA_ARGS__) - -#define REDIS_LOG_ENTER() swss::Logger::getInstance().write(swss::Logger::SWSS_DEBUG, "%s>", __FUNCTION__) -#define REDIS_LOG_EXIT() swss::Logger::getInstance().write(swss::Logger::SWSS_DEBUG, "%s<", __FUNCTION__) - sai_object_id_t redis_create_virtual_object_id( _In_ sai_object_type_t object_type); diff --git a/lib/src/Makefile.am b/lib/src/Makefile.am index 7bc19dcad..4aea333ce 100644 --- a/lib/src/Makefile.am +++ b/lib/src/Makefile.am @@ -43,6 +43,7 @@ libsairedis_la_SOURCES = sai_redis_acl.cpp \ sai_redis_generic_set.cpp \ sai_redis_generic_get.cpp \ sai_redis_notifications.cpp \ + ../../common/redisclient.cpp \ ../../common/saiserialize.cpp \ ../../common/saiattributelist.cpp diff --git a/lib/src/sai_redis_acl.cpp b/lib/src/sai_redis_acl.cpp index 09bc62a70..2c31fa8b2 100644 --- a/lib/src/sai_redis_acl.cpp +++ b/lib/src/sai_redis_acl.cpp @@ -18,7 +18,7 @@ sai_status_t redis_create_acl_table( _In_ uint32_t attr_count, _In_ const sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_create( SAI_OBJECT_TYPE_ACL_TABLE, @@ -26,8 +26,6 @@ sai_status_t redis_create_acl_table( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -45,14 +43,12 @@ sai_status_t redis_create_acl_table( sai_status_t redis_delete_acl_table( _In_ sai_object_id_t acl_table_id) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_remove( SAI_OBJECT_TYPE_ACL_TABLE, acl_table_id); - REDIS_LOG_EXIT(); - return status; } @@ -72,15 +68,13 @@ sai_status_t redis_set_acl_table_attribute( _In_ sai_object_id_t acl_table_id, _In_ const sai_attribute_t *attr) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_set( SAI_OBJECT_TYPE_ACL_TABLE, acl_table_id, attr); - REDIS_LOG_EXIT(); - return status; } @@ -102,7 +96,7 @@ sai_status_t redis_get_acl_table_attribute( _In_ uint32_t attr_count, _Out_ sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_get( SAI_OBJECT_TYPE_ACL_TABLE, @@ -110,8 +104,6 @@ sai_status_t redis_get_acl_table_attribute( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -133,7 +125,7 @@ sai_status_t redis_create_acl_entry( _In_ uint32_t attr_count, _In_ const sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_create( SAI_OBJECT_TYPE_ACL_ENTRY, @@ -141,8 +133,6 @@ sai_status_t redis_create_acl_entry( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -160,14 +150,12 @@ sai_status_t redis_create_acl_entry( sai_status_t redis_delete_acl_entry( _In_ sai_object_id_t acl_entry_id) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_remove( SAI_OBJECT_TYPE_ACL_ENTRY, acl_entry_id); - REDIS_LOG_EXIT(); - return status; } @@ -187,15 +175,13 @@ sai_status_t redis_set_acl_entry_attribute( _In_ sai_object_id_t acl_entry_id, _In_ const sai_attribute_t *attr) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_set( SAI_OBJECT_TYPE_ACL_ENTRY, acl_entry_id, attr); - REDIS_LOG_EXIT(); - return status; } @@ -217,7 +203,7 @@ sai_status_t redis_get_acl_entry_attribute( _In_ uint32_t attr_count, _Out_ sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_get( SAI_OBJECT_TYPE_ACL_ENTRY, @@ -225,8 +211,6 @@ sai_status_t redis_get_acl_entry_attribute( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -248,7 +232,7 @@ sai_status_t redis_create_acl_counter( _In_ uint32_t attr_count, _In_ const sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_create( SAI_OBJECT_TYPE_ACL_COUNTER, @@ -256,8 +240,6 @@ sai_status_t redis_create_acl_counter( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -275,14 +257,12 @@ sai_status_t redis_create_acl_counter( sai_status_t redis_delete_acl_counter( _In_ sai_object_id_t acl_counter_id) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_remove( SAI_OBJECT_TYPE_ACL_COUNTER, acl_counter_id); - REDIS_LOG_EXIT(); - return status; } @@ -302,15 +282,13 @@ sai_status_t redis_set_acl_counter_attribute( _In_ sai_object_id_t acl_counter_id, _In_ const sai_attribute_t *attr) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_set( SAI_OBJECT_TYPE_ACL_COUNTER, acl_counter_id, attr); - REDIS_LOG_EXIT(); - return status; } @@ -332,7 +310,7 @@ sai_status_t redis_get_acl_counter_attribute( _In_ uint32_t attr_count, _Out_ sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_get( SAI_OBJECT_TYPE_ACL_COUNTER, @@ -340,8 +318,6 @@ sai_status_t redis_get_acl_counter_attribute( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } diff --git a/lib/src/sai_redis_buffer.cpp b/lib/src/sai_redis_buffer.cpp index 46bc64cef..747fb285e 100644 --- a/lib/src/sai_redis_buffer.cpp +++ b/lib/src/sai_redis_buffer.cpp @@ -12,15 +12,13 @@ sai_status_t redis_set_ingress_priority_group_attr( _In_ sai_object_id_t ingress_pg_id, _In_ const sai_attribute_t *attr) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_set( SAI_OBJECT_TYPE_PRIORITY_GROUP, ingress_pg_id, attr); - REDIS_LOG_EXIT(); - return status; } @@ -38,7 +36,7 @@ sai_status_t redis_get_ingress_priority_group_attr( _In_ uint32_t attr_count, _Inout_ sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_get( SAI_OBJECT_TYPE_PRIORITY_GROUP, @@ -46,8 +44,6 @@ sai_status_t redis_get_ingress_priority_group_attr( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -68,9 +64,7 @@ sai_status_t redis_get_ingress_priority_group_stats( _In_ uint32_t number_of_counters, _Out_ uint64_t* counters) { - REDIS_LOG_ENTER(); - - REDIS_LOG_EXIT(); + SWSS_LOG_ENTER(); return SAI_STATUS_NOT_IMPLEMENTED; } @@ -90,9 +84,7 @@ sai_status_t redis_clear_ingress_priority_group_stats( _In_ const sai_ingress_priority_group_stat_counter_t *counter_ids, _In_ uint32_t number_of_counters) { - REDIS_LOG_ENTER(); - - REDIS_LOG_EXIT(); + SWSS_LOG_ENTER(); return SAI_STATUS_NOT_IMPLEMENTED; } @@ -110,7 +102,7 @@ sai_status_t redis_create_buffer_pool( _In_ uint32_t attr_count, _In_ const sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_create( SAI_OBJECT_TYPE_BUFFER_POOL, @@ -118,8 +110,6 @@ sai_status_t redis_create_buffer_pool( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -132,14 +122,12 @@ sai_status_t redis_create_buffer_pool( sai_status_t redis_remove_buffer_pool( _In_ sai_object_id_t pool_id) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_remove( SAI_OBJECT_TYPE_BUFFER_POOL, pool_id); - REDIS_LOG_EXIT(); - return status; } @@ -154,15 +142,13 @@ sai_status_t redis_set_buffer_pool_attr( _In_ sai_object_id_t pool_id, _In_ const sai_attribute_t *attr) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_set( SAI_OBJECT_TYPE_BUFFER_POOL, pool_id, attr); - REDIS_LOG_EXIT(); - return status; } @@ -179,7 +165,7 @@ sai_status_t redis_get_buffer_pool_attr( _In_ uint32_t attr_count, _Inout_ sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_get( SAI_OBJECT_TYPE_BUFFER_POOL, @@ -187,8 +173,6 @@ sai_status_t redis_get_buffer_pool_attr( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -209,9 +193,7 @@ sai_status_t redis_get_buffer_pool_stats( _In_ uint32_t number_of_counters, _Out_ uint64_t* counters) { - REDIS_LOG_ENTER(); - - REDIS_LOG_EXIT(); + SWSS_LOG_ENTER(); return SAI_STATUS_NOT_IMPLEMENTED; } @@ -229,7 +211,7 @@ sai_status_t redis_create_buffer_profile( _In_ uint32_t attr_count, _In_ const sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_create( SAI_OBJECT_TYPE_BUFFER_PROFILE, @@ -237,8 +219,6 @@ sai_status_t redis_create_buffer_profile( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -251,14 +231,12 @@ sai_status_t redis_create_buffer_profile( sai_status_t redis_remove_buffer_profile( _In_ sai_object_id_t buffer_profile_id) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_remove( SAI_OBJECT_TYPE_BUFFER_PROFILE, buffer_profile_id); - REDIS_LOG_EXIT(); - return status; } @@ -273,15 +251,13 @@ sai_status_t redis_set_buffer_profile_attr( _In_ sai_object_id_t buffer_profile_id, _In_ const sai_attribute_t *attr) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_set( SAI_OBJECT_TYPE_BUFFER_PROFILE, buffer_profile_id, attr); - REDIS_LOG_EXIT(); - return status; } @@ -298,7 +274,7 @@ sai_status_t redis_get_buffer_profile_attr( _In_ uint32_t attr_count, _Inout_ sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_get( SAI_OBJECT_TYPE_BUFFER_PROFILE, @@ -306,8 +282,6 @@ sai_status_t redis_get_buffer_profile_attr( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } diff --git a/lib/src/sai_redis_fdb.cpp b/lib/src/sai_redis_fdb.cpp index 5bc90530c..38d21ff23 100644 --- a/lib/src/sai_redis_fdb.cpp +++ b/lib/src/sai_redis_fdb.cpp @@ -18,7 +18,7 @@ sai_status_t redis_create_fdb_entry( _In_ uint32_t attr_count, _In_ const sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_create( SAI_OBJECT_TYPE_FDB, @@ -26,8 +26,6 @@ sai_status_t redis_create_fdb_entry( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -45,14 +43,12 @@ sai_status_t redis_create_fdb_entry( sai_status_t redis_remove_fdb_entry( _In_ const sai_fdb_entry_t* fdb_entry) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_remove( SAI_OBJECT_TYPE_FDB, fdb_entry); - REDIS_LOG_EXIT(); - return status; } @@ -70,15 +66,13 @@ sai_status_t redis_set_fdb_entry_attribute( _In_ const sai_fdb_entry_t* fdb_entry, _In_ const sai_attribute_t *attr) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_set( SAI_OBJECT_TYPE_FDB, fdb_entry, attr); - REDIS_LOG_EXIT(); - return status; } @@ -100,7 +94,7 @@ sai_status_t redis_get_fdb_entry_attribute( _In_ uint32_t attr_count, _Inout_ sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_get( SAI_OBJECT_TYPE_FDB, @@ -108,8 +102,6 @@ sai_status_t redis_get_fdb_entry_attribute( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -129,9 +121,7 @@ sai_status_t redis_flush_fdb_entries( _In_ uint32_t attr_count, _In_ const sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); - - REDIS_LOG_EXIT(); + SWSS_LOG_ENTER(); return SAI_STATUS_NOT_IMPLEMENTED; } @@ -151,9 +141,7 @@ void redis_fdb_event_notification( _In_ uint32_t count, _In_ sai_fdb_event_notification_data_t *data) { - REDIS_LOG_ENTER(); - - REDIS_LOG_EXIT(); + SWSS_LOG_ENTER(); } /** diff --git a/lib/src/sai_redis_generic.cpp b/lib/src/sai_redis_generic.cpp deleted file mode 100644 index a77dbf4bc..000000000 --- a/lib/src/sai_redis_generic.cpp +++ /dev/null @@ -1,2 +0,0 @@ -#include "sai_redis.h" - diff --git a/lib/src/sai_redis_generic_create.cpp b/lib/src/sai_redis_generic_create.cpp index 23fd82dee..e4448bde9 100644 --- a/lib/src/sai_redis_generic_create.cpp +++ b/lib/src/sai_redis_generic_create.cpp @@ -1,10 +1,10 @@ #include "sai_redis.h" -uint64_t object_id_counter = 0; - sai_object_id_t redis_create_virtual_object_id( _In_ sai_object_type_t object_type) { + SWSS_LOG_ENTER(); + // when started, we need to get current status of // generated objects and pick up values from there // we should also keep mapping of those values in syncd @@ -16,12 +16,14 @@ sai_object_id_t redis_create_virtual_object_id( // in future we could change this to find "holes" after delted // objects, but can be tricky since this information would need // to be stored somewhere in case of oa restart - // - // TODO make this atomic - uint64_t virtual_id = object_id_counter++; + uint64_t virtual_id = g_redisClient->incr("VIDCOUNTER"); + + sai_object_id_t objectId = (((sai_object_id_t)object_type) << 48) | virtual_id; - return (((sai_object_id_t)object_type) << 48) | virtual_id; + SWSS_LOG_DEBUG("created VID %llx", objectId); + + return objectId; } /** @@ -43,7 +45,7 @@ sai_status_t internal_redis_generic_create( _In_ uint32_t attr_count, _In_ const sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); std::vector entry = SaiAttributeList::serialize_attr_list( object_type, @@ -51,15 +53,24 @@ sai_status_t internal_redis_generic_create( attr_list, false); + if (entry.size() == 0) + { + // make sure that we put object into db + // even if there are no attributes set + swss::FieldValueTuple null("NULL", "NULL"); + + entry.push_back(null); + } + std::string str_object_type; sai_serialize_primitive(object_type, str_object_type); std::string key = str_object_type + ":" + serialized_object_id; - g_asicState->set(key, entry, "create"); + SWSS_LOG_DEBUG("generic create key: %s, fields: %lu", key.c_str(), entry.size()); - REDIS_LOG_EXIT(); + g_asicState->set(key, entry, "create"); // we assume create will always succeed which may not be true // we should make this synchronous call @@ -85,7 +96,7 @@ sai_status_t redis_generic_create( _In_ uint32_t attr_count, _In_ const sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); // on create vid is put in db by syncd *object_id = redis_create_virtual_object_id(object_type); @@ -99,8 +110,6 @@ sai_status_t redis_generic_create( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -110,7 +119,7 @@ sai_status_t redis_generic_create( _In_ uint32_t attr_count, _In_ const sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); std::string str_fdb_entry; sai_serialize_primitive(*fdb_entry, str_fdb_entry); @@ -121,8 +130,6 @@ sai_status_t redis_generic_create( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -132,11 +139,11 @@ sai_status_t redis_generic_create( _In_ uint32_t attr_count, _In_ const sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); // rif_id must be valid virtual id std::string str_neighbor_entry; - sai_serialize_primitive(*neighbor_entry, str_neighbor_entry); + sai_serialize_neighbor_entry(*neighbor_entry, str_neighbor_entry); sai_status_t status = internal_redis_generic_create( object_type, @@ -144,8 +151,6 @@ sai_status_t redis_generic_create( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -155,11 +160,11 @@ sai_status_t redis_generic_create( _In_ uint32_t attr_count, _In_ const sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); // vr_id must be valid virtual router id std::string str_route_entry; - sai_serialize_primitive(*unicast_route_entry, str_route_entry); + sai_serialize_route_entry(*unicast_route_entry, str_route_entry); sai_status_t status = internal_redis_generic_create( object_type, @@ -167,8 +172,6 @@ sai_status_t redis_generic_create( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -176,7 +179,7 @@ sai_status_t redis_generic_create_vlan( _In_ sai_object_type_t object_type, _In_ sai_vlan_id_t vlan_id) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); std::string str_vlan_id; sai_serialize_primitive(vlan_id, str_vlan_id); @@ -191,7 +194,5 @@ sai_status_t redis_generic_create_vlan( 0, &dummy_attribute); - REDIS_LOG_EXIT(); - return status; } diff --git a/lib/src/sai_redis_generic_get.cpp b/lib/src/sai_redis_generic_get.cpp index a069f9134..ca451eec4 100644 --- a/lib/src/sai_redis_generic_get.cpp +++ b/lib/src/sai_redis_generic_get.cpp @@ -1,115 +1,12 @@ #include "sai_redis.h" -sai_object_id_t translate_rid_to_vid( - _In_ sai_object_type_t object_type, - _In_ sai_object_id_t rid) -{ - if (rid == SAI_NULL_OBJECT_ID) - return SAI_NULL_OBJECT_ID; - - // get from syncd should always return real id - sai_object_id_t vid; - - std::string str_rid; - std::string str_vid; - - sai_serialize_primitive(rid, str_rid); - - if (g_ridToVid->getField(std::string(), str_rid, str_vid)) - { - // object exists - - int index = 0; - sai_deserialize_primitive(str_vid, index, vid); - - return vid; - } - - REDIS_LOG_DBG("rid is missing from db"); - - vid = redis_create_virtual_object_id(object_type); - - sai_serialize_primitive(vid, str_vid); - - g_ridToVid->setField(std::string(), str_rid, str_vid); - g_vidToRid->setField(std::string(), str_vid, str_rid); - - return vid; -} - -template -void translate_list_rid_to_vid( - _In_ sai_object_type_t object_type, - _In_ T &element) -{ - for (uint32_t i = 0; i < element.count; i++) - { - element.list[i] = translate_rid_to_vid(object_type, element.list[i]); - } -} - -void translate_rid_to_vid( - _In_ sai_object_type_t object_type, - _In_ uint32_t attr_count, - _In_ sai_attribute_t *attr_list) -{ - // we receive real id's here, if they are new then create new id - // for them and put in db, if entry exists in db, use it - - for (uint32_t i = 0; i < attr_count; i++) - { - sai_attribute_t &attr = attr_list[i]; - - sai_attr_serialization_type_t serialization_type; - sai_status_t status = sai_get_serialization_type(object_type, attr.id, serialization_type); - - if (status != SAI_STATUS_SUCCESS) - { - throw std::runtime_error("unable to find serialization type"); - } - - switch (serialization_type) - { - case SAI_SERIALIZATION_TYPE_OBJECT_ID: - attr.value.oid = translate_rid_to_vid(object_type, attr.value.oid); - break; - - case SAI_SERIALIZATION_TYPE_OBJECT_LIST: - translate_list_rid_to_vid(object_type, attr.value.objlist); - break; - - case SAI_SERIALIZATION_TYPE_ACL_FIELD_DATA_OBJECT_ID: - attr.value.aclfield.data.oid = translate_rid_to_vid(object_type, attr.value.aclfield.data.oid); - break; - - case SAI_SERIALIZATION_TYPE_ACL_FIELD_DATA_OBJECT_LIST: - translate_list_rid_to_vid(object_type, attr.value.aclfield.data.objlist); - break; - - case SAI_SERIALIZATION_TYPE_ACL_ACTION_DATA_OBJECT_ID: - attr.value.aclaction.parameter.oid = translate_rid_to_vid(object_type, attr.value.aclaction.parameter.oid); - break; - - case SAI_SERIALIZATION_TYPE_ACL_ACTION_DATA_OBJECT_LIST: - translate_list_rid_to_vid(object_type, attr.value.aclaction.parameter.objlist); - break; - - case SAI_SERIALIZATION_TYPE_PORT_BREAKOUT: - translate_list_rid_to_vid(object_type, attr.value.portbreakout.port_list); - - default: - break; - } - } -} - sai_status_t internal_redis_get_process( _In_ sai_object_type_t object_type, _In_ uint32_t attr_count, _Out_ sai_attribute_t *attr_list, _In_ swss::KeyOpFieldsValuesTuple &kco) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); // key is: object_type:object_id:sai_status @@ -129,8 +26,6 @@ sai_status_t internal_redis_get_process( SaiAttributeList list(object_type, values, false); transfer_attributes(object_type, attr_count, list.get_attr_list(), attr_list, false); - - translate_rid_to_vid(object_type, attr_count, attr_list); } else if (status == SAI_STATUS_BUFFER_OVERFLOW) { @@ -140,8 +35,6 @@ sai_status_t internal_redis_get_process( transfer_attributes(object_type, attr_count, list.get_attr_list(), attr_list, true); } - REDIS_LOG_EXIT(); - return status; } @@ -164,7 +57,7 @@ sai_status_t internal_redis_generic_get( _In_ uint32_t attr_count, _Out_ sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); std::vector entry = SaiAttributeList::serialize_attr_list( object_type, @@ -178,6 +71,8 @@ sai_status_t internal_redis_generic_get( std::string key = str_object_type + ":" + serialized_object_id; + SWSS_LOG_DEBUG("generic get key: %s, fields: %lu", key.c_str(), entry.size()); + g_redisGetProducer->set(key, entry, "get"); g_redisGetProducer->del(key, "delget"); @@ -189,6 +84,8 @@ sai_status_t internal_redis_generic_get( while (true) { + SWSS_LOG_DEBUG("wait for response"); + swss::Selectable *sel; int fd; @@ -204,27 +101,27 @@ sai_status_t internal_redis_generic_get( const std::string &op = kfvOp(kco); const std::string &key = kfvKey(kco); - REDIS_LOG_DBG("op = %s, key = %s", op.c_str(), key.c_str()); + SWSS_LOG_DEBUG("response: %s op = %s, key = %s", key.c_str(), op.c_str()); if (op != "getresponse") // ignore non response messages continue; - sai_status_t sai_status = internal_redis_get_process( + sai_status_t status = internal_redis_get_process( object_type, attr_count, attr_list, kco); - REDIS_LOG_EXIT(); + SWSS_LOG_DEBUG("generic get status: %d", status); - return sai_status; + return status; } - REDIS_LOG_ERR("failed to get response for get status: %d", result); + SWSS_LOG_ERROR("generic get failed to get response result: %d", result); break; } - REDIS_LOG_EXIT(); + SWSS_LOG_ERROR("generic get failed to get response"); return SAI_STATUS_FAILURE; } @@ -249,7 +146,7 @@ sai_status_t redis_generic_get( _In_ uint32_t attr_count, _Out_ sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); std::string str_object_id; sai_serialize_primitive(object_id, str_object_id); @@ -260,8 +157,6 @@ sai_status_t redis_generic_get( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -271,7 +166,7 @@ sai_status_t redis_generic_get( _In_ uint32_t attr_count, _Out_ sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); std::string str_fdb_entry; sai_serialize_primitive(*fdb_entry, str_fdb_entry); @@ -282,8 +177,6 @@ sai_status_t redis_generic_get( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -293,10 +186,10 @@ sai_status_t redis_generic_get( _In_ uint32_t attr_count, _Out_ sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); std::string str_neighbor_entry; - sai_serialize_primitive(*neighbor_entry, str_neighbor_entry); + sai_serialize_neighbor_entry(*neighbor_entry, str_neighbor_entry); sai_status_t status = internal_redis_generic_get( object_type, @@ -304,8 +197,6 @@ sai_status_t redis_generic_get( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -315,10 +206,10 @@ sai_status_t redis_generic_get( _In_ uint32_t attr_count, _Out_ sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); std::string str_route_entry; - sai_serialize_primitive(*unicast_route_entry, str_route_entry); + sai_serialize_route_entry(*unicast_route_entry, str_route_entry); sai_status_t status = internal_redis_generic_get( object_type, @@ -326,8 +217,6 @@ sai_status_t redis_generic_get( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -337,7 +226,7 @@ sai_status_t redis_generic_get_vlan( _In_ uint32_t attr_count, _Out_ sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); std::string str_vlan_id; sai_serialize_primitive(vlan_id, str_vlan_id); @@ -348,7 +237,5 @@ sai_status_t redis_generic_get_vlan( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } diff --git a/lib/src/sai_redis_generic_remove.cpp b/lib/src/sai_redis_generic_remove.cpp index 5cec3a799..55ad745a8 100644 --- a/lib/src/sai_redis_generic_remove.cpp +++ b/lib/src/sai_redis_generic_remove.cpp @@ -4,7 +4,7 @@ sai_status_t internal_redis_generic_remove( _In_ sai_object_type_t object_type, _In_ const std::string &serialized_object_id) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); std::string str_object_type; @@ -12,9 +12,9 @@ sai_status_t internal_redis_generic_remove( std::string key = str_object_type + ":" + serialized_object_id; - g_asicState->del(key, "remove"); + SWSS_LOG_DEBUG("generic remove key: %s", key.c_str()); - REDIS_LOG_EXIT(); + g_asicState->del(key, "remove"); return SAI_STATUS_SUCCESS; } @@ -35,7 +35,7 @@ sai_status_t redis_generic_remove( _In_ sai_object_type_t object_type, _In_ sai_object_id_t object_id) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); std::string str_object_id; sai_serialize_primitive(object_id, str_object_id); @@ -44,8 +44,6 @@ sai_status_t redis_generic_remove( object_type, str_object_id); - REDIS_LOG_EXIT(); - return status; } @@ -53,7 +51,7 @@ sai_status_t redis_generic_remove( _In_ sai_object_type_t object_type, _In_ const sai_fdb_entry_t* fdb_entry) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); std::string str_fdb_entry; sai_serialize_primitive(*fdb_entry, str_fdb_entry); @@ -62,8 +60,6 @@ sai_status_t redis_generic_remove( object_type, str_fdb_entry); - REDIS_LOG_EXIT(); - return status; } @@ -71,18 +67,16 @@ sai_status_t redis_generic_remove( _In_ sai_object_type_t object_type, _In_ const sai_neighbor_entry_t* neighbor_entry) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); // rif_id must be valid virtual id std::string str_neighbor_entry; - sai_serialize_primitive(*neighbor_entry, str_neighbor_entry); + sai_serialize_neighbor_entry(*neighbor_entry, str_neighbor_entry); sai_status_t status = internal_redis_generic_remove( object_type, str_neighbor_entry); - REDIS_LOG_EXIT(); - return status; } @@ -90,18 +84,16 @@ sai_status_t redis_generic_remove( _In_ sai_object_type_t object_type, _In_ const sai_unicast_route_entry_t* unicast_route_entry) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); // vr_id must be valid virtual router id std::string str_route_entry; - sai_serialize_primitive(*unicast_route_entry, str_route_entry); + sai_serialize_route_entry(*unicast_route_entry, str_route_entry); sai_status_t status = internal_redis_generic_remove( object_type, str_route_entry); - REDIS_LOG_EXIT(); - return status; } @@ -109,7 +101,7 @@ sai_status_t redis_generic_remove_vlan( _In_ sai_object_type_t object_type, _In_ sai_vlan_id_t vlan_id) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); std::string str_vlan_id; sai_serialize_primitive(vlan_id, str_vlan_id); @@ -118,7 +110,5 @@ sai_status_t redis_generic_remove_vlan( object_type, str_vlan_id); - REDIS_LOG_EXIT(); - return status; } diff --git a/lib/src/sai_redis_generic_set.cpp b/lib/src/sai_redis_generic_set.cpp index ccc784a2d..69c0163ae 100644 --- a/lib/src/sai_redis_generic_set.cpp +++ b/lib/src/sai_redis_generic_set.cpp @@ -18,7 +18,7 @@ sai_status_t internal_redis_generic_set( _In_ const std::string &serialized_object_id, _In_ const sai_attribute_t *attr) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); std::vector entry = SaiAttributeList::serialize_attr_list( object_type, @@ -32,9 +32,9 @@ sai_status_t internal_redis_generic_set( std::string key = str_object_type + ":" + serialized_object_id; - g_asicState->set(key, entry, "set"); + SWSS_LOG_DEBUG("generic set key: %s, fields: %lu", key.c_str(), entry.size()); - REDIS_LOG_EXIT(); + g_asicState->set(key, entry, "set"); return SAI_STATUS_SUCCESS; } @@ -44,7 +44,7 @@ sai_status_t redis_generic_set( _In_ sai_object_id_t object_id, _In_ const sai_attribute_t *attr) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); std::string str_object_id; sai_serialize_primitive(object_id, str_object_id); @@ -54,8 +54,6 @@ sai_status_t redis_generic_set( str_object_id, attr); - REDIS_LOG_EXIT(); - return status; } @@ -64,7 +62,7 @@ sai_status_t redis_generic_set( _In_ const sai_fdb_entry_t *fdb_entry, _In_ const sai_attribute_t *attr) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); std::string str_fdb_entry; sai_serialize_primitive(*fdb_entry, str_fdb_entry); @@ -74,8 +72,6 @@ sai_status_t redis_generic_set( str_fdb_entry, attr); - REDIS_LOG_EXIT(); - return status; } @@ -84,18 +80,16 @@ sai_status_t redis_generic_set( _In_ const sai_neighbor_entry_t* neighbor_entry, _In_ const sai_attribute_t *attr) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); std::string str_neighbor_entry; - sai_serialize_primitive(*neighbor_entry, str_neighbor_entry); + sai_serialize_neighbor_entry(*neighbor_entry, str_neighbor_entry); sai_status_t status = internal_redis_generic_set( object_type, str_neighbor_entry, attr); - REDIS_LOG_EXIT(); - return status; } @@ -104,18 +98,16 @@ sai_status_t redis_generic_set( _In_ const sai_unicast_route_entry_t* unicast_route_entry, _In_ const sai_attribute_t *attr) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); std::string str_route_entry; - sai_serialize_primitive(*unicast_route_entry, str_route_entry); + sai_serialize_route_entry(*unicast_route_entry, str_route_entry); sai_status_t status = internal_redis_generic_set( object_type, str_route_entry, attr); - REDIS_LOG_EXIT(); - return status; } @@ -124,7 +116,7 @@ sai_status_t redis_generic_set_vlan( _In_ sai_vlan_id_t vlan_id, _In_ const sai_attribute_t *attr) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); std::string str_vlan_id; sai_serialize_primitive(vlan_id, str_vlan_id); @@ -134,7 +126,5 @@ sai_status_t redis_generic_set_vlan( str_vlan_id, attr); - REDIS_LOG_EXIT(); - return status; } diff --git a/lib/src/sai_redis_hash.cpp b/lib/src/sai_redis_hash.cpp index 81ef4cce1..315a615ab 100644 --- a/lib/src/sai_redis_hash.cpp +++ b/lib/src/sai_redis_hash.cpp @@ -19,7 +19,7 @@ sai_status_t redis_create_hash( _In_ uint32_t attr_count, _In_ const sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_create( SAI_OBJECT_TYPE_HASH, @@ -27,8 +27,6 @@ sai_status_t redis_create_hash( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -46,14 +44,12 @@ sai_status_t redis_create_hash( sai_status_t redis_remove_hash( _In_ sai_object_id_t hash_id) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_remove( SAI_OBJECT_TYPE_HASH, hash_id); - REDIS_LOG_EXIT(); - return status; } @@ -73,15 +69,13 @@ sai_status_t redis_set_hash_attribute( _In_ sai_object_id_t hash_id, _In_ const sai_attribute_t *attr) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_set( SAI_OBJECT_TYPE_HASH, hash_id, attr); - REDIS_LOG_EXIT(); - return status; } @@ -103,7 +97,7 @@ sai_status_t redis_get_hash_attribute( _In_ uint32_t attr_count, _Inout_ sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_get( SAI_OBJECT_TYPE_HASH, @@ -111,8 +105,6 @@ sai_status_t redis_get_hash_attribute( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } diff --git a/lib/src/sai_redis_hostintf.cpp b/lib/src/sai_redis_hostintf.cpp index dffc429bb..26c205b83 100644 --- a/lib/src/sai_redis_hostintf.cpp +++ b/lib/src/sai_redis_hostintf.cpp @@ -26,9 +26,7 @@ sai_status_t redis_recv_packet( _Inout_ uint32_t *attr_count, _Out_ sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); - - REDIS_LOG_EXIT(); + SWSS_LOG_ENTER(); return SAI_STATUS_NOT_IMPLEMENTED; } @@ -55,9 +53,7 @@ sai_status_t redis_send_packet( _In_ uint32_t attr_count, _In_ sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); - - REDIS_LOG_EXIT(); + SWSS_LOG_ENTER(); return SAI_STATUS_NOT_IMPLEMENTED; } @@ -78,15 +74,13 @@ sai_status_t redis_set_user_defined_trap_attribute( _In_ sai_hostif_user_defined_trap_id_t hostif_user_defined_trapid, _In_ const sai_attribute_t *attr) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_set( SAI_OBJECT_TYPE_TRAP_USER_DEF, hostif_user_defined_trapid, attr); - REDIS_LOG_EXIT(); - return status; } @@ -108,7 +102,7 @@ sai_status_t redis_get_user_defined_trap_attribute( _In_ uint32_t attr_count, _Inout_ sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_get( SAI_OBJECT_TYPE_TRAP_USER_DEF, @@ -116,8 +110,6 @@ sai_status_t redis_get_user_defined_trap_attribute( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -139,7 +131,7 @@ sai_status_t redis_create_hostif_trap_group( _In_ uint32_t attr_count, _In_ const sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_create( SAI_OBJECT_TYPE_TRAP_GROUP, @@ -147,8 +139,6 @@ sai_status_t redis_create_hostif_trap_group( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -167,14 +157,12 @@ sai_status_t redis_create_hostif_trap_group( sai_status_t redis_remove_hostif_trap_group( _In_ sai_object_id_t hostif_trap_group_id) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_remove( SAI_OBJECT_TYPE_TRAP_GROUP, hostif_trap_group_id); - REDIS_LOG_EXIT(); - return status; } @@ -195,15 +183,13 @@ sai_status_t redis_set_trap_group_attribute _In_ sai_object_id_t hostif_trap_group_id, _In_ const sai_attribute_t *attr) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_set( SAI_OBJECT_TYPE_TRAP_GROUP, hostif_trap_group_id, attr); - REDIS_LOG_EXIT(); - return status; } @@ -226,7 +212,7 @@ sai_status_t redis_get_trap_group_attribute( _In_ uint32_t attr_count, _Inout_ sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_get( SAI_OBJECT_TYPE_TRAP_GROUP, @@ -234,8 +220,6 @@ sai_status_t redis_get_trap_group_attribute( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -255,15 +239,13 @@ sai_status_t redis_set_trap_attribute( _In_ sai_hostif_trap_id_t hostif_trapid, _In_ const sai_attribute_t *attr) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_set( SAI_OBJECT_TYPE_TRAP, hostif_trapid, attr); - REDIS_LOG_EXIT(); - return status; } @@ -285,7 +267,7 @@ sai_status_t redis_get_trap_attribute( _In_ uint32_t attr_count, _Inout_ sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_get( SAI_OBJECT_TYPE_TRAP, @@ -293,8 +275,6 @@ sai_status_t redis_get_trap_attribute( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -316,7 +296,7 @@ sai_status_t redis_create_hostif( _In_ uint32_t attr_count, _In_ const sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_create( SAI_OBJECT_TYPE_HOST_INTERFACE, @@ -324,8 +304,6 @@ sai_status_t redis_create_hostif( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -343,14 +321,12 @@ sai_status_t redis_create_hostif( sai_status_t redis_remove_hostif( _In_ sai_object_id_t hif_id) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_remove( SAI_OBJECT_TYPE_HOST_INTERFACE, hif_id); - REDIS_LOG_EXIT(); - return status; } @@ -370,15 +346,13 @@ sai_status_t redis_set_hostif_attribute( _In_ sai_object_id_t hif_id, _In_ const sai_attribute_t *attr) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_set( SAI_OBJECT_TYPE_HOST_INTERFACE, hif_id, attr); - REDIS_LOG_EXIT(); - return status; } @@ -400,7 +374,7 @@ sai_status_t redis_get_hostif_attribute( _In_ uint32_t attr_count, _Inout_ sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_get( SAI_OBJECT_TYPE_HOST_INTERFACE, @@ -408,8 +382,6 @@ sai_status_t redis_get_hostif_attribute( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -432,9 +404,7 @@ void redis_packet_event_notification( _In_ uint32_t attr_count, _In_ const sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); - - REDIS_LOG_EXIT(); + SWSS_LOG_ENTER(); } /** diff --git a/lib/src/sai_redis_interfacequery.cpp b/lib/src/sai_redis_interfacequery.cpp index b32c64039..de5ed5324 100644 --- a/lib/src/sai_redis_interfacequery.cpp +++ b/lib/src/sai_redis_interfacequery.cpp @@ -6,6 +6,7 @@ service_method_table_t g_services; bool g_initialized = false; swss::DBConnector *g_db = NULL; +swss::DBConnector *g_dbNtf = NULL; swss::ProducerTable *g_asicState = NULL; // we probably don't need those to tables to access GET requests @@ -13,16 +14,17 @@ swss::ProducerTable *g_redisGetProducer = NULL; swss::ConsumerTable *g_redisGetConsumer = NULL; swss::ConsumerTable *g_redisNotifications = NULL; -swss::Table *g_vidToRid = NULL; -swss::Table *g_ridToVid = NULL; +swss::RedisClient *g_redisClient = NULL; sai_status_t sai_api_initialize( _In_ uint64_t flags, _In_ const service_method_table_t* services) { + SWSS_LOG_ENTER(); + if ((NULL == services) || (NULL == services->profile_get_next_value) || (NULL == services->profile_get_value)) { - REDIS_LOG_ERR("Invalid services handle passed to SAI API initialize\n"); + SWSS_LOG_ERROR("Invalid services handle passed to SAI API initialize\n"); return SAI_STATUS_INVALID_PARAMETER; } @@ -30,7 +32,7 @@ sai_status_t sai_api_initialize( if (0 != flags) { - REDIS_LOG_ERR("Invalid flags passed to SAI API initialize\n"); + SWSS_LOG_ERROR("Invalid flags passed to SAI API initialize\n"); return SAI_STATUS_INVALID_PARAMETER; } @@ -39,6 +41,11 @@ sai_status_t sai_api_initialize( g_db = new swss::DBConnector(ASIC_DB, "localhost", 6379, 0); + if (g_dbNtf != NULL) + delete g_dbNtf; + + g_dbNtf = new swss::DBConnector(ASIC_DB, "localhost", 6379, 0); + if (g_asicState != NULL) delete g_asicState; @@ -57,16 +64,12 @@ sai_status_t sai_api_initialize( if (g_redisNotifications != NULL) delete g_redisNotifications; - g_redisNotifications = new swss::ConsumerTable(g_db, "NOTIFICATIONS"); + g_redisNotifications = new swss::ConsumerTable(g_dbNtf, "NOTIFICATIONS"); - if (g_vidToRid != NULL) - delete g_vidToRid; + if (g_redisClient != NULL) + delete g_redisClient; - if (g_ridToVid != NULL) - delete g_ridToVid; - - g_vidToRid = new swss::Table(g_db, "VIDTORID"); - g_ridToVid = new swss::Table(g_db, "RIDTOVID"); + g_redisClient = new swss::RedisClient(g_db); g_initialized = true; @@ -77,6 +80,8 @@ sai_status_t sai_log_set( _In_ sai_api_t sai_api_id, _In_ sai_log_level_t log_level) { + SWSS_LOG_ENTER(); + switch (log_level) { case SAI_LOG_DEBUG: @@ -98,7 +103,7 @@ sai_status_t sai_log_set( break; default: - REDIS_LOG_ERR("Invalid log level %d\n", log_level); + SWSS_LOG_ERROR("Invalid log level %d\n", log_level); return SAI_STATUS_INVALID_PARAMETER; } @@ -153,7 +158,7 @@ sai_status_t sai_log_set( break; default: - REDIS_LOG_ERR("Invalid API type %d\n", sai_api_id); + SWSS_LOG_ERROR("Invalid API type %d\n", sai_api_id); return SAI_STATUS_INVALID_PARAMETER; } @@ -164,15 +169,17 @@ sai_status_t sai_api_query( _In_ sai_api_t sai_api_id, _Out_ void** api_method_table) { + SWSS_LOG_ENTER(); + if (NULL == api_method_table) { - REDIS_LOG_ERR("NULL method table passed to SAI API initialize\n"); + SWSS_LOG_ERROR("NULL method table passed to SAI API initialize\n"); return SAI_STATUS_INVALID_PARAMETER; } if (!g_initialized) { - REDIS_LOG_ERR("SAI API not initialized before calling API query\n"); + SWSS_LOG_ERROR("SAI API not initialized before calling API query\n"); return SAI_STATUS_UNINITIALIZED; } @@ -278,7 +285,7 @@ sai_status_t sai_api_query( return SAI_STATUS_SUCCESS; default: - REDIS_LOG_ERR("Invalid API type %d\n", sai_api_id); + SWSS_LOG_ERROR("Invalid API type %d\n", sai_api_id); return SAI_STATUS_INVALID_PARAMETER; } } diff --git a/lib/src/sai_redis_lag.cpp b/lib/src/sai_redis_lag.cpp index 8082b4393..a00ce6f6d 100644 --- a/lib/src/sai_redis_lag.cpp +++ b/lib/src/sai_redis_lag.cpp @@ -14,7 +14,7 @@ sai_status_t redis_create_lag( _In_ uint32_t attr_count, _In_ const sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_create( SAI_OBJECT_TYPE_LAG, @@ -22,8 +22,6 @@ sai_status_t redis_create_lag( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -36,14 +34,12 @@ sai_status_t redis_create_lag( sai_status_t redis_remove_lag( _In_ sai_object_id_t lag_id) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_remove( SAI_OBJECT_TYPE_LAG, lag_id); - REDIS_LOG_EXIT(); - return status; } @@ -58,15 +54,13 @@ sai_status_t redis_set_lag_attribute( _In_ sai_object_id_t lag_id, _In_ const sai_attribute_t *attr) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_set( SAI_OBJECT_TYPE_LAG, lag_id, attr); - REDIS_LOG_EXIT(); - return status; } @@ -84,7 +78,7 @@ sai_status_t redis_get_lag_attribute( _In_ uint32_t attr_count, _Inout_ sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_get( SAI_OBJECT_TYPE_LAG, @@ -92,8 +86,6 @@ sai_status_t redis_get_lag_attribute( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -110,7 +102,7 @@ sai_status_t redis_create_lag_member( _In_ uint32_t attr_count, _In_ const sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_create( SAI_OBJECT_TYPE_LAG_MEMBER, @@ -118,8 +110,6 @@ sai_status_t redis_create_lag_member( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -132,14 +122,12 @@ sai_status_t redis_create_lag_member( sai_status_t redis_remove_lag_member( _In_ sai_object_id_t lag_member_id) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_remove( SAI_OBJECT_TYPE_LAG_MEMBER, lag_member_id); - REDIS_LOG_EXIT(); - return status; } @@ -154,15 +142,13 @@ sai_status_t redis_set_lag_member_attribute( _In_ sai_object_id_t lag_member_id, _In_ const sai_attribute_t *attr) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_set( SAI_OBJECT_TYPE_LAG_MEMBER, lag_member_id, attr); - REDIS_LOG_EXIT(); - return status; } @@ -180,7 +166,7 @@ sai_status_t redis_get_lag_member_attribute( _In_ uint32_t attr_count, _Inout_ sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_get( SAI_OBJECT_TYPE_LAG_MEMBER, @@ -188,8 +174,6 @@ sai_status_t redis_get_lag_member_attribute( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } diff --git a/lib/src/sai_redis_mirror.cpp b/lib/src/sai_redis_mirror.cpp index 444653a15..4a328d646 100644 --- a/lib/src/sai_redis_mirror.cpp +++ b/lib/src/sai_redis_mirror.cpp @@ -14,7 +14,7 @@ sai_status_t redis_create_mirror_session( _In_ uint32_t attr_count, _In_ const sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_create( SAI_OBJECT_TYPE_MIRROR, @@ -22,8 +22,6 @@ sai_status_t redis_create_mirror_session( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -37,14 +35,12 @@ sai_status_t redis_create_mirror_session( sai_status_t redis_remove_mirror_session( _In_ sai_object_id_t session_id) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_remove( SAI_OBJECT_TYPE_MIRROR, session_id); - REDIS_LOG_EXIT(); - return status; } @@ -60,15 +56,13 @@ sai_status_t redis_set_mirror_session_attribute( _In_ sai_object_id_t session_id, _In_ const sai_attribute_t *attr) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_set( SAI_OBJECT_TYPE_MIRROR, session_id, attr); - REDIS_LOG_EXIT(); - return status; } @@ -86,7 +80,7 @@ sai_status_t redis_get_mirror_session_attribute( _In_ uint32_t attr_count, _Inout_ sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_get( SAI_OBJECT_TYPE_MIRROR, @@ -94,8 +88,6 @@ sai_status_t redis_get_mirror_session_attribute( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } diff --git a/lib/src/sai_redis_neighbor.cpp b/lib/src/sai_redis_neighbor.cpp index fe56ad276..1b3901d72 100644 --- a/lib/src/sai_redis_neighbor.cpp +++ b/lib/src/sai_redis_neighbor.cpp @@ -20,7 +20,7 @@ sai_status_t redis_create_neighbor_entry( _In_ uint32_t attr_count, _In_ const sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_create( SAI_OBJECT_TYPE_NEIGHBOR, @@ -28,8 +28,6 @@ sai_status_t redis_create_neighbor_entry( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -49,14 +47,12 @@ sai_status_t redis_create_neighbor_entry( sai_status_t redis_remove_neighbor_entry( _In_ const sai_neighbor_entry_t* neighbor_entry) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_remove( SAI_OBJECT_TYPE_NEIGHBOR, neighbor_entry); - REDIS_LOG_EXIT(); - return status; } @@ -76,15 +72,13 @@ sai_status_t redis_set_neighbor_attribute( _In_ const sai_neighbor_entry_t* neighbor_entry, _In_ const sai_attribute_t *attr) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_set( SAI_OBJECT_TYPE_NEIGHBOR, neighbor_entry, attr); - REDIS_LOG_EXIT(); - return status; } @@ -106,7 +100,7 @@ sai_status_t redis_get_neighbor_attribute( _In_ uint32_t attr_count, _Inout_ sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_get( SAI_OBJECT_TYPE_NEIGHBOR, @@ -114,8 +108,6 @@ sai_status_t redis_get_neighbor_attribute( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -132,9 +124,7 @@ sai_status_t redis_get_neighbor_attribute( */ sai_status_t redis_remove_all_neighbor_entries(void) { - REDIS_LOG_ENTER(); - - REDIS_LOG_EXIT(); + SWSS_LOG_ENTER(); return SAI_STATUS_NOT_IMPLEMENTED; } diff --git a/lib/src/sai_redis_nexthop.cpp b/lib/src/sai_redis_nexthop.cpp index e5eab9731..45339305b 100644 --- a/lib/src/sai_redis_nexthop.cpp +++ b/lib/src/sai_redis_nexthop.cpp @@ -20,7 +20,7 @@ sai_status_t redis_create_next_hop( _In_ uint32_t attr_count, _In_ const sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_create( SAI_OBJECT_TYPE_NEXT_HOP, @@ -28,8 +28,6 @@ sai_status_t redis_create_next_hop( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -47,14 +45,12 @@ sai_status_t redis_create_next_hop( sai_status_t redis_remove_next_hop( _In_ sai_object_id_t next_hop_id) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_remove( SAI_OBJECT_TYPE_NEXT_HOP, next_hop_id); - REDIS_LOG_EXIT(); - return status; } @@ -74,15 +70,13 @@ sai_status_t redis_set_next_hop_attribute( _In_ sai_object_id_t next_hop_id, _In_ const sai_attribute_t *attr) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_set( SAI_OBJECT_TYPE_NEXT_HOP, next_hop_id, attr); - REDIS_LOG_EXIT(); - return status; } @@ -104,7 +98,7 @@ sai_status_t redis_get_next_hop_attribute( _In_ uint32_t attr_count, _Inout_ sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_get( SAI_OBJECT_TYPE_NEXT_HOP, @@ -112,8 +106,6 @@ sai_status_t redis_get_next_hop_attribute( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } diff --git a/lib/src/sai_redis_nexthopgroup.cpp b/lib/src/sai_redis_nexthopgroup.cpp index 3773ae7c5..8eee934e0 100644 --- a/lib/src/sai_redis_nexthopgroup.cpp +++ b/lib/src/sai_redis_nexthopgroup.cpp @@ -18,7 +18,7 @@ sai_status_t redis_create_next_hop_group( _In_ uint32_t attr_count, _In_ const sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_create( SAI_OBJECT_TYPE_NEXT_HOP_GROUP, @@ -26,8 +26,6 @@ sai_status_t redis_create_next_hop_group( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -45,14 +43,12 @@ sai_status_t redis_create_next_hop_group( sai_status_t redis_remove_next_hop_group( _In_ sai_object_id_t next_hop_group_id) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_remove( SAI_OBJECT_TYPE_NEXT_HOP_GROUP, next_hop_group_id); - REDIS_LOG_EXIT(); - return status; } @@ -72,15 +68,13 @@ sai_status_t redis_set_next_hop_group_attribute( _In_ sai_object_id_t next_hop_group_id, _In_ const sai_attribute_t *attr) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_set( SAI_OBJECT_TYPE_NEXT_HOP_GROUP, next_hop_group_id, attr); - REDIS_LOG_EXIT(); - return status; } @@ -102,7 +96,7 @@ sai_status_t redis_get_next_hop_group_attribute( _In_ uint32_t attr_count, _Inout_ sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_get( SAI_OBJECT_TYPE_NEXT_HOP_GROUP, @@ -110,8 +104,6 @@ sai_status_t redis_get_next_hop_group_attribute( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -133,9 +125,7 @@ sai_status_t redis_add_next_hop_to_group( _In_ uint32_t next_hop_count, _In_ const sai_object_id_t* nexthops) { - REDIS_LOG_ENTER(); - - REDIS_LOG_EXIT(); + SWSS_LOG_ENTER(); return SAI_STATUS_NOT_IMPLEMENTED; } @@ -158,9 +148,7 @@ sai_status_t redis_remove_next_hop_from_group( _In_ uint32_t next_hop_count, _In_ const sai_object_id_t* nexthops) { - REDIS_LOG_ENTER(); - - REDIS_LOG_EXIT(); + SWSS_LOG_ENTER(); return SAI_STATUS_NOT_IMPLEMENTED; } diff --git a/lib/src/sai_redis_notifications.cpp b/lib/src/sai_redis_notifications.cpp index 644cd0b66..6db44451e 100644 --- a/lib/src/sai_redis_notifications.cpp +++ b/lib/src/sai_redis_notifications.cpp @@ -3,7 +3,9 @@ void handle_switch_state_change( _In_ const std::string &data) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); + + SWSS_LOG_DEBUG("data: %s", data.c_str()); int index = 0; @@ -14,16 +16,18 @@ void handle_switch_state_change( if (on_switch_state_change != NULL) { + SWSS_LOG_ENTER(); + on_switch_state_change(switch_oper_status); } - - REDIS_LOG_EXIT(); } void handle_fdb_event( _In_ const std::string &data) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); + + SWSS_LOG_DEBUG("data: %s", data.c_str()); int index = 0; @@ -42,9 +46,8 @@ void handle_fdb_event( if (status != SAI_STATUS_SUCCESS) { - REDIS_LOG_ERR("Unable to deserialize fdb event, status: %u", status); + SWSS_LOG_ERROR("Unable to deserialize fdb event, status: %u", status); - REDIS_LOG_EXIT(); return; } } @@ -53,6 +56,8 @@ void handle_fdb_event( if (on_fdb_event != NULL) { + SWSS_LOG_ENTER(); + on_fdb_event(count, fdbdata.data()); } @@ -64,17 +69,17 @@ void handle_fdb_event( if (status != SAI_STATUS_SUCCESS) { - REDIS_LOG_ERR("Unable to free fdb event, status: %u", status); + SWSS_LOG_ERROR("Unable to free fdb event, status: %u", status); } } - - REDIS_LOG_EXIT(); } void handle_port_state_change( _In_ const std::string &data) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); + + SWSS_LOG_DEBUG("data: %s", data.c_str()); int index = 0; @@ -97,16 +102,18 @@ void handle_port_state_change( if (on_port_state_change != NULL) { + SWSS_LOG_ENTER(); + on_port_state_change(count, portdata.data()); } - - REDIS_LOG_EXIT(); } void handle_port_event( _In_ const std::string &data) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); + + SWSS_LOG_DEBUG("data: %s", data.c_str()); int index = 0; @@ -129,32 +136,36 @@ void handle_port_event( if (on_port_event != NULL) { + SWSS_LOG_ENTER(); + on_port_event(count, portdata.data()); } - - REDIS_LOG_EXIT(); } void handle_switch_shutdown_request( _In_ const std::string &data) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); + + SWSS_LOG_DEBUG("data: %s", data.c_str()); auto on_switch_shutdown_request = redis_switch_notifications.on_switch_shutdown_request; if (on_switch_shutdown_request != NULL) { + SWSS_LOG_ENTER(); + on_switch_shutdown_request(); } - - REDIS_LOG_EXIT(); } void handle_packet_event( _In_ const std::string &data, _In_ const std::vector &values) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); + + SWSS_LOG_DEBUG("data: %s, values: %lu", data.c_str(), values.size()); sai_size_t buffer_size; @@ -170,16 +181,14 @@ void handle_packet_event( SaiAttributeList list(SAI_OBJECT_TYPE_PACKET, values, false); - translate_rid_to_vid(SAI_OBJECT_TYPE_PACKET, list.get_attr_count(), list.get_attr_list()); - auto on_packet_event = redis_switch_notifications.on_packet_event; if (on_packet_event != NULL) { + SWSS_LOG_ENTER(); + on_packet_event(buffer.data(), buffer_size, list.get_attr_count(), list.get_attr_list()); } - - REDIS_LOG_EXIT(); } void handle_notification( @@ -187,7 +196,7 @@ void handle_notification( _In_ const std::string &data, _In_ const std::vector &values) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); if (notification == "switch_state_change") { @@ -215,8 +224,6 @@ void handle_notification( } else { - REDIS_LOG_ERR("unknow notification: %s", notification.c_str()); + SWSS_LOG_ERROR("unknow notification: %s", notification.c_str()); } - - REDIS_LOG_EXIT(); } diff --git a/lib/src/sai_redis_policer.cpp b/lib/src/sai_redis_policer.cpp index 7ca7d8e24..ac4ff83b4 100644 --- a/lib/src/sai_redis_policer.cpp +++ b/lib/src/sai_redis_policer.cpp @@ -1,7 +1,5 @@ #include "sai_redis.h" - - /** * @brief Create Policer * @@ -17,7 +15,7 @@ sai_status_t redis_create_policer( _In_ uint32_t attr_count, _In_ const sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_create( SAI_OBJECT_TYPE_POLICER, @@ -25,8 +23,6 @@ sai_status_t redis_create_policer( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -41,14 +37,12 @@ sai_status_t redis_create_policer( sai_status_t redis_remove_policer( _In_ sai_object_id_t policer_id) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_remove( SAI_OBJECT_TYPE_POLICER, policer_id); - REDIS_LOG_EXIT(); - return status; } @@ -65,15 +59,13 @@ sai_status_t redis_set_policer_attribute( _In_ sai_object_id_t policer_id, _In_ const sai_attribute_t *attr) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_set( SAI_OBJECT_TYPE_POLICER, policer_id, attr); - REDIS_LOG_EXIT(); - return status; } @@ -92,7 +84,7 @@ sai_status_t redis_get_policer_attribute( _In_ uint32_t attr_count, _Inout_ sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_get( SAI_OBJECT_TYPE_POLICER, @@ -100,8 +92,6 @@ sai_status_t redis_get_policer_attribute( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -122,9 +112,7 @@ sai_status_t redis_get_policer_stats( _In_ uint32_t number_of_counters, _Out_ uint64_t* counters) { - REDIS_LOG_ENTER(); - - REDIS_LOG_EXIT(); + SWSS_LOG_ENTER(); return SAI_STATUS_NOT_IMPLEMENTED; } diff --git a/lib/src/sai_redis_port.cpp b/lib/src/sai_redis_port.cpp index 7a450002f..9a799a977 100644 --- a/lib/src/sai_redis_port.cpp +++ b/lib/src/sai_redis_port.cpp @@ -1,6 +1,5 @@ #include "sai_redis.h" - /** * Routine Description: * @brief Set port attribute value. @@ -17,15 +16,13 @@ sai_status_t redis_set_port_attribute( _In_ sai_object_id_t port_id, _In_ const sai_attribute_t *attr) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_set( SAI_OBJECT_TYPE_PORT, port_id, attr); - REDIS_LOG_EXIT(); - return status; } @@ -47,7 +44,7 @@ sai_status_t redis_get_port_attribute( _In_ uint32_t attr_count, _Inout_ sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_get( SAI_OBJECT_TYPE_PORT, @@ -55,8 +52,6 @@ sai_status_t redis_get_port_attribute( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -80,9 +75,7 @@ sai_status_t redis_get_port_stats( _In_ uint32_t number_of_counters, _Out_ uint64_t* counters) { - REDIS_LOG_ENTER(); - - REDIS_LOG_EXIT(); + SWSS_LOG_ENTER(); return SAI_STATUS_NOT_IMPLEMENTED; } @@ -105,9 +98,7 @@ sai_status_t redis_clear_port_stats( _In_ const sai_port_stat_counter_t *counter_ids, _In_ uint32_t number_of_counters) { - REDIS_LOG_ENTER(); - - REDIS_LOG_EXIT(); + SWSS_LOG_ENTER(); return SAI_STATUS_NOT_IMPLEMENTED; } @@ -126,9 +117,7 @@ sai_status_t redis_clear_port_stats( sai_status_t redis_clear_port_all_stats( _In_ sai_object_id_t port_id) { - REDIS_LOG_ENTER(); - - REDIS_LOG_EXIT(); + SWSS_LOG_ENTER(); return SAI_STATUS_NOT_IMPLEMENTED; } @@ -149,9 +138,7 @@ void redis_port_state_change_notification( _In_ uint32_t count, _In_ sai_port_oper_status_notification_t *data) { - REDIS_LOG_ENTER(); - - REDIS_LOG_EXIT(); + SWSS_LOG_ENTER(); } /** @@ -169,9 +156,7 @@ void redis_port_event_notification( _In_ uint32_t count, _In_ sai_port_event_notification_t *data) { - REDIS_LOG_ENTER(); - - REDIS_LOG_EXIT(); + SWSS_LOG_ENTER(); } /** diff --git a/lib/src/sai_redis_qosmaps.cpp b/lib/src/sai_redis_qosmaps.cpp index de5719258..5795f8b8e 100644 --- a/lib/src/sai_redis_qosmaps.cpp +++ b/lib/src/sai_redis_qosmaps.cpp @@ -15,7 +15,7 @@ sai_status_t redis_create_qos_map( _In_ uint32_t attr_count, _In_ const sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_create( SAI_OBJECT_TYPE_QOS_MAPS, @@ -23,8 +23,6 @@ sai_status_t redis_create_qos_map( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -39,14 +37,12 @@ sai_status_t redis_create_qos_map( sai_status_t redis_remove_qos_map ( _In_ sai_object_id_t qos_map_id) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_remove( SAI_OBJECT_TYPE_QOS_MAPS, qos_map_id); - REDIS_LOG_EXIT(); - return status; } @@ -59,20 +55,17 @@ sai_status_t redis_remove_qos_map ( * @return SAI_STATUS_SUCCESS on success * Failure status code on error */ - sai_status_t redis_set_qos_map_attribute( _In_ sai_object_id_t qos_map_id, _In_ const sai_attribute_t *attr) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_set( SAI_OBJECT_TYPE_QOS_MAPS, qos_map_id, attr); - REDIS_LOG_EXIT(); - return status; } @@ -86,14 +79,12 @@ sai_status_t redis_set_qos_map_attribute( * @return SAI_STATUS_SUCCESS on success * Failure status code on error */ - - sai_status_t redis_get_qos_map_attribute( _In_ sai_object_id_t qos_map_id, _In_ uint32_t attr_count, _Inout_ sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_get( SAI_OBJECT_TYPE_QOS_MAPS, @@ -101,8 +92,6 @@ sai_status_t redis_get_qos_map_attribute( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } diff --git a/lib/src/sai_redis_queue.cpp b/lib/src/sai_redis_queue.cpp index c73be63ba..0f63c0a8f 100644 --- a/lib/src/sai_redis_queue.cpp +++ b/lib/src/sai_redis_queue.cpp @@ -12,15 +12,13 @@ sai_status_t redis_set_queue_attribute( _In_ sai_object_id_t queue_id, _In_ const sai_attribute_t *attr) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_set( SAI_OBJECT_TYPE_QUEUE, queue_id, attr); - REDIS_LOG_EXIT(); - return status; } @@ -38,7 +36,7 @@ sai_status_t redis_get_queue_attribute( _In_ uint32_t attr_count, _Inout_ sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_get( SAI_OBJECT_TYPE_QUEUE, @@ -46,8 +44,6 @@ sai_status_t redis_get_queue_attribute( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -68,9 +64,7 @@ sai_status_t redis_get_queue_stats( _In_ uint32_t number_of_counters, _Out_ uint64_t* counters) { - REDIS_LOG_ENTER(); - - REDIS_LOG_EXIT(); + SWSS_LOG_ENTER(); return SAI_STATUS_NOT_IMPLEMENTED; } @@ -90,9 +84,7 @@ sai_status_t redis_clear_queue_stats( _In_ const sai_queue_stat_counter_t *counter_ids, _In_ uint32_t number_of_counters) { - REDIS_LOG_ENTER(); - - REDIS_LOG_EXIT(); + SWSS_LOG_ENTER(); return SAI_STATUS_NOT_IMPLEMENTED; } diff --git a/lib/src/sai_redis_route.cpp b/lib/src/sai_redis_route.cpp index a84575422..a168e27a6 100644 --- a/lib/src/sai_redis_route.cpp +++ b/lib/src/sai_redis_route.cpp @@ -21,7 +21,7 @@ sai_status_t redis_create_route( _In_ uint32_t attr_count, _In_ const sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_create( SAI_OBJECT_TYPE_ROUTE, @@ -29,8 +29,6 @@ sai_status_t redis_create_route( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -50,14 +48,12 @@ sai_status_t redis_create_route( sai_status_t redis_remove_route( _In_ const sai_unicast_route_entry_t* unicast_route_entry) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_remove( SAI_OBJECT_TYPE_ROUTE, unicast_route_entry); - REDIS_LOG_EXIT(); - return status; } @@ -77,15 +73,13 @@ sai_status_t redis_set_route_attribute( _In_ const sai_unicast_route_entry_t* unicast_route_entry, _In_ const sai_attribute_t *attr) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_set( SAI_OBJECT_TYPE_ROUTE, unicast_route_entry, attr); - REDIS_LOG_EXIT(); - return status; } @@ -107,7 +101,7 @@ sai_status_t redis_get_route_attribute( _In_ uint32_t attr_count, _Inout_ sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_get( SAI_OBJECT_TYPE_ROUTE, @@ -115,8 +109,6 @@ sai_status_t redis_get_route_attribute( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } diff --git a/lib/src/sai_redis_router.cpp b/lib/src/sai_redis_router.cpp index 7f452bf10..4cfe133e0 100644 --- a/lib/src/sai_redis_router.cpp +++ b/lib/src/sai_redis_router.cpp @@ -19,7 +19,7 @@ sai_status_t redis_create_virtual_router( _In_ uint32_t attr_count, _In_ const sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_create( SAI_OBJECT_TYPE_VIRTUAL_ROUTER, @@ -27,8 +27,6 @@ sai_status_t redis_create_virtual_router( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -46,14 +44,12 @@ sai_status_t redis_create_virtual_router( sai_status_t redis_remove_virtual_router( _In_ sai_object_id_t vr_id) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_remove( SAI_OBJECT_TYPE_VIRTUAL_ROUTER, vr_id); - REDIS_LOG_EXIT(); - return status; } @@ -73,15 +69,13 @@ sai_status_t redis_set_virtual_router_attribute( _In_ sai_object_id_t vr_id, _In_ const sai_attribute_t *attr) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_set( SAI_OBJECT_TYPE_VIRTUAL_ROUTER, vr_id, attr); - REDIS_LOG_EXIT(); - return status; } @@ -103,7 +97,7 @@ sai_status_t redis_get_virtual_router_attribute( _In_ uint32_t attr_count, _Inout_ sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_get( SAI_OBJECT_TYPE_VIRTUAL_ROUTER, @@ -111,8 +105,6 @@ sai_status_t redis_get_virtual_router_attribute( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } diff --git a/lib/src/sai_redis_routerintf.cpp b/lib/src/sai_redis_routerintf.cpp index afdfbc3b1..38269b60c 100644 --- a/lib/src/sai_redis_routerintf.cpp +++ b/lib/src/sai_redis_routerintf.cpp @@ -18,7 +18,7 @@ sai_status_t redis_create_router_interface( _In_ uint32_t attr_count, _In_ const sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_create( SAI_OBJECT_TYPE_ROUTER_INTERFACE, @@ -26,8 +26,6 @@ sai_status_t redis_create_router_interface( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -45,14 +43,12 @@ sai_status_t redis_create_router_interface( sai_status_t redis_remove_router_interface( _In_ sai_object_id_t rif_id) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_remove( SAI_OBJECT_TYPE_ROUTER_INTERFACE, rif_id); - REDIS_LOG_EXIT(); - return status; } @@ -72,15 +68,13 @@ sai_status_t redis_set_router_interface_attribute( _In_ sai_object_id_t rif_id, _In_ const sai_attribute_t *attr) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_set( SAI_OBJECT_TYPE_ROUTER_INTERFACE, rif_id, attr); - REDIS_LOG_EXIT(); - return status; } @@ -102,7 +96,7 @@ sai_status_t redis_get_router_interface_attribute( _In_ uint32_t attr_count, _Inout_ sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_get( SAI_OBJECT_TYPE_ROUTER_INTERFACE, @@ -110,8 +104,6 @@ sai_status_t redis_get_router_interface_attribute( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } diff --git a/lib/src/sai_redis_samplepacket.cpp b/lib/src/sai_redis_samplepacket.cpp index 8d6e34f6d..64d70e54f 100644 --- a/lib/src/sai_redis_samplepacket.cpp +++ b/lib/src/sai_redis_samplepacket.cpp @@ -14,7 +14,7 @@ sai_status_t redis_create_samplepacket_session( _In_ uint32_t attr_count, _In_ const sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_create( SAI_OBJECT_TYPE_SAMPLEPACKET, @@ -22,8 +22,6 @@ sai_status_t redis_create_samplepacket_session( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -37,14 +35,12 @@ sai_status_t redis_create_samplepacket_session( sai_status_t redis_remove_samplepacket_session( _In_ sai_object_id_t session_id) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_remove( SAI_OBJECT_TYPE_SAMPLEPACKET, session_id); - REDIS_LOG_EXIT(); - return status; } @@ -60,15 +56,13 @@ sai_status_t redis_set_samplepacket_attribute( _In_ sai_object_id_t session_id, _In_ const sai_attribute_t *attr) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_set( SAI_OBJECT_TYPE_SAMPLEPACKET, session_id, attr); - REDIS_LOG_EXIT(); - return status; } @@ -86,7 +80,7 @@ sai_status_t redis_get_samplepacket_attribute( _In_ uint32_t attr_count, _Inout_ sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_get( SAI_OBJECT_TYPE_SAMPLEPACKET, @@ -94,8 +88,6 @@ sai_status_t redis_get_samplepacket_attribute( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } diff --git a/lib/src/sai_redis_scheduler.cpp b/lib/src/sai_redis_scheduler.cpp index db1c6170b..e7edc77d3 100644 --- a/lib/src/sai_redis_scheduler.cpp +++ b/lib/src/sai_redis_scheduler.cpp @@ -15,7 +15,7 @@ sai_status_t redis_create_scheduler_profile( _In_ uint32_t attr_count, _In_ const sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_create( SAI_OBJECT_TYPE_SCHEDULER, @@ -23,8 +23,6 @@ sai_status_t redis_create_scheduler_profile( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -39,14 +37,12 @@ sai_status_t redis_create_scheduler_profile( sai_status_t redis_remove_scheduler_profile( _In_ sai_object_id_t scheduler_id) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_remove( SAI_OBJECT_TYPE_SCHEDULER, scheduler_id); - REDIS_LOG_EXIT(); - return status; } @@ -63,15 +59,13 @@ sai_status_t redis_set_scheduler_attribute( _In_ sai_object_id_t scheduler_id, _In_ const sai_attribute_t *attr) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_set( SAI_OBJECT_TYPE_SCHEDULER, scheduler_id, attr); - REDIS_LOG_EXIT(); - return status; } @@ -91,7 +85,7 @@ sai_status_t redis_get_scheduler_attribute( _In_ uint32_t attr_count, _Inout_ sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_get( SAI_OBJECT_TYPE_SCHEDULER, @@ -99,8 +93,6 @@ sai_status_t redis_get_scheduler_attribute( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } diff --git a/lib/src/sai_redis_schedulergroup.cpp b/lib/src/sai_redis_schedulergroup.cpp index 3e467283e..ca9465bad 100644 --- a/lib/src/sai_redis_schedulergroup.cpp +++ b/lib/src/sai_redis_schedulergroup.cpp @@ -15,7 +15,7 @@ sai_status_t redis_create_scheduler_group( _In_ uint32_t attr_count, _In_ const sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_create( SAI_OBJECT_TYPE_SCHEDULER_GROUP, @@ -23,8 +23,6 @@ sai_status_t redis_create_scheduler_group( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -39,14 +37,12 @@ sai_status_t redis_create_scheduler_group( sai_status_t redis_remove_scheduler_group( _In_ sai_object_id_t scheduler_group_id) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_remove( SAI_OBJECT_TYPE_SCHEDULER_GROUP, scheduler_group_id); - REDIS_LOG_EXIT(); - return status; } @@ -63,15 +59,13 @@ sai_status_t redis_set_scheduler_group_attribute( _In_ sai_object_id_t scheduler_group_id, _In_ const sai_attribute_t *attr) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_set( SAI_OBJECT_TYPE_SCHEDULER_GROUP, scheduler_group_id, attr); - REDIS_LOG_EXIT(); - return status; } @@ -91,7 +85,7 @@ sai_status_t redis_get_scheduler_group_attribute( _In_ uint32_t attr_count, _Inout_ sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_get( SAI_OBJECT_TYPE_SCHEDULER_GROUP, @@ -99,8 +93,6 @@ sai_status_t redis_get_scheduler_group_attribute( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -119,9 +111,7 @@ sai_status_t redis_add_child_object_to_group( _In_ uint32_t child_count, _In_ const sai_object_id_t* child_objects) { - REDIS_LOG_ENTER(); - - REDIS_LOG_EXIT(); + SWSS_LOG_ENTER(); return SAI_STATUS_NOT_IMPLEMENTED; } @@ -142,9 +132,7 @@ sai_status_t redis_remove_child_object_from_group( _In_ uint32_t child_count, _In_ const sai_object_id_t* child_objects) { - REDIS_LOG_ENTER(); - - REDIS_LOG_EXIT(); + SWSS_LOG_ENTER(); return SAI_STATUS_NOT_IMPLEMENTED; } diff --git a/lib/src/sai_redis_stp.cpp b/lib/src/sai_redis_stp.cpp index c214668b0..3973d82cd 100644 --- a/lib/src/sai_redis_stp.cpp +++ b/lib/src/sai_redis_stp.cpp @@ -14,7 +14,7 @@ sai_status_t redis_create_stp( _In_ uint32_t attr_count, _In_ const sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_create( SAI_OBJECT_TYPE_STP_INSTANCE, @@ -22,8 +22,6 @@ sai_status_t redis_create_stp( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -37,14 +35,12 @@ sai_status_t redis_create_stp( sai_status_t redis_remove_stp( _In_ sai_object_id_t stp_id) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_remove( SAI_OBJECT_TYPE_STP_INSTANCE, stp_id); - REDIS_LOG_EXIT(); - return status; } @@ -62,12 +58,10 @@ sai_status_t redis_set_stp_port_state( _In_ sai_object_id_t port_id, _In_ sai_port_stp_port_state_t stp_port_state) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); // TODO function signature must be changed to match other types - REDIS_LOG_EXIT(); - return SAI_STATUS_NOT_IMPLEMENTED; } @@ -85,12 +79,10 @@ sai_status_t redis_get_stp_port_state( _In_ sai_object_id_t port_id, _Out_ sai_port_stp_port_state_t *stp_port_state) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); // TODO function signature must be changed to match other types - REDIS_LOG_EXIT(); - return SAI_STATUS_NOT_IMPLEMENTED; } @@ -106,15 +98,13 @@ sai_status_t redis_set_stp_attribute( _In_ sai_object_id_t stp_id, _In_ const sai_attribute_t *attr) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_set( SAI_OBJECT_TYPE_STP_INSTANCE, stp_id, attr); - REDIS_LOG_EXIT(); - return status; } @@ -132,7 +122,7 @@ sai_status_t redis_get_stp_attribute( _In_ uint32_t attr_count, _Inout_ sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_get( SAI_OBJECT_TYPE_STP_INSTANCE, @@ -140,8 +130,6 @@ sai_status_t redis_get_stp_attribute( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } diff --git a/lib/src/sai_redis_switch.cpp b/lib/src/sai_redis_switch.cpp index 4ae2f45d7..d5f06f1e3 100644 --- a/lib/src/sai_redis_switch.cpp +++ b/lib/src/sai_redis_switch.cpp @@ -10,7 +10,7 @@ std::shared_ptr notification_thread; void ntf_thread() { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); swss::Select s; @@ -34,7 +34,7 @@ void ntf_thread() const std::string &key = kfvKey(kco); const std::vector &values = kfvFieldsValues(kco); - REDIS_LOG_DBG("op = %s, key = %s", op.c_str(), key.c_str()); + SWSS_LOG_DEBUG("notification: op = %s, key = %s", op.c_str(), key.c_str()); if (op != "ntf") continue; @@ -45,8 +45,6 @@ void ntf_thread() handle_notification(ntf, data, values); } } - - REDIS_LOG_EXIT(); } /** @@ -70,11 +68,11 @@ sai_status_t redis_initialize_switch( _In_reads_opt_z_(SAI_MAX_FIRMWARE_PATH_NAME_LEN) char* firmware_path_name, _In_ sai_switch_notification_t* switch_notifications) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); if (g_initialised) { - REDIS_LOG_EXIT(); + SWSS_LOG_ERROR("switch is already initialized"); return SAI_STATUS_FAILURE; } @@ -94,9 +92,9 @@ sai_status_t redis_initialize_switch( g_run = true; - notification_thread = std::make_shared(std::thread(ntf_thread)); + SWSS_LOG_DEBUG("creating notification thread"); - REDIS_LOG_EXIT(); + notification_thread = std::make_shared(std::thread(ntf_thread)); return SAI_STATUS_SUCCESS; } @@ -117,11 +115,12 @@ sai_status_t redis_initialize_switch( void redis_shutdown_switch( _In_ bool warm_restart_hint) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); if (!g_initialised) { - REDIS_LOG_EXIT(); + SWSS_LOG_ERROR("not initialized"); + return; } @@ -132,8 +131,6 @@ void redis_shutdown_switch( g_initialised = false; memset(&redis_switch_notifications, 0, sizeof(sai_switch_notification_t)); - - REDIS_LOG_EXIT(); } /** @@ -155,9 +152,7 @@ sai_status_t redis_connect_switch( _In_reads_z_(SAI_MAX_HARDWARE_ID_LEN) char* switch_hardware_id, _In_ sai_switch_notification_t* switch_notifications) { - REDIS_LOG_ENTER(); - - REDIS_LOG_EXIT(); + SWSS_LOG_ENTER(); return SAI_STATUS_NOT_IMPLEMENTED; } @@ -171,12 +166,9 @@ sai_status_t redis_connect_switch( * Return Values: * None */ -void redis_disconnect_switch( - void) +void redis_disconnect_switch(void) { - REDIS_LOG_ENTER(); - - REDIS_LOG_EXIT(); + SWSS_LOG_ENTER(); } /** @@ -193,15 +185,13 @@ void redis_disconnect_switch( sai_status_t redis_set_switch_attribute( _In_ const sai_attribute_t *attr) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_set( SAI_OBJECT_TYPE_SWITCH, (sai_object_id_t)0, // dummy sai_object_id_t for switch attr); - REDIS_LOG_EXIT(); - return status; } @@ -221,7 +211,7 @@ sai_status_t redis_get_switch_attribute( _In_ sai_uint32_t attr_count, _Inout_ sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_get( SAI_OBJECT_TYPE_SWITCH, @@ -229,8 +219,6 @@ sai_status_t redis_get_switch_attribute( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } diff --git a/lib/src/sai_redis_udf.cpp b/lib/src/sai_redis_udf.cpp index 830831b34..63d7448ff 100644 --- a/lib/src/sai_redis_udf.cpp +++ b/lib/src/sai_redis_udf.cpp @@ -19,7 +19,7 @@ sai_status_t redis_create_udf( _In_ uint32_t attr_count, _In_ const sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_create( SAI_OBJECT_TYPE_UDF, @@ -27,8 +27,6 @@ sai_status_t redis_create_udf( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -46,14 +44,12 @@ sai_status_t redis_create_udf( sai_status_t redis_remove_udf( _In_ sai_object_id_t udf_id) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_remove( SAI_OBJECT_TYPE_UDF, udf_id); - REDIS_LOG_EXIT(); - return status; } @@ -73,15 +69,13 @@ sai_status_t redis_set_udf_attribute( _In_ sai_object_id_t udf_id, _In_ const sai_attribute_t *attr) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_set( SAI_OBJECT_TYPE_UDF, udf_id, attr); - REDIS_LOG_EXIT(); - return status; } @@ -103,7 +97,7 @@ sai_status_t redis_get_udf_attribute( _In_ uint32_t attr_count, _Inout_ sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_get( SAI_OBJECT_TYPE_UDF, @@ -111,8 +105,6 @@ sai_status_t redis_get_udf_attribute( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -135,7 +127,7 @@ sai_status_t redis_create_udf_match( _In_ uint32_t attr_count, _In_ const sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_create( SAI_OBJECT_TYPE_UDF_MATCH, @@ -143,8 +135,6 @@ sai_status_t redis_create_udf_match( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -162,14 +152,12 @@ sai_status_t redis_create_udf_match( sai_status_t redis_remove_udf_match( _In_ sai_object_id_t udf_match_id) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_remove( SAI_OBJECT_TYPE_UDF_MATCH, udf_match_id); - REDIS_LOG_EXIT(); - return status; } @@ -189,15 +177,13 @@ sai_status_t redis_set_udf_match_attribute( _In_ sai_object_id_t udf_match_id, _In_ const sai_attribute_t *attr) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_set( SAI_OBJECT_TYPE_UDF_MATCH, udf_match_id, attr); - REDIS_LOG_EXIT(); - return status; } @@ -219,7 +205,7 @@ sai_status_t redis_get_udf_match_attribute( _In_ uint32_t attr_count, _Inout_ sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_get( SAI_OBJECT_TYPE_UDF_MATCH, @@ -227,8 +213,6 @@ sai_status_t redis_get_udf_match_attribute( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -251,7 +235,7 @@ sai_status_t redis_create_udf_group( _In_ uint32_t attr_count, _In_ const sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_create( SAI_OBJECT_TYPE_UDF_GROUP, @@ -259,8 +243,6 @@ sai_status_t redis_create_udf_group( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -278,14 +260,12 @@ sai_status_t redis_create_udf_group( sai_status_t redis_remove_udf_group( _In_ sai_object_id_t udf_group_id) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_remove( SAI_OBJECT_TYPE_UDF_GROUP, udf_group_id); - REDIS_LOG_EXIT(); - return status; } @@ -305,15 +285,13 @@ sai_status_t redis_set_udf_group_attribute( _In_ sai_object_id_t udf_group_id, _In_ const sai_attribute_t *attr) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_set( SAI_OBJECT_TYPE_UDF_GROUP, udf_group_id, attr); - REDIS_LOG_EXIT(); - return status; } @@ -335,7 +313,7 @@ sai_status_t redis_get_udf_group_attribute( _In_ uint32_t attr_count, _Inout_ sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_get( SAI_OBJECT_TYPE_UDF_GROUP, @@ -343,8 +321,6 @@ sai_status_t redis_get_udf_group_attribute( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } diff --git a/lib/src/sai_redis_vlan.cpp b/lib/src/sai_redis_vlan.cpp index 2a1202d7e..f3f32a9c1 100644 --- a/lib/src/sai_redis_vlan.cpp +++ b/lib/src/sai_redis_vlan.cpp @@ -14,14 +14,12 @@ sai_status_t redis_create_vlan( _In_ sai_vlan_id_t vlan_id) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_create_vlan( SAI_OBJECT_TYPE_VLAN, vlan_id); - REDIS_LOG_EXIT(); - return status; } @@ -39,14 +37,12 @@ sai_status_t redis_create_vlan( sai_status_t redis_remove_vlan( _In_ sai_vlan_id_t vlan_id) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_remove_vlan( SAI_OBJECT_TYPE_VLAN, vlan_id); - REDIS_LOG_EXIT(); - return status; } @@ -66,15 +62,13 @@ sai_status_t redis_set_vlan_attribute( _In_ sai_vlan_id_t vlan_id, _In_ const sai_attribute_t *attr) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_set_vlan( SAI_OBJECT_TYPE_VLAN, vlan_id, attr); - REDIS_LOG_EXIT(); - return status; } @@ -96,7 +90,7 @@ sai_status_t redis_get_vlan_attribute( _In_ uint32_t attr_count, _Inout_ sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_get_vlan( SAI_OBJECT_TYPE_VLAN, @@ -104,8 +98,6 @@ sai_status_t redis_get_vlan_attribute( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -122,7 +114,7 @@ sai_status_t redis_create_vlan_member( _In_ uint32_t attr_count, _In_ const sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_create( SAI_OBJECT_TYPE_VLAN_MEMBER, @@ -130,8 +122,6 @@ sai_status_t redis_create_vlan_member( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -144,14 +134,12 @@ sai_status_t redis_create_vlan_member( sai_status_t redis_remove_vlan_member( _In_ sai_object_id_t vlan_member_id) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_remove( SAI_OBJECT_TYPE_VLAN_MEMBER, vlan_member_id); - REDIS_LOG_EXIT(); - return status; } @@ -166,15 +154,13 @@ sai_status_t redis_set_vlan_member_attribute( _In_ sai_object_id_t vlan_member_id, _In_ const sai_attribute_t *attr) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_set( SAI_OBJECT_TYPE_VLAN_MEMBER, vlan_member_id, attr); - REDIS_LOG_EXIT(); - return status; } @@ -192,7 +178,7 @@ sai_status_t redis_get_vlan_member_attribute( _In_ uint32_t attr_count, _Inout_ sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_get( SAI_OBJECT_TYPE_VLAN_MEMBER, @@ -200,8 +186,6 @@ sai_status_t redis_get_vlan_member_attribute( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -226,9 +210,7 @@ sai_status_t redis_get_vlan_stats( _In_ uint32_t number_of_counters, _Out_ uint64_t* counters) { - REDIS_LOG_ENTER(); - - REDIS_LOG_EXIT(); + SWSS_LOG_ENTER(); return SAI_STATUS_NOT_IMPLEMENTED; } @@ -251,9 +233,7 @@ sai_status_t redis_clear_vlan_stats( _In_ const sai_vlan_stat_counter_t *counter_ids, _In_ uint32_t number_of_counters) { - REDIS_LOG_ENTER(); - - REDIS_LOG_EXIT(); + SWSS_LOG_ENTER(); return SAI_STATUS_NOT_IMPLEMENTED; } diff --git a/lib/src/sai_redis_wred.cpp b/lib/src/sai_redis_wred.cpp index af3e3409e..c7539d1e1 100644 --- a/lib/src/sai_redis_wred.cpp +++ b/lib/src/sai_redis_wred.cpp @@ -17,7 +17,7 @@ sai_status_t redis_create_wred_profile( _In_ uint32_t attr_count, _In_ const sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_create( SAI_OBJECT_TYPE_WRED, @@ -25,8 +25,6 @@ sai_status_t redis_create_wred_profile( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } @@ -41,14 +39,12 @@ sai_status_t redis_create_wred_profile( sai_status_t redis_remove_wred_profile( _In_ sai_object_id_t wred_id) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_remove( SAI_OBJECT_TYPE_WRED, wred_id); - REDIS_LOG_EXIT(); - return status; } @@ -67,15 +63,13 @@ sai_status_t redis_set_wred_attribute( _In_ sai_object_id_t wred_id, _In_ const sai_attribute_t *attr) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_set( SAI_OBJECT_TYPE_WRED, wred_id, attr); - REDIS_LOG_EXIT(); - return status; } @@ -94,7 +88,7 @@ sai_status_t redis_get_wred_attribute( _In_ uint32_t attr_count, _Inout_ sai_attribute_t *attr_list) { - REDIS_LOG_ENTER(); + SWSS_LOG_ENTER(); sai_status_t status = redis_generic_get( SAI_OBJECT_TYPE_WRED, @@ -102,8 +96,6 @@ sai_status_t redis_get_wred_attribute( attr_count, attr_list); - REDIS_LOG_EXIT(); - return status; } diff --git a/syncd/Makefile.am b/syncd/Makefile.am index 365609e8c..5b7983bea 100644 --- a/syncd/Makefile.am +++ b/syncd/Makefile.am @@ -19,7 +19,10 @@ endif syncd_SOURCES = syncd.cpp \ syncd_init.cpp \ + syncd_reinit.cpp \ + syncd_hard_reinit.cpp \ syncd_notifications.cpp \ + ../common/redisclient.cpp \ ../common/saiserialize.cpp \ ../common/saiattributelist.cpp diff --git a/syncd/syncd.cpp b/syncd/syncd.cpp index 9ab0c6496..81d53f8cb 100644 --- a/syncd/syncd.cpp +++ b/syncd/syncd.cpp @@ -1,13 +1,15 @@ #include #include "syncd.h" -swss::Table *g_vidToRid = NULL; -swss::Table *g_ridToVid = NULL; +std::mutex g_mutex; +swss::RedisClient *g_redisClient = NULL; std::map gProfileMap; void sai_diag_shell() { + SWSS_LOG_ENTER(); + sai_status_t status; while (true) @@ -17,7 +19,7 @@ void sai_diag_shell() status = sai_switch_api->set_switch_attribute(&attr); if (status != SAI_STATUS_SUCCESS) { - SYNCD_LOG_ERR("open sai shell failed %d", status); + SWSS_LOG_ERROR("open sai shell failed %d", status); return; } @@ -25,36 +27,192 @@ void sai_diag_shell() } } +sai_object_id_t redis_create_virtual_object_id( + _In_ sai_object_type_t object_type) +{ + SWSS_LOG_ENTER(); + + uint64_t virtual_id = g_redisClient->incr(VIDCOUNTER); + + sai_object_id_t vid = (((sai_object_id_t)object_type) << 48) | virtual_id; + + SWSS_LOG_DEBUG("created virtual object id %llx for object type %x", vid, object_type); + + return vid; +} + +sai_object_id_t translate_rid_to_vid( + _In_ sai_object_id_t rid) +{ + SWSS_LOG_ENTER(); + + if (rid == SAI_NULL_OBJECT_ID) + { + SWSS_LOG_DEBUG("translated RID null to VID null"); + + return SAI_NULL_OBJECT_ID; + } + + sai_object_id_t vid; + + std::string str_rid; + std::string str_vid; + + sai_serialize_primitive(rid, str_rid); + + auto pvid = g_redisClient->hget(RIDTOVID, str_rid); + + if (pvid != NULL) + { + // object exists + str_vid = *pvid; + + int index = 0; + sai_deserialize_primitive(str_vid, index, vid); + + SWSS_LOG_DEBUG("translated RID %llx to VID %llx", rid, vid); + + return vid; + } + + SWSS_LOG_INFO("spotted new RID %llx", rid); + + sai_object_type_t object_type = sai_object_type_query(rid); + + if (object_type == SAI_OBJECT_TYPE_NULL) + { + SWSS_LOG_ERROR("sai_object_type_query returned NULL type for RID %llx", rid); + + exit(EXIT_FAILURE); + } + + vid = redis_create_virtual_object_id(object_type); + + SWSS_LOG_DEBUG("translated RID %llx to VID %llx", rid, vid); + + sai_serialize_primitive(vid, str_vid); + + g_redisClient->hset(RIDTOVID, str_rid, str_vid); + g_redisClient->hset(VIDTORID, str_vid, str_rid); + + return vid; +} + +template +void translate_list_rid_to_vid( + _In_ T &element) +{ + SWSS_LOG_ENTER(); + + for (uint32_t i = 0; i < element.count; i++) + { + element.list[i] = translate_rid_to_vid(element.list[i]); + } +} + +void translate_rid_to_vid_list( + _In_ sai_object_type_t object_type, + _In_ uint32_t attr_count, + _In_ sai_attribute_t *attr_list) +{ + SWSS_LOG_ENTER(); + + // we receive real id's here, if they are new then create new id + // for them and put in db, if entry exists in db, use it + + for (uint32_t i = 0; i < attr_count; i++) + { + sai_attribute_t &attr = attr_list[i]; + + sai_attr_serialization_type_t serialization_type; + sai_status_t status = sai_get_serialization_type(object_type, attr.id, serialization_type); + + if (status != SAI_STATUS_SUCCESS) + { + SWSS_LOG_ERROR("unable to find serialization type for object type %x, attribute %x", object_type, attr.id); + + exit(EXIT_FAILURE); + } + + switch (serialization_type) + { + case SAI_SERIALIZATION_TYPE_OBJECT_ID: + attr.value.oid = translate_rid_to_vid(attr.value.oid); + break; + + case SAI_SERIALIZATION_TYPE_OBJECT_LIST: + translate_list_rid_to_vid(attr.value.objlist); + break; + + case SAI_SERIALIZATION_TYPE_ACL_FIELD_DATA_OBJECT_ID: + attr.value.aclfield.data.oid = translate_rid_to_vid(attr.value.aclfield.data.oid); + break; + + case SAI_SERIALIZATION_TYPE_ACL_FIELD_DATA_OBJECT_LIST: + translate_list_rid_to_vid(attr.value.aclfield.data.objlist); + break; + + case SAI_SERIALIZATION_TYPE_ACL_ACTION_DATA_OBJECT_ID: + attr.value.aclaction.parameter.oid = translate_rid_to_vid(attr.value.aclaction.parameter.oid); + break; + + case SAI_SERIALIZATION_TYPE_ACL_ACTION_DATA_OBJECT_LIST: + translate_list_rid_to_vid(attr.value.aclaction.parameter.objlist); + break; + + case SAI_SERIALIZATION_TYPE_PORT_BREAKOUT: + translate_list_rid_to_vid(attr.value.portbreakout.port_list); + + default: + break; + } + } +} + sai_object_id_t translate_vid_to_rid( _In_ sai_object_id_t vid) { + SWSS_LOG_ENTER(); + if (vid == SAI_NULL_OBJECT_ID) + { + SWSS_LOG_DEBUG("translated RID null to VID null"); return SAI_NULL_OBJECT_ID; + } std::string str_vid; sai_serialize_primitive(vid, str_vid); std::string str_rid; - if (!g_vidToRid->getField(std::string(), str_vid, str_rid)) + auto prid = g_redisClient->hget(VIDTORID, str_vid); + + if (prid == NULL) { - SYNCD_LOG_ERR("unable to get rid for vid: %s", str_vid.c_str()); - throw std::runtime_error("unable to get rid for vid"); + SWSS_LOG_ERROR("unable to get RID for VID: %s", str_vid.c_str()); + + exit(EXIT_FAILURE); } + str_rid = *prid; + sai_object_id_t rid; int index = 0; sai_deserialize_primitive(str_rid, index, rid); + SWSS_LOG_DEBUG("translated VID %llx to RID %llx", vid, rid); + return rid; } -void translate_vid_to_rid( +void translate_vid_to_rid_list( _In_ sai_object_type_t object_type, _In_ uint32_t attr_count, _In_ sai_attribute_t *attr_list) { + SWSS_LOG_ENTER(); + // all id's reseived from sairedis should be virtual, so // lets translate them to real id's @@ -67,7 +225,9 @@ void translate_vid_to_rid( if (status != SAI_STATUS_SUCCESS) { - throw std::runtime_error("unable to find serialization type"); + SWSS_LOG_ERROR("unable to find serialization type for object type %x, attribute %x", object_type, attr.id); + + exit(EXIT_FAILURE); } switch (serialization_type) @@ -111,10 +271,14 @@ void internal_syncd_get_send( _In_ uint32_t attr_count, _In_ sai_attribute_t *attr_list) { + SWSS_LOG_ENTER(); + std::vector entry; if (status == SAI_STATUS_SUCCESS) { + translate_rid_to_vid_list(object_type, attr_count, attr_list); + // XXX: normal serialization + translate reverse entry = SaiAttributeList::serialize_attr_list( object_type, @@ -195,16 +359,28 @@ sai_status_t handle_generic( _In_ uint32_t attr_count, _In_ sai_attribute_t *attr_list) { + SWSS_LOG_ENTER(); + int index = 0; sai_object_id_t object_id; sai_deserialize_primitive(str_object_id, index, object_id); + SWSS_LOG_DEBUG("common generic api: %d", api); + switch(api) { case SAI_COMMON_API_CREATE: { + SWSS_LOG_DEBUG("generic create for object type %x", object_type); + create_fn create = common_create[object_type]; + if (create == NULL) + { + SWSS_LOG_ERROR("create function is not defined for object type %x", object_type); + exit(EXIT_FAILURE); + } + sai_object_id_t real_object_id; sai_status_t status = create(&real_object_id, attr_count, attr_list); @@ -219,14 +395,14 @@ sai_status_t handle_generic( sai_serialize_primitive(object_id, str_vid); sai_serialize_primitive(real_object_id, str_rid); - g_vidToRid->setField(std::string(), str_vid, str_rid); - g_ridToVid->setField(std::string(), str_rid, str_vid); + g_redisClient->hset(VIDTORID, str_vid, str_rid); + g_redisClient->hset(RIDTOVID, str_rid, str_vid); - SYNCD_LOG_INF("saved vid %s to rid %s", str_vid.c_str(), str_rid.c_str()); + SWSS_LOG_INFO("saved VID %s to RID %s", str_vid.c_str(), str_rid.c_str()); } else { - SYNCD_LOG_ERR("failed to create %d", status); + SWSS_LOG_ERROR("failed to create %d", status); } return status; @@ -234,8 +410,16 @@ sai_status_t handle_generic( case SAI_COMMON_API_REMOVE: { + SWSS_LOG_DEBUG("generic remove for object type %x", object_type); + remove_fn remove = common_remove[object_type]; + if (remove == NULL) + { + SWSS_LOG_ERROR("remove function is not defined for object type %x", object_type); + exit(EXIT_FAILURE); + } + sai_object_id_t rid = translate_vid_to_rid(object_id); std::string str_vid; @@ -244,16 +428,24 @@ sai_status_t handle_generic( std::string str_rid; sai_serialize_primitive(rid, str_rid); - g_vidToRid->delField(std::string(), str_vid); - g_ridToVid->delField(std::string(), str_rid); + g_redisClient->hdel(VIDTORID, str_vid); + g_redisClient->hdel(RIDTOVID, str_rid); return remove(rid); } case SAI_COMMON_API_SET: { + SWSS_LOG_DEBUG("generic set for object type %x", object_type); + set_attribute_fn set = common_set_attribute[object_type]; + if (set == NULL) + { + SWSS_LOG_ERROR("set function is not defined for object type %x", object_type); + exit(EXIT_FAILURE); + } + sai_object_id_t rid = translate_vid_to_rid(object_id); return set(rid, attr_list); @@ -261,19 +453,25 @@ sai_status_t handle_generic( case SAI_COMMON_API_GET: { + SWSS_LOG_DEBUG("generic get for object type %x", object_type); + get_attribute_fn get = common_get_attribute[object_type]; + if (get == NULL) + { + SWSS_LOG_ERROR("get function is not defined for object type %x", object_type); + exit(EXIT_FAILURE); + } + sai_object_id_t rid = translate_vid_to_rid(object_id); return get(rid, attr_count, attr_list); } default: - SYNCD_LOG_ERR("generic other apis not implemented"); - return SAI_STATUS_NOT_SUPPORTED; + SWSS_LOG_ERROR("generic other apis not implemented"); + exit(EXIT_FAILURE); } - - return SAI_STATUS_SUCCESS; } sai_status_t handle_fdb( @@ -282,6 +480,8 @@ sai_status_t handle_fdb( _In_ uint32_t attr_count, _In_ sai_attribute_t *attr_list) { + SWSS_LOG_ENTER(); + int index = 0; sai_fdb_entry_t fdb_entry; sai_deserialize_primitive(str_object_id, index, fdb_entry); @@ -301,8 +501,8 @@ sai_status_t handle_fdb( return sai_fdb_api->get_fdb_entry_attribute(&fdb_entry, attr_count, attr_list); default: - SYNCD_LOG_ERR("fdb other apis not implemented"); - return SAI_STATUS_NOT_SUPPORTED; + SWSS_LOG_ERROR("fdb other apis not implemented"); + exit(EXIT_FAILURE); } } @@ -312,6 +512,8 @@ sai_status_t handle_switch( _In_ uint32_t attr_count, _In_ sai_attribute_t *attr_list) { + SWSS_LOG_ENTER(); + switch(api) { case SAI_COMMON_API_CREATE: @@ -327,8 +529,8 @@ sai_status_t handle_switch( return sai_switch_api->get_switch_attribute(attr_count, attr_list); default: - SYNCD_LOG_ERR("switch other apis not implemented"); - return SAI_STATUS_NOT_SUPPORTED; + SWSS_LOG_ERROR("switch other apis not implemented"); + exit(EXIT_FAILURE); } } @@ -338,9 +540,11 @@ sai_status_t handle_neighbor( _In_ uint32_t attr_count, _In_ sai_attribute_t *attr_list) { + SWSS_LOG_ENTER(); + int index = 0; sai_neighbor_entry_t neighbor_entry; - sai_deserialize_primitive(str_object_id, index, neighbor_entry); + sai_deserialize_neighbor_entry(str_object_id, index, neighbor_entry); neighbor_entry.rif_id = translate_vid_to_rid(neighbor_entry.rif_id); @@ -359,8 +563,8 @@ sai_status_t handle_neighbor( return sai_neighbor_api->get_neighbor_attribute(&neighbor_entry, attr_count, attr_list); default: - SYNCD_LOG_ERR("neighbor other apis not implemented"); - return SAI_STATUS_NOT_SUPPORTED; + SWSS_LOG_ERROR("neighbor other apis not implemented"); + exit(EXIT_FAILURE); } } @@ -370,9 +574,11 @@ sai_status_t handle_route( _In_ uint32_t attr_count, _In_ sai_attribute_t *attr_list) { + SWSS_LOG_ENTER(); + int index = 0; sai_unicast_route_entry_t route_entry; - sai_deserialize_primitive(str_object_id, index, route_entry); + sai_deserialize_route_entry(str_object_id, index, route_entry); route_entry.vr_id = translate_vid_to_rid(route_entry.vr_id); @@ -388,11 +594,11 @@ sai_status_t handle_route( return sai_route_api->set_route_attribute(&route_entry, attr_list); case SAI_COMMON_API_GET: - return sai_route_api->get_route_attribute(&route_entry, attr_count, attr_list); + return sai_route_api->get_route_attribute(&route_entry, attr_count, attr_list); default: - SYNCD_LOG_ERR("route other apis not implemented"); - return SAI_STATUS_NOT_SUPPORTED; + SWSS_LOG_ERROR("route other apis not implemented"); + exit(EXIT_FAILURE); } } @@ -402,6 +608,8 @@ sai_status_t handle_vlan( _In_ uint32_t attr_count, _In_ sai_attribute_t *attr_list) { + SWSS_LOG_ENTER(); + int index = 0; sai_vlan_id_t vlan_id; sai_deserialize_primitive(str_object_id, index, vlan_id); @@ -421,8 +629,8 @@ sai_status_t handle_vlan( return sai_vlan_api->get_vlan_attribute(vlan_id, attr_count, attr_list); default: - SYNCD_LOG_ERR("vlan other apis not implemented"); - return SAI_STATUS_NOT_SUPPORTED; + SWSS_LOG_ERROR("vlan other apis not implemented"); + exit(EXIT_FAILURE); } } @@ -432,6 +640,8 @@ sai_status_t handle_trap( _In_ uint32_t attr_count, _In_ sai_attribute_t *attr_list) { + SWSS_LOG_ENTER(); + int index = 0; sai_object_id_t dummy_id; sai_deserialize_primitive(str_object_id, index, dummy_id); @@ -447,13 +657,17 @@ sai_status_t handle_trap( return sai_hostif_api->get_trap_attribute(trap_id, attr_count, attr_list); default: - SYNCD_LOG_ERR("trap other apis not implemented"); - return SAI_STATUS_NOT_SUPPORTED; + SWSS_LOG_ERROR("trap other apis not implemented"); + exit(EXIT_FAILURE); } } sai_status_t processEvent(swss::ConsumerTable &consumer) { + std::lock_guard lock(g_mutex); + + SWSS_LOG_ENTER(); + swss::KeyOpFieldsValuesTuple kco; consumer.pop(kco); @@ -463,7 +677,7 @@ sai_status_t processEvent(swss::ConsumerTable &consumer) std::string str_object_type = key.substr(0, key.find(":")); std::string str_object_id = key.substr(key.find(":")+1); - SYNCD_LOG_DBG( + SWSS_LOG_INFO( "key: %s op: %s objtype: %s objid: %s", key.c_str(), op.c_str(), @@ -482,6 +696,9 @@ sai_status_t processEvent(swss::ConsumerTable &consumer) api = SAI_COMMON_API_GET; else { + if (op != "delget") + SWSS_LOG_ERROR("api %s is not implemented", op.c_str()); + return SAI_STATUS_NOT_SUPPORTED; } @@ -493,7 +710,7 @@ sai_status_t processEvent(swss::ConsumerTable &consumer) if (object_type >= SAI_OBJECT_TYPE_MAX) { - SYNCD_LOG_ERR("undefined object type %d", object_type); + SWSS_LOG_ERROR("undefined object type %d", object_type); return SAI_STATUS_NOT_SUPPORTED; } @@ -502,7 +719,7 @@ sai_status_t processEvent(swss::ConsumerTable &consumer) SaiAttributeList list(object_type, values, false); if (api != SAI_COMMON_API_GET) - translate_vid_to_rid(object_type, list.get_attr_count(), list.get_attr_list()); + translate_vid_to_rid_list(object_type, list.get_attr_count(), list.get_attr_list()); sai_attribute_t *attr_list = list.get_attr_list(); uint32_t attr_count = list.get_attr_count(); @@ -540,17 +757,105 @@ sai_status_t processEvent(swss::ConsumerTable &consumer) } if (api == SAI_COMMON_API_GET) + { internal_syncd_get_send(object_type, status, attr_count, attr_list); + } + else if (status != SAI_STATUS_SUCCESS) + { + SWSS_LOG_ERROR("failed to execute api: %s: %u", op.c_str(), status); + + exit(EXIT_FAILURE); + } return status; } +void handler(int sig) +{ + signal(SIGSEGV, SIG_DFL); + + SWSS_LOG_ENTER(); + + SWSS_LOG_ERROR("SIGNAL %d", sig); + + void *array[10]; + char **strings; + size_t size; + + size = backtrace(array, 10); + + SWSS_LOG_ERROR("backtrace() returned %d addresses", size); + + strings = backtrace_symbols(array, size); + + if (strings == NULL) + { + SWSS_LOG_ERROR("backtrace_sumbols() returned NULL"); + exit(EXIT_FAILURE); + } + + for (size_t j = 0; j < size; j++) + SWSS_LOG_ERROR("backtrace stack: %s", strings[j]); + + free(strings); + + backtrace_symbols_fd(array, size, STDERR_FILENO); + + exit(EXIT_FAILURE); +} + +swss::Logger::Priority redisGetLogLevel() +{ + SWSS_LOG_ENTER(); + + auto plevel = g_redisClient->get("LOGLEVEL"); + + if (plevel == NULL) + return swss::Logger::SWSS_NOTICE; + + return swss::Logger::stringToPriority(*plevel); +} + +void redisSetLogLevel(swss::Logger::Priority prio) +{ + SWSS_LOG_ENTER(); + + std::string level = swss::Logger::priorityToString(prio); + + g_redisClient->set("LOGLEVEL", level); +} + +void updateLogLevel() +{ + std::lock_guard lock(g_mutex); + + auto level = redisGetLogLevel(); + + if (level != swss::Logger::getInstance().getMinPrio()) + { + swss::Logger::getInstance().setMinPrio(level); + + SWSS_LOG_NOTICE("log level changed to %s", swss::Logger::priorityToString(level).c_str()); + + // set level to correct one if user set some invalid value + redisSetLogLevel(level); + } +} + int main(int argc, char **argv) { + swss::Logger::getInstance().setMinPrio(swss::Logger::SWSS_DEBUG); + + SWSS_LOG_ENTER(); + + signal(SIGSEGV, handler); + swss::DBConnector *db = new swss::DBConnector(ASIC_DB, "localhost", 6379, 0); + swss::DBConnector *dbNtf = new swss::DBConnector(ASIC_DB, "localhost", 6379, 0); - g_vidToRid = new swss::Table(db, "VIDTORID"); - g_ridToVid = new swss::Table(db, "RIDTOVID"); + g_redisClient = new swss::RedisClient(db); + + updateLogLevel(); swss::ConsumerTable *asicState = new swss::ConsumerTable(db, "ASIC_STATE"); @@ -559,6 +864,7 @@ int main(int argc, char **argv) // also "remove" from response queue will also trigger another "response" getRequest = new swss::ConsumerTable(db, "GETREQUEST"); getResponse = new swss::ProducerTable(db, "GETRESPONSE"); + notifications = new swss::ProducerTable(dbNtf, "NOTIFICATIONS"); #ifdef MLNXSAI std::string mlnx_config_file = "/etc/ssw/ACS-MSN2700/sai_2700.xml"; @@ -571,21 +877,30 @@ int main(int argc, char **argv) initialize_common_api_pointers(); - // swss::Logger::getInstance().setMinPrio(swss::Logger::SWSS_DEBUG); - #if 1 + sai_status_t status = sai_switch_api->initialize_switch(0, "0xb850", "", &switch_notifications); if (status != SAI_STATUS_SUCCESS) { - SYNCD_LOG_ERR("fail to sai_initialize_switch: %lld", status); + SWSS_LOG_ERROR("fail to sai_initialize_switch: %d", status); exit(EXIT_FAILURE); } #ifdef BRCMSAI - std::thread bcm_diag_shell_thread = std::thread(sai_diag_shell); - bcm_diag_shell_thread.detach(); + + for (int i = 0; i < argc; i++) + { + if (strcmp(argv[i],"--diag") == 0) + { + std::thread bcm_diag_shell_thread = std::thread(sai_diag_shell); + bcm_diag_shell_thread.detach(); + break; + } + } + #endif /* BRCMSAI */ + #else sai_switch_api->initialize_switch( 0, // profile id @@ -594,10 +909,14 @@ int main(int argc, char **argv) &switch_notifications); #endif - SYNCD_LOG_INF("syncd started"); + SWSS_LOG_INFO("syncd started"); try { + onSyncdStart(); + + SWSS_LOG_INFO("syncd listening for events"); + swss::Select s; s.addSelectable(getRequest); @@ -615,15 +934,20 @@ int main(int argc, char **argv) { processEvent(*(swss::ConsumerTable*)sel); } + + // TODO may be not efficient to do it here + updateLogLevel(); } } - catch(const std::runtime_error &e) + catch(const std::exception &e) { - SYNCD_LOG_ERR("Runtime error: %s", e.what()); + SWSS_LOG_ERROR("Runtime error: %s", e.what()); } catch(...) { - SYNCD_LOG_ERR("Runtime error: unhandled exception"); + SWSS_LOG_ERROR("Runtime error: unhandled exception"); + + handler(SIGSEGV); } sai_api_uninitialize(); diff --git a/syncd/syncd.h b/syncd/syncd.h index 38878b773..66e802227 100644 --- a/syncd/syncd.h +++ b/syncd/syncd.h @@ -4,13 +4,19 @@ #include #include #include +#include +#include + #include +#include +#include #include "string.h" extern "C" { #include "sai.h" } +#include "common/redisclient.h" #include "common/saiserialize.h" #include "common/saiattributelist.h" #include "swss/dbconnector.h" @@ -23,27 +29,40 @@ extern "C" { #define UNREFERENCED_PARAMETER(X) -#define SYNCD_LOG_ERR(MSG, ...) swss::Logger::getInstance().write(swss::Logger::SWSS_ERROR, MSG, ##__VA_ARGS__) -#define SYNCD_LOG_WRN(MSG, ...) swss::Logger::getInstance().write(swss::Logger::SWSS_WARN, MSG, ##__VA_ARGS__) -#define SYNCD_LOG_NTC(MSG, ...) swss::Logger::getInstance().write(swss::Logger::SWSS_NOTICE, MSG, ##__VA_ARGS__) -#define SYNCD_LOG_INF(MSG, ...) swss::Logger::getInstance().write(swss::Logger::SWSS_INFO, MSG, ##__VA_ARGS__) -#define SYNCD_LOG_DBG(MSG, ...) swss::Logger::getInstance().write(swss::Logger::SWSS_DEBUG, MSG, ##__VA_ARGS__) -#define SYNCD_LOG_ENTER() SYNCD_LOG_DBG("%s: >", __FUNCTION__) -#define SYNCD_LOG_EXIT() SYNCD_LOG_DBG("%s: <", __FUNCTION__) +#define VIDTORID "VIDTORID" +#define RIDTOVID "RIDTOVID" +#define VIDCOUNTER "VIDCOUNTER" +#define LANES "LANES" +#define HIDDEN "HIDDEN" +#define DEFAULT_VIRTUAL_ROUTER_ID "DEFAULT_VIRTUAL_ROUTER_ID" +#define CPU_PORT_ID "CPU_PORT_ID" + +extern std::mutex g_mutex; + +void onSyncdStart(); +void hardReinit(); sai_object_id_t replaceVidToRid(const sai_object_id_t &virtual_object_id); +std::unordered_map redisGetVidToRidMap(); +std::unordered_map redisGetRidToVidMap(); +std::vector redisGetAsicStateKeys(); +sai_object_id_t redisGetDefaultVirtualRouterId(); +void redisClearVidToRidMap(); +void redisClearRidToVidMap(); extern swss::ConsumerTable *getRequest; extern swss::ProducerTable *getResponse; extern swss::ProducerTable *notifications; -extern swss::Table *g_vidToRid; -extern swss::Table *g_ridToVid; +extern swss::RedisClient *g_redisClient; + +sai_object_id_t redis_create_virtual_object_id( + _In_ sai_object_type_t object_type); sai_object_id_t translate_vid_to_rid( _In_ sai_object_id_t vid); -void translate_vid_to_rid( +void translate_vid_to_rid_list( _In_ sai_object_type_t object_type, _In_ uint32_t attr_count, _In_ sai_attribute_t *attr_list); @@ -58,6 +77,14 @@ void translate_list_vid_to_rid( } } +sai_object_id_t translate_rid_to_vid( + _In_ sai_object_id_t rid); + +void translate_rid_to_vid_list( + _In_ sai_object_type_t object_type, + _In_ uint32_t attr_count, + _In_ sai_attribute_t *attr_list); + typedef sai_status_t (*create_fn)( _Out_ sai_object_id_t *stp_id, _In_ uint32_t attr_count, @@ -108,7 +135,7 @@ extern sai_wred_api_t *sai_wred_api; extern sai_switch_notification_t switch_notifications; -extern swss::Table *vidToRid; +extern swss::DBConnector *db; void initialize_common_api_pointers(); void populate_sai_apis(); diff --git a/syncd/syncd_hard_reinit.cpp b/syncd/syncd_hard_reinit.cpp new file mode 100644 index 000000000..136476e77 --- /dev/null +++ b/syncd/syncd_hard_reinit.cpp @@ -0,0 +1,747 @@ +#include +#include +#include + +#include "syncd.h" + +typedef std::unordered_map StringHash; +typedef std::unordered_map ObjectIdMap; + +std::unordered_map> g_attributesLists; + +ObjectIdMap g_translated; + +ObjectIdMap g_vidToRidMap; +ObjectIdMap g_ridToVidMap; + +StringHash g_switches; +StringHash g_vlans; +StringHash g_neighbors; +StringHash g_oids; +StringHash g_fdbs; +StringHash g_routes; +StringHash g_traps; + +void processAttributesForOids(sai_object_type_t objectType, std::shared_ptr list); +void processSwitch(); +void processVlans(); +void processNeighbors(); +void processOids(); +void processFdbs(); +void processRoutes(); +void processTraps(); + +sai_object_type_t getObjectTypeFromAsicKey(const std::string &key); + +sai_object_type_t getObjectTypeFromVid(sai_object_id_t sai_object_id) +{ + SWSS_LOG_ENTER(); + + sai_object_type_t objectType = (sai_object_type_t)(sai_object_id >> 48); + + if (objectType >= SAI_OBJECT_TYPE_MAX || + objectType == SAI_OBJECT_TYPE_NULL) + { + SWSS_LOG_ERROR("invalid object type: %x on object id: %llx", objectType, sai_object_id); + + exit(EXIT_FAILURE); + } + + return objectType; +} + +std::shared_ptr redisGetAttributesFromAsicKey(const std::string &key) +{ + SWSS_LOG_ENTER(); + + sai_object_type_t objectType = getObjectTypeFromAsicKey(key); + + std::vector values; + + auto hash = g_redisClient->hgetall(key); + + for (auto &kv: hash) + { + const std::string &key = kv.first; + const std::string &value = kv.second; + + swss::FieldValueTuple fvt(key, value); + + values.push_back(fvt); + } + + return std::shared_ptr(new SaiAttributeList(objectType, values, false)); +} + +sai_object_type_t getObjectTypeFromAsicKey(const std::string &key) +{ + SWSS_LOG_ENTER(); + + const std::string strObjectType = key.substr(key.find_first_of(":") + 1, key.find_last_of(":")); + + int index = 0; + + sai_object_type_t objectType; + sai_deserialize_primitive(strObjectType, index, objectType); + + if (objectType >= SAI_OBJECT_TYPE_MAX || + objectType == SAI_OBJECT_TYPE_NULL) + { + SWSS_LOG_ERROR("invalid object type: %x on asic key: %s", objectType, key.c_str()); + + exit(EXIT_FAILURE); + } + + return objectType; +} + +std::string getObjectIdFromAsicKey(const std::string &key) +{ + SWSS_LOG_ENTER(); + + return key.substr(key.find_last_of(":") + 1); +} + +void redisSetVidAndRidMap(std::unordered_map map) +{ + SWSS_LOG_ENTER(); + + redisClearVidToRidMap(); + redisClearRidToVidMap(); + + for (auto &kv: map) + { + std::string strVid; + std::string strRid; + + sai_serialize_primitive(kv.first, strVid); + sai_serialize_primitive(kv.second, strRid); + + g_redisClient->hset(VIDTORID, strVid, strRid); + g_redisClient->hset(RIDTOVID, strRid, strVid); + } +} + +void checkAllIds() +{ + SWSS_LOG_ENTER(); + + for (auto &kv: g_translated) + { + auto it = g_vidToRidMap.find(kv.first); + + if (it == g_vidToRidMap.end()) + { + SWSS_LOG_ERROR("failed to find vid %llx in previous map", kv.first); + + exit(EXIT_FAILURE); + } + + g_vidToRidMap.erase(it); + } + + if (g_vidToRidMap.size() != 0) + { + SWSS_LOG_ERROR("vid to rid map is not empty after translation"); + + for (auto &kv: g_vidToRidMap) + { + sai_object_type_t objectType = getObjectTypeFromVid(kv.first); + + SWSS_LOG_ERROR("vid not translated: %llx, object type: %llx", kv.first, objectType); + } + + exit(EXIT_FAILURE); + } + + redisSetVidAndRidMap(g_translated); +} + +void hardReinit() +{ + SWSS_LOG_ENTER(); + + // repopulate asic view from redis db after hard asic initialize + + g_vidToRidMap = redisGetVidToRidMap(); + g_ridToVidMap = redisGetRidToVidMap(); + + std::vector asicStateKeys = redisGetAsicStateKeys(); + + for (auto &key: asicStateKeys) + { + sai_object_type_t objectType = getObjectTypeFromAsicKey(key); + const std::string &strObjectId = getObjectIdFromAsicKey(key); + + switch (objectType) + { + case SAI_OBJECT_TYPE_ROUTE: + g_routes[strObjectId] = key; + break; + + case SAI_OBJECT_TYPE_VLAN: + g_vlans[strObjectId] = key; + break; + + case SAI_OBJECT_TYPE_FDB: + g_fdbs[strObjectId] = key; + break; + + case SAI_OBJECT_TYPE_NEIGHBOR: + g_neighbors[strObjectId] = key; + break; + + case SAI_OBJECT_TYPE_TRAP: + g_traps[strObjectId] = key; + break; + + case SAI_OBJECT_TYPE_SWITCH: + g_switches[strObjectId] = key; + break; + + default: + g_oids[strObjectId] = key; + break; + } + + g_attributesLists[key] = redisGetAttributesFromAsicKey(key); + } + + processSwitch(); + processVlans(); + processFdbs(); + processNeighbors(); + processOids(); + processRoutes(); + processTraps(); + + checkAllIds(); +} + +sai_object_id_t processSingleVid(sai_object_id_t vid) +{ + SWSS_LOG_ENTER(); + + if (vid == SAI_NULL_OBJECT_ID) + { + SWSS_LOG_DEBUG("processed VID 0 to RID 0"); + + return SAI_NULL_OBJECT_ID; + } + + auto it = g_translated.find(vid); + + if (it != g_translated.end()) + { + // this object was already processed, + // just return real object id + + SWSS_LOG_DEBUG("processed VID %llx to RID %llx", vid, it->second); + + return it->second; + } + + sai_object_id_t rid; + sai_object_type_t objectType = getObjectTypeFromVid(vid); + + std::string strVid; + sai_serialize_primitive(vid, strVid); + + bool createObject = true; + + if (objectType == SAI_OBJECT_TYPE_VIRTUAL_ROUTER) + { + auto it = g_vidToRidMap.find(vid); + + if (it == g_vidToRidMap.end()) + { + SWSS_LOG_ERROR("failed to find VID %llx in VIDTORID map", vid); + + exit(EXIT_FAILURE); + } + + sai_object_id_t virtualRouterRid = it->second; + + sai_object_id_t defaultVirtualRouterId = redisGetDefaultVirtualRouterId(); + + if (virtualRouterRid == defaultVirtualRouterId) + { + // this is default virtual router id + // we don't need to create it, just set attributes + + rid = defaultVirtualRouterId; + + createObject = false; + + SWSS_LOG_INFO("default virtual router will not be created, processed VID %llx to RID %llx", vid, rid); + } + + } + else if (objectType == SAI_OBJECT_TYPE_PORT) + { + // currently we assume that port id's don't change, + // so we can just treat previous rid as current rid + + auto it = g_vidToRidMap.find(vid); + + if (it == g_vidToRidMap.end()) + { + SWSS_LOG_ERROR("failed to find VID %llx in VIDTORID map", vid); + + exit(EXIT_FAILURE); + } + + rid = it->second; + + createObject = false; + + SWSS_LOG_INFO("port will not be created, processed VID %llx to RID %llx", vid, rid); + } + + auto oit = g_oids.find(strVid); + + if (oit == g_oids.end()) + { + SWSS_LOG_ERROR("failed to find VID %s in OIDs map", strVid.c_str()); + + exit(EXIT_FAILURE); + } + + std::string asicKey = oit->second;; + + std::shared_ptr list = g_attributesLists[asicKey]; + + processAttributesForOids(objectType, list); // recursion + + sai_attribute_t *attrList = list->get_attr_list(); + + uint32_t attrCount = list->get_attr_count(); + + if (createObject) + { + create_fn create = common_create[objectType]; + + if (create == NULL) + { + SWSS_LOG_ERROR("create function is not defined for object type %llx", objectType); + + exit(EXIT_FAILURE); + } + + sai_status_t status = create(&rid, attrCount, attrList); + + if (status != SAI_STATUS_SUCCESS) + { + SWSS_LOG_ERROR("failed to create object %llx: %d", objectType, status); + + exit(EXIT_FAILURE); + } + + SWSS_LOG_DEBUG("created object of type %x, processed VID %llx to RID %llx", objectType, vid, rid); + } + else + { + SWSS_LOG_DEBUG("setting attributes on object of type %x, processed VID %llx to RID %llx", objectType, vid, rid); + + set_attribute_fn set = common_set_attribute[objectType]; + + for (uint32_t idx = 0; idx < attrCount; idx++) + { + sai_attribute_t *attr = &attrList[idx]; + + sai_status_t status = set(rid, attr); + + if (status != SAI_STATUS_SUCCESS) + { + SWSS_LOG_ERROR("failed to set attribute for object type %llx attr id %llx: %d", objectType, attr->id, status); + + exit(EXIT_FAILURE); + } + } + } + + g_translated[vid] = rid; + + return rid; +} + +sai_attr_serialization_type_t getSerializationType(sai_object_type_t objectType, sai_attr_id_t attrId) +{ + SWSS_LOG_ENTER(); + + sai_attr_serialization_type_t serializationType; + sai_status_t status = sai_get_serialization_type(objectType, attrId, serializationType); + + if (status != SAI_STATUS_SUCCESS) + { + SWSS_LOG_ERROR("unable to find serialization type on object type %x and attr id %x", objectType, attrId); + + exit(EXIT_FAILURE); + } + + return serializationType; +} + +void processAttributesForOids(sai_object_type_t objectType, std::shared_ptr list) +{ + SWSS_LOG_ENTER(); + + SWSS_LOG_DEBUG("processing list for object type %llx", objectType); + + sai_attribute_t *attrList = list->get_attr_list(); + + uint32_t attrCount = list->get_attr_count(); + + for (uint32_t idx = 0; idx < attrCount; idx++) + { + sai_attribute_t &attr = attrList[idx]; + + sai_attr_serialization_type_t serializationType = getSerializationType(objectType, attr.id); + + uint32_t count = 0; + sai_object_id_t *objectIdList; + + switch (serializationType) + { + case SAI_SERIALIZATION_TYPE_OBJECT_ID: + count = 1; + objectIdList = &attr.value.oid; + break; + + case SAI_SERIALIZATION_TYPE_OBJECT_LIST: + count = attr.value.objlist.count; + objectIdList = attr.value.objlist.list; + break; + + case SAI_SERIALIZATION_TYPE_ACL_FIELD_DATA_OBJECT_ID: + count = 1; + objectIdList = &attr.value.aclfield.data.oid; + break; + + case SAI_SERIALIZATION_TYPE_ACL_FIELD_DATA_OBJECT_LIST: + count = attr.value.aclfield.data.objlist.count; + objectIdList = attr.value.aclfield.data.objlist.list; + break; + + case SAI_SERIALIZATION_TYPE_ACL_ACTION_DATA_OBJECT_ID: + count = 1; + objectIdList = &attr.value.aclaction.parameter.oid; + break; + + case SAI_SERIALIZATION_TYPE_ACL_ACTION_DATA_OBJECT_LIST: + count = attr.value.aclaction.parameter.objlist.count; + objectIdList = attr.value.aclaction.parameter.objlist.list; + break; + + case SAI_SERIALIZATION_TYPE_PORT_BREAKOUT: + count = attr.value.portbreakout.port_list.count; + objectIdList = attr.value.portbreakout.port_list.list; + break; + + default: + continue; + } + + // attribute contains object id's, they need to be translated + // some of them could be already translated + + for (uint32_t idx = 0; idx < count; idx++) + { + sai_object_id_t vid = objectIdList[idx]; + + sai_object_id_t rid = processSingleVid(vid); + + objectIdList[idx] = rid; + } + } +} + +sai_object_id_t getObjectIdFromString(const std::string &strObjectId) +{ + SWSS_LOG_ENTER(); + + int index = 0; + sai_object_id_t objectId; + sai_deserialize_primitive(strObjectId, index, objectId); + + return objectId; +} + +void processOids() +{ + for (auto &kv: g_oids) + { + const std::string &strObjectId = kv.first; + + sai_object_id_t vidObjectId = getObjectIdFromString(strObjectId); + + processSingleVid(vidObjectId); + } +} + +void processSwitch() +{ + SWSS_LOG_ENTER(); + + for (auto &kv: g_switches) + { + const std::string &asicKey = kv.second; + + std::shared_ptr list = g_attributesLists[asicKey]; + + processAttributesForOids(SAI_OBJECT_TYPE_SWITCH, list); + + sai_attribute_t *attrList = list->get_attr_list(); + + uint32_t attrCount = list->get_attr_count(); + + for (uint32_t idx = 0; idx < attrCount; idx++) + { + sai_attribute_t *attr = &attrList[idx]; + + sai_status_t status = sai_switch_api->set_switch_attribute(attr); + + if (status != SAI_STATUS_SUCCESS) + { + SWSS_LOG_ERROR("failed to set_switch_attribute %llx: %d", attr->id, status); + + exit(EXIT_FAILURE); + } + } + } +} + +sai_vlan_id_t getVlanIdFromString(const std::string &strVlanId) +{ + SWSS_LOG_ENTER(); + + int index = 0; + sai_vlan_id_t vlanId; + sai_deserialize_primitive(strVlanId, index, vlanId); + + return vlanId; +} + +void processVlans() +{ + SWSS_LOG_ENTER(); + + for (auto &kv: g_vlans) + { + const std::string &strVlanId = kv.first; + const std::string &asicKey = kv.second; + + sai_vlan_id_t vlanId = getVlanIdFromString(strVlanId); + + if (vlanId != 1) + { + // don't create vlan 1, we assume it exists + sai_status_t status = sai_vlan_api->create_vlan(vlanId); + + if (status != SAI_STATUS_SUCCESS) + { + SWSS_LOG_ERROR("failed to create_vlan %d: %d", vlanId, status); + + exit(EXIT_FAILURE); + } + } + + std::shared_ptr list = g_attributesLists[asicKey]; + + processAttributesForOids(SAI_OBJECT_TYPE_VLAN, list); + + sai_attribute_t *attrList = list->get_attr_list(); + + uint32_t count = list->get_attr_count(); + + for (uint32_t idx = 0; idx < count; idx++) + { + sai_attribute_t *attr = &attrList[idx]; + + sai_status_t status = sai_vlan_api->set_vlan_attribute(vlanId, attr); + + if (status != SAI_STATUS_SUCCESS) + { + SWSS_LOG_ERROR("failed to set_vlan_attribute %llx: %d", attr->id, status); + + exit(EXIT_FAILURE); + } + } + } +} + +sai_fdb_entry_t getFdbEntryFromString(const std::string &strFdbEntry) +{ + SWSS_LOG_ENTER(); + + int index = 0; + sai_fdb_entry_t fdbEntry; + sai_deserialize_primitive(strFdbEntry, index, fdbEntry); + + return fdbEntry; +} + +void processFdbs() +{ + SWSS_LOG_ENTER(); + + for (auto &kv: g_fdbs) + { + const std::string &strFdbEntry = kv.first; + const std::string &asicKey = kv.second; + + sai_fdb_entry_t fdbEntry = getFdbEntryFromString(strFdbEntry); + + std::shared_ptr list = g_attributesLists[asicKey]; + + processAttributesForOids(SAI_OBJECT_TYPE_FDB, list); + + sai_attribute_t *attrList = list->get_attr_list(); + + uint32_t attrCount = list->get_attr_count(); + + sai_status_t status = sai_fdb_api->create_fdb_entry(&fdbEntry, attrCount, attrList); + + if (status != SAI_STATUS_SUCCESS) + { + SWSS_LOG_ERROR("failed to create_fdb_entry: %d", status); + + exit(EXIT_FAILURE); + } + } +} + +sai_neighbor_entry_t getNeighborEntryFromString(const std::string &strNeighborEntry) +{ + SWSS_LOG_ENTER(); + + int index = 0; + sai_neighbor_entry_t neighborEntry; + sai_deserialize_neighbor_entry(strNeighborEntry, index, neighborEntry); + + return neighborEntry; +} + +void processNeighbors() +{ + SWSS_LOG_ENTER(); + + for (auto &kv: g_neighbors) + { + const std::string &strNeighborEntry = kv.first; + const std::string &asicKey = kv.second; + + sai_neighbor_entry_t neighborEntry = getNeighborEntryFromString(strNeighborEntry); + + neighborEntry.rif_id = processSingleVid(neighborEntry.rif_id); + + std::shared_ptr list = g_attributesLists[asicKey]; + + processAttributesForOids(SAI_OBJECT_TYPE_NEIGHBOR, list); + + sai_attribute_t *attrList = list->get_attr_list(); + + uint32_t attrCount = list->get_attr_count(); + + sai_status_t status = sai_neighbor_api->create_neighbor_entry(&neighborEntry, attrCount, attrList); + + if (status != SAI_STATUS_SUCCESS) + { + SWSS_LOG_ERROR("failed to create_neighbor_entry: %d", status); + + exit(EXIT_FAILURE); + } + } +} + +sai_unicast_route_entry_t getRouteEntryFromString(const std::string &strRouteEntry) +{ + SWSS_LOG_ENTER(); + + int index = 0; + sai_unicast_route_entry_t routeEntry; + sai_deserialize_route_entry(strRouteEntry, index, routeEntry); + + return routeEntry; +} + +void processRoutes() +{ + SWSS_LOG_ENTER(); + + for (auto &kv: g_routes) + { + const std::string &strRouteEntry = kv.first; + const std::string &asicKey = kv.second; + + sai_unicast_route_entry_t routeEntry = getRouteEntryFromString(strRouteEntry); + + routeEntry.vr_id = processSingleVid(routeEntry.vr_id); + + std::shared_ptr list = g_attributesLists[asicKey]; + + processAttributesForOids(SAI_OBJECT_TYPE_ROUTE, list); + + sai_attribute_t *attrList = list->get_attr_list(); + + uint32_t attrCount = list->get_attr_count(); + + sai_status_t status = sai_route_api->create_route(&routeEntry, attrCount, attrList); + + if (status != SAI_STATUS_SUCCESS) + { + SWSS_LOG_ERROR("failed to create_route_entry: %d", status); + + exit(EXIT_FAILURE); + } + } +} + +sai_hostif_trap_id_t getTrapIdFromString(const std::string &strObjectId) +{ + SWSS_LOG_ENTER(); + + int index = 0; + sai_object_id_t dummyId; + sai_deserialize_primitive(strObjectId, index, dummyId); + + // trap id is encoded as sai_object_id_t + sai_hostif_trap_id_t trapId = (sai_hostif_trap_id_t)dummyId; + + return trapId; +} + +void processTraps() +{ + SWSS_LOG_ENTER(); + + for (auto &kv: g_traps) + { + const std::string &strTrapId = kv.first; + const std::string &asicKey = kv.second; + + sai_hostif_trap_id_t trapId = getTrapIdFromString(strTrapId); + + std::shared_ptr list = g_attributesLists[asicKey]; + + processAttributesForOids(SAI_OBJECT_TYPE_TRAP, list); + + sai_attribute_t *attrList = list->get_attr_list(); + + uint32_t attrCount = list->get_attr_count(); + + for (uint32_t idx = 0; idx < attrCount; idx++) + { + sai_attribute_t *attr = &attrList[idx]; + + sai_status_t status = sai_hostif_api->set_trap_attribute(trapId, attr); + + if (status != SAI_STATUS_SUCCESS) + { + SWSS_LOG_ERROR("failed to set_trap_attribute %d: %d", trapId, status); + + exit(EXIT_FAILURE); + } + } + } +} diff --git a/syncd/syncd_init.cpp b/syncd/syncd_init.cpp index 0530d16f0..afe977fff 100644 --- a/syncd/syncd_init.cpp +++ b/syncd/syncd_init.cpp @@ -33,6 +33,8 @@ sai_wred_api_t *sai_wred_api; void initialize_common_api_pointers() { + SWSS_LOG_ENTER(); + common_create[SAI_OBJECT_TYPE_NULL] = NULL; common_create[SAI_OBJECT_TYPE_PORT] = NULL; common_create[SAI_OBJECT_TYPE_LAG] = sai_lag_api->create_lag; @@ -164,6 +166,8 @@ void initialize_common_api_pointers() void populate_sai_apis() { + SWSS_LOG_ENTER(); + sai_api_query(SAI_API_ACL, (void**)&sai_acl_api); sai_api_query(SAI_API_BUFFERS, (void**)&sai_buffer_api); sai_api_query(SAI_API_FDB, (void**)&sai_fdb_api); diff --git a/syncd/syncd_notifications.cpp b/syncd/syncd_notifications.cpp index c8db9ac7c..799cce617 100644 --- a/syncd/syncd_notifications.cpp +++ b/syncd/syncd_notifications.cpp @@ -5,16 +5,24 @@ void send_notification( _In_ std::string data, _In_ std::vector &entry) { + SWSS_LOG_ENTER(); + key = key + ":" + data; + SWSS_LOG_DEBUG("sending notification: %s", key.c_str()); + notifications->set(key, entry, "ntf"); notifications->del(key, "delntf"); + + SWSS_LOG_DEBUG("notification send successfull"); } void send_notification( _In_ std::string key, _In_ std::string data) { + SWSS_LOG_ENTER(); + std::vector entry; send_notification(key, data, entry); @@ -23,52 +31,155 @@ void send_notification( void on_switch_state_change( _In_ sai_switch_oper_status_t switch_oper_status) { - SYNCD_LOG_ENTER(); + std::lock_guard lock(g_mutex); + + SWSS_LOG_ENTER(); std::string s; sai_serialize_primitive(switch_oper_status, s); send_notification("switch_state_change", s); +} + +sai_fdb_entry_type_t getFdbEntryType( + _In_ uint32_t count, + _In_ const sai_attribute_t *list) +{ + for (uint32_t idx = 0; idx < count; idx++) + { + const sai_attribute_t &attr = list[idx]; + + if (attr.id == SAI_FDB_ENTRY_ATTR_TYPE) + return (sai_fdb_entry_type_t)attr.value.s32; + } + + SWSS_LOG_WARN("unknown fdb entry type"); - SYNCD_LOG_EXIT(); + return (sai_fdb_entry_type_t)-1; +} + +void redisPutFdbEntryToAsicView( + _In_ const sai_fdb_entry_t *fdbEntry, + _In_ SaiAttributeList &list) +{ + // NOTE: this fdb entry already contains translated RID to VID + + std::vector entry; + + entry = SaiAttributeList::serialize_attr_list( + SAI_OBJECT_TYPE_FDB, + list.get_attr_count(), + list.get_attr_list(), + false); + + sai_object_type_t objectType = SAI_OBJECT_TYPE_FDB; + + std::string strObjectType; + sai_serialize_primitive(objectType, strObjectType); + + std::string strFdbEntry; + sai_serialize_primitive(*fdbEntry, strFdbEntry); + + std::string key = "ASIC_STATE:" + strObjectType + ":" + strFdbEntry; + + for (const auto &e: entry) + { + const std::string &strField = fvField(e); + const std::string &strValue = fvValue(e); + + g_redisClient->hset(key, strField, strValue); + } + + // currently we need to add type manually since fdb event don't contain type + sai_attribute_t attr; + + attr.id = SAI_FDB_ENTRY_ATTR_TYPE; + attr.value.s32 = SAI_FDB_ENTRY_DYNAMIC; + + std::string strAttrValue; + + sai_status_t status = sai_serialize_attr_value(SAI_SERIALIZATION_TYPE_INT32, attr, strAttrValue, false); + + if (status != SAI_STATUS_SUCCESS) + { + SWSS_LOG_ERROR("Unable to serialize fdb entry attribute, status: %u", status); + + exit(EXIT_FAILURE); + } + + std::string strAttrType; + sai_serialize_primitive(attr.id, strAttrType); + + g_redisClient->hset(key, strAttrType, strAttrValue); } void on_fdb_event( _In_ uint32_t count, _In_ sai_fdb_event_notification_data_t *data) { - SYNCD_LOG_ENTER(); + std::lock_guard lock(g_mutex); + + SWSS_LOG_ENTER(); std::string s; sai_serialize_primitive(count, s); + SWSS_LOG_DEBUG("fdb event count: %d", count); + for (uint32_t i = 0; i < count; i++) { sai_fdb_event_notification_data_t *fdb = &data[i]; - sai_status_t status = sai_serialize_fdb_event_notification_data(fdb, s); + SWSS_LOG_DEBUG("fdb %u: type: %d", i, fdb->event_type); + + // NOTE: operate on copy to not modify sdk data + + sai_fdb_event_notification_data_t copy; + + memcpy(©, fdb, sizeof(sai_fdb_event_notification_data_t)); + + std::vector entry; + + entry = SaiAttributeList::serialize_attr_list( + SAI_OBJECT_TYPE_FDB, + copy.attr_count, + copy.attr, + false); + + SaiAttributeList list(SAI_OBJECT_TYPE_FDB, entry, false); + + translate_rid_to_vid_list(SAI_OBJECT_TYPE_FDB, list.get_attr_count(), list.get_attr_list()); + + copy.attr_count = list.get_attr_count(); + copy.attr = list.get_attr_list(); + + sai_status_t status = sai_serialize_fdb_event_notification_data(©, s); if (status != SAI_STATUS_SUCCESS) { - SYNCD_LOG_ERR("Unable to serialize fdb event, status: %u", status); + SWSS_LOG_ERROR("Unable to serialize fdb event, status: %u", status); - // we need to break here since serialized data may be inconsistent - - SYNCD_LOG_EXIT(); - return; + exit(EXIT_FAILURE); } + + // currently because of bcrm bug, we need to install fdb entries in asic view + // and currently this event don't have fdb type which is required on creation + + redisPutFdbEntryToAsicView(©.fdb_entry, list); } send_notification("fdb_event", s); - - SYNCD_LOG_EXIT(); } void on_port_state_change( _In_ uint32_t count, _In_ sai_port_oper_status_notification_t *data) { - SYNCD_LOG_ENTER(); + std::lock_guard lock(g_mutex); + + SWSS_LOG_ENTER(); + + SWSS_LOG_DEBUG("port notification count: %u", count); std::string s; sai_serialize_primitive(count, s); @@ -76,19 +187,27 @@ void on_port_state_change( for (uint32_t i = 0; i < count; i++) { sai_port_oper_status_notification_t *oper_stat = &data[i]; - sai_serialize_primitive(oper_stat, s); + + // NOTE: make a copy to not modify sdk values + sai_port_oper_status_notification_t copy; + + memcpy(©, oper_stat, sizeof(sai_port_oper_status_notification_t)); + + copy.port_id = translate_rid_to_vid(copy.port_id); + + sai_serialize_primitive(copy, s); } send_notification("port_state_change", s); - - SYNCD_LOG_EXIT(); } void on_port_event( _In_ uint32_t count, _In_ sai_port_event_notification_t *data) { - SYNCD_LOG_ENTER(); + std::lock_guard lock(g_mutex); + + SWSS_LOG_ENTER(); std::string s; sai_serialize_primitive(count, s); @@ -96,21 +215,27 @@ void on_port_event( for (uint32_t i = 0; i < count; i++) { sai_port_event_notification_t *port_event = &data[i]; - sai_serialize_primitive(port_event, s); + + // NOTE: make a copy to not modify sdk values + sai_port_event_notification_t copy; + + memcpy(©, port_event, sizeof(sai_port_event_notification_t)); + + copy.port_id = translate_rid_to_vid(copy.port_id); + + sai_serialize_primitive(copy, s); } send_notification("port_event", s); - - SYNCD_LOG_EXIT(); } void on_switch_shutdown_request() { - SYNCD_LOG_ENTER(); + std::lock_guard lock(g_mutex); - send_notification("switch_shutdown_request", ""); + SWSS_LOG_ENTER(); - SYNCD_LOG_EXIT(); + send_notification("switch_shutdown_request", ""); } void on_packet_event( @@ -119,7 +244,9 @@ void on_packet_event( _In_ uint32_t attr_count, _In_ const sai_attribute_t *attr_list) { - SYNCD_LOG_ENTER(); + std::lock_guard lock(g_mutex); + + SWSS_LOG_ENTER(); std::string s; sai_serialize_primitive(buffer_size, s); @@ -134,9 +261,20 @@ void on_packet_event( attr_list, false); - send_notification("packet_event", s, entry); + // since attr_list is const, we can't replace rid's + // we need to create copy of that list + + SaiAttributeList copy(SAI_OBJECT_TYPE_PACKET, entry, false); - SYNCD_LOG_EXIT(); + translate_rid_to_vid_list(SAI_OBJECT_TYPE_PACKET, copy.get_attr_count(), copy.get_attr_list()); + + entry = SaiAttributeList::serialize_attr_list( + SAI_OBJECT_TYPE_PACKET, + copy.get_attr_count(), + copy.get_attr_list(), + false); + + send_notification("packet_event", s, entry); } sai_switch_notification_t switch_notifications diff --git a/syncd/syncd_reinit.cpp b/syncd/syncd_reinit.cpp new file mode 100644 index 000000000..fae67d39a --- /dev/null +++ b/syncd/syncd_reinit.cpp @@ -0,0 +1,558 @@ +#include +#include +#include + +#include "syncd.h" + +sai_uint32_t saiGetPortCount() +{ + SWSS_LOG_ENTER(); + + sai_attribute_t attr; + + attr.id = SAI_SWITCH_ATTR_PORT_NUMBER; + + sai_status_t status = sai_switch_api->get_switch_attribute(1, &attr); + + if (status != SAI_STATUS_SUCCESS) + { + SWSS_LOG_ERROR("failed to get port number: %d", status); + + exit(EXIT_FAILURE); + } + + SWSS_LOG_DEBUG("port count is %u", attr.value.u32); + + return attr.value.u32; +} + +sai_object_id_t saiGetCpuId() +{ + SWSS_LOG_ENTER(); + + sai_attribute_t attr; + + attr.id = SAI_SWITCH_ATTR_CPU_PORT; + + sai_status_t status = sai_switch_api->get_switch_attribute(1, &attr); + + if (status != SAI_STATUS_SUCCESS) + { + SWSS_LOG_ERROR("failed to get cpu port: %d", status); + + exit(EXIT_FAILURE); + } + + SWSS_LOG_DEBUG("cpu port RID %llx", attr.value.oid); + + return attr.value.oid; +} + +std::vector saiGetPortList() +{ + SWSS_LOG_ENTER(); + + uint32_t portCount = saiGetPortCount(); + + std::vector portList; + + portList.resize(portCount); + + sai_attribute_t attr; + + attr.id = SAI_SWITCH_ATTR_PORT_LIST; + attr.value.objlist.count = portCount; + attr.value.objlist.list = portList.data(); + + sai_status_t status = sai_switch_api->get_switch_attribute(1, &attr); + + if (status != SAI_STATUS_SUCCESS) + { + SWSS_LOG_ERROR("failed to get port list: %d", status); + + exit(EXIT_FAILURE); + } + + return portList; +} + +std::unordered_map saiGetHardwareLaneMap() +{ + SWSS_LOG_ENTER(); + + std::unordered_map map; + + const std::vector portList = saiGetPortList(); + + // NOTE: currently we don't support port breakout + // this will need to be addressed in future + const int lanesPerPort = 4; + + for (size_t i = 0; i < portList.size(); i++) + { + sai_uint32_t lanes[lanesPerPort]; + + sai_attribute_t attr; + + attr.id = SAI_PORT_ATTR_HW_LANE_LIST; + attr.value.u32list.count = lanesPerPort; + attr.value.u32list.list = lanes; + + sai_status_t status = sai_port_api->get_port_attribute(portList[i], 1, &attr); + + if (status != SAI_STATUS_SUCCESS) + { + SWSS_LOG_ERROR("failed to get hardware lane list pid: %lx: %d", portList[i], status); + + exit(EXIT_FAILURE); + } + + for (int j = 0; j < lanesPerPort; j++) + { + map[lanes[j]] = portList[i]; + } + } + + return map; +} + +sai_object_id_t saiGetDefaultVirtualRouter() +{ + SWSS_LOG_ENTER(); + + sai_attribute_t attr; + + attr.id = SAI_SWITCH_ATTR_DEFAULT_VIRTUAL_ROUTER_ID; + + sai_status_t status = sai_switch_api->get_switch_attribute(1, &attr); + + if (status != SAI_STATUS_SUCCESS) + { + SWSS_LOG_ERROR("failed to get switch virtual router id %d", status); + + exit(EXIT_FAILURE); + } + + return attr.value.oid; +} + +void redisClearLaneMap() +{ + SWSS_LOG_ENTER(); + + g_redisClient->del(LANES); +} + +std::unordered_map redisGetLaneMap() +{ + SWSS_LOG_ENTER(); + + auto hash = g_redisClient->hgetall(LANES); + + SWSS_LOG_DEBUG("previous lanes: %lu", hash.size()); + + std::unordered_map map; + + for (auto &kv: hash) + { + const std::string &str_key = kv.first; + const std::string &str_value = kv.second; + + sai_uint32_t lane; + sai_object_id_t portId; + + int index = 0; + + sai_deserialize_primitive(str_key, index, lane); + + index = 0; + + sai_deserialize_primitive(str_value, index, portId); + + map[lane] = portId; + } + + return map; +} + +void redisSaveLaneMap(const std::unordered_map &map) +{ + SWSS_LOG_ENTER(); + + redisClearLaneMap(); + + for (auto const &it: map) + { + sai_uint32_t lane = it.first; + sai_object_id_t portId = it.second; + + std::string strLane; + std::string strPortId; + + sai_serialize_primitive(lane, strLane); + sai_serialize_primitive(portId, strPortId); + + // TODO use multi or hmset + g_redisClient->hset(LANES, strLane, strPortId); + } +} + +std::vector redisGetAsicStateKeys() +{ + SWSS_LOG_ENTER(); + + return g_redisClient->keys("ASIC_STATE:*"); +} + +void redisClearVidToRidMap() +{ + SWSS_LOG_ENTER(); + + g_redisClient->del(VIDTORID); +} + +void redisClearRidToVidMap() +{ + SWSS_LOG_ENTER(); + + g_redisClient->del(RIDTOVID); +} + +std::unordered_map redisGetObjectMap(std::string key) +{ + SWSS_LOG_ENTER(); + + auto hash = g_redisClient->hgetall(key); + + std::unordered_map map; + + for (auto &kv: hash) + { + const std::string &str_key = kv.first; + const std::string &str_value = kv.second; + + sai_object_id_t objectIdKey; + sai_object_id_t objectIdValue; + + int index = 0; + + sai_deserialize_primitive(str_key, index, objectIdKey); + + index = 0; + + sai_deserialize_primitive(str_value, index, objectIdValue); + + map[objectIdKey] = objectIdValue; + } + + return map; +} + +std::unordered_map redisGetVidToRidMap() +{ + SWSS_LOG_ENTER(); + + return redisGetObjectMap(VIDTORID); +} + +std::unordered_map redisGetRidToVidMap() +{ + SWSS_LOG_ENTER(); + + return redisGetObjectMap(RIDTOVID); +} + +void helperCheckLaneMap() +{ + SWSS_LOG_ENTER(); + + auto redisLaneMap = redisGetLaneMap(); + + auto laneMap = saiGetHardwareLaneMap(); + + if (redisLaneMap.size() == 0) + { + SWSS_LOG_INFO("no lanes defined in redis, seems like it is first syncd start"); + + // TODO put ports to db ? + redisSaveLaneMap(laneMap); + + redisLaneMap = laneMap; // copy + } + + if (laneMap.size() != redisLaneMap.size()) + { + SWSS_LOG_ERROR("lanes map size differ: %lu vs %lu", laneMap.size(), redisLaneMap.size()); + + exit(EXIT_FAILURE); + } + + for (auto kv: laneMap) + { + sai_uint32_t lane = kv.first; + sai_object_id_t portId = kv.second; + + if (redisLaneMap.find(lane) == redisLaneMap.end()) + { + SWSS_LOG_ERROR("lane %u not found in redis", lane); + + exit(EXIT_FAILURE); + } + + if (redisLaneMap[lane] != portId) + { + // if this happens, we need to remap VIDTORID and RIDTOVID + SWSS_LOG_ERROR("FIXME: lane port id differs: %llx vs %llx, port ids must be remapped", portId, redisLaneMap[lane]); + + exit(EXIT_FAILURE); + } + } +} + +sai_object_id_t redisGetDefaultVirtualRouterId() +{ + SWSS_LOG_ENTER(); + + auto redisVrId = g_redisClient->hget(HIDDEN, DEFAULT_VIRTUAL_ROUTER_ID); + + if (redisVrId == NULL) + return SAI_NULL_OBJECT_ID; + + sai_object_id_t vr_id; + + int index = 0; + + sai_deserialize_primitive(*redisVrId, index, vr_id); + + return vr_id; +} + +sai_object_id_t redisGetCpuId() +{ + SWSS_LOG_ENTER(); + + auto redisCpuId = g_redisClient->hget(HIDDEN, CPU_PORT_ID); + + if (redisCpuId == NULL) + return SAI_NULL_OBJECT_ID; + + sai_object_id_t cpuId; + + int index = 0; + + sai_deserialize_primitive(*redisCpuId, index, cpuId); + + return cpuId; +} + +void redisSetDefaultVirtualRouterId(sai_object_id_t vr_id) +{ + SWSS_LOG_ENTER(); + + std::string strVrId; + + sai_serialize_primitive(vr_id, strVrId); + + g_redisClient->hset(HIDDEN, DEFAULT_VIRTUAL_ROUTER_ID, strVrId); +} + +void redisCreateRidAndVidMapping(sai_object_id_t rid, sai_object_id_t vid) +{ + SWSS_LOG_ENTER(); + + std::string strRid, strVid; + + sai_serialize_primitive(rid, strRid); + sai_serialize_primitive(vid, strVid); + + g_redisClient->hset(VIDTORID, strVid, strRid); + g_redisClient->hset(RIDTOVID, strRid, strVid); + + SWSS_LOG_DEBUG("set VID %llx and RID %llx", vid, rid); +} + +void redisSetDummyAsicStateForRealObjectId(sai_object_id_t rid) +{ + SWSS_LOG_ENTER(); + + sai_object_type_t objectType = sai_object_type_query(rid); + + if (objectType == SAI_OBJECT_TYPE_NULL) + { + SWSS_LOG_ERROR("sai_object_type_query returned NULL type for RID %llx", rid); + + exit(EXIT_FAILURE); + } + + std::string strObjectType; + + sai_serialize_primitive(objectType, strObjectType); + + sai_object_id_t vid = redis_create_virtual_object_id(objectType); + + std::string strVid; + + sai_serialize_primitive(vid, strVid); + + std::string strKey = "ASIC_STATE:" + strObjectType + ":" + strVid; + + g_redisClient->hset(strKey, "NULL", "NULL"); + + redisCreateRidAndVidMapping(rid, vid); +} + +void helperCheckVirtualRouterId() +{ + SWSS_LOG_ENTER(); + + sai_object_id_t vrId = saiGetDefaultVirtualRouter(); + + sai_object_id_t redisVrId = redisGetDefaultVirtualRouterId(); + + if (redisVrId == SAI_NULL_OBJECT_ID) + { + redisSetDummyAsicStateForRealObjectId(vrId); + + SWSS_LOG_INFO("redis default virtual router id is not defined yet"); + + redisSetDefaultVirtualRouterId(vrId); + + redisVrId = vrId; + } + + if (vrId != redisVrId) + { + // if this happens, we need to remap VIDTORID and RIDTOVID + SWSS_LOG_ERROR("FIXME: default virtual router id differs: %llx vs %llx, ids must be remapped", vrId, redisVrId); + + exit(EXIT_FAILURE); + } +} + +void redisSetCpuId(sai_object_id_t cpuId) +{ + SWSS_LOG_ENTER(); + + std::string strCpuId; + + sai_serialize_primitive(cpuId, strCpuId); + + g_redisClient->hset(HIDDEN, CPU_PORT_ID, strCpuId); +} + +void helperCheckCpuId() +{ + SWSS_LOG_ENTER(); + + sai_object_id_t cpuId = saiGetCpuId(); + + sai_object_id_t redisCpuId = redisGetCpuId(); + + if (redisCpuId == SAI_NULL_OBJECT_ID) + { + redisSetDummyAsicStateForRealObjectId(cpuId); + + SWSS_LOG_INFO("redis cpu id is not defined yet"); + + redisSetCpuId(cpuId); + + redisCpuId = cpuId; + } + + if (cpuId != redisCpuId) + { + // if this happens, we need to remap VIDTORID and RIDTOVID + SWSS_LOG_ERROR("FIXME: cpu id differs: %llx vs %llx, ids must be remapped", cpuId, redisCpuId); + + exit(EXIT_FAILURE); + } +} + +void helperCheckPortIds() +{ + SWSS_LOG_ENTER(); + + // we need lock here since after initialization + // some notifications may appear and it may cause + // race condition for port id generation + std::lock_guard lock(g_mutex); + + // it may happen that after initialize we will receive + // some port notifications with port'ids that are not in + // redis db yet, so after checking VIDTORID map there will + // be entries and translate_vid_to_rid will generate new + // id's for ports + + auto laneMap = saiGetHardwareLaneMap(); + + for (auto kv: laneMap) + { + sai_object_id_t portId = kv.second; + + // translate will create entry if missing + // we assume here that port numbers didn't changed + // during restarts + sai_object_id_t vid = translate_rid_to_vid(portId); + + sai_object_type_t objectType = sai_object_type_query(portId); + + if (objectType == SAI_OBJECT_TYPE_NULL) + { + SWSS_LOG_ERROR("sai_object_type_query returned NULL type for RID %llx", portId); + + exit(EXIT_FAILURE); + } + + std::string strObjectType; + + sai_serialize_primitive(objectType, strObjectType); + + std::string strVid; + + sai_serialize_primitive(vid, strVid); + + std::string strKey = "ASIC_STATE:" + strObjectType + ":" + strVid; + + g_redisClient->hset(strKey, "NULL", "NULL"); + } +} + +void helperCheckVlanId() +{ + SWSS_LOG_ENTER(); + + // TODO create vlan entry only when its hard restart + + sai_object_type_t objectType = SAI_OBJECT_TYPE_VLAN; + + std::string strObjectType; + + sai_serialize_primitive(objectType, strObjectType); + + std::string strVlanId; + + sai_vlan_id_t vlanId = 1; + + sai_serialize_primitive(vlanId, strVlanId); + + std::string strKey = "ASIC_STATE:" + strObjectType + ":" + strVlanId; + + g_redisClient->hset(strKey, "NULL", "NULL"); +} + +void onSyncdStart() +{ + SWSS_LOG_ENTER(); + + helperCheckLaneMap(); + + helperCheckCpuId(); + + helperCheckVirtualRouterId(); + + helperCheckVlanId(); + + helperCheckPortIds(); + + hardReinit(); +}