--- ./source/private_module/ld/ld_debug.c	2018-03-14 11:05:13.000000000 +0000
+++ ./source/private_module/ld/ld_debug.c.hotpatch	2018-08-24 10:59:26.000000000 +0000
@@ -6163,22 +6163,22 @@
     g_ldDbgUpgradeResult = result;
     LVOS_sema_up(sema);
 }
-
+void ldDoDbgCmdUpgradeFWConfCallback(void *context, int32_t result, void *args);
 void ldDoDbgCmdUpgrade(int32_t argc, char *argv[])
 {
     int32_t ret = RETURN_ERROR;
     uint32_t logicId = 0;
     IOCTRL_SET_DISK_UPGRADE_FW_PARAM_S diskUpgradeMode;
     LVOS_SEMAPHORE_S semp;
-
-    if ( argc < 3 )
-    {
+    if ( argc < 3 ){
         DBG_Print("Please input valid param\n");
         return;
     }
     logicId = (uint32_t)LVOS_StrToU64(argv[2]);
     diskUpgradeMode.upgradeMode = 1;
     LVOS_sema_init(&semp, 0);
+    ret = ldIoCtl(logicId, (LOGIC_DISK_IOCTRL_CMND_E)999, &diskUpgradeMode, ldDoDbgCmdUpgradeFWConfCallback, (void*)&semp);//ִиºڰ
+    LVOS_sema_down(&semp);
     ret = ldIoCtl(logicId, IOCTRL_SET_DISK_UPGRADE_FW, &diskUpgradeMode, ldDoDbgCmdUpgradeCallback, (void*)&semp);
     if (RETURN_OK != ret)
     {
@@ -7515,3 +7515,13 @@
 }
 /*End Modified by y00355707 ϵͳ 20170627*/
 
+void ldDoDbgCmdUpgradeFWConfCallback(void *context, int32_t result, void *args)
+{
+    LVOS_SEMAPHORE_S *sema = (LVOS_SEMAPHORE_S*)context;
+    UNREFERENCE_PARAM(args);
+    DBG_Print("Update disk hddconf %s.\n", (RETURN_OK == result) ? "success" : "failed");    
+    //g_ldDbgUpgradeResult = result;
+    LVOS_sema_up(sema);
+}
+
+
--- ./source/private_module/ld/stub_v3/stub_ld.c	2018-04-11 12:46:26.000000000 +0000
+++ ./source/private_module/ld/stub_v3/stub_ld.c.hotpatch	2018-08-24 10:59:26.000000000 +0000
@@ -486,22 +486,20 @@
 
     return RETURN_OK;
 }
-
+static inline bool ldCheckStopPartitionDbDisk(LD_S* logicDisk);
+static inline bool ldCheckStopPartitionRootDisk(LD_S* logicDisk);
+static inline bool ldCheckStopPartitionUsrOrVault(LD_S* logicDisk);
+//uint32_t g_ldpartitionTypeBitmap = 0;
 /**************************************************************************
    : ldGetCheckedLogicDisk
      : ȡڵ߼
  : REQ_S* req   : LDreq        
  : 
-   ֵ: LD_S* : NULL : ȡʧ
-           NULL       : ȡɹ߼ָ   
-     : 
 **************************************************************************/
 LD_S* stub_ldGetCheckedLogicDisk(REQ_S* req)
 {  
     LD_S* logicDisk = NULL;
     LD_REQ_PRIVATE_INFO* private = NULL;
-
-    /*Begin Modified by l90005948 SR-0000268771 20140513*/
     IOCTRL_GET_DISK_ALIGN_SIZE_PARAM_S args;
 
     memset((void *)&args, MEM_INIT_VAL, sizeof(IOCTRL_GET_DISK_ALIGN_SIZE_PARAM_S));
@@ -568,16 +566,18 @@
         }
     }
     /*End Modified by l90005948 SR-0000268771 20140513*/
-
     if (g_ldLocalNodeIsStop)
     {
-        if (DISK_PARTITION_VAULT != logicDisk->partitionType)
-        {
-            /*Begin Modified by l90005948 DTS2014072205903  20140730*/
-            BDM_PRINT_LIMIT_PERIOD(5*HZ, 1, DBG_LOG_WARNING, LOG_ID_LD_0518,
-                "Sys inform bdm hold io: req(0x%p), logicId(%llu), opCode(0x%x), lba(%llu), len(%d).", 
-                req, req->objectId, req->opCode, req->objectLba, req->length);
-            /*End Modified by l90005948 DTS2014072205903  20140730*/
+        if (ldCheckStopPartitionDbDisk(logicDisk) 
+            || ldCheckStopPartitionRootDisk(logicDisk) 
+            || ldCheckStopPartitionUsrOrVault(logicDisk))
+        {
+            BDM_PRINT_LIMIT_PERIOD(5*HZ, 1, DBG_LOG_WARNING, LOG_ID_LD_0501,
+                "Sys inform bdm hold io(type : 0x%x): req(0x%p), logicId(%llu), opCode(0x%x), lba(%llu), len(%d).", 
+                g_ldpartitionTypeBitmap, req, req->objectId, req->opCode, req->objectLba, req->length);
+
+            req->result = IO_ERR_ABNORMAL_ERROR;
+            IOD_ADD_DONEQ(req);
             return NULL;
         }
     }
@@ -1505,7 +1505,7 @@
     }
 }
 
-
+void ldSetTrimIoTimeout(REQ_S *req);
 /**************************************************************************
    : ldDiskReqSetDefaultInfo
      : ld reqĬ
@@ -1584,7 +1584,7 @@
         /*End Modified by w90005722 DTS2015031103947 20150211*/
     }
     private->timeout = (int64_t)(((uint64_t)private->fgIoStgy.ioTimeOut * HZ)/1000);
-    /*һtimeoutΪ²㳬ʱʱ*/
+    ldSetTrimIoTimeout(req);
     private->actionInfo.timeOut = (uint32_t)private->fgIoStgy.sioTimeOut;
     return RETURN_OK;
 }
@@ -1609,15 +1609,15 @@
     }
 }
 /*End Modified by t00352166 SR-0000271883  20160813*/
+void ldDiskReqSetChildReqInfoPatch(REQ_S *req, LD_REQ_PRIVATE_INFO* private);
+int32_t ldDiskReqProcMulDiskDiagnose(REQ_S *req, REQ_S *childReq, LD_S* logicDisk, uint32_t diagInfo);
+void ldDiskClearMulDiskDiagnoseFlag(LD_S* logicDisk);
 
 /**
 * @brief    sioreqĲ
 * @param    req     
 * @param    childReq
-* @return   NA    
-
 * @exception    None
-
 * @author   m90005436 
 * @date     2017/10/9
 */
@@ -1674,14 +1674,16 @@
     uint32_t diagInfo = 0;
     uint64_t reservedSec = 0x100000; /* ӲԤ */
     uint64_t upperPhyLbaStart = 0;
-
     diagInfo = (((uint32_t)private->diagErrorInfo.sk<<24) | ((uint32_t)private->diagErrorInfo.asc<<16) |
                         ((uint32_t)private->diagErrorInfo.ascq<<8) | ((uint32_t)private->diagErrorInfo.fru));
+    if (RETURN_OK != ldDiskReqProcMulDiskDiagnose(req, childReq, logicDisk, diagInfo))  //??begin  
+    {
+        BDM_LOG_ERR_CAN_PRINT(DBG_LOG_BUTT, (360*HZ), 1ULL, "The result of multiple disk diagnose is not ok, ldid %u.", (uint32_t)req->objectId);         
+        return RETURN_ERROR;
+    }
     switch(private->actionInfo.action)
     {
         case CFG_IO_ERROR_ACTION_QUICK_DIAGNOSE:
-            //SDϽӿ
-            /*Begin Modified by j00285232 DTS2015072206717 20150723*/
             BDM_LOG_ERR_CAN_PRINT(LOG_ID_LD_0041,
                 (1*HZ),
                 req->objectId,
@@ -1702,9 +1704,7 @@
             sdDiagInfo.errLen = private->errLen;
             sdDiagInfo.errCode = diagInfo;
             sdDiagInfo.opCode = req->opCode;
-            /*Begin Modified by j90006936 DTS2014111100568 2014.11.27*/
             sdDiagInfo.isDidError = (0 == private->newErrorInfo.hostByte) ? 0 : 1;
-            /*End Modified by j90006936 DTS2014111100568 2014.11.27*/
             SET_BIT32(private->flag, LD_REQ_DIAG_MASK);
             private->diagExeNid = GET_LOCAL_NID();
             if (BDM_CFG_IO_TYPE_DISK_FOREEND == private->ioInfo.ioType)
@@ -1720,6 +1720,7 @@
             (void)sdDevicePowerCycle((uint32_t)childReq->objectId, childReq, 
                                         private->actionInfo.timeOut, repairTimeout, &sdDiagInfo);
             private->fgIoStgy.rePairTimeOut = 0;
+            ldDiskClearMulDiskDiagnoseFlag(logicDisk);
             return RETURN_ERROR;
         case CFG_IO_ERROR_ACTION_DEVICE_RESET:
             private->timeout += (int64_t)(((uint64_t)private->fgIoStgy.rePairTimeOut/1000)*HZ);/*תHZ*/
@@ -1729,7 +1730,6 @@
             private->fgIoStgy.rePairTimeOut = 0;
             return RETURN_ERROR;
         case CFG_IO_ERROR_ACTION_DIAGNOSE:
-            //SDϽӿ
             ANY_TRACE_CALL(LD_DISK_REQ_ERROR_TRACE, 3, "LD disk req(0x%p) current diagnose(stgyId:%u)(diagId:%u).", 
                     req, private->strategyInfo.curStgyCode, private->actionInfo.diagnoseId);
             /*Begin Modified by j00285232 DTS2015072206717 20150723*/
@@ -1768,7 +1768,7 @@
             req->result = (int32_t)private->strategyInfo.errCode;
             /* DTS2016022407985 modify by y00376877 20160803 begin */
             BDM_IOD_ADD_DONEQ(req);
-            /* DTS2016022407985 modify by y00376877 20160803 end */
+            ldDiskClearMulDiskDiagnoseFlag(logicDisk);
             return RETURN_ERROR;
         default:
             return RETURN_OK;
@@ -1839,22 +1839,22 @@
             req->result = BDM_IO_ERROR;
             memset(&private->newErrorInfo, 0, sizeof(CFG_ERR_INFO_S));
             private->newErrorInfo.bdmByte = BDM_INNER_ERROR_NO_PATH;
-            if (BDM_TEST_BIT(LD_REQ_FWD_MASK, (void*)&private->flag))
-            {
-                /* DTS2016022407985 modify by y00376877 20160803 begin */
-                BDM_IOD_ADD_DONEQ(req);
-                /* DTS2016022407985 modify by y00376877 20160803 end */
-            }
-            else
-            {
-                ldDiskReqInquiryStrategy(req);
-            }
+            ldDiskReqSetChildReqInfoPatch(req, private);
             return RETURN_ERROR;
         }
         sdFlushHungIO((uint32_t)childReq->objectId, FALSE);
         return RETURN_ERROR;
     }
- 
+
+
+
+
+
+
+
+
+
+    
     /*Begin Modified by l90005948 DTS2014061700462 20140616*/   
     /*Begin Modified by t00352166 SR-0000271883  20160813*/
     ret = ldHandleSpecOpcode(req, childReq, logicDisk->hwSectorSize);
@@ -4741,7 +4741,7 @@
     }
     return ret;
 }
-
+#define IOCTRL_UPDATE_SD_FW_CONF (999)
 /**************************************************************************
    : ldIoCtlInner
      : úͲѯ߼Խӿ
@@ -4754,35 +4754,35 @@
  : 
    ֵ: int32_t : RETURN_OK : ɹ
                                   RETURN_ERROR :  ʧ
-     : ldIoCtlʱIOD_ADD_LOW_BLOCK_CMDQǶʹ
-**************************************************************************/
+     : ldIoCtlʱIOD_ADD_LOW_BLOCK_CMDQǶʹ******/
+extern int32_t ldProcUpConfIOCtrlCmd(uint32_t logicId, LOGIC_DISK_IOCTRL_CMND_E cmnd, void * args, void(* ayncCallBack)(void *, int32_t, void *), void * context);
 int32_t stub_ldIoCtl(uint32_t logicId, LOGIC_DISK_IOCTRL_CMND_E cmnd, void* args, 
                             void (*ayncCallBack)(void *, int32_t, void *), void *context)
 {
     int32_t ret = RETURN_ERROR;
     uint64_t printKey = 0;
-
+    int32_t tmpCmnd = (int32_t)cmnd;
+    if (IOCTRL_UPDATE_SD_FW_CONF == tmpCmnd){
+        ret = ldProcUpConfIOCtrlCmd(logicId, cmnd, args, ayncCallBack, context);
+        DBG_LogInfo(LOG_ID_LD_008E, "[BDM_FW]: Finish Update FW conf, ret[%d].", ret);
+        return ret;
+    }
     if (cmnd >= IOCTRL_CMMND_BUTT)
     {
         DBG_LogError(LOG_ID_LD_008E, "Input cmnd(%d) invalid, fail to operate disk LogicId(%u).", cmnd, logicId);
         return ret;
     }
-    
-     /* 豸 */
     if (!ldIsDiskExist(logicId))
     {
         DBG_LogError(LOG_ID_LD_008F, "Logic disk is not exsit:logicId(%u), cmnd(%d).", logicId, cmnd);
         return ret;
     }
-
     ret = ldIoCtlInnerCheckArgs(cmnd, args,logicId);
     if (RETURN_OK != ret)
     {
-        /*Begin Modified by w90005722 CR-01770370 20150403*/
         printKey = (uint64_t)cmnd<<32|logicId;
         BDM_LOG_ERR_CAN_PRINT(LOG_ID_LD_0090, 30 * HZ, printKey, "Cmnd inalid ,LogicId(%u), cmnd(%u), ret(%u).",logicId, cmnd, ret);
         return ret;
-        /*End Modified by w90005722 CR-01770370 20150403*/
     }       
     
     ret = ldProcIOCtrlCmd(logicId, cmnd, args, ayncCallBack, context);  
@@ -5195,3 +5195,378 @@
 /* PC-Lint */
 LD_USE_TRACE_POINT
 
+extern int32_t sdUpgradeUpdateFWConfSync(void* args);
+/**************************************************************************
+   : ldProcUpConfIOCtrlCmdHandler
+     : up Conf IOCtrlֵĴ
+ :CMD_S *cmd: IOD CMDָ
+ : 
+   ֵ: 
+     : 
+**************************************************************************/
+void ldProcUpConfIOCtrlCmdHandler(CMD_S *cmd)
+{
+    uint64_t* ptr = NULL;
+    IOCTRLCMD_SEND_PRIVATE_S* private = NULL;
+    //LD_S *logicDisk = NULL;
+    int32_t ret = RETURN_ERROR;
+    
+    if (NULL == cmd)
+    {
+        DBG_LogError(LOG_ID_LD_0081, "[BDM_FW]: cmd is NULL.");
+        return;
+    }
+
+    ptr = (uint64_t*)cmd->privateData;
+    private = (IOCTRLCMD_SEND_PRIVATE_S*)(*ptr);
+    FREE_STRUCTURE(cmd, g_ldPoolId.ldCmdPoolId);
+
+    ret = sdUpgradeUpdateFWConfSync(private->args);
+
+    DBG_LogInfo(LOG_ID_LD_0082, "[BDM_FW]: Update FW conf %s, cmd(%d).", (RETURN_OK == ret) ? "success" : "failed", private->cmdCode);
+
+    if (NULL == private->ayncCallBack)
+    {
+        DBG_LogError(LOG_ID_LD_0083, "[BDM_FW]: call back is NULL, cmd(%d).", private->cmdCode);
+        FREE_STRUCTURE(private, g_ldPoolId.callBackParamPoolId);
+        return;   
+    }
+
+    private->ayncCallBack(private->context, ret, private->args);
+    FREE_STRUCTURE(private, g_ldPoolId.callBackParamPoolId);
+    return;   
+}
+
+
+/**************************************************************************
+   : ldProcUpConfIOCtrlCmd
+     : лTPOOLĴ
+ :  logicId: ߼ID
+ : 
+   ֵ: RETURN_OK:ִгɹ;RETURN_ERROR:ִʧ
+     : 
+**************************************************************************/
+int32_t ldProcUpConfIOCtrlCmd(uint32_t logicId, LOGIC_DISK_IOCTRL_CMND_E cmnd, void* args,
+                                 void (*ayncCallBack)(void *, int32_t, void *), void *context)
+{
+    uint64_t* ptr = NULL;
+    CMD_S *cmd = NULL; 
+    IOCTRLCMD_SEND_PRIVATE_S *private = NULL;
+    int32_t ret = RETURN_ERROR;
+    
+    ALLOCATE_STRUCTURE(MY_PID, g_ldPoolId.callBackParamPoolId, (void**)&private);
+    if (NULL == private)
+    {
+        /*Begin Modified by w90005722 DTS2015011905882 20150122*/
+        BDM_LOG_ERR_CAN_PRINT(LOG_ID_LD_0082, LD_LOG_INTERVAL_DEFULT, (uint64_t)logicId, 
+                                "Malloc private failed, logicId(%u), cmnd(%u).", 
+                                logicId, (uint32_t)cmnd);
+        /*End Modified by w90005722 DTS2015011905882 20150122*/
+        return ret;
+    }    
+    
+    ALLOCATE_STRUCTURE(MY_PID, g_ldPoolId.ldCmdPoolId, (void**)&cmd);
+    if (NULL == cmd)
+    {
+        FREE_STRUCTURE(private, g_ldPoolId.callBackParamPoolId);
+        /*Begin Modified by w90005722 DTS2015011905882 20150122*/
+        BDM_LOG_ERR_CAN_PRINT(LOG_ID_LD_0083, LD_LOG_INTERVAL_DEFULT, (uint64_t)logicId, 
+                                "Allocate cmd failed, logicId(%u), cmnd(%u).", 
+                                logicId, (uint32_t)cmnd);
+        /*End Modified by w90005722 DTS2015011905882 20150122*/
+        return ret;
+    }
+
+    private->logicId = logicId;
+    private->cmdCode = cmnd;
+    private->args = args;
+    private->ayncCallBack = ayncCallBack;
+    private->context = context;
+    
+    (void)IOD_INIT_CMD(MY_PID, cmd);
+    cmd->execute = ldProcUpConfIOCtrlCmdHandler;
+    ptr = (uint64_t*)(void*)cmd->privateData;
+    *ptr = (uint64_t)private;
+
+    if (RETURN_OK != ldProcIoctrlAdd2Tpool(cmnd, cmd, LD_IOCTRL_THREAD_TPOOL_HIGH))
+    {
+        FREE_STRUCTURE(private, g_ldPoolId.callBackParamPoolId);
+        FREE_STRUCTURE(cmd, g_ldPoolId.ldCmdPoolId);
+        DBG_LogError(LOG_ID_LD_0084, "Add cmd to LD Thread Pool failed, cmnd(%u).", (uint32_t)cmnd);
+    }
+    else
+    {
+        ret = RETURN_OK;
+    } 
+    
+    return ret;
+}
+
+void ldSetTrimIoTimeout(REQ_S *req)
+{
+    LD_REQ_PRIVATE_INFO* private = NULL;
+
+    private = (LD_REQ_PRIVATE_INFO*)(void*)req->producerPrivate;
+    if (OP_TRIM == req->opCode)
+    {
+        private->timeout = (18 * HZ);
+    }
+
+    return;
+}
+
+extern bool sdDeviceRecoverDevPowerCtrl(uint32_t sdevId, REQ_S* req, uint32_t reqDeadline, uint32_t timeout, SD_DIAG_INFO_S* diag);
+extern bool sdDiskIsDiagnoseState(uint32_t sdId);
+
+uint32_t g_muldiskdiagnoseflag = 0;
+uint32_t g_muldiskdiagnoseLdId = INVALID_VALUE32;
+
+void ldDiskClearMulDiskDiagnoseFlag(LD_S* logicDisk)
+{
+    if (0 == logicDisk->useCount)
+    {
+        return;
+    }
+    
+    spin_lock(&g_allowDiskInParamlock);
+    g_muldiskdiagnoseflag = 0;
+    spin_unlock(&g_allowDiskInParamlock);
+
+    return;
+}
+
+bool ldDiskSetMulDiskDiagnoseFlag(LD_S* logicDisk)
+{   
+    LD_S* logicDiagnoseDisk = NULL;
+    
+    spin_lock(&g_allowDiskInParamlock);   
+    if (0 != g_muldiskdiagnoseflag)
+    {
+        spin_unlock(&g_allowDiskInParamlock);
+
+        DBG_LogInfo(LOG_ID_LD_05EE, "LD disk ldid(%u) can't diagnose, other disk is in.", logicDisk->logicId);                
+        return FALSE;
+    }
+
+    g_muldiskdiagnoseflag = 1;
+    spin_unlock(&g_allowDiskInParamlock);
+    
+    logicDiagnoseDisk = ldGetLogicDiskBylogicId(g_muldiskdiagnoseLdId);
+    if ((NULL != logicDiagnoseDisk) && (TRUE == sdDiskIsDiagnoseState(logicDiagnoseDisk->sdiskId[GET_LOCAL_NID()])))
+    {
+        DBG_LogInfo(LOG_ID_LD_05EE, 
+            "LD disk ldid(%u) is in original diagnose, ldid(%u) disk start new diagnose.", 
+            g_muldiskdiagnoseLdId, logicDisk->logicId);
+        
+        spin_lock(&g_allowDiskInParamlock);
+        g_muldiskdiagnoseflag = 0;
+        spin_unlock(&g_allowDiskInParamlock);
+        
+        return FALSE;
+    }
+
+    g_muldiskdiagnoseLdId = logicDisk->logicId;
+    
+    return TRUE;
+}
+
+int32_t ldDiskReqProcMulDiskDiagnose(REQ_S *req, REQ_S *childReq, LD_S* logicDisk, uint32_t diagInfo)
+{
+    LD_REQ_PRIVATE_INFO* private = NULL;
+    uint32_t repairTimeout = 0;
+    SD_DIAG_INFO_S sdDiagInfo;
+
+    if (0 == logicDisk->useCount)
+    {
+        return RETURN_OK;
+    }
+
+    private = (LD_REQ_PRIVATE_INFO*)(void*)req->producerPrivate;    
+    if ((CFG_IO_ERROR_ACTION_QUICK_DIAGNOSE == private->actionInfo.action)
+        || (CFG_IO_ERROR_ACTION_DIAGNOSE == private->actionInfo.action))
+    {   
+        if (FALSE == ldDiskSetMulDiskDiagnoseFlag(logicDisk))
+        {        
+            BDM_LOG_ERR_CAN_PRINT(LOG_ID_LD_05EE,
+                (1*HZ),
+                req->objectId,
+                "LD disk req(0x%p) do power ctrl, (ldId:%u)(sdId:%u), errCode(%x,%x,%x,%x,%x,%x,%x,%x) timeout(%u)(%u).", 
+                req, (uint32_t)req->objectId, (uint32_t)childReq->objectId,
+                private->newErrorInfo.hostByte,
+                private->newErrorInfo.msgByte,
+                private->newErrorInfo.bdmByte,
+                private->newErrorInfo.statusByte,
+                private->newErrorInfo.sk,
+                private->newErrorInfo.asc,
+                private->newErrorInfo.ascq,
+                private->newErrorInfo.fru,
+                private->actionInfo.timeOut,
+                repairTimeout);
+                
+            private->timeout += (int64_t)(((uint64_t)private->fgIoStgy.rePairTimeOut/1000)*HZ);/*???HZ*/
+            repairTimeout = (uint32_t)((private->timeout*1000)/HZ);                  /*HZ???*/
+            sdDiagInfo.errLba = private->errLba;
+            sdDiagInfo.errLen = private->errLen;
+            sdDiagInfo.errCode = diagInfo;
+            sdDiagInfo.opCode = req->opCode;
+            sdDiagInfo.isDidError = (0 == private->newErrorInfo.hostByte) ? 0 : 1;
+            SET_BIT32(private->flag, LD_REQ_DIAG_MASK);
+            private->diagExeNid = GET_LOCAL_NID();
+
+            if ((CFG_IO_ERROR_ACTION_DIAGNOSE == private->actionInfo.action))
+            {
+                BDM_LOG_ERR_CAN_PRINT(LOG_ID_LD_05EE, (60*HZ), (uint64_t)logicDisk->logicId,
+                         "LD disk ldid(%u) diagnose, return req.", logicDisk->logicId);
+                (void)sdDeviceRecoverDevPowerCtrl((uint32_t)childReq->objectId, NULL, 
+                                private->actionInfo.timeOut, repairTimeout, &sdDiagInfo);
+
+                REQ_DELETE(childReq);
+                req->result = (int32_t)private->strategyInfo.errCode;
+                IOD_ADD_DONEQ(req);
+
+                return RETURN_ERROR;
+            }
+
+            if (BDM_CFG_IO_TYPE_DISK_FOREEND == private->ioInfo.ioType)
+            {
+                (void)sdDeviceRecoverDevPowerCtrl((uint32_t)childReq->objectId, NULL, 
+                                private->actionInfo.timeOut, repairTimeout, &sdDiagInfo);
+                REQ_DELETE(childReq);
+                req->result = IO_ERR_WAIT_ACCESS;
+                IOD_ADD_DONEQ(req);
+                return RETURN_ERROR;
+            }
+
+            (void)sdDeviceRecoverDevPowerCtrl((uint32_t)childReq->objectId, childReq, 
+                                    private->actionInfo.timeOut, repairTimeout, &sdDiagInfo);            
+            private->fgIoStgy.rePairTimeOut = 0;            
+            return RETURN_ERROR;
+        }
+    }
+
+    return RETURN_OK;
+}
+
+void ldDiskReqSetChildReqInfoPatch(REQ_S *req, LD_REQ_PRIVATE_INFO* private)
+{
+    if (test_bit(LD_REQ_FWD_MASK, (void*)&private->flag))
+    {
+        IOD_ADD_DONEQ(req);
+    }
+    else
+    {
+        ldDiskReqInquiryStrategy(req);
+    }
+    return;
+}
+
+#define IS_CLOSE_PARTITION(diskType) (g_ldpartitionTypeBitmap & (diskType))
+
+/**************************************************************************
+   : ldCheckClosePartitionUsrOrVault
+     : жָݷǷҪIO
+ : LD_S* logicDisk  : ߼̶ַ        
+ : 
+   ֵ: TRUE  : ָݷҪIO
+           FALSE : ָݷIO 
+     : 
+**************************************************************************/
+static inline bool ldCheckStopPartitionUsrOrVault(LD_S* logicDisk)
+{
+    if (IS_CLOSE_PARTITION(DISK_VAULT) && (DISK_PARTITION_VAULT == logicDisk->partitionType))
+    {
+        return TRUE;
+    }
+
+    if (IS_CLOSE_PARTITION(DISK_USR) && (DISK_PARTITION_USR == logicDisk->partitionType))
+    {
+        return TRUE;
+    }
+
+    return FALSE;
+}
+
+//extern bool ldIsLogicDiskV3RootDisk(LD_S *logicDisk);
+extern bool ldIsV3Product(void);
+
+/**************************************************************************
+   : ldCheckClosePartitionRootDisk
+     : жָϵͳ̷ǷҪIO
+ : LD_S* logicDisk  : ߼̶ַ        
+ : 
+   ֵ: TRUE  : ָϵͳ̷ҪIO
+           FALSE : ָϵͳ̷IO 
+     : 
+**************************************************************************/
+static inline bool ldCheckStopPartitionRootDisk(LD_S* logicDisk)
+{
+    if (ldIsLogicDiskV3RootDisk(logicDisk))
+    {
+        if (IS_CLOSE_PARTITION(DISK_DB_ROOT) && (DISK_PARTITION_DB == logicDisk->partitionType))
+        {
+            return TRUE;
+        }
+
+        if (IS_CLOSE_PARTITION(DISK_SYSPOOL_ROOT) && (DISK_PARTITION_SYSPOOL == logicDisk->partitionType))
+        {
+            return TRUE;
+        }
+
+        if (IS_CLOSE_PARTITION(DISK_LOGZONE_ROOT) && (DISK_PARTITION_LOGZONE == logicDisk->partitionType))
+        {
+            return TRUE;
+        }     
+    }
+
+    return FALSE;
+}
+
+/**************************************************************************
+     : ѯǰǷV3ǰĿ
+ : logicDisk߼̶ַ
+ : 
+   ֵ: TRUEV3豸ǰĿ̣FALSEV3豸ǰĿ
+     : 
+**************************************************************************/
+bool ldIsLogicDiskV3DbDisk(LD_S *logicDisk)
+{
+    if (BDM_TEST_BIT(IS_DB_DISK_PATIONTION_MASK, (void *)&logicDisk->flag) && ldIsV3Product())
+    {
+        return TRUE;
+    }
+
+    return FALSE;
+}
+
+/**************************************************************************
+   : ldCheckStopPartitionDbDisk
+     : жָǰ̷ǷҪIO
+ : LD_S* logicDisk  : ߼̶ַ        
+ : 
+   ֵ: TRUE  : ָǰ̷ҪIO
+           FALSE : ָǰ̷IO 
+     : 
+**************************************************************************/
+static inline bool ldCheckStopPartitionDbDisk(LD_S* logicDisk)
+{
+    if (ldIsLogicDiskV3DbDisk(logicDisk))
+    {
+        if (IS_CLOSE_PARTITION(DISK_DB_COMM) && (DISK_PARTITION_DB == logicDisk->partitionType))
+        {
+            return TRUE;
+        }
+
+        if (IS_CLOSE_PARTITION(DISK_SYSPOOL_COMM) && (DISK_PARTITION_SYSPOOL == logicDisk->partitionType))
+        {
+            return TRUE;
+        }
+
+        if (IS_CLOSE_PARTITION(DISK_LOGZONE_COMM) && (DISK_PARTITION_LOGZONE == logicDisk->partitionType))
+        {
+            return TRUE;
+        }
+    }
+
+    return FALSE;
+}
+
