--- ./source/private_module/ctrl/sys/cls/cls_fencing.c	2018-04-04 09:03:55.000000000 +0000
+++ ./source/private_module/ctrl/sys/cls/cls_fencing.c.hotpatch	2019-01-07 02:25:17.000000000 +0000
@@ -2348,12 +2348,12 @@
     return retVal;
 }
 
+#define SPLIT_POWERON_ARB_REG (SPLIT_CHECK_TYPE_E)(SPLIT_CHECK_ARB_REG+1)
+#define SPLIT_CYCLE_ARB_REG (SPLIT_CHECK_TYPE_E)(SPLIT_CHECK_ARB_REG+2)
+void createPowerOnRegDiskTask(void* cmd);
+void createCycleRegDiskTask(void* cmd);
 /**************************************************************************
      : ٲý
- :
- :  
-   ֵ:
-     :  
 **************************************************************************/
 static int32_t actionClsSplitTaskOver(TASK_S* task)
 {
@@ -2381,9 +2381,7 @@
     CLS_SPLIT_TASK_S* splitTask = NULL;
     SYS_CMD_S* sysCmd = NULL;
     SPLIT_JUDGE_INFO_S* splitJudgeInfo = NULL;
-
     CTRL_UTIL_IF(NULL != cmd);
-
     sysCmd = (SYS_CMD_S*)cmd;
     splitJudgeInfo = (SPLIT_JUDGE_INFO_S*)GET_SYSCMD_PARAM_PTR(sysCmd);
 
@@ -2397,7 +2395,6 @@
         splitJudgeInfo->callBack(SPLIT_UNKNOWN, splitJudgeInfo->context);
         return RETURN_ERROR;
     }
-
     memcpy(&(splitTask->splitJudgeInfo), splitJudgeInfo, sizeof(SPLIT_JUDGE_INFO_S));
     splitTask->isDelayPreempt = B_FALSE;
     splitTask->winnerGroupMap = 0;
@@ -2406,7 +2403,6 @@
     splitTask->diskIdx = 0;
     splitTask->result = SPLIT_UNKNOWN;
     splitTask->traceType = SYS_TRACE_TYPE_FENCING_CLS_SPLIT;
-
     switch (splitTask->splitJudgeInfo.type)
     {
         case SPLIT_CHECK_LINK_EVENT_ARB_CHK:
@@ -2416,6 +2412,14 @@
         case SPLIT_CHECK_ARB_REG:
             fillClsSplitJudgeCleanTaskActions(&(splitTask->baseTask));
             break;
+        case SPLIT_POWERON_ARB_REG:  //ϵעٲkey
+            DESTROY_SYS_TASK(&(splitTask->baseTask));
+            createPowerOnRegDiskTask(sysCmd);
+            return RETURN_OK;
+        case SPLIT_CYCLE_ARB_REG:   //1hʱעٲkey
+            DESTROY_SYS_TASK(&(splitTask->baseTask));
+            createCycleRegDiskTask(sysCmd);
+            return RETURN_OK;
         default:
             DBG_LogError(DBG_LOGID_NEW, "SPLIT_JUDGE: split judge type invalide,split result : unknow.");
             splitJudgeInfo->callBack(SPLIT_UNKNOWN, splitJudgeInfo->context);
@@ -2424,18 +2428,14 @@
             /*Modified by j00358105 for DTS2016051010784  2016/5/9 end*/
             return RETURN_ERROR;
     }
-
-
     INIT_SYS_TRACE(SYS_TRACE_TYPE_FENCING_CLS_SPLIT);
     SET_TASK_PRIORITY_HIGH(&(splitTask->baseTask));
     SET_TASK_PRIVATE_PTR(&(splitTask->baseTask), sysCmd);
     SET_TASK_NAME(&(splitTask->baseTask), "SPLIT_JUDGE");
-
     TASK_CALL_ACTION_START_ASYNC(&(splitTask->baseTask));
 
     DBG_LogInfo(DBG_LOGID_NEW, "SPLIT_JUDGE: Create cls split judge task(fencing preempt way:alivemap:%u,faultmap:%u,exitmap:%u) succeeded.",
                 splitTask->splitJudgeInfo.localNidMap, splitTask->splitJudgeInfo.faultNidMap, splitTask->splitJudgeInfo.exitNidMap);
-
     return RETURN_OK;
 }
 
@@ -2552,9 +2552,9 @@
 }
 
 
-
+void cycleQueryArbDiskDone(int32_t result, uint32_t slotId, uint32_t prGen, uint32_t length, uint64_t* keyList, void* context);
 /**************************************************************************
-     : ڵϵٲ:ٲ̺ϷԼ
+     : 1hʱٲkey:ٲkeyϢǷʧ
  :
  :  
    ֵ:
@@ -2566,28 +2566,28 @@
     TASK_CALL_ACTION_DONE_ASYNC_WITH_RESULT(task, RETURN_OK);
     return RETURN_OK;
 #else
+    CLS_SPLIT_REGDISK_CHILD_TASK_S* splitRegDiskChildTask = NULL;
     int32_t retVal = RETURN_ERROR;
-    uint32_t diskIdx = 0;
-
     CTRL_UTIL_IF(NULL != task);
 
-    SET_SYS_TRACE_STEP(SYS_TRACE_TYPE_FENCING_LOCAL_SPLIT, task);
-
-    SET_ACTION_CHILDNUM(task, ARB_DISK_NUM);
-
-    for (diskIdx = 0; diskIdx < ARB_DISK_NUM; diskIdx++)
+    splitRegDiskChildTask = (CLS_SPLIT_REGDISK_CHILD_TASK_S*)task;
+    SET_ACTION_CHILDNUM(task, 1);
+    //ѭѯ0-3λٲkeyϢ
+    //cycleQueryArbDiskDoneصжԲѯĽж
+    //ͬһ̣ڵ㶼ûκοkeyΪòλٲkeyʧ
+    retVal = sdInquiryArbitrationDisk(splitRegDiskChildTask->diskIdx,
+                                      task,
+                                      cycleQueryArbDiskDone);
+    if (RETURN_OK != retVal)
     {
-        retVal = sdInquiryArbitrationDisk(diskIdx, task, localSplitArbDiskCheckKeyDone);
-        if (RETURN_OK != retVal)
-        {
-            TASK_CALL_ACTION_CHILDDONE(task, retVal);
-        }
+       DBG_LogWarning(DBG_LOGID_NEW, "CLS_FENCING: query arb key of disk(%u) failed(%d).", splitRegDiskChildTask->diskIdx, retVal);
+       TASK_CALL_ACTION_CHILDDONE(task, RETURN_ERROR);
+       return RETURN_OK;
     }
-
     return RETURN_OK;
 #endif
 }
-
+#define RETURN_KEY_VALID (1)
 /**************************************************************************
      : ڵϵٲ:ٲ̺ϷԼ
  :
@@ -2598,27 +2598,27 @@
 static int32_t localSplitArbDiskCheckActionDone(TASK_S* task)
 {
     int32_t retVal = RETURN_ERROR;
-    LOCAL_SPLIT_CHECK_TASK_S* localSplitCheckTask = NULL;
-
+    CLS_SPLIT_REGDISK_CHILD_TASK_S* splitRegDiskChildTask = NULL;
     CTRL_UTIL_IF(NULL != task);
-
-    localSplitCheckTask = (LOCAL_SPLIT_CHECK_TASK_S*)task;
-
-    SET_SYS_TRACE_STEP(SYS_TRACE_TYPE_FENCING_LOCAL_SPLIT, task);
-
-    /*ٲ̸Сڵϵʧ*/
-    if (atomic_read(&(localSplitCheckTask->diskNum)) < ARB_DISK_NUM - 1)
-    {
-        localSplitCheckTask->result = SPLIT_FAIL;
-        retVal = defaultActionDone(task);
-        return retVal;
+    splitRegDiskChildTask = (CLS_SPLIT_REGDISK_CHILD_TASK_S*)task;
+    retVal = GET_ACTION_RESULT(task);
+    if (RETURN_OK != retVal){
+        if (splitRegDiskChildTask->diskIdx >= ARB_DISK_NUM - 1){
+            retVal = (RETURN_KEY_VALID == retVal) ? RETURN_OK : retVal;
+            SET_ACTION_RESULT(task, retVal); /* ǿƸĵǰRETURN_KEY_VALIDresultΪOK־ӡ */
+            SET_GOTO_TASK_OVER_FLAG(task, B_TRUE); /*Ѿѯٲ̣*/
+            retVal = defaultActionDone(task);
+            return retVal;
+        }
+        /*  ǰλkeyѯʧܣעٲ̣ѯһλ*/ /*ǰλkeyûжʧעٲ̣ѯһλ*/
+        splitRegDiskChildTask->diskIdx++;  
+        REDO_SYS_TASK_FROM_BEGIN(task);
+        return RETURN_OK;
     }
-    else
-    {
-        retVal = defaultActionDoneIgnoreResult(task);
+    else{ /*ǰλkeyʧһactionעٲ*/
+        retVal = defaultActionDone(task);  
+        return retVal;
     }
-
-    return retVal;
 }
 
 /**************************************************************************
@@ -5348,3 +5348,405 @@
     return;
 }
 
+
+#if DESC("ϵڹ̼FWͬɺעٲkeyFWµٲkey쳣")
+/**************************************************************************
+     :  עص
+ :  
+ :  
+   ֵ:  
+     :  
+**************************************************************************/
+void powerOnRegDiskCb(int32_t result, void* context)
+{
+    SYS_CMD_S* sysCmd = NULL;
+    SPLIT_JUDGE_INFO_S* splitJudgeInfo = NULL;
+
+    sysCmd = (SYS_CMD_S*)context;
+    CTRL_UTIL_IF_RETURN(NULL != sysCmd);
+
+    splitJudgeInfo = (SPLIT_JUDGE_INFO_S*)GET_SYSCMD_PARAM_PTR(sysCmd);
+    if (NULL != splitJudgeInfo->callBack)
+    {
+        splitJudgeInfo->callBack(RETURN_OK, splitJudgeInfo->context);
+    }
+    COMPLETE_MUTEX_REQUEST(sysCmd, result);
+    return;
+}
+
+/**************************************************************************
+     :  עٲ̲
+ :
+ :  
+   ֵ:
+     :  
+**************************************************************************/
+static void fillPowerOnRegDiskTaskActions(TASK_S* task)
+{
+    uint32_t idx = 0;
+    task->ActionArray[idx++] = ACTION_CLS_SPLIT_REGDISK_TASK_OVER;
+    task->ActionArray[idx++] = ACTION_CLS_SPLIT_REGDISK_REG_FIRST_LOOP;
+    task->ActionArray[idx++] = ACTION_OPCODE_BUTT;
+    return;
+}
+
+void createPowerOnRegDiskTask(void* cmd)
+{
+    int32_t retVal = RETURN_ERROR;
+    CLS_SPLIT_REGDISK_CHILD_TASK_S* powerOnRegTask = NULL;
+    SYS_CMD_S* sysCmd = NULL;
+    SPLIT_JUDGE_INFO_S* splitJudgeInfo = NULL;
+
+    sysCmd = (SYS_CMD_S*)cmd;
+    CTRL_UTIL_IF_RETURN(NULL != sysCmd);
+
+    splitJudgeInfo = (SPLIT_JUDGE_INFO_S*)GET_SYSCMD_PARAM_PTR(sysCmd);
+    if (NULL == splitJudgeInfo)
+    {
+        DBG_LogWarning(DBG_LOGID_NEW, "CLS_FENCING: Create reg disk with null para.");
+        COMPLETE_MUTEX_REQUEST(cmd, RETURN_ERROR);
+        return;
+    }
+    
+    if (NULL == splitJudgeInfo->callBack)
+    {
+        DBG_LogWarning(DBG_LOGID_NEW, 
+            "CLS_FENCING: Create reg disk with null callback.");
+        COMPLETE_MUTEX_REQUEST(cmd, RETURN_ERROR);
+        return;
+    }
+    
+    /* עĽڵΪ0 ֱӽ */
+    if (0 == splitJudgeInfo->localNidMap)
+    {
+        DBG_LogWarning(DBG_LOGID_NEW, 
+            "CLS_FENCING: Create reg disk with invalid para(node %u).", splitJudgeInfo->localNidMap);
+        splitJudgeInfo->callBack(RETURN_OK, cmd);
+        COMPLETE_MUTEX_REQUEST(cmd, RETURN_ERROR);
+        return;
+    }
+    
+    retVal = CREATE_SYS_TASK((TASK_S**)&powerOnRegTask,
+                             sizeof(CLS_SPLIT_REGDISK_CHILD_TASK_S),
+                             fillPowerOnRegDiskTaskActions);
+    if (RETURN_OK != retVal)
+    {
+        DBG_LogError(DBG_LOGID_NEW, "CLS_FENCING: create regdisk child task fail.");
+        splitJudgeInfo->callBack(RETURN_OK, cmd);
+        COMPLETE_MUTEX_REQUEST(cmd, RETURN_ERROR);
+        return ;
+    }
+
+    powerOnRegTask->regBitmap = splitJudgeInfo->localNidMap;  //ϵ硢ָϵڵλͼ
+    powerOnRegTask->diskBitmap = (1 << MAX_ARB_DISK_NUM) - 1;  //ǰ3λdiskλͼ
+    powerOnRegTask->cb = powerOnRegDiskCb;
+    powerOnRegTask->ctx = cmd;
+    powerOnRegTask->diskIdx = getNextRegDiskId(powerOnRegTask->diskBitmap, 0);
+    //SYS_ASSERT(INVALID_DISK_ID != powerOnRegTask->diskIdx);
+
+    SET_TASK_PRIVATE_PTR(&(powerOnRegTask->baseTask), cmd);
+    SET_TASK_PRIORITY_HIGH(&(powerOnRegTask->baseTask));
+    SET_TASK_NAME(&(powerOnRegTask->baseTask),"SPLIT_POWERON_REGDISK");
+
+    TASK_CALL_ACTION_START_ASYNC(&(powerOnRegTask->baseTask));
+
+}
+#endif
+
+#if DESC("1hΪѭעٲkeyٲkey쳣")
+static uint32_t s_lastArbDiskKeyNum[ARB_DISK_NUM] = {2,2,2}; //Ĭÿ̶key
+atomic_t s_arbDiskCycleHandleCnt = ATOMIC_INIT(0); /* ¼עٲkeyǷ */
+/**************************************************************************
+     :  λͼеĵһڵ
+ :
+ :  
+   ֵ:
+     :  
+**************************************************************************/
+bool isFirstNidInNidMap(nid_t nid, uint32_t map)
+{
+    int32_t firstNid = INVALID_NID;
+
+    if (!LVOS_FindFirst1Bit(&map, MAX_CTRL_NODE_NUM, (int32_t *)&firstNid))
+    {
+        return B_FALSE;
+    }
+
+    if (firstNid != nid)
+    {
+        return B_FALSE;
+    }
+
+    return B_TRUE;
+}
+
+/**************************************************************************
+     :   
+ :  
+ :  
+   ֵ:  
+     :  
+**************************************************************************/
+void clsArbDiskCycleHandle(void)
+{
+    int32_t retVal = RETURN_ERROR;
+    SPLIT_JUDGE_INFO_S splitJudgeInfo;
+    nid_t localNid = INVALID_NID;
+    uint32_t groupMap = 0;
+    uint32_t normalMap = 0;
+    uint32_t groupNormalMap = 0;
+
+    localNid = getLocalNid();
+    getNidMapInGroup(localNid, &groupMap);
+
+    getNodeBitMap(SYS_NODE_STATUS_NORMAL, &normalMap);
+    groupNormalMap = normalMap & groupMap;
+    if (groupMap != groupNormalMap) //нڵ㲻λ
+    {
+        SYSCTRL_PRINT_LIMIT(720 * 60 * HZ, 1, DBG_LOG_INFO, 
+                            DBG_LOGID_NEW, "SPLIT_JUDGE: some node(normal:%u) is abnonarl.", groupNormalMap);
+        return;
+    }
+
+    /*߼ĵһڵ飬Ƿٲ̶ʧkey*/
+    if (!isFirstNidInNidMap(localNid, groupNormalMap))
+    {
+    
+        SYSCTRL_PRINT_LIMIT(10080 * 60 * HZ, 1, DBG_LOG_INFO, 
+                            DBG_LOGID_NEW, "SPLIT_JUDGE: node(%u) need not to check arb disk.", localNid);
+        return;
+    }
+
+    /*ִйóֲ ʱ1H*/
+    if (1 != atomic_inc_return (&s_arbDiskCycleHandleCnt))
+    {
+        SYSCTRL_PRINT_LIMIT(360 * 60 * HZ, 1, DBG_LOG_INFO, 
+                            DBG_LOGID_NEW, "SPLIT_JUDGE: no need to register arb disk again.");
+        atomic_dec(&s_arbDiskCycleHandleCnt);
+        return;
+    }
+
+    memset(&splitJudgeInfo,0,sizeof(splitJudgeInfo));
+    splitJudgeInfo.type = (SPLIT_CHECK_TYPE_E)SPLIT_CYCLE_ARB_REG;
+
+    /*뻥ִ*/
+    retVal = RECEIVE_MUTEX_REQUEST(SYS_OP_SYS_FENCING_SPLITJUDGE, SYS_CMD_PARAM_EVENT, sizeof(SPLIT_JUDGE_INFO_S), &splitJudgeInfo);
+    if (RETURN_OK != retVal)
+    {
+        SYSCTRL_PRINT_LIMIT(360 * 60 * HZ, 1, DBG_LOG_INFO, 
+                            DBG_LOGID_NEW,  "SPLIT_JUDGE: start fencing split judge failed,split result : unknow.");
+        atomic_dec(&s_arbDiskCycleHandleCnt);
+        return;
+    }
+
+    return;
+}
+/**************************************************************************
+     :  עص
+ :  
+ :  
+   ֵ:  
+     :  
+**************************************************************************/
+void cycleRegDiskCb(int32_t result, void* context)
+{
+    void* sysCmd = NULL;
+
+    DBG_LogDebug(DBG_LOGID_NEW, "CLS_FENCING: Cls fencing result %d.", result);
+    sysCmd = context;
+    COMPLETE_MUTEX_REQUEST(sysCmd, result);
+
+    /* µٲ̼ */
+    atomic_dec(&s_arbDiskCycleHandleCnt);
+    return;
+}
+
+/**************************************************************************
+     :  עٲ̲
+ :
+ :  
+   ֵ:
+     :  
+**************************************************************************/
+static void fillCycleRegDiskTaskActions(TASK_S* task)
+{
+    uint32_t idx = 0;
+    task->ActionArray[idx++] = ACTION_CLS_SPLIT_REGDISK_TASK_OVER;
+    task->ActionArray[idx++] = ACTION_LOCAL_SPLIT_ARBDISK_CHECK;
+    task->ActionArray[idx++] = ACTION_CLS_SPLIT_REGDISK_REG_FIRST_LOOP;
+    task->ActionArray[idx++] = ACTION_OPCODE_BUTT;
+    return;
+}
+
+void createCycleRegDiskTask(void* cmd)
+{
+    int32_t retVal = RETURN_ERROR;
+    CLS_SPLIT_REGDISK_CHILD_TASK_S* cycleRegTask = NULL;
+    uint32_t regBitmap = 0;
+
+    getNidMapInGroup (getLocalNid(), &regBitmap);
+
+    /* עĽڵΪ0 ֱӽ */
+    if (0 == regBitmap)
+    {
+        DBG_LogWarning(DBG_LOGID_NEW, 
+            "CLS_FENCING: Create reg disk with invalid para(node %u).", regBitmap);
+        COMPLETE_MUTEX_REQUEST(cmd, RETURN_ERROR);
+        atomic_dec(&s_arbDiskCycleHandleCnt);
+        return;
+    }
+    
+    retVal = CREATE_SYS_TASK((TASK_S**)&cycleRegTask,
+                             sizeof(CLS_SPLIT_REGDISK_CHILD_TASK_S),
+                             fillCycleRegDiskTaskActions);
+    if (RETURN_OK != retVal)
+    {
+        DBG_LogError(DBG_LOGID_NEW, "CLS_FENCING: create regdisk child task fail.");
+        COMPLETE_MUTEX_REQUEST(cmd, RETURN_ERROR);
+        atomic_dec(&s_arbDiskCycleHandleCnt);
+        return ;
+    }
+
+    cycleRegTask->regBitmap = regBitmap; //СŽڵ߼Ľڵλͼ
+    cycleRegTask->diskBitmap = (1 << MAX_ARB_DISK_NUM) - 1;  //ǰ3λdiskλͼ
+    cycleRegTask->cb = cycleRegDiskCb;
+    cycleRegTask->ctx = cmd;
+    cycleRegTask->diskIdx = getNextRegDiskId(cycleRegTask->diskBitmap, 0);
+
+    SET_TASK_PRIORITY_HIGH(&(cycleRegTask->baseTask));
+    SET_TASK_NAME(&(cycleRegTask->baseTask),"SPLIT_CYCLE_REGDISK");
+
+    TASK_CALL_ACTION_START_ASYNC(&(cycleRegTask->baseTask));
+
+}
+
+/**************************************************************************
+     :  ѯٲ̵keyǷЧ
+ :
+ :  
+   ֵ:
+     :  
+**************************************************************************/
+bool isArbKeyValid(uint32_t slotId, uint32_t keyNum, uint64_t* keyList)
+{
+    nid_t localNid = INVALID_NID;
+    uint32_t groupMap = 0;
+    nid_t nidIdx = INVALID_NID;
+    uint64_t key = INVALID_KEY;
+    uint32_t keyIdx = 0;
+    
+    localNid = getLocalNid();
+    getNidMapInGroup(localNid, &groupMap);
+    
+    /* αµĽڵ */
+    for (nidIdx = 0; nidIdx < MAX_CTRL_NODE_NUM; nidIdx++)
+    {
+        if (!CHECK_NODEMAP_BIT_VALID(nidIdx, groupMap))
+        {
+            continue;
+        }
+        /* ɵǰڵkey */
+        key = GET_FENCING_REG_CODE(nidIdx, slotId);
+        
+        for (keyIdx = 0; keyIdx < keyNum; keyIdx++)
+        {
+            if (key == keyList[keyIdx]) /* ǰڵkeyٲϴ */
+            {
+                return true;
+            }
+        }/* ǰڵkeyٲϣڵһڵ */
+    }
+
+    return false; /*нڵkey */
+}
+
+/**************************************************************************
+     :  ѯٲ̵Ļص
+ :
+ :  
+   ֵ:
+     :  
+**************************************************************************/
+void cycleQueryArbDiskDone(int32_t result, uint32_t slotId, uint32_t prGen, uint32_t keyNum, uint64_t* keyList, void* context)
+{
+    CLS_SPLIT_REGDISK_CHILD_TASK_S* cycleRegTask = NULL;
+    uint32_t normalMap = 0;
+    uint32_t groupNormalMap = 0;
+    nid_t localNid = INVALID_NID;
+    uint32_t groupMap = 0;
+    uint32_t kidx = 0;
+
+    UNREFERENCE_PARAM(prGen);
+    UNREFERENCE_PARAM(keyList);
+
+    CTRL_UTIL_IF(NULL != context);
+
+    cycleRegTask = (CLS_SPLIT_REGDISK_CHILD_TASK_S*)context;
+
+    if (RETURN_OK != result)
+    {
+       DBG_LogWarning(DBG_LOGID_NEW, "CLS_FENCING: query arb key of disk(%u) failed(%d).", slotId, result);
+       TASK_CALL_ACTION_CHILDDONE(&(cycleRegTask->baseTask), RETURN_ERROR);
+       return;
+    }
+
+    if (ARB_DISK_NUM <= slotId)
+    {
+        DBG_LogWarning(DBG_LOGID_NEW, "CLS_FENCING: query arb key of disk(%u) failed.", slotId);
+        TASK_CALL_ACTION_CHILDDONE(&(cycleRegTask->baseTask), RETURN_ERROR);
+        return;
+    }
+
+    if (0 != keyNum)  //Уϵkeyֵ
+    {
+        if (!isArbKeyValid(slotId, keyNum, keyList))            
+        {
+            DBG_LogWarning(DBG_LOGID_NEW, "CLS_FENCING: the arb key of disk(%u) is invalid.", slotId);
+            for (kidx = 0; kidx < keyNum; kidx++)
+            {
+                DBG_LogWarning(DBG_LOGID_NEW, "CLS_FENCING: the arb key(%u) of disk(%u) is:0x%016lx.", kidx, slotId, keyList[kidx]);
+            }
+            keyNum = 0; //еkeyЧkeyNumΪ0
+        }
+    }
+
+    /*ͬһ̣ڵ㶼ûκοkey*/
+    if ((0 == keyNum) && (0 == s_lastArbDiskKeyNum[slotId]))
+    {
+       s_lastArbDiskKeyNum[slotId] = keyNum; //µǰkeyϢlast
+       
+       /*вɺٴ*/
+        if (UPGRADE_GetAllUpgradeFlag())
+        {
+            DBG_LogInfo(DBG_LOGID_NEW, "CLS_FENCING: Systerm is online upgrading, need to delay trigger.");
+            TASK_CALL_ACTION_CHILDDONE(&(cycleRegTask->baseTask), RETURN_ERROR);
+            return;
+        }
+
+        localNid = getLocalNid();
+        getNidMapInGroup(localNid, &groupMap);
+        getNodeBitMap(SYS_NODE_STATUS_NORMAL, &normalMap);
+        groupNormalMap = normalMap & groupMap;
+        if (groupMap == groupNormalMap) //нڵ
+        {
+            DBG_LogWarning(DBG_LOGID_NEW, "CLS_FENCING: the arb key of disk(%u) is lost, need to register now.", slotId);
+            TASK_CALL_ACTION_CHILDDONE(&(cycleRegTask->baseTask), RETURN_OK);
+            return;
+        }
+        else //ڽڵϡߵ쳣
+        {
+            DBG_LogInfo(DBG_LOGID_NEW, "CLS_FENCING: some node is fault, need to delay trigger.");
+            TASK_CALL_ACTION_CHILDDONE(&(cycleRegTask->baseTask), RETURN_ERROR);
+            return;
+        }
+    }
+    else
+    {   /*ͬһ̣ڵԲ鵽key*/
+        s_lastArbDiskKeyNum[slotId] = keyNum;
+        TASK_CALL_ACTION_CHILDDONE(&(cycleRegTask->baseTask), RETURN_KEY_VALID);
+        return;
+    }
+}
+#endif
+
+
--- ./source/private_module/ctrl/sys/cls/cls_power_on.c	2018-04-25 09:54:21.000000000 +0000
+++ ./source/private_module/ctrl/sys/cls/cls_power_on.c.hotpatch	2019-01-04 03:26:17.000000000 +0000
@@ -70,7 +70,7 @@
 #include "ctrl_public_util.h"
 #include "om_adapter.h"
 #include "cfg_obj_bdm.h"
-
+#include "cls_fencing.h"
 MODULE_ID(OSP_SYS);
 
 /*****************************************************************/
@@ -6495,13 +6495,13 @@
 
     return RETURN_OK;
 }
-
+#define SPLIT_POWERON_ARB_REG (SPLIT_CHECK_TYPE_E)(SPLIT_CHECK_ARB_REG+1)
+extern void voteOverClsSplitRegCb(int32_t result, void* context);
 /**************************************************************************
      :  PowerOnִв--ͼȺϵ¼
  :  task -- Taskָ
  :  
  ֵ  :  RETURN_OK:ɹ;RETURN_ERROR:ʧ
-     :  
 **************************************************************************/
 static int32_t pwrOnSendEvent(TASK_S *task)
 {
@@ -6594,8 +6594,8 @@
     }
 
     LVOS_TP_END
-
-    TASK_CALL_ACTION_DONE_ASYNC_WITH_RESULT(task, RETURN_OK);
+    /* Ӳ̿FWͬע */
+    clsSplitJudge(SPLIT_POWERON_ARB_REG, powerOnTask->pwrBitmap, 0,0, voteOverClsSplitRegCb, task);
     return RETURN_OK;
 }
 
--- ./source/private_module/ctrl/sys/flow_manager/flow_scheduler/comm_mutex.c	2018-03-08 04:40:08.000000000 +0000
+++ ./source/private_module/ctrl/sys/flow_manager/flow_scheduler/comm_mutex.c.hotpatch	2019-01-04 03:26:17.000000000 +0000
@@ -240,22 +240,22 @@
 
     curTime = LVOS_GetMilliSecond();
     printInfo = getMutexPrintInfo(sysCmd->opCode);
-
     /* sysCmd opcodeӡͬ־ */
     if (NULL != printInfo)
     {
         CTRL_UTIL_TYPE_LOG(printInfo->logType, printInfo->limitType, printInfo->logLevel, LOG_ID_2471,
                            "SYS_MUTEX: Set sys cmd(name %s, index %u) delay(0x%x) status(%s) succeeded.",
                            sysCmd->name, sysCmd->serialNo, (uint32_t)(curTime-sysCmd->birthTime), getSysCmdStatusName(status));
-            
     }
     else
     {
+        if  (SYS_OP_SYS_FENCING_SPLITJUDGE == sysCmd->opCode){
+            return;
+        }
         DBG_LogInfo(LOG_ID_16D6,
             "SYS_MUTEX: Set sys cmd(name %s, index %u) delay(0x%x) status(%s) succeeded.",
             sysCmd->name, sysCmd->serialNo, (uint32_t)(curTime-sysCmd->birthTime), getSysCmdStatusName(status));
     }
-
     return;
 }
 
--- ./source/private_module/ctrl/sys/strategy/ha_service/ha_service_strategy.c	2018-02-09 07:36:26.000000000 +0000
+++ ./source/private_module/ctrl/sys/strategy/ha_service/ha_service_strategy.c.hotpatch	2019-01-04 03:26:17.000000000 +0000
@@ -345,7 +345,7 @@
         return B_FALSE;
     }
 }
-
+void clsArbDiskCycleHandle(void);
 
 /** \brief  HAʱԴȵĳʱ
     \param[in] HA_SERVICE_TYPE_E serviceType   -- VNODEȶ,HA_SERVICE_TYPE_E
@@ -360,7 +360,7 @@
     SYS_NODE_CLUSTER_ROLE_E role = SYS_NODE_CLUSTER_BUTT;
 
     UNREFERENCE_PARAM(arg);
-    
+    clsArbDiskCycleHandle();
     localNid = getLocalNid();
 
     /* Ƿڣ򲻴 */
