--- ./source/private_module/framework/quota/quota_obj.c	2018-02-09 13:47:03.000000000 +0000
+++ ./source/private_module/framework/quota/quota_obj.c.hotpatch	2021-05-08 08:44:07.000000000 +0000
@@ -3792,3 +3792,128 @@
     return RETURN_OK;
 }
 
+int32_t abortTimeOutByPriListHotpatch(QUOTA_OBJ_S* quotaObj, uint16_t prio)
+{
+    struct list_head*        waitNode = NULL;
+    struct list_head*        tempNode = NULL;
+    WAIT_ALLOC_QUOTA_NODE_S* waitObj;
+    QUOTA_TIMEOUT_CB_REQ_PRIVATE_S* reqPrivate = NULL;
+    REQ_S* req = NULL;
+    uint64_t hangTimeJif;
+
+    int32_t ret = RETURN_OK;
+    uint32_t tmpCount = 0;
+    uint64_t beginTime = LVOS_GetNanoSecond();
+    uint64_t diffTime = 0;
+
+    spin_lock(&quotaObj->waitQuotaList[prio].spinlock);
+    list_for_each_safe(waitNode, tempNode, &quotaObj->waitQuotaList[prio].head)
+    {
+        waitObj = list_entry(waitNode, WAIT_ALLOC_QUOTA_NODE_S, waitAllocNode);
+
+        hangTimeJif = jiffies - waitObj->hangStartTime;
+        if ((0 == tmpCount) && (hangTimeJif < HZ))
+        {
+            spin_unlock(&quotaObj->waitQuotaList[prio].spinlock);
+            return RETURN_OK;
+        }
+        
+        tmpCount++;
+        
+        if (hangTimeJif > waitObj->maxHangTime)
+        {
+            req = NULL;
+            
+            if (atomic_inc_return(&g_quotaTimeOutCbReqCnt) <= 1024)
+            {
+                ALLOCATE_REQ(&req);
+            }
+            
+            if (NULL == req)
+            {
+                atomic_dec(&g_quotaTimeOutCbReqCnt);
+                ret = RETURN_ERROR;
+                break;
+            }
+            
+            list_del(waitNode);
+            req->ops = &g_quotaTimeOutCbOps;
+            reqPrivate = (QUOTA_TIMEOUT_CB_REQ_PRIVATE_S*)(void*)(req->producerPrivate);
+            reqPrivate->cbFunc = waitObj->cbFunc;
+            reqPrivate->cbCtx = waitObj->cbCtx;
+
+            atomic_dec(&quotaObj->waitingCnt);
+            quotaObj->waitQuotaList[prio].sum--;
+            IOD_ADD_DONEQ(req);
+            FREE_STRUCTURE(waitObj, g_memWaitAllocQuotaPoolId);
+            waitObj = NULL;
+        }
+        
+        diffTime = LVOS_GetNanoSecond() - beginTime;
+        if (diffTime >= 5000000)
+        {
+            break;
+        }
+    }
+    spin_unlock(&quotaObj->waitQuotaList[prio].spinlock);
+    return ret;
+}
+
+int32_t abortTimeOutQuotaHotpatch(QUOTA_OBJ_S* quotaObj)
+{
+    uint16_t p;
+
+    for (p = 0; p < IO_PRIORITY_BUTT; p++)
+    {
+        if (RETURN_ERROR == abortTimeOutByPriListHotpatch(quotaObj, p))
+        {
+            return RETURN_ERROR;
+        }
+    }
+
+    return RETURN_OK;
+}
+
+void abortTimeOutQuotaTimerDoneHotpatch(void)
+{
+    struct list_head *listNode = NULL;
+    struct list_head *nextNode = NULL;
+    QUOTA_OBJ_S *quotaObj = NULL;
+    uint32_t maxQuotaObjCnt = 1024;    
+    uint64_t maxProcTimeNs = 10000000;
+    
+    uint32_t quotaObjCnt = 0;
+    uint64_t beginTime = LVOS_GetNanoSecond();
+    uint64_t diffTime = 0;
+    
+    spin_lock(&g_quotaObjHangList.spinlock);    
+    
+    list_for_each_safe(listNode, nextNode, &(g_quotaObjHangList.head))
+    {
+        quotaObj = list_entry(listNode, QUOTA_OBJ_S, quotaObjhead);
+
+        if (atomic_read(&(quotaObj->waitingCnt)) > 0)
+        {
+            if (RETURN_OK != abortTimeOutQuotaHotpatch(quotaObj))
+            {
+                break;
+            }
+        }
+        
+        quotaObjCnt++;
+
+        if (quotaObjCnt > maxQuotaObjCnt)
+        {
+            break;
+        }
+        diffTime = LVOS_GetNanoSecond() - beginTime;
+        if (diffTime > maxProcTimeNs)
+        {
+            break;
+        }
+    }
+    
+    spin_unlock(&g_quotaObjHangList.spinlock);
+    return;
+}
+
--- ./source/private_module/framework/version/V3R6C10/quota/quota_init.c	2018-02-09 13:47:03.000000000 +0000
+++ ./source/private_module/framework/version/V3R6C10/quota/quota_init.c.hotpatch	2021-05-08 08:44:07.000000000 +0000
@@ -875,7 +875,7 @@
     UNREFERENCE_PARAM(args);
     return;
 }
-
+void abortTimeOutQuotaTimerDoneHotpatch(void);
 /**************************************************************************
      : ԷquotaIODĴ
  : REQ_S   *req        : req
@@ -945,13 +945,13 @@
         }
         
         procedCount++;
-        /* ȴһ */
         if (procQuotaObjHasWait > maxProcCount 
             || procedCount > g_maxQuotaRollingTimeObj)
         {
             break;
         }
     }
+    abortTimeOutQuotaTimerDoneHotpatch();
     atomic_dec(&retryPriv->isInIOD);
     return RETURN_OK;
 }
