Link event damping feature

lib/ClientSai.cpp

@@ -240,7 +240,8 @@ sai_status_t ClientSai::set(
     SWSS_LOG_ENTER();
     REDIS_CHECK_API_INITIALIZED();
 
-    if (RedisRemoteSaiInterface::isRedisAttribute(objectType, attr))
+    if (RedisRemoteSaiInterface::isRedisAttribute(objectType, attr) ||
+        RedisRemoteSaiInterface::isRedisPortAttribute(objectType, attr))
     {
         SWSS_LOG_ERROR("sairedis extension attributes are not supported in CLIENT mode");
 

lib/RedisRemoteSaiInterface.cpp

@@ -532,6 +532,83 @@ sai_status_t RedisRemoteSaiInterface::setRedisExtensionAttribute(
     return SAI_STATUS_FAILURE;
 }
 
+sai_status_t RedisRemoteSaiInterface::setLinkEventDampingConfig(
+        _In_ sai_object_type_t objectType,
+        _In_ sai_object_id_t objectId,
+        _In_ const std::vector<swss::FieldValueTuple> &values)
+{
+    SWSS_LOG_ENTER();
+
+    std::string key = sai_serialize_object_type(objectType) + ":" + sai_serialize_object_id(objectId);
+
+    m_communicationChannel->set(key, values, REDIS_ASIC_STATE_COMMAND_DAMPING_CONFIG_SET);
+
+    if (m_syncMode)
+    {
+        swss::KeyOpFieldsValuesTuple kco;
+        auto status = m_communicationChannel->wait(REDIS_ASIC_STATE_COMMAND_DAMPING_CONFIG_SET, kco);
+
+        m_recorder->recordGenericSetResponse(status);
+
+        return status;
+    }
+
+    return SAI_STATUS_SUCCESS;
+}
+
+sai_status_t RedisRemoteSaiInterface::setRedisPortExtensionAttribute(
+        _In_ sai_object_type_t objectType,
+        _In_ sai_object_id_t objectId,
+        _In_ const sai_attribute_t *attr)
+{
+    SWSS_LOG_ENTER();
+
+    if (attr == nullptr)
+    {
+        SWSS_LOG_ERROR("attr pointer is null");
+
+        return SAI_STATUS_INVALID_PARAMETER;
+    }
+
+    std::string str_attr_id = sai_serialize_redis_port_attr_id(
+            static_cast<sai_redis_port_attr_t>(attr->id));
+
+    switch (attr->id)
+    {
+        case SAI_REDIS_PORT_ATTR_LINK_EVENT_DAMPING_ALGORITHM:
+        {
+            std::string str_attr_value = sai_serialize_redis_link_event_damping_algorithm(
+                    static_cast<sai_redis_link_event_damping_algorithm_t>(attr->value.s32));
+
+            return setLinkEventDampingConfig(
+                    objectType, objectId, {swss::FieldValueTuple(str_attr_id, str_attr_value)});
+        }
+        case SAI_REDIS_PORT_ATTR_LINK_EVENT_DAMPING_ALGO_AIED_CONFIG:
+        {
+            sai_redis_link_event_damping_algo_aied_config_t *config =
+                    (sai_redis_link_event_damping_algo_aied_config_t *)attr->value.ptr;
+
+            if (config == NULL)
+            {
+                SWSS_LOG_ERROR("invalid link damping config attr value NULL");
+
+                return SAI_STATUS_INVALID_PARAMETER;
+            }
+
+            std::string str_attr_value = sai_serialize_redis_link_event_damping_aied_config(*config);
+
+            return setLinkEventDampingConfig(
+                    objectType, objectId, {swss::FieldValueTuple(str_attr_id, str_attr_value)});
+        }
+        default:
+            break;
+    }
+
+    SWSS_LOG_ERROR("unknown redis port extension attribute: %d", attr->id);
+
+    return SAI_STATUS_INVALID_PARAMETER;
+}
+
 bool RedisRemoteSaiInterface::isSaiS8ListValidString(
         _In_ const sai_s8_list_t &s8list)
 {
@@ -666,6 +743,11 @@ sai_status_t RedisRemoteSaiInterface::set(
         return setRedisExtensionAttribute(objectType, objectId, attr);
     }
 
+    if (RedisRemoteSaiInterface::isRedisPortAttribute(objectType, attr))
+    {
+        return setRedisPortExtensionAttribute(objectType, objectId, attr);
+    }
+
     auto status = set(
             objectType,
             sai_serialize_object_id(objectId),
@@ -2201,6 +2283,20 @@ bool RedisRemoteSaiInterface::isRedisAttribute(
     return true;
 }
 
+bool RedisRemoteSaiInterface::isRedisPortAttribute(
+        _In_ sai_object_type_t objectType,
+        _In_ const sai_attribute_t* attr)
+{
+    SWSS_LOG_ENTER();
+
+    if ((objectType != SAI_OBJECT_TYPE_PORT) || (attr == nullptr) || (attr->id < SAI_PORT_ATTR_CUSTOM_RANGE_START) || (attr->id >= SAI_PORT_ATTR_EXTENSIONS_RANGE_BASE))
+    {
+        return false;
+    }
+
+    return true;
+}
+
 void RedisRemoteSaiInterface::handleNotification(
         _In_ const std::string &name,
         _In_ const std::string &serializedNotification,

lib/RedisRemoteSaiInterface.h

@@ -231,6 +231,15 @@ namespace sairedis
                     _In_ sai_object_id_t switchId,
                     _In_ const sai_attribute_t* attr);
 
+            /**
+             * @brief Checks whether attribute is custom SAI_REDIS_PORT attribute.
+             *
+             * This function should only be used on port_api set function.
+             */
+            static bool isRedisPortAttribute(
+                    _In_ sai_object_type_t objectType,
+                    _In_ const sai_attribute_t* attr);
+
             void setMeta(
                     _In_ std::weak_ptr<saimeta::Meta> meta);
 
@@ -401,6 +410,11 @@ namespace sairedis
                     _In_ sai_object_id_t objectId,
                     _In_ const sai_attribute_t *attr);
 
+            sai_status_t setRedisPortExtensionAttribute(
+                    _In_ sai_object_type_t objectType,
+                    _In_ sai_object_id_t objectId,
+                    _In_ const sai_attribute_t *attr);
+
             bool isSaiS8ListValidString(
                     _In_ const sai_s8_list_t &s8list);
 
@@ -428,6 +442,11 @@ namespace sairedis
                     _In_ sai_object_id_t switchId,
                     _In_ const sai_attribute_t *attr);
 
+            sai_status_t setLinkEventDampingConfig(
+                    _In_ sai_object_type_t objectType,
+                    _In_ sai_object_id_t objectId,
+                    _In_ const std::vector<swss::FieldValueTuple> &values);
+
             void clear_local_state();
 
             sai_switch_notifications_t processNotification(

lib/Sai.cpp

@@ -251,6 +251,12 @@ sai_status_t Sai::set(
 
     REDIS_CHECK_CONTEXT(objectId);
 
+    if (RedisRemoteSaiInterface::isRedisPortAttribute(objectType, attr))
+    {
+        // skip metadata if attribute is redis extension port attribute.
+        return context->m_redisSai->set(objectType, objectId, attr);
+    }
+
     return context->m_meta->set(objectType, objectId, attr);
 }
 

lib/sairediscommon.h

@@ -52,6 +52,8 @@
 #define REDIS_ASIC_STATE_COMMAND_OBJECT_TYPE_GET_AVAILABILITY_QUERY     "object_type_get_availability_query"
 #define REDIS_ASIC_STATE_COMMAND_OBJECT_TYPE_GET_AVAILABILITY_RESPONSE  "object_type_get_availability_response"
 
+#define REDIS_ASIC_STATE_COMMAND_DAMPING_CONFIG_SET    "link_event_damping_config_set"
+
 #define REDIS_FLEX_COUNTER_COMMAND_START_POLL       "start_poll"
 #define REDIS_FLEX_COUNTER_COMMAND_STOP_POLL        "stop_poll"
 #define REDIS_FLEX_COUNTER_COMMAND_SET_GROUP        "set_counter_group"

syncd/NotificationProcessor.cpp

@@ -18,8 +18,10 @@ using namespace saimeta;
 NotificationProcessor::NotificationProcessor(
         _In_ std::shared_ptr<NotificationProducerBase> producer,
         _In_ std::shared_ptr<BaseRedisClient> client,
-        _In_ std::function<void(const swss::KeyOpFieldsValuesTuple&)> synchronizer):
+        _In_ std::function<void(const swss::KeyOpFieldsValuesTuple&)> synchronizer,
+        _In_ std::function<bool(sai_object_id_t, sai_port_oper_status_t)> linkEventDampingApplier):
     m_synchronizer(synchronizer),
+    m_linkEventDampingApplier(linkEventDampingApplier),
     m_client(client),
     m_notifications(producer)
 {
@@ -494,6 +496,9 @@ void NotificationProcessor::process_on_port_state_change(
 
     SWSS_LOG_DEBUG("port notification count: %u", count);
 
+    // Vector to store filtered notifications (after damping applied)
+    std::vector<sai_port_oper_status_notification_t> filtered_notifications;
+
     for (uint32_t i = 0; i < count; i++)
     {
         sai_port_oper_status_notification_t *oper_stat = &data[i];
@@ -520,14 +525,43 @@ void NotificationProcessor::process_on_port_state_change(
          * Port may be in process of removal. OA may receive notification for VID either
          * SAI_NULL_OBJECT_ID or non exist at time of processing
          */
+        SWSS_LOG_INFO("Port VID %s state change notification: %s",
+                sai_serialize_object_id(oper_stat->port_id).c_str(),
+                sai_serialize_port_oper_status(oper_stat->port_state).c_str());
 
-        SWSS_LOG_INFO("Port VID %s state change notification",
-                sai_serialize_object_id(oper_stat->port_id).c_str());
-    }
+        // Apply link event damping if configured
+        bool should_suppress = false;
+        if (m_linkEventDampingApplier != nullptr && oper_stat->port_id != SAI_NULL_OBJECT_ID)
+        {
+            should_suppress = m_linkEventDampingApplier(oper_stat->port_id, oper_stat->port_state);
+        }
 
-    std::string s = sai_serialize_port_oper_status_ntf(count, data);
+        if (!should_suppress)
+        {
+            // Add to filtered notifications
+            filtered_notifications.push_back(*oper_stat);
+            SWSS_LOG_INFO("Port state change PROPAGATED: %s -> %s",
+                    sai_serialize_object_id(oper_stat->port_id).c_str(),
+                    sai_serialize_port_oper_status(oper_stat->port_state).c_str());
+        }
+        else
+        {
+            SWSS_LOG_INFO("Port state change SUPPRESSED by damping: %s -> %s",
+                    sai_serialize_object_id(oper_stat->port_id).c_str(),
+                    sai_serialize_port_oper_status(oper_stat->port_state).c_str());
+        }
+    }
 
-    sendNotification(SAI_SWITCH_NOTIFICATION_NAME_PORT_STATE_CHANGE, s);
+    // Send only non-suppressed (filtered) notifications
+    if (!filtered_notifications.empty())
+    {
+        std::string s = sai_serialize_port_oper_status_ntf((uint32_t)filtered_notifications.size(), filtered_notifications.data());
+        sendNotification(SAI_SWITCH_NOTIFICATION_NAME_PORT_STATE_CHANGE, s);
+    }
+    else
+    {
+        SWSS_LOG_DEBUG("All port state changes were suppressed by damping, no notification sent");
+    }
 }
 
 void NotificationProcessor::process_on_bfd_session_state_change(

syncd/NotificationProcessor.h

@@ -22,7 +22,8 @@ namespace syncd
             NotificationProcessor(
                     _In_ std::shared_ptr<NotificationProducerBase> producer,
                     _In_ std::shared_ptr<BaseRedisClient> client,
-                    _In_ std::function<void(const swss::KeyOpFieldsValuesTuple&)> synchronizer);
+                    _In_ std::function<void(const swss::KeyOpFieldsValuesTuple&)> synchronizer,
+                    _In_ std::function<bool(sai_object_id_t, sai_port_oper_status_t)> linkEventDampingApplier = nullptr);
 
             virtual ~NotificationProcessor();
 
@@ -211,6 +212,12 @@ namespace syncd
 
             std::function<void(const swss::KeyOpFieldsValuesTuple&)> m_synchronizer;
 
+            /**
+             * @brief Callback function to apply link event damping to port state changes
+             * Returns true if notification should be suppressed, false if it should be propagated
+             */
+            std::function<bool(sai_object_id_t, sai_port_oper_status_t)> m_linkEventDampingApplier;
+
             std::shared_ptr<BaseRedisClient> m_client;
 
             std::shared_ptr<NotificationProducerBase> m_notifications;