--- ./source/private_module/ckg/ckgiof_debug.c	2018-04-26 08:06:00.000000000 +0000
+++ ./source/private_module/ckg/ckgiof_debug.c.hotpatch	2019-09-24 07:03:11.000000000 +0000
@@ -1586,14 +1586,14 @@
         ckgiofShowIoCounterBaseInfo();
     }
     else
-    {
+    {        
+        stripeRestoreDiagnose(argc, argv);
         while ((result = DBG_GetOpt(argc, argv, "n:", &opt)) != -1)
         {
             DBG_PROC_NUMBER_PARAM(result, opt.szOptArg, optBits, index)
             DBG_PROC_UNKNOWN_PARAM(result, argv[0], opt.szOptArg)
             DBG_PROC_ERROR(opt.szErrMsg)
-        }
-       
+        }       
         if (DBG_TestOpt(optBits, 'n'))
         {
             if((index < (CKG_COUNT_START + 1)) || (index >= CKG_COUNT_BUTT))
@@ -4024,8 +4024,7 @@
 **************************************************************************/
 void showWriteErr(int32_t argc, char *argv[])
 {
-    UNREFERENCE_PARAM(argv);
-    UNREFERENCE_PARAM(argc);
+    UNREFERENCE_PARAM(argv);    UNREFERENCE_PARAM(argc);
     DBG_Print("ERROR_TYPE                           COUNT\n");
     DBG_Print("----------                           ------------\n");
     DBG_Print("WRITE MEDIA ERROR                    %lld\n", atomic64_read(&g_writeMediumErrSum));
@@ -4033,7 +4032,8 @@
     DBG_Print("WRITEHOLE MEDIA ERROR                %lld\n", atomic64_read(&g_writeholeMediumErrSum));
     DBG_Print("WRITEHOLE WRITE ERROR                %lld\n", atomic64_read(&g_writeholeWriteErrSum));
     DBG_Print("WRITEHOLE WRITE CACHE ERROR          %lld\n", atomic64_read(&g_writeholeWriteCacheErr));
-    DBG_Print("WRITEHOLE OK WRITE ERROR          %lld\n", atomic64_read(&g_writeholeOkWriteErr));
+    DBG_Print("WRITEHOLE OK WRITE ERROR          %lld\n", atomic64_read(&g_writeholeOkWriteErr));    
+    ckgDebugStripeVerifyRestore(argc, argv);
 }
 void cleanWriteErr(int32_t argc, char *argv[])
 {
--- ./source/private_module/ckg/disklog/disk_log_debug.c	2018-04-21 12:37:43.000000000 +0000
+++ ./source/private_module/ckg/disklog/disk_log_debug.c.hotpatch	2019-09-24 07:03:11.000000000 +0000
@@ -2719,14 +2719,14 @@
     UNREFERENCE_PARAM(argc);
 
     spin_lock(&g_diskLogQueryLimitLock);
-    countDisklogWaitQueryLock(&g_diskLogQueryReqLimitList, &commonIoNum);
- 
+    countDisklogWaitQueryLock(&g_diskLogQueryReqLimitList, &commonIoNum); 
     spin_unlock(&g_diskLogQueryLimitLock);
 
     DBG_Print("--------------------disklog state -------------------------------\n");
     DBG_Print("\tfly query lock num:\t%d\n", atomic_read(&g_diskLogFlyQReqNum));
     DBG_Print("\twait query lock num(limit: %d):\t%d\n", g_diskLogQueryCtrlLimit, commonIoNum);
-    DBG_Print("------------------------------------------------------------\n");
+    DBG_Print("------------------------------------------------------------\n");    
+    diskLogDebugDel(argc, argv);
     return;
 }
 
--- ./source/private_module/ckg/raid10/raid10_read.c	2018-03-14 10:44:13.000000000 +0000
+++ ./source/private_module/ckg/raid10/raid10_read.c.hotpatch	2019-09-24 07:03:11.000000000 +0000
@@ -1956,7 +1956,7 @@
     }
     return B_TRUE;
 }
-
+bool raid10CheckAllDiskAbortError(REQ_S *stripeReq);
 /**************************************************************************
      :  ύĻص
  :  1)stripeReq: ύķREQ
@@ -1968,21 +1968,21 @@
 void reportDiskFaultCallBackForRead(void *stripeReq, int32_t result)
 {
     REQ_S *localStripeReq = (REQ_S *)stripeReq;
-
     /* 첽̼ */
-    ckgCountBack(CKG_COUNT_RAID10_REPORT_EH, result);
-    
+    ckgCountBack(CKG_COUNT_RAID10_REPORT_EH, result);    
     if (unlikely((RETURN_OK != result) && (RETURN_BST_ERROR != result)))
     {
         DBG_LogDebug(CKGLOG_RAID10_00b8, "RAID6 read IO object id(0x%llx), ret(0x%x), report disk "
                      "fault failed.", localStripeReq->objectId, result);
-        
-        localStripeReq->result = result;
+        localStripeReq->result = result;        
+        if (B_TRUE == raid10CheckAllDiskAbortError(localStripeReq))
+        {   
+            localStripeReq->result = RETURN_IO_BUSY_NEED_RETRY;
+        }        
         SET_RAID10_IO_STEP_RESULT(localStripeReq, RETURN_CKG_DONE);
         GOTO_RAID10_NEXT_STEP(localStripeReq, GET_RAID10_IO_FAIL_STEP(localStripeReq));
         return;
-    }
-    
+    }    
     /* ޸ʧ˲Ļ, ȥBST */
     if ((RETURN_ERROR != result) || (CHECK_OPCODE_IS_READ(localStripeReq->opCode)))
     {
@@ -2361,3 +2361,50 @@
 callRaid10IoStep(raid10, ReadRspHandle)
 
 
+bool raid10CheckAllDiskAbortError(REQ_S *stripeReq)
+{
+    RAID10_STRIPE_S *readStripe = NULL;
+    CKG_IO_PRIVATE_S *ckgIoPrivate = NULL;
+    RAID_SU_S *su = NULL;
+    uint32_t abortNum = 0;
+    uint32_t firstCol;
+    uint32_t mirrorGroupIndex;
+    uint32_t index;
+    
+    if (OP_READ != stripeReq->opCode)
+    {
+        return B_FALSE;
+    }
+
+    ckgIoPrivate = GET_CKG_REQ_PRIVATE(stripeReq);
+    readStripe = (RAID10_STRIPE_S *)GET_CKG_REQ_STRIPE(stripeReq);
+    
+    for (mirrorGroupIndex = 0; mirrorGroupIndex < ckgIoPrivate->mirrorGroupNum; mirrorGroupIndex++)
+    {
+        firstCol = mirrorGroupIndex * ckgIoPrivate->mirrorDiskNum;
+        if (B_FALSE == readStripe->suRow[firstCol]->isOperate)
+        {
+            continue;
+        }
+        abortNum = 0;
+        for (index = firstCol; index < firstCol + ckgIoPrivate->mirrorDiskNum; index++)
+        {
+            su = readStripe->suRow[index];
+            if (IO_ERR_REDUNDANT_ABORT != su->diskErr)
+            {
+                break;
+            }
+            abortNum++;
+        }
+        if (abortNum == ckgIoPrivate->mirrorDiskNum)  /* ̶abort룬ŷҪת */
+        {
+            CKG_PRINT_LIMIT_PERIOD(CKGLOG_CTRL_INTERVAL, CKGLOG_CTRL_COUNT, DBG_LOG_ERROR, 
+                     DBG_LOGID_NEW, "Raid10 read io(ckgid 0x%llx lba %llu len %u) reset result %d to retry.",
+                     stripeReq->objectId, stripeReq->objectLba, stripeReq->length, stripeReq->result);
+            return B_TRUE;
+        }
+    }
+    return B_FALSE;
+}
+
+
--- ./source/private_module/ckg/raid5/raid5_readrsp.c	2018-02-09 13:47:03.000000000 +0000
+++ ./source/private_module/ckg/raid5/raid5_readrsp.c.hotpatch	2019-09-24 07:03:11.000000000 +0000
@@ -294,7 +294,7 @@
     }
     return;
 }
-
+bool raid5CheckAllDiskAbortError(REQ_S *stripeReq);
 /**************************************************************************
 *     : RAID5ӦϱĻص
 * : context -- صݣǷREQ
@@ -306,17 +306,17 @@
 void raid5ReadReportDiskFaultBack(void * context, int32_t ret)
 {
     REQ_S *stripeReq = NULL;
-
     stripeReq = (REQ_S *)context;
     ckgCountBack(CKG_COUNT_RAID5_REPORT_EH, ret);
     if (unlikely((RETURN_OK != ret) && (RETURN_BST_ERROR != ret)))
     {
-        stripeReq->result = ret;
+        stripeReq->result = ret;        
+        if (B_TRUE == raid5CheckAllDiskAbortError(stripeReq)){    
+            stripeReq->result = RETURN_IO_BUSY_NEED_RETRY;
+        }
         RAID5_ASYNC_GO_TO_IO_STEP(stripeReq, RAID5_IO_STEP_READ_RSP_IO_FAILED);
         return;
     }
-
-    /* ޸ */
     RAID5_ASYNC_GO_TO_IO_STEP(stripeReq, RAID5_IO_STEP_READ_RSP_REPIR_BACK);
 }
 
@@ -743,3 +743,48 @@
     return g_raid5IoStepOps[stripeIoStep].raid5IoFunc(stripeReq);
 }
 
+bool raid5CheckAllDiskAbortError(REQ_S *stripeReq)
+{
+    RAID5_STRIPE_S *readStripe = NULL;
+    uint32_t index;
+    CKG_IO_PRIVATE_S *ckgIoPrivate = NULL;
+    RAID_SU_S *su = NULL;
+    uint32_t abortNum = 0;
+
+    if (OP_READ != stripeReq->opCode)
+    {
+        return B_FALSE;
+    }
+    
+    ckgIoPrivate = GET_CKG_REQ_PRIVATE(stripeReq);
+    readStripe = (RAID5_STRIPE_S *)RAID5_GET_STRIPE_POINT(stripeReq);
+    for (index = 0; index < ckgIoPrivate->memberDiskNum; index++)
+    {
+        su = readStripe->suRow[index];
+        if (B_TRUE != su->isNeedRead)
+        {
+            continue;
+        }
+        
+        if (RETURN_OK == su->diskErr)
+        {
+            continue;
+        }
+        
+        if (IO_ERR_REDUNDANT_ABORT != su->diskErr)
+        {
+            return B_FALSE;
+        }
+        abortNum++;
+    }
+
+    if (abortNum > 1)  /* 1Ϊ raid5 */
+    {
+        CKG_PRINT_LIMIT_PERIOD(CKGLOG_CTRL_INTERVAL, CKGLOG_CTRL_COUNT, DBG_LOG_ERROR,
+                                    DBG_LOGID_NEW, "Raid5 read io(ckgid 0x%llx lba %llu len %u) reset result %d to retry.", 
+                                    stripeReq->objectId, stripeReq->objectLba, stripeReq->length, stripeReq->result);
+        return B_TRUE;
+    }
+    return B_FALSE;
+}
+
--- ./source/private_module/ckg/raid6/raid6_readrsp.c	2018-02-09 13:47:03.000000000 +0000
+++ ./source/private_module/ckg/raid6/raid6_readrsp.c.hotpatch	2019-09-24 07:03:11.000000000 +0000
@@ -329,7 +329,7 @@
         }
     }
 }
-
+bool raid6CheckAllDiskAbortError(REQ_S *stripeReq);
 /**************************************************************************
      : RAID6ӦϱĻص
  : context:صݣǷREQ
@@ -341,20 +341,20 @@
 void raid6ReadReportDiskFaultBack(void * context, int32_t ret)
 {
     REQ_S *stripeReq;
-
     stripeReq = (REQ_S *)context;
     ckgCountBack(CKG_COUNT_RAID6_REPORT_EH, ret);
-
     if (unlikely((RETURN_OK != ret) && (RETURN_BST_ERROR != ret)))
     {
         DBG_LogDebug(CKGLOG_RAID6_00EE, "RAID6 read IO object id(0x%llx), ret(0x%x), report disk "
-                     "fault failed.", stripeReq->objectId, ret);
-        
-        stripeReq->result = ret;       
+                     "fault failed.", stripeReq->objectId, ret);        
+        stripeReq->result = ret;        
+        if (B_TRUE == raid6CheckAllDiskAbortError(stripeReq))
+        {
+            stripeReq->result = RETURN_IO_BUSY_NEED_RETRY;
+        }
         RAID6_ASYNC_GO_TO_IO_STEP(stripeReq, RAID6_IO_STEP_READ_RSP_IO_FAILED);
         return;
     }
-   
     /* ޸ */
     RAID6_ASYNC_GO_TO_IO_STEP(stripeReq, RAID6_IO_STEP_READ_RSP_REPIR_FINISH);
     return;
@@ -1036,3 +1036,50 @@
     }
 }
 
+bool raid6CheckAllDiskAbortError(REQ_S *stripeReq)
+{
+    RAID6_STRIPE_S *readStripe = NULL;
+    uint32_t index;
+    CKG_IO_PRIVATE_S *ckgIoPrivate = NULL;
+    RAID_SU_S *su = NULL;
+    uint32_t abortNum = 0;
+
+    if (OP_READ != stripeReq->opCode)
+    {
+        return B_FALSE;
+    }
+    
+    ckgIoPrivate = GET_CKG_REQ_PRIVATE(stripeReq);
+    readStripe = (RAID6_STRIPE_S *)RAID6_GET_STRIPE_POINT(stripeReq);
+    for (index = 0; index < ckgIoPrivate->memberDiskNum; index++)
+    {
+        su = readStripe->suRow[index];
+        if (B_TRUE != su->isNeedRead)
+        {
+            continue;
+        }
+        
+        if (RETURN_OK == su->diskErr)
+        {
+            continue;
+        }
+        
+        if (IO_ERR_REDUNDANT_ABORT != su->diskErr)
+        {
+            return B_FALSE;
+        }
+        abortNum++;
+    }
+
+    if (abortNum > 2)  /* 2Ϊ raid6 */
+    {
+        CKG_PRINT_LIMIT_PERIOD(CKGLOG_CTRL_INTERVAL, CKGLOG_CTRL_COUNT, DBG_LOG_ERROR,
+                                    DBG_LOGID_NEW, "Raid6 read io(ckgid 0x%llx lba %llu len %u) reset result %d to retry.", 
+                                    stripeReq->objectId, stripeReq->objectLba, stripeReq->length, stripeReq->result);
+        return B_TRUE;
+    }
+    return B_FALSE;
+    
+}
+
+
