--- ./source/private_module/drm/feature/slow_disk_detect/drm_slow_disk_detect.c	2018-03-21 09:07:29.000000000 +0000
+++ ./source/private_module/drm/feature/slow_disk_detect/drm_slow_disk_detect.c.hotpatch	2022-05-12 15:35:05.000000000 +0000
@@ -23,13 +23,13 @@
 #include "config/db/db_bdm.h"
 
 MODULE_ID(PID_BDM);
-
-/*lint -e754*/
-
 /*궨*/  
 #define MAX_DRM_ZONE_NUM  100          /*ǰĬZONEΪ100*/
 
-//#define DRM_SLOW_DISK_DETECT_MILLISEC (5000)  /*ǰĬ5Sһ*/
+
+extern uint32_t g_drmConfigAverageDelay[DISK_TYPE_BUTT];
+
+
 
 #define SAS_CARD_ID_NO_MASK 0xffffff00
 #define SAS_CARD_ID(PortId)    ((PortId) & SAS_CARD_ID_NO_MASK)
@@ -1425,7 +1425,7 @@
     
     return;
 }
-
+void DrmConfigAverageDelayAndPermitCntInitSph039(void);
 /**************************************************************************
 :drmSlowDiskDetectLocalHandler
 :  ʱӲǷΪ׼̴
@@ -1441,7 +1441,7 @@
     uint32_t index = 0;
     uint32_t zoneAvgTime = 0;
     uint8_t triggerFlag = 0;
-    
+    DrmConfigAverageDelayAndPermitCntInitSph039();
     /*Begin Modified by m90005436 ALMCR2018010319670125 2018.01.11*/
     drmSlowDiskSilenceCheck();
     /*End Modified by m90005436 ALMCR2018010319670125 2018.01.11*/
@@ -1661,7 +1661,7 @@
     {
         return minThresholdValue;
     }
-    return GET_SLOW_DISK_MIN_SVCTM_BASE(devInfo.zoneDiskType);
+    return g_drmConfigAverageDelay[devInfo.zoneDiskType];
 }
 /**************************************************************************
 :drmFreeSlowDiskDectAllocatedPartition
--- ./source/private_module/drm/feature/slow_disk_detect/drm_slow_disk_detect_debug.c	2018-03-21 09:07:29.000000000 +0000
+++ ./source/private_module/drm/feature/slow_disk_detect/drm_slow_disk_detect_debug.c.hotpatch	2022-05-18 03:10:44.000000000 +0000
@@ -17,12 +17,12 @@
 #include "bdm_common.h"
 
 MODULE_ID(PID_BDM);
-
-//extern DRM_SLOW_DETECT_POOL_ID_S g_zonePoolId;
+#include "customize.h"
+#include "econf.h"
 extern ALL_ZONE_INFO_S g_allZoneInfo;      /*zoneܼ*/
 extern SLOW_DISK_SPIN_LOCK_LIST_HEAD_S g_preSlowDiskEventList;
-/*ȫֱ*/
-//extern CCDB_DISK_SLOW_DETECT_CONFIG_S g_drmSlowDiskFeatureConfig;
+
+
 extern CCDB_DISK_SLOW_RECORD_LIST_S g_drmSlowDiskRecordList;
 extern spinlock_t g_drmSlowDiskRecordSpinlock;    /*  */
 extern uint32_t g_drmConfigWeightLen;
@@ -1050,8 +1050,8 @@
 
     drmSlowDiskDoDbgSetDiskDiagDetectInfoById(logicId, idx, diagJiffies);
 }
-
-
+void drmSlowDiskDoDbgSetDiskDelaythresholdTimeSph039(uint32_t diskType, uint32_t times);
+int32_t DrmQslowUpdateOneConfigDataSph039(char *itemName, uint32_t value);
 void drmSlowDiskDoDbgClearDiagDetectInfo(int32_t argc, char *argv[])
 {
     struct list_head *pos = NULL;
@@ -1082,47 +1082,47 @@
     spin_unlock(&g_diskDiagInfoList.listLock);
     DBG_PrintBuf("success to clear disk diagnose detect info!cnt:%u\n", diskCnt);
 }
-
+void drmSlowDiskDoDbgSetPermitCountSph039(uint32_t permitCnt);
 void drmSlowDiskDoDbgSetDiskDiagDetectPermitCnt(int32_t argc, char *argv[])
 {
     int32_t ret = 0;
     DBG_OPT_S opt = {0};
     uint32_t permitCnt = INVALID_VALUE32;
+    uint32_t diskTyle = DISK_TYPE_BUTT;
+    uint32_t times = INVALID_VALUE32;
+    uint16_t opType = 0;
     
-    if (argc < 3)
-    {
+    if (argc < 3) {
         DBG_ShowUsageAndErrMsg(NULL);
-        return;
-    }
-    
-    while ((ret = DBG_GetOpt(argc - 1, &argv[1], "c:", &opt)) != -1)
-    {
-        if ('c' == ret)
-        {
+		return;
+	}
+    while ((ret = DBG_GetOpt(argc - 1, &argv[1], "c:d:t:", &opt)) != -1){
+        if ('c' == ret) {
             permitCnt = (uint32_t)LVOS_StrToU64(opt.szOptArg);
-        }
-        else
-        {
+            opType = 1;
+        } else if (ret == 'd'){
+            opType = 2;
+            diskTyle = (uint32_t)LVOS_StrToU64(opt.szOptArg);
+        } else if (ret == 't'){
+            times = (uint32_t)LVOS_StrToU64(opt.szOptArg);
+        } else {
             DBG_ShowUsageAndErrMsg("%s", opt.szErrMsg);
             return;
         }
     }
-
-    if (INVALID_VALUE32 == permitCnt)
-    {
-        DBG_ShowUsageAndErrMsg("%s", opt.szErrMsg);
-        return;        
-    }
-
-    g_slowDiskDiagAllowCnt = permitCnt;
-    DBG_PrintBuf("slow disk diagnose detect permit count:%u\n", g_slowDiskDiagAllowCnt);
+    if (opType == 1) {
+        drmSlowDiskDoDbgSetPermitCountSph039(permitCnt);
+    } 
+    if (opType == 2) {
+        drmSlowDiskDoDbgSetDiskDelaythresholdTimeSph039(diskTyle, times);
+    }   
 }
-
+void drmSlowDiskDoDbgShowDiskDiagDetectPermitCntSph039(void);
 void drmSlowDiskDoDbgShowDiskDiagDetectPermitCnt(int32_t argc, char *argv[])
 {
     UNREFERENCE_PARAM(argc);
     UNREFERENCE_PARAM(argv);
-    DBG_PrintBuf("slow disk diagnose detect permit count:%u\n", g_slowDiskDiagAllowCnt);
+    drmSlowDiskDoDbgShowDiskDiagDetectPermitCntSph039();
 }
 
 
@@ -1298,3 +1298,131 @@
 }
 
 
+int32_t DrmQslowUpdateOneConfigDataSph039(char *itemName, uint32_t value)
+{
+    int32_t ret = RETURN_OK;
+    if (value == INVALID_VALUE32) {
+        return RETURN_OK;
+    }
+
+    CST_ITEM_T item;
+    memset(&item, 0, sizeof(CST_ITEM_T));
+    snprintf(item.acValue, CST_MAX_ITEM_VALUE_LEN, "%u", value);
+    snprintf(item.acName, CST_MAX_ITEM_NAME_LEN, "%s", itemName);
+
+    ret = CST_SetItem("BDM", &item);
+    if (ret != RETURN_OK) {
+        DBG_LogError(DBG_LOGID_NEW, "Set item %s value %u failed, ret %d.", itemName, value, ret);
+        return RETURN_ERROR;
+    }
+
+    ret = ECONF_ModifyConfig("BDM", item.acName, item.acValue);
+    DBG_LogInfo(DBG_LOGID_NEW, "Set item %s value %u ret %d.", itemName, value, ret);
+    return ret;
+}
+
+void DrmQslowRecoverOneConfParamSph039(const char *itemName, uint32_t *data)
+{
+    CST_ITEM_T item;
+    uint32_t value = INVALID_VALUE32;
+
+    memset(&item, 0, sizeof(item));
+    if (CST_GetItem("BDM", itemName, &item)) {
+        value = (uint32_t)LVOS_StrToU64(item.acValue);
+    }
+
+    if (value != INVALID_VALUE32) {
+        *data = value;
+    }
+
+    return;
+}
+
+void drmSlowDiskDoDbgSetPermitCountSph039(uint32_t permitCnt){
+     
+    if (permitCnt > 5 || permitCnt == 0) {
+        DBG_PrintBuf("The input permit count is not correct(1-5), curent set count:%u!\n",permitCnt);
+        return;        
+    }
+    
+    if (DrmQslowUpdateOneConfigDataSph039("SlowDiskDiagAllowCount", permitCnt) != RETURN_OK) {
+        DBG_LogError(DBG_LOGID_NEW, "Save slow disk diag allow count failed!");
+        DBG_PrintBuf("Save slow disk diag allow count failed!\n");
+        return;
+    }
+    g_slowDiskDiagAllowCnt = permitCnt;
+    DBG_PrintBuf("Set slow disk diag permit count success, permit count:%u\n", g_slowDiskDiagAllowCnt);
+}
+
+
+extern uint32_t g_drmConfigAverageDelay[DISK_TYPE_BUTT];
+
+void drmSlowDiskDoDbgSetDiskDelaythresholdTimeSph039(uint32_t diskType, uint32_t time){
+     
+    if (!(diskType == 1 || diskType == 2 || diskType == 3)) {
+        DBG_PrintBuf("diskType is not correct, please check: 1:SAS_HDD, 2:NL_SAS_HDD, 3:SSD;\n");
+        return;        
+    }
+    
+    if (time > 60000 || time < 100) {
+        DBG_PrintBuf("delay time is not in range 100us-60000us!\n");
+        return;        
+    }
+    
+    if (diskType == 1) {
+        if (DrmQslowUpdateOneConfigDataSph039("SlowDiskDiagDelayTypeSASHDD", time) != RETURN_OK) {
+            DBG_LogError(DBG_LOGID_NEW, "Save delay threshold of disk type SAS HDD failed!");
+            DBG_PrintBuf("Save delay threshold of disk type SAS HDD failed!\n");
+            return;
+        }
+        g_drmConfigAverageDelay[DISK_TYPE_SAS] = time;
+        g_drmConfigAverageDelay[DISK_TYPE_SATA] = time;
+        g_drmConfigAverageDelay[DISK_TYPE_SAS_SED] = time;
+        g_drmConfigAverageDelay[DISK_TYPE_SATA_SED] = time;
+        DBG_PrintBuf("Save delay threshold of disk type HDD times:%u\n", time);
+        DBG_LogInfo(DBG_LOG_BUTT, "Save delay threshold of disk type HDD times:%u.", time);
+    }
+    
+    if (diskType == 2) {
+        if (DrmQslowUpdateOneConfigDataSph039("SlowDiskDiagDelayTypeNLSASHDD", time) != RETURN_OK) {
+            DBG_LogError(DBG_LOGID_NEW, "Save delay threshold of disk type NL_SAS HDD failed!");
+            DBG_PrintBuf("Save delay threshold of disk type NL_SAS HDD failed!\n");
+            return;
+        }
+        g_drmConfigAverageDelay[DISK_TYPE_NL_SAS] = time;
+        g_drmConfigAverageDelay[DISK_TYPE_NL_SAS_SED] = time;
+        DBG_PrintBuf("Save delay threshold of disk type NL_SAS HDD times:%u\n", time);
+        DBG_LogInfo(DBG_LOG_BUTT, "Save delay threshold of disk type NL_SAS HDD times:%u.", time);
+    }
+
+    if (diskType == 3) {
+        if (DrmQslowUpdateOneConfigDataSph039("SlowDiskDiagDelayTypeSSD", time) != RETURN_OK) {
+            DBG_LogError(DBG_LOGID_NEW, "Save delay threshold of disk type SSD failed!");
+            DBG_PrintBuf("Save delay threshold of disk type SSD failed!\n");
+            return;
+        }
+        g_drmConfigAverageDelay[DISK_TYPE_SSD] = time;
+        g_drmConfigAverageDelay[DISK_TYPE_SLC_SSD] = time;
+        g_drmConfigAverageDelay[DISK_TYPE_MLC_SSD] = time;
+        g_drmConfigAverageDelay[DISK_TYPE_SSD_SED] = time;
+        g_drmConfigAverageDelay[DISK_TYPE_SLC_SSD_SED] = time;
+        g_drmConfigAverageDelay[DISK_TYPE_MLC_SSD_SED] = time;
+        g_drmConfigAverageDelay[DISK_TYPE_NVME_SSD] = time;
+        DBG_PrintBuf("Save delay threshold of disk type SSD times:%u\n", time);
+        DBG_LogInfo(DBG_LOG_BUTT, "Save delay threshold of disk type SSD times:%u.", time);
+    }
+}
+
+void drmSlowDiskDoDbgShowDiskDiagDetectPermitCntSph039(void)
+{
+    DBG_PrintBuf("slow disk delay threshold of disk type SAS HDD:%u\n", 
+        g_drmConfigAverageDelay[DISK_TYPE_SAS]);
+    DBG_PrintBuf("slow disk delay threshold of disk type NL_SAS HDD:%u\n", 
+        g_drmConfigAverageDelay[DISK_TYPE_NL_SAS]);
+    DBG_PrintBuf("slow disk delay threshold of disk type SSD:%u\n", 
+        g_drmConfigAverageDelay[DISK_TYPE_SSD]);
+    
+    DBG_PrintBuf("slow disk diagnose detect permit count:%u\n", g_slowDiskDiagAllowCnt);
+}
+
+
--- ./source/private_module/drm/feature/slow_disk_detect/drm_slow_disk_strategy.c	2018-03-21 09:07:29.000000000 +0000
+++ ./source/private_module/drm/feature/slow_disk_detect/drm_slow_disk_strategy.c.hotpatch	2022-05-18 03:10:44.000000000 +0000
@@ -32,9 +32,9 @@
 CCDB_DISK_SLOW_RECORD_LIST_S g_drmSlowDiskRecordList; /*̼¼*/
 
 spinlock_t g_drmSlowDiskRecordSpinlock;    /*  */
-
+#define DRM_MIN_DIAG_INTERVAL_MINUTE (20)   /* ϵʱ,λ */
 extern DRM_SLOW_DETECT_POOL_ID_S g_zonePoolId;  /*zone*/
-
+#define DRM_MIN_TO_SEC  (60)           /* ӵsת */
 #define SLOW_DISK_DETECT_TIME_INTERNAL  (5)  /*̼*/
 #define SLOW_DISK_DIAG_TIME_INTERNAL  (120)  /*ϼʱ*/
 #define DRM_DAY_TO_SEC  (24*60*60)           /*һ쵽sת*/
@@ -59,8 +59,8 @@
     uint32_t domainId;
     uint64_t reportTime;
 }DRM_SLOW_DISK_DIAG_FLAG_E;
-
-
+uint32_t g_drmConfigAverageDelay[DISK_TYPE_BUTT] = {1000, 3000, 3000, 500, 6000, 500, 500, 1000, 3000, 3000, 
+    500, 6000, 500, 500, 500};
 DRM_SLOW_DISK_DIAG_INFO_LIST_S g_diskDiagInfoList;
 /*1ϼĴ*/
 uint32_t g_slowDiskDiagAllowCnt = 0;
@@ -1397,13 +1397,13 @@
         return TRUE;
     }
     
-    /*2.60sIOƽʱڵֵСֵһ*/
-    if (unlikely(RETURN_OK == result && 
-        avgSvctm >= ((minSvctmBase * DRM_MILLISEC_TO_USEC) >> 1)))
+    /*2.60sIOƽʱڵֵ*/
+    if (unlikely(RETURN_OK == result && avgSvctm >= minSvctmBase))
     {
         return TRUE;
     }
 
+
     /*3.Ŀػ60sIOƽʱڵƽʱ2*/
     if (unlikely(RETURN_OK == result && avgSvctm >= svctmCtrl))
     {
@@ -1413,7 +1413,7 @@
     return FALSE;
 }
 /*End Modified by m90005436 ALMCR2018010319670125 2018.01.11*/
-
+bool DrmJudgeSlowDiskContinuousDiagSph039(uint32_t diskId, uint64_t endTime);
 /**************************************************************************
 :drmSlowDiskDiagCallBack
 :  ϻص
@@ -1438,8 +1438,7 @@
     uint32_t svctmCtrl = INVALID_VALUE32;
     bool realSlow = FALSE;
 
-    if (NULL == backInfo)
-    {
+    if (NULL == backInfo) {
         return;
     }
 
@@ -1453,16 +1452,13 @@
 
     sdId = drmGetDiskScsiDeviceId(tmpInfo.logicId); 
     
-    /*˴ϵĽ,ǰ̴*/
-    /*ϱrecover*/
+    /*˴ϵĽ,ǰ̴,ϱrecover*/
     sdDeviceReportRecover(sdId, state);
 
-    if (DIAG_RESULT_OK != state)
-    {
+    if (DIAG_RESULT_OK != state) {
         DBG_LogWarning(DBG_LOG_BUTT,"Disk diag failed:ld(%u),sd(%u), origin svectm(%u).",tmpInfo.logicId,sdId, tmpInfo.svectm);
         ret = drmDelSlowDiskDiagInfoById(tmpInfo.logicId);
-        if (unlikely(RETURN_OK != ret))
-        {
+        if (unlikely(RETURN_OK != ret)) {
             DBG_LogInfo(DBG_LOG_BUTT, "delete disk(%u) diag info failed.",
                           tmpInfo.logicId);
         } 
@@ -1485,8 +1481,7 @@
       3.Ŀػ60sIOƽʱڵƽʱ2
     */
     realSlow = drmSlowDiskCheckDiskIsRealSlow(slowCycleNum, ret, avgservTime, svctmCtrl, minSvctmBase);
-    if (unlikely(TRUE == realSlow))
-    {
+    if (unlikely(TRUE == realSlow)) {
         drmSlowDiskDiagReportSlowDisk(tmpInfo.logicId);
         return;
     }
@@ -1495,16 +1490,21 @@
     /*Begin Modified by z90005565 DTS2018031904559 20180319*/
     /* ޸Ϊ */
     curTime = (uint64_t)LVOS_GetTime(NULL);
+
+    if(DrmJudgeSlowDiskContinuousDiagSph039(tmpInfo.logicId, curTime)) {
+        DBG_LogInfo(DBG_LOG_BUTT, "SPH039:report slow disk,ld(%u),sd(%u), cause diag 2 times in 20 minutes.",
+            tmpInfo.logicId, sdId);
+        drmSlowDiskDiagReportSlowDisk(tmpInfo.logicId);
+        return;
+    }
     slowDiagDectCnt = drmQuerySlowDiskDiagInfoCntById(tmpInfo.logicId, curTime);
     /*End Modified by z90005565 DTS2018031904559 20180319*/
-    if (unlikely(slowDiagDectCnt >= g_slowDiskDiagAllowCnt))
-    {
+    if (unlikely(slowDiagDectCnt >= g_slowDiskDiagAllowCnt)) {
         DBG_LogInfo(DBG_LOG_BUTT, "Report slow disk,ld(%u),sd(%u),diagdectcnt(%u) more than(%u) in month.",
             tmpInfo.logicId, sdId, slowDiagDectCnt, g_slowDiskDiagAllowCnt);
         drmSlowDiskDiagReportSlowDisk(tmpInfo.logicId);
     }
-    return;
-    
+    return;   
 }
 
 /**************************************************************************
@@ -1917,3 +1917,151 @@
     return RETURN_OK;
 }
 
+/**************************************************************************
+:drmJudgeSlowDiskContinuousDiagSubSph039
+: жһʱ͵ǰʱǷָʱ
+:
+:
+ֵ:
+:
+**************************************************************************/
+bool DrmJudgeSlowDiskContinuousDiagSubSph039(DRM_SLOW_DISK_DIAG_INFO_S* diagInfo, uint64_t curTime)
+{
+    uint32_t i = 0;
+    uint32_t recordCnt = 0;
+    uint64_t tmp = 0;
+    uint64_t curSeconds = curTime;   
+    /* ĬϼΪ20 */
+    uint64_t intevalSeconds = DRM_MIN_DIAG_INTERVAL_MINUTE * DRM_MIN_TO_SEC;
+
+    for (i = 0; i < DRM_MAX_DIAG_INFO_CNT; i++) {
+        if (unlikely(0 == diagInfo->diagTime[i])) {
+            continue;
+        }
+
+        tmp = curSeconds - diagInfo->diagTime[i];
+        if (tmp <= intevalSeconds) {
+            recordCnt++;
+        }
+    }
+
+    if(recordCnt > 1) {
+        return TRUE;
+    } else {
+        return FALSE;
+    }
+
+}
+
+/**************************************************************************
+:drmJudgeSlowDiskContinuousDiagSph039
+: ׼ָʱνϣжΪ
+:
+:
+ֵ:
+:
+**************************************************************************/
+bool DrmJudgeSlowDiskContinuousDiagSph039(uint32_t diskId, uint64_t curTime)
+{
+    struct list_head *pos = NULL;
+    struct list_head *next = NULL;
+    bool isDiskSlow = FALSE;
+    DRM_SLOW_DISK_DIAG_INFO_S* tempInfo = NULL;
+    
+    spin_lock(&g_diskDiagInfoList.listLock);
+    
+    if (unlikely(g_diskDiagInfoList.diskCnt < 1)) {
+        spin_unlock(&g_diskDiagInfoList.listLock);
+        return FALSE;
+    }
+
+    list_for_each_safe(pos, next, &g_diskDiagInfoList.diagInfoList) {
+        tempInfo = list_entry(pos, DRM_SLOW_DISK_DIAG_INFO_S, head);
+        
+        if (tempInfo->diskId == diskId) {
+            isDiskSlow = DrmJudgeSlowDiskContinuousDiagSubSph039(tempInfo, curTime);
+            break;
+        }
+    }
+    spin_unlock(&g_diskDiagInfoList.listLock);
+    return isDiskSlow;
+}
+
+void DrmQslowRecoverOneConfParamSph039(const char *itemName, uint32_t *data);
+void GetSlowDiskDiagDiskAverDelayFromConfSph039(DISK_TYPE_E diskType)
+{
+    uint32_t TmpValue = INVALID_VALUE32;
+    
+    if (diskType >= DISK_TYPE_BUTT) {
+        DBG_LogError(DBG_LOG_BUTT,"Disk type is fault, diskType(%d).", diskType);
+    }
+    
+    switch(diskType){
+        case DISK_TYPE_FC:
+        case DISK_TYPE_FC_SED:
+            TmpValue = INVALID_VALUE32;
+            break;
+        case DISK_TYPE_SAS:
+        case DISK_TYPE_SATA:    
+        case DISK_TYPE_SAS_SED:
+        case DISK_TYPE_SATA_SED:
+            DrmQslowRecoverOneConfParamSph039("SlowDiskDiagDelayTypeSASHDD", &TmpValue);
+            break;
+        case DISK_TYPE_NL_SAS:
+        case DISK_TYPE_NL_SAS_SED:
+            DrmQslowRecoverOneConfParamSph039("SlowDiskDiagDelayTypeNLSASHDD", &TmpValue);
+            break;
+        case DISK_TYPE_SSD:
+        case DISK_TYPE_SLC_SSD:
+        case DISK_TYPE_MLC_SSD:         
+        case DISK_TYPE_SSD_SED:
+        case DISK_TYPE_SLC_SSD_SED:         
+        case DISK_TYPE_MLC_SSD_SED:
+        case DISK_TYPE_NVME_SSD: 
+            DrmQslowRecoverOneConfParamSph039("SlowDiskDiagDelayTypeSSD", &TmpValue);
+            break;
+        case DISK_TYPE_BUTT:
+        default:
+            DBG_LogInfo(DBG_LOG_BUTT, "DiskType(%u) is invalid.", diskType);
+            return;
+    }
+    
+    if (TmpValue != INVALID_VALUE32) {
+        g_drmConfigAverageDelay[diskType] = TmpValue;        
+        DBG_LogInfo(DBG_LOG_BUTT, "Get drmMinThresholdValue of diskType(%u) from conf, value(%u).", diskType, TmpValue);
+        return;
+    }  
+    DBG_LogInfo(DBG_LOG_BUTT, "DrmMinThresholdValue of diskType(%u) is not in conf file, use default value(%u)us.", 
+        diskType, g_drmConfigAverageDelay[diskType]);
+}
+
+bool g_hasGetConfigParamFromConf = FALSE;
+
+void DrmConfigAverageDelayAndPermitCntInitSph039(void)
+{
+    if (g_hasGetConfigParamFromConf == TRUE) {
+        return;
+    }
+    /* ļгʼдӲ */
+    DISK_TYPE_E diskType;
+    for (diskType = DISK_TYPE_FC; diskType < DISK_TYPE_BUTT; diskType++) {
+        GetSlowDiskDiagDiskAverDelayFromConfSph039(diskType);
+    } 
+
+    /* ļгʼ̵ϴ */
+    uint32_t SlowDiskDiagAllowCntTmp = INVALID_VALUE32;
+    DrmQslowRecoverOneConfParamSph039("SlowDiskDiagAllowCount", &SlowDiskDiagAllowCntTmp);
+    if (SlowDiskDiagAllowCntTmp != INVALID_VALUE32) {
+        g_slowDiskDiagAllowCnt = SlowDiskDiagAllowCntTmp;
+        DBG_LogInfo(DBG_LOG_BUTT, "Get SlowDiskDiagAllowCount from conf, value(%u).", SlowDiskDiagAllowCntTmp);
+    } else {
+        DBG_LogInfo(DBG_LOG_BUTT, "SlowDiskDiagAllowCount is not in conf file, use default value(%u).", 
+            g_slowDiskDiagAllowCnt);
+    }
+    g_hasGetConfigParamFromConf = TRUE;
+}
+
+
+
+
+
--- ./source/private_module/drm/framework/adapter/drm_pool_adapter.c	2018-02-09 07:36:26.000000000 +0000
+++ ./source/private_module/drm/framework/adapter/drm_pool_adapter.c.hotpatch	2022-05-12 15:35:05.000000000 +0000
@@ -25,7 +25,7 @@
     uint32_t logicId;
     uint32_t domainId;
 }DRM_GET_DOMAIN_REDUNT_PARAM_S;
-
+bool checkDiskCanDiagnosePatch(diskid_t diskId);
 /**************************************************************************
 :drmGetDomainRedundantCallBack
 :  ȷϴӲǷص
@@ -43,8 +43,7 @@
     void *judgeContext = NULL;
     uint32_t logicId = INVALID_VALUE32;
 
-    if (NULL == context)
-    {
+    if (NULL == context) {
         return;
     }
     
@@ -54,8 +53,7 @@
     drmFreeNoBlock(checkParam, sizeof(DRM_GET_DOMAIN_REDUNT_PARAM_S));
 
     /*ѯʧ*/
-    if (RETURN_OK != result || NULL == diskPoolInfo)
-    {
+    if (RETURN_OK != result || NULL == diskPoolInfo) {
         DBG_LogError(DBG_LOG_BUTT,"get disk_domain failed(%u).", logicId);
         callBack(judgeContext, RETURN_ERROR, FALSE);
         return;
@@ -63,15 +61,17 @@
 
     healthStatus = diskPoolInfo->diskPoolBaseInfo.healthStatus;
     runningStatus = diskPoolInfo->diskPoolBaseInfo.runningStatus;
-    /*жӲ*/
-    if (RUNNING_STATUS_RECONSTRUCTION == runningStatus || HEALTH_STATUS_NORMAL != healthStatus)
-    {
+
+    if (HEALTH_STATUS_NORMAL != healthStatus || 
+        (RUNNING_STATUS_RECONSTRUCTION == runningStatus && checkDiskCanDiagnosePatch(logicId) == FALSE)) {
         DBG_LogError(DBG_LOG_BUTT,"get disk_domain status in pool not normal,status(%u,%u).", 
-                        healthStatus, runningStatus);
+            healthStatus, runningStatus);
         callBack(judgeContext, RETURN_OK, FALSE);
         return;
     }
 
+
+
     callBack(judgeContext, RETURN_OK, TRUE);
     return;
 }
