--- ./source/private_module/src/upgrade_disk_kern.c	2018-02-09 07:36:26.000000000 +0000
+++ ./source/private_module/src/upgrade_disk_kern.c.hotpatch	2021-11-22 10:16:18.000000000 +0000
@@ -35,16 +35,12 @@
 #include "ctrl/flow/flow_operate.h"
 #include "upgrade_sys_event_template.h"
 #include "upgrade_kern_intf.h"
-
 CONVERTOR_MUTEX_LIST_HEAD_S g_stConvertorInfoList;
-
 extern uint32_t getNodeCount(void);
 extern OSP_BOOL UPGRADE_isBDMReturnResult(OSP_VOID);
 extern OSP_BOOL UPGRADE_isDiskResume(OSP_U32 uiInnerFrameID, OSP_U32 uiSlot);
 extern UPD_DISK_UPGRADE_STATUS g_stDiskUpgradeStatus;
-
 #define MAX_RECORD_FOR_CLI  (100)
-
 #define CHECK_EXP_RETURN_AND_FREE(log_id,exp, toFree, ret, ...) \
 do { \
     if (exp) { \
@@ -53,23 +49,18 @@
         return ret; \
     }\
 } while (0)
-
 #define UPGRADE_PRINT_CONVERTOR_INFO(conInfo) \
 do { \
     UPG_LogInfo(UPGRADE_LOG_ID03ce, "Frame(%s), slot(%u), model(%s), version(%s), logicID(%u), status(%u), type(%s).",\
     conInfo.szFrameID,conInfo.uiSlot,conInfo.szModel,conInfo.szVersion,conInfo.uiLogicID,conInfo.uiStatus,conInfo.szType);\
 } while (0)
-
 #define BDM_DISK_UPGRADE(uiLogicID, stParam, callback, context) \
     ldIoCtl(uiLogicID, IOCTRL_SET_DISK_UPGRADE_FW, (void *)&stParam, callback, (void *)&context)
-
 /*ȡϵͳϢǰǹ̶*/
 #define GET_SYS_DISK_INFO(stSysDiskInfo) \
     sdIoCtl(32, SD_IOCTL_CMD_QRY_BASEINFO, (void *)&stSysDiskInfo)
-
 #define GET_LOGICID_BY_FRAME_SLOT(innerFrameID, slot, logicID) \
     ldGetLogicIdByFrameSlotIdOnlyForUsrDisk(innerFrameID, slot, logicID)
-
 #define SET_SINGLE_RESULT_LOCK(result) \
     do \
     { \
@@ -77,7 +68,21 @@
         g_stDiskUpgradeResult[0].uiProcessResult = result; \
         LVOS_mutex_unlock(&g_stDiskStatMutex); \
     } while (0)
-
+typedef struct tagUPGRADE_DISK_THREAD_RESULT_S
+{
+    OSP_U32 uiSlotID;                            /* Ӳ̲ۺ*/
+    OSP_U32 uiProcessResult;                     /* ǰ*/
+    OSP_U32 uiLogicID;                           /*Ӳ̵߼ID       */
+    OSP_CHAR szFrameID[USER_FRAME_ID_LENGTH];    /* ûţDKE000 */
+    OSP_BOOL bIsBDMReturn;
+    OSP_U32 excBDMResult;
+}UPGRADE_DISK_THREAD_RESULT_S;
+typedef struct tagDISK_FRAME_SLOT_INFO_NEW_S
+{
+   OSP_U32 uiSlotID;                            /* ۺ*/
+   OSP_CHAR szFrameID[USER_FRAME_ID_LENGTH];    /* ţDKE000 */
+   OSP_BOOL bMemberDisk;
+}DISK_FRAME_SLOT_INFO_NEW_S;
 /*ʶӲʽTRUE:ߣĬ*/
 static OSP_BOOL g_bIsOffline = FALSE;
 
@@ -86,23 +91,16 @@
 static OSP_BOOL g_bIsBDMReturn = FALSE;
 static OSP_BOOL g_bIsFail = FALSE;
 static OSP_U32 g_uiDiskUpgradeResultTmp = UPGRADE_DISK_FW_RESU_INVALID;//ʱBDMӿڷصĽ
-
 static IOCTRL_SET_DISK_UPGRADE_FW_PARAM_S g_stParam = {0}; /* 漰첽Ҫȫڴ棬ioctlֻǱָ*/
-
+#define DISK_MAX_NUM            (3000)
 #define MAX_WAIT_STATE_TIMES     (180)
-
-/*****************************************************************************
-ģʹBDM
-BDMжˢֱ̼ӻصʱ1-2Sһ̣µӲBDM̴߳
-жBDM-ˢcacheȴ20룩-
-·µȴ30룩-·ϵ-ص-ѯǷ
-BDMԼĳʱʱΪһӣһ
-*****************************************************************************/
 #define MAX_BDM_WAIT_TIMES           (120)
-
+#define MAX_BDM_WAIT_TIMES_NEW           (300)
 #define DISK_WAIT_RESUME_5S    (UPGRADE_ONE_SECOND * 5)
 #define DISK_WAIT_RESUME_1S    (UPGRADE_ONE_SECOND)
+OSP_VOID UPGRADE_UpgradeSingleDiskInKernNew(DISK_FRAME_SLOT_INFO_NEW_S *pDiskInfo);
 
+OSP_VOID UPGRADE_NotifyBdmInit(VOID);
 /* Ӳ̽Ϣд */
 extern LVOS_MUTEX_S g_stDiskStatMutex;
 /* Ӳ¼д */
@@ -110,6 +108,8 @@
 /*¼Ƿ*/
 OSP_BOOL g_bDiskEventIsDone = FALSE;
 extern UPGRADE_DISK_RESULT_S g_stDiskUpgradeResult[DISK_STAT_MAX_NUM];
+extern UPGRADE_DISK_RESULT_S g_stDiskUpgradeResultNew[DISK_MAX_NUM];
+extern UPGRADE_DISK_THREAD_RESULT_S g_stDiskUpgradeThreadResult[10];
 extern DISK_RESUME_RESULT_S g_stDiskResumeCheck;
 
 MODULE_ID(PID_UPGRADE_KERNEL);
@@ -385,14 +385,6 @@
     return bState;
 }
 
-
-/*****************************************************************************
-     : UPGRADE_CheckDiskState
-   : ̵״̬
-       : 2013621
-        : w00214935
- ޸   : ɺ
-*****************************************************************************/
 static OSP_BOOL UPGRADE_CheckDiskState(OSP_U32 innerFrameID, OSP_U32 uiLogicID)
 {
     OSP_U16 uiNid = 0;
@@ -405,7 +397,17 @@
     OSP_U32 diskCcdbId = INVALID_VALUE32;
     OSP_U32 diskLogzoneId = INVALID_VALUE32;
     OSP_U32 diskDbId= INVALID_VALUE32;
+    getOnlineNids(&nodeIdBitMap);
 
+    for (uiNidIndex = 0; uiNidIndex < XVE_MAX_NODE_NUM; uiNidIndex++)
+    {
+        if(!(LVOS_test_bit(uiNid + uiNidIndex, (void *)&nodeIdBitMap)))
+        {
+            continue;
+        }
+
+        (OSP_VOID)UPGRADE_SendMsgToCheckState(uiNid + uiNidIndex, uiLogicID, INVALID_VALUE32, INVALID_VALUE32);
+    }
     /* ûIDID */
     if(RETURN_OK != ldGetLogicDiskInfo(uiLogicID, &logicDiskInfo))
     {
@@ -457,8 +459,6 @@
     uiNid = (OSP_U16)(getNodeCount() * uiEngineID);
     DBG_LogIntf(DBG_LOG_DEBUG, UPGRADE_LOG_ID03ad, "Engineid is (%u) , node count in one engine is (%u).", uiEngineID, getNodeCount());
 
-    getOnlineNids(&nodeIdBitMap);
-
     for (uiNidIndex = 0; uiNidIndex < getNodeCount(); uiNidIndex++)
     {
 #ifdef _DT_ /*DT£׷д*/
@@ -497,21 +497,34 @@
 
     DBG_LogIntf(DBG_LOG_INFO, UPGRADE_LOG_ID03af, "Frame(%s),slot(%u),logic(%u),result(%d).",
         szUserFrameID, uiSlot, uiLogicID, uiResult);
-
     LVOS_mutex_lock(&g_stDiskStatMutex);
-    for(uiLoop = 0; uiLoop < DISK_STAT_MAX_NUM; uiLoop++)
+    for(uiLoop = 0; uiLoop < 10; uiLoop++)
     {
-        if(INVALID_VALUE32 == g_stDiskUpgradeResult[uiLoop].uiLogicID)
+        if(INVALID_VALUE32 == g_stDiskUpgradeThreadResult[uiLoop].uiLogicID)
         {
-            LVOS_strncpy(g_stDiskUpgradeResult[uiLoop].szFrameID, szUserFrameID, USER_FRAME_ID_LENGTH);
-            g_stDiskUpgradeResult[uiLoop].uiSlotID = uiSlot;
-            g_stDiskUpgradeResult[uiLoop].uiLogicID = uiLogicID;
-            g_stDiskUpgradeResult[uiLoop].uiProcessResult = uiResult;
+            LVOS_strncpy(g_stDiskUpgradeThreadResult[uiLoop].szFrameID, szUserFrameID, USER_FRAME_ID_LENGTH);
+            g_stDiskUpgradeThreadResult[uiLoop].uiSlotID = uiSlot;
+            g_stDiskUpgradeThreadResult[uiLoop].uiLogicID = uiLogicID;
+            g_stDiskUpgradeThreadResult[uiLoop].uiProcessResult = uiResult;
+            g_stDiskUpgradeThreadResult[uiLoop].bIsBDMReturn = FALSE;
+            g_stDiskUpgradeThreadResult[uiLoop].excBDMResult= INVALID_VALUE32;
+            break;
+        }
+    }
+    LVOS_mutex_unlock(&g_stDiskStatMutex);
+    LVOS_mutex_lock(&g_stDiskStatMutex);
+    for(uiLoop = 0; uiLoop < DISK_MAX_NUM; uiLoop++)
+    {
+        if(INVALID_VALUE32 == g_stDiskUpgradeResultNew[uiLoop].uiLogicID)
+        {
+            LVOS_strncpy(g_stDiskUpgradeResultNew[uiLoop].szFrameID, szUserFrameID, USER_FRAME_ID_LENGTH);
+            g_stDiskUpgradeResultNew[uiLoop].uiSlotID = uiSlot;
+            g_stDiskUpgradeResultNew[uiLoop].uiLogicID = uiLogicID;
+            g_stDiskUpgradeResultNew[uiLoop].uiProcessResult = uiResult;
             break;
         }
     }
     LVOS_mutex_unlock(&g_stDiskStatMutex);
-
     return;
 }
 
@@ -523,35 +536,34 @@
 static OSP_VOID UPGRADE_ChangeFrameDiskResult(OSP_CHAR *szUserFrameID, OSP_U32 uiSlot, OSP_U32 uiLogicID, OSP_U32 uiResult)
 {
     OSP_U32 uiLoop = 0;
-
     DBG_LogIntf(DBG_LOG_INFO, UPGRADE_LOG_ID03af, "Frame(%s),slot(%u),logic(%u),result(%d).",
         szUserFrameID, uiSlot, uiLogicID, uiResult);
-
     LVOS_mutex_lock(&g_stDiskStatMutex);
-    for(uiLoop = 0; uiLoop < DISK_STAT_MAX_NUM; uiLoop++)
+    for(uiLoop = 0; uiLoop < 10; uiLoop++)
     {
-        if((0 == strncmp(szUserFrameID, g_stDiskUpgradeResult[uiLoop].szFrameID, USER_FRAME_ID_LENGTH))
-            && (uiSlot == g_stDiskUpgradeResult[uiLoop].uiSlotID))
+        if((0 == strncmp(szUserFrameID, g_stDiskUpgradeThreadResult[uiLoop].szFrameID, USER_FRAME_ID_LENGTH))
+            && (uiSlot == g_stDiskUpgradeThreadResult[uiLoop].uiSlotID))
         {
-            LVOS_strncpy(g_stDiskUpgradeResult[uiLoop].szFrameID, szUserFrameID, USER_FRAME_ID_LENGTH);
-            g_stDiskUpgradeResult[uiLoop].uiSlotID = uiSlot;
-            g_stDiskUpgradeResult[uiLoop].uiLogicID = uiLogicID;
-            g_stDiskUpgradeResult[uiLoop].uiProcessResult = uiResult;
+            g_stDiskUpgradeThreadResult[uiLoop].uiLogicID = uiLogicID;
+            g_stDiskUpgradeThreadResult[uiLoop].uiProcessResult = uiResult;
+            break;
+        }
+    }
+    LVOS_mutex_unlock(&g_stDiskStatMutex);
+    LVOS_mutex_lock(&g_stDiskStatMutex);
+    for(uiLoop = 0; uiLoop < DISK_MAX_NUM; uiLoop++)
+    {
+        if((0 == strncmp(szUserFrameID, g_stDiskUpgradeResultNew[uiLoop].szFrameID, USER_FRAME_ID_LENGTH))
+            && (uiSlot == g_stDiskUpgradeResultNew[uiLoop].uiSlotID))
+        {
+            g_stDiskUpgradeResultNew[uiLoop].uiLogicID = uiLogicID;
+            g_stDiskUpgradeResultNew[uiLoop].uiProcessResult = uiResult;
             break;
         }
     }
     LVOS_mutex_unlock(&g_stDiskStatMutex);
-
     return;
 }
-
-/*****************************************************************************
-     : UPGRADE_IsInvalidDisk
-   : ǷҪ
-       : 2013621
-        : w00214935
- ޸   : ɺ
-*****************************************************************************/
 OSP_BOOL UPGRADE_IsInvalidDisk(OSP_CHAR *szUserFrameID, OSP_U32 uiLogicID, OSP_U32 *v_puiSlot, OSP_BOOL *pbMemDisk)
 {
     LD_INFO_S logicDiskInfo = {0};
@@ -609,77 +621,65 @@
 
     return FALSE;
 }
-/*****************************************************************************
-     : UPGRADE_SetDiskUpgradeResult
-   : ӲĽ
-        : 2013621
-        : w00214935
- ޸   : ɺ
-*****************************************************************************/
 OSP_VOID UPGRADE_SetDiskUpgradeResult(OSP_VOID *context, OSP_S32 uiResult, OSP_VOID *args)
 {
+    OSP_U32 uiLoop = 0;
     OSP_U32 uiLogicID = 0;
-
     uiLogicID = *(OSP_U32 *)context;
     UNREFERENCE_PARAM(args);
-
     DBG_LogIntf(DBG_LOG_INFO, UPGRADE_LOG_ID03b8, "LogicID(%u)-----result(%d).", uiLogicID, uiResult);
-
-    g_bIsBDMReturn = TRUE;
-
     /*ֹBDMЧֵ*/
     if(UPGRADE_DISK_FW_RESU_INVALID == uiResult)
     {
         uiResult = UPGRADE_DISK_FW_RESU_FAIL;
     }
-
-    if(UPGRADE_DISK_FW_RESU_FAIL == uiResult)
+    LVOS_mutex_lock(&g_stDiskStatMutex);
+    for(uiLoop = 0; uiLoop < 10; uiLoop++)
     {
-        g_bIsFail = TRUE;
+        if(uiLogicID == g_stDiskUpgradeThreadResult[uiLoop].uiLogicID)
+        {
+            g_stDiskUpgradeThreadResult[uiLoop].excBDMResult= uiResult;
+            g_stDiskUpgradeThreadResult[uiLoop].uiProcessResult= uiResult;
+            g_stDiskUpgradeThreadResult[uiLoop].bIsBDMReturn = TRUE;
+            break;
+        }
     }
-    g_uiDiskUpgradeResultTmp = (OSP_U32)uiResult;
-
+    LVOS_mutex_unlock(&g_stDiskStatMutex);
+    if(10 == uiLoop)
+    {
+        DBG_LogIntf(DBG_LOG_ERROR, UPGRADE_LOG_ID03ba, "Not find disk(%u).", uiLogicID);
+    }
+    DBG_LogIntf(DBG_LOG_INFO, UPGRADE_LOG_ID03b8, "BDM return result(%d).", uiResult);
     return ;
 }
 
-/*****************************************************************************
-     : UPGRADE_ExecSingleDiskUpgradeInKern
-   : Ӳ̵
-        : 2013621
-        : w00214935
- ޸   : ɺ
-*****************************************************************************/
 static OSP_VOID UPGRADE_ExecSingleDiskUpgradeInKern(OSP_CHAR *szFrameID, OSP_U32 uiSlotID, OSP_U32 uiLogicID)
 {
-    OSP_S32 uiExecRet = RETURN_ERROR;
+    OSP_S32 uiExecRet;
     OSP_U32 uiLoop = 0;
-
-    memset(&g_stParam, 0, sizeof(IOCTRL_SET_DISK_UPGRADE_FW_PARAM_S));
-
     LVOS_mutex_lock(&g_stDiskStatMutex);
-    for(uiLoop = 0; uiLoop < DISK_STAT_MAX_NUM; uiLoop++)
+    for(uiLoop = 0; uiLoop < 10; uiLoop++)
     {
-        if(INVALID_VALUE32 == g_stDiskUpgradeResult[uiLoop].uiLogicID)
+        if(uiLogicID == g_stDiskUpgradeThreadResult[uiLoop].uiLogicID)
         {
-            LVOS_strncpy(g_stDiskUpgradeResult[uiLoop].szFrameID, szFrameID, USER_FRAME_ID_LENGTH);
-            g_stDiskUpgradeResult[uiLoop].uiSlotID = uiSlotID;
-            g_stDiskUpgradeResult[uiLoop].uiLogicID = uiLogicID;
-            g_stDiskUpgradeResult[uiLoop].uiProcessResult = UPGRADE_DISK_FW_RESU_INVALID;
             break;
         }
     }
     LVOS_mutex_unlock(&g_stDiskStatMutex);
-
-    if(DISK_STAT_MAX_NUM == uiLoop)
+    if(10 == uiLoop)
     {
         DBG_LogIntf(DBG_LOG_ERROR, UPGRADE_LOG_ID03bb, "Not find invalid logic!");
         return;
     }
-
-    g_bIsBDMReturn = FALSE;
     g_stParam.upgradeMode = (OSP_U32)g_bIsOffline;
     DBG_LogIntf(DBG_LOG_INFO, UPGRADE_LOG_ID03be, "Upgrade disk:enclosure(%s)-slot(%u)-logicID(%u).", szFrameID, uiSlotID, uiLogicID);
-    uiExecRet = BDM_DISK_UPGRADE(uiLogicID, g_stParam, UPGRADE_SetDiskUpgradeResult, g_stDiskUpgradeResult[uiLoop].uiLogicID);
+    uiExecRet = BDM_DISK_UPGRADE(uiLogicID, g_stParam, UPGRADE_SetDiskUpgradeResult, g_stDiskUpgradeThreadResult[uiLoop].uiLogicID);
+    if (RETURN_ERROR == uiExecRet)
+    {
+        DBG_LogIntf(DBG_LOG_ERROR, UPGRADE_LOG_ID03bf, "Failed:enclosure(%s)-slot(%u) return (%d)!", szFrameID, uiSlotID, uiExecRet);
+        UPGRADE_SetDiskUpgradeResult(&uiLogicID, UPGRADE_DISK_FW_RESU_FAIL, NULL);
+        return;
+    }
     if(RETURN_OK != uiExecRet)
     {
         DBG_LogIntf(DBG_LOG_ERROR, UPGRADE_LOG_ID03bf, "Failed:enclosure(%s)-slot(%u) return (%d)!", szFrameID, uiSlotID, uiExecRet);
@@ -1897,15 +1897,208 @@
   ֵ:
     :  
 **************************************************************************/
-OSP_VOID UPGRADE_StartUpgradeDisk(OSP_VOID* flow_handle)
+OSP_BOOL UPGRADE_isBDMReturnResultNew(OSP_U32 uiLogicID, OSP_U32 *v_puiResult)
 {
-    /*¼ɣԿʼӲ*/
-    LVOS_mutex_lock(&g_stDiskEventMutex); /*  */
-    g_bDiskEventIsDone = TRUE;
-    LVOS_mutex_unlock(&g_stDiskEventMutex); /* ͷ */
+    OSP_U32 uiCount = 0;
+    OSP_U32 uiLoop = 0;
+    while(uiCount++ < MAX_BDM_WAIT_TIMES_NEW)
+    {
+        for(uiLoop = 0; uiLoop < 10; uiLoop++)
+        {
+            LVOS_mutex_lock(&g_stDiskStatMutex);
+            if(uiLogicID == g_stDiskUpgradeThreadResult[uiLoop].uiLogicID)
+            {
+                if (TRUE == g_stDiskUpgradeThreadResult[uiLoop].bIsBDMReturn)
+                {
+                    *v_puiResult = g_stDiskUpgradeThreadResult[uiLoop].excBDMResult;
+                    LVOS_mutex_unlock(&g_stDiskStatMutex);
+                    return TRUE;
+                }
+            }
+            LVOS_mutex_unlock(&g_stDiskStatMutex);
+        }
+        LVOS_sleep(DISK_WAIT_RESUME_1S);
+    }
+    DBG_LogIntf(DBG_LOG_ERROR, UPGRADE_LOG_ID03c8, "It has wait BDM callback timeout.");
+    return FALSE;
+}
+OSP_BOOL UPGRADE_CheckDiskStateBeforeUpg(OSP_U32 uiInnerFrameID, OSP_U32 uiLogicID)
+{
+    OSP_U32 uiCount = 0;
+
+    while(uiCount++ < 10) {
+        if(UPGRADE_CheckDiskState(uiInnerFrameID, uiLogicID)) {
+            return TRUE;
+        }
+
+        DBG_LogIntf(DBG_LOG_WARNING, UPGRADE_LOG_ID03cc, "Disk(%u) state is abnomal, Loop(%u).", uiLogicID, uiCount);
+        LVOS_sleep(DISK_WAIT_RESUME_1S);
+    }
+
+    DBG_LogIntf(DBG_LOG_WARNING, UPGRADE_LOG_ID03cd, "Disk(%u) state is invalid, goto next.", uiLogicID);
+    return FALSE;
+}
 
-    flowContinue(flow_handle, RETURN_OK);
+OSP_VOID UPGRADE_UpgradeSingleDiskInKernNew(DISK_FRAME_SLOT_INFO_NEW_S *pDiskInfo)
+{
+    OSP_U32 uiLogicID        = INVALID_VALUE32;
+    OSP_U32 uiInnerFrameID   = INVALID_VALUE32;
+    char cmd[256] = {0};
+    OSP_U32 uiCount = 0;
+    OSP_S32 iScritpRes = 0;
+    OSP_S32 iRet = RETURN_ERROR;
+    OSP_U32 uiLoop = 0;
+    OSP_BOOL bResult = TRUE;
+    OSP_S64 timeSecond = 0;
+    OSP_U32 uiResult = UPGRADE_DISK_FW_RESU_INVALID;
+    OSP_U32 uiNewLogicID  = INVALID_VALUE32;
 
+    UPGRADE_SetFrameDiskResult(pDiskInfo->szFrameID, pDiskInfo->uiSlotID, INVALID_VALUE32-2, UPGRADE_DISK_FW_RESU_UPGRADE);
+    /*ͨEMPӿתַûΪڲ*/
+    uiInnerFrameID = UPGRADE_ChangeUserFrame2Inner(pDiskInfo->szFrameID);
+    if(INVALID_VALUE32 == uiInnerFrameID)
+    {
+        DBG_LogIntf(DBG_LOG_ERROR, UPGRADE_LOG_ID03c0, "Get inner frame id from (%s) failed.", pDiskInfo->szFrameID);
+        UPGRADE_ChangeFrameDiskResult(pDiskInfo->szFrameID, pDiskInfo->uiSlotID, INVALID_VALUE32-2, UPGRADE_DISK_NOT_EXIST);
+        return;
+    }
+    /*ͨBDMӿڻȡû߼ID*/
+    uiLogicID = DISK_POSITION_2_LOGIC_ID(uiInnerFrameID, (OSP_U16)pDiskInfo->uiSlotID, DISK_PARTITION_USR);
+    if(INVALID_VALUE32 == uiLogicID)
+    {
+        DBG_LogIntf(DBG_LOG_ERROR, UPGRADE_LOG_ID03c1, "Invalid logicID!");
+        UPGRADE_ChangeFrameDiskResult(pDiskInfo->szFrameID, pDiskInfo->uiSlotID, INVALID_VALUE32-2, UPGRADE_DISK_NOT_EXIST);
+        return;
+    }
+    DBG_LogIntf(DBG_LOG_INFO, UPGRADE_LOG_ID03c2,"Single disk info: enclosure (%s), slot (%u) and logicID (%u).",
+        pDiskInfo->szFrameID, pDiskInfo->uiSlotID, uiLogicID);
+    /*߼ID*/
+    UPGRADE_ChangeFrameDiskResult(pDiskInfo->szFrameID, pDiskInfo->uiSlotID, uiLogicID, UPGRADE_DISK_FW_RESU_UPGRADE);
+    /*߷װģʽµı̲*/
+    if((g_bIsOffline == TRUE) && (!g_bIsDFTMode) && (UPGRADE_IsVaultDisk(uiInnerFrameID, pDiskInfo->uiSlotID)))
+    {
+        DBG_LogIntf(DBG_LOG_WARNING, UPGRADE_LOG_ID03c3, "Vault disk must upgrad in equ_test mode.");
+        UPGRADE_ChangeFrameDiskResult(pDiskInfo->szFrameID, pDiskInfo->uiSlotID, uiLogicID,UPGRADE_DISK_FW_RESU_VAULT);
+        return;
+    }
+    /*ڻָع״̬̲*/
+    if((!g_bIsOffline) && (!UPGRADE_CheckDiskStateBeforeUpg(uiInnerFrameID, uiLogicID)))
+    {
+        DBG_LogIntf(DBG_LOG_ERROR, UPGRADE_LOG_ID03c4, "Disk(%u) state is invalid, forbid to upgrade.", uiLogicID);
+        UPGRADE_ChangeFrameDiskResult(pDiskInfo->szFrameID, pDiskInfo->uiSlotID, uiLogicID,UPGRADE_DISK_STATE_IS_ABNOMAL);
+        return;
+    }
+    timeSecond = LVOS_GetTime(NULL);
+    if(0 == timeSecond)
+    {
+        DBG_LogIntf(DBG_LOG_WARNING, UPGRADE_LOG_ID03c3, "Get sys time failed.");
+        UPGRADE_ChangeFrameDiskResult(pDiskInfo->szFrameID, pDiskInfo->uiSlotID, uiLogicID,UPGRADE_DISK_FW_RESU_FAIL);
+        return;
+    }
+    UPGRADE_ExecSingleDiskUpgradeInKern(pDiskInfo->szFrameID, pDiskInfo->uiSlotID, uiLogicID);
+    bResult = UPGRADE_isBDMReturnResultNew(uiLogicID, &uiResult);
+    if(bResult == FALSE)
+    {
+        UPGRADE_ChangeFrameDiskResult(pDiskInfo->szFrameID, pDiskInfo->uiSlotID, uiLogicID, UPGRADE_DISK_FW_RESU_FAIL);
+        return;
+    }
+    if ((!g_bIsOffline) && (uiResult == UPGRADE_DISK_FW_RESU_SUCCESS) && (UPGRADE_IsVaultDisk(uiInnerFrameID, pDiskInfo->uiSlotID)))
+    {
+        if(!UPGRADE_isDiskResume(uiInnerFrameID, pDiskInfo->uiSlotID))
+        {
+            DBG_LogIntf(DBG_LOG_ERROR, UPGRADE_LOG_ID03ca, "Slot(%u) not found.", pDiskInfo->uiSlotID);
+            UPGRADE_ChangeFrameDiskResult(pDiskInfo->szFrameID, pDiskInfo->uiSlotID, uiLogicID, UPGRADE_DISK_FW_RESU_FAIL);
+            return;
+        }
+        uiNewLogicID = DISK_POSITION_2_LOGIC_ID(uiInnerFrameID, (OSP_U16)pDiskInfo->uiSlotID, DISK_PARTITION_USR);
+        if(UPGRADE_FrameDiskWaitState(uiInnerFrameID, uiNewLogicID))
+        {
+            DBG_LogIntf(DBG_LOG_ERROR, UPGRADE_LOG_ID03d3, "Disk(%u) state is invalid.", uiNewLogicID);
+            UPGRADE_ChangeFrameDiskResult(pDiskInfo->szFrameID, pDiskInfo->uiSlotID, uiLogicID, UPGRADE_DISK_FW_RESU_FAIL);
+            return;
+        }
+    }
+    snprintf(cmd, 256, "/OSM/script/check_disk_recon_finish.sh \"%llu\" \"%s\" \"%d\"",
+                timeSecond, pDiskInfo->szFrameID, pDiskInfo->uiSlotID);
+    DBG_LogIntf(DBG_LOG_INFO, UPGRADE_LOG_ID03d4, "cmd is %s, logicId is %u, BDM exec result is %u", cmd, uiLogicID, uiResult);
+    if((!g_bIsOffline) && (uiResult == UPGRADE_DISK_FW_RESU_SUCCESS) && (TRUE == pDiskInfo->bMemberDisk))
+    {
+        while(uiCount++ < MAX_WAIT_STATE_TIMES)
+        {
+            iRet = LVOS_Execute(cmd);
+            if (iRet < 0)
+            {
+                DBG_LogIntf(DBG_LOG_ERROR, UPGRADE_LOG_ID03d0, "Execute cmd(%s) failed(%d)!", cmd, iRet);
+                UPGRADE_ChangeFrameDiskResult(pDiskInfo->szFrameID, pDiskInfo->uiSlotID, uiLogicID, UPGRADE_DISK_FW_RESU_FAIL);
+                return;
+            }
+            else
+            {
+                UPG_PRINT_LIMIT_PERIOD(UPGRADE_LOG_INFO_INTERVAL, UPGRADE_LOG_INFO_COUNT, DBG_LOG_INFO, UPGRADE_LOG_ID03d0, "Execute cmd(%s) successed(%d)!", cmd, iRet);
+                iScritpRes = iRet >>8;
+                if(iScritpRes == 6)
+                {
+                    UPGRADE_ChangeFrameDiskResult(pDiskInfo->szFrameID, pDiskInfo->uiSlotID, uiLogicID, uiResult);
+                    return;
+                }
+                else if(iScritpRes == 20)
+                {
+                    DBG_LogIntf(DBG_LOG_ERROR, UPGRADE_LOG_ID03d0, "Execute cmd(%s) parameter error!", cmd);
+                    UPGRADE_ChangeFrameDiskResult(pDiskInfo->szFrameID, pDiskInfo->uiSlotID, uiLogicID, UPGRADE_DISK_FW_RESU_FAIL);
+                    return;
+                }
+            }
+            DBG_LogIntf(DBG_LOG_DEBUG, UPGRADE_LOG_ID03cc, "Disk logicId(%u) state is abnomal, Loop(%u).", uiLogicID, uiCount);
+            LVOS_sleep(DISK_WAIT_RESUME_5S);
+        }
+        if(uiCount >= MAX_WAIT_STATE_TIMES)
+        {
+            DBG_LogIntf(DBG_LOG_ERROR, UPGRADE_LOG_ID03cc, "Disk logicId(%u) state is abnomal, Loop(%u).", uiLogicID, uiCount);
+            UPGRADE_ChangeFrameDiskResult(pDiskInfo->szFrameID, pDiskInfo->uiSlotID, uiLogicID, UPGRADE_DISK_FW_RESU_FAIL);
+            return;
+        }
+    }
+    else
+    {
+        UPGRADE_ChangeFrameDiskResult(pDiskInfo->szFrameID, pDiskInfo->uiSlotID, uiLogicID, uiResult);
+    }
     return;
 }
+OSP_VOID UPGRADE_SetBdmInitResult(OSP_VOID *context, OSP_S32 uiResult, OSP_VOID *args)
+{
+    UNREFERENCE_PARAM(args);
+    UNREFERENCE_PARAM(context);
 
+    DBG_LogIntf(DBG_LOG_INFO, UPGRADE_LOG_ID03b8, "BDM ini result(%d).", uiResult);
+
+    g_bIsBDMReturn = TRUE;
+
+    return;
+}
+OSP_VOID UPGRADE_NotifyBdmInit(OSP_VOID)
+{
+    OSP_S32 uiExecRet;
+    OSP_U32 uiCount = 0;
+    g_bIsBDMReturn = FALSE;
+
+    uiExecRet = ldIoCtl(INVALID_VALUE32, 999, NULL, UPGRADE_SetBdmInitResult, NULL);
+    if(RETURN_OK != uiExecRet)
+    {
+        DBG_LogIntf(DBG_LOG_ERROR, UPGRADE_LOG_ID03bf, "Bdm init result (%d)!", uiExecRet);
+        return;
+    }
+
+    while(uiCount++ < 30)
+    {
+        if (TRUE == g_bIsBDMReturn)
+        {
+            g_bIsBDMReturn = FALSE;
+            return;
+        }
+        LVOS_sleep(DISK_WAIT_RESUME_1S);
+    }
+
+    DBG_LogIntf(DBG_LOG_ERROR, UPGRADE_LOG_ID03c8, "It has wait BDM init callback timeout.");
+
+    return;
+}
--- ./source/private_module/src/upgrade_linux_kern.c	2018-03-01 09:06:14.000000000 +0000
+++ ./source/private_module/src/upgrade_linux_kern.c.hotpatch	2021-11-22 10:16:18.000000000 +0000
@@ -55,16 +55,29 @@
     {ASL_CMD_RESETLINK, admModifyAslLink},
     {ASL_CMD_ROLLBACK, admRollbackAsl},
 };
-
-/* ϵͳ״̬ */
+typedef struct tagUPGRADE_DISK_THREAD_RESULT_S
+{
+    OSP_U32 uiSlotID;                            /* Ӳ̲ۺ*/
+    OSP_U32 uiProcessResult;                     /* ǰ*/
+    OSP_U32 uiLogicID;                           /*Ӳ̵߼ID       */
+    OSP_CHAR szFrameID[USER_FRAME_ID_LENGTH];    /* ûţDKE000 */
+    OSP_BOOL bIsBDMReturn;
+    OSP_U32 excBDMResult;
+}UPGRADE_DISK_THREAD_RESULT_S;
+typedef struct tagDISK_FRAME_SLOT_INFO_NEW_S
+{
+   OSP_U32 uiSlotID;                            /* ۺ*/
+   OSP_CHAR szFrameID[USER_FRAME_ID_LENGTH];    /* ţDKE000 */
+   OSP_BOOL bMemberDisk;
+}DISK_FRAME_SLOT_INFO_NEW_S;
+#define DISK_MAX_NUM            (3000)
+OSP_BOOL UPGRADE_CheckThreadResult(OSP_CHAR *szUserFrameID, OSP_U32 uiSlot);
 OSP_U32 g_uiSysExeOperatorFlag = UPGRADE_SYS_STATUS_WAIT;
-
-/* Ƿnormal״̬ */
 OSP_BOOL g_bControllerStatusFlag = FALSE;
 
-/* ӲĽṹ*/
 UPGRADE_DISK_RESULT_S g_stDiskUpgradeResult[DISK_STAT_MAX_NUM] = {{0}};
-
+UPGRADE_DISK_RESULT_S g_stDiskUpgradeResultNew[DISK_MAX_NUM] = {{0}};
+UPGRADE_DISK_THREAD_RESULT_S g_stDiskUpgradeThreadResult[10] = {{0}};
 /* Ӳ̲ѯĽṹ */
 DISK_RESUME_RESULT_S g_stDiskResumeCheck = {0};
 
@@ -86,6 +99,8 @@
 #ifndef _DT_
 extern OSP_S32 UPGRADE_SysDiskUpgradeInKern(OSP_U32 uiCmd, LVOS_SYSCALL_PARAM_S *pstParam);
 #endif
+extern OSP_VOID UPGRADE_NotifyBdmInit(VOID);
+extern OSP_VOID UPGRADE_UpgradeSingleDiskInKernNew(DISK_FRAME_SLOT_INFO_NEW_S *pDiskInfo);
 /* ϵͳں̬ģӿ,֧256ӿ */
 static LVOS_GROUP_SYSCALL_S s_astUpgradeSyscalls[] =
 {
@@ -172,21 +187,6 @@
 };
 
 #ifndef _DT_
-/*****************************************************************************
-     : UPGRADE_GetSysDiskStateInKernel
-   : ϵͳ״̬,ǷλԼϵͳǷ (69豸)
-   : 
-   : 
-   ֵ  : OSP_S32
- ú  :
-   :
-
- ޸ʷ      :
-  1.       : 20120628
-           : l90005937
-    ޸   : ɺ
-
-*****************************************************************************/
 OSP_S32 UPGRADE_GetSysDiskStateInKernel(OSP_U32 v_uiCmd, LVOS_SYSCALL_PARAM_S *v_pstParam)
 {
     OSP_U32 uiProductId = INVALID_VALUE32;
@@ -509,14 +509,22 @@
 
     /* ʼӲ */
     LVOS_mutex_lock(&g_stDiskStatMutex); /*  */
-    memset(g_stDiskUpgradeResult, 0, sizeof(g_stDiskUpgradeResult));
-    for(uiLoop = 0; uiLoop < DISK_STAT_MAX_NUM; uiLoop++)
+    memset(g_stDiskUpgradeResultNew, 0, sizeof(g_stDiskUpgradeResultNew));
+    for(uiLoop = 0; uiLoop < DISK_MAX_NUM; uiLoop++)
     {
-        g_stDiskUpgradeResult[uiLoop].uiSlotID = INVALID_VALUE32;
-        g_stDiskUpgradeResult[uiLoop].uiLogicID = INVALID_VALUE32;
+        g_stDiskUpgradeResultNew[uiLoop].uiSlotID = INVALID_VALUE32;
+        g_stDiskUpgradeResultNew[uiLoop].uiLogicID = INVALID_VALUE32;
     }
     LVOS_mutex_unlock(&g_stDiskStatMutex); /* ͷ */
-
+    LVOS_mutex_lock(&g_stDiskStatMutex);
+    memset(g_stDiskUpgradeThreadResult, 0, sizeof(g_stDiskUpgradeThreadResult));
+    for(uiLoop = 0; uiLoop < 10; uiLoop++)
+    {
+        g_stDiskUpgradeThreadResult[uiLoop].uiSlotID = INVALID_VALUE32;
+        g_stDiskUpgradeThreadResult[uiLoop].uiLogicID = INVALID_VALUE32;
+    }
+    LVOS_mutex_unlock(&g_stDiskStatMutex);
+    UPGRADE_NotifyBdmInit();
     return RETURN_OK;
 }
 
@@ -538,8 +546,9 @@
 *****************************************************************************/
 OSP_S32 UPGRADE_GetDiskUpgradeResultInKernel(OSP_VOID *v_pMsg, MSG_INFO_S *v_pMsgInfo)
 {
-    OSP_U32 uiIndex = 0;
+    OSP_S32 uiIndex = 0;
     OSP_VOID *pAckObj = NULL;
+    OSP_U32 uiResultNum = 0;
 
     UNREFERENCE_PARAM(v_pMsgInfo);
 
@@ -552,29 +561,43 @@
     }
     LVOS_mutex_lock(&g_stDiskStatMutex); /*  */
 
-    for (uiIndex = 0; uiIndex < DISK_STAT_MAX_NUM; uiIndex++)
+    for (uiIndex = 0; uiIndex < DISK_MAX_NUM; uiIndex++)
     {
-        MSGOBJ_SetItemUnsigned(pAckObj, 0, (OSP_U32)uiIndex, (OSP_U64)g_stDiskUpgradeResult[uiIndex].uiSlotID, sizeof(OSP_U32));
-        MSGOBJ_SetItemUnsigned(pAckObj, 1, (OSP_U32)uiIndex, (OSP_U64)g_stDiskUpgradeResult[uiIndex].uiProcessResult, sizeof(OSP_U32));
-        MSGOBJ_SetItemString(pAckObj, 2, (OSP_U32)uiIndex, g_stDiskUpgradeResult[uiIndex].szFrameID);
         /* ȡӲ̽״ֵ̬ */
-        if(UPGRADE_DISK_FW_RESU_INVALID != g_stDiskUpgradeResult[uiIndex].uiProcessResult)
+        if(UPGRADE_DISK_FW_RESU_INVALID != g_stDiskUpgradeResultNew[uiIndex].uiProcessResult)
         {
-            UPG_LogInfo(UPGRADE_LOG_ID0ab7, "Send result(%u) of frame(%s) and slot (%u) to cli, Init the struct(index:%u).",
-                g_stDiskUpgradeResult[uiIndex].uiProcessResult, g_stDiskUpgradeResult[uiIndex].szFrameID,
-                g_stDiskUpgradeResult[uiIndex].uiSlotID, uiIndex);
-
-            memset(&(g_stDiskUpgradeResult[uiIndex]), 0, sizeof(UPGRADE_DISK_RESULT_S));
-            g_stDiskUpgradeResult[uiIndex].uiLogicID= INVALID_VALUE32;
-            g_stDiskUpgradeResult[uiIndex].uiSlotID = INVALID_VALUE32;
+            UPG_PRINT_LIMIT_PERIOD(UPGRADE_LOG_INFO_INTERVAL, UPGRADE_LOG_INFO_COUNT, DBG_LOG_INFO, UPGRADE_LOG_ID0ab7, "Send result(%u) of frame(%s) and slot (%u) to cli, Init the struct(index:%u).",
+                g_stDiskUpgradeResultNew[uiIndex].uiProcessResult, g_stDiskUpgradeResultNew[uiIndex].szFrameID,
+                g_stDiskUpgradeResultNew[uiIndex].uiSlotID, uiIndex);
+            MSGOBJ_SetItemUnsigned(pAckObj, 0, (OSP_U32)uiResultNum, (OSP_U64)g_stDiskUpgradeResultNew[uiIndex].uiSlotID, sizeof(OSP_U32));
+            MSGOBJ_SetItemUnsigned(pAckObj, 1, (OSP_U32)uiResultNum, (OSP_U64)g_stDiskUpgradeResultNew[uiIndex].uiProcessResult, sizeof(OSP_U32));
+            MSGOBJ_SetItemString(pAckObj, 2, (OSP_U32)uiResultNum, g_stDiskUpgradeResultNew[uiIndex].szFrameID);
+            if (UPGRADE_DISK_FW_RESU_UPGRADE != g_stDiskUpgradeResultNew[uiIndex].uiProcessResult)
+            {
+                memset(&(g_stDiskUpgradeResultNew[uiIndex]), 0, sizeof(UPGRADE_DISK_RESULT_S));
+                g_stDiskUpgradeResultNew[uiIndex].uiLogicID= INVALID_VALUE32;
+                g_stDiskUpgradeResultNew[uiIndex].uiSlotID = INVALID_VALUE32;
+            }
+            uiResultNum++;
+        }
+
+        if (DISK_STAT_MAX_NUM == uiResultNum)
+        {
+            break;
         }
     }
 
     LVOS_mutex_unlock(&g_stDiskStatMutex); /* ͷ */
+    /* û¼ʱһռ¼Ϣ */
+    if (0 == uiResultNum)
+    {
+        MSGOBJ_SetItemUnsigned(pAckObj, 0, 0, (OSP_U64)0, sizeof(OSP_U32));
+        MSGOBJ_SetItemUnsigned(pAckObj, 1, 0, (OSP_U64)UPGRADE_DISK_FW_RESU_INVALID, sizeof(OSP_U32));
+        MSGOBJ_SetItemString(pAckObj, 2, 0, "");
+    }
 
     UPGRADE_TlvPostAckMsg(v_pMsg, pAckObj);
 
-
     MSGOBJ_Destroy(pAckObj);
     return RETURN_OK;
 }
@@ -597,7 +620,7 @@
 OSP_S32 UPGRADE_SetDiskUpgradeResultInKernel(OSP_VOID *v_pMsg, MSG_INFO_S *v_pMsgInfo)
 {
     OSP_VOID *pMsgObjDecode = NULL;
-    OSP_U32 index;
+
     OSP_U32 uiResult = UPGRADE_DISK_FW_RESU_INVALID;
     OSP_CHAR *pszFrameID = NULL;
 
@@ -607,39 +630,30 @@
         DBG_LogIntf(DBG_LOG_ERROR, UPGRADE_LOG_ID0ab9, "Decode Failed!");
         UPGRADE_TlvPostAckOnlyUnsignedRet(v_pMsg, (OSP_U64)MSG_OP_UPGRADE_SET_DISK_RESULT,
             (OSP_U64)RETURN_ERROR, TRUE);
+
         return RETURN_ERROR;
     }
 
     LVOS_mutex_lock(&g_stDiskStatMutex); /*  */
-    /* ӲϢ */
-    for(index = 0; index < DISK_STAT_MAX_NUM; index++)
+
+    if (MSGOBJ_ITEM_TYPE_INVALID != MSGOBJ_GetItemType(pMsgObjDecode, 0, 0))
     {
-        if (MSGOBJ_ITEM_TYPE_INVALID != MSGOBJ_GetItemType(pMsgObjDecode, 0, index))
+        MSGOBJ_GetItemUnsigned(pMsgObjDecode, 1, 0, (OSP_VOID *)&uiResult, sizeof(OSP_U32));
+
+        if(UPGRADE_DISK_FW_RESU_INVALID != uiResult)
         {
-            MSGOBJ_GetItemUnsigned(pMsgObjDecode, 1, index, (OSP_VOID *)&uiResult, sizeof(OSP_U32));
-            if(UPGRADE_DISK_FW_RESU_INVALID != uiResult)
-            {
-                MSGOBJ_GetItemUnsigned(pMsgObjDecode, 0, index, (OSP_VOID *)&g_stDiskUpgradeResult[index].uiSlotID, sizeof(OSP_U32));
-                MSGOBJ_GetItemUnsigned(pMsgObjDecode, 1, index, (OSP_VOID *)&g_stDiskUpgradeResult[index].uiProcessResult, sizeof(OSP_U32));
-                MSGOBJ_GetItemString(pMsgObjDecode, 2, index, &pszFrameID);
-
-                if (NULL == pszFrameID)
-                {
-                    continue;    
-                }
-                
-                LVOS_strncpy(g_stDiskUpgradeResult[index].szFrameID, pszFrameID, USER_FRAME_ID_LENGTH);
-
-                if(UPGRADE_DISK_FW_RESU_INVALID == g_stDiskUpgradeResult[index].uiProcessResult)
-                {
-                    continue;
-                }
-                DBG_LogIntf(DBG_LOG_INFO, UPGRADE_LOG_ID0aba, "Set upgrade disk result in kernel, frameId(%s), slotId(%u), result(%u).",
-                    g_stDiskUpgradeResult[index].szFrameID,
-                    g_stDiskUpgradeResult[index].uiSlotID,
-                    g_stDiskUpgradeResult[index].uiProcessResult);
-            }
-            uiResult = UPGRADE_DISK_FW_RESU_INVALID;
+            MSGOBJ_GetItemUnsigned(pMsgObjDecode, 0, 0, (OSP_VOID *)&g_stDiskUpgradeResultNew[0].uiSlotID, sizeof(OSP_U32));
+
+            MSGOBJ_GetItemUnsigned(pMsgObjDecode, 1, 0, (OSP_VOID *)&g_stDiskUpgradeResultNew[0].uiProcessResult, sizeof(OSP_U32));
+
+            MSGOBJ_GetItemString(pMsgObjDecode, 2, 0, &pszFrameID);
+
+            LVOS_strncpy(g_stDiskUpgradeResultNew[0].szFrameID, pszFrameID, USER_FRAME_ID_LENGTH);
+
+            DBG_LogIntf(DBG_LOG_INFO, UPGRADE_LOG_ID0aba, "Set upgrade disk result in kernel, frameId(%s), slotId(%u), result(%u).",
+                g_stDiskUpgradeResultNew[0].szFrameID,
+                g_stDiskUpgradeResultNew[0].uiSlotID,
+                g_stDiskUpgradeResultNew[0].uiProcessResult);
         }
     }
     LVOS_mutex_unlock(&g_stDiskStatMutex); /* ͷ */
@@ -654,21 +668,7 @@
     return RETURN_OK;
 }
 
-/*****************************************************************************
-     : UPGRADE_GetFrameIsValidStatusInInKernel
-   : жϢǷȫѯȡ,,FALSE
-   : OSP_U32 v_uiCmd, LVOS_SYSCALL_PARAM_S *v_pstParam
-   : 
-   ֵ  : OSP_S32
- ú  :
-   :
-
- ޸ʷ      :
-  1.       : 201236
-           : l90004318
-    ޸   : ɺ
 
-*****************************************************************************/
 OSP_S32 UPGRADE_GetFrameIsValidStatusInKernel(OSP_U32 v_uiCmd, LVOS_SYSCALL_PARAM_S *v_pstParam)
 {
     OSP_BOOL bIsValidStat = TRUE;
@@ -678,10 +678,10 @@
 
     LVOS_mutex_lock(&g_stDiskStatMutex); /*  */
 
-    for (uiIndex = 0; uiIndex < DISK_STAT_MAX_NUM; uiIndex++)
+    for (uiIndex = 0; uiIndex < DISK_MAX_NUM; uiIndex++)
     {
-        DBG_LogIntf(DBG_LOG_DEBUG, UPGRADE_LOG_ID0abc, "GetFrameIsValidStatusInKerne:slot(%u).", g_stDiskUpgradeResult[uiIndex].uiSlotID);
-        if(INVALID_VALUE32 != g_stDiskUpgradeResult[uiIndex].uiSlotID)
+        DBG_LogIntf(DBG_LOG_DEBUG, UPGRADE_LOG_ID0abc, "GetFrameIsValidStatusInKerne:slot(%u).", g_stDiskUpgradeResultNew[uiIndex].uiSlotID);
+        if(INVALID_VALUE32 != g_stDiskUpgradeResultNew[uiIndex].uiSlotID)
         {
             //ϴͷûbreakΪʲô?
             bIsValidStat = FALSE;
@@ -868,19 +868,19 @@
 *****************************************************************************/
 OSP_S32 UPGRADE_SingleDiskUpgradeInKernel(OSP_U32 v_uiCmd, LVOS_SYSCALL_PARAM_S *v_pstParam)
 {
-    DISK_FRAME_SLOT_INFO_S *pDiskInfo = NULL;
-
+    DISK_FRAME_SLOT_INFO_NEW_S *pDiskInfo = NULL;
+    OSP_BOOL bFail = FALSE;
     UNREFERENCE_PARAM(v_uiCmd);
-
-    if ((NULL == v_pstParam) || (NULL == v_pstParam->pvInBuf))
+    if ((NULL == v_pstParam) || (NULL == v_pstParam->pvInBuf) || (NULL == v_pstParam->pvOutBuf))
     {
         DBG_LogIntf(DBG_LOG_ERROR, UPGRADE_LOG_ID0acf, "Parameter is NULL.");
         return RETURN_ERROR;
     }
-
-    pDiskInfo = (DISK_FRAME_SLOT_INFO_S *)(v_pstParam->pvInBuf);
-
-    UPGRADE_UpgradeSingleDiskInKern(pDiskInfo);
+    pDiskInfo = (DISK_FRAME_SLOT_INFO_NEW_S *)(v_pstParam->pvInBuf);
+    UPGRADE_UpgradeSingleDiskInKernNew(pDiskInfo);
+    bFail = UPGRADE_CheckThreadResult(pDiskInfo->szFrameID, pDiskInfo->uiSlotID);
+    *(OSP_BOOL *)(v_pstParam->pvOutBuf) = bFail;
+    v_pstParam->uiRetBufLen = sizeof(OSP_BOOL);
 
     return RETURN_OK;
 }
@@ -2569,5 +2569,31 @@
     v_pstParam->uiRetBufLen = sizeof(OSP_U32);
     return iRet;
 }
-
+OSP_BOOL UPGRADE_CheckThreadResult(OSP_CHAR *szUserFrameID, OSP_U32 uiSlot)
+{
+    OSP_BOOL bFail = FALSE;
+    OSP_U32 uiLoop = 0;
+    LVOS_mutex_lock(&g_stDiskStatMutex);
+    for(uiLoop = 0; uiLoop < 10; uiLoop++)
+    {
+        if((0 == strncmp(szUserFrameID, g_stDiskUpgradeThreadResult[uiLoop].szFrameID, USER_FRAME_ID_LENGTH))
+            && (uiSlot == g_stDiskUpgradeThreadResult[uiLoop].uiSlotID))
+        {
+            if (UPGRADE_DISK_FW_RESU_FAIL == g_stDiskUpgradeThreadResult[uiLoop].uiProcessResult ||
+                UPGRADE_UPDATE_FW_FILE_FAILED == g_stDiskUpgradeThreadResult[uiLoop].uiProcessResult)
+            {
+                bFail = TRUE;
+            }
+            LVOS_strncpy(g_stDiskUpgradeThreadResult[uiLoop].szFrameID, "", USER_FRAME_ID_LENGTH);
+            g_stDiskUpgradeThreadResult[uiLoop].uiSlotID = INVALID_VALUE32;
+            g_stDiskUpgradeThreadResult[uiLoop].uiLogicID = INVALID_VALUE32;
+            g_stDiskUpgradeThreadResult[uiLoop].uiProcessResult = UPGRADE_DISK_FW_RESU_INVALID;
+            g_stDiskUpgradeThreadResult[uiLoop].bIsBDMReturn= FALSE;
+            g_stDiskUpgradeThreadResult[uiLoop].excBDMResult= UPGRADE_DISK_FW_RESU_INVALID;
+            break;
+        }
+    }
+    LVOS_mutex_unlock(&g_stDiskStatMutex);
+    return bFail;
+}
 
