--- ./source/private_module/range/rl_lib/rl_freeze.c	2018-12-02 02:40:58.000000000 +0800
+++ ./source/private_module/range/rl_lib/rl_freeze.c.hotpatch	2018-12-02 02:40:58.000000000 +0800
@@ -16,12 +16,12 @@
 
 #include "rl_internal.h"
 
-/************************************************************************
-    ܣִproxyԴĶᣬֻ޸Դ״̬
-Դ
-
-  ֵԶRETURN_OK
-************************************************************************/
+void rlDoProcessFreezingReqInPatch(DLMRL_RSC_S* rscProxy, DLMRL_ARG_FREEZED_S* farg,
+    struct list_head *need_callbacks, struct list_head *need_free);
+
+
+
+
 int32_t rlDoFreeze(DLMRL_RSC_S* rscProxy)
 {
     /* proxyʹstatestatemasterԴstateķʽͬע֡
@@ -51,27 +51,27 @@
     rlResendLock2MasterWhenUnfreeze(rscProxy);
 
     spin_unlock(&rscProxy->lock);
-    
-    spin_lock(&rscProxy->lockState);
 
-    rlSetFlag(rscProxy->state, DLMRL_RSC_STATE_HANDLE_FREQ);
+
 
     /* ڼɵ:ȡȨӦٻ */
     rlProcessFreezingReq(rscProxy);
 
-    rlClrFlag(rscProxy->state, DLMRL_RSC_STATE_HANDLE_FREQ);
 
     /* ǣҪڴ궳ǡ
        ΪĹУmasterϢҲܻյmasterӦ
        ҪȷڶϺٴmasterӦ */
-    rlClrFlag(rscProxy->state, DLMRL_RSC_STATE_FREEZING);
-    spin_unlock(&rscProxy->lockState);
 
     DLM_LOG(DBG_LOG_DEBUG, DLM_LOG_ID_RLOCK(1), "RL rsc %p unfreezed.", rscProxy);
     return RETURN_OK;
 }
 
 
+
+
+
+
+
 /************************************************************************/
 /* ڲӿ */
 /************************************************************************/
@@ -149,69 +149,69 @@
 
 #define MIN_LOCK 2000
 #define MS_TO_NS   1000000
-
-/************************************************************************
-    ܣⶳʱڼ󡣴ʱĴδʱȫһ
-proxyԴ
-
-  ֵ
-************************************************************************/
 void rlProcessFreezingReq(DLMRL_RSC_S* rscProxy)
 {
     struct list_head* pos = NULL;
     struct list_head* next = NULL;
+    struct list_head need_callbacks;
+    struct list_head need_free;
     DLMRL_ARG_FREEZED_S* farg = NULL;
     DLM_RL_ARG_S *rlArg = NULL;
     uint32_t count = 0;
     uint32_t cancelExpire = 0;
     uint64_t costTime = 0;
-
+    INIT_LIST_HEAD(&need_callbacks);
+    INIT_LIST_HEAD(&need_free);
+    spin_lock(&rscProxy->lockState);
+    rlSetFlag(rscProxy->state, DLMRL_RSC_STATE_HANDLE_FREQ);
     list_for_each_safe(pos, next, &rscProxy->statistics.data.dataProxy->hungReqList)
     {
         farg  = list_entry(pos, DLMRL_ARG_FREEZED_S, stHead);
         rlArg = rlFArg2Arg(farg);
         cancelExpire = rlArg->cancelExpire;
-
-        /* гʱʱ첽Ĵ:
-           1) ʣʱ򲻴, ȴгʱ, ; 
-           2) ʣʱ㹻³ʱʱ, ɾᳬʱtimer,  */
         if (!farg->isCopy && cancelExpire > 0)
         {
             costTime = LVOS_GetNanoSecond() - farg->lockStartTime;
-
-            /* 趨ĳʱʱ̫, ʣʱ̫ */
+            /* 趨ĳʱʱ̫, ʣ̫ */
             if ((cancelExpire < MIN_LOCK)
                 || (costTime > (uint64_t)(cancelExpire - MIN_LOCK) * MS_TO_NS))
             {
                 continue;
             }
-
             /* ɾᳬʱtimer, ɾʧܱʱtimerѾ볬ʱ, ʲٴ */
             if (RETURN_OK != rlReqAppDelAutoCancelTimerInFreeze(farg))
             {
                 continue;
             }
-
             /* ³ʱʱ */
             rlArg->cancelExpire -= (uint32_t)(costTime / MS_TO_NS);
         }
-
-        rlDoProcessFreezingReq(rscProxy, rlArg);
         count++;
         list_del(pos);
         rscProxy->statistics.data.dataProxy->numOfHungReq--;
+        rlDoProcessFreezingReqInPatch(rscProxy, farg, &need_callbacks, &need_free);
+    }
+    rlClrFlag(rscProxy->state, DLMRL_RSC_STATE_HANDLE_FREQ);
+    rlClrFlag(rscProxy->state, DLMRL_RSC_STATE_FREEZING);
+    spin_unlock(&rscProxy->lockState);
+    list_for_each_safe(pos, next, &need_callbacks)
+    {
+        farg = list_entry(pos, DLMRL_ARG_FREEZED_S, stHead);
+        list_del(pos);
+        rlArg = rlFArg2Arg(farg);
+        rlArg->result = RETURN_ERROR;
+        rlArg->complete(rlArg);
+        rlFArgDestroy(farg);
+    }
+    list_for_each_safe(pos, next, &need_free)
+    {
+        farg = list_entry(pos, DLMRL_ARG_FREEZED_S, stHead);
+        list_del(pos);
         rlFArgDestroy(farg);
     }
-
     DLM_LOG(DBG_LOG_DEBUG, DLM_LOG_ID_RLOCK(1), "RL %u freezed req handled.", count);
 }
 
-/************************************************************************
-    ܣһ
-proxyԴapp
-
-  ֵ
-************************************************************************/
 void rlDoProcessFreezingReq(DLMRL_RSC_S* rscProxy, DLM_RL_ARG_S* arg)
 {
     switch(arg->opCode)
@@ -275,4 +275,40 @@
     return RETURN_OK;
 }
 #endif
-
+void rlDoProcessFreezingReqInPatch(DLMRL_RSC_S* rscProxy, DLMRL_ARG_FREEZED_S* farg,
+    struct list_head *need_callbacks, struct list_head *need_free)
+{
+    int32_t rc;
+    DLM_RL_ARG_S *arg = rlFArg2Arg(farg);
+    switch(arg->opCode)
+    {
+        case DLM_OPCODE_LOCK:
+        case DLM_OPCODE_TEST:
+        case DLM_OPCODE_TRY:
+            rc = rlAPIProxyLock(rscProxy, arg);
+            if(rc != RETURN_OK)
+            {
+                if ( arg->complete != NULL) {
+                    list_add_tail(&farg->stHead, need_callbacks);
+                } else {
+                    list_add_tail(&farg->stHead, need_free);
+                }
+            } else {
+                list_add_tail(&farg->stHead, need_free);
+            }
+            break;
+        case DLM_OPCODE_LOOKUP:
+            (void)rlAPIProxyLock(rscProxy, arg);
+            list_add_tail(&farg->stHead, need_free);
+            break;
+        case DLM_OPCODE_UNLOCK:
+        case DLM_OPCODE_CANCEL:
+            (void)rlAPIProxyUnlock(rscProxy, arg);
+            list_add_tail(&farg->stHead, need_free);
+            break;
+        default:
+            DLM_LOG(DBG_LOG_ERROR, DLM_LOGID_CRI(DLM_LOGID_RL_402A), "RL Invalid opcode(%d) when handling freezed req.", arg->opCode);
+            list_add_tail(&farg->stHead, need_free);
+            break;
+    }
+}
--- ./source/private_module/range/rl_lib/rl_internal.c	2018-12-02 02:40:58.000000000 +0800
+++ ./source/private_module/range/rl_lib/rl_internal.c.hotpatch	2018-12-02 02:40:58.000000000 +0800
@@ -15,7 +15,7 @@
 #include "dlm_common.h"
 #include "rl_internal.h"
 #include "rl_msg_packer.h"
-
+bool dlmCapabilitySpecCheckOverflowWithPercent(DLM_RES_NAMESPACE_E nameSpace, DLM_CAPABILITY_TYPE_E capType,DLM_RANGELOCK_CAPABILITY_ITEM_E capItem, DLM_RANGELOCK_CAPABILITY_CHECK_RESULT_E* checkResult, uint32_t percent);
 /************************************************************************/
 /* DTרȫֱ */
 /************************************************************************/
@@ -360,7 +360,7 @@
 
     return RETURN_OK;
 }
-
+void rlAllProxyAging(void);
 /************************************************************************
     ܣproxyദappļ󣬽ʵʵĹ飻
           飻
@@ -376,11 +376,11 @@
     int32_t ret = RETURN_ERROR;
     DLMRL_TIME_COST_S tc = {0ULL};
     DLM_PROXY_S *proxy = (DLM_PROXY_S *)rsc->res;
-
+    if (dlmCapabilitySpecCheckOverflowWithPercent((DLM_RES_NAMESPACE_E)proxy->name.ns,
+        DLM_CAPABILITY_TYPE_RANGELOCK, DLM_RANGELOCK_CAPABILITY_ITEM_INTERVAL, NULL, 80)) { rlAllProxyAging();}
     ret = rlDoProxyLockCheckCondition(rsc);
     if (RETURN_OK != ret)
     {
-        //inner log
         return ret;
     }
 
@@ -1915,7 +1915,7 @@
     }
 
     /* reqע⣬ҪȨ֮֮ǰpodProxyѾ */
-    if (rlIsInGrace(rsc))
+    if (rlIsInGrace(rsc) && !list_empty(&rsc->waitQ))
     {
         /*  */
         spin_lock(&rsc->statistics.data.dataMaster->lockGrace);
@@ -4009,8 +4009,99 @@
     return RETURN_OK;
 }
 #endif
+int32_t rlProxyCacheAgingNew(DLMRL_RSC_S *rsc, bool force);
+int rlProxyCacheAgingWithLockNew(DLMRL_RSC_S *rsc, bool force)
+{
+    int32_t ret;
+    spin_lock(&rsc->lock);
+    ret = rlProxyCacheAgingNew(rsc, force);
+    spin_unlock(&rsc->lock);
+    return ret;
+}
 
+int32_t rlProxyCacheAgingNew(DLMRL_RSC_S *rsc, bool force)
+{
+    struct list_head *pos = NULL;
+    struct list_head *next = NULL;
+    DLMRL_REQ_MASTER_S *req = NULL;
+    DLM_INTREE_NODE_S *node2Release = NULL;
+    DLMRL_STATISTICS_PROXY_S* staData = rsc->statistics.data.dataProxy;
+    uint32_t numOfNode2Release = 0;
+    int32_t ret = RETURN_ERROR;
+    uint32_t lrulimit = 0;
+    bool bLoopFlag = FALSE;
+    DLM_PROXY_S *proxy = (DLM_PROXY_S *)rsc->res;
+    const volatile uint32_t *unlockCnt = &proxy->unlockCnt;
+    struct list_head* delPos  = NULL;
+    DLMRL_ITEM_INS_DEL_S* item;
+    uint64_t startTime;
 
+    lrulimit = rlLruLimitNum(rsc);
+    if(staData->numOfCachedInterval <= lrulimit && !force)
+    {
+        return RETURN_OK;
+    }
 
+    numOfNode2Release = MIN(DLM_AGING_MAX_CACHE_LENGTH, (staData->numOfCachedInterval - lrulimit));
 
+    startTime = LVOS_GetNanoSecond();
+    list_for_each_safe(pos, next, &staData->lruList)
+    {
+        if (*unlockCnt >= UNLOCK_LIST_MAX_LENGTH)
+        {
+            DLM_LOG_LIMITED_COMMON(DBG_LOG_WARNING, DLM_LOG_ID_RLOCK(0), "Unlock(%u) num is too more.", *unlockCnt);
+            break;
+        }
 
+        node2Release = list_entry(pos, DLM_INTREE_NODE_S, lruListHead);
+        if (!list_empty(&node2Release->ownerList))
+        {
+            continue;
+        }
+        if (NULL == req)
+        { /*ڴ*/
+            req = rlReqMasterCreateBasic(rsc, node2Release->interval.start, node2Release->interval.end, DLM_MODE_EXCLU);
+            if(NULL == req)
+            {
+                DLM_LOG_LIMITED(60 * HZ, 1, DBG_LOG_WARNING, DLM_LOG_ID_RLOCK(1), "Create reqMaster failed, cache aging need retry.");
+                return RETURN_ERROR;
+            }
+        }
+        else
+        {
+            rlReqMasterInitBasic(req, rsc, node2Release->interval.start, node2Release->interval.end, DLM_MODE_EXCLU);
+        }
+        ret = rlPreGrant(&req->base, &req->semOps->tcbProxyRevoke, &req->base.itvlOriginal);
+        if(RETURN_OK == ret)
+        {
+            list_for_each(delPos, &req->base.deleteListHead)
+            {
+                item = list_entry(delPos, DLMRL_ITEM_INS_DEL_S, stHead);
+                if (&item->node->lruListHead == next)
+                {
+                    bLoopFlag = TRUE;
+                    break;
+                }
+            }
+            ret = rlDoGrant(&req->base, &req->semOps->tcbProxyRevoke);
+        }
+        rlReqMasterClear(&req->base);
+        numOfNode2Release--;
+        if(0 == numOfNode2Release || bLoopFlag == TRUE)
+        {
+            break;
+        }
+        if (DLM_RL_AGE_CACHE_EXEC_DEADLINE <= (LVOS_GetNanoSecond() - startTime))
+        {
+            DLM_LOG(DBG_LOG_DEBUG, DLM_LOG_ID_RLOCK(1), "Cache aging breaked, cachenum(%u), not release(%u), limit(%u).",
+                staData->numOfCachedInterval, numOfNode2Release, lrulimit);
+            break;
+        }
+    }
+    if (NULL != req)
+    {
+        dlmFreeToPool(req, MY_PID, g_rlPoolReqMaster);
+        req = NULL;
+    }
+    return ret;
+}
--- ./source/private_module/range/rl_lib/rl_lib.c	2018-12-02 02:40:58.000000000 +0800
+++ ./source/private_module/range/rl_lib/rl_lib.c.hotpatch	2018-12-02 02:40:58.000000000 +0800
@@ -2925,3 +2925,23 @@
 EXPORT_SYMBOL(rlAPIClmProxyCleanupByOwnerid);
 #endif
 
+#define MAX_PROXY_AGING_TIME (1000 * 1000 * 100)
+int rlProxyCacheAgingWithLockNew(DLMRL_RSC_S *rsc, bool force);
+void rlAllProxyAging(void)
+{
+    DLMRL_RSC_S *rsc;
+    struct list_head *p, *n;
+    struct list_head tmpLst;
+    uint64_t startTime = LVOS_GetNanoSecond();
+    spin_lock(&g_rlRscProxyListLock);
+    list_for_each_safe(p, n, &g_rlRscProxyList)
+    {
+        rsc = list_entry(p, DLMRL_RSC_S, stHead);
+        rlProxyCacheAgingWithLockNew(rsc, TRUE);
+        if (LVOS_GetNanoSecond() - startTime > MAX_PROXY_AGING_TIME)
+        {
+            break;
+        }
+    }
+    spin_unlock(&g_rlRscProxyListLock);
+}
