--- ./source/private_module/pal/pal_diagnose/pal_ctrl_diagnose.c	2018-02-09 13:47:03.000000000 +0000
+++ ./source/private_module/pal/pal_diagnose/pal_ctrl_diagnose.c.hotpatch	2022-12-08 15:03:09.000000000 +0000
@@ -814,7 +814,7 @@
     
     return;
 }
-
+extern void setMaxAclScanOneBatch(uint32_t aclScanVal); extern uint32_t getMaxAclScanOneBatch(void); extern void setAclScanTime(uint32_t scanTimeVal); extern uint32_t getAclScanTime(void);
 /**************************************************************************
      :  ʾеtask
  :  
@@ -831,38 +831,46 @@
     PAL_CTRL_GLOBAL_S     *ctrlObj    = NULL;
     DBG_RUN_TASK_INFO_S   *taskInfo   = NULL;
     struct list_head       taskList;
-    
-    UNREFERENCE_PARAM(argc);
-    UNREFERENCE_PARAM(argv);
-
+	uint32_t aclScanNum = 128; uint32_t aclScanTime = 100; int32_t ret;  
+    if (0 != argc) {
+        if (!strncasecmp(argv[0], "acl_scan_cnt", 20)) {
+            ret = palGetParamU32(argv[1], &aclScanNum);
+            if (unlikely(RETURN_OK != ret)) { DBG_Print("ERROR: Get acl scan num (%s) is invalid.\n", argv[1]); return; }
+            if (aclScanNum > 4096 || aclScanNum < 64) { DBG_Print("ERROR: acl scan num (%s) should between 64 and 4096.\n", argv[1]); return; }
+            setMaxAclScanOneBatch(aclScanNum); return;
+        }
+        if (!strncasecmp(argv[0], "acl_scan_time", 20)) {
+            ret = palGetParamU32(argv[1], &aclScanTime);
+            if (unlikely(RETURN_OK != ret)) { DBG_Print("ERROR: Get acl scan time (%s) is invalid.\n", argv[1]); return; }
+            if (aclScanTime > 2000 || aclScanTime < 50) { DBG_Print("ERROR: acl scan time (%s) ms should between 50 and 2000.\n", argv[1]); return; }
+            setAclScanTime(aclScanTime); return;
+        }
+        if (!strncasecmp(argv[0], "show_acl_scan", 20)) {
+            aclScanNum  = getMaxAclScanOneBatch();
+            aclScanTime = getAclScanTime() / 1000000;
+            DBG_Print("Get acl scan num %u.\n", aclScanNum); DBG_LogInfo(0, "Get acl scan num %u.", aclScanNum);
+            DBG_Print("Get acl scan time %u ms.\n", aclScanTime); DBG_LogInfo(0, "Get acl scan time %u ms.", aclScanTime); return;
+        }
+    }
     DBG_Print("\nRunning task:\n");
-
     ctrlObj = getCtrlGlobalObj();
-
     INIT_LIST_HEAD(&taskList);
-    
     spin_lock(&ctrlObj->runningTaskList.spLock);
-    if (0 == ctrlObj->runningTaskList.size)
-    {
+    if (0 == ctrlObj->runningTaskList.size) {
         spin_unlock(&ctrlObj->runningTaskList.spLock);
         DBG_Print("No running task.\n");
         return;    
     }
-    
-    list_for_each(pos, &ctrlObj->runningTaskList.taskList)
-    {
+    list_for_each(pos, &ctrlObj->runningTaskList.taskList) {
         taskEntry = list_entry(pos, PAL_TASK_LIST_ENTRY_S, head);
         task = taskEntry->task;
-
         taskInfo = PAL_ALLOC_MEMORY(PAL_DBG_TASK_INFO, sizeof(DBG_RUN_TASK_INFO_S));
-        if (unlikely(NULL == taskInfo))
-        {
+        if (unlikely(NULL == taskInfo)) {
             spin_unlock(&ctrlObj->runningTaskList.spLock);
             DBG_Print("ERROR: Out of memory, size(%u).\n", sizeof(DBG_RUN_TASK_INFO_S));
             freeDbgTaskInfoList(&taskList);
             return;
         }
-
         taskInfo->fsId = getTaskFsId(task);
         LVOS_strncpy(taskInfo->taskName, GET_TASK_NAME((TASK_S*)taskEntry->task), sizeof(taskInfo->taskName));
         LVOS_strncpy(taskInfo->step, GET_ACTION_NAME_BY_OPCODE(task->ActionArray[GET_TASK_CURR_ACTION_IDX(task)]), 
@@ -871,16 +879,11 @@
         taskInfo->actionResult = task->ActionStepResult;
         taskInfo->notBackNum   = atomic_read(&task->ActionNotBackChild);
         taskInfo->childTaskNum = task->ActionChildSum;
-
         list_add_tail(&taskInfo->head, &taskList);
     }
     spin_unlock(&ctrlObj->runningTaskList.spLock);
-
-
-    list_for_each(pos, &taskList)
-    {
+    list_for_each(pos, &taskList) {
         taskInfo = list_entry(pos, DBG_RUN_TASK_INFO_S, head);
-        
         DBG_Print("FS id          :  %u\n", taskInfo->fsId);
         DBG_Print("Task name      :  %s\n", taskInfo->taskName);
         DBG_Print("Current step   :  %s\n", taskInfo->step);
@@ -888,11 +891,8 @@
         DBG_Print("Action result  :  %d\n",   taskInfo->actionResult);
         DBG_Print("Child task num :  %d\n",   taskInfo->childTaskNum);
         DBG_Print("Not back       :  %d\n\n",   taskInfo->notBackNum);
-        
     }
-    
     freeDbgTaskInfoList(&taskList);
-    
 }
 
 
--- ./source/private_module/pal/pal_sync/pal_acl_kvobj.c	2018-02-09 13:47:03.000000000 +0000
+++ ./source/private_module/pal/pal_sync/pal_acl_kvobj.c.hotpatch	2022-12-08 15:03:09.000000000 +0000
@@ -1098,7 +1098,7 @@
     res->objHandle  = res->openKvOut.kvObjHandle;
     return CONTEXT_CONTINUE;
 }
-
+uint32_t g_maxAclScanOneBatch = MAX_ACL_RECORD_SCAN_ONE_BATCH; uint32_t g_maxAclScanTime = 100000000ULL;  /*100ms = 100000000ns*/
 uint16_t traverseAclKvObjStrategy(const void* oldData, void* opData, CONTEXT_S* context)
 {
     RECYCLE_ACL_KV_ITEMS_RES_S  *res    = NULL;
@@ -1121,7 +1121,7 @@
     KVOBJTRACE(DBG_LOGID_NEW, "ObsId(%llx) txnId(%llu) traverse items(%u) aclId(%llu), txnId(%llu).",
         res->input->obsId, res->input->txnId, res->travItems, item->aclId, item->txnId);
     
-    if (MAX_ACL_RECORD_SCAN_ONE_BATCH <= res->travItems)
+    if (g_maxAclScanOneBatch <= res->travItems)
     {
         return STRATEGY_QUIT;
     }
@@ -1156,7 +1156,7 @@
     kvObjTraverseItem(&res->travKvIn, &res->travKvOut, context);
     return CONTEXT_PENDING;
 }
-
+bool isReplayTimeout(uint64_t begin, uint64_t end);
 STATIC int32_t recycleAclKvItemsTraverseDone(CONTEXT_S *context)
 {
     RECYCLE_ACL_KV_ITEMS_RES_S *res = (RECYCLE_ACL_KV_ITEMS_RES_S *)getData(context);
@@ -1178,7 +1178,7 @@
 
     /*õitemұitemΪKV_DBѱɡ*/
     if (res->itemsNum < MAX_ACL_AYNC_DEL_PER_TRANS
-        && res->travItems < MAX_ACL_RECORD_SCAN_ONE_BATCH)
+        && res->travItems < g_maxAclScanOneBatch)
     {
         refreshScanStatus(res->input->manager, res->input->scan,
             res->input->fsVersion, res->input->txnId); 
@@ -1195,7 +1195,7 @@
             ACL_KV_ITEM_S *item = (ACL_KV_ITEM_S *)res->itemList[index];
 
             result = addAclAsyncDeleteEntry(res->input->fsId, item->aclId);
-            if (RETURN_SPACE_EBUSY == result)
+            if (RETURN_SPACE_EBUSY == result || RETURN_SPACE_ENOMEM == result)
             {
                 PAL_LOG_DEBUG(DBG_LOGID_NEW, "ObsId(%llx) txnId(%llu) async delete list is busy.",
                     res->input->obsId, res->input->txnId);
@@ -1221,8 +1221,8 @@
     {
         uint64_t currNano = LVOS_GetNanoSecond();
         
-        if (!IS_REPLAY_TIMEOUT(res->input->beginNano, currNano)
-            && ACL_APO_SCAN_ENDED != res->input->scan->status)
+        if (!isReplayTimeout(res->input->beginNano, currNano)
+            && ACL_APO_SCAN_ENDED != res->input->scan->status && res->travItems < g_maxAclScanOneBatch)
         {
             return CONTEXT_REPEAT;
         }
@@ -1546,4 +1546,13 @@
 
 #endif
 
-
+bool isReplayTimeout(uint64_t begin, uint64_t end)
+{
+    if (begin > end) {
+        return TRUE;
+    }
+    if (end - begin >= g_maxAclScanTime) {
+        return TRUE;
+    }
+    return FALSE;
+}
--- ./source/private_module/pal/pal_sync/pal_acl_recycle.c	2018-02-09 13:47:03.000000000 +0000
+++ ./source/private_module/pal/pal_sync/pal_acl_recycle.c.hotpatch	2022-12-08 15:03:09.000000000 +0000
@@ -29,7 +29,7 @@
 #include "pal/pal_sync/pal_sync_acl.h"
 #include "pal/pal_comm/pal_ftds.h"
 #include "pal/pal_comm/pal_fdsa.h"        /* FDSA */
-
+#include <util/customize.h>
 MODULE_ID(PID_SPACE_PAL);
 MODULE_NAME("PAL");
 PAL_SUB_MODULE(FS_ACL_SYNC);
@@ -424,7 +424,7 @@
 
     return (int32_t)num;
 }
-
+extern uint32_t g_maxAclScanOneBatch;
 /**************************************************************************
      :  ACL첽ɾУɶ׶̵
  :  
@@ -436,7 +436,7 @@
 {
     ACL_ASYNC_DELETE_LIST_S *list   = getAclAsyncDeleteList(fsId);
     ACL_ASYNC_DELETE_ENTRY_S *entry = NULL;
-
+	uint32_t maxAclAsyncDelList = MAX_ACL_ASYNC_DELETE_LIST_LEN;
     if (unlikely(NULL == list))
     {
         PAL_LOG_ERROR(DBG_LOGID_NEW, "Fs(%u) get acl async delete list failed.", fsId);
@@ -478,9 +478,9 @@
             fsId, aclId);
         return RETURN_SPACE_EEXIST;
     }
-
+	if (g_maxAclScanOneBatch > maxAclAsyncDelList) {maxAclAsyncDelList = g_maxAclScanOneBatch;}
     /*1. Ƿѳ¼*/
-    if (MAX_ACL_ASYNC_DELETE_LIST_LEN == (list->entryNum + list->preAddNum + list->handledNum))
+    if (maxAclAsyncDelList == (list->entryNum + list->preAddNum + list->handledNum))
     {
         spin_unlock(&list->lock);
         PAL_LOG_ERROR(DBG_LOGID_NEW, "Fs(%u) aclId(%llu) list is full.", fsId, aclId);
@@ -1731,7 +1731,7 @@
         aclRecycleTimerTaskStart,           aclRecycleTimerTaskDone
     },
 };
-
+void updateAclScanNumOneBatch(void);
 /**************************************************************************
      :  ACLնʱ
  :  
@@ -1746,7 +1746,7 @@
     int32_t result                      = RETURN_ERROR;
 
     UNREFERENCE_PARAM(args);
-
+	updateAclScanNumOneBatch();
     isRestrict = FDSA_GetRestrictTaskStatus((uint16_t)SPACE_RESTRICT_ACL_RECYCLE);
     if (unlikely(isRestrict))
     {
@@ -1865,3 +1865,118 @@
     mgr->fsCursor       = 0; 
 }
 
+uint64_t g_readAclScanCnt  = 0;
+extern uint32_t g_maxAclScanTime;
+extern OSP_S32 ECONF_ModifyConfig(OSP_CHAR *v_szSectionName, OSP_CHAR *v_szItemName, OSP_CHAR *v_szItemValue); 
+#define CST_MAX_VALUE_LEN (256 + 1)
+void setMaxAclScanOneBatch(uint32_t aclScanVal)
+{
+    int32_t result = RETURN_OK;
+    uint32_t oldScanCnt = g_maxAclScanOneBatch;
+    int8_t value[CST_MAX_VALUE_LEN] = {0};
+
+    snprintf(value, CST_MAX_VALUE_LEN, "%u", aclScanVal);
+
+    result = ECONF_ModifyConfig("SPECIFICATION", "AclScanNumOneBatch", value);
+    if (RETURN_OK != result)
+    {
+        DBG_PrintBuf("Set acl scan num to %u failed, result(%d).\n", aclScanVal, result);
+        return;
+    }
+    
+    g_maxAclScanOneBatch = aclScanVal;
+    DBG_PrintBuf("Set acl scan num from %u to %u success.\n", oldScanCnt, g_maxAclScanOneBatch);
+    DBG_LogInfo(0, "Set acl scan num from %u to %u success.", oldScanCnt, g_maxAclScanOneBatch);
+    
+    return;
+}
+
+uint32_t getMaxAclScanOneBatch(void)
+{
+    return g_maxAclScanOneBatch;
+}
+
+void setAclScanTime(uint32_t scanTimeVal)
+{
+    int32_t result;
+    uint32_t oldAclScanTime = g_maxAclScanTime;
+    uint32_t scanTimeValInNs = scanTimeVal * 1000000; /* ĵλms޸Ϊns */
+    int8_t value[CST_MAX_VALUE_LEN] = {0};
+    
+    snprintf(value, CST_MAX_VALUE_LEN, "%u", scanTimeValInNs);
+
+    result = ECONF_ModifyConfig("SPECIFICATION", "AclScanTimeOneBatch", value);
+    if (RETURN_OK != result)
+    {
+        DBG_PrintBuf("Set acl scan time to %u ns failed, result(%d).\n", scanTimeValInNs, result);
+        return;
+    }
+    
+    g_maxAclScanTime = scanTimeValInNs;
+    DBG_PrintBuf("Set acl scan time from %u to %u ns success.\n", oldAclScanTime, g_maxAclScanTime);
+    DBG_LogInfo(0, "Set acl scan time from %u to %u ns success.", oldAclScanTime, g_maxAclScanTime);
+
+    return;
+}
+
+uint32_t getAclScanTime(void)
+{
+    return g_maxAclScanTime;
+}
+
+void updateAclScanNumOneBatch(void)
+{
+    uint32_t readCfgCntCycle;
+    uint32_t readCfgTimeCycle;
+    CST_ITEM_T item;
+    uint32_t aclScanNumOneBatch = MAX_ACL_RECORD_SCAN_ONE_BATCH;
+    uint32_t aclScanTime = 100000000ULL;  /*100ms = 100000000ns*/
+
+    /* ÿ20ӶһļԸaclɨĸÿ10Ӷaclɨļ */
+    readCfgCntCycle  = 1201000 / 1000;
+    readCfgTimeCycle = 609000  / 1000;
+
+    g_readAclScanCnt++;
+
+    if ((1 == g_readAclScanCnt) || (0 == g_readAclScanCnt % readCfgTimeCycle))
+    {
+        memset(&item, 0, sizeof(CST_ITEM_T));
+        if (FALSE == CST_GetItem("SPECIFICATION", "AclScanTimeOneBatch", &item))
+        {
+            DBG_LogDebug(DBG_LOGID_NEW, "Get acl scan time one batch failed.\n");
+        }
+        else
+        {
+            aclScanTime = (uint32_t)LVOS_StrToU64(item.acValue);
+            DBG_LogDebug(DBG_LOGID_NEW, "Acl scan time one batch : %u\n", aclScanTime);
+        }
+
+        if (g_maxAclScanTime != aclScanTime)
+        {
+            DBG_LogInfo(DBG_LOGID_NEW, "Update acl scan time from %u to %u.\n", g_maxAclScanTime, aclScanTime);
+            g_maxAclScanTime = aclScanTime;
+        }
+    }
+
+    if ((1 == g_readAclScanCnt) || (0 == g_readAclScanCnt % readCfgCntCycle))
+    {
+        memset(&item, 0, sizeof(CST_ITEM_T));
+        if (FALSE == CST_GetItem("SPECIFICATION", "AclScanNumOneBatch", &item))
+        {
+            DBG_LogDebug(DBG_LOGID_NEW, "Get acl scan num one batch failed.\n");
+        }
+        else
+        {
+            aclScanNumOneBatch = (uint32_t)LVOS_StrToU64(item.acValue);
+            DBG_LogDebug(DBG_LOGID_NEW, "Acl scan num one batch : %u\n", aclScanNumOneBatch);
+        }
+
+        if (g_maxAclScanOneBatch != aclScanNumOneBatch)
+        {
+            DBG_LogInfo(DBG_LOGID_NEW, "Update acl scan num from %u to %u.\n", g_maxAclScanOneBatch, aclScanNumOneBatch);
+            g_maxAclScanOneBatch = aclScanNumOneBatch;
+        }
+    }
+
+    return;
+}
--- ./source/private_module/pal/pal_sync/pal_sync_acl.c	2018-02-09 13:47:03.000000000 +0000
+++ ./source/private_module/pal/pal_sync/pal_sync_acl.c.hotpatch	2022-12-08 15:03:09.000000000 +0000
@@ -4541,7 +4541,7 @@
 }
 EXPORT_SYMBOL(setFsConsistenceTxno);
 #endif
-
+extern uint32_t g_maxAclScanOneBatch; 
 #if DESC("ʵ")
 /**************************************************************************
      :  ǷҪִп
@@ -4556,7 +4556,7 @@
 {
     uint32_t fsId       = getSpcFsidByObsId(input->objId);
     ACL_FLUSH_MANAGER_S *manager = NULL;
-
+	uint32_t maxAclAsyncDelList = MAX_ACL_ASYNC_DELETE_LIST_LEN;
     output->executeSynctask = FALSE;
     CHECK_ACL_SYNC_FLOW_WIHT_CONTEXT(fsId, NULL, output->result, parentContext);
     
@@ -4570,12 +4570,12 @@
         callbackContext(parentContext);
         return;
     }  
-
+	if (g_maxAclScanOneBatch > maxAclAsyncDelList) { maxAclAsyncDelList = g_maxAclScanOneBatch; }
     output->result  = RETURN_OK;
     LVOS_TP_START(PAL_ACL_REUSE_REPLAY_LOG_2_301_5, &output->executeSynctask, NULL);
     spin_lock(&manager->lock);
     output->executeSynctask = (ACL_APO_SCAN_ENDED != manager->scan.status 
-        && MAX_ACL_ASYNC_DELETE_LIST_LEN > getAclAsyncDeleteEntryNum(fsId));
+        && maxAclAsyncDelList > (uint32_t)getAclAsyncDeleteEntryNum(fsId));
     spin_unlock(&manager->lock);
     LVOS_TP_END;
     
