--- ./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,11 +15,11 @@
 #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רȫֱ */
 /************************************************************************/
-
+bool dlmCapabilitySpecCheckAboutToOverflow(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 number);
 #ifdef _DLM_DT_
 //proxyǿƻбǣΪtrue־ǿУΪfalseʾ
 bool g_dtCacheHit = TRUE;
@@ -115,7 +115,7 @@
 uint32_t g_rlPoolLogInc = 0;
 
 uint32_t g_rlUseDefaultDesire = 0;
-
+uint64_t g_rlLastAgingTime = 0;
 
 /************************************************************************/
 /* ڲʹõĺ */
@@ -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)) { uint64_t currentTime = LVOS_GetMilliSecond(); if (currentTime - g_rlLastAgingTime > 1000 || dlmCapabilitySpecCheckAboutToOverflow((DLM_RES_NAMESPACE_E)proxy->name.ns,DLM_CAPABILITY_TYPE_RANGELOCK, DLM_RANGELOCK_CAPABILITY_ITEM_INTERVAL, NULL, 5)){g_rlLastAgingTime = currentTime;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 uint16_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);
+}
