diff --git a/source/common/src/trow.c b/source/common/src/trow.c
index 7234e5c5f6..1dc4a6f9ba 100644
--- a/source/common/src/trow.c
+++ b/source/common/src/trow.c
@@ -138,7 +138,7 @@ int32_t tdGetBitmapValTypeII(const void *pBitmap, int16_t colIdx, TDRowValT *pVa
 int32_t tdGetBitmapValType(const void *pBitmap, int16_t colIdx, TDRowValT *pValType, int8_t bitmapMode) {
   switch (bitmapMode) {
     case 0:
-      tdGetBitmapValTypeII(pBitmap, colIdx, pValType);
+      (void)tdGetBitmapValTypeII(pBitmap, colIdx, pValType);
       break;
 #if 0
     case -1:
@@ -354,8 +354,8 @@ bool tdSKvRowGetVal(STSRow *pRow, col_id_t colId, col_id_t colIdx, SCellVal *pVa
   }
 
   void *pBitmap = tdGetBitmapAddrKv(pRow, tdRowGetNCols(pRow));
-  tdGetKvRowValOfCol(pVal, pRow, pBitmap, pColIdx->offset,
-                     POINTER_DISTANCE(pColIdx, TD_ROW_COL_IDX(pRow)) / sizeof(SKvRowIdx));
+  (void)tdGetKvRowValOfCol(pVal, pRow, pBitmap, pColIdx->offset,
+                           POINTER_DISTANCE(pColIdx, TD_ROW_COL_IDX(pRow)) / sizeof(SKvRowIdx));
   return true;
 }
 
@@ -366,7 +366,7 @@ bool tdSTpRowGetVal(STSRow *pRow, col_id_t colId, col_type_t colType, int32_t fl
     return true;
   }
   void *pBitmap = tdGetBitmapAddrTp(pRow, flen);
-  tdGetTpRowValOfCol(pVal, pRow, pBitmap, colType, offset, colIdx);
+  (void)tdGetTpRowValOfCol(pVal, pRow, pBitmap, colType, offset, colIdx);
   return true;
 }
 
@@ -385,9 +385,9 @@ bool tdSTSRowIterNext(STSRowIter *pIter, SCellVal *pVal) {
   }
 
   if (TD_IS_TP_ROW(pIter->pRow)) {
-    tdSTSRowIterGetTpVal(pIter, pCol->type, pCol->offset, pVal);
+    (void)tdSTSRowIterGetTpVal(pIter, pCol->type, pCol->offset, pVal);
   } else if (TD_IS_KV_ROW(pIter->pRow)) {
-    tdSTSRowIterGetKvVal(pIter, pCol->colId, &pIter->kvIdx, pVal);
+    (void)tdSTSRowIterGetKvVal(pIter, pCol->colId, &pIter->kvIdx, pVal);
   } else {
     ASSERT(0);
   }
@@ -486,8 +486,8 @@ int32_t tdSTSRowNew(SArray *pArray, STSchema *pTSchema, STSRow **ppRow, int8_t r
 
   SRowBuilder rb = {.rowType = rowType};
   tdSRowInit(&rb, pTSchema->version);
-  tdSRowSetInfo(&rb, pTSchema->numOfCols, nBound, pTSchema->flen);
-  tdSRowResetBuf(&rb, *ppRow);
+  (void)tdSRowSetInfo(&rb, pTSchema->numOfCols, nBound, pTSchema->flen);
+  (void)tdSRowResetBuf(&rb, *ppRow);
   int32_t iBound = 0;
 
   iColVal = 0;
@@ -506,7 +506,7 @@ int32_t tdSTSRowNew(SArray *pArray, STSchema *pTSchema, STSRow **ppRow, int8_t r
       } else if (IS_VAR_DATA_TYPE(pTColumn->type)) {
         varDataSetLen(varBuf, pColVal->value.nData);
         if (pColVal->value.nData != 0) {
-          memcpy(varDataVal(varBuf), pColVal->value.pData, pColVal->value.nData);
+          (void)memcpy(varDataVal(varBuf), pColVal->value.pData, pColVal->value.nData);
         }
         val = varBuf;
         ++iBound;
@@ -578,7 +578,7 @@ bool tdSTSRowGetVal(STSRowIter *pIter, col_id_t colId, col_type_t colType, SCell
 #ifdef TD_SUPPORT_BITMAP
     colIdx = POINTER_DISTANCE(pCol, pSchema->columns) / sizeof(STColumn);
 #endif
-    tdGetTpRowValOfCol(pVal, pRow, pIter->pBitmap, pCol->type, pCol->offset, colIdx - 1);
+    (void)tdGetTpRowValOfCol(pVal, pRow, pIter->pBitmap, pCol->type, pCol->offset, colIdx - 1);
   } else if (TD_IS_KV_ROW(pRow)) {
     SKvRowIdx *pIdx = (SKvRowIdx *)taosbsearch(&colId, TD_ROW_COL_IDX(pRow), tdRowGetNCols(pRow), sizeof(SKvRowIdx),
                                                compareKvRowColId, TD_EQ);
@@ -587,7 +587,7 @@ bool tdSTSRowGetVal(STSRowIter *pIter, col_id_t colId, col_type_t colType, SCell
       colIdx = POINTER_DISTANCE(pIdx, TD_ROW_COL_IDX(pRow)) / sizeof(SKvRowIdx);
     }
 #endif
-    tdGetKvRowValOfCol(pVal, pRow, pIter->pBitmap, pIdx ? pIdx->offset : -1, colIdx);
+    (void)tdGetKvRowValOfCol(pVal, pRow, pIter->pBitmap, pIdx ? pIdx->offset : -1, colIdx);
   } else {
     if (COL_REACH_END(colId, pIter->maxColId)) return false;
     pVal->valType = TD_VTYPE_NONE;
@@ -689,9 +689,9 @@ int32_t tdAppendColValToRow(SRowBuilder *pBuilder, col_id_t colId, int8_t colTyp
   }
 
   if (TD_IS_TP_ROW(pRow)) {
-    tdAppendColValToTpRow(pBuilder, valType, val, isCopyVarData, colType, colIdx, offset);
+    (void)tdAppendColValToTpRow(pBuilder, valType, val, isCopyVarData, colType, colIdx, offset);
   } else {
-    tdAppendColValToKvRow(pBuilder, valType, val, isCopyVarData, colType, colIdx, offset, colId);
+    (void)tdAppendColValToKvRow(pBuilder, valType, val, isCopyVarData, colType, colIdx, offset, colId);
   }
   TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
@@ -718,11 +718,11 @@ int32_t tdAppendColValToKvRow(SRowBuilder *pBuilder, TDRowValT valType, const vo
     char *ptr = (char *)POINTER_SHIFT(row, TD_ROW_LEN(row));
     if (IS_VAR_DATA_TYPE(colType)) {
       if (isCopyVarData) {
-        memcpy(ptr, val, varDataTLen(val));
+        (void)memcpy(ptr, val, varDataTLen(val));
       }
       TD_ROW_LEN(row) += varDataTLen(val);
     } else {
-      memcpy(ptr, val, TYPE_BYTES[colType]);
+      (void)memcpy(ptr, val, TYPE_BYTES[colType]);
       TD_ROW_LEN(row) += TYPE_BYTES[colType];
     }
   }
@@ -752,11 +752,11 @@ int32_t tdAppendColValToTpRow(SRowBuilder *pBuilder, TDRowValT valType, const vo
       // ts key stored in STSRow.ts
       *(VarDataOffsetT *)POINTER_SHIFT(TD_ROW_DATA(row), offset) = TD_ROW_LEN(row);
       if (isCopyVarData) {
-        memcpy(POINTER_SHIFT(row, TD_ROW_LEN(row)), val, varDataTLen(val));
+        (void)memcpy(POINTER_SHIFT(row, TD_ROW_LEN(row)), val, varDataTLen(val));
       }
       TD_ROW_LEN(row) += varDataTLen(val);
     } else {
-      memcpy(POINTER_SHIFT(TD_ROW_DATA(row), offset), val, TYPE_BYTES[colType]);
+      (void)memcpy(POINTER_SHIFT(TD_ROW_DATA(row), offset), val, TYPE_BYTES[colType]);
     }
   }
 
@@ -782,7 +782,7 @@ int32_t tdSRowResetBuf(SRowBuilder *pBuilder, void *pBuf) {
     case TD_ROW_TP:
 #ifdef TD_SUPPORT_BITMAP
       pBuilder->pBitmap = tdGetBitmapAddrTp(pBuilder->pBuf, pBuilder->flen);
-      memset(pBuilder->pBitmap, TD_VTYPE_NONE_BYTE_II, pBuilder->nBitmaps);
+      (void)memset(pBuilder->pBitmap, TD_VTYPE_NONE_BYTE_II, pBuilder->nBitmaps);
 #endif
       // the primary TS key is stored separatedly
       len = TD_ROW_HEAD_LEN + pBuilder->flen + pBuilder->nBitmaps;
@@ -792,7 +792,7 @@ int32_t tdSRowResetBuf(SRowBuilder *pBuilder, void *pBuf) {
     case TD_ROW_KV:
 #ifdef TD_SUPPORT_BITMAP
       pBuilder->pBitmap = tdGetBitmapAddrKv(pBuilder->pBuf, pBuilder->nBoundCols);
-      memset(pBuilder->pBitmap, TD_VTYPE_NONE_BYTE_II, pBuilder->nBoundBitmaps);
+      (void)memset(pBuilder->pBitmap, TD_VTYPE_NONE_BYTE_II, pBuilder->nBoundBitmaps);
 #endif
       len = TD_ROW_HEAD_LEN + TD_ROW_NCOLS_LEN + (pBuilder->nBoundCols - 1) * sizeof(SKvRowIdx) +
             pBuilder->nBoundBitmaps;  // add
@@ -937,9 +937,9 @@ void tTSRowGetVal(STSRow *pRow, STSchema *pTSchema, int16_t iCol, SColVal *pColV
   ASSERT((pTColumn->colId == PRIMARYKEY_TIMESTAMP_COL_ID) || (iCol > 0));
 
   if (TD_IS_TP_ROW(pRow)) {
-    tdSTpRowGetVal(pRow, pTColumn->colId, pTColumn->type, pTSchema->flen, pTColumn->offset, iCol - 1, &cv);
+    (void)tdSTpRowGetVal(pRow, pTColumn->colId, pTColumn->type, pTSchema->flen, pTColumn->offset, iCol - 1, &cv);
   } else if (TD_IS_KV_ROW(pRow)) {
-    tdSKvRowGetVal(pRow, pTColumn->colId, iCol - 1, &cv);
+    (void)tdSKvRowGetVal(pRow, pTColumn->colId, iCol - 1, &cv);
   } else {
     ASSERT(0);
   }
@@ -957,7 +957,7 @@ void tTSRowGetVal(STSRow *pRow, STSchema *pTSchema, int16_t iCol, SColVal *pColV
       pColVal->value.nData = varDataLen(cv.val);
       pColVal->value.pData = varDataVal(cv.val);
     } else {
-      memcpy(&pColVal->value.val, cv.val, tDataTypes[pTColumn->type].bytes);
+      (void)memcpy(&pColVal->value.val, cv.val, tDataTypes[pTColumn->type].bytes);
     }
   }
 }
\ No newline at end of file
diff --git a/source/dnode/mnode/impl/src/mndUser.c b/source/dnode/mnode/impl/src/mndUser.c
index ab421ccd0f..2095f80f0f 100644
--- a/source/dnode/mnode/impl/src/mndUser.c
+++ b/source/dnode/mnode/impl/src/mndUser.c
@@ -142,12 +142,12 @@ static int32_t ipWhiteMgtInit() {
     TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
   }
   ipWhiteMgt.ver = 0;
-  taosThreadRwlockInit(&ipWhiteMgt.rw, NULL);
+  (void)taosThreadRwlockInit(&ipWhiteMgt.rw, NULL);
   TAOS_RETURN(0);
 }
 void ipWhiteMgtCleanup() {
   destroyIpWhiteTab(ipWhiteMgt.pIpWhiteTab);
-  taosThreadRwlockDestroy(&ipWhiteMgt.rw);
+  (void)taosThreadRwlockDestroy(&ipWhiteMgt.rw);
 }
 
 int32_t ipWhiteMgtUpdate(SMnode *pMnode, char *user, SIpWhiteList *pNew) {
@@ -155,7 +155,7 @@ int32_t ipWhiteMgtUpdate(SMnode *pMnode, char *user, SIpWhiteList *pNew) {
   int32_t lino = 0;
   bool    update = true;
   SArray *fqdns = NULL;
-  taosThreadRwlockWrlock(&ipWhiteMgt.rw);
+  (void)taosThreadRwlockWrlock(&ipWhiteMgt.rw);
   SIpWhiteList **ppList = taosHashGet(ipWhiteMgt.pIpWhiteTab, user, strlen(user));
 
   if (ppList == NULL || *ppList == NULL) {
@@ -212,7 +212,7 @@ int32_t ipWhiteMgtUpdate(SMnode *pMnode, char *user, SIpWhiteList *pNew) {
   if (update) ipWhiteMgt.ver++;
 
 _OVER:
-  taosThreadRwlockUnlock(&ipWhiteMgt.rw);
+  (void)taosThreadRwlockUnlock(&ipWhiteMgt.rw);
   taosArrayDestroyP(fqdns, (FDelete)taosMemoryFree);
   if (code < 0) {
     mError("failed to update ip white list for user: %s at line %d since %s", user, lino, tstrerror(code));
@@ -221,17 +221,17 @@ _OVER:
 }
 int32_t ipWhiteMgtRemove(char *user) {
   bool update = true;
-  taosThreadRwlockWrlock(&ipWhiteMgt.rw);
+  (void)taosThreadRwlockWrlock(&ipWhiteMgt.rw);
   SIpWhiteList **ppList = taosHashGet(ipWhiteMgt.pIpWhiteTab, user, strlen(user));
   if (ppList == NULL || *ppList == NULL) {
     update = false;
   } else {
     taosMemoryFree(*ppList);
-    taosHashRemove(ipWhiteMgt.pIpWhiteTab, user, strlen(user));
+    (void)taosHashRemove(ipWhiteMgt.pIpWhiteTab, user, strlen(user));
   }
 
   if (update) ipWhiteMgt.ver++;
-  taosThreadRwlockUnlock(&ipWhiteMgt.rw);
+  (void)taosThreadRwlockUnlock(&ipWhiteMgt.rw);
   return 0;
 }
 
@@ -245,7 +245,7 @@ bool isRangeInWhiteList(SIpWhiteList *pList, SIpV4Range *range) {
 }
 #if 0
 int32_t ipWhiteUpdateForAllUser(SIpWhiteList *pList) {
-  taosThreadRwlockWrlock(&ipWhiteMgt.rw);
+  (void)taosThreadRwlockWrlock(&ipWhiteMgt.rw);
 
   SHashObj *pIpWhiteTab = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), 1, HASH_ENTRY_LOCK);
   void     *pIter = taosHashIterate(ipWhiteMgt.pIpWhiteTab, NULL);
@@ -267,8 +267,8 @@ int32_t ipWhiteUpdateForAllUser(SIpWhiteList *pList) {
     if (clone->num != 0) {
       int32_t sz = clone->num + p->num;
       val = taosMemoryCalloc(1, sizeof(SIpWhiteList) + sz * sizeof(SIpV4Range));
-      memcpy(val->pIpRange, p->pIpRange, sizeof(SIpV4Range) * p->num);
-      memcpy(((char *)val->pIpRange) + sizeof(SIpV4Range) * p->num, (char *)clone->pIpRange,
+      (void)memcpy(val->pIpRange, p->pIpRange, sizeof(SIpV4Range) * p->num);
+      (void)memcpy(((char *)val->pIpRange) + sizeof(SIpV4Range) * p->num, (char *)clone->pIpRange,
              sizeof(SIpV4Range) * clone->num);
 
     } else {
@@ -285,7 +285,7 @@ int32_t ipWhiteUpdateForAllUser(SIpWhiteList *pList) {
 
   ipWhiteMgt.pIpWhiteTab = pIpWhiteTab;
   ipWhiteMgt.ver++;
-  taosThreadRwlockUnlock(&ipWhiteMgt.rw);
+  (void)taosThreadRwlockUnlock(&ipWhiteMgt.rw);
   return 0;
 }
 #endif
@@ -305,29 +305,29 @@ static int32_t ipWhiteMgtUpdateAll(SMnode *pMnode) {
 
 #if 0
 void ipWhiteMgtUpdate2(SMnode *pMnode) {
-  taosThreadRwlockWrlock(&ipWhiteMgt.rw);
+  (void)taosThreadRwlockWrlock(&ipWhiteMgt.rw);
 
   ipWhiteMgtUpdateAll(pMnode);
 
-  taosThreadRwlockUnlock(&ipWhiteMgt.rw);
+  (void)taosThreadRwlockUnlock(&ipWhiteMgt.rw);
 }
 #endif
 
 int64_t mndGetIpWhiteVer(SMnode *pMnode) {
   int64_t ver = 0;
   int32_t code = 0;
-  taosThreadRwlockWrlock(&ipWhiteMgt.rw);
+  (void)taosThreadRwlockWrlock(&ipWhiteMgt.rw);
   if (ipWhiteMgt.ver == 0) {
     // get user and dnode ip white list
     if ((code = ipWhiteMgtUpdateAll(pMnode)) != 0) {
-      taosThreadRwlockUnlock(&ipWhiteMgt.rw);
+      (void)taosThreadRwlockUnlock(&ipWhiteMgt.rw);
       mError("%s failed to update ip white list since %s", __func__, tstrerror(code));
       return ver;
     }
     ipWhiteMgt.ver = taosGetTimestampMs();
   }
   ver = ipWhiteMgt.ver;
-  taosThreadRwlockUnlock(&ipWhiteMgt.rw);
+  (void)taosThreadRwlockUnlock(&ipWhiteMgt.rw);
 
   if (mndEnableIpWhiteList(pMnode) == 0 || tsEnableWhiteList == false) {
     ver = 0;
@@ -357,7 +357,7 @@ int32_t mndUpdateIpWhiteImpl(SHashObj *pIpWhiteTab, char *user, char *fqdn, int8
       if (pNewList == NULL) {
         TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER);
       }
-      memcpy(pNewList->pIpRange, &range, sizeof(SIpV4Range));
+      (void)memcpy(pNewList->pIpRange, &range, sizeof(SIpV4Range));
       pNewList->num = 1;
 
       if ((code = taosHashPut(pIpWhiteTab, user, strlen(user), &pNewList, sizeof(void *))) != 0) {
@@ -372,7 +372,7 @@ int32_t mndUpdateIpWhiteImpl(SHashObj *pIpWhiteTab, char *user, char *fqdn, int8
         if (pNewList == NULL) {
           TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER);
         }
-        memcpy(pNewList->pIpRange, pList->pIpRange, sizeof(SIpV4Range) * (pList->num));
+        (void)memcpy(pNewList->pIpRange, pList->pIpRange, sizeof(SIpV4Range) * (pList->num));
         pNewList->pIpRange[pList->num].ip = range.ip;
         pNewList->pIpRange[pList->num].mask = range.mask;
 
@@ -390,7 +390,7 @@ int32_t mndUpdateIpWhiteImpl(SHashObj *pIpWhiteTab, char *user, char *fqdn, int8
     if (pList != NULL) {
       if (isRangeInWhiteList(pList, &range)) {
         if (pList->num == 1) {
-          taosHashRemove(pIpWhiteTab, user, strlen(user));
+          (void)taosHashRemove(pIpWhiteTab, user, strlen(user));
           taosMemoryFree(pList);
         } else {
           int32_t       idx = 0;
@@ -433,14 +433,14 @@ _OVER:
 
 int32_t mndRefreshUserIpWhiteList(SMnode *pMnode) {
   int32_t code = 0;
-  taosThreadRwlockWrlock(&ipWhiteMgt.rw);
+  (void)taosThreadRwlockWrlock(&ipWhiteMgt.rw);
 
   if ((code = ipWhiteMgtUpdateAll(pMnode)) != 0) {
-    taosThreadRwlockUnlock(&ipWhiteMgt.rw);
+    (void)taosThreadRwlockUnlock(&ipWhiteMgt.rw);
     TAOS_RETURN(code);
   }
   ipWhiteMgt.ver = taosGetTimestampMs();
-  taosThreadRwlockUnlock(&ipWhiteMgt.rw);
+  (void)taosThreadRwlockUnlock(&ipWhiteMgt.rw);
 
   TAOS_RETURN(code);
 }
@@ -451,7 +451,7 @@ int32_t mndUpdateIpWhiteForAllUser(SMnode *pMnode, char *user, char *fqdn, int8_
   bool    update = false;
 
   if (lock) {
-    taosThreadRwlockWrlock(&ipWhiteMgt.rw);
+    (void)taosThreadRwlockWrlock(&ipWhiteMgt.rw);
     if (ipWhiteMgt.ver == 0) {
       TAOS_CHECK_GOTO(ipWhiteMgtUpdateAll(pMnode), &lino, _OVER);
       ipWhiteMgt.ver = taosGetTimestampMs();
@@ -470,7 +470,7 @@ int32_t mndUpdateIpWhiteForAllUser(SMnode *pMnode, char *user, char *fqdn, int8_
     if (keyDup == NULL) {
       TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER);
     }
-    memcpy(keyDup, key, klen);
+    (void)memcpy(keyDup, key, klen);
     bool upd = false;
     code = mndUpdateIpWhiteImpl(ipWhiteMgt.pIpWhiteTab, keyDup, fqdn, type, &upd);
     update |= upd;
@@ -485,7 +485,7 @@ int32_t mndUpdateIpWhiteForAllUser(SMnode *pMnode, char *user, char *fqdn, int8_
 
 _OVER:
   if (update) ipWhiteMgt.ver++;
-  if (lock) taosThreadRwlockUnlock(&ipWhiteMgt.rw);
+  if (lock) (void)taosThreadRwlockUnlock(&ipWhiteMgt.rw);
   if (code < 0) {
     mError("failed to update ip-white-list for user: %s, fqdn: %s at line %d since %s", user, fqdn, lino,
            tstrerror(code));
@@ -496,13 +496,13 @@ _OVER:
 
 static int64_t ipWhiteMgtFillMsg(SUpdateIpWhite *pUpdate) {
   int64_t ver = 0;
-  taosThreadRwlockWrlock(&ipWhiteMgt.rw);
+  (void)taosThreadRwlockWrlock(&ipWhiteMgt.rw);
   ver = ipWhiteMgt.ver;
   int32_t num = taosHashGetSize(ipWhiteMgt.pIpWhiteTab);
 
   pUpdate->pUserIpWhite = taosMemoryCalloc(1, num * sizeof(SUpdateUserIpWhite));
   if (pUpdate->pUserIpWhite == NULL) {
-    taosThreadRwlockUnlock(&ipWhiteMgt.rw);
+    (void)taosThreadRwlockUnlock(&ipWhiteMgt.rw);
     TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
   }
 
@@ -516,14 +516,14 @@ static int64_t ipWhiteMgtFillMsg(SUpdateIpWhite *pUpdate) {
     char  *key = taosHashGetKey(pIter, &klen);
     if (list->num != 0) {
       pUser->ver = ver;
-      memcpy(pUser->user, key, klen);
+      (void)memcpy(pUser->user, key, klen);
       pUser->numOfRange = list->num;
       pUser->pIpRanges = taosMemoryCalloc(1, list->num * sizeof(SIpV4Range));
       if (pUser->pIpRanges == NULL) {
-        taosThreadRwlockUnlock(&ipWhiteMgt.rw);
+        (void)taosThreadRwlockUnlock(&ipWhiteMgt.rw);
         TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
       }
-      memcpy(pUser->pIpRanges, list->pIpRange, list->num * sizeof(SIpV4Range));
+      (void)memcpy(pUser->pIpRanges, list->pIpRange, list->num * sizeof(SIpV4Range));
       i++;
     }
     pIter = taosHashIterate(ipWhiteMgt.pIpWhiteTab, pIter);
@@ -531,7 +531,7 @@ static int64_t ipWhiteMgtFillMsg(SUpdateIpWhite *pUpdate) {
   pUpdate->numOfUser = i;
   pUpdate->ver = ver;
 
-  taosThreadRwlockUnlock(&ipWhiteMgt.rw);
+  (void)taosThreadRwlockUnlock(&ipWhiteMgt.rw);
   TAOS_RETURN(0);
 }
 
@@ -684,7 +684,7 @@ static void ipRangeToStr(SIpV4Range *range, char *buf) {
 
   uv_inet_ntop(AF_INET, &addr, buf, 32);
   if (range->mask != 32) {
-    sprintf(buf + strlen(buf), "/%d", range->mask);
+    (void)sprintf(buf + strlen(buf), "/%d", range->mask);
   }
   return;
 }
@@ -1314,7 +1314,7 @@ static SSdbRow *mndUserActionDecode(SSdbRaw *pRaw) {
       if (key == NULL) {
         TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER);
       }
-      memset(key, 0, keyLen);
+      (void)memset(key, 0, keyLen);
       SDB_GET_BINARY(pRaw, dataPos, key, keyLen, _OVER);
 
       int32_t valuelen = 0;
@@ -1323,7 +1323,7 @@ static SSdbRow *mndUserActionDecode(SSdbRaw *pRaw) {
       if (value == NULL) {
         TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER);
       }
-      memset(value, 0, valuelen);
+      (void)memset(value, 0, valuelen);
       SDB_GET_BINARY(pRaw, dataPos, value, valuelen, _OVER)
 
       TAOS_CHECK_GOTO(taosHashPut(pUser->readTbs, key, keyLen, value, valuelen), &lino, _OVER);
@@ -1337,7 +1337,7 @@ static SSdbRow *mndUserActionDecode(SSdbRaw *pRaw) {
       if (key == NULL) {
         TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER);
       }
-      memset(key, 0, keyLen);
+      (void)memset(key, 0, keyLen);
       SDB_GET_BINARY(pRaw, dataPos, key, keyLen, _OVER);
 
       int32_t valuelen = 0;
@@ -1346,7 +1346,7 @@ static SSdbRow *mndUserActionDecode(SSdbRaw *pRaw) {
       if (value == NULL) {
         TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER);
       }
-      memset(value, 0, valuelen);
+      (void)memset(value, 0, valuelen);
       SDB_GET_BINARY(pRaw, dataPos, value, valuelen, _OVER)
 
       TAOS_CHECK_GOTO(taosHashPut(pUser->writeTbs, key, keyLen, value, valuelen), &lino, _OVER);
@@ -1361,7 +1361,7 @@ static SSdbRow *mndUserActionDecode(SSdbRaw *pRaw) {
         if (key == NULL) {
           TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER);
         }
-        memset(key, 0, keyLen);
+        (void)memset(key, 0, keyLen);
         SDB_GET_BINARY(pRaw, dataPos, key, keyLen, _OVER);
 
         int32_t valuelen = 0;
@@ -1370,7 +1370,7 @@ static SSdbRow *mndUserActionDecode(SSdbRaw *pRaw) {
         if (value == NULL) {
           TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER);
         }
-        memset(value, 0, valuelen);
+        (void)memset(value, 0, valuelen);
         SDB_GET_BINARY(pRaw, dataPos, value, valuelen, _OVER)
 
         TAOS_CHECK_GOTO(taosHashPut(pUser->alterTbs, key, keyLen, value, valuelen), &lino, _OVER);
@@ -1384,7 +1384,7 @@ static SSdbRow *mndUserActionDecode(SSdbRaw *pRaw) {
         if (key == NULL) {
           TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER);
         }
-        memset(key, 0, keyLen);
+        (void)memset(key, 0, keyLen);
         SDB_GET_BINARY(pRaw, dataPos, key, keyLen, _OVER);
 
         int32_t valuelen = 0;
@@ -1393,7 +1393,7 @@ static SSdbRow *mndUserActionDecode(SSdbRaw *pRaw) {
         if (value == NULL) {
           TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER);
         }
-        memset(value, 0, valuelen);
+        (void)memset(value, 0, valuelen);
         SDB_GET_BINARY(pRaw, dataPos, value, valuelen, _OVER)
 
         TAOS_CHECK_GOTO(taosHashPut(pUser->readViews, key, keyLen, value, valuelen), &lino, _OVER);
@@ -1407,7 +1407,7 @@ static SSdbRow *mndUserActionDecode(SSdbRaw *pRaw) {
         if (key == NULL) {
           TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER);
         }
-        memset(key, 0, keyLen);
+        (void)memset(key, 0, keyLen);
         SDB_GET_BINARY(pRaw, dataPos, key, keyLen, _OVER);
 
         int32_t valuelen = 0;
@@ -1416,7 +1416,7 @@ static SSdbRow *mndUserActionDecode(SSdbRaw *pRaw) {
         if (value == NULL) {
           TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER);
         }
-        memset(value, 0, valuelen);
+        (void)memset(value, 0, valuelen);
         SDB_GET_BINARY(pRaw, dataPos, value, valuelen, _OVER)
 
         TAOS_CHECK_GOTO(taosHashPut(pUser->writeViews, key, keyLen, value, valuelen), &lino, _OVER);
@@ -1430,7 +1430,7 @@ static SSdbRow *mndUserActionDecode(SSdbRaw *pRaw) {
         if (key == NULL) {
           TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER);
         }
-        memset(key, 0, keyLen);
+        (void)memset(key, 0, keyLen);
         SDB_GET_BINARY(pRaw, dataPos, key, keyLen, _OVER);
 
         int32_t valuelen = 0;
@@ -1439,7 +1439,7 @@ static SSdbRow *mndUserActionDecode(SSdbRaw *pRaw) {
         if (value == NULL) {
           TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER);
         }
-        memset(value, 0, valuelen);
+        (void)memset(value, 0, valuelen);
         SDB_GET_BINARY(pRaw, dataPos, value, valuelen, _OVER)
 
         TAOS_CHECK_GOTO(taosHashPut(pUser->alterViews, key, keyLen, value, valuelen), &lino, _OVER);
@@ -1454,7 +1454,7 @@ static SSdbRow *mndUserActionDecode(SSdbRaw *pRaw) {
       if (key == NULL) {
         TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER);
       }
-      memset(key, 0, keyLen);
+      (void)memset(key, 0, keyLen);
       SDB_GET_BINARY(pRaw, dataPos, key, keyLen, _OVER);
 
       int32_t ref = 0;
@@ -1645,7 +1645,7 @@ static int32_t mndUserActionUpdate(SSdb *pSdb, SUserObj *pOld, SUserObj *pNew) {
   pOld->sysInfo = pNew->sysInfo;
   pOld->enable = pNew->enable;
   pOld->flag = pNew->flag;
-  memcpy(pOld->pass, pNew->pass, TSDB_PASSWORD_LEN);
+  (void)memcpy(pOld->pass, pNew->pass, TSDB_PASSWORD_LEN);
   TSWAP(pOld->readDbs, pNew->readDbs);
   TSWAP(pOld->writeDbs, pNew->writeDbs);
   TSWAP(pOld->topics, pNew->topics);
@@ -1663,7 +1663,7 @@ static int32_t mndUserActionUpdate(SSdb *pSdb, SUserObj *pOld, SUserObj *pNew) {
     taosWUnLockLatch(&pOld->lock);
     return TSDB_CODE_OUT_OF_MEMORY;
   }
-  memcpy(pOld->pIpWhiteList, pNew->pIpWhiteList, sz);
+  (void)memcpy(pOld->pIpWhiteList, pNew->pIpWhiteList, sz);
   pOld->ipWhiteListVer = pNew->ipWhiteListVer;
 
   taosWUnLockLatch(&pOld->lock);
@@ -1854,13 +1854,13 @@ static int32_t mndProcessCreateUserReq(SRpcMsg *pReq) {
   if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;
 
   char detail[1000] = {0};
-  sprintf(detail, "enable:%d, superUser:%d, sysInfo:%d, password:xxx", createReq.enable, createReq.superUser,
-          createReq.sysInfo);
+  (void)sprintf(detail, "enable:%d, superUser:%d, sysInfo:%d, password:xxx", createReq.enable, createReq.superUser,
+                createReq.sysInfo);
   char operation[15] = {0};
   if (createReq.isImport == 1) {
-    strcpy(operation, "importUser");
+    (void)strcpy(operation, "importUser");
   } else {
-    strcpy(operation, "createUser");
+    (void)strcpy(operation, "createUser");
   }
 
   auditRecord(pReq, pMnode->clusterId, operation, "", createReq.user, detail, strlen(detail));
@@ -2037,7 +2037,7 @@ static int32_t mndTablePriviledge(SMnode *pMnode, SHashObj *hash, SHashObj *useD
   void *pIter = NULL;
   char  tbFName[TSDB_TABLE_FNAME_LEN] = {0};
 
-  snprintf(tbFName, sizeof(tbFName), "%s.%s", alterReq->objname, alterReq->tabName);
+  (void)snprintf(tbFName, sizeof(tbFName), "%s.%s", alterReq->objname, alterReq->tabName);
   int32_t len = strlen(tbFName) + 1;
 
   if (alterReq->tagCond != NULL && alterReq->tagCondLen != 0) {
@@ -2067,7 +2067,7 @@ static int32_t mndRemoveTablePriviledge(SMnode *pMnode, SHashObj *hash, SHashObj
                                         SSdb *pSdb) {
   void *pIter = NULL;
   char  tbFName[TSDB_TABLE_FNAME_LEN] = {0};
-  snprintf(tbFName, sizeof(tbFName), "%s.%s", alterReq->objname, alterReq->tabName);
+  (void)snprintf(tbFName, sizeof(tbFName), "%s.%s", alterReq->objname, alterReq->tabName);
   int32_t len = strlen(tbFName) + 1;
 
   if (taosHashRemove(hash, tbFName, len) != 0) {
@@ -2323,7 +2323,7 @@ static int32_t mndProcessAlterUserReq(SRpcMsg *pReq) {
   if (alterReq.alterType == TSDB_ALTER_USER_PASSWD) {
     char pass[TSDB_PASSWORD_LEN + 1] = {0};
     taosEncryptPass_c((uint8_t *)alterReq.pass, strlen(alterReq.pass), pass);
-    memcpy(newUser.pass, pass, TSDB_PASSWORD_LEN);
+    (void)memcpy(newUser.pass, pass, TSDB_PASSWORD_LEN);
     if (0 != strncmp(pUser->pass, pass, TSDB_PASSWORD_LEN)) {
       ++newUser.passVersion;
     }
@@ -2361,12 +2361,12 @@ static int32_t mndProcessAlterUserReq(SRpcMsg *pReq) {
     }
 
     bool exist = false;
-    memcpy(pNew->pIpRange, pUser->pIpWhiteList->pIpRange, sizeof(SIpV4Range) * idx);
+    (void)memcpy(pNew->pIpRange, pUser->pIpWhiteList->pIpRange, sizeof(SIpV4Range) * idx);
     for (int i = 0; i < alterReq.numIpRanges; i++) {
       SIpV4Range *range = &(alterReq.pIpRanges[i]);
       if (!isRangeInIpWhiteList(pUser->pIpWhiteList, range)) {
         // already exist, just ignore;
-        memcpy(&pNew->pIpRange[idx], range, sizeof(SIpV4Range));
+        (void)memcpy(&pNew->pIpRange[idx], range, sizeof(SIpV4Range));
         idx++;
         continue;
       } else {
@@ -2416,7 +2416,7 @@ static int32_t mndProcessAlterUserReq(SRpcMsg *pReq) {
         if (localHost) break;
 
         if (found == false) {
-          memcpy(&pNew->pIpRange[idx], oldRange, sizeof(SIpV4Range));
+          (void)memcpy(&pNew->pIpRange[idx], oldRange, sizeof(SIpV4Range));
           idx++;
         } else {
           noexist = false;
@@ -2445,9 +2445,9 @@ static int32_t mndProcessAlterUserReq(SRpcMsg *pReq) {
 
   if (alterReq.alterType == TSDB_ALTER_USER_PASSWD) {
     char detail[1000] = {0};
-    sprintf(detail, "alterType:%s, enable:%d, superUser:%d, sysInfo:%d, createdb:%d, tabName:%s, password:xxx",
-            mndUserAuditTypeStr(alterReq.alterType), alterReq.enable, alterReq.superUser, alterReq.sysInfo,
-            alterReq.createdb ? 1 : 0, alterReq.tabName);
+    (void)sprintf(detail, "alterType:%s, enable:%d, superUser:%d, sysInfo:%d, createdb:%d, tabName:%s, password:xxx",
+                  mndUserAuditTypeStr(alterReq.alterType), alterReq.enable, alterReq.superUser, alterReq.sysInfo,
+                  alterReq.createdb ? 1 : 0, alterReq.tabName);
     auditRecord(pReq, pMnode->clusterId, "alterUser", "", alterReq.user, detail, strlen(detail));
   } else if (alterReq.alterType == TSDB_ALTER_USER_SUPERUSER || alterReq.alterType == TSDB_ALTER_USER_ENABLE ||
              alterReq.alterType == TSDB_ALTER_USER_SYSINFO || alterReq.alterType == TSDB_ALTER_USER_CREATEDB) {
@@ -2460,7 +2460,7 @@ static int32_t mndProcessAlterUserReq(SRpcMsg *pReq) {
              ALTER_USER_ADD_ALL_TB_PRIV(alterReq.alterType, alterReq.privileges, alterReq.tabName)) {
     if (strcmp(alterReq.objname, "1.*") != 0) {
       SName name = {0};
-      tNameFromString(&name, alterReq.objname, T_NAME_ACCT | T_NAME_DB);
+      (void)tNameFromString(&name, alterReq.objname, T_NAME_ACCT | T_NAME_DB);
       auditRecord(pReq, pMnode->clusterId, "GrantPrivileges", name.dbname, alterReq.user, alterReq.sql,
                   alterReq.sqlLen);
     } else {
@@ -2475,7 +2475,7 @@ static int32_t mndProcessAlterUserReq(SRpcMsg *pReq) {
   } else {
     if (strcmp(alterReq.objname, "1.*") != 0) {
       SName name = {0};
-      tNameFromString(&name, alterReq.objname, T_NAME_ACCT | T_NAME_DB);
+      (void)tNameFromString(&name, alterReq.objname, T_NAME_ACCT | T_NAME_DB);
       auditRecord(pReq, pMnode->clusterId, "RevokePrivileges", name.dbname, alterReq.user, alterReq.sql,
                   alterReq.sqlLen);
     } else {
@@ -2658,7 +2658,7 @@ static int32_t mndRetrieveUsers(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBl
         TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _exit);
       }
       varDataSetLen(varstr, tlen);
-      memcpy(varDataVal(varstr), buf, tlen);
+      (void)memcpy(varDataVal(varstr), buf, tlen);
 
       pColInfo = taosArrayGet(pBlock->pDataBlock, cols);
       COL_DATA_SET_VAL_GOTO((const char *)varstr, false, pUser, _exit);
@@ -2743,7 +2743,7 @@ static int32_t mndRetrieveUsersFull(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock
         TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _exit);
       }
       varDataSetLen(varstr, tlen);
-      memcpy(varDataVal(varstr), buf, tlen);
+      (void)memcpy(varDataVal(varstr), buf, tlen);
 
       pColInfo = taosArrayGet(pBlock->pDataBlock, cols);
       COL_DATA_SET_VAL_GOTO((const char *)varstr, false, pUser, _exit);
@@ -2834,7 +2834,7 @@ static int32_t mndLoopHash(SHashObj *hash, char *priType, SSDataBlock *pBlock, i
         nodesDestroyNode(pAst);
       } else {
         sqlLen = 5;
-        sprintf(*sql, "error");
+        (void)sprintf(*sql, "error");
       }
 
       STR_WITH_MAXSIZE_TO_VARSTR((*condition), (*sql), pShow->pMeta->pSchemas[cols].bytes);
@@ -2978,8 +2978,8 @@ static int32_t mndRetrievePrivileges(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock
 
       SName name = {0};
       char  objName[TSDB_DB_NAME_LEN + VARSTR_HEADER_SIZE] = {0};
-      tNameFromString(&name, db, T_NAME_ACCT | T_NAME_DB);
-      tNameGetDbName(&name, varDataVal(objName));
+      (void)tNameFromString(&name, db, T_NAME_ACCT | T_NAME_DB);
+      (void)tNameGetDbName(&name, varDataVal(objName));
       varDataSetLen(objName, strlen(varDataVal(objName)));
       pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
       COL_DATA_SET_VAL_GOTO((const char *)objName, false, pUser, _exit);
@@ -3022,8 +3022,8 @@ static int32_t mndRetrievePrivileges(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock
 
       SName name = {0};
       char  objName[TSDB_DB_NAME_LEN + VARSTR_HEADER_SIZE] = {0};
-      tNameFromString(&name, db, T_NAME_ACCT | T_NAME_DB);
-      tNameGetDbName(&name, varDataVal(objName));
+      (void)tNameFromString(&name, db, T_NAME_ACCT | T_NAME_DB);
+      (void)tNameGetDbName(&name, varDataVal(objName));
       varDataSetLen(objName, strlen(varDataVal(objName)));
       pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
       COL_DATA_SET_VAL_GOTO((const char *)objName, false, pUser, _exit);
@@ -3143,7 +3143,7 @@ int32_t mndValidateUserAuthInfo(SMnode *pMnode, SUserAuthVersion *pUsers, int32_
     if (pUser == NULL) {
       if (TSDB_CODE_MND_USER_NOT_EXIST == code) {
         SGetUserAuthRsp rsp = {.dropped = 1};
-        memcpy(rsp.user, pUsers[i].user, TSDB_USER_LEN);
+        (void)memcpy(rsp.user, pUsers[i].user, TSDB_USER_LEN);
         (void)taosArrayPush(batchRsp.pArray, &rsp);
       }
       mError("user:%s, failed to auth user since %s", pUsers[i].user, terrstr());
diff --git a/source/dnode/vnode/src/sma/smaEnv.c b/source/dnode/vnode/src/sma/smaEnv.c
index b3e072f823..e7a8de17a0 100644
--- a/source/dnode/vnode/src/sma/smaEnv.c
+++ b/source/dnode/vnode/src/sma/smaEnv.c
@@ -103,7 +103,7 @@ void smaCleanUp() {
   }
 
   if (old == 1) {
-    taosCloseRef(smaMgmt.rsetId);
+    (void)taosCloseRef(smaMgmt.rsetId);
     taosHashCleanup(smaMgmt.refHash);
     smaMgmt.refHash = NULL;
     taosTmrCleanUp(smaMgmt.tmrHandle);
@@ -174,10 +174,10 @@ static void tRSmaInfoHashFreeNode(void *data) {
 
   if ((pRSmaInfo = *(SRSmaInfo **)data)) {
     if ((pItem = RSMA_INFO_ITEM((SRSmaInfo *)pRSmaInfo, 0)) && pItem->level) {
-      taosHashRemove(smaMgmt.refHash, &pItem, POINTER_BYTES);
+      (void)taosHashRemove(smaMgmt.refHash, &pItem, POINTER_BYTES);
     }
     if ((pItem = RSMA_INFO_ITEM((SRSmaInfo *)pRSmaInfo, 1)) && pItem->level) {
-      taosHashRemove(smaMgmt.refHash, &pItem, POINTER_BYTES);
+      (void)taosHashRemove(smaMgmt.refHash, &pItem, POINTER_BYTES);
     }
     tdFreeRSmaInfo(pRSmaInfo->pSma, pRSmaInfo);
   }
@@ -378,16 +378,16 @@ int32_t tdCheckAndInitSmaEnv(SSma *pSma, int8_t smaType) {
   }
 
   // init sma env
-  tdLockSma(pSma);
+  (void)tdLockSma(pSma);
   pEnv = (smaType == TSDB_SMA_TYPE_TIME_RANGE) ? atomic_load_ptr(&SMA_TSMA_ENV(pSma))
                                                : atomic_load_ptr(&SMA_RSMA_ENV(pSma));
   if (!pEnv) {
     if ((code = tdInitSmaEnv(pSma, smaType, &pEnv)) < 0) {
-      tdUnLockSma(pSma);
+      (void)tdUnLockSma(pSma);
       TAOS_RETURN(code);
     }
   }
-  tdUnLockSma(pSma);
+  (void)tdUnLockSma(pSma);
 
   TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
@@ -395,15 +395,15 @@ int32_t tdCheckAndInitSmaEnv(SSma *pSma, int8_t smaType) {
 void *tdRSmaExecutorFunc(void *param) {
   setThreadName("vnode-rsma");
 
-  tdRSmaProcessExecImpl((SSma *)param, RSMA_EXEC_OVERFLOW);
+  (void)tdRSmaProcessExecImpl((SSma *)param, RSMA_EXEC_OVERFLOW);
   return NULL;
 }
 
 static int32_t tdRsmaStartExecutor(const SSma *pSma) {
   int32_t      code = 0;
   TdThreadAttr thAttr = {0};
-  taosThreadAttrInit(&thAttr);
-  taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE);
+  (void)taosThreadAttrInit(&thAttr);
+  (void)taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE);
 
   SSmaEnv  *pEnv = SMA_RSMA_ENV(pSma);
   SSmaStat *pStat = SMA_ENV_STAT(pEnv);
@@ -418,7 +418,7 @@ static int32_t tdRsmaStartExecutor(const SSma *pSma) {
     smaDebug("vgId:%d, success to create pthread for rsma", SMA_VID(pSma));
   }
 
-  taosThreadAttrDestroy(&thAttr);
+  (void)taosThreadAttrDestroy(&thAttr);
   TAOS_RETURN(code);
 }
 
@@ -444,7 +444,7 @@ static int32_t tdRsmaStopExecutor(const SSma *pSma) {
     for (int32_t i = 0; i < tsNumOfVnodeRsmaThreads; ++i) {
       if (taosCheckPthreadValid(pthread[i])) {
         smaDebug("vgId:%d, start to join pthread for rsma:%" PRId64 "", SMA_VID(pSma), taosGetPthreadId(pthread[i]));
-        taosThreadJoin(pthread[i], NULL);
+        (void)taosThreadJoin(pthread[i], NULL);
       }
     }
 
diff --git a/source/dnode/vnode/src/sma/smaOpen.c b/source/dnode/vnode/src/sma/smaOpen.c
index 19f0c4a964..41d4c8994f 100644
--- a/source/dnode/vnode/src/sma/smaOpen.c
+++ b/source/dnode/vnode/src/sma/smaOpen.c
@@ -145,7 +145,7 @@ int32_t smaOpen(SVnode *pVnode, int8_t rollback, bool force) {
   pVnode->pSma = pSma;
 
   pSma->pVnode = pVnode;
-  taosThreadMutexInit(&pSma->mutex, NULL);
+  (void)taosThreadMutexInit(&pSma->mutex, NULL);
   pSma->locked = false;
 
   if (VND_IS_RSMA(pVnode)) {
@@ -173,8 +173,8 @@ _exit:
 
 int32_t smaClose(SSma *pSma) {
   if (pSma) {
-    smaPreClose(pSma);
-    taosThreadMutexDestroy(&pSma->mutex);
+    (void)smaPreClose(pSma);
+    (void)taosThreadMutexDestroy(&pSma->mutex);
     SMA_TSMA_ENV(pSma) = tdFreeSmaEnv(SMA_TSMA_ENV(pSma));
     SMA_RSMA_ENV(pSma) = tdFreeSmaEnv(SMA_RSMA_ENV(pSma));
     if SMA_RSMA_TSDB0 (pSma) tsdbClose(&SMA_RSMA_TSDB0(pSma));
diff --git a/source/dnode/vnode/src/sma/smaRollup.c b/source/dnode/vnode/src/sma/smaRollup.c
index 8c12f80f2b..d5409cf268 100644
--- a/source/dnode/vnode/src/sma/smaRollup.c
+++ b/source/dnode/vnode/src/sma/smaRollup.c
@@ -89,7 +89,7 @@ void *tdFreeRSmaInfo(SSma *pSma, SRSmaInfo *pInfo) {
       if (pItem->tmrId) {
         smaDebug("vgId:%d, stop fetch timer %p for table %" PRIi64 " level %d", SMA_VID(pSma), pItem->tmrId,
                  pInfo->suid, i + 1);
-        taosTmrStopA(&pItem->tmrId);
+        (void)taosTmrStopA(&pItem->tmrId);
       }
 
       if (pItem->pStreamState) {
@@ -246,7 +246,7 @@ static void tdRSmaTaskInit(SStreamMeta *pMeta, SRSmaInfoItem *pItem, SStreamTask
 }
 
 static void tdRSmaTaskRemove(SStreamMeta *pMeta, int64_t streamId, int32_t taskId) {
-  streamMetaUnregisterTask(pMeta, streamId, taskId);
+  (void)streamMetaUnregisterTask(pMeta, streamId, taskId);
   streamMetaWLock(pMeta);
   int32_t numOfTasks = streamMetaGetNumOfTasks(pMeta);
   if (streamMetaCommit(pMeta) < 0) {
@@ -296,7 +296,7 @@ static int32_t tdSetRSmaInfoItemParams(SSma *pSma, SRSmaParam *param, SRSmaStat
     if (!pStreamTask->exec.qmsg) {
       TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
     }
-    sprintf(pStreamTask->exec.qmsg, "%s", RSMA_EXEC_TASK_FLAG);
+    (void)sprintf(pStreamTask->exec.qmsg, "%s", RSMA_EXEC_TASK_FLAG);
     pStreamTask->chkInfo.checkpointId = streamMetaGetLatestCheckpointId(pStreamTask->pMeta);
     tdRSmaTaskInit(pStreamTask->pMeta, pItem, &pStreamTask->id);
 
@@ -347,7 +347,7 @@ static int32_t tdSetRSmaInfoItemParams(SSma *pSma, SRSmaParam *param, SRSmaStat
       TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
     }
 
-    taosTmrReset(tdRSmaFetchTrigger, RSMA_FETCH_INTERVAL, pItem, smaMgmt.tmrHandle, &pItem->tmrId);
+    (void)taosTmrReset(tdRSmaFetchTrigger, RSMA_FETCH_INTERVAL, pItem, smaMgmt.tmrHandle, &pItem->tmrId);
 
     smaInfo("vgId:%d, open rsma task:%p table:%" PRIi64 " level:%" PRIi8 ", checkpointId:%" PRIi64
             ", submitReqVer:%" PRIi64 ", fetchResultVer:%" PRIi64 ", maxdelay:%" PRIi64 " watermark:%" PRIi64
@@ -799,7 +799,7 @@ static int32_t tdExecuteRSmaImplAsync(SSma *pSma, int64_t version, const void *p
   *(int32_t *)pItem = len;
   pItem = POINTER_SHIFT(pItem, sizeof(int32_t));
   *(int64_t *)pItem = version;
-  memcpy(POINTER_SHIFT(pItem, sizeof(int64_t)), pMsg, len);
+  (void)memcpy(POINTER_SHIFT(pItem, sizeof(int64_t)), pMsg, len);
 
   TAOS_CHECK_RETURN(taosWriteQitem(pInfo->queue, qItem));
 
@@ -810,7 +810,7 @@ static int32_t tdExecuteRSmaImplAsync(SSma *pSma, int64_t version, const void *p
   int64_t nItems = atomic_fetch_add_64(&pRSmaStat->nBufItems, 1);
 
   if (atomic_load_8(&pInfo->assigned) == 0) {
-    tsem_post(&(pRSmaStat->notEmpty));
+    (void)tsem_post(&(pRSmaStat->notEmpty));
   }
 
   // smoothing consume
@@ -1339,7 +1339,7 @@ static void tdRSmaFetchTrigger(void *param, void *tmrId) {
   if (!(pStat = (SRSmaStat *)tdAcquireSmaRef(smaMgmt.rsetId, pRSmaRef->refId))) {
     smaWarn("rsma fetch task not start since rsma stat already destroyed, rsetId:%d refId:%" PRIi64 ")", smaMgmt.rsetId,
             pRSmaRef->refId);  // pRSmaRef freed in taosHashRemove
-    taosHashRemove(smaMgmt.refHash, &param, POINTER_BYTES);
+    (void)taosHashRemove(smaMgmt.refHash, &param, POINTER_BYTES);
     return;
   }
 
@@ -1348,8 +1348,8 @@ static void tdRSmaFetchTrigger(void *param, void *tmrId) {
   if ((code = tdAcquireRSmaInfoBySuid(pSma, pRSmaRef->suid, &pRSmaInfo)) != 0) {
     smaDebug("rsma fetch task not start since rsma info not exist, rsetId:%d refId:%" PRIi64 ")", smaMgmt.rsetId,
              pRSmaRef->refId);  // pRSmaRef freed in taosHashRemove
-    tdReleaseSmaRef(smaMgmt.rsetId, pRSmaRef->refId);
-    taosHashRemove(smaMgmt.refHash, &param, POINTER_BYTES);
+    (void)tdReleaseSmaRef(smaMgmt.rsetId, pRSmaRef->refId);
+    (void)taosHashRemove(smaMgmt.refHash, &param, POINTER_BYTES);
     return;
   }
 
@@ -1357,8 +1357,8 @@ static void tdRSmaFetchTrigger(void *param, void *tmrId) {
     smaDebug("rsma fetch task not start since rsma info already deleted, rsetId:%d refId:%" PRIi64 ")", smaMgmt.rsetId,
              pRSmaRef->refId);  // pRSmaRef freed in taosHashRemove
     tdReleaseRSmaInfo(pSma, pRSmaInfo);
-    tdReleaseSmaRef(smaMgmt.rsetId, pRSmaRef->refId);
-    taosHashRemove(smaMgmt.refHash, &param, POINTER_BYTES);
+    (void)tdReleaseSmaRef(smaMgmt.rsetId, pRSmaRef->refId);
+    (void)taosHashRemove(smaMgmt.refHash, &param, POINTER_BYTES);
     return;
   }
 
@@ -1376,7 +1376,7 @@ static void tdRSmaFetchTrigger(void *param, void *tmrId) {
         taosTmrReset(tdRSmaFetchTrigger, RSMA_FETCH_INTERVAL, pItem, smaMgmt.tmrHandle, &pItem->tmrId);
       }
       tdReleaseRSmaInfo(pSma, pRSmaInfo);
-      tdReleaseSmaRef(smaMgmt.rsetId, pRSmaRef->refId);
+      (void)tdReleaseSmaRef(smaMgmt.rsetId, pRSmaRef->refId);
       return;
     }
     default:
@@ -1393,7 +1393,7 @@ static void tdRSmaFetchTrigger(void *param, void *tmrId) {
       atomic_store_8(&pItem->fetchLevel, 1);
 
       if (atomic_load_8(&pRSmaInfo->assigned) == 0) {
-        tsem_post(&(pStat->notEmpty));
+        (void)tsem_post(&(pStat->notEmpty));
       }
     } break;
     case TASK_TRIGGER_STAT_INACTIVE: {
@@ -1414,7 +1414,7 @@ static void tdRSmaFetchTrigger(void *param, void *tmrId) {
 _end:
   taosTmrReset(tdRSmaFetchTrigger, pItem->maxDelay, pItem, smaMgmt.tmrHandle, &pItem->tmrId);
   tdReleaseRSmaInfo(pSma, pRSmaInfo);
-  tdReleaseSmaRef(smaMgmt.rsetId, pRSmaRef->refId);
+  (void)tdReleaseSmaRef(smaMgmt.rsetId, pRSmaRef->refId);
 }
 
 static void tdFreeRSmaSubmitItems(SArray *pItems, int32_t type) {
@@ -1507,7 +1507,7 @@ static int32_t tdRSmaBatchExec(SSma *pSma, SRSmaInfo *pInfo, STaosQall *qall, SA
 
   // the submitReq/deleteReq msg may exsit alternately in the msg queue, consume them sequentially in batch mode
   while (1) {
-    taosGetQitem(qall, (void **)&msg);
+    (void)taosGetQitem(qall, (void **)&msg);
     if (msg) {
       int8_t inputType = RSMA_EXEC_MSG_TYPE(msg);
       if (inputType == STREAM_INPUT__DATA_SUBMIT) {
@@ -1574,7 +1574,7 @@ _exit:
   tdFreeRSmaSubmitItems(pSubmitArr, nSubmit ? STREAM_INPUT__MERGED_SUBMIT : STREAM_INPUT__REF_DATA_BLOCK);
   while (1) {
     void *msg = NULL;
-    taosGetQitem(qall, (void **)&msg);
+    (void)taosGetQitem(qall, (void **)&msg);
     if (msg) {
       taosFreeQitem(msg);
     } else {
@@ -1687,7 +1687,7 @@ int32_t tdRSmaProcessExecImpl(SSma *pSma, ERsmaExecType type) {
         break;
       }
 
-      tsem_wait(&pRSmaStat->notEmpty);
+      (void)tsem_wait(&pRSmaStat->notEmpty);
 
       if ((pEnv->flag & SMA_ENV_FLG_CLOSE) && (atomic_load_64(&pRSmaStat->nBufItems) <= 0)) {
         smaDebug("vgId:%d, exec task end, flag:%" PRIi8 ", nBufItems:%" PRIi64, SMA_VID(pSma), pEnv->flag,
diff --git a/source/dnode/vnode/src/sma/smaSnapshot.c b/source/dnode/vnode/src/sma/smaSnapshot.c
index cd8a334f4a..0095acf79a 100644
--- a/source/dnode/vnode/src/sma/smaSnapshot.c
+++ b/source/dnode/vnode/src/sma/smaSnapshot.c
@@ -93,7 +93,7 @@ int32_t rsmaSnapRead(SRSmaSnapReader* pReader, uint8_t** ppData) {
 _exit:
   if (code) {
     smaError("vgId:%d, %s failed at line %d since %s", SMA_VID(pReader->pSma), __func__, lino, tstrerror(code));
-    rsmaSnapReaderClose(&pReader);
+    (void)rsmaSnapReaderClose(&pReader);
   } else {
     smaInfo("vgId:%d, vnode snapshot rsma read succeed", SMA_VID(pReader->pSma));
   }
@@ -106,7 +106,7 @@ int32_t rsmaSnapReaderClose(SRSmaSnapReader** ppReader) {
 
   for (int32_t i = 0; i < TSDB_RETENTION_L2; ++i) {
     if (pReader->pDataReader[i]) {
-      tsdbSnapReaderClose(&pReader->pDataReader[i]);
+      (void)tsdbSnapReaderClose(&pReader->pDataReader[i]);
     }
   }
 
diff --git a/source/dnode/vnode/src/sma/smaTimeRange.c b/source/dnode/vnode/src/sma/smaTimeRange.c
index da99a2c9a2..918fd9e5d3 100644
--- a/source/dnode/vnode/src/sma/smaTimeRange.c
+++ b/source/dnode/vnode/src/sma/smaTimeRange.c
@@ -204,7 +204,10 @@ int32_t smaBlockToSubmit(SVnode *pVnode, const SArray *pBlocks, const STSchema *
           continue;
         }
 
-        taosArrayPush(pReq->aSubmitTbData, &tbData);
+        if( taosArrayPush(pReq->aSubmitTbData, &tbData) == NULL) {
+          code = TSDB_CODE_OUT_OF_MEMORY;
+          continue;
+        }
 
         int32_t size = (int32_t)taosArrayGetSize(pReq->aSubmitTbData) - 1;
         TAOS_CHECK_EXIT(taosHashPut(pTableIndexMap, &groupId, sizeof(groupId), &size, sizeof(size)));
diff --git a/source/dnode/vnode/src/sma/smaUtil.c b/source/dnode/vnode/src/sma/smaUtil.c
index d94e58f954..8b908ed5bb 100644
--- a/source/dnode/vnode/src/sma/smaUtil.c
+++ b/source/dnode/vnode/src/sma/smaUtil.c
@@ -19,19 +19,19 @@
 void tdRSmaQTaskInfoGetFullPath(SVnode *pVnode, tb_uid_t suid, int8_t level, STfs *pTfs, char *outputName) {
   tdRSmaGetDirName(pVnode, pTfs, true, outputName);
   int32_t rsmaLen = strlen(outputName);
-  snprintf(outputName + rsmaLen, TSDB_FILENAME_LEN - rsmaLen, "%" PRIi8 "%s%" PRIi64, level, TD_DIRSEP, suid);
+  (void)snprintf(outputName + rsmaLen, TSDB_FILENAME_LEN - rsmaLen, "%" PRIi8 "%s%" PRIi64, level, TD_DIRSEP, suid);
 }
 
 void tdRSmaGetDirName(SVnode *pVnode, STfs *pTfs, bool endWithSep, char *outputName) {
   int32_t offset = 0;
 
   // vnode
-  vnodeGetPrimaryDir(pVnode->path, pVnode->diskPrimary, pTfs, outputName, TSDB_FILENAME_LEN);
+  (void)vnodeGetPrimaryDir(pVnode->path, pVnode->diskPrimary, pTfs, outputName, TSDB_FILENAME_LEN);
   offset = strlen(outputName);
 
   // rsma
-  snprintf(outputName + offset, TSDB_FILENAME_LEN - offset - 1, "%s%s%s", TD_DIRSEP, VNODE_RSMA_DIR,
-           (endWithSep ? TD_DIRSEP : ""));
+  (void)snprintf(outputName + offset, TSDB_FILENAME_LEN - offset - 1, "%s%s%s", TD_DIRSEP, VNODE_RSMA_DIR,
+                 (endWithSep ? TD_DIRSEP : ""));
 }
 
 // smaXXXUtil ================
diff --git a/source/libs/sync/inc/syncPipeline.h b/source/libs/sync/inc/syncPipeline.h
index ddc036b606..ea85b796d5 100644
--- a/source/libs/sync/inc/syncPipeline.h
+++ b/source/libs/sync/inc/syncPipeline.h
@@ -77,7 +77,7 @@ static FORCE_INLINE int32_t syncLogReplGetNextRetryBackoff(SSyncLogReplMgr* pMgr
   return TMIN(pMgr->retryBackoff + 1, SYNC_MAX_RETRY_BACKOFF);
 }
 
-SyncTerm syncLogReplGetPrevLogTerm(SSyncLogReplMgr* pMgr, SSyncNode* pNode, SyncIndex index);
+int32_t syncLogReplGetPrevLogTerm(SSyncLogReplMgr* pMgr, SSyncNode* pNode, SyncIndex index, SyncTerm* pSyncTerm);
 
 int32_t syncLogReplStart(SSyncLogReplMgr* pMgr, SSyncNode* pNode);
 int32_t syncLogReplAttempt(SSyncLogReplMgr* pMgr, SSyncNode* pNode);
@@ -93,10 +93,10 @@ int32_t syncLogReplContinue(SSyncLogReplMgr* pMgr, SSyncNode* pNode, SyncAppendE
 int32_t syncLogReplProcessHeartbeatReply(SSyncLogReplMgr* pMgr, SSyncNode* pNode, SyncHeartbeatReply* pMsg);
 
 // SSyncLogBuffer
-SSyncLogBuffer* syncLogBufferCreate();
-void            syncLogBufferDestroy(SSyncLogBuffer* pBuf);
-int32_t         syncLogBufferInit(SSyncLogBuffer* pBuf, SSyncNode* pNode);
-int32_t         syncLogBufferReInit(SSyncLogBuffer* pBuf, SSyncNode* pNode);
+int32_t syncLogBufferCreate(SSyncLogBuffer** ppBuf);
+void    syncLogBufferDestroy(SSyncLogBuffer* pBuf);
+int32_t syncLogBufferInit(SSyncLogBuffer* pBuf, SSyncNode* pNode);
+int32_t syncLogBufferReInit(SSyncLogBuffer* pBuf, SSyncNode* pNode);
 
 // access
 int64_t syncLogBufferGetEndIndex(SSyncLogBuffer* pBuf);
@@ -110,9 +110,10 @@ int32_t syncLogBufferCommit(SSyncLogBuffer* pBuf, SSyncNode* pNode, int64_t comm
 int32_t syncLogBufferReset(SSyncLogBuffer* pBuf, SSyncNode* pNode);
 
 // private
-SSyncRaftEntry* syncLogBufferGetOneEntry(SSyncLogBuffer* pBuf, SSyncNode* pNode, SyncIndex index, bool* pInBuf);
-int32_t         syncLogBufferValidate(SSyncLogBuffer* pBuf);
-int32_t         syncLogBufferRollback(SSyncLogBuffer* pBuf, SSyncNode* pNode, SyncIndex toIndex);
+int32_t syncLogBufferGetOneEntry(SSyncLogBuffer* pBuf, SSyncNode* pNode, SyncIndex index, bool* pInBuf,
+                                 SSyncRaftEntry** ppEntry);
+int32_t syncLogBufferValidate(SSyncLogBuffer* pBuf);
+int32_t syncLogBufferRollback(SSyncLogBuffer* pBuf, SSyncNode* pNode, SyncIndex toIndex);
 
 int32_t syncFsmExecute(SSyncNode* pNode, SSyncFSM* pFsm, ESyncState role, SyncTerm term, SSyncRaftEntry* pEntry,
                        int32_t applyCode, bool force);
diff --git a/source/libs/sync/inc/syncRaftEntry.h b/source/libs/sync/inc/syncRaftEntry.h
index b13c69e471..7f8cb78ea1 100644
--- a/source/libs/sync/inc/syncRaftEntry.h
+++ b/source/libs/sync/inc/syncRaftEntry.h
@@ -43,7 +43,7 @@ SSyncRaftEntry* syncEntryBuildFromRpcMsg(const SRpcMsg* pMsg, SyncTerm term, Syn
 SSyncRaftEntry* syncEntryBuildFromAppendEntries(const SyncAppendEntries* pMsg);
 SSyncRaftEntry* syncEntryBuildNoop(SyncTerm term, SyncIndex index, int32_t vgId);
 void            syncEntryDestroy(SSyncRaftEntry* pEntry);
-void            syncEntry2OriginalRpc(const SSyncRaftEntry* pEntry, SRpcMsg* pRpcMsg);  // step 7
+int32_t         syncEntry2OriginalRpc(const SSyncRaftEntry* pEntry, SRpcMsg* pRpcMsg);  // step 7
 
 static FORCE_INLINE bool syncLogReplBarrier(SSyncRaftEntry* pEntry) {
   return pEntry->originalRpcType == TDMT_SYNC_NOOP || pEntry->originalRpcType == TDMT_SYNC_CONFIG_CHANGE;
diff --git a/source/libs/sync/inc/syncReplication.h b/source/libs/sync/inc/syncReplication.h
index ecd2b5163e..36c4599527 100644
--- a/source/libs/sync/inc/syncReplication.h
+++ b/source/libs/sync/inc/syncReplication.h
@@ -58,7 +58,7 @@ int32_t syncNodeSendAppendEntries(SSyncNode* pNode, const SRaftId* destRaftId, S
 
 int32_t syncSnapSendMsg(SSyncSnapshotSender* pSender, int32_t seq, void* pBlock, int32_t len, int32_t typ);
 int32_t syncSnapSendRsp(SSyncSnapshotReceiver* pReceiver, SyncSnapshotSend* pMsg, void* pBlock, int32_t len,
-                        int32_t typ, int32_t code);
+                        int32_t typ, int32_t rspCode);
 
 #ifdef __cplusplus
 }
diff --git a/source/libs/sync/inc/syncRespMgr.h b/source/libs/sync/inc/syncRespMgr.h
index 1d41c0a85f..611c6575c1 100644
--- a/source/libs/sync/inc/syncRespMgr.h
+++ b/source/libs/sync/inc/syncRespMgr.h
@@ -35,14 +35,14 @@ typedef struct SSyncRespMgr {
   uint64_t      seqNum;
 } SSyncRespMgr;
 
-SSyncRespMgr *syncRespMgrCreate(void *data, int64_t ttl);
-void          syncRespMgrDestroy(SSyncRespMgr *pObj);
-uint64_t      syncRespMgrAdd(SSyncRespMgr *pObj, const SRespStub *pStub);
-int32_t       syncRespMgrDel(SSyncRespMgr *pObj, uint64_t seq);
-int32_t       syncRespMgrGet(SSyncRespMgr *pObj, uint64_t seq, SRespStub *pStub);
-int32_t       syncRespMgrGetAndDel(SSyncRespMgr *pObj, uint64_t seq, SRpcHandleInfo *pInfo);
-void          syncRespClean(SSyncRespMgr *pObj);
-void          syncRespCleanRsp(SSyncRespMgr *pObj);
+int32_t  syncRespMgrCreate(void *data, int64_t ttl, SSyncRespMgr **ppObj);
+void     syncRespMgrDestroy(SSyncRespMgr *pObj);
+uint64_t syncRespMgrAdd(SSyncRespMgr *pObj, const SRespStub *pStub);
+int32_t  syncRespMgrDel(SSyncRespMgr *pObj, uint64_t seq);
+int32_t  syncRespMgrGet(SSyncRespMgr *pObj, uint64_t seq, SRespStub *pStub);
+int32_t  syncRespMgrGetAndDel(SSyncRespMgr *pObj, uint64_t seq, SRpcHandleInfo *pInfo);
+void     syncRespClean(SSyncRespMgr *pObj);
+void     syncRespCleanRsp(SSyncRespMgr *pObj);
 
 #ifdef __cplusplus
 }
diff --git a/source/libs/sync/inc/syncSnapshot.h b/source/libs/sync/inc/syncSnapshot.h
index 66d8edfdfc..540255c200 100644
--- a/source/libs/sync/inc/syncSnapshot.h
+++ b/source/libs/sync/inc/syncSnapshot.h
@@ -74,12 +74,12 @@ typedef struct SSyncSnapshotSender {
   int32_t    replicaIndex;
 } SSyncSnapshotSender;
 
-SSyncSnapshotSender *snapshotSenderCreate(SSyncNode *pSyncNode, int32_t replicaIndex);
-void                 snapshotSenderDestroy(SSyncSnapshotSender *pSender);
-bool                 snapshotSenderIsStart(SSyncSnapshotSender *pSender);
-int32_t              snapshotSenderStart(SSyncSnapshotSender *pSender);
-void                 snapshotSenderStop(SSyncSnapshotSender *pSender, bool finish);
-int32_t              snapshotReSend(SSyncSnapshotSender *pSender);
+int32_t snapshotSenderCreate(SSyncNode *pSyncNode, int32_t replicaIndex, SSyncSnapshotSender **ppSender);
+void    snapshotSenderDestroy(SSyncSnapshotSender *pSender);
+bool    snapshotSenderIsStart(SSyncSnapshotSender *pSender);
+int32_t snapshotSenderStart(SSyncSnapshotSender *pSender);
+void    snapshotSenderStop(SSyncSnapshotSender *pSender, bool finish);
+int32_t snapshotReSend(SSyncSnapshotSender *pSender);
 
 typedef struct SSyncSnapshotReceiver {
   // update when prep snapshot
@@ -101,11 +101,11 @@ typedef struct SSyncSnapshotReceiver {
   SSyncNode *pSyncNode;
 } SSyncSnapshotReceiver;
 
-SSyncSnapshotReceiver *snapshotReceiverCreate(SSyncNode *pSyncNode, SRaftId fromId);
-void                   snapshotReceiverDestroy(SSyncSnapshotReceiver *pReceiver);
-void                   snapshotReceiverStart(SSyncSnapshotReceiver *pReceiver, SyncSnapshotSend *pBeginMsg);
-void                   snapshotReceiverStop(SSyncSnapshotReceiver *pReceiver);
-bool                   snapshotReceiverIsStart(SSyncSnapshotReceiver *pReceiver);
+int32_t snapshotReceiverCreate(SSyncNode *pSyncNode, SRaftId fromId, SSyncSnapshotReceiver **ppReceiver);
+void    snapshotReceiverDestroy(SSyncSnapshotReceiver *pReceiver);
+void    snapshotReceiverStart(SSyncSnapshotReceiver *pReceiver, SyncSnapshotSend *pBeginMsg);
+void    snapshotReceiverStop(SSyncSnapshotReceiver *pReceiver);
+bool    snapshotReceiverIsStart(SSyncSnapshotReceiver *pReceiver);
 
 // on message
 // int32_t syncNodeOnSnapshot(SSyncNode *ths, const SRpcMsg *pMsg);
diff --git a/source/libs/sync/src/syncMain.c b/source/libs/sync/src/syncMain.c
index b455e3355f..d6a1efc05f 100644
--- a/source/libs/sync/src/syncMain.c
+++ b/source/libs/sync/src/syncMain.c
@@ -949,6 +949,7 @@ int32_t syncNodeLogStoreRestoreOnNeed(SSyncNode* pNode) {
 
 // open/close --------------
 SSyncNode* syncNodeOpen(SSyncInfo* pSyncInfo, int32_t vnodeVersion) {
+  int32_t    code = 0;
   SSyncNode* pSyncNode = taosMemoryCalloc(1, sizeof(SSyncNode));
   if (pSyncNode == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
@@ -1041,7 +1042,7 @@ SSyncNode* syncNodeOpen(SSyncInfo* pSyncInfo, int32_t vnodeVersion) {
   pSyncNode->syncEqCtrlMsg = pSyncInfo->syncEqCtrlMsg;
 
   // create raft log ring buffer
-  pSyncNode->pLogBuf = syncLogBufferCreate();
+  (void)syncLogBufferCreate(&pSyncNode->pLogBuf); // TODO: check return value
   if (pSyncNode->pLogBuf == NULL) {
     sError("failed to init sync log buffer since %s. vgId:%d", terrstr(), pSyncNode->vgId);
     goto _error;
@@ -1218,7 +1219,7 @@ SSyncNode* syncNodeOpen(SSyncInfo* pSyncInfo, int32_t vnodeVersion) {
   }
 
   // tools
-  pSyncNode->pSyncRespMgr = syncRespMgrCreate(pSyncNode, SYNC_RESP_TTL_MS);
+  (void)syncRespMgrCreate(pSyncNode, SYNC_RESP_TTL_MS, &pSyncNode->pSyncRespMgr); // TODO: check return value
   if (pSyncNode->pSyncRespMgr == NULL) {
     sError("vgId:%d, failed to create SyncRespMgr", pSyncNode->vgId);
     goto _error;
@@ -1229,7 +1230,8 @@ SSyncNode* syncNodeOpen(SSyncInfo* pSyncInfo, int32_t vnodeVersion) {
 
   // snapshot senders
   for (int32_t i = 0; i < TSDB_MAX_REPLICA + TSDB_MAX_LEARNER_REPLICA; ++i) {
-    SSyncSnapshotSender* pSender = snapshotSenderCreate(pSyncNode, i);
+    SSyncSnapshotSender* pSender = NULL;
+    code = snapshotSenderCreate(pSyncNode, i, &pSender);
     if (pSender == NULL) return NULL;
 
     pSyncNode->senders[i] = pSender;
@@ -1237,7 +1239,7 @@ SSyncNode* syncNodeOpen(SSyncInfo* pSyncInfo, int32_t vnodeVersion) {
   }
 
   // snapshot receivers
-  pSyncNode->pNewNodeReceiver = snapshotReceiverCreate(pSyncNode, EMPTY_RAFT_ID);
+  code = snapshotReceiverCreate(pSyncNode, EMPTY_RAFT_ID, &pSyncNode->pNewNodeReceiver);
   if (pSyncNode->pNewNodeReceiver == NULL) return NULL;
   sRDebug(pSyncNode->pNewNodeReceiver, "snapshot receiver create while open sync node, data:%p",
           pSyncNode->pNewNodeReceiver);
@@ -1810,7 +1812,7 @@ void syncNodeDoConfigChange(SSyncNode* pSyncNode, SSyncCfg* pNewConfig, SyncInde
     // create new
     for (int32_t i = 0; i < TSDB_MAX_REPLICA + TSDB_MAX_LEARNER_REPLICA; ++i) {
       if (pSyncNode->senders[i] == NULL) {
-        pSyncNode->senders[i] = snapshotSenderCreate(pSyncNode, i);
+        snapshotSenderCreate(pSyncNode, i, &pSyncNode->senders[i]);
         if (pSyncNode->senders[i] == NULL) {
           // will be created later while send snapshot
           sSError(pSyncNode->senders[i], "snapshot sender create failed while reconfig");
@@ -2840,8 +2842,9 @@ int32_t syncNodeRebuildAndCopyIfExist(SSyncNode* ths, int32_t oldtotalReplicaNum
   }
 
   for (int32_t i = 0; i < TSDB_MAX_REPLICA + TSDB_MAX_LEARNER_REPLICA; ++i) {
-    SSyncSnapshotSender* pSender = snapshotSenderCreate(ths, i);
-    if (pSender == NULL) return -1;
+    SSyncSnapshotSender* pSender = NULL;
+    int32_t              code = snapshotSenderCreate(ths, i, &pSender);
+    if (pSender == NULL) return terrno = code;
 
     ths->senders[i] = pSender;
     sSDebug(pSender, "snapshot sender create while open sync node, data:%p", pSender);
diff --git a/source/libs/sync/src/syncPipeline.c b/source/libs/sync/src/syncPipeline.c
index 796a45d997..8b6092e839 100644
--- a/source/libs/sync/src/syncPipeline.c
+++ b/source/libs/sync/src/syncPipeline.c
@@ -19,13 +19,13 @@
 #include "syncCommit.h"
 #include "syncIndexMgr.h"
 #include "syncInt.h"
+#include "syncRaftCfg.h"
 #include "syncRaftEntry.h"
 #include "syncRaftStore.h"
 #include "syncReplication.h"
 #include "syncRespMgr.h"
 #include "syncSnapshot.h"
 #include "syncUtil.h"
-#include "syncRaftCfg.h"
 #include "syncVoteMgr.h"
 
 static bool syncIsMsgBlock(tmsg_t type) {
@@ -38,35 +38,36 @@ FORCE_INLINE static int64_t syncGetRetryMaxWaitMs() {
 }
 
 int64_t syncLogBufferGetEndIndex(SSyncLogBuffer* pBuf) {
-  taosThreadMutexLock(&pBuf->mutex);
+  (void)taosThreadMutexLock(&pBuf->mutex);
   int64_t index = pBuf->endIndex;
-  taosThreadMutexUnlock(&pBuf->mutex);
+  (void)taosThreadMutexUnlock(&pBuf->mutex);
   return index;
 }
 
 int32_t syncLogBufferAppend(SSyncLogBuffer* pBuf, SSyncNode* pNode, SSyncRaftEntry* pEntry) {
-  taosThreadMutexLock(&pBuf->mutex);
-  syncLogBufferValidate(pBuf);
+  int32_t code = 0;
+  (void)taosThreadMutexLock(&pBuf->mutex);
+  (void)syncLogBufferValidate(pBuf);
   SyncIndex index = pEntry->index;
 
   if (index - pBuf->startIndex >= pBuf->size) {
-    terrno = TSDB_CODE_SYN_BUFFER_FULL;
-    sError("vgId:%d, failed to append since %s. index:%" PRId64 "", pNode->vgId, terrstr(), index);
+    code = TSDB_CODE_SYN_BUFFER_FULL;
+    sError("vgId:%d, failed to append since %s. index:%" PRId64 "", pNode->vgId, tstrerror(code), index);
     goto _err;
   }
 
   if (pNode->restoreFinish && index - pBuf->commitIndex >= TSDB_SYNC_NEGOTIATION_WIN) {
-    terrno = TSDB_CODE_SYN_NEGOTIATION_WIN_FULL;
-    sError("vgId:%d, failed to append since %s, index:%" PRId64 ", commit-index:%" PRId64, pNode->vgId, terrstr(),
+    code = TSDB_CODE_SYN_NEGOTIATION_WIN_FULL;
+    sError("vgId:%d, failed to append since %s, index:%" PRId64 ", commit-index:%" PRId64, pNode->vgId, tstrerror(code),
            index, pBuf->commitIndex);
     goto _err;
   }
 
   SyncIndex appliedIndex = pNode->pFsm->FpAppliedIndexCb(pNode->pFsm);
   if (pNode->restoreFinish && pBuf->commitIndex - appliedIndex >= TSDB_SYNC_APPLYQ_SIZE_LIMIT) {
-    terrno = TSDB_CODE_SYN_WRITE_STALL;
+    code = TSDB_CODE_SYN_WRITE_STALL;
     sError("vgId:%d, failed to append since %s. index:%" PRId64 ", commit-index:%" PRId64 ", applied-index:%" PRId64,
-           pNode->vgId, terrstr(), index, pBuf->commitIndex, appliedIndex);
+           pNode->vgId, tstrerror(code), index, pBuf->commitIndex, appliedIndex);
     goto _err;
   }
 
@@ -85,29 +86,32 @@ int32_t syncLogBufferAppend(SSyncLogBuffer* pBuf, SSyncNode* pNode, SSyncRaftEnt
   pBuf->entries[index % pBuf->size] = tmp;
   pBuf->endIndex = index + 1;
 
-  syncLogBufferValidate(pBuf);
-  taosThreadMutexUnlock(&pBuf->mutex);
+  (void)syncLogBufferValidate(pBuf);
+  (void)taosThreadMutexUnlock(&pBuf->mutex);
   return 0;
 
 _err:
-  syncLogBufferValidate(pBuf);
-  taosThreadMutexUnlock(&pBuf->mutex);
+  (void)syncLogBufferValidate(pBuf);
+  (void)taosThreadMutexUnlock(&pBuf->mutex);
   taosMsleep(1);
-  return -1;
+  TAOS_RETURN(code);
 }
 
-SyncTerm syncLogReplGetPrevLogTerm(SSyncLogReplMgr* pMgr, SSyncNode* pNode, SyncIndex index) {
+int32_t syncLogReplGetPrevLogTerm(SSyncLogReplMgr* pMgr, SSyncNode* pNode, SyncIndex index, SyncTerm* pSyncTerm) {
   SSyncLogBuffer* pBuf = pNode->pLogBuf;
   SSyncRaftEntry* pEntry = NULL;
   SyncIndex       prevIndex = index - 1;
   SyncTerm        prevLogTerm = -1;
-  terrno = TSDB_CODE_SUCCESS;
+  int32_t         code = 0;
 
-  if (prevIndex == -1 && pNode->pLogStore->syncLogBeginIndex(pNode->pLogStore) == 0) return 0;
+  if (prevIndex == -1 && pNode->pLogStore->syncLogBeginIndex(pNode->pLogStore) == 0) {
+    *pSyncTerm = 0;
+    return 0;
+  }
 
   if (prevIndex > pBuf->matchIndex) {
-    terrno = TSDB_CODE_WAL_LOG_NOT_EXIST;
-    return -1;
+    *pSyncTerm = -1;
+    TAOS_RETURN(TSDB_CODE_WAL_LOG_NOT_EXIST);
   }
 
   ASSERT(index - 1 == prevIndex);
@@ -116,7 +120,8 @@ SyncTerm syncLogReplGetPrevLogTerm(SSyncLogReplMgr* pMgr, SSyncNode* pNode, Sync
     pEntry = pBuf->entries[(prevIndex + pBuf->size) % pBuf->size].pItem;
     ASSERTS(pEntry != NULL, "no log entry found");
     prevLogTerm = pEntry->term;
-    return prevLogTerm;
+    *pSyncTerm = prevLogTerm;
+    return 0;
   }
 
   if (pMgr && pMgr->startIndex <= prevIndex && prevIndex < pMgr->endIndex) {
@@ -124,25 +129,28 @@ SyncTerm syncLogReplGetPrevLogTerm(SSyncLogReplMgr* pMgr, SSyncNode* pNode, Sync
     ASSERTS(timeMs != 0, "no log entry found");
     prevLogTerm = pMgr->states[(prevIndex + pMgr->size) % pMgr->size].term;
     ASSERT(prevIndex == 0 || prevLogTerm != 0);
-    return prevLogTerm;
+    *pSyncTerm = prevLogTerm;
+    return 0;
   }
 
   SSnapshot snapshot = {0};
-  pNode->pFsm->FpGetSnapshotInfo(pNode->pFsm, &snapshot);
+  (void)pNode->pFsm->FpGetSnapshotInfo(pNode->pFsm, &snapshot);  // TODO: check the return code
   if (prevIndex == snapshot.lastApplyIndex) {
-    return snapshot.lastApplyTerm;
+    *pSyncTerm = snapshot.lastApplyTerm;
+    return 0;
   }
 
-  if (pNode->pLogStore->syncLogGetEntry(pNode->pLogStore, prevIndex, &pEntry) == 0) {
+  if ((code = pNode->pLogStore->syncLogGetEntry(pNode->pLogStore, prevIndex, &pEntry)) == 0) {
     prevLogTerm = pEntry->term;
     syncEntryDestroy(pEntry);
     pEntry = NULL;
-    return prevLogTerm;
+    *pSyncTerm = prevLogTerm;
+    return 0;
   }
 
-  sInfo("vgId:%d, failed to get log term since %s. index:%" PRId64, pNode->vgId, terrstr(), prevIndex);
-  terrno = TSDB_CODE_WAL_LOG_NOT_EXIST;
-  return -1;
+  *pSyncTerm = -1;
+  sInfo("vgId:%d, failed to get log term since %s. index:%" PRId64, pNode->vgId, tstrerror(code), prevIndex);
+  TAOS_RETURN(code);
 }
 
 SSyncRaftEntry* syncEntryBuildDummy(SyncTerm term, SyncIndex index, int32_t vgId) {
@@ -155,7 +163,7 @@ int32_t syncLogValidateAlignmentOfCommit(SSyncNode* pNode, SyncIndex commitIndex
     sError("vgId:%d, firstVer of WAL log greater than tsdb commit version + 1. firstVer:%" PRId64
            ", tsdb commit version:%" PRId64 "",
            pNode->vgId, firstVer, commitIndex);
-    return -1;
+    return TSDB_CODE_WAL_LOG_INCOMPLETE;
   }
 
   SyncIndex lastVer = pNode->pLogStore->syncLogLastIndex(pNode->pLogStore);
@@ -163,7 +171,7 @@ int32_t syncLogValidateAlignmentOfCommit(SSyncNode* pNode, SyncIndex commitIndex
     sError("vgId:%d, lastVer of WAL log less than tsdb commit version. lastVer:%" PRId64
            ", tsdb commit version:%" PRId64 "",
            pNode->vgId, lastVer, commitIndex);
-    return -1;
+    return TSDB_CODE_WAL_LOG_INCOMPLETE;
   }
 
   return 0;
@@ -174,15 +182,13 @@ int32_t syncLogBufferInitWithoutLock(SSyncLogBuffer* pBuf, SSyncNode* pNode) {
   ASSERTS(pNode->pFsm != NULL, "pFsm not registered");
   ASSERTS(pNode->pFsm->FpGetSnapshotInfo != NULL, "FpGetSnapshotInfo not registered");
 
+  int32_t   code = 0, lino = 0;
   SSnapshot snapshot = {0};
   pNode->pFsm->FpGetSnapshotInfo(pNode->pFsm, &snapshot);
 
   SyncIndex commitIndex = snapshot.lastApplyIndex;
   SyncTerm  commitTerm = TMAX(snapshot.lastApplyTerm, 0);
-  if (syncLogValidateAlignmentOfCommit(pNode, commitIndex)) {
-    terrno = TSDB_CODE_WAL_LOG_INCOMPLETE;
-    goto _err;
-  }
+  TAOS_CHECK_EXIT(syncLogValidateAlignmentOfCommit(pNode, commitIndex));
 
   SyncIndex lastVer = pNode->pLogStore->syncLogLastIndex(pNode->pLogStore);
   ASSERT(lastVer >= commitIndex);
@@ -206,7 +212,7 @@ int32_t syncLogBufferInitWithoutLock(SSyncLogBuffer* pBuf, SSyncNode* pNode) {
     }
 
     if (pLogStore->syncLogGetEntry(pLogStore, index, &pEntry) < 0) {
-      sWarn("vgId:%d, failed to get log entry since %s. index:%" PRId64 "", pNode->vgId, terrstr(), index);
+      sWarn("vgId:%d, failed to get log entry since %s. index:%" PRId64 "", pNode->vgId, tstrerror(code), index);
       break;
     }
 
@@ -237,8 +243,7 @@ int32_t syncLogBufferInitWithoutLock(SSyncLogBuffer* pBuf, SSyncNode* pNode) {
 
     SSyncRaftEntry* pDummy = syncEntryBuildDummy(commitTerm, commitIndex, pNode->vgId);
     if (pDummy == NULL) {
-      terrno = TSDB_CODE_OUT_OF_MEMORY;
-      goto _err;
+      TAOS_CHECK_EXIT(TSDB_CODE_OUT_OF_MEMORY);
     }
     SSyncLogBufEntry tmp = {.pItem = pDummy, .prevLogIndex = commitIndex - 1, .prevLogTerm = commitTerm};
     pBuf->entries[(commitIndex + pBuf->size) % pBuf->size] = tmp;
@@ -258,38 +263,41 @@ int32_t syncLogBufferInitWithoutLock(SSyncLogBuffer* pBuf, SSyncNode* pNode) {
         pBuf->startIndex, pBuf->commitIndex, pBuf->matchIndex, pBuf->endIndex);
 
   // validate
-  syncLogBufferValidate(pBuf);
+  (void)syncLogBufferValidate(pBuf);
   return 0;
 
-_err:
-  return -1;
+_exit:
+  if (code != 0) {
+    sError("vgId:%d, failed to initialize sync log buffer at line %d since %s.", pNode->vgId, lino, tstrerror(code));
+  }
+  TAOS_RETURN(code);
 }
 
 int32_t syncLogBufferInit(SSyncLogBuffer* pBuf, SSyncNode* pNode) {
-  taosThreadMutexLock(&pBuf->mutex);
+  (void)taosThreadMutexLock(&pBuf->mutex);
   int32_t ret = syncLogBufferInitWithoutLock(pBuf, pNode);
-  taosThreadMutexUnlock(&pBuf->mutex);
+  (void)taosThreadMutexUnlock(&pBuf->mutex);
   return ret;
 }
 
 int32_t syncLogBufferReInit(SSyncLogBuffer* pBuf, SSyncNode* pNode) {
-  taosThreadMutexLock(&pBuf->mutex);
-  syncLogBufferValidate(pBuf);
+  (void)taosThreadMutexLock(&pBuf->mutex);
+  (void)syncLogBufferValidate(pBuf);
   for (SyncIndex index = pBuf->startIndex; index < pBuf->endIndex; index++) {
     SSyncRaftEntry* pEntry = pBuf->entries[(index + pBuf->size) % pBuf->size].pItem;
     if (pEntry == NULL) continue;
     syncEntryDestroy(pEntry);
     pEntry = NULL;
-    memset(&pBuf->entries[(index + pBuf->size) % pBuf->size], 0, sizeof(pBuf->entries[0]));
+    (void)memset(&pBuf->entries[(index + pBuf->size) % pBuf->size], 0, sizeof(pBuf->entries[0]));
   }
   pBuf->startIndex = pBuf->commitIndex = pBuf->matchIndex = pBuf->endIndex = 0;
-  int32_t ret = syncLogBufferInitWithoutLock(pBuf, pNode);
-  if (ret < 0) {
-    sError("vgId:%d, failed to re-initialize sync log buffer since %s.", pNode->vgId, terrstr());
+  int32_t code = syncLogBufferInitWithoutLock(pBuf, pNode);
+  if (code < 0) {
+    sError("vgId:%d, failed to re-initialize sync log buffer since %s.", pNode->vgId, tstrerror(code));
   }
-  syncLogBufferValidate(pBuf);
-  taosThreadMutexUnlock(&pBuf->mutex);
-  return ret;
+  (void)syncLogBufferValidate(pBuf);
+  (void)taosThreadMutexUnlock(&pBuf->mutex);
+  return code;
 }
 
 FORCE_INLINE SyncTerm syncLogBufferGetLastMatchTermWithoutLock(SSyncLogBuffer* pBuf) {
@@ -300,23 +308,23 @@ FORCE_INLINE SyncTerm syncLogBufferGetLastMatchTermWithoutLock(SSyncLogBuffer* p
 }
 
 SyncTerm syncLogBufferGetLastMatchTerm(SSyncLogBuffer* pBuf) {
-  taosThreadMutexLock(&pBuf->mutex);
+  (void)taosThreadMutexLock(&pBuf->mutex);
   SyncTerm term = syncLogBufferGetLastMatchTermWithoutLock(pBuf);
-  taosThreadMutexUnlock(&pBuf->mutex);
+  (void)taosThreadMutexUnlock(&pBuf->mutex);
   return term;
 }
 
 bool syncLogBufferIsEmpty(SSyncLogBuffer* pBuf) {
-  taosThreadMutexLock(&pBuf->mutex);
+  (void)taosThreadMutexLock(&pBuf->mutex);
   bool empty = (pBuf->endIndex <= pBuf->startIndex);
-  taosThreadMutexUnlock(&pBuf->mutex);
+  (void)taosThreadMutexUnlock(&pBuf->mutex);
   return empty;
 }
 
 int32_t syncLogBufferAccept(SSyncLogBuffer* pBuf, SSyncNode* pNode, SSyncRaftEntry* pEntry, SyncTerm prevTerm) {
-  taosThreadMutexLock(&pBuf->mutex);
-  syncLogBufferValidate(pBuf);
-  int32_t         ret = -1;
+  (void)taosThreadMutexLock(&pBuf->mutex);
+  (void)syncLogBufferValidate(pBuf);
+  int32_t         code = 0;
   SyncIndex       index = pEntry->index;
   SyncIndex       prevIndex = pEntry->index - 1;
   SyncTerm        lastMatchTerm = syncLogBufferGetLastMatchTermWithoutLock(pBuf);
@@ -328,21 +336,22 @@ int32_t syncLogBufferAccept(SSyncLogBuffer* pBuf, SSyncNode* pNode, SSyncRaftEnt
            " %" PRId64 ", %" PRId64 ")",
            pNode->vgId, pEntry->index, pEntry->term, pBuf->startIndex, pBuf->commitIndex, pBuf->matchIndex,
            pBuf->endIndex);
-    SyncTerm term = syncLogReplGetPrevLogTerm(NULL, pNode, index + 1);
+    SyncTerm term = -1;
+    code = syncLogReplGetPrevLogTerm(NULL, pNode, index + 1, &term);
     ASSERT(pEntry->term >= 0);
     if (term == pEntry->term) {
-      ret = 0;
+      code = 0;
     }
     goto _out;
   }
 
-  if(pNode->raftCfg.cfg.nodeInfo[pNode->raftCfg.cfg.myIndex].nodeRole == TAOS_SYNC_ROLE_LEARNER &&
-      index > 0 && index > pBuf->totalIndex){
+  if (pNode->raftCfg.cfg.nodeInfo[pNode->raftCfg.cfg.myIndex].nodeRole == TAOS_SYNC_ROLE_LEARNER && index > 0 &&
+      index > pBuf->totalIndex) {
     pBuf->totalIndex = index;
     sTrace("vgId:%d, update learner progress. index:%" PRId64 ", term:%" PRId64 ": prevterm:%" PRId64
-          " != lastmatch:%" PRId64 ". log buffer: [%" PRId64 " %" PRId64 " %" PRId64 ", %" PRId64 ")",
-          pNode->vgId, pEntry->index, pEntry->term, prevTerm, lastMatchTerm, pBuf->startIndex, pBuf->commitIndex,
-          pBuf->matchIndex, pBuf->endIndex);
+           " != lastmatch:%" PRId64 ". log buffer: [%" PRId64 " %" PRId64 " %" PRId64 ", %" PRId64 ")",
+           pNode->vgId, pEntry->index, pEntry->term, prevTerm, lastMatchTerm, pBuf->startIndex, pBuf->commitIndex,
+           pBuf->matchIndex, pBuf->endIndex);
   }
 
   if (index - pBuf->startIndex >= pBuf->size) {
@@ -350,6 +359,7 @@ int32_t syncLogBufferAccept(SSyncLogBuffer* pBuf, SSyncNode* pNode, SSyncRaftEnt
           " %" PRId64 ", %" PRId64 ")",
           pNode->vgId, pEntry->index, pEntry->term, pBuf->startIndex, pBuf->commitIndex, pBuf->matchIndex,
           pBuf->endIndex);
+    code = TSDB_CODE_OUT_OF_RANGE;
     goto _out;
   }
 
@@ -358,11 +368,12 @@ int32_t syncLogBufferAccept(SSyncLogBuffer* pBuf, SSyncNode* pNode, SSyncRaftEnt
           " != lastmatch:%" PRId64 ". log buffer: [%" PRId64 " %" PRId64 " %" PRId64 ", %" PRId64 ")",
           pNode->vgId, pEntry->index, pEntry->term, prevTerm, lastMatchTerm, pBuf->startIndex, pBuf->commitIndex,
           pBuf->matchIndex, pBuf->endIndex);
+    code = TSDB_CODE_ACTION_IN_PROGRESS;
     goto _out;
   }
 
   // check current in buffer
-  pExist = syncLogBufferGetOneEntry(pBuf, pNode, index, &inBuf);
+  code = syncLogBufferGetOneEntry(pBuf, pNode, index, &inBuf, &pExist);
   if (pExist != NULL) {
     ASSERT(pEntry->index == pExist->index);
     if (pEntry->term != pExist->term) {
@@ -372,9 +383,10 @@ int32_t syncLogBufferAccept(SSyncLogBuffer* pBuf, SSyncNode* pNode, SSyncRaftEnt
              " %" PRId64 " %" PRId64 ", %" PRId64 ")",
              pNode->vgId, pEntry->index, pEntry->term, pBuf->startIndex, pBuf->commitIndex, pBuf->matchIndex,
              pBuf->endIndex);
-      SyncTerm existPrevTerm = syncLogReplGetPrevLogTerm(NULL, pNode, index);
+      SyncTerm existPrevTerm = -1;
+      (void)syncLogReplGetPrevLogTerm(NULL, pNode, index, &existPrevTerm);
       ASSERT(pEntry->term == pExist->term && (pEntry->index > pBuf->matchIndex || prevTerm == existPrevTerm));
-      ret = 0;
+      code = 0;
       goto _out;
     }
   }
@@ -391,7 +403,7 @@ int32_t syncLogBufferAccept(SSyncLogBuffer* pBuf, SSyncNode* pNode, SSyncRaftEnt
   pBuf->endIndex = TMAX(index + 1, pBuf->endIndex);
 
   // success
-  ret = 0;
+  code = 0;
 
 _out:
   syncEntryDestroy(pEntry);
@@ -399,9 +411,9 @@ _out:
     syncEntryDestroy(pExist);
     pExist = NULL;
   }
-  syncLogBufferValidate(pBuf);
-  taosThreadMutexUnlock(&pBuf->mutex);
-  return ret;
+  (void)syncLogBufferValidate(pBuf);
+  (void)taosThreadMutexUnlock(&pBuf->mutex);
+  TAOS_RETURN(code);
 }
 
 static inline bool syncLogStoreNeedFlush(SSyncRaftEntry* pEntry, int32_t replicaNum) {
@@ -409,20 +421,21 @@ static inline bool syncLogStoreNeedFlush(SSyncRaftEntry* pEntry, int32_t replica
 }
 
 int32_t syncLogStorePersist(SSyncLogStore* pLogStore, SSyncNode* pNode, SSyncRaftEntry* pEntry) {
+  int32_t code = 0;
   ASSERT(pEntry->index >= 0);
   SyncIndex lastVer = pLogStore->syncLogLastIndex(pLogStore);
-  if (lastVer >= pEntry->index && pLogStore->syncLogTruncate(pLogStore, pEntry->index) < 0) {
-    sError("failed to truncate log store since %s. from index:%" PRId64 "", terrstr(), pEntry->index);
-    return -1;
+  if (lastVer >= pEntry->index && (code = pLogStore->syncLogTruncate(pLogStore, pEntry->index)) < 0) {
+    sError("failed to truncate log store since %s. from index:%" PRId64 "", tstrerror(code), pEntry->index);
+    TAOS_RETURN(code);
   }
   lastVer = pLogStore->syncLogLastIndex(pLogStore);
   ASSERT(pEntry->index == lastVer + 1);
 
   bool doFsync = syncLogStoreNeedFlush(pEntry, pNode->replicaNum);
-  if (pLogStore->syncLogAppendEntry(pLogStore, pEntry, doFsync) < 0) {
-    sError("failed to append sync log entry since %s. index:%" PRId64 ", term:%" PRId64 "", terrstr(), pEntry->index,
-           pEntry->term);
-    return -1;
+  if ((code = pLogStore->syncLogAppendEntry(pLogStore, pEntry, doFsync)) < 0) {
+    sError("failed to append sync log entry since %s. index:%" PRId64 ", term:%" PRId64 "", tstrerror(code),
+           pEntry->index, pEntry->term);
+    TAOS_RETURN(code);
   }
 
   lastVer = pLogStore->syncLogLastIndex(pLogStore);
@@ -430,12 +443,13 @@ int32_t syncLogStorePersist(SSyncLogStore* pLogStore, SSyncNode* pNode, SSyncRaf
   return 0;
 }
 
-int64_t syncLogBufferProceed(SSyncLogBuffer* pBuf, SSyncNode* pNode, SyncTerm* pMatchTerm, char *str) {
-  taosThreadMutexLock(&pBuf->mutex);
-  syncLogBufferValidate(pBuf);
+int64_t syncLogBufferProceed(SSyncLogBuffer* pBuf, SSyncNode* pNode, SyncTerm* pMatchTerm, char* str) {
+  (void)taosThreadMutexLock(&pBuf->mutex);
+  (void)syncLogBufferValidate(pBuf);
 
   SSyncLogStore* pLogStore = pNode->pLogStore;
   int64_t        matchIndex = pBuf->matchIndex;
+  int32_t        code = 0;
 
   while (pBuf->matchIndex + 1 < pBuf->endIndex) {
     int64_t index = pBuf->matchIndex + 1;
@@ -478,39 +492,40 @@ int64_t syncLogBufferProceed(SSyncLogBuffer* pBuf, SSyncNode* pNode, SyncTerm* p
            pNode->vgId, pBuf->startIndex, pBuf->matchIndex, pBuf->endIndex);
 
     // persist
-    if (syncLogStorePersist(pLogStore, pNode, pEntry) < 0) {
-      sError("vgId:%d, failed to persist sync log entry from buffer since %s. index:%" PRId64, pNode->vgId, terrstr(),
-             pEntry->index);
+    if ((code = syncLogStorePersist(pLogStore, pNode, pEntry)) < 0) {
+      sError("vgId:%d, failed to persist sync log entry from buffer since %s. index:%" PRId64, pNode->vgId,
+             tstrerror(code), pEntry->index);
       taosMsleep(1);
       goto _out;
     }
 
-    if(pEntry->originalRpcType == TDMT_SYNC_CONFIG_CHANGE){
-      if(pNode->pLogBuf->commitIndex == pEntry->index -1){
-        sInfo("vgId:%d, to change config at %s. "
-              "current entry, index:%" PRId64 ", term:%" PRId64", "
-              "node, restore:%d, commitIndex:%" PRId64 ", "
-              "cond: (pre entry index:%" PRId64 "== buf commit index:%" PRId64 ")",
-              pNode->vgId, str,
-              pEntry->index, pEntry->term,
-              pNode->restoreFinish, pNode->commitIndex,
-              pEntry->index - 1, pNode->pLogBuf->commitIndex);
-        if(syncNodeChangeConfig(pNode, pEntry, str) != 0){
-          sError("vgId:%d, failed to change config from Append since %s. index:%" PRId64, pNode->vgId, terrstr(),
-             pEntry->index);
+    if (pEntry->originalRpcType == TDMT_SYNC_CONFIG_CHANGE) {
+      if (pNode->pLogBuf->commitIndex == pEntry->index - 1) {
+        sInfo(
+            "vgId:%d, to change config at %s. "
+            "current entry, index:%" PRId64 ", term:%" PRId64
+            ", "
+            "node, restore:%d, commitIndex:%" PRId64
+            ", "
+            "cond: (pre entry index:%" PRId64 "== buf commit index:%" PRId64 ")",
+            pNode->vgId, str, pEntry->index, pEntry->term, pNode->restoreFinish, pNode->commitIndex, pEntry->index - 1,
+            pNode->pLogBuf->commitIndex);
+        if ((code = syncNodeChangeConfig(pNode, pEntry, str)) != 0) {
+          sError("vgId:%d, failed to change config from Append since %s. index:%" PRId64, pNode->vgId, tstrerror(code),
+                 pEntry->index);
           goto _out;
         }
-      }
-      else{
-        sInfo("vgId:%d, delay change config from Node %s. "
-              "curent entry, index:%" PRId64 ", term:%" PRId64 ", "
-              "node, commitIndex:%" PRId64 ",  pBuf: [%" PRId64 " %" PRId64 " %" PRId64 ", %" PRId64 "), "
-              "cond:( pre entry index:%" PRId64" != buf commit index:%" PRId64 ")",
-              pNode->vgId, str,
-              pEntry->index, pEntry->term,
-              pNode->commitIndex, pNode->pLogBuf->startIndex, pNode->pLogBuf->commitIndex,
-              pNode->pLogBuf->matchIndex, pNode->pLogBuf->endIndex,
-              pEntry->index - 1, pNode->pLogBuf->commitIndex);
+      } else {
+        sInfo(
+            "vgId:%d, delay change config from Node %s. "
+            "curent entry, index:%" PRId64 ", term:%" PRId64
+            ", "
+            "node, commitIndex:%" PRId64 ",  pBuf: [%" PRId64 " %" PRId64 " %" PRId64 ", %" PRId64
+            "), "
+            "cond:( pre entry index:%" PRId64 " != buf commit index:%" PRId64 ")",
+            pNode->vgId, str, pEntry->index, pEntry->term, pNode->commitIndex, pNode->pLogBuf->startIndex,
+            pNode->pLogBuf->commitIndex, pNode->pLogBuf->matchIndex, pNode->pLogBuf->endIndex, pEntry->index - 1,
+            pNode->pLogBuf->commitIndex);
       }
     }
 
@@ -529,22 +544,22 @@ _out:
   if (pMatchTerm) {
     *pMatchTerm = pBuf->entries[(matchIndex + pBuf->size) % pBuf->size].pItem->term;
   }
-  syncLogBufferValidate(pBuf);
-  taosThreadMutexUnlock(&pBuf->mutex);
+  (void)syncLogBufferValidate(pBuf);
+  (void)taosThreadMutexUnlock(&pBuf->mutex);
   return matchIndex;
 }
 
 int32_t syncFsmExecute(SSyncNode* pNode, SSyncFSM* pFsm, ESyncState role, SyncTerm term, SSyncRaftEntry* pEntry,
-                          int32_t applyCode, bool force) {
-  //learner need to execute fsm when it catch up entry log
-  //if force is true, keep all contition check to execute fsm
-  if (pNode->replicaNum == 1 && pNode->restoreFinish && pNode->vgId != 1
-      && pNode->raftCfg.cfg.nodeInfo[pNode->raftCfg.cfg.myIndex].nodeRole != TAOS_SYNC_ROLE_LEARNER
-      && force == false) {
-    sDebug("vgId:%d, not to execute fsm, index:%" PRId64 ", term:%" PRId64 ", type:%s code:0x%x, replicaNum:%d,"
-          "role:%d, restoreFinish:%d",
-           pNode->vgId, pEntry->index, pEntry->term, TMSG_INFO(pEntry->originalRpcType), applyCode,
-           pNode->replicaNum, pNode->raftCfg.cfg.nodeInfo[pNode->raftCfg.cfg.myIndex].nodeRole, pNode->restoreFinish);
+                       int32_t applyCode, bool force) {
+  // learner need to execute fsm when it catch up entry log
+  // if force is true, keep all contition check to execute fsm
+  if (pNode->replicaNum == 1 && pNode->restoreFinish && pNode->vgId != 1 &&
+      pNode->raftCfg.cfg.nodeInfo[pNode->raftCfg.cfg.myIndex].nodeRole != TAOS_SYNC_ROLE_LEARNER && force == false) {
+    sDebug("vgId:%d, not to execute fsm, index:%" PRId64 ", term:%" PRId64
+           ", type:%s code:0x%x, replicaNum:%d,"
+           "role:%d, restoreFinish:%d",
+           pNode->vgId, pEntry->index, pEntry->term, TMSG_INFO(pEntry->originalRpcType), applyCode, pNode->replicaNum,
+           pNode->raftCfg.cfg.nodeInfo[pNode->raftCfg.cfg.myIndex].nodeRole, pNode->restoreFinish);
     return 0;
   }
 
@@ -558,11 +573,11 @@ int32_t syncFsmExecute(SSyncNode* pNode, SSyncFSM* pFsm, ESyncState role, SyncTe
           pEntry->term);
   }
 
-  int32_t code = 0;
+  int32_t code = 0, lino = 0;
   bool    retry = false;
   do {
     SRpcMsg rpcMsg = {.code = applyCode};
-    syncEntry2OriginalRpc(pEntry, &rpcMsg);
+    TAOS_CHECK_EXIT(syncEntry2OriginalRpc(pEntry, &rpcMsg));
 
     SFsmCbMeta cbMeta = {0};
     cbMeta.index = pEntry->index;
@@ -580,9 +595,15 @@ int32_t syncFsmExecute(SSyncNode* pNode, SSyncFSM* pFsm, ESyncState role, SyncTe
     retry = (code != 0) && (terrno == TSDB_CODE_OUT_OF_RPC_MEMORY_QUEUE);
     if (retry) {
       taosMsleep(10);
-      sError("vgId:%d, retry on fsm commit since %s. index:%" PRId64, pNode->vgId, terrstr(), pEntry->index);
+      sError("vgId:%d, retry on fsm commit since %s. index:%" PRId64, pNode->vgId, tstrerror(code), pEntry->index);
     }
   } while (retry);
+
+_exit:
+  if (code < 0) {
+    sError("vgId:%d, failed to execute fsm at line %d since %s. index:%" PRId64 ", term:%" PRId64 ", type:%s",
+           pNode->vgId, lino, tstrerror(code), pEntry->index, pEntry->term, TMSG_INFO(pEntry->originalRpcType));
+  }
   return code;
 }
 
@@ -596,15 +617,15 @@ int32_t syncLogBufferValidate(SSyncLogBuffer* pBuf) {
 }
 
 int32_t syncLogBufferCommit(SSyncLogBuffer* pBuf, SSyncNode* pNode, int64_t commitIndex) {
-  taosThreadMutexLock(&pBuf->mutex);
-  syncLogBufferValidate(pBuf);
+  (void)taosThreadMutexLock(&pBuf->mutex);
+  (void)syncLogBufferValidate(pBuf);
 
   SSyncLogStore*  pLogStore = pNode->pLogStore;
   SSyncFSM*       pFsm = pNode->pFsm;
   ESyncState      role = pNode->state;
   SyncTerm        currentTerm = raftStoreGetTerm(pNode);
   SyncGroupId     vgId = pNode->vgId;
-  int32_t         ret = -1;
+  int32_t         code = 0;
   int64_t         upperIndex = TMIN(commitIndex, pBuf->matchIndex);
   SSyncRaftEntry* pEntry = NULL;
   bool            inBuf = false;
@@ -614,7 +635,6 @@ int32_t syncLogBufferCommit(SSyncLogBuffer* pBuf, SSyncNode* pNode, int64_t comm
   if (commitIndex <= pBuf->commitIndex) {
     sDebug("vgId:%d, stale commit index. current:%" PRId64 ", notified:%" PRId64 "", vgId, pBuf->commitIndex,
            commitIndex);
-    ret = 0;
     goto _out;
   }
 
@@ -624,7 +644,7 @@ int32_t syncLogBufferCommit(SSyncLogBuffer* pBuf, SSyncNode* pNode, int64_t comm
   // execute in fsm
   for (int64_t index = pBuf->commitIndex + 1; index <= upperIndex; index++) {
     // get a log entry
-    pEntry = syncLogBufferGetOneEntry(pBuf, pNode, index, &inBuf);
+    code = syncLogBufferGetOneEntry(pBuf, pNode, index, &inBuf, &pEntry);
     if (pEntry == NULL) {
       goto _out;
     }
@@ -635,7 +655,7 @@ int32_t syncLogBufferCommit(SSyncLogBuffer* pBuf, SSyncNode* pNode, int64_t comm
             pEntry->term, TMSG_INFO(pEntry->originalRpcType));
     }
 
-    if (syncFsmExecute(pNode, pFsm, role, currentTerm, pEntry, 0, false) != 0) {
+    if ((code = syncFsmExecute(pNode, pFsm, role, currentTerm, pEntry, 0, false)) != 0) {
       sError("vgId:%d, failed to execute sync log entry. index:%" PRId64 ", term:%" PRId64
              ", role:%d, current term:%" PRId64,
              vgId, pEntry->index, pEntry->term, role, currentTerm);
@@ -646,39 +666,40 @@ int32_t syncLogBufferCommit(SSyncLogBuffer* pBuf, SSyncNode* pNode, int64_t comm
     sTrace("vgId:%d, committed index:%" PRId64 ", term:%" PRId64 ", role:%d, current term:%" PRId64 "", pNode->vgId,
            pEntry->index, pEntry->term, role, currentTerm);
 
-    pNextEntry = syncLogBufferGetOneEntry(pBuf, pNode, index + 1, &nextInBuf);
+    code = syncLogBufferGetOneEntry(pBuf, pNode, index + 1, &nextInBuf, &pNextEntry);
     if (pNextEntry != NULL) {
-      if(pNextEntry->originalRpcType == TDMT_SYNC_CONFIG_CHANGE){
-        sInfo("vgId:%d, to change config at Commit. "
-              "current entry, index:%" PRId64 ", term:%" PRId64", "
-              "node, role:%d, current term:%" PRId64 ", restore:%d, "
-              "cond, next entry index:%" PRId64 ", msgType:%s",
-              vgId,
-              pEntry->index, pEntry->term,
-              role, currentTerm, pNode->restoreFinish,
-              pNextEntry->index, TMSG_INFO(pNextEntry->originalRpcType));
+      if (pNextEntry->originalRpcType == TDMT_SYNC_CONFIG_CHANGE) {
+        sInfo(
+            "vgId:%d, to change config at Commit. "
+            "current entry, index:%" PRId64 ", term:%" PRId64
+            ", "
+            "node, role:%d, current term:%" PRId64
+            ", restore:%d, "
+            "cond, next entry index:%" PRId64 ", msgType:%s",
+            vgId, pEntry->index, pEntry->term, role, currentTerm, pNode->restoreFinish, pNextEntry->index,
+            TMSG_INFO(pNextEntry->originalRpcType));
 
-        if(syncNodeChangeConfig(pNode, pNextEntry, "Commit") != 0){
+        if ((code = syncNodeChangeConfig(pNode, pNextEntry, "Commit")) != 0) {
           sError("vgId:%d, failed to change config from Commit. index:%" PRId64 ", term:%" PRId64
-                ", role:%d, current term:%" PRId64,
-                vgId, pNextEntry->index, pNextEntry->term, role, currentTerm);
-            goto _out;
+                 ", role:%d, current term:%" PRId64,
+                 vgId, pNextEntry->index, pNextEntry->term, role, currentTerm);
+          goto _out;
         }
 
-        //for 2->1, need to apply config change entry in sync thread,
-        if(pNode->replicaNum == 1){
-          if (syncFsmExecute(pNode, pFsm, role, currentTerm, pNextEntry, 0, true) != 0) {
+        // for 2->1, need to apply config change entry in sync thread,
+        if (pNode->replicaNum == 1) {
+          if ((code = syncFsmExecute(pNode, pFsm, role, currentTerm, pNextEntry, 0, true)) != 0) {
             sError("vgId:%d, failed to execute sync log entry. index:%" PRId64 ", term:%" PRId64
-                ", role:%d, current term:%" PRId64,
-                vgId, pNextEntry->index, pNextEntry->term, role, currentTerm);
+                   ", role:%d, current term:%" PRId64,
+                   vgId, pNextEntry->index, pNextEntry->term, role, currentTerm);
             goto _out;
           }
 
           index++;
           pBuf->commitIndex = index;
 
-          sTrace("vgId:%d, committed index:%" PRId64 ", term:%" PRId64 ", role:%d, current term:%" PRId64 "", pNode->vgId,
-                pNextEntry->index, pNextEntry->term, role, currentTerm);
+          sTrace("vgId:%d, committed index:%" PRId64 ", term:%" PRId64 ", role:%d, current term:%" PRId64 "",
+                 pNode->vgId, pNextEntry->index, pNextEntry->term, role, currentTerm);
         }
       }
       if (!nextInBuf) {
@@ -699,11 +720,11 @@ int32_t syncLogBufferCommit(SSyncLogBuffer* pBuf, SSyncNode* pNode, int64_t comm
     SSyncRaftEntry* pEntry = pBuf->entries[(index + pBuf->size) % pBuf->size].pItem;
     ASSERT(pEntry != NULL);
     syncEntryDestroy(pEntry);
-    memset(&pBuf->entries[(index + pBuf->size) % pBuf->size], 0, sizeof(pBuf->entries[0]));
+    (void)memset(&pBuf->entries[(index + pBuf->size) % pBuf->size], 0, sizeof(pBuf->entries[0]));
     pBuf->startIndex = index + 1;
   }
 
-  ret = 0;
+  code = 0;
 _out:
   // mark as restored if needed
   if (!pNode->restoreFinish && pBuf->commitIndex >= pNode->commitIndex && pEntry != NULL &&
@@ -722,9 +743,9 @@ _out:
     syncEntryDestroy(pNextEntry);
     pNextEntry = NULL;
   }
-  syncLogBufferValidate(pBuf);
-  taosThreadMutexUnlock(&pBuf->mutex);
-  return ret;
+  (void)syncLogBufferValidate(pBuf);
+  (void)taosThreadMutexUnlock(&pBuf->mutex);
+  TAOS_RETURN(code);
 }
 
 void syncLogReplReset(SSyncLogReplMgr* pMgr) {
@@ -732,7 +753,7 @@ void syncLogReplReset(SSyncLogReplMgr* pMgr) {
 
   ASSERT(pMgr->startIndex >= 0);
   for (SyncIndex index = pMgr->startIndex; index < pMgr->endIndex; index++) {
-    memset(&pMgr->states[index % pMgr->size], 0, sizeof(pMgr->states[0]));
+    (void)memset(&pMgr->states[index % pMgr->size], 0, sizeof(pMgr->states[0]));
   }
   pMgr->startIndex = 0;
   pMgr->matchIndex = 0;
@@ -751,10 +772,10 @@ int32_t syncLogReplRetryOnNeed(SSyncLogReplMgr* pMgr, SSyncNode* pNode) {
     syncLogReplReset(pMgr);
     sWarn("vgId:%d, reset sync log repl since retry backoff exceeding limit. peer:%" PRIx64, pNode->vgId,
           pDestId->addr);
-    return -1;
+    return TSDB_CODE_OUT_OF_RANGE;
   }
 
-  int32_t  ret = -1;
+  int32_t  code = 0;
   bool     retried = false;
   int64_t  retryWaitMs = syncLogReplGetRetryBackoffTimeMs(pMgr);
   int64_t  nowMs = taosGetMonoTimestampMs();
@@ -776,15 +797,16 @@ int32_t syncLogReplRetryOnNeed(SSyncLogReplMgr* pMgr, SSyncNode* pNode) {
         syncLogReplReset(pMgr);
         sWarn("vgId:%d, reset sync log repl since stagnation. index:%" PRId64 ", peer:%" PRIx64, pNode->vgId, index,
               pDestId->addr);
+        code = TSDB_CODE_ACTION_IN_PROGRESS;
         goto _out;
       }
       continue;
     }
 
     bool barrier = false;
-    if (syncLogReplSendTo(pMgr, pNode, index, &term, pDestId, &barrier) < 0) {
+    if ((code = syncLogReplSendTo(pMgr, pNode, index, &term, pDestId, &barrier)) < 0) {
       sError("vgId:%d, failed to replicate sync log entry since %s. index:%" PRId64 ", dest:%" PRIx64 "", pNode->vgId,
-             terrstr(), index, pDestId->addr);
+             tstrerror(code), index, pDestId->addr);
       goto _out;
     }
     ASSERT(barrier == pMgr->states[pos].barrier);
@@ -800,7 +822,6 @@ int32_t syncLogReplRetryOnNeed(SSyncLogReplMgr* pMgr, SSyncNode* pNode) {
     }
   }
 
-  ret = 0;
 _out:
   if (retried) {
     pMgr->retryBackoff = syncLogReplGetNextRetryBackoff(pMgr);
@@ -811,12 +832,13 @@ _out:
           pNode->vgId, count, pDestId->addr, firstIndex, term, retryWaitMs, pMgr->startIndex, pMgr->matchIndex,
           pMgr->endIndex, pBuf->startIndex, pBuf->commitIndex, pBuf->matchIndex, pBuf->endIndex);
   }
-  return ret;
+  TAOS_RETURN(code);
 }
 
 int32_t syncLogReplRecover(SSyncLogReplMgr* pMgr, SSyncNode* pNode, SyncAppendEntriesReply* pMsg) {
   SSyncLogBuffer* pBuf = pNode->pLogBuf;
   SRaftId         destId = pMsg->srcId;
+  int32_t         code = 0;
   ASSERT(pMgr->restored == false);
 
   if (pMgr->endIndex == 0) {
@@ -832,7 +854,7 @@ int32_t syncLogReplRecover(SSyncLogReplMgr* pMgr, SSyncNode* pNode, SyncAppendEn
     }
   } else {
     if (pMsg->lastSendIndex < pMgr->startIndex || pMsg->lastSendIndex >= pMgr->endIndex) {
-      syncLogReplRetryOnNeed(pMgr, pNode);
+      (void)syncLogReplRetryOnNeed(pMgr, pNode);
       return 0;
     }
 
@@ -854,9 +876,9 @@ int32_t syncLogReplRecover(SSyncLogReplMgr* pMgr, SSyncNode* pNode, SyncAppendEn
       sInfo("vgId:%d, snapshot replication to dnode:%d. reason:%s, match index:%" PRId64 ", last sent:%" PRId64,
             pNode->vgId, DID(&destId), (pMsg->fsmState == SYNC_FSM_STATE_INCOMPLETE ? msg2 : msg1), pMsg->matchIndex,
             pMsg->lastSendIndex);
-      if (syncNodeStartSnapshot(pNode, &destId) < 0) {
+      if ((code = syncNodeStartSnapshot(pNode, &destId)) < 0) {
         sError("vgId:%d, failed to start snapshot for peer dnode:%d", pNode->vgId, DID(&destId));
-        return -1;
+        TAOS_RETURN(code);
       }
       return 0;
     }
@@ -869,10 +891,10 @@ int32_t syncLogReplRecover(SSyncLogReplMgr* pMgr, SSyncNode* pNode, SyncAppendEn
   errno = 0;
 
   if (pMsg->matchIndex < pNode->pLogBuf->matchIndex) {
-    term = syncLogReplGetPrevLogTerm(pMgr, pNode, index + 1);
+    code = syncLogReplGetPrevLogTerm(pMgr, pNode, index + 1, &term);
     if (term < 0 && (errno == ENFILE || errno == EMFILE)) {
-      sError("vgId:%d, failed to get prev log term since %s. index:%" PRId64, pNode->vgId, terrstr(), index + 1);
-      return -1;
+      sError("vgId:%d, failed to get prev log term since %s. index:%" PRId64, pNode->vgId, tstrerror(code), index + 1);
+      TAOS_RETURN(code);
     }
 
     if (pMsg->matchIndex == -1) {
@@ -888,9 +910,9 @@ int32_t syncLogReplRecover(SSyncLogReplMgr* pMgr, SSyncNode* pNode, SyncAppendEn
     if ((index + 1 < firstVer) || (term < 0) ||
         (term != pMsg->lastMatchTerm && (index + 1 == firstVer || index == firstVer))) {
       ASSERT(term >= 0 || terrno == TSDB_CODE_WAL_LOG_NOT_EXIST);
-      if (syncNodeStartSnapshot(pNode, &destId) < 0) {
+      if ((code = syncNodeStartSnapshot(pNode, &destId)) < 0) {
         sError("vgId:%d, failed to start snapshot for peer dnode:%d", pNode->vgId, DID(&destId));
-        return -1;
+        TAOS_RETURN(code);
       }
       sInfo("vgId:%d, snapshot replication to peer dnode:%d", pNode->vgId, DID(&destId));
       return 0;
@@ -913,20 +935,20 @@ int32_t syncLogReplRecover(SSyncLogReplMgr* pMgr, SSyncNode* pNode, SyncAppendEn
 
 int32_t syncLogReplProcessHeartbeatReply(SSyncLogReplMgr* pMgr, SSyncNode* pNode, SyncHeartbeatReply* pMsg) {
   SSyncLogBuffer* pBuf = pNode->pLogBuf;
-  taosThreadMutexLock(&pBuf->mutex);
+  (void)taosThreadMutexLock(&pBuf->mutex);
   if (pMsg->startTime != 0 && pMsg->startTime != pMgr->peerStartTime) {
     sInfo("vgId:%d, reset sync log repl in heartbeat. peer:%" PRIx64 ", start time:%" PRId64 ", old:%" PRId64 "",
           pNode->vgId, pMsg->srcId.addr, pMsg->startTime, pMgr->peerStartTime);
     syncLogReplReset(pMgr);
     pMgr->peerStartTime = pMsg->startTime;
   }
-  taosThreadMutexUnlock(&pBuf->mutex);
+  (void)taosThreadMutexUnlock(&pBuf->mutex);
   return 0;
 }
 
 int32_t syncLogReplProcessReply(SSyncLogReplMgr* pMgr, SSyncNode* pNode, SyncAppendEntriesReply* pMsg) {
   SSyncLogBuffer* pBuf = pNode->pLogBuf;
-  taosThreadMutexLock(&pBuf->mutex);
+  (void)taosThreadMutexLock(&pBuf->mutex);
   if (pMsg->startTime != pMgr->peerStartTime) {
     sInfo("vgId:%d, reset sync log repl in appendlog reply. peer:%" PRIx64 ", start time:%" PRId64 ", old:%" PRId64,
           pNode->vgId, pMsg->srcId.addr, pMsg->startTime, pMgr->peerStartTime);
@@ -939,7 +961,7 @@ int32_t syncLogReplProcessReply(SSyncLogReplMgr* pMgr, SSyncNode* pNode, SyncApp
   } else {
     (void)syncLogReplRecover(pMgr, pNode, pMsg);
   }
-  taosThreadMutexUnlock(&pBuf->mutex);
+  (void)taosThreadMutexUnlock(&pBuf->mutex);
   return 0;
 }
 
@@ -957,6 +979,7 @@ int32_t syncLogReplProbe(SSyncLogReplMgr* pMgr, SSyncNode* pNode, SyncIndex inde
   ASSERT(pMgr->startIndex >= 0);
   int64_t retryMaxWaitMs = syncGetRetryMaxWaitMs();
   int64_t nowMs = taosGetMonoTimestampMs();
+  int32_t code = 0;
 
   if (pMgr->endIndex > pMgr->startIndex &&
       nowMs < pMgr->states[pMgr->startIndex % pMgr->size].timeMs + retryMaxWaitMs) {
@@ -967,10 +990,10 @@ int32_t syncLogReplProbe(SSyncLogReplMgr* pMgr, SSyncNode* pNode, SyncIndex inde
   SRaftId* pDestId = &pNode->replicasId[pMgr->peerId];
   bool     barrier = false;
   SyncTerm term = -1;
-  if (syncLogReplSendTo(pMgr, pNode, index, &term, pDestId, &barrier) < 0) {
+  if ((code = syncLogReplSendTo(pMgr, pNode, index, &term, pDestId, &barrier)) < 0) {
     sError("vgId:%d, failed to replicate log entry since %s. index:%" PRId64 ", dest: 0x%016" PRIx64 "", pNode->vgId,
-           terrstr(), index, pDestId->addr);
-    return -1;
+           tstrerror(code), index, pDestId->addr);
+    TAOS_RETURN(code);
   }
 
   ASSERT(index >= 0);
@@ -995,6 +1018,7 @@ int32_t syncLogReplAttempt(SSyncLogReplMgr* pMgr, SSyncNode* pNode) {
 
   SRaftId*  pDestId = &pNode->replicasId[pMgr->peerId];
   int32_t   batchSize = TMAX(1, pMgr->size >> (4 + pMgr->retryBackoff));
+  int32_t   code = 0;
   int32_t   count = 0;
   int64_t   nowMs = taosGetMonoTimestampMs();
   int64_t   limit = pMgr->size >> 1;
@@ -1012,10 +1036,10 @@ int32_t syncLogReplAttempt(SSyncLogReplMgr* pMgr, SSyncNode* pNode) {
     SRaftId* pDestId = &pNode->replicasId[pMgr->peerId];
     bool     barrier = false;
     SyncTerm term = -1;
-    if (syncLogReplSendTo(pMgr, pNode, index, &term, pDestId, &barrier) < 0) {
+    if ((code = syncLogReplSendTo(pMgr, pNode, index, &term, pDestId, &barrier)) < 0) {
       sError("vgId:%d, failed to replicate log entry since %s. index:%" PRId64 ", dest: 0x%016" PRIx64 "", pNode->vgId,
-             terrstr(), index, pDestId->addr);
-      return -1;
+             tstrerror(code), index, pDestId->addr);
+      TAOS_RETURN(code);
     }
     pMgr->states[pos].barrier = barrier;
     pMgr->states[pos].timeMs = nowMs;
@@ -1034,7 +1058,7 @@ int32_t syncLogReplAttempt(SSyncLogReplMgr* pMgr, SSyncNode* pNode) {
     }
   }
 
-  syncLogReplRetryOnNeed(pMgr, pNode);
+  (void)syncLogReplRetryOnNeed(pMgr, pNode);
 
   SSyncLogBuffer* pBuf = pNode->pLogBuf;
   sTrace("vgId:%d, replicated %d msgs to peer:%" PRIx64 ". indexes:%" PRId64 "..., terms: ...%" PRId64
@@ -1059,7 +1083,7 @@ int32_t syncLogReplContinue(SSyncLogReplMgr* pMgr, SSyncNode* pNode, SyncAppendE
     pMgr->states[pMsg->lastSendIndex % pMgr->size].acked = true;
     pMgr->matchIndex = TMAX(pMgr->matchIndex, pMsg->matchIndex);
     for (SyncIndex index = pMgr->startIndex; index < pMgr->matchIndex; index++) {
-      memset(&pMgr->states[index % pMgr->size], 0, sizeof(pMgr->states[0]));
+      (void)memset(&pMgr->states[index % pMgr->size], 0, sizeof(pMgr->states[0]));
     }
     pMgr->startIndex = pMgr->matchIndex;
   }
@@ -1094,8 +1118,7 @@ int32_t syncNodeLogReplInit(SSyncNode* pNode) {
     ASSERT(pNode->logReplMgrs[i] == NULL);
     pNode->logReplMgrs[i] = syncLogReplCreate();
     if (pNode->logReplMgrs[i] == NULL) {
-      terrno = TSDB_CODE_OUT_OF_MEMORY;
-      return -1;
+      TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
     }
     pNode->logReplMgrs[i]->peerId = i;
   }
@@ -1109,11 +1132,11 @@ void syncNodeLogReplDestroy(SSyncNode* pNode) {
   }
 }
 
-SSyncLogBuffer* syncLogBufferCreate() {
+int32_t syncLogBufferCreate(SSyncLogBuffer** ppBuf) {
+  int32_t         code = 0;
   SSyncLogBuffer* pBuf = taosMemoryCalloc(1, sizeof(SSyncLogBuffer));
   if (pBuf == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return NULL;
+    TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, NULL, _exit);
   }
 
   pBuf->size = sizeof(pBuf->entries) / sizeof(pBuf->entries[0]);
@@ -1121,41 +1144,41 @@ SSyncLogBuffer* syncLogBufferCreate() {
   ASSERT(pBuf->size == TSDB_SYNC_LOG_BUFFER_SIZE);
 
   if (taosThreadMutexAttrInit(&pBuf->attr) < 0) {
-    sError("failed to init log buffer mutexattr due to %s", strerror(errno));
-    terrno = TAOS_SYSTEM_ERROR(errno);
-    goto _err;
+    code = TAOS_SYSTEM_ERROR(errno);
+    sError("failed to init log buffer mutexattr due to %s", tstrerror(code));
+    goto _exit;
   }
 
   if (taosThreadMutexAttrSetType(&pBuf->attr, PTHREAD_MUTEX_RECURSIVE) < 0) {
-    sError("failed to set log buffer mutexattr type due to %s", strerror(errno));
-    terrno = TAOS_SYSTEM_ERROR(errno);
-    goto _err;
+    code = TAOS_SYSTEM_ERROR(errno);
+    sError("failed to set log buffer mutexattr type due to %s", tstrerror(code));
+    goto _exit;
   }
 
   if (taosThreadMutexInit(&pBuf->mutex, &pBuf->attr) < 0) {
-    sError("failed to init log buffer mutex due to %s", strerror(errno));
-    terrno = TAOS_SYSTEM_ERROR(errno);
-    goto _err;
+    code = TAOS_SYSTEM_ERROR(errno);
+    sError("failed to init log buffer mutex due to %s", tstrerror(code));
+    goto _exit;
   }
-
-  return pBuf;
-
-_err:
-  taosMemoryFree(pBuf);
-  return NULL;
+_exit:
+  if (code != 0) {
+    taosMemoryFreeClear(pBuf);
+  }
+  *ppBuf = pBuf;
+  TAOS_RETURN(code);
 }
 
 void syncLogBufferClear(SSyncLogBuffer* pBuf) {
-  taosThreadMutexLock(&pBuf->mutex);
+  (void)taosThreadMutexLock(&pBuf->mutex);
   for (SyncIndex index = pBuf->startIndex; index < pBuf->endIndex; index++) {
     SSyncRaftEntry* pEntry = pBuf->entries[(index + pBuf->size) % pBuf->size].pItem;
     if (pEntry == NULL) continue;
     syncEntryDestroy(pEntry);
     pEntry = NULL;
-    memset(&pBuf->entries[(index + pBuf->size) % pBuf->size], 0, sizeof(pBuf->entries[0]));
+    (void)memset(&pBuf->entries[(index + pBuf->size) % pBuf->size], 0, sizeof(pBuf->entries[0]));
   }
   pBuf->startIndex = pBuf->commitIndex = pBuf->matchIndex = pBuf->endIndex = 0;
-  taosThreadMutexUnlock(&pBuf->mutex);
+  (void)taosThreadMutexUnlock(&pBuf->mutex);
 }
 
 void syncLogBufferDestroy(SSyncLogBuffer* pBuf) {
@@ -1170,14 +1193,15 @@ void syncLogBufferDestroy(SSyncLogBuffer* pBuf) {
 }
 
 int32_t syncLogBufferRollback(SSyncLogBuffer* pBuf, SSyncNode* pNode, SyncIndex toIndex) {
+  int32_t code = 0;
   ASSERT(pBuf->commitIndex < toIndex && toIndex <= pBuf->endIndex);
 
   if (toIndex == pBuf->endIndex) {
     return 0;
   }
 
-  sInfo("vgId:%d, rollback sync log buffer. toindex:%" PRId64 ", buffer: [%" PRId64 " %" PRId64 " %" PRId64
-        ", %" PRId64 ")",
+  sInfo("vgId:%d, rollback sync log buffer. toindex:%" PRId64 ", buffer: [%" PRId64 " %" PRId64 " %" PRId64 ", %" PRId64
+        ")",
         pNode->vgId, toIndex, pBuf->startIndex, pBuf->commitIndex, pBuf->matchIndex, pBuf->endIndex);
 
   // trunc buffer
@@ -1187,7 +1211,7 @@ int32_t syncLogBufferRollback(SSyncLogBuffer* pBuf, SSyncNode* pNode, SyncIndex
     if (pEntry != NULL) {
       (void)syncEntryDestroy(pEntry);
       pEntry = NULL;
-      memset(&pBuf->entries[index % pBuf->size], 0, sizeof(pBuf->entries[0]));
+      (void)memset(&pBuf->entries[index % pBuf->size], 0, sizeof(pBuf->entries[0]));
     }
     index--;
   }
@@ -1197,30 +1221,30 @@ int32_t syncLogBufferRollback(SSyncLogBuffer* pBuf, SSyncNode* pNode, SyncIndex
 
   // trunc wal
   SyncIndex lastVer = pNode->pLogStore->syncLogLastIndex(pNode->pLogStore);
-  if (lastVer >= toIndex && pNode->pLogStore->syncLogTruncate(pNode->pLogStore, toIndex) < 0) {
-    sError("vgId:%d, failed to truncate log store since %s. from index:%" PRId64 "", pNode->vgId, terrstr(), toIndex);
-    return -1;
+  if (lastVer >= toIndex && (code = pNode->pLogStore->syncLogTruncate(pNode->pLogStore, toIndex)) < 0) {
+    sError("vgId:%d, failed to truncate log store since %s. from index:%" PRId64 "", pNode->vgId, tstrerror(code),
+           toIndex);
+    TAOS_RETURN(code);
   }
   lastVer = pNode->pLogStore->syncLogLastIndex(pNode->pLogStore);
   ASSERT(toIndex == lastVer + 1);
 
   // refill buffer on need
   if (toIndex <= pBuf->startIndex) {
-    int32_t ret = syncLogBufferInitWithoutLock(pBuf, pNode);
-    if (ret < 0) {
-      sError("vgId:%d, failed to refill sync log buffer since %s", pNode->vgId, terrstr());
-      return -1;
+    if ((code = syncLogBufferInitWithoutLock(pBuf, pNode)) < 0) {
+      sError("vgId:%d, failed to refill sync log buffer since %s", pNode->vgId, tstrerror(code));
+      TAOS_RETURN(code);
     }
   }
 
   ASSERT(pBuf->endIndex == toIndex);
-  syncLogBufferValidate(pBuf);
+  (void)syncLogBufferValidate(pBuf);
   return 0;
 }
 
 int32_t syncLogBufferReset(SSyncLogBuffer* pBuf, SSyncNode* pNode) {
-  taosThreadMutexLock(&pBuf->mutex);
-  syncLogBufferValidate(pBuf);
+  (void)taosThreadMutexLock(&pBuf->mutex);
+  (void)syncLogBufferValidate(pBuf);
   SyncIndex lastVer = pNode->pLogStore->syncLogLastIndex(pNode->pLogStore);
   ASSERT(lastVer == pBuf->matchIndex);
   SyncIndex index = pBuf->endIndex - 1;
@@ -1237,26 +1261,32 @@ int32_t syncLogBufferReset(SSyncLogBuffer* pBuf, SSyncNode* pNode) {
     SSyncLogReplMgr* pMgr = pNode->logReplMgrs[i];
     syncLogReplReset(pMgr);
   }
-  syncLogBufferValidate(pBuf);
-  taosThreadMutexUnlock(&pBuf->mutex);
+  (void)syncLogBufferValidate(pBuf);
+  (void)taosThreadMutexUnlock(&pBuf->mutex);
   return 0;
 }
 
-SSyncRaftEntry* syncLogBufferGetOneEntry(SSyncLogBuffer* pBuf, SSyncNode* pNode, SyncIndex index, bool* pInBuf) {
-  SSyncRaftEntry* pEntry = NULL;
+int32_t syncLogBufferGetOneEntry(SSyncLogBuffer* pBuf, SSyncNode* pNode, SyncIndex index, bool* pInBuf,
+                                 SSyncRaftEntry** ppEntry) {
+  int32_t code = 0;
+
+  *ppEntry = NULL;
+
   if (index >= pBuf->endIndex) {
-    return NULL;
+    return TSDB_CODE_OUT_OF_RANGE;
   }
+
   if (index > pBuf->startIndex) {  // startIndex might be dummy
     *pInBuf = true;
-    pEntry = pBuf->entries[index % pBuf->size].pItem;
+    *ppEntry = pBuf->entries[index % pBuf->size].pItem;
   } else {
     *pInBuf = false;
-    if (pNode->pLogStore->syncLogGetEntry(pNode->pLogStore, index, &pEntry) < 0) {
-      sWarn("vgId:%d, failed to get log entry since %s. index:%" PRId64 "", pNode->vgId, terrstr(), index);
+
+    if ((code = pNode->pLogStore->syncLogGetEntry(pNode->pLogStore, index, ppEntry)) < 0) {
+      sWarn("vgId:%d, failed to get log entry since %s. index:%" PRId64 "", pNode->vgId, tstrerror(code), index);
     }
   }
-  return pEntry;
+  TAOS_RETURN(code);
 }
 
 int32_t syncLogReplSendTo(SSyncLogReplMgr* pMgr, SSyncNode* pNode, SyncIndex index, SyncTerm* pTerm, SRaftId* pDestId,
@@ -1266,15 +1296,16 @@ int32_t syncLogReplSendTo(SSyncLogReplMgr* pMgr, SSyncNode* pNode, SyncIndex ind
   bool            inBuf = false;
   SyncTerm        prevLogTerm = -1;
   SSyncLogBuffer* pBuf = pNode->pLogBuf;
+  int32_t         code = 0;
 
-  pEntry = syncLogBufferGetOneEntry(pBuf, pNode, index, &inBuf);
+  code = syncLogBufferGetOneEntry(pBuf, pNode, index, &inBuf, &pEntry);
   if (pEntry == NULL) {
     sWarn("vgId:%d, failed to get raft entry for index:%" PRId64 "", pNode->vgId, index);
-    if (terrno == TSDB_CODE_WAL_LOG_NOT_EXIST) {
+    if (code == TSDB_CODE_WAL_LOG_NOT_EXIST) {
       SSyncLogReplMgr* pMgr = syncNodeGetLogReplMgr(pNode, pDestId);
       if (pMgr) {
         sInfo("vgId:%d, reset sync log repl of peer:%" PRIx64 " since %s. index:%" PRId64, pNode->vgId, pDestId->addr,
-              terrstr(), index);
+              tstrerror(code), index);
         (void)syncLogReplReset(pMgr);
       }
     }
@@ -1282,14 +1313,14 @@ int32_t syncLogReplSendTo(SSyncLogReplMgr* pMgr, SSyncNode* pNode, SyncIndex ind
   }
   *pBarrier = syncLogReplBarrier(pEntry);
 
-  prevLogTerm = syncLogReplGetPrevLogTerm(pMgr, pNode, index);
+  code = syncLogReplGetPrevLogTerm(pMgr, pNode, index, &prevLogTerm);
   if (prevLogTerm < 0) {
-    sError("vgId:%d, failed to get prev log term since %s. index:%" PRId64 "", pNode->vgId, terrstr(), index);
+    sError("vgId:%d, failed to get prev log term since %s. index:%" PRId64 "", pNode->vgId, tstrerror(code), index);
     goto _err;
   }
   if (pTerm) *pTerm = pEntry->term;
 
-  int32_t code = syncBuildAppendEntriesFromRaftEntry(pNode, pEntry, prevLogTerm, &msgOut);
+  code = syncBuildAppendEntriesFromRaftEntry(pNode, pEntry, prevLogTerm, &msgOut);
   if (code < 0) {
     sError("vgId:%d, failed to get append entries for index:%" PRId64 "", pNode->vgId, index);
     goto _err;
@@ -1313,5 +1344,5 @@ _err:
     syncEntryDestroy(pEntry);
     pEntry = NULL;
   }
-  return -1;
+  TAOS_RETURN(code);
 }
diff --git a/source/libs/sync/src/syncRaftCfg.c b/source/libs/sync/src/syncRaftCfg.c
index 0e98fe94eb..b0e6abffc6 100644
--- a/source/libs/sync/src/syncRaftCfg.c
+++ b/source/libs/sync/src/syncRaftCfg.c
@@ -18,7 +18,7 @@
 #include "syncUtil.h"
 #include "tjson.h"
 
-const char* syncRoleToStr(ESyncRole role) {
+const char *syncRoleToStr(ESyncRole role) {
   switch (role) {
     case TAOS_SYNC_ROLE_VOTER:
       return "true";
@@ -29,11 +29,11 @@ const char* syncRoleToStr(ESyncRole role) {
   }
 }
 
-const ESyncRole syncStrToRole(char* str) {
-  if(strcmp(str, "true") == 0){
+const ESyncRole syncStrToRole(char *str) {
+  if (strcmp(str, "true") == 0) {
     return TAOS_SYNC_ROLE_VOTER;
   }
-  if(strcmp(str, "false") == 0){
+  if (strcmp(str, "false") == 0) {
     return TAOS_SYNC_ROLE_LEARNER;
   }
 
@@ -42,92 +42,130 @@ const ESyncRole syncStrToRole(char* str) {
 
 static int32_t syncEncodeSyncCfg(const void *pObj, SJson *pJson) {
   SSyncCfg *pCfg = (SSyncCfg *)pObj;
-  if (tjsonAddDoubleToObject(pJson, "replicaNum", pCfg->replicaNum) < 0) return -1;
-  if (tjsonAddDoubleToObject(pJson, "myIndex", pCfg->myIndex) < 0) return -1;
-  if (tjsonAddDoubleToObject(pJson, "changeVersion", pCfg->changeVersion) < 0) return -1;
+  int32_t   code = 0, lino = 0;
+
+  TAOS_CHECK_EXIT(tjsonAddDoubleToObject(pJson, "replicaNum", pCfg->replicaNum));
+  TAOS_CHECK_EXIT(tjsonAddDoubleToObject(pJson, "myIndex", pCfg->myIndex));
+  TAOS_CHECK_EXIT(tjsonAddDoubleToObject(pJson, "changeVersion", pCfg->changeVersion));
 
   SJson *nodeInfo = tjsonCreateArray();
-  if (nodeInfo == NULL) return -1;
-  if (tjsonAddItemToObject(pJson, "nodeInfo", nodeInfo) < 0) return -1;
+  if (nodeInfo == NULL) {
+    TAOS_CHECK_EXIT(TSDB_CODE_OUT_OF_MEMORY);
+  }
+  if ((code = tjsonAddItemToObject(pJson, "nodeInfo", nodeInfo)) < 0) {
+    tjsonDelete(nodeInfo);
+    TAOS_CHECK_EXIT(code);
+  }
   for (int32_t i = 0; i < pCfg->totalReplicaNum; ++i) {
     SJson *info = tjsonCreateObject();
-    if (info == NULL) return -1;
-    if (tjsonAddDoubleToObject(info, "nodePort", pCfg->nodeInfo[i].nodePort) < 0) return -1;
-    if (tjsonAddStringToObject(info, "nodeFqdn", pCfg->nodeInfo[i].nodeFqdn) < 0) return -1;
-    if (tjsonAddIntegerToObject(info, "nodeId", pCfg->nodeInfo[i].nodeId) < 0) return -1;
-    if (tjsonAddIntegerToObject(info, "clusterId", pCfg->nodeInfo[i].clusterId) < 0) return -1;
-    if (tjsonAddStringToObject(info, "isReplica", syncRoleToStr(pCfg->nodeInfo[i].nodeRole)) < 0) return -1;
-    if (tjsonAddItemToArray(nodeInfo, info) < 0) return -1;
+    if (info == NULL) {
+      TAOS_CHECK_EXIT(TSDB_CODE_OUT_OF_MEMORY);
+    }
+    TAOS_CHECK_GOTO(tjsonAddDoubleToObject(info, "nodePort", pCfg->nodeInfo[i].nodePort), NULL, _err);
+    TAOS_CHECK_GOTO(tjsonAddStringToObject(info, "nodeFqdn", pCfg->nodeInfo[i].nodeFqdn), NULL, _err);
+    TAOS_CHECK_GOTO(tjsonAddIntegerToObject(info, "nodeId", pCfg->nodeInfo[i].nodeId), NULL, _err);
+    TAOS_CHECK_GOTO(tjsonAddIntegerToObject(info, "clusterId", pCfg->nodeInfo[i].clusterId), NULL, _err);
+    TAOS_CHECK_GOTO(tjsonAddStringToObject(info, "isReplica", syncRoleToStr(pCfg->nodeInfo[i].nodeRole)), NULL, _err);
+    TAOS_CHECK_GOTO(tjsonAddItemToArray(nodeInfo, info), NULL, _err);
+    continue;
+  _err:
+    tjsonDelete(info);
+    break;
   }
-
-  return 0;
+_exit:
+  if (code < 0) {
+    sError("failed to encode sync cfg at line %d since %s", lino, tstrerror(code));
+  }
+  TAOS_RETURN(code);
 }
 
 static int32_t syncEncodeRaftCfg(const void *pObj, SJson *pJson) {
   SRaftCfg *pCfg = (SRaftCfg *)pObj;
-  if (tjsonAddObject(pJson, "SSyncCfg", syncEncodeSyncCfg, (void *)&pCfg->cfg) < 0) return -1;
-  if (tjsonAddDoubleToObject(pJson, "isStandBy", pCfg->isStandBy) < 0) return -1;
-  if (tjsonAddDoubleToObject(pJson, "snapshotStrategy", pCfg->snapshotStrategy) < 0) return -1;
-  if (tjsonAddDoubleToObject(pJson, "batchSize", pCfg->batchSize) < 0) return -1;
-  if (tjsonAddIntegerToObject(pJson, "lastConfigIndex", pCfg->lastConfigIndex) < 0) return -1;
-  if (tjsonAddDoubleToObject(pJson, "configIndexCount", pCfg->configIndexCount) < 0) return -1;
+  int32_t   code = 0, lino = 0;
+  TAOS_CHECK_EXIT(tjsonAddObject(pJson, "SSyncCfg", syncEncodeSyncCfg, (void *)&pCfg->cfg));
+  TAOS_CHECK_EXIT(tjsonAddDoubleToObject(pJson, "isStandBy", pCfg->isStandBy));
+  TAOS_CHECK_EXIT(tjsonAddDoubleToObject(pJson, "snapshotStrategy", pCfg->snapshotStrategy));
+  TAOS_CHECK_EXIT(tjsonAddDoubleToObject(pJson, "batchSize", pCfg->batchSize));
+  TAOS_CHECK_EXIT(tjsonAddIntegerToObject(pJson, "lastConfigIndex", pCfg->lastConfigIndex));
+  TAOS_CHECK_EXIT(tjsonAddDoubleToObject(pJson, "configIndexCount", pCfg->configIndexCount));
 
   SJson *configIndexArr = tjsonCreateArray();
-  if (configIndexArr == NULL) return -1;
-  if (tjsonAddItemToObject(pJson, "configIndexArr", configIndexArr) < 0) return -1;
+  if (configIndexArr == NULL) {
+    TAOS_CHECK_EXIT(TSDB_CODE_OUT_OF_MEMORY);
+  }
+  if ((code = tjsonAddItemToObject(pJson, "configIndexArr", configIndexArr)) < 0) {
+    tjsonDelete(configIndexArr);
+    TAOS_CHECK_EXIT(code);
+  }
   for (int32_t i = 0; i < pCfg->configIndexCount; ++i) {
     SJson *configIndex = tjsonCreateObject();
-    if (configIndex == NULL) return -1;
-    if (tjsonAddIntegerToObject(configIndex, "index", pCfg->configIndexArr[i]) < 0) return -1;
-    if (tjsonAddItemToArray(configIndexArr, configIndex) < 0) return -1;
+    if (configIndex == NULL) {
+      TAOS_CHECK_EXIT(TSDB_CODE_OUT_OF_MEMORY);
+    }
+    TAOS_CHECK_EXIT(tjsonAddIntegerToObject(configIndex, "index", pCfg->configIndexArr[i]));
+    TAOS_CHECK_EXIT(tjsonAddItemToArray(configIndexArr, configIndex));
+    continue;
+  _err:
+    tjsonDelete(configIndex);
+    break;
   }
-
-  return 0;
+_exit:
+  if (code < 0) {
+    sError("failed to encode raft cfg at line %d since %s", lino, tstrerror(code));
+  }
+  TAOS_RETURN(code);
 }
 
 int32_t syncWriteCfgFile(SSyncNode *pNode) {
-  int32_t     code = -1;
+  int32_t     code = 0, lino = 0;
   char       *buffer = NULL;
   SJson      *pJson = NULL;
   TdFilePtr   pFile = NULL;
   const char *realfile = pNode->configPath;
   SRaftCfg   *pCfg = &pNode->raftCfg;
   char        file[PATH_MAX] = {0};
-  snprintf(file, sizeof(file), "%s.bak", realfile);
+  (void)snprintf(file, sizeof(file), "%s.bak", realfile);
 
-  terrno = TSDB_CODE_OUT_OF_MEMORY;
-  pJson = tjsonCreateObject();
-  if (pJson == NULL) goto _OVER;
-  if (tjsonAddObject(pJson, "RaftCfg", syncEncodeRaftCfg, pCfg) < 0) goto _OVER;
+  if ((pJson = tjsonCreateObject()) == NULL) {
+    TAOS_CHECK_EXIT(TSDB_CODE_OUT_OF_MEMORY);
+  }
+  TAOS_CHECK_EXIT(tjsonAddObject(pJson, "RaftCfg", syncEncodeRaftCfg, pCfg));
   buffer = tjsonToString(pJson);
-  if (buffer == NULL) goto _OVER;
-  terrno = 0;
+  if (buffer == NULL) {
+    TAOS_CHECK_EXIT(TSDB_CODE_OUT_OF_MEMORY);
+  }
 
   pFile = taosOpenFile(file, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_TRUNC | TD_FILE_WRITE_THROUGH);
-  if (pFile == NULL) goto _OVER;
+  if (pFile == NULL) {
+    code = terrno ? terrno : TAOS_SYSTEM_ERROR(errno);
+    TAOS_CHECK_EXIT(code);
+  }
 
   int32_t len = strlen(buffer);
-  if (taosWriteFile(pFile, buffer, len) <= 0) goto _OVER;
-  if (taosFsyncFile(pFile) < 0) goto _OVER;
+  if (taosWriteFile(pFile, buffer, len) <= 0) {
+    TAOS_CHECK_EXIT(TAOS_SYSTEM_ERROR(errno));
+  }
+  if (taosFsyncFile(pFile) < 0) {
+    TAOS_CHECK_EXIT(TAOS_SYSTEM_ERROR(errno));
+  }
 
-  taosCloseFile(&pFile);
-  if (taosRenameFile(file, realfile) != 0) goto _OVER;
+  (void)taosCloseFile(&pFile);
+  if (taosRenameFile(file, realfile) != 0) {
+    TAOS_CHECK_EXIT(TAOS_SYSTEM_ERROR(errno));
+  }
 
-  code = 0;
-  sInfo("vgId:%d, succeed to write sync cfg file:%s, len:%d, lastConfigIndex:%" PRId64 ", "
-        "changeVersion:%d", pNode->vgId, 
-        realfile, len, pNode->raftCfg.lastConfigIndex, pNode->raftCfg.cfg.changeVersion);
+  sInfo("vgId:%d, succeed to write sync cfg file:%s, len:%d, lastConfigIndex:%" PRId64 ", changeVersion:%d",
+        pNode->vgId, realfile, len, pNode->raftCfg.lastConfigIndex, pNode->raftCfg.cfg.changeVersion);
 
-_OVER:
+_exit:
   if (pJson != NULL) tjsonDelete(pJson);
   if (buffer != NULL) taosMemoryFree(buffer);
   if (pFile != NULL) taosCloseFile(&pFile);
 
   if (code != 0) {
-    if (terrno == 0) terrno = TAOS_SYSTEM_ERROR(errno);
-    sError("vgId:%d, failed to write sync cfg file:%s since %s", pNode->vgId, realfile, terrstr());
+    sError("vgId:%d, failed to write sync cfg file:%s since %s", pNode->vgId, realfile, tstrerror(code));
   }
-  return code;
+  TAOS_RETURN(code);
 }
 
 static int32_t syncDecodeSyncCfg(const SJson *pJson, void *pObj) {
@@ -135,32 +173,31 @@ static int32_t syncDecodeSyncCfg(const SJson *pJson, void *pObj) {
   int32_t   code = 0;
 
   tjsonGetInt32ValueFromDouble(pJson, "replicaNum", pCfg->replicaNum, code);
-  if (code < 0) return -1;
+  if (code < 0) return TSDB_CODE_INVALID_JSON_FORMAT;
   tjsonGetInt32ValueFromDouble(pJson, "myIndex", pCfg->myIndex, code);
-  if (code < 0) return -1;
+  if (code < 0) return TSDB_CODE_INVALID_JSON_FORMAT;
   tjsonGetInt32ValueFromDouble(pJson, "changeVersion", pCfg->changeVersion, code);
-  if (code < 0) return -1;
+  if (code < 0) return TSDB_CODE_INVALID_JSON_FORMAT;
 
   SJson *nodeInfo = tjsonGetObjectItem(pJson, "nodeInfo");
-  if (nodeInfo == NULL) return -1;
+  if (nodeInfo == NULL) return TSDB_CODE_INVALID_JSON_FORMAT;
   pCfg->totalReplicaNum = tjsonGetArraySize(nodeInfo);
 
   for (int32_t i = 0; i < pCfg->totalReplicaNum; ++i) {
     SJson *info = tjsonGetArrayItem(nodeInfo, i);
-    if (info == NULL) return -1;
+    if (info == NULL) return TSDB_CODE_INVALID_JSON_FORMAT;
     tjsonGetUInt16ValueFromDouble(info, "nodePort", pCfg->nodeInfo[i].nodePort, code);
-    if (code < 0) return -1;
+    if (code < 0) return TSDB_CODE_INVALID_JSON_FORMAT;
     code = tjsonGetStringValue(info, "nodeFqdn", pCfg->nodeInfo[i].nodeFqdn);
-    if (code < 0) return -1;
+    if (code < 0) return TSDB_CODE_INVALID_JSON_FORMAT;
     tjsonGetNumberValue(info, "nodeId", pCfg->nodeInfo[i].nodeId, code);
     tjsonGetNumberValue(info, "clusterId", pCfg->nodeInfo[i].clusterId, code);
     char role[10] = {0};
     code = tjsonGetStringValue(info, "isReplica", role);
-    if(code < 0) return -1;
-    if(strlen(role) != 0){
+    if (code < 0) return TSDB_CODE_INVALID_JSON_FORMAT;
+    if (strlen(role) != 0) {
       pCfg->nodeInfo[i].nodeRole = syncStrToRole(role);
-    }
-    else{
+    } else {
       pCfg->nodeInfo[i].nodeRole = TAOS_SYNC_ROLE_VOTER;
     }
   }
@@ -172,34 +209,34 @@ static int32_t syncDecodeRaftCfg(const SJson *pJson, void *pObj) {
   SRaftCfg *pCfg = (SRaftCfg *)pObj;
   int32_t   code = 0;
 
-  if (tjsonToObject(pJson, "SSyncCfg", syncDecodeSyncCfg, (void *)&pCfg->cfg) < 0) return -1;
+  TAOS_CHECK_RETURN(tjsonToObject(pJson, "SSyncCfg", syncDecodeSyncCfg, (void *)&pCfg->cfg));
 
   tjsonGetInt8ValueFromDouble(pJson, "isStandBy", pCfg->isStandBy, code);
-  if (code < 0) return -1;
+  if (code < 0) return TSDB_CODE_INVALID_JSON_FORMAT;
   tjsonGetInt8ValueFromDouble(pJson, "snapshotStrategy", pCfg->snapshotStrategy, code);
-  if (code < 0) return -1;
+  if (code < 0) return TSDB_CODE_INVALID_JSON_FORMAT;
   tjsonGetInt32ValueFromDouble(pJson, "batchSize", pCfg->batchSize, code);
-  if (code < 0) return -1;
+  if (code < 0) return TSDB_CODE_INVALID_JSON_FORMAT;
   tjsonGetNumberValue(pJson, "lastConfigIndex", pCfg->lastConfigIndex, code);
-  if (code < 0) return -1;
+  if (code < 0) return TSDB_CODE_INVALID_JSON_FORMAT;
   tjsonGetInt32ValueFromDouble(pJson, "configIndexCount", pCfg->configIndexCount, code);
+  if (code < 0) return TSDB_CODE_INVALID_JSON_FORMAT;
 
   SJson *configIndexArr = tjsonGetObjectItem(pJson, "configIndexArr");
-  if (configIndexArr == NULL) return -1;
+  if (configIndexArr == NULL) return TSDB_CODE_INVALID_JSON_FORMAT;
 
   pCfg->configIndexCount = tjsonGetArraySize(configIndexArr);
   for (int32_t i = 0; i < pCfg->configIndexCount; ++i) {
     SJson *configIndex = tjsonGetArrayItem(configIndexArr, i);
-    if (configIndex == NULL) return -1;
+    if (configIndex == NULL) return TSDB_CODE_INVALID_JSON_FORMAT;
     tjsonGetNumberValue(configIndex, "index", pCfg->configIndexArr[i], code);
-    if (code < 0) return -1;
+    if (code < 0) return TSDB_CODE_INVALID_JSON_FORMAT;
   }
-
   return 0;
 }
 
 int32_t syncReadCfgFile(SSyncNode *pNode) {
-  int32_t     code = -1;
+  int32_t     code = 0;
   TdFilePtr   pFile = NULL;
   char       *pData = NULL;
   SJson      *pJson = NULL;
@@ -208,27 +245,27 @@ int32_t syncReadCfgFile(SSyncNode *pNode) {
 
   pFile = taosOpenFile(file, TD_FILE_READ);
   if (pFile == NULL) {
-    terrno = TAOS_SYSTEM_ERROR(errno);
-    sError("vgId:%d, failed to open sync cfg file:%s since %s", pNode->vgId, file, terrstr());
+    code = TAOS_SYSTEM_ERROR(errno);
+    sError("vgId:%d, failed to open sync cfg file:%s since %s", pNode->vgId, file, tstrerror(code));
     goto _OVER;
   }
 
   int64_t size = 0;
   if (taosFStatFile(pFile, &size, NULL) < 0) {
-    terrno = TAOS_SYSTEM_ERROR(errno);
-    sError("vgId:%d, failed to fstat sync cfg file:%s since %s", pNode->vgId, file, terrstr());
+    code = TAOS_SYSTEM_ERROR(errno);
+    sError("vgId:%d, failed to fstat sync cfg file:%s since %s", pNode->vgId, file, tstrerror(code));
     goto _OVER;
   }
 
   pData = taosMemoryMalloc(size + 1);
   if (pData == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    code = TSDB_CODE_OUT_OF_MEMORY;
     goto _OVER;
   }
 
   if (taosReadFile(pFile, pData, size) != size) {
-    terrno = TAOS_SYSTEM_ERROR(errno);
-    sError("vgId:%d, failed to read sync cfg file:%s since %s", pNode->vgId, file, terrstr());
+    code = TAOS_SYSTEM_ERROR(errno);
+    sError("vgId:%d, failed to read sync cfg file:%s since %s", pNode->vgId, file, tstrerror(code));
     goto _OVER;
   }
 
@@ -236,18 +273,16 @@ int32_t syncReadCfgFile(SSyncNode *pNode) {
 
   pJson = tjsonParse(pData);
   if (pJson == NULL) {
-    terrno = TSDB_CODE_INVALID_JSON_FORMAT;
+    code = TSDB_CODE_INVALID_JSON_FORMAT;
     goto _OVER;
   }
 
   if (tjsonToObject(pJson, "RaftCfg", syncDecodeRaftCfg, (void *)pCfg) < 0) {
-    terrno = TSDB_CODE_INVALID_JSON_FORMAT;
+    code = TSDB_CODE_INVALID_JSON_FORMAT;
     goto _OVER;
   }
 
-  code = 0;
-  sInfo("vgId:%d, succceed to read sync cfg file %s, changeVersion:%d", 
-    pNode->vgId, file, pCfg->cfg.changeVersion);
+  sInfo("vgId:%d, succceed to read sync cfg file %s, changeVersion:%d", pNode->vgId, file, pCfg->cfg.changeVersion);
 
 _OVER:
   if (pData != NULL) taosMemoryFree(pData);
@@ -255,15 +290,15 @@ _OVER:
   if (pFile != NULL) taosCloseFile(&pFile);
 
   if (code != 0) {
-    sError("vgId:%d, failed to read sync cfg file:%s since %s", pNode->vgId, file, terrstr());
+    sError("vgId:%d, failed to read sync cfg file:%s since %s", pNode->vgId, file, tstrerror(code));
   }
-  return code;
+  TAOS_RETURN(code);
 }
 
 int32_t syncAddCfgIndex(SSyncNode *pNode, SyncIndex cfgIndex) {
   SRaftCfg *pCfg = &pNode->raftCfg;
-  if (pCfg->configIndexCount < MAX_CONFIG_INDEX_COUNT) {
-    return -1;
+  if (pCfg->configIndexCount >= MAX_CONFIG_INDEX_COUNT) {
+    return TSDB_CODE_OUT_OF_RANGE;
   }
 
   pCfg->configIndexArr[pCfg->configIndexCount] = cfgIndex;
diff --git a/source/libs/sync/src/syncRaftEntry.c b/source/libs/sync/src/syncRaftEntry.c
index 8f42780eb9..fd6781f354 100644
--- a/source/libs/sync/src/syncRaftEntry.c
+++ b/source/libs/sync/src/syncRaftEntry.c
@@ -99,9 +99,14 @@ void syncEntryDestroy(SSyncRaftEntry* pEntry) {
   }
 }
 
-void syncEntry2OriginalRpc(const SSyncRaftEntry* pEntry, SRpcMsg* pRpcMsg) {
+int32_t syncEntry2OriginalRpc(const SSyncRaftEntry* pEntry, SRpcMsg* pRpcMsg) {
   pRpcMsg->msgType = pEntry->originalRpcType;
   pRpcMsg->contLen = (int32_t)(pEntry->dataLen);
   pRpcMsg->pCont = rpcMallocCont(pRpcMsg->contLen);
+  if (pRpcMsg->pCont == NULL) {
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
   memcpy(pRpcMsg->pCont, pEntry->data, pRpcMsg->contLen);
+
+  return 0;
 }
diff --git a/source/libs/sync/src/syncRespMgr.c b/source/libs/sync/src/syncRespMgr.c
index 3506d477d3..4663a1f6e9 100644
--- a/source/libs/sync/src/syncRespMgr.c
+++ b/source/libs/sync/src/syncRespMgr.c
@@ -19,25 +19,33 @@
 #include "syncRaftStore.h"
 #include "syncUtil.h"
 
-SSyncRespMgr *syncRespMgrCreate(void *data, int64_t ttl) {
-  SSyncRespMgr *pObj = taosMemoryCalloc(1, sizeof(SSyncRespMgr));
-  if (pObj == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return NULL;
+int32_t syncRespMgrCreate(void *data, int64_t ttl, SSyncRespMgr **ppObj) {
+  SSyncRespMgr *pObj = NULL;
+
+  *ppObj = NULL;
+
+  if ((pObj = taosMemoryCalloc(1, sizeof(SSyncRespMgr))) == NULL) {
+    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
   }
 
   pObj->pRespHash =
       taosHashInit(sizeof(uint64_t), taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
-  if (pObj->pRespHash == NULL) return NULL;
+  if (pObj->pRespHash == NULL) {
+    taosMemoryFree(pObj);
+    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
+  }
 
   pObj->ttl = ttl;
   pObj->data = data;
   pObj->seqNum = 0;
-  taosThreadMutexInit(&(pObj->mutex), NULL);
+  (void)taosThreadMutexInit(&(pObj->mutex), NULL);
 
   SSyncNode *pNode = pObj->data;
   sDebug("vgId:%d, resp manager create", pNode->vgId);
-  return pObj;
+
+  *ppObj = pObj;
+
+  TAOS_RETURN(0);
 }
 
 void syncRespMgrDestroy(SSyncRespMgr *pObj) {
@@ -46,82 +54,84 @@ void syncRespMgrDestroy(SSyncRespMgr *pObj) {
   SSyncNode *pNode = pObj->data;
   sDebug("vgId:%d, resp manager destroy", pNode->vgId);
 
-  taosThreadMutexLock(&pObj->mutex);
+  (void)taosThreadMutexLock(&pObj->mutex);
   taosHashCleanup(pObj->pRespHash);
-  taosThreadMutexUnlock(&pObj->mutex);
-  taosThreadMutexDestroy(&(pObj->mutex));
+  (void)taosThreadMutexUnlock(&pObj->mutex);
+  (void)taosThreadMutexDestroy(&(pObj->mutex));
   taosMemoryFree(pObj);
 }
 
 uint64_t syncRespMgrAdd(SSyncRespMgr *pObj, const SRespStub *pStub) {
-  taosThreadMutexLock(&pObj->mutex);
+  (void)taosThreadMutexLock(&pObj->mutex);
 
   uint64_t seq = ++(pObj->seqNum);
   int32_t  code = taosHashPut(pObj->pRespHash, &seq, sizeof(uint64_t), pStub, sizeof(SRespStub));
   sNTrace(pObj->data, "save message handle:%p, type:%s seq:%" PRIu64 " code:0x%x", pStub->rpcMsg.info.handle,
           TMSG_INFO(pStub->rpcMsg.msgType), seq, code);
 
-  taosThreadMutexUnlock(&pObj->mutex);
+  (void)taosThreadMutexUnlock(&pObj->mutex);
   return seq;
 }
 
 int32_t syncRespMgrDel(SSyncRespMgr *pObj, uint64_t seq) {
-  taosThreadMutexLock(&pObj->mutex);
+  (void)taosThreadMutexLock(&pObj->mutex);
 
   int32_t code = taosHashRemove(pObj->pRespHash, &seq, sizeof(seq));
   sNTrace(pObj->data, "remove message handle, seq:%" PRIu64 " code:%d", seq, code);
 
-  taosThreadMutexUnlock(&pObj->mutex);
+  (void)taosThreadMutexUnlock(&pObj->mutex);
   return code;
 }
 
 int32_t syncRespMgrGet(SSyncRespMgr *pObj, uint64_t seq, SRespStub *pStub) {
-  taosThreadMutexLock(&pObj->mutex);
+  (void)taosThreadMutexLock(&pObj->mutex);
 
   SRespStub *pTmp = taosHashGet(pObj->pRespHash, &seq, sizeof(uint64_t));
   if (pTmp != NULL) {
-    memcpy(pStub, pTmp, sizeof(SRespStub));
+    (void)memcpy(pStub, pTmp, sizeof(SRespStub));
     sNTrace(pObj->data, "get message handle, type:%s seq:%" PRIu64 " handle:%p", TMSG_INFO(pStub->rpcMsg.msgType), seq,
             pStub->rpcMsg.info.handle);
 
-    taosThreadMutexUnlock(&pObj->mutex);
+    (void)taosThreadMutexUnlock(&pObj->mutex);
     return 1;  // get one object
   } else {
     sNError(pObj->data, "get message handle, no object of seq:%" PRIu64, seq);
   }
 
-  taosThreadMutexUnlock(&pObj->mutex);
+  (void)taosThreadMutexUnlock(&pObj->mutex);
   return 0;  // get none object
 }
 
 int32_t syncRespMgrGetAndDel(SSyncRespMgr *pObj, uint64_t seq, SRpcHandleInfo *pInfo) {
-  taosThreadMutexLock(&pObj->mutex);
+  (void)taosThreadMutexLock(&pObj->mutex);
 
   SRespStub *pStub = taosHashGet(pObj->pRespHash, &seq, sizeof(uint64_t));
   if (pStub != NULL) {
     *pInfo = pStub->rpcMsg.info;
     sNTrace(pObj->data, "get-and-del message handle:%p, type:%s seq:%" PRIu64, pStub->rpcMsg.info.handle,
             TMSG_INFO(pStub->rpcMsg.msgType), seq);
-    taosHashRemove(pObj->pRespHash, &seq, sizeof(uint64_t));
+    (void)taosHashRemove(pObj->pRespHash, &seq, sizeof(uint64_t));
 
-    taosThreadMutexUnlock(&pObj->mutex);
+    (void)taosThreadMutexUnlock(&pObj->mutex);
     return 1;  // get one object
   } else {
     sNTrace(pObj->data, "get-and-del message handle, no object of seq:%" PRIu64, seq);
   }
 
-  taosThreadMutexUnlock(&pObj->mutex);
+  (void)taosThreadMutexUnlock(&pObj->mutex);
   return 0;  // get none object
 }
 
-static void syncRespCleanByTTL(SSyncRespMgr *pObj, int64_t ttl, bool rsp) {
+static int32_t syncRespCleanByTTL(SSyncRespMgr *pObj, int64_t ttl, bool rsp) {
   SRespStub *pStub = (SRespStub *)taosHashIterate(pObj->pRespHash, NULL);
   int        cnt = 0;
   int        sum = 0;
   SSyncNode *pNode = pObj->data;
 
   SArray *delIndexArray = taosArrayInit(4, sizeof(uint64_t));
-  if (delIndexArray == NULL) return;
+  if (delIndexArray == NULL) {
+    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
+  }
 
   sDebug("vgId:%d, resp manager begin clean by ttl", pNode->vgId);
   while (pStub) {
@@ -153,7 +163,7 @@ static void syncRespCleanByTTL(SSyncRespMgr *pObj, int64_t ttl, bool rsp) {
       SRpcMsg rpcMsg = {.info = pStub->rpcMsg.info, .code = TSDB_CODE_SYN_TIMEOUT};
       sInfo("vgId:%d, message handle:%p expired, type:%s ahandle:%p", pNode->vgId, rpcMsg.info.handle,
             TMSG_INFO(pStub->rpcMsg.msgType), rpcMsg.info.ahandle);
-      rpcSendResponse(&rpcMsg);
+      (void)rpcSendResponse(&rpcMsg);
     }
 
     pStub = taosHashIterate(pObj->pRespHash, pStub);
@@ -164,10 +174,12 @@ static void syncRespCleanByTTL(SSyncRespMgr *pObj, int64_t ttl, bool rsp) {
 
   for (int32_t i = 0; i < arraySize; ++i) {
     uint64_t *pSeqNum = taosArrayGet(delIndexArray, i);
-    taosHashRemove(pObj->pRespHash, pSeqNum, sizeof(uint64_t));
+    (void)taosHashRemove(pObj->pRespHash, pSeqNum, sizeof(uint64_t));
     sDebug("vgId:%d, resp manager clean by ttl, seq:%" PRId64, pNode->vgId, *pSeqNum);
   }
   taosArrayDestroy(delIndexArray);
+
+  return 0;
 }
 
 void syncRespCleanRsp(SSyncRespMgr *pObj) {
@@ -176,16 +188,16 @@ void syncRespCleanRsp(SSyncRespMgr *pObj) {
   SSyncNode *pNode = pObj->data;
   sTrace("vgId:%d, clean all resp", pNode->vgId);
 
-  taosThreadMutexLock(&pObj->mutex);
-  syncRespCleanByTTL(pObj, -1, true);
-  taosThreadMutexUnlock(&pObj->mutex);
+  (void)taosThreadMutexLock(&pObj->mutex);
+  (void)syncRespCleanByTTL(pObj, -1, true);
+  (void)taosThreadMutexUnlock(&pObj->mutex);
 }
 
 void syncRespClean(SSyncRespMgr *pObj) {
   SSyncNode *pNode = pObj->data;
   sTrace("vgId:%d, clean resp by ttl", pNode->vgId);
 
-  taosThreadMutexLock(&pObj->mutex);
-  syncRespCleanByTTL(pObj, pObj->ttl, false);
-  taosThreadMutexUnlock(&pObj->mutex);
+  (void)taosThreadMutexLock(&pObj->mutex);
+  (void)syncRespCleanByTTL(pObj, pObj->ttl, false);
+  (void)taosThreadMutexUnlock(&pObj->mutex);
 }
diff --git a/source/libs/sync/src/syncSnapshot.c b/source/libs/sync/src/syncSnapshot.c
index 8dab694975..450d22528d 100644
--- a/source/libs/sync/src/syncSnapshot.c
+++ b/source/libs/sync/src/syncSnapshot.c
@@ -44,33 +44,37 @@ static void syncSnapBufferDestroy(SSyncSnapBuffer **ppBuf) {
 
   syncSnapBufferReset(pBuf);
 
-  taosThreadMutexDestroy(&pBuf->mutex);
+  (void)taosThreadMutexDestroy(&pBuf->mutex);
   taosMemoryFree(ppBuf[0]);
   ppBuf[0] = NULL;
   return;
 }
 
-static SSyncSnapBuffer *syncSnapBufferCreate() {
+static int32_t syncSnapBufferCreate(SSyncSnapBuffer **ppBuf) {
   SSyncSnapBuffer *pBuf = taosMemoryCalloc(1, sizeof(SSyncSnapBuffer));
   if (pBuf == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return NULL;
+    *ppBuf = NULL;
+    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
   }
   pBuf->size = sizeof(pBuf->entries) / sizeof(void *);
   ASSERT(pBuf->size == TSDB_SYNC_SNAP_BUFFER_SIZE);
-  taosThreadMutexInit(&pBuf->mutex, NULL);
-  return pBuf;
+  (void)taosThreadMutexInit(&pBuf->mutex, NULL);
+  *ppBuf = pBuf;
+  TAOS_RETURN(0);
 }
 
-SSyncSnapshotSender *snapshotSenderCreate(SSyncNode *pSyncNode, int32_t replicaIndex) {
+int32_t snapshotSenderCreate(SSyncNode *pSyncNode, int32_t replicaIndex, SSyncSnapshotSender **ppSender) {
+  int32_t code = 0;
+  *ppSender = NULL;
   bool condition = (pSyncNode->pFsm->FpSnapshotStartRead != NULL) && (pSyncNode->pFsm->FpSnapshotStopRead != NULL) &&
                    (pSyncNode->pFsm->FpSnapshotDoRead != NULL);
-  if (!condition) return NULL;
+  if (!condition) {
+    TAOS_RETURN(TSDB_CODE_SYN_INTERNAL_ERROR);
+  }
 
   SSyncSnapshotSender *pSender = taosMemoryCalloc(1, sizeof(SSyncSnapshotSender));
   if (pSender == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return NULL;
+    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
   }
 
   pSender->start = false;
@@ -85,17 +89,19 @@ SSyncSnapshotSender *snapshotSenderCreate(SSyncNode *pSyncNode, int32_t replicaI
   pSender->pSyncNode->pFsm->FpGetSnapshotInfo(pSender->pSyncNode->pFsm, &pSender->snapshot);
   pSender->finish = false;
 
-  SSyncSnapBuffer *pSndBuf = syncSnapBufferCreate();
+  SSyncSnapBuffer *pSndBuf = NULL;
+  code = syncSnapBufferCreate(&pSndBuf);
   if (pSndBuf == NULL) {
     taosMemoryFree(pSender);
     pSender = NULL;
-    return NULL;
+    TAOS_RETURN(code);
   }
   pSndBuf->entryDeleteCb = syncSnapBlockDestroy;
   pSender->pSndBuf = pSndBuf;
 
   syncSnapBufferReset(pSender->pSndBuf);
-  return pSender;
+  *ppSender = pSender;
+  TAOS_RETURN(code);
 }
 
 void syncSnapBlockDestroy(void *ptr) {
@@ -135,7 +141,7 @@ void snapshotSenderDestroy(SSyncSnapshotSender *pSender) {
     syncSnapBufferDestroy(&pSender->pSndBuf);
   }
 
-  snapshotSenderClearInfoData(pSender);
+  (void)snapshotSenderClearInfoData(pSender);
 
   // free sender
   taosMemoryFree(pSender);
@@ -144,7 +150,7 @@ void snapshotSenderDestroy(SSyncSnapshotSender *pSender) {
 bool snapshotSenderIsStart(SSyncSnapshotSender *pSender) { return atomic_load_8(&pSender->start); }
 
 int32_t snapshotSenderStart(SSyncSnapshotSender *pSender) {
-  int32_t code = -1;
+  int32_t code = 0;
 
   int8_t started = atomic_val_compare_exchange_8(&pSender->start, false, true);
   if (started) return 0;
@@ -160,7 +166,7 @@ int32_t snapshotSenderStart(SSyncSnapshotSender *pSender) {
   pSender->snapshot.lastApplyTerm = SYNC_TERM_INVALID;
   pSender->snapshot.lastConfigIndex = SYNC_INDEX_INVALID;
 
-  memset(&pSender->lastConfig, 0, sizeof(pSender->lastConfig));
+  (void)memset(&pSender->lastConfig, 0, sizeof(pSender->lastConfig));
   pSender->sendingMS = 0;
   pSender->term = raftStoreGetTerm(pSender->pSyncNode);
   pSender->startTime = taosGetMonoTimestampMs();
@@ -170,8 +176,8 @@ int32_t snapshotSenderStart(SSyncSnapshotSender *pSender) {
   // Get snapshot info
   SSyncNode *pSyncNode = pSender->pSyncNode;
   SSnapshot  snapInfo = {.type = TDMT_SYNC_PREP_SNAPSHOT};
-  if (pSyncNode->pFsm->FpGetSnapshotInfo(pSyncNode->pFsm, &snapInfo) != 0) {
-    sSError(pSender, "snapshot get info failure since %s", terrstr());
+  if ((code = pSyncNode->pFsm->FpGetSnapshotInfo(pSyncNode->pFsm, &snapInfo)) != 0) {
+    sSError(pSender, "snapshot get info failure since %s", tstrerror(code));
     goto _out;
   }
 
@@ -182,25 +188,24 @@ int32_t snapshotSenderStart(SSyncSnapshotSender *pSender) {
     SSyncTLV *datHead = pData;
     if (datHead->typ != TDMT_SYNC_PREP_SNAPSHOT) {
       sSError(pSender, "unexpected data typ in data of snapshot info. typ: %d", datHead->typ);
-      terrno = TSDB_CODE_INVALID_DATA_FMT;
+      code = TSDB_CODE_INVALID_DATA_FMT;
       goto _out;
     }
     dataLen = sizeof(SSyncTLV) + datHead->len;
   }
 
-  if (syncSnapSendMsg(pSender, pSender->seq, pData, dataLen, type) != 0) {
+  if ((code = syncSnapSendMsg(pSender, pSender->seq, pData, dataLen, type)) != 0) {
     goto _out;
   }
 
   SRaftId destId = pSender->pSyncNode->replicasId[pSender->replicaIndex];
   sSInfo(pSender, "snapshot sender start, to dnode:%d.", DID(&destId));
-  code = 0;
 _out:
   if (snapInfo.data) {
     taosMemoryFree(snapInfo.data);
     snapInfo.data = NULL;
   }
-  return code;
+  TAOS_RETURN(code);
 }
 
 void snapshotSenderStop(SSyncSnapshotSender *pSender, bool finish) {
@@ -209,7 +214,7 @@ void snapshotSenderStop(SSyncSnapshotSender *pSender, bool finish) {
   // update flag
   int8_t stopped = !atomic_val_compare_exchange_8(&pSender->start, true, false);
   if (stopped) return;
-  taosThreadMutexLock(&pSender->pSndBuf->mutex);
+  (void)taosThreadMutexLock(&pSender->pSndBuf->mutex);
   {
     pSender->finish = finish;
 
@@ -221,20 +226,20 @@ void snapshotSenderStop(SSyncSnapshotSender *pSender, bool finish) {
 
     syncSnapBufferReset(pSender->pSndBuf);
 
-    snapshotSenderClearInfoData(pSender);
+    (void)snapshotSenderClearInfoData(pSender);
 
     SRaftId destId = pSender->pSyncNode->replicasId[pSender->replicaIndex];
     sSInfo(pSender, "snapshot sender stop, to dnode:%d, finish:%d", DID(&destId), finish);
   }
-  taosThreadMutexUnlock(&pSender->pSndBuf->mutex);
+  (void)taosThreadMutexUnlock(&pSender->pSndBuf->mutex);
 }
 
 int32_t syncSnapSendMsg(SSyncSnapshotSender *pSender, int32_t seq, void *pBlock, int32_t blockLen, int32_t typ) {
-  int32_t code = -1;
+  int32_t code = 0;
   SRpcMsg rpcMsg = {0};
 
-  if (syncBuildSnapshotSend(&rpcMsg, blockLen, pSender->pSyncNode->vgId) != 0) {
-    sSError(pSender, "failed to build snap replication msg since %s", terrstr());
+  if ((code = syncBuildSnapshotSend(&rpcMsg, blockLen, pSender->pSyncNode->vgId)) != 0) {
+    sSError(pSender, "failed to build snap replication msg since %s", tstrerror(code));
     goto _OUT;
   }
 
@@ -251,25 +256,24 @@ int32_t syncSnapSendMsg(SSyncSnapshotSender *pSender, int32_t seq, void *pBlock,
   pMsg->seq = seq;
 
   if (pBlock != NULL && blockLen > 0) {
-    memcpy(pMsg->data, pBlock, blockLen);
+    (void)memcpy(pMsg->data, pBlock, blockLen);
   }
   pMsg->payloadType = typ;
 
   // send msg
-  if (syncNodeSendMsgById(&pMsg->destId, pSender->pSyncNode, &rpcMsg) != 0) {
-    sSError(pSender, "failed to send snap replication msg since %s. seq:%d", terrstr(), seq);
+  if ((code = syncNodeSendMsgById(&pMsg->destId, pSender->pSyncNode, &rpcMsg)) != 0) {
+    sSError(pSender, "failed to send snap replication msg since %s. seq:%d", tstrerror(code), seq);
     goto _OUT;
   }
 
-  code = 0;
 _OUT:
-  return code;
+  TAOS_RETURN(code);
 }
 
 // when sender receive ack, call this function to send msg from seq
 // seq = ack + 1, already updated
 static int32_t snapshotSend(SSyncSnapshotSender *pSender) {
-  int32_t        code = -1;
+  int32_t        code = 0;
   SyncSnapBlock *pBlk = NULL;
 
   if (pSender->seq < SYNC_SNAPSHOT_SEQ_END) {
@@ -278,7 +282,7 @@ static int32_t snapshotSend(SSyncSnapshotSender *pSender) {
     if (pSender->seq > SYNC_SNAPSHOT_SEQ_BEGIN) {
       pBlk = taosMemoryCalloc(1, sizeof(SyncSnapBlock));
       if (pBlk == NULL) {
-        terrno = TSDB_CODE_OUT_OF_MEMORY;
+        code = TSDB_CODE_OUT_OF_MEMORY;
         goto _OUT;
       }
 
@@ -288,7 +292,6 @@ static int32_t snapshotSend(SSyncSnapshotSender *pSender) {
       code = pSender->pSyncNode->pFsm->FpSnapshotDoRead(pSender->pSyncNode->pFsm, pSender->pReader, &pBlk->pBlock,
                                                         &pBlk->blockLen);
       if (code != 0) {
-        terrno = code;
         sSError(pSender, "snapshot sender read failed since %s", tstrerror(code));
         goto _OUT;
       }
@@ -300,7 +303,6 @@ static int32_t snapshotSend(SSyncSnapshotSender *pSender) {
         // read finish, update seq to end
         pSender->seq = SYNC_SNAPSHOT_SEQ_END;
         sSInfo(pSender, "snapshot sender read to the end");
-        code = 0;
         goto _OUT;
       }
     }
@@ -311,7 +313,7 @@ static int32_t snapshotSend(SSyncSnapshotSender *pSender) {
   // send msg
   int32_t blockLen = (pBlk) ? pBlk->blockLen : 0;
   void   *pBlock = (pBlk) ? pBlk->pBlock : NULL;
-  if (syncSnapSendMsg(pSender, pSender->seq, pBlock, blockLen, 0) != 0) {
+  if ((code = syncSnapSendMsg(pSender, pSender->seq, pBlock, blockLen, 0)) != 0) {
     goto _OUT;
   }
 
@@ -325,22 +327,22 @@ static int32_t snapshotSend(SSyncSnapshotSender *pSender) {
     pSender->pSndBuf->end = TMAX(pSender->seq + 1, pSender->pSndBuf->end);
   }
   pSender->lastSendTime = nowMs;
-  code = 0;
 
 _OUT:;
   if (pBlk != NULL) {
     syncSnapBlockDestroy(pBlk);
     pBlk = NULL;
   }
-  return code;
+  TAOS_RETURN(code);
 }
 
 // send snapshot data from cache
 int32_t snapshotReSend(SSyncSnapshotSender *pSender) {
   SSyncSnapBuffer *pSndBuf = pSender->pSndBuf;
-  int32_t          code = -1;
-  taosThreadMutexLock(&pSndBuf->mutex);
+  int32_t          code = 0;
+  (void)taosThreadMutexLock(&pSndBuf->mutex);
   if (pSender->pReader == NULL || pSender->finish || !snapshotSenderIsStart(pSender)) {
+    code = TSDB_CODE_SYN_INTERNAL_ERROR;
     goto _out;
   }
 
@@ -351,7 +353,7 @@ int32_t snapshotReSend(SSyncSnapshotSender *pSender) {
     if (pBlk->acked || nowMs < pBlk->sendTimeMs + SYNC_SNAP_RESEND_MS) {
       continue;
     }
-    if (syncSnapSendMsg(pSender, pBlk->seq, pBlk->pBlock, pBlk->blockLen, 0) != 0) {
+    if ((code = syncSnapSendMsg(pSender, pBlk->seq, pBlk->pBlock, pBlk->blockLen, 0)) != 0) {
       goto _out;
     }
     pBlk->sendTimeMs = nowMs;
@@ -364,21 +366,20 @@ int32_t snapshotReSend(SSyncSnapshotSender *pSender) {
   }
 
   if (pSender->seq == SYNC_SNAPSHOT_SEQ_END && pSndBuf->end <= pSndBuf->start) {
-    if (syncSnapSendMsg(pSender, pSender->seq, NULL, 0, 0) != 0) {
+    if ((code = syncSnapSendMsg(pSender, pSender->seq, NULL, 0, 0)) != 0) {
       goto _out;
     }
   }
-  code = 0;
 _out:;
-  taosThreadMutexUnlock(&pSndBuf->mutex);
-  return code;
+  (void)taosThreadMutexUnlock(&pSndBuf->mutex);
+  TAOS_RETURN(code);
 }
 
 int32_t syncNodeStartSnapshot(SSyncNode *pSyncNode, SRaftId *pDestId) {
   SSyncSnapshotSender *pSender = syncNodeGetSnapshotSender(pSyncNode, pDestId);
   if (pSender == NULL) {
     sNError(pSyncNode, "snapshot sender start error since get failed");
-    return -1;
+    TAOS_RETURN(TSDB_CODE_SYN_INTERNAL_ERROR);
   }
 
   if (snapshotSenderIsStart(pSender)) {
@@ -390,23 +391,26 @@ int32_t syncNodeStartSnapshot(SSyncNode *pSyncNode, SRaftId *pDestId) {
 
   int32_t code = snapshotSenderStart(pSender);
   if (code != 0) {
-    sSError(pSender, "snapshot sender start error since %s", terrstr());
-    return -1;
+    sSError(pSender, "snapshot sender start error since %s", tstrerror(code));
+    TAOS_RETURN(code);
   }
 
   return 0;
 }
 
 // receiver
-SSyncSnapshotReceiver *snapshotReceiverCreate(SSyncNode *pSyncNode, SRaftId fromId) {
+int32_t snapshotReceiverCreate(SSyncNode *pSyncNode, SRaftId fromId, SSyncSnapshotReceiver **ppReceiver) {
+  int32_t code = 0;
+  *ppReceiver = NULL;
   bool condition = (pSyncNode->pFsm->FpSnapshotStartWrite != NULL) && (pSyncNode->pFsm->FpSnapshotStopWrite != NULL) &&
                    (pSyncNode->pFsm->FpSnapshotDoWrite != NULL);
-  if (!condition) return NULL;
+  if (!condition) {
+    TAOS_RETURN(TSDB_CODE_SYN_INTERNAL_ERROR);
+  }
 
   SSyncSnapshotReceiver *pReceiver = taosMemoryCalloc(1, sizeof(SSyncSnapshotReceiver));
   if (pReceiver == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return NULL;
+    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
   }
 
   pReceiver->start = false;
@@ -421,17 +425,19 @@ SSyncSnapshotReceiver *snapshotReceiverCreate(SSyncNode *pSyncNode, SRaftId from
   pReceiver->snapshot.lastApplyTerm = 0;
   pReceiver->snapshot.lastConfigIndex = SYNC_INDEX_INVALID;
 
-  SSyncSnapBuffer *pRcvBuf = syncSnapBufferCreate();
+  SSyncSnapBuffer *pRcvBuf = NULL;
+  code = syncSnapBufferCreate(&pRcvBuf);
   if (pRcvBuf == NULL) {
     taosMemoryFree(pReceiver);
     pReceiver = NULL;
-    return NULL;
+    TAOS_RETURN(code);
   }
   pRcvBuf->entryDeleteCb = rpcFreeCont;
   pReceiver->pRcvBuf = pRcvBuf;
 
   syncSnapBufferReset(pReceiver->pRcvBuf);
-  return pReceiver;
+  *ppReceiver = pReceiver;
+  TAOS_RETURN(code);
 }
 
 static int32_t snapshotReceiverClearInfoData(SSyncSnapshotReceiver *pReceiver) {
@@ -452,10 +458,11 @@ void snapshotReceiverDestroy(SSyncSnapshotReceiver *pReceiver) {
 
   // close writer
   if (pReceiver->pWriter != NULL) {
-    int32_t ret = pReceiver->pSyncNode->pFsm->FpSnapshotStopWrite(pReceiver->pSyncNode->pFsm, pReceiver->pWriter, false,
-                                                                  &pReceiver->snapshot);
-    if (ret != 0) {
-      sError("vgId:%d, snapshot receiver stop failed while destroy since %s", pReceiver->pSyncNode->vgId, terrstr());
+    int32_t code = pReceiver->pSyncNode->pFsm->FpSnapshotStopWrite(pReceiver->pSyncNode->pFsm, pReceiver->pWriter,
+                                                                   false, &pReceiver->snapshot);
+    if (code != 0) {
+      sError("vgId:%d, snapshot receiver stop failed while destroy since %s", pReceiver->pSyncNode->vgId,
+             tstrerror(code));
     }
     pReceiver->pWriter = NULL;
   }
@@ -486,8 +493,7 @@ static int32_t snapshotReceiverSignatureCmp(SSyncSnapshotReceiver *pReceiver, Sy
 static int32_t snapshotReceiverStartWriter(SSyncSnapshotReceiver *pReceiver, SyncSnapshotSend *pBeginMsg) {
   if (pReceiver->pWriter != NULL) {
     sRError(pReceiver, "vgId:%d, snapshot receiver writer is not null", pReceiver->pSyncNode->vgId);
-    terrno = TSDB_CODE_SYN_INTERNAL_ERROR;
-    return -1;
+    TAOS_RETURN(TSDB_CODE_SYN_INTERNAL_ERROR);
   }
 
   // update ack
@@ -501,11 +507,11 @@ static int32_t snapshotReceiverStartWriter(SSyncSnapshotReceiver *pReceiver, Syn
   pReceiver->snapshotParam.end = pBeginMsg->lastIndex;
 
   // start writer
-  int32_t ret = pReceiver->pSyncNode->pFsm->FpSnapshotStartWrite(pReceiver->pSyncNode->pFsm, &pReceiver->snapshotParam,
-                                                                 &pReceiver->pWriter);
-  if (ret != 0) {
-    sRError(pReceiver, "snapshot receiver start write failed since %s", terrstr());
-    return -1;
+  int32_t code = pReceiver->pSyncNode->pFsm->FpSnapshotStartWrite(pReceiver->pSyncNode->pFsm, &pReceiver->snapshotParam,
+                                                                  &pReceiver->pWriter);
+  if (code != 0) {
+    sRError(pReceiver, "snapshot receiver start write failed since %s", tstrerror(code));
+    TAOS_RETURN(code);
   }
 
   // event log
@@ -538,13 +544,13 @@ void snapshotReceiverStop(SSyncSnapshotReceiver *pReceiver) {
 
   int8_t stopped = !atomic_val_compare_exchange_8(&pReceiver->start, true, false);
   if (stopped) return;
-  taosThreadMutexLock(&pReceiver->pRcvBuf->mutex);
+  (void)taosThreadMutexLock(&pReceiver->pRcvBuf->mutex);
   {
     if (pReceiver->pWriter != NULL) {
-      int32_t ret = pReceiver->pSyncNode->pFsm->FpSnapshotStopWrite(pReceiver->pSyncNode->pFsm, pReceiver->pWriter,
-                                                                    false, &pReceiver->snapshot);
-      if (ret != 0) {
-        sRError(pReceiver, "snapshot receiver stop write failed since %s", terrstr());
+      int32_t code = pReceiver->pSyncNode->pFsm->FpSnapshotStopWrite(pReceiver->pSyncNode->pFsm, pReceiver->pWriter,
+                                                                     false, &pReceiver->snapshot);
+      if (code != 0) {
+        sRError(pReceiver, "snapshot receiver stop write failed since %s", tstrerror(code));
       }
       pReceiver->pWriter = NULL;
     } else {
@@ -553,9 +559,9 @@ void snapshotReceiverStop(SSyncSnapshotReceiver *pReceiver) {
 
     syncSnapBufferReset(pReceiver->pRcvBuf);
 
-    snapshotReceiverClearInfoData(pReceiver);
+    (void)snapshotReceiverClearInfoData(pReceiver);
   }
-  taosThreadMutexUnlock(&pReceiver->pRcvBuf->mutex);
+  (void)taosThreadMutexUnlock(&pReceiver->pRcvBuf->mutex);
 }
 
 static int32_t snapshotReceiverFinish(SSyncSnapshotReceiver *pReceiver, SyncSnapshotSend *pMsg) {
@@ -567,8 +573,8 @@ static int32_t snapshotReceiverFinish(SSyncSnapshotReceiver *pReceiver, SyncSnap
       code = pReceiver->pSyncNode->pFsm->FpSnapshotDoWrite(pReceiver->pSyncNode->pFsm, pReceiver->pWriter, pMsg->data,
                                                            pMsg->dataLen);
       if (code != 0) {
-        sRError(pReceiver, "failed to finish snapshot receiver write since %s", terrstr());
-        return -1;
+        sRError(pReceiver, "failed to finish snapshot receiver write since %s", tstrerror(code));
+        TAOS_RETURN(code);
       }
     }
 
@@ -586,8 +592,8 @@ static int32_t snapshotReceiverFinish(SSyncSnapshotReceiver *pReceiver, SyncSnap
     code = pReceiver->pSyncNode->pFsm->FpSnapshotStopWrite(pReceiver->pSyncNode->pFsm, pReceiver->pWriter, true,
                                                            &pReceiver->snapshot);
     if (code != 0) {
-      sRError(pReceiver, "snapshot receiver apply failed  since %s", terrstr());
-      return -1;
+      sRError(pReceiver, "snapshot receiver apply failed  since %s", tstrerror(code));
+      TAOS_RETURN(code);
     }
     pReceiver->pWriter = NULL;
     sRInfo(pReceiver, "snapshot receiver write stopped");
@@ -604,13 +610,14 @@ static int32_t snapshotReceiverFinish(SSyncSnapshotReceiver *pReceiver, SyncSnap
     code =
         pReceiver->pSyncNode->pLogStore->syncLogRestoreFromSnapshot(pReceiver->pSyncNode->pLogStore, pMsg->lastIndex);
     if (code != 0) {
-      sRError(pReceiver, "failed to snapshot receiver log restore since %s", terrstr());
-      return -1;
+      sRError(pReceiver, "failed to snapshot receiver log restore since %s", tstrerror(code));
+      TAOS_RETURN(code);
     }
     sRInfo(pReceiver, "wal log restored from snapshot");
   } else {
+    code = TSDB_CODE_SYN_INTERNAL_ERROR;
     sRError(pReceiver, "snapshot receiver finish error since writer is null");
-    return -1;
+    TAOS_RETURN(code);
   }
 
   return 0;
@@ -619,14 +626,12 @@ static int32_t snapshotReceiverFinish(SSyncSnapshotReceiver *pReceiver, SyncSnap
 static int32_t snapshotReceiverGotData(SSyncSnapshotReceiver *pReceiver, SyncSnapshotSend *pMsg) {
   if (pMsg->seq != pReceiver->ack + 1) {
     sRError(pReceiver, "snapshot receiver invalid seq, ack:%d seq:%d", pReceiver->ack, pMsg->seq);
-    terrno = TSDB_CODE_SYN_INVALID_SNAPSHOT_MSG;
-    return -1;
+    TAOS_RETURN(TSDB_CODE_SYN_INVALID_SNAPSHOT_MSG);
   }
 
   if (pReceiver->pWriter == NULL) {
     sRError(pReceiver, "snapshot receiver failed to write data since writer is null");
-    terrno = TSDB_CODE_SYN_INTERNAL_ERROR;
-    return -1;
+    TAOS_RETURN(TSDB_CODE_SYN_INTERNAL_ERROR);
   }
 
   sRDebug(pReceiver, "snapshot receiver continue to write, blockLen:%d seq:%d", pMsg->dataLen, pMsg->seq);
@@ -636,8 +641,8 @@ static int32_t snapshotReceiverGotData(SSyncSnapshotReceiver *pReceiver, SyncSna
     int32_t code = pReceiver->pSyncNode->pFsm->FpSnapshotDoWrite(pReceiver->pSyncNode->pFsm, pReceiver->pWriter,
                                                                  pMsg->data, pMsg->dataLen);
     if (code != 0) {
-      sRError(pReceiver, "snapshot receiver continue write failed since %s", terrstr());
-      return -1;
+      sRError(pReceiver, "snapshot receiver continue write failed since %s", tstrerror(code));
+      TAOS_RETURN(code);
     }
   }
 
@@ -671,29 +676,27 @@ SyncIndex syncNodeGetSnapBeginIndex(SSyncNode *ths) {
 static int32_t syncSnapReceiverExchgSnapInfo(SSyncNode *pSyncNode, SSyncSnapshotReceiver *pReceiver,
                                              SyncSnapshotSend *pMsg, SSnapshot *pInfo) {
   ASSERT(pMsg->payloadType == TDMT_SYNC_PREP_SNAPSHOT);
-  int32_t code = 0;
+  int32_t code = 0, lino = 0;
 
   // copy snap info from leader
   void *data = taosMemoryCalloc(1, pMsg->dataLen);
   if (data == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    code = terrno;
-    goto _out;
+    TAOS_CHECK_EXIT(TSDB_CODE_OUT_OF_MEMORY);
   }
   pInfo->data = data;
   data = NULL;
-  memcpy(pInfo->data, pMsg->data, pMsg->dataLen);
+  (void)memcpy(pInfo->data, pMsg->data, pMsg->dataLen);
 
   // exchange snap info
-  if (pSyncNode->pFsm->FpGetSnapshotInfo(pSyncNode->pFsm, pInfo) != 0) {
+  if ((code = pSyncNode->pFsm->FpGetSnapshotInfo(pSyncNode->pFsm, pInfo)) != 0) {
     sRError(pReceiver, "failed to get snapshot info. type: %d", pMsg->payloadType);
-    goto _out;
+    goto _exit;
   }
   SSyncTLV *datHead = pInfo->data;
   if (datHead->typ != TDMT_SYNC_PREP_SNAPSHOT_REPLY) {
     sRError(pReceiver, "unexpected data typ in data of snapshot info. typ: %d", datHead->typ);
     code = TSDB_CODE_INVALID_DATA_FMT;
-    goto _out;
+    goto _exit;
   }
   int32_t dataLen = sizeof(SSyncTLV) + datHead->len;
 
@@ -701,18 +704,17 @@ static int32_t syncSnapReceiverExchgSnapInfo(SSyncNode *pSyncNode, SSyncSnapshot
   SSnapshotParam *pParam = &pReceiver->snapshotParam;
   data = taosMemoryRealloc(pParam->data, dataLen);
   if (data == NULL) {
+    code = TSDB_CODE_OUT_OF_MEMORY;
     sError("vgId:%d, failed to realloc memory for snapshot prep due to %s. dataLen:%d", pSyncNode->vgId,
-           strerror(errno), dataLen);
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    code = terrno;
-    goto _out;
+           tstrerror(code), dataLen);
+    goto _exit;
   }
   pParam->data = data;
   data = NULL;
-  memcpy(pParam->data, pInfo->data, dataLen);
+  (void)memcpy(pParam->data, pInfo->data, dataLen);
 
-_out:
-  return code;
+_exit:
+  TAOS_RETURN(code);
 }
 
 static int32_t syncNodeOnSnapshotPrep(SSyncNode *pSyncNode, SyncSnapshotSend *pMsg) {
@@ -741,8 +743,7 @@ static int32_t syncNodeOnSnapshotPrep(SSyncNode *pSyncNode, SyncSnapshotSend *pM
               "received a stale snapshot preparation. ignore."
               " msg signature:(%" PRId64 ", %" PRId64 ")",
               pMsg->term, pMsg->startTime);
-      terrno = TSDB_CODE_SYN_MISMATCHED_SIGNATURE;
-      code = terrno;
+      code = TSDB_CODE_SYN_MISMATCHED_SIGNATURE;
       goto _SEND_REPLY;
     }
   } else {
@@ -764,7 +765,7 @@ _SEND_REPLY:;
   SSnapshot snapInfo = {.type = TDMT_SYNC_PREP_SNAPSHOT_REPLY};
   int32_t   dataLen = 0;
   if (pMsg->payloadType == TDMT_SYNC_PREP_SNAPSHOT) {
-    if (syncSnapReceiverExchgSnapInfo(pSyncNode, pReceiver, pMsg, &snapInfo) != 0) {
+    if ((code = syncSnapReceiverExchgSnapInfo(pSyncNode, pReceiver, pMsg, &snapInfo)) != 0) {
       goto _out;
     }
     SSyncTLV *datHead = snapInfo.data;
@@ -773,8 +774,7 @@ _SEND_REPLY:;
 
   // send response
   int32_t type = (snapInfo.data) ? snapInfo.type : 0;
-  if (syncSnapSendRsp(pReceiver, pMsg, snapInfo.data, dataLen, type, code) != 0) {
-    code = terrno;
+  if ((code = syncSnapSendRsp(pReceiver, pMsg, snapInfo.data, dataLen, type, code)) != 0) {
     goto _out;
   }
 
@@ -783,7 +783,7 @@ _out:
     taosMemoryFree(snapInfo.data);
     snapInfo.data = NULL;
   }
-  return code;
+  TAOS_RETURN(code);
 }
 
 static int32_t syncNodeOnSnapshotBegin(SSyncNode *pSyncNode, SyncSnapshotSend *pMsg) {
@@ -797,14 +797,14 @@ static int32_t syncNodeOnSnapshotBegin(SSyncNode *pSyncNode, SyncSnapshotSend *p
   }
 
   if (snapshotReceiverSignatureCmp(pReceiver, pMsg) != 0) {
-    terrno = TSDB_CODE_SYN_MISMATCHED_SIGNATURE;
-    sRError(pReceiver, "failed to begin snapshot receiver since %s", terrstr());
+    code = TSDB_CODE_SYN_MISMATCHED_SIGNATURE;
+    sRError(pReceiver, "failed to begin snapshot receiver since %s", tstrerror(code));
     goto _SEND_REPLY;
   }
 
   // start writer
-  if (snapshotReceiverStartWriter(pReceiver, pMsg) != 0) {
-    sRError(pReceiver, "failed to start snapshot writer since %s", terrstr());
+  if ((code = snapshotReceiverStartWriter(pReceiver, pMsg)) != 0) {
+    sRError(pReceiver, "failed to start snapshot writer since %s", tstrerror(code));
     goto _SEND_REPLY;
   }
 
@@ -817,26 +817,22 @@ static int32_t syncNodeOnSnapshotBegin(SSyncNode *pSyncNode, SyncSnapshotSend *p
 
   code = 0;
 _SEND_REPLY:
-  if (code != 0 && terrno != 0) {
-    code = terrno;
-  }
 
   // send response
-  if (syncSnapSendRsp(pReceiver, pMsg, NULL, 0, 0, code) != 0) {
-    return -1;
-  }
+  TAOS_CHECK_RETURN(syncSnapSendRsp(pReceiver, pMsg, NULL, 0, 0, code));
 
-  return code;
+  TAOS_RETURN(code);
 }
 
 int32_t syncSnapSendRsp(SSyncSnapshotReceiver *pReceiver, SyncSnapshotSend *pMsg, void *pBlock, int32_t blockLen,
-                        int32_t type, int32_t code) {
+                        int32_t type, int32_t rspCode) {
+  int32_t    code = 0;
   SSyncNode *pSyncNode = pReceiver->pSyncNode;
   // build msg
   SRpcMsg rpcMsg = {0};
-  if (syncBuildSnapshotSendRsp(&rpcMsg, blockLen, pSyncNode->vgId)) {
-    sRError(pReceiver, "failed to build snapshot receiver resp since %s", terrstr());
-    return -1;
+  if ((code = syncBuildSnapshotSendRsp(&rpcMsg, blockLen, pSyncNode->vgId)) != 0) {
+    sRError(pReceiver, "failed to build snapshot receiver resp since %s", tstrerror(code));
+    TAOS_RETURN(code);
   }
 
   SyncSnapshotRsp *pRspMsg = rpcMsg.pCont;
@@ -847,18 +843,18 @@ int32_t syncSnapSendRsp(SSyncSnapshotReceiver *pReceiver, SyncSnapshotSend *pMsg
   pRspMsg->lastTerm = pMsg->lastTerm;
   pRspMsg->startTime = pMsg->startTime;
   pRspMsg->ack = pMsg->seq;
-  pRspMsg->code = code;
+  pRspMsg->code = rspCode;
   pRspMsg->snapBeginIndex = pReceiver->snapshotParam.start;
   pRspMsg->payloadType = type;
 
   if (pBlock != NULL && blockLen > 0) {
-    memcpy(pRspMsg->data, pBlock, blockLen);
+    (void)memcpy(pRspMsg->data, pBlock, blockLen);
   }
 
   // send msg
-  if (syncNodeSendMsgById(&pRspMsg->destId, pSyncNode, &rpcMsg) != 0) {
-    sRError(pReceiver, "failed to send snapshot receiver resp since %s", terrstr());
-    return -1;
+  if ((code = syncNodeSendMsgById(&pRspMsg->destId, pSyncNode, &rpcMsg)) != 0) {
+    sRError(pReceiver, "failed to send snapshot receiver resp since %s", tstrerror(code));
+    TAOS_RETURN(code);
   }
   return 0;
 }
@@ -867,13 +863,11 @@ static int32_t syncSnapBufferRecv(SSyncSnapshotReceiver *pReceiver, SyncSnapshot
   int32_t           code = 0;
   SSyncSnapBuffer  *pRcvBuf = pReceiver->pRcvBuf;
   SyncSnapshotSend *pMsg = ppMsg[0];
-  terrno = TSDB_CODE_SUCCESS;
 
-  taosThreadMutexLock(&pRcvBuf->mutex);
+  (void)taosThreadMutexLock(&pRcvBuf->mutex);
 
   if (pMsg->seq - pRcvBuf->start >= pRcvBuf->size) {
-    terrno = TSDB_CODE_SYN_BUFFER_FULL;
-    code = terrno;
+    code = TSDB_CODE_SYN_BUFFER_FULL;
     goto _out;
   }
 
@@ -887,7 +881,7 @@ static int32_t syncSnapBufferRecv(SSyncSnapshotReceiver *pReceiver, SyncSnapshot
     ppMsg[0] = NULL;
     pRcvBuf->end = TMAX(pMsg->seq + 1, pRcvBuf->end);
   } else if (pMsg->seq < pRcvBuf->start) {
-    syncSnapSendRsp(pReceiver, pMsg, NULL, 0, 0, code);
+    code = syncSnapSendRsp(pReceiver, pMsg, NULL, 0, 0, code);
     goto _out;
   }
 
@@ -900,22 +894,21 @@ static int32_t syncSnapBufferRecv(SSyncSnapshotReceiver *pReceiver, SyncSnapshot
   }
 
   for (int64_t seq = pRcvBuf->start; seq <= pRcvBuf->cursor; ++seq) {
-    if (snapshotReceiverGotData(pReceiver, pRcvBuf->entries[seq % pRcvBuf->size]) != 0) {
-      code = terrno;
+    if ((code = snapshotReceiverGotData(pReceiver, pRcvBuf->entries[seq % pRcvBuf->size])) != 0) {
       if (code >= SYNC_SNAPSHOT_SEQ_INVALID) {
         code = TSDB_CODE_SYN_INTERNAL_ERROR;
       }
     }
     pRcvBuf->start = seq + 1;
-    syncSnapSendRsp(pReceiver, pRcvBuf->entries[seq % pRcvBuf->size], NULL, 0, 0, code);
+    (void)syncSnapSendRsp(pReceiver, pRcvBuf->entries[seq % pRcvBuf->size], NULL, 0, 0, code);
     pRcvBuf->entryDeleteCb(pRcvBuf->entries[seq % pRcvBuf->size]);
     pRcvBuf->entries[seq % pRcvBuf->size] = NULL;
     if (code) goto _out;
   }
 
 _out:
-  taosThreadMutexUnlock(&pRcvBuf->mutex);
-  return code;
+  (void)taosThreadMutexUnlock(&pRcvBuf->mutex);
+  TAOS_RETURN(code);
 }
 
 static int32_t syncNodeOnSnapshotReceive(SSyncNode *pSyncNode, SyncSnapshotSend **ppMsg) {
@@ -928,9 +921,9 @@ static int32_t syncNodeOnSnapshotReceive(SSyncNode *pSyncNode, SyncSnapshotSend
   int32_t                code = 0;
 
   if (snapshotReceiverSignatureCmp(pReceiver, pMsg) != 0) {
-    terrno = TSDB_CODE_SYN_MISMATCHED_SIGNATURE;
-    sRError(pReceiver, "failed to receive snapshot data since %s.", terrstr());
-    return syncSnapSendRsp(pReceiver, pMsg, NULL, 0, 0, terrno);
+    code = TSDB_CODE_SYN_MISMATCHED_SIGNATURE;
+    sRError(pReceiver, "failed to receive snapshot data since %s.", tstrerror(code));
+    return syncSnapSendRsp(pReceiver, pMsg, NULL, 0, 0, code);
   }
 
   return syncSnapBufferRecv(pReceiver, ppMsg);
@@ -940,14 +933,13 @@ static int32_t syncNodeOnSnapshotEnd(SSyncNode *pSyncNode, SyncSnapshotSend *pMs
   // condition 2
   // end, finish FSM
   SSyncSnapshotReceiver *pReceiver = pSyncNode->pNewNodeReceiver;
-  int64_t timeNow = taosGetTimestampMs();
+  int64_t                timeNow = taosGetTimestampMs();
   int32_t                code = 0;
 
   if (snapshotReceiverSignatureCmp(pReceiver, pMsg) != 0) {
     sRError(pReceiver, "snapshot end failed since startTime:%" PRId64 " not equal to msg startTime:%" PRId64,
             pReceiver->startTime, pMsg->startTime);
-    terrno = TSDB_CODE_SYN_MISMATCHED_SIGNATURE;
-    code = terrno;
+    code = TSDB_CODE_SYN_MISMATCHED_SIGNATURE;
     goto _SEND_REPLY;
   }
 
@@ -960,9 +952,9 @@ _SEND_REPLY:;
 
   // build msg
   SRpcMsg rpcMsg = {0};
-  if (syncBuildSnapshotSendRsp(&rpcMsg, 0, pSyncNode->vgId) != 0) {
-    sRError(pReceiver, "snapshot receiver build rsp failed since %s", terrstr());
-    return -1;
+  if ((code = syncBuildSnapshotSendRsp(&rpcMsg, 0, pSyncNode->vgId)) != 0) {
+    sRError(pReceiver, "snapshot receiver build rsp failed since %s", tstrerror(code));
+    TAOS_RETURN(code);
   }
 
   SyncSnapshotRsp *pRspMsg = rpcMsg.pCont;
@@ -978,16 +970,16 @@ _SEND_REPLY:;
 
   // send msg
   syncLogSendSyncSnapshotRsp(pSyncNode, pRspMsg, "snapshot receiver end");
-  if (syncNodeSendMsgById(&pRspMsg->destId, pSyncNode, &rpcMsg) != 0) {
-    sRError(pReceiver, "snapshot receiver send rsp failed since %s", terrstr());
-    return -1;
+  if ((code = syncNodeSendMsgById(&pRspMsg->destId, pSyncNode, &rpcMsg)) != 0) {
+    sRError(pReceiver, "snapshot receiver send rsp failed since %s", tstrerror(code));
+    TAOS_RETURN(code);
   }
 
-  return code;
+  TAOS_RETURN(code);
 }
 
 int32_t syncNodeOnSnapshot(SSyncNode *pSyncNode, SRpcMsg *pRpcMsg) {
-  SyncSnapshotSend **ppMsg = (SyncSnapshotSend **)&pRpcMsg->pCont;
+  SyncSnapshotSend     **ppMsg = (SyncSnapshotSend **)&pRpcMsg->pCont;
   SyncSnapshotSend      *pMsg = ppMsg[0];
   SSyncSnapshotReceiver *pReceiver = pSyncNode->pNewNodeReceiver;
   int32_t                code = 0;
@@ -995,35 +987,36 @@ int32_t syncNodeOnSnapshot(SSyncNode *pSyncNode, SRpcMsg *pRpcMsg) {
   // if already drop replica, do not process
   if (!syncNodeInRaftGroup(pSyncNode, &pMsg->srcId)) {
     syncLogRecvSyncSnapshotSend(pSyncNode, pMsg, "not in my config");
-    terrno = TSDB_CODE_SYN_MISMATCHED_SIGNATURE;
-    return -1;
+    code = TSDB_CODE_SYN_MISMATCHED_SIGNATURE;
+    TAOS_RETURN(code);
   }
 
   if (pMsg->term < raftStoreGetTerm(pSyncNode)) {
     sRError(pReceiver, "reject snap replication with smaller term. msg term:%" PRId64 ", seq:%d", pMsg->term,
             pMsg->seq);
-    terrno = TSDB_CODE_SYN_MISMATCHED_SIGNATURE;
-    syncSnapSendRsp(pReceiver, pMsg, NULL, 0, 0, terrno);
-    return -1;
+    code = TSDB_CODE_SYN_MISMATCHED_SIGNATURE;
+    (void)syncSnapSendRsp(pReceiver, pMsg, NULL, 0, 0, code);
+    TAOS_RETURN(code);
   }
 
-  if(pSyncNode->raftCfg.cfg.nodeInfo[pSyncNode->raftCfg.cfg.myIndex].nodeRole != TAOS_SYNC_ROLE_LEARNER){
+  if (pSyncNode->raftCfg.cfg.nodeInfo[pSyncNode->raftCfg.cfg.myIndex].nodeRole != TAOS_SYNC_ROLE_LEARNER) {
     if (pMsg->term > raftStoreGetTerm(pSyncNode)) {
       syncNodeStepDown(pSyncNode, pMsg->term);
     }
-  }
-  else{
+  } else {
     syncNodeUpdateTermWithoutStepDown(pSyncNode, pMsg->term);
   }
 
   if (pSyncNode->state != TAOS_SYNC_STATE_FOLLOWER && pSyncNode->state != TAOS_SYNC_STATE_LEARNER) {
     sRError(pReceiver, "snapshot receiver not a follower or learner");
-    return -1;
+    code = TSDB_CODE_SYN_INTERNAL_ERROR;
+    TAOS_RETURN(code);
   }
 
   if (pMsg->seq < SYNC_SNAPSHOT_SEQ_PREP || pMsg->seq > SYNC_SNAPSHOT_SEQ_END) {
     sRError(pReceiver, "snap replication msg with invalid seq:%d", pMsg->seq);
-    return -1;
+    code = TSDB_CODE_SYN_INVALID_SNAPSHOT_MSG;
+    TAOS_RETURN(code);
   }
 
   // prepare
@@ -1060,14 +1053,14 @@ int32_t syncNodeOnSnapshot(SSyncNode *pSyncNode, SRpcMsg *pRpcMsg) {
 
     code = syncLogBufferReInit(pSyncNode->pLogBuf, pSyncNode);
     if (code != 0) {
-      sRError(pReceiver, "failed to reinit log buffer since %s", terrstr());
+      sRError(pReceiver, "failed to reinit log buffer since %s", tstrerror(code));
     }
     goto _out;
   }
 
 _out:;
   syncNodeResetElectTimer(pSyncNode);
-  return code;
+  TAOS_RETURN(code);
 }
 
 static int32_t syncSnapSenderExchgSnapInfo(SSyncNode *pSyncNode, SSyncSnapshotSender *pSender, SyncSnapshotRsp *pMsg) {
@@ -1076,18 +1069,16 @@ static int32_t syncSnapSenderExchgSnapInfo(SSyncNode *pSyncNode, SSyncSnapshotSe
   SSyncTLV *datHead = (void *)pMsg->data;
   if (datHead->typ != pMsg->payloadType) {
     sSError(pSender, "unexpected data type in data of SyncSnapshotRsp. typ: %d", datHead->typ);
-    terrno = TSDB_CODE_INVALID_DATA_FMT;
-    return -1;
+    TAOS_RETURN(TSDB_CODE_INVALID_DATA_FMT);
   }
   int32_t dataLen = sizeof(SSyncTLV) + datHead->len;
 
   SSnapshotParam *pParam = &pSender->snapshotParam;
   void           *data = taosMemoryRealloc(pParam->data, dataLen);
   if (data == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
+    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
   }
-  memcpy(data, pMsg->data, dataLen);
+  (void)memcpy(data, pMsg->data, dataLen);
 
   pParam->data = data;
   data = NULL;
@@ -1097,19 +1088,18 @@ static int32_t syncSnapSenderExchgSnapInfo(SSyncNode *pSyncNode, SSyncSnapshotSe
 
 // sender
 static int32_t syncNodeOnSnapshotPrepRsp(SSyncNode *pSyncNode, SSyncSnapshotSender *pSender, SyncSnapshotRsp *pMsg) {
-  int32_t   code = -1;
+  int32_t   code = 0;
   SSnapshot snapshot = {0};
 
   if (pMsg->snapBeginIndex > pSyncNode->commitIndex) {
     sSError(pSender,
             "snapshot begin index is greater than commit index. snapBeginIndex:%" PRId64 ", commitIndex:%" PRId64,
             pMsg->snapBeginIndex, pSyncNode->commitIndex);
-    terrno = TSDB_CODE_SYN_INVALID_SNAPSHOT_MSG;
-    return -1;
+    TAOS_RETURN(TSDB_CODE_SYN_INVALID_SNAPSHOT_MSG);
   }
 
-  taosThreadMutexLock(&pSender->pSndBuf->mutex);
-  pSyncNode->pFsm->FpGetSnapshotInfo(pSyncNode->pFsm, &snapshot);
+  (void)taosThreadMutexLock(&pSender->pSndBuf->mutex);
+  TAOS_CHECK_GOTO(pSyncNode->pFsm->FpGetSnapshotInfo(pSyncNode->pFsm, &snapshot), NULL, _out);
 
   // prepare <begin, end>
   pSender->snapshotParam.start = pMsg->snapBeginIndex;
@@ -1123,14 +1113,12 @@ static int32_t syncNodeOnSnapshotPrepRsp(SSyncNode *pSyncNode, SSyncSnapshotSend
 
   // start reader
   if (pMsg->payloadType == TDMT_SYNC_PREP_SNAPSHOT_REPLY) {
-    if (syncSnapSenderExchgSnapInfo(pSyncNode, pSender, pMsg) != 0) {
-      goto _out;
-    }
+    TAOS_CHECK_GOTO(syncSnapSenderExchgSnapInfo(pSyncNode, pSender, pMsg), NULL, _out);
   }
 
   code = pSyncNode->pFsm->FpSnapshotStartRead(pSyncNode->pFsm, &pSender->snapshotParam, &pSender->pReader);
   if (code != 0) {
-    sSError(pSender, "prepare snapshot failed since %s", terrstr());
+    sSError(pSender, "prepare snapshot failed since %s", tstrerror(code));
     goto _out;
   }
 
@@ -1140,8 +1128,8 @@ static int32_t syncNodeOnSnapshotPrepRsp(SSyncNode *pSyncNode, SSyncSnapshotSend
   code = snapshotSend(pSender);
 
 _out:
-  taosThreadMutexUnlock(&pSender->pSndBuf->mutex);
-  return code;
+  (void)taosThreadMutexUnlock(&pSender->pSndBuf->mutex);
+  TAOS_RETURN(code);
 }
 
 static int32_t snapshotSenderSignatureCmp(SSyncSnapshotSender *pSender, SyncSnapshotRsp *pMsg) {
@@ -1157,19 +1145,19 @@ static int32_t syncSnapBufferSend(SSyncSnapshotSender *pSender, SyncSnapshotRsp
   SSyncSnapBuffer *pSndBuf = pSender->pSndBuf;
   SyncSnapshotRsp *pMsg = ppMsg[0];
 
-  taosThreadMutexLock(&pSndBuf->mutex);
+  (void)taosThreadMutexLock(&pSndBuf->mutex);
   if (snapshotSenderSignatureCmp(pSender, pMsg) != 0) {
-    code = terrno = TSDB_CODE_SYN_MISMATCHED_SIGNATURE;
+    code = TSDB_CODE_SYN_MISMATCHED_SIGNATURE;
     goto _out;
   }
 
   if (pSender->pReader == NULL || pSender->finish || !snapshotSenderIsStart(pSender)) {
-    code = terrno = TSDB_CODE_SYN_INTERNAL_ERROR;
+    code = TSDB_CODE_SYN_INTERNAL_ERROR;
     goto _out;
   }
 
   if (pMsg->ack - pSndBuf->start >= pSndBuf->size) {
-    code = terrno = TSDB_CODE_SYN_BUFFER_FULL;
+    code = TSDB_CODE_SYN_BUFFER_FULL;
     goto _out;
   }
 
@@ -1208,50 +1196,48 @@ static int32_t syncSnapBufferSend(SSyncSnapshotSender *pSender, SyncSnapshotRsp
     }
   }
 _out:
-  taosThreadMutexUnlock(&pSndBuf->mutex);
-  return code;
+  (void)taosThreadMutexUnlock(&pSndBuf->mutex);
+  TAOS_RETURN(code);
 }
 
 int32_t syncNodeOnSnapshotRsp(SSyncNode *pSyncNode, SRpcMsg *pRpcMsg) {
   SyncSnapshotRsp **ppMsg = (SyncSnapshotRsp **)&pRpcMsg->pCont;
   SyncSnapshotRsp  *pMsg = ppMsg[0];
+  int32_t           code = 0;
 
   // if already drop replica, do not process
   if (!syncNodeInRaftGroup(pSyncNode, &pMsg->srcId)) {
     syncLogRecvSyncSnapshotRsp(pSyncNode, pMsg, "maybe replica already dropped");
-    terrno = TSDB_CODE_SYN_MISMATCHED_SIGNATURE;
-    return -1;
+    TAOS_RETURN(TSDB_CODE_SYN_MISMATCHED_SIGNATURE);
   }
 
   // get sender
   SSyncSnapshotSender *pSender = syncNodeGetSnapshotSender(pSyncNode, &pMsg->srcId);
   if (pSender == NULL) {
     syncLogRecvSyncSnapshotRsp(pSyncNode, pMsg, "sender is null");
-    terrno = TSDB_CODE_SYN_INTERNAL_ERROR;
-    return -1;
+    TAOS_RETURN(TSDB_CODE_SYN_INTERNAL_ERROR);
   }
 
   if (!snapshotSenderIsStart(pSender)) {
     sSError(pSender, "snapshot sender stopped. sender startTime:%" PRId64 ", msg startTime:%" PRId64,
             pSender->startTime, pMsg->startTime);
-    return -1;
+    TAOS_RETURN(TSDB_CODE_SYN_INTERNAL_ERROR);
   }
 
   // check signature
   int32_t order = 0;
   if ((order = snapshotSenderSignatureCmp(pSender, pMsg)) > 0) {
     sSWarn(pSender, "ignore a stale snap rsp, msg signature:(%" PRId64 ", %" PRId64 ").", pMsg->term, pMsg->startTime);
-    terrno = TSDB_CODE_SYN_MISMATCHED_SIGNATURE;
-    return -1;
+    TAOS_RETURN(TSDB_CODE_SYN_MISMATCHED_SIGNATURE);
   } else if (order < 0) {
     sSError(pSender, "snapshot sender is stale. stop");
-    terrno = TSDB_CODE_SYN_MISMATCHED_SIGNATURE;
+    code = TSDB_CODE_SYN_MISMATCHED_SIGNATURE;
     goto _ERROR;
   }
 
   if (pSyncNode->state != TAOS_SYNC_STATE_LEADER && pSyncNode->state != TAOS_SYNC_STATE_ASSIGNED_LEADER) {
     sSError(pSender, "snapshot sender not leader");
-    terrno = TSDB_CODE_SYN_NOT_LEADER;
+    code = TSDB_CODE_SYN_NOT_LEADER;
     goto _ERROR;
   }
 
@@ -1259,29 +1245,29 @@ int32_t syncNodeOnSnapshotRsp(SSyncNode *pSyncNode, SRpcMsg *pRpcMsg) {
   if (pMsg->term != currentTerm) {
     sSError(pSender, "snapshot sender term mismatch, msg term:%" PRId64 " currentTerm:%" PRId64, pMsg->term,
             currentTerm);
-    terrno = TSDB_CODE_SYN_MISMATCHED_SIGNATURE;
+    code = TSDB_CODE_SYN_MISMATCHED_SIGNATURE;
     goto _ERROR;
   }
 
   if (pMsg->code != 0) {
     sSError(pSender, "snapshot sender receive error:%s 0x%x and stop sender", tstrerror(pMsg->code), pMsg->code);
-    terrno = pMsg->code;
+    code = pMsg->code;
     goto _ERROR;
   }
 
   // send begin
   if (pMsg->ack == SYNC_SNAPSHOT_SEQ_PREP) {
     sSInfo(pSender, "process prepare rsp");
-    if (syncNodeOnSnapshotPrepRsp(pSyncNode, pSender, pMsg) != 0) {
+    if ((code = syncNodeOnSnapshotPrepRsp(pSyncNode, pSender, pMsg)) != 0) {
       goto _ERROR;
     }
   }
 
   // send msg of data or end
   if (pMsg->ack >= SYNC_SNAPSHOT_SEQ_BEGIN && pMsg->ack < SYNC_SNAPSHOT_SEQ_END) {
-    if (syncSnapBufferSend(pSender, ppMsg) != 0) {
-      sSError(pSender, "failed to replicate snap since %s. seq:%d, pReader:%p, finish:%d", terrstr(), pSender->seq,
-              pSender->pReader, pSender->finish);
+    if ((code = syncSnapBufferSend(pSender, ppMsg)) != 0) {
+      sSError(pSender, "failed to replicate snap since %s. seq:%d, pReader:%p, finish:%d", tstrerror(code),
+              pSender->seq, pSender->pReader, pSender->finish);
       goto _ERROR;
     }
   }
@@ -1298,5 +1284,5 @@ int32_t syncNodeOnSnapshotRsp(SSyncNode *pSyncNode, SRpcMsg *pRpcMsg) {
 _ERROR:
   snapshotSenderStop(pSender, false);
   syncNodeReplicateReset(pSyncNode, &pMsg->srcId);
-  return -1;
+  TAOS_RETURN(code);
 }
diff --git a/source/libs/sync/src/syncTimeout.c b/source/libs/sync/src/syncTimeout.c
index dbbd914041..b2233ae664 100644
--- a/source/libs/sync/src/syncTimeout.c
+++ b/source/libs/sync/src/syncTimeout.c
@@ -65,7 +65,7 @@ static int32_t syncNodeTimerRoutine(SSyncNode* ths) {
   }
 
   // timer replicate
-  syncNodeReplicate(ths);
+  (void)syncNodeReplicate(ths);
 
   // clean mnode index
   if (syncNodeIsMnode(ths)) {
@@ -89,7 +89,7 @@ static int32_t syncNodeTimerRoutine(SSyncNode* ths) {
           snapshotSenderStop(pSender, false);
         } else {
           sSWarn(pSender, "snap replication resend.");
-          snapshotReSend(pSender);
+          (void)snapshotReSend(pSender);
         }
       }
     }
@@ -112,14 +112,14 @@ int32_t syncNodeOnTimeout(SSyncNode* ths, const SRpcMsg* pRpc) {
     if (atomic_load_64(&ths->pingTimerLogicClockUser) <= pMsg->logicClock) {
       ++(ths->pingTimerCounter);
 
-      syncNodeTimerRoutine(ths);
+      (void)syncNodeTimerRoutine(ths);
     }
 
   } else if (pMsg->timeoutType == SYNC_TIMEOUT_ELECTION) {
     if (atomic_load_64(&ths->electTimerLogicClock) <= pMsg->logicClock) {
       ++(ths->electTimerCounter);
 
-      syncNodeElect(ths);
+      (void)syncNodeElect(ths);
     }
 
   } else if (pMsg->timeoutType == SYNC_TIMEOUT_HEARTBEAT) {
diff --git a/source/libs/sync/src/syncUtil.c b/source/libs/sync/src/syncUtil.c
index 6ac29739c2..2076de6ec7 100644
--- a/source/libs/sync/src/syncUtil.c
+++ b/source/libs/sync/src/syncUtil.c
@@ -103,10 +103,10 @@ bool syncUtilUserPreCommit(tmsg_t msgType) { return msgType != TDMT_SYNC_NOOP &&
 bool syncUtilUserRollback(tmsg_t msgType) { return msgType != TDMT_SYNC_NOOP && msgType != TDMT_SYNC_LEADER_TRANSFER; }
 
 void syncUtilGenerateArbToken(int32_t nodeId, int32_t groupId, char* buf) {
-  memset(buf, 0, TSDB_ARB_TOKEN_SIZE);
+  (void)memset(buf, 0, TSDB_ARB_TOKEN_SIZE);
   int32_t randVal = taosSafeRand() % 1000;
   int64_t currentMs = taosGetTimestampMs();
-  snprintf(buf, TSDB_ARB_TOKEN_SIZE, "d%d#g%d#%" PRId64 "#%d", nodeId, groupId, currentMs, randVal);
+  (void)snprintf(buf, TSDB_ARB_TOKEN_SIZE, "d%d#g%d#%" PRId64 "#%d", nodeId, groupId, currentMs, randVal);
 }
 
 // for leader
diff --git a/source/libs/sync/src/syncVoteMgr.c b/source/libs/sync/src/syncVoteMgr.c
index 83b0dde8e0..64f66c27a4 100644
--- a/source/libs/sync/src/syncVoteMgr.c
+++ b/source/libs/sync/src/syncVoteMgr.c
@@ -19,7 +19,7 @@
 #include "syncUtil.h"
 
 static void voteGrantedClearVotes(SVotesGranted *pVotesGranted) {
-  memset(pVotesGranted->isGranted, 0, sizeof(pVotesGranted->isGranted));
+  (void)memset(pVotesGranted->isGranted, 0, sizeof(pVotesGranted->isGranted));
   pVotesGranted->votes = 0;
 }
 
@@ -165,5 +165,5 @@ void votesRespondAdd(SVotesRespond *pVotesRespond, const SyncRequestVoteReply *p
 
 void votesRespondReset(SVotesRespond *pVotesRespond, SyncTerm term) {
   pVotesRespond->term = term;
-  memset(pVotesRespond->isRespond, 0, sizeof(pVotesRespond->isRespond));
+  (void)memset(pVotesRespond->isRespond, 0, sizeof(pVotesRespond->isRespond));
 }
diff --git a/source/libs/sync/test/syncRespMgrTest.cpp b/source/libs/sync/test/syncRespMgrTest.cpp
index 74246abf62..714f42a836 100644
--- a/source/libs/sync/test/syncRespMgrTest.cpp
+++ b/source/libs/sync/test/syncRespMgrTest.cpp
@@ -77,7 +77,7 @@ SSyncNode *createSyncNode() {
 
 void test1() {
   printf("------- test1 ---------\n");
-  pMgr = syncRespMgrCreate(createSyncNode(), 0);
+  (void)syncRespMgrCreate(createSyncNode(), 0, &pMgr);
   assert(pMgr != NULL);
 
   syncRespMgrInsert(10);
@@ -102,7 +102,7 @@ void test1() {
 
 void test2() {
   printf("------- test2 ---------\n");
-  pMgr = syncRespMgrCreate(createSyncNode(), 0);
+  (void)syncRespMgrCreate(createSyncNode(), 0, &pMgr);
   assert(pMgr != NULL);
 
   syncRespMgrInsert(10);
@@ -119,7 +119,7 @@ void test2() {
 
 void test3() {
   printf("------- test3 ---------\n");
-  pMgr = syncRespMgrCreate(createSyncNode(), 0);
+  (void)syncRespMgrCreate(createSyncNode(), 0, &pMgr);
   assert(pMgr != NULL);
 
   syncRespMgrInsert(10);
@@ -136,7 +136,7 @@ void test3() {
 
 void test4() {
   printf("------- test4 ---------\n");
-  pMgr = syncRespMgrCreate(createSyncNode(), 2);
+  (void)syncRespMgrCreate(createSyncNode(), 2, &pMgr);
   assert(pMgr != NULL);
 
   syncRespMgrInsert(5);
diff --git a/source/libs/sync/test/syncSnapshotReceiverTest.cpp b/source/libs/sync/test/syncSnapshotReceiverTest.cpp
index 1fca04a1ad..112c145a45 100644
--- a/source/libs/sync/test/syncSnapshotReceiverTest.cpp
+++ b/source/libs/sync/test/syncSnapshotReceiverTest.cpp
@@ -42,7 +42,8 @@ SSyncSnapshotReceiver* createReceiver() {
   id.addr = syncUtilAddr2U64("1.2.3.4", 99);
   id.vgId = 100;
 
-  SSyncSnapshotReceiver* pReceiver = snapshotReceiverCreate(pSyncNode, id);
+  SSyncSnapshotReceiver* pReceiver = NULL;
+  (void)snapshotReceiverCreate(pSyncNode, id, &pReceiver);
   pReceiver->start = true;
   pReceiver->ack = 20;
   pReceiver->pWriter = (void*)0x11;
diff --git a/source/libs/sync/test/syncSnapshotSenderTest.cpp b/source/libs/sync/test/syncSnapshotSenderTest.cpp
index a1768c2ce5..be31df30e9 100644
--- a/source/libs/sync/test/syncSnapshotSenderTest.cpp
+++ b/source/libs/sync/test/syncSnapshotSenderTest.cpp
@@ -39,7 +39,8 @@ SSyncSnapshotSender* createSender() {
   pSyncNode->pFsm->FpGetSnapshotInfo = GetSnapshot;
 #endif
 
-  SSyncSnapshotSender* pSender = snapshotSenderCreate(pSyncNode, 2);
+  SSyncSnapshotSender* pSender = NULL;
+  (void)snapshotSenderCreate(pSyncNode, 2, &pSender);
   pSender->start = true;
   pSender->seq = 10;
   pSender->ack = 20;
diff --git a/source/libs/tfs/src/tfs.c b/source/libs/tfs/src/tfs.c
index 81c853e546..ede7636011 100644
--- a/source/libs/tfs/src/tfs.c
+++ b/source/libs/tfs/src/tfs.c
@@ -81,7 +81,7 @@ void tfsClose(STfs *pTfs) {
   }
 
   taosHashCleanup(pTfs->hash);
-  taosThreadSpinDestroy(&pTfs->lock);
+  (void)taosThreadSpinDestroy(&pTfs->lock);
   taosMemoryFree(pTfs);
 }
 
@@ -96,15 +96,15 @@ void tfsUpdateSize(STfs *pTfs) {
     size.used += pTier->size.used;
   }
 
-  tfsLock(pTfs);
+  (void)tfsLock(pTfs);
   pTfs->size = size;
-  tfsUnLock(pTfs);
+  (void)tfsUnLock(pTfs);
 }
 
 SDiskSize tfsGetSize(STfs *pTfs) {
-  tfsLock(pTfs);
+  (void)tfsLock(pTfs);
   SDiskSize size = pTfs->size;
-  tfsUnLock(pTfs);
+  (void)tfsUnLock(pTfs);
 
   return size;
 }
@@ -190,7 +190,7 @@ void tfsInitFile(STfs *pTfs, STfsFile *pFile, SDiskID diskId, const char *rname)
   tstrncpy(pFile->rname, rname, TSDB_FILENAME_LEN);
 
   char tmpName[TMPNAME_LEN] = {0};
-  snprintf(tmpName, TMPNAME_LEN, "%s%s%s", pDisk->path, TD_DIRSEP, rname);
+  (void)snprintf(tmpName, TMPNAME_LEN, "%s%s%s", pDisk->path, TD_DIRSEP, rname);
   tstrncpy(pFile->aname, tmpName, TSDB_FILENAME_LEN);
   pFile->pTfs = pTfs;
 }
@@ -200,12 +200,12 @@ bool tfsIsSameFile(const STfsFile *pFile1, const STfsFile *pFile2) {
   if (pFile1->did.level != pFile2->did.level) return false;
   if (pFile1->did.id != pFile2->did.id) return false;
   char nameBuf1[TMPNAME_LEN], nameBuf2[TMPNAME_LEN];
-  strncpy(nameBuf1, pFile1->rname, TMPNAME_LEN);
-  strncpy(nameBuf2, pFile2->rname, TMPNAME_LEN);
+  (void)strncpy(nameBuf1, pFile1->rname, TMPNAME_LEN);
+  (void)strncpy(nameBuf2, pFile2->rname, TMPNAME_LEN);
   nameBuf1[TMPNAME_LEN - 1] = 0;
   nameBuf2[TMPNAME_LEN - 1] = 0;
-  taosRealPath(nameBuf1, NULL, TMPNAME_LEN);
-  taosRealPath(nameBuf2, NULL, TMPNAME_LEN);
+  (void)taosRealPath(nameBuf1, NULL, TMPNAME_LEN);
+  (void)taosRealPath(nameBuf2, NULL, TMPNAME_LEN);
   if (strncmp(nameBuf1, nameBuf2, TMPNAME_LEN) != 0) return false;
   return true;
 }
@@ -251,7 +251,7 @@ void tfsDirname(const STfsFile *pFile, char *dest) {
 void tfsAbsoluteName(STfs *pTfs, SDiskID diskId, const char *rname, char *aname) {
   STfsDisk *pDisk = TFS_DISK_AT(pTfs, diskId);
 
-  snprintf(aname, TSDB_FILENAME_LEN, "%s%s%s", pDisk->path, TD_DIRSEP, rname);
+  (void)snprintf(aname, TSDB_FILENAME_LEN, "%s%s%s", pDisk->path, TD_DIRSEP, rname);
 }
 
 int32_t tfsRemoveFile(const STfsFile *pFile) { return taosRemoveFile(pFile->aname); }
@@ -267,7 +267,7 @@ int32_t tfsMkdirAt(STfs *pTfs, const char *rname, SDiskID diskId) {
   if (pDisk == NULL) {
     TAOS_RETURN(TSDB_CODE_FS_INVLD_CFG);
   }
-  snprintf(aname, TMPNAME_LEN, "%s%s%s", pDisk->path, TD_DIRSEP, rname);
+  (void)snprintf(aname, TMPNAME_LEN, "%s%s%s", pDisk->path, TD_DIRSEP, rname);
   if (taosMkDir(aname) != 0) {
     TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
   }
@@ -347,7 +347,7 @@ bool tfsDirExistAt(STfs *pTfs, const char *rname, SDiskID diskId) {
   STfsDisk *pDisk = TFS_DISK_AT(pTfs, diskId);
   char      aname[TMPNAME_LEN];
 
-  snprintf(aname, TMPNAME_LEN, "%s%s%s", pDisk->path, TD_DIRSEP, rname);
+  (void)snprintf(aname, TMPNAME_LEN, "%s%s%s", pDisk->path, TD_DIRSEP, rname);
   return taosDirExist(aname);
 }
 
@@ -362,7 +362,7 @@ int32_t tfsRmdir(STfs *pTfs, const char *rname) {
     STfsTier *pTier = TFS_TIER_AT(pTfs, level);
     for (int32_t id = 0; id < pTier->ndisk; id++) {
       STfsDisk *pDisk = pTier->disks[id];
-      snprintf(aname, TMPNAME_LEN, "%s%s%s", pDisk->path, TD_DIRSEP, rname);
+      (void)snprintf(aname, TMPNAME_LEN, "%s%s%s", pDisk->path, TD_DIRSEP, rname);
       uInfo("tfs remove dir:%s aname:%s rname:[%s]", pDisk->path, aname, rname);
       taosRemoveDir(aname);
     }
@@ -379,8 +379,8 @@ static int32_t tfsRenameAt(STfs *pTfs, SDiskID diskId, const char *orname, const
   int32_t   id = diskId.id;
   STfsTier *pTier = TFS_TIER_AT(pTfs, level);
   STfsDisk *pDisk = pTier->disks[id];
-  snprintf(oaname, TMPNAME_LEN, "%s%s%s", pDisk->path, TD_DIRSEP, orname);
-  snprintf(naname, TMPNAME_LEN, "%s%s%s", pDisk->path, TD_DIRSEP, nrname);
+  (void)snprintf(oaname, TMPNAME_LEN, "%s%s%s", pDisk->path, TD_DIRSEP, orname);
+  (void)snprintf(naname, TMPNAME_LEN, "%s%s%s", pDisk->path, TD_DIRSEP, nrname);
 
   if (taosRenameFile(oaname, naname) != 0 && errno != ENOENT) {
     int32_t code = TAOS_SYSTEM_ERROR(errno);  // TODO: use return value of taosRenameFile directly
@@ -417,7 +417,7 @@ int32_t tfsSearch(STfs *pTfs, int32_t level, const char *fname) {
 
   for (int32_t id = 0; id < pTier->ndisk; id++) {
     STfsDisk *pDisk = pTier->disks[id];
-    snprintf(path, TMPNAME_LEN - 1, "%s%s%s", pDisk->path, TD_DIRSEP, fname);
+    (void)snprintf(path, TMPNAME_LEN - 1, "%s%s%s", pDisk->path, TD_DIRSEP, fname);
     if (taosCheckExistFile(path)) {
       return id;
     }
@@ -460,9 +460,9 @@ const STfsFile *tfsReaddir(STfsDir *pTfsDir) {
       if (strcmp(name, ".") == 0 || strcmp(name, "..") == 0) continue;
 
       if (pTfsDir->dirName[0] == 0) {
-        snprintf(bname, TMPNAME_LEN * 2, "%s", name);
+        (void)snprintf(bname, TMPNAME_LEN * 2, "%s", name);
       } else {
-        snprintf(bname, TMPNAME_LEN * 2, "%s%s%s", pTfsDir->dirName, TD_DIRSEP, name);
+        (void)snprintf(bname, TMPNAME_LEN * 2, "%s%s%s", pTfsDir->dirName, TD_DIRSEP, name);
       }
 
       tfsInitFile(pTfsDir->pTfs, &pTfsDir->tfile, pTfsDir->did, bname);
@@ -655,9 +655,9 @@ static int32_t tfsOpendirImpl(STfs *pTfs, STfsDir *pTfsDir) {
     pTfsDir->did.id = pDisk->id;
 
     if (pDisk->path == NULL || pDisk->path[0] == 0) {
-      snprintf(adir, TMPNAME_LEN * 2, "%s", pTfsDir->dirName);
+      (void)snprintf(adir, TMPNAME_LEN * 2, "%s", pTfsDir->dirName);
     } else {
-      snprintf(adir, TMPNAME_LEN * 2, "%s%s%s", pDisk->path, TD_DIRSEP, pTfsDir->dirName);
+      (void)snprintf(adir, TMPNAME_LEN * 2, "%s%s%s", pDisk->path, TD_DIRSEP, pTfsDir->dirName);
     }
     pTfsDir->pDir = taosOpenDir(adir);
     if (pTfsDir->pDir != NULL) break;
@@ -698,7 +698,7 @@ int32_t tfsGetMonitorInfo(STfs *pTfs, SMonDiskInfo *pInfo) {
 
   tfsUpdateSize(pTfs);
 
-  tfsLock(pTfs);
+  (void)tfsLock(pTfs);
   for (int32_t level = 0; level < pTfs->nlevel; level++) {
     STfsTier *pTier = &pTfs->tiers[level];
     for (int32_t disk = 0; disk < pTier->ndisk; ++disk) {
@@ -708,14 +708,14 @@ int32_t tfsGetMonitorInfo(STfs *pTfs, SMonDiskInfo *pInfo) {
       dinfo.level = pDisk->level;
       tstrncpy(dinfo.name, pDisk->path, sizeof(dinfo.name));
       if (taosArrayPush(pInfo->datadirs, &dinfo) == NULL) {
-        tfsUnLock(pTfs);
+        (void)tfsUnLock(pTfs);
         taosArrayDestroy(pInfo->datadirs);
         pInfo->datadirs = NULL;
         TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
       }
     }
   }
-  tfsUnLock(pTfs);
+  (void)tfsUnLock(pTfs);
 
   TAOS_RETURN(0);
 }
diff --git a/source/libs/tfs/src/tfsTier.c b/source/libs/tfs/src/tfsTier.c
index 685f95c517..0733e3c76a 100644
--- a/source/libs/tfs/src/tfsTier.c
+++ b/source/libs/tfs/src/tfsTier.c
@@ -19,7 +19,7 @@
 extern int64_t tsMinDiskFreeSize;
 
 int32_t tfsInitTier(STfsTier *pTier, int32_t level) {
-  memset(pTier, 0, sizeof(STfsTier));
+  (void)memset(pTier, 0, sizeof(STfsTier));
 
   if (taosThreadSpinInit(&pTier->lock, 0) != 0) {
     TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
@@ -35,7 +35,7 @@ void tfsDestroyTier(STfsTier *pTier) {
   }
 
   pTier->ndisk = 0;
-  taosThreadSpinDestroy(&pTier->lock);
+  (void)taosThreadSpinDestroy(&pTier->lock);
 }
 
 int32_t tfsMountDiskToTier(STfsTier *pTier, SDiskCfg *pCfg, STfsDisk **ppDisk) {
@@ -88,7 +88,7 @@ void tfsUpdateTierSize(STfsTier *pTier) {
   SDiskSize size = {0};
   int32_t   nAvailDisks = 0;
 
-  tfsLockTier(pTier);
+  (void)tfsLockTier(pTier);
 
   for (int32_t id = 0; id < pTier->ndisk; id++) {
     STfsDisk *pDisk = pTier->disks[id];
@@ -104,15 +104,15 @@ void tfsUpdateTierSize(STfsTier *pTier) {
   pTier->size = size;
   pTier->nAvailDisks = nAvailDisks;
 
-  tfsUnLockTier(pTier);
+  (void)tfsUnLockTier(pTier);
 }
 
 // Round-Robin to allocate disk on a tier
 int32_t tfsAllocDiskOnTier(STfsTier *pTier) {
-  tfsLockTier(pTier);
+  (void)tfsLockTier(pTier);
 
   if (pTier->ndisk <= 0 || pTier->nAvailDisks <= 0) {
-    tfsUnLockTier(pTier);
+    (void)tfsUnLockTier(pTier);
     TAOS_RETURN(TSDB_CODE_FS_NO_VALID_DISK);
   }
 
@@ -155,7 +155,7 @@ int32_t tfsAllocDiskOnTier(STfsTier *pTier) {
 #endif
   }
 
-  tfsUnLockTier(pTier);
+  (void)tfsUnLockTier(pTier);
   if (retId < 0) {
     TAOS_RETURN(TSDB_CODE_FS_NO_VALID_DISK);
   }
diff --git a/source/os/src/osFile.c b/source/os/src/osFile.c
index ea13b45e40..821488c90c 100644
--- a/source/os/src/osFile.c
+++ b/source/os/src/osFile.c
@@ -1158,6 +1158,7 @@ TdFilePtr taosOpenFile(const char *path, int32_t tdFileOptions) {
     if (fd >= 0) (void)close(fd);
 #endif
     if (fp != NULL) (void)fclose(fp);
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
     return NULL;
   }
 
diff --git a/source/util/src/tbase58.c b/source/util/src/tbase58.c
index 274249badf..b5d873f5ea 100644
--- a/source/util/src/tbase58.c
+++ b/source/util/src/tbase58.c
@@ -67,7 +67,7 @@ int32_t base58_encode(const uint8_t *value, int32_t vlen, char **result) {
     if (bfree) taosMemoryFree(pbuf);
     return TSDB_CODE_OUT_OF_MEMORY;
   }
-  memset(pResult, '1', nz);
+  (void)memset(pResult, '1', nz);
   while (pi != pbuf + size) pResult[nz++] = basis_58[*pi++];
 
   if (bfree) taosMemoryFree(pbuf);
@@ -152,7 +152,7 @@ int32_t base58_decode(const char *value, size_t inlen, int32_t *outlen, uint8_t
     return TSDB_CODE_OUT_OF_MEMORY;
   }
 
-  memset(pResult, 0, nz);
+  (void)memset(pResult, 0, nz);
   while (it != pbuf + size) pResult[nz++] = *it++;
 
   if (outlen) *outlen = nz;