diff --git a/include/util/tutil.h b/include/util/tutil.h
index b97d2ff39d..2aa28ac1df 100644
--- a/include/util/tutil.h
+++ b/include/util/tutil.h
@@ -172,18 +172,6 @@ static FORCE_INLINE int32_t taosGetTbHashVal(const char *tbname, int32_t tblen,
     }                                     \
   } while (0)
 
-#define TAOS_CHECK_EXEC_GOTO(CMD, LINO, EXEC, LABEL) \
-  do {                                               \
-    code = (CMD);                                    \
-    if (code != TSDB_CODE_SUCCESS) {                 \
-      if (LINO) {                                    \
-        *((int32_t *)(LINO)) = __LINE__;             \
-      }                                              \
-      (EXEC);                                        \
-      goto LABEL;                                    \
-    }                                                \
-  } while (0)
-
 #define TAOS_UNUSED(expr) (void)(expr)
 
 #ifdef __cplusplus
diff --git a/source/dnode/mnode/impl/inc/mndUser.h b/source/dnode/mnode/impl/inc/mndUser.h
index a443673a35..5043f6da3d 100644
--- a/source/dnode/mnode/impl/inc/mndUser.h
+++ b/source/dnode/mnode/impl/inc/mndUser.h
@@ -27,22 +27,22 @@ enum {
   IP_WHITE_ADD,
   IP_WHITE_DROP,
 };
-int32_t   mndInitUser(SMnode *pMnode);
-void      mndCleanupUser(SMnode *pMnode);
-int32_t   mndAcquireUser(SMnode *pMnode, const char *userName, SUserObj **ppUser);
-void      mndReleaseUser(SMnode *pMnode, SUserObj *pUser);
+int32_t mndInitUser(SMnode *pMnode);
+void    mndCleanupUser(SMnode *pMnode);
+int32_t mndAcquireUser(SMnode *pMnode, const char *userName, SUserObj **ppUser);
+void    mndReleaseUser(SMnode *pMnode, SUserObj *pUser);
 
 // for trans test
-SSdbRaw  *mndUserActionEncode(SUserObj *pUser);
-int32_t   mndDupDbHash(SHashObj *pOld, SHashObj **ppNew);
-int32_t   mndDupTableHash(SHashObj *pOld, SHashObj **ppNew);
-int32_t mndDupTopicHash(SHashObj *pOld, SHashObj **ppNew);
-int32_t   mndValidateUserAuthInfo(SMnode *pMnode, SUserAuthVersion *pUsers, int32_t numOfUses, void **ppRsp,
-                                  int32_t *pRspLen, int64_t ipWhiteListVer);
-int32_t   mndUserRemoveDb(SMnode *pMnode, STrans *pTrans, char *db);
-int32_t   mndUserRemoveStb(SMnode *pMnode, STrans *pTrans, char *stb);
-int32_t   mndUserRemoveView(SMnode *pMnode, STrans *pTrans, char *view);
-int32_t   mndUserRemoveTopic(SMnode *pMnode, STrans *pTrans, char *topic);
+SSdbRaw *mndUserActionEncode(SUserObj *pUser);
+int32_t  mndDupDbHash(SHashObj *pOld, SHashObj **ppNew);
+int32_t  mndDupTableHash(SHashObj *pOld, SHashObj **ppNew);
+int32_t  mndDupTopicHash(SHashObj *pOld, SHashObj **ppNew);
+int32_t  mndValidateUserAuthInfo(SMnode *pMnode, SUserAuthVersion *pUsers, int32_t numOfUses, void **ppRsp,
+                                 int32_t *pRspLen, int64_t ipWhiteListVer);
+int32_t  mndUserRemoveDb(SMnode *pMnode, STrans *pTrans, char *db);
+int32_t  mndUserRemoveStb(SMnode *pMnode, STrans *pTrans, char *stb);
+int32_t  mndUserRemoveView(SMnode *pMnode, STrans *pTrans, char *view);
+int32_t  mndUserRemoveTopic(SMnode *pMnode, STrans *pTrans, char *topic);
 
 int32_t mndUserDupObj(SUserObj *pUser, SUserObj *pNew);
 void    mndUserFreeObj(SUserObj *pUser);
diff --git a/source/dnode/mnode/impl/src/mndUser.c b/source/dnode/mnode/impl/src/mndUser.c
index c47e2e03a7..a019533133 100644
--- a/source/dnode/mnode/impl/src/mndUser.c
+++ b/source/dnode/mnode/impl/src/mndUser.c
@@ -95,11 +95,11 @@
 #define ALTER_USER_DEL_SUBSCRIBE_TOPIC_PRIV(_type, _priv) \
   (ALTER_USER_DEL_PRIVS(_type) && ALTER_USER_SUBSCRIBE_PRIV(_priv))
 
-static SIpWhiteList *createDefaultIpWhiteList();
-SIpWhiteList        *createIpWhiteList(void *buf, int32_t len);
-static bool          updateIpWhiteList(SIpWhiteList *pOld, SIpWhiteList *pNew);
-static bool          isIpWhiteListEqual(SIpWhiteList *a, SIpWhiteList *b);
-static bool          isIpRangeEqual(SIpV4Range *a, SIpV4Range *b);
+static int32_t createDefaultIpWhiteList(SIpWhiteList **ppWhiteList);
+SIpWhiteList  *createIpWhiteList(void *buf, int32_t len);
+static bool    updateIpWhiteList(SIpWhiteList *pOld, SIpWhiteList *pNew);
+static bool    isIpWhiteListEqual(SIpWhiteList *a, SIpWhiteList *b);
+static bool    isIpRangeEqual(SIpV4Range *a, SIpV4Range *b);
 
 void destroyIpWhiteTab(SHashObj *pIpWhiteTab);
 
@@ -645,20 +645,24 @@ SIpWhiteList *createIpWhiteList(void *buf, int32_t len) {
   return p;
 }
 
-static SIpWhiteList *createDefaultIpWhiteList() {
-  SIpWhiteList *pWhiteList = taosMemoryCalloc(1, sizeof(SIpWhiteList) + sizeof(SIpV4Range) * 1);
-  pWhiteList->num = 1;
-  SIpV4Range *range = &(pWhiteList->pIpRange[0]);
+static int32_t createDefaultIpWhiteList(SIpWhiteList **ppWhiteList) {
+  *ppWhiteList = taosMemoryCalloc(1, sizeof(SIpWhiteList) + sizeof(SIpV4Range) * 1);
+  if (*ppWhiteList == NULL) {
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+  (*ppWhiteList)->num = 1;
+  SIpV4Range *range = &((*ppWhiteList)->pIpRange[0]);
 
   struct in_addr addr;
   if (uv_inet_pton(AF_INET, "127.0.0.1", &addr) == 0) {
     range->ip = addr.s_addr;
     range->mask = 32;
   }
-  return pWhiteList;
+  return 0;
 }
 
 static int32_t mndCreateDefaultUser(SMnode *pMnode, char *acct, char *user, char *pass) {
+  int32_t  code = 0;
   SUserObj userObj = {0};
   taosEncryptPass_c((uint8_t *)pass, strlen(pass), userObj.pass);
   tstrncpy(userObj.user, user, TSDB_USER_LEN);
@@ -668,7 +672,7 @@ static int32_t mndCreateDefaultUser(SMnode *pMnode, char *acct, char *user, char
   userObj.sysInfo = 1;
   userObj.enable = 1;
   userObj.ipWhiteListVer = taosGetTimestampMs();
-  userObj.pIpWhiteList = createDefaultIpWhiteList();
+  TAOS_CHECK_RETURN(createDefaultIpWhiteList(&userObj.pIpWhiteList));
   if (strcmp(user, TSDB_DEFAULT_USER) == 0) {
     userObj.superUser = 1;
     userObj.createdb = 1;
@@ -830,7 +834,10 @@ SSdbRaw *mndUserActionEncode(SUserObj *pUser) {
   }
 
   SSdbRaw *pRaw = sdbAllocRaw(SDB_USER, USER_VER_NUMBER, size);
-  if (pRaw == NULL) goto _OVER;
+  if (pRaw == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    goto _OVER;
+  }
 
   int32_t dataPos = 0;
   SDB_SET_BINARY(pRaw, dataPos, pUser->user, TSDB_USER_LEN, _OVER)
@@ -973,6 +980,10 @@ SSdbRaw *mndUserActionEncode(SUserObj *pUser) {
   int32_t num = pUser->pIpWhiteList->num;
   int32_t tlen = sizeof(SIpWhiteList) + num * sizeof(SIpV4Range) + 4;
   char   *buf = taosMemoryCalloc(1, tlen);
+  if (buf == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    goto _OVER;
+  }
   int32_t len = tSerializeIpWhiteList(buf, tlen, pUser->pIpWhiteList);
 
   SDB_SET_INT32(pRaw, dataPos, len, _OVER);
@@ -1306,12 +1317,11 @@ static int32_t mndUserActionInsert(SSdb *pSdb, SUserObj *pUser) {
 }
 
 int32_t mndDupTableHash(SHashObj *pOld, SHashObj **ppNew) {
+  int32_t code = 0;
   *ppNew =
       taosHashInit(taosHashGetSize(pOld), taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
   if (*ppNew == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return NULL;
-    TAOS_CHECK_RETURN(NULL);
+    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
   }
 
   char *tb = taosHashIterate(pOld, NULL);
@@ -1320,24 +1330,24 @@ int32_t mndDupTableHash(SHashObj *pOld, SHashObj **ppNew) {
     char  *key = taosHashGetKey(tb, &keyLen);
 
     int32_t valueLen = strlen(tb) + 1;
-    if (taosHashPut(pNew, key, keyLen, tb, valueLen) != 0) {
+    if ((code = taosHashPut(*ppNew, key, keyLen, tb, valueLen)) != 0) {
       taosHashCancelIterate(pOld, tb);
-      taosHashCleanup(pNew);
-      terrno = TSDB_CODE_OUT_OF_MEMORY;
-      return NULL;
+      taosHashCleanup(*ppNew);
+      code = terrno ? terrno : TSDB_CODE_OUT_OF_MEMORY;  // TODO: remove this line after terrno is removed
+      TAOS_RETURN(code);
     }
     tb = taosHashIterate(pOld, tb);
   }
 
-  return pNew;
+  TAOS_RETURN(code);
 }
 
-SHashObj *mndDupUseDbHash(SHashObj *pOld) {
-  SHashObj *pNew =
+int32_t mndDupUseDbHash(SHashObj *pOld, SHashObj **ppNew) {
+  int32_t code = 0;
+  *ppNew =
       taosHashInit(taosHashGetSize(pOld), taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
-  if (pNew == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return NULL;
+  if (*ppNew == NULL) {
+    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
   }
 
   int32_t *db = taosHashIterate(pOld, NULL);
@@ -1345,42 +1355,43 @@ SHashObj *mndDupUseDbHash(SHashObj *pOld) {
     size_t keyLen = 0;
     char  *key = taosHashGetKey(db, &keyLen);
 
-    if (taosHashPut(pNew, key, keyLen, db, sizeof(*db)) != 0) {
+    if ((code = taosHashPut(*ppNew, key, keyLen, db, sizeof(*db))) != 0) {
       taosHashCancelIterate(pOld, db);
-      taosHashCleanup(pNew);
-      terrno = TSDB_CODE_OUT_OF_MEMORY;
-      return NULL;
+      taosHashCleanup(*ppNew);
+      code = terrno ? terrno : TSDB_CODE_OUT_OF_MEMORY;  // TODO: remove this line after terrno is removed
+      TAOS_RETURN(code);
     }
     db = taosHashIterate(pOld, db);
   }
 
-  return pNew;
+  TAOS_RETURN(code);
 }
 
 int32_t mndUserDupObj(SUserObj *pUser, SUserObj *pNew) {
+  int32_t code = 0;
   memcpy(pNew, pUser, sizeof(SUserObj));
   pNew->authVersion++;
   pNew->updateTime = taosGetTimestampMs();
 
   taosRLockLatch(&pUser->lock);
-  pNew->readDbs = mndDupDbHash(pUser->readDbs);
-  pNew->writeDbs = mndDupDbHash(pUser->writeDbs);
-  pNew->readTbs = mndDupTableHash(pUser->readTbs);
-  pNew->writeTbs = mndDupTableHash(pUser->writeTbs);
-  pNew->alterTbs = mndDupTableHash(pUser->alterTbs);
-  pNew->readViews = mndDupTableHash(pUser->readViews);
-  pNew->writeViews = mndDupTableHash(pUser->writeViews);
-  pNew->alterViews = mndDupTableHash(pUser->alterViews);
-  pNew->topics = mndDupTopicHash(pUser->topics);
-  pNew->useDbs = mndDupUseDbHash(pUser->useDbs);
+  TAOS_CHECK_GOTO(mndDupDbHash(pUser->readDbs, &pNew->readDbs), NULL, _OVER);
+  TAOS_CHECK_GOTO(mndDupDbHash(pUser->writeDbs, &pNew->writeDbs), NULL, _OVER);
+  TAOS_CHECK_GOTO(mndDupTableHash(pUser->readTbs, &pNew->readTbs), NULL, _OVER);
+  TAOS_CHECK_GOTO(mndDupTableHash(pUser->writeTbs, &pNew->writeTbs), NULL, _OVER);
+  TAOS_CHECK_GOTO(mndDupTableHash(pUser->alterTbs, &pNew->alterTbs), NULL, _OVER);
+  TAOS_CHECK_GOTO(mndDupTableHash(pUser->readViews, &pNew->readViews), NULL, _OVER);
+  TAOS_CHECK_GOTO(mndDupTableHash(pUser->writeViews, &pNew->writeViews), NULL, _OVER);
+  TAOS_CHECK_GOTO(mndDupTableHash(pUser->alterViews, &pNew->alterViews), NULL, _OVER);
+  TAOS_CHECK_GOTO(mndDupTopicHash(pUser->topics, &pNew->topics), NULL, _OVER);
+  TAOS_CHECK_GOTO(mndDupUseDbHash(pUser->useDbs, &pNew->useDbs), NULL, _OVER);
   pNew->pIpWhiteList = cloneIpWhiteList(pUser->pIpWhiteList);
-
-  taosRUnLockLatch(&pUser->lock);
-
-  if (pNew->readDbs == NULL || pNew->writeDbs == NULL || pNew->topics == NULL) {
-    return -1;
+  if (pNew->pIpWhiteList == NULL) {
+    code = TSDB_CODE_OUT_OF_MEMORY;
   }
-  return 0;
+
+_OVER:
+  taosRUnLockLatch(&pUser->lock);
+  TAOS_RETURN(code);
 }
 
 void mndUserFreeObj(SUserObj *pUser) {
@@ -1436,6 +1447,10 @@ static int32_t mndUserActionUpdate(SSdb *pSdb, SUserObj *pOld, SUserObj *pNew) {
 
   int32_t sz = sizeof(SIpWhiteList) + pNew->pIpWhiteList->num * sizeof(SIpV4Range);
   pOld->pIpWhiteList = taosMemoryRealloc(pOld->pIpWhiteList, sz);
+  if (pOld->pIpWhiteList == NULL) {
+    taosWUnLockLatch(&pOld->lock);
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
   memcpy(pOld->pIpWhiteList, pNew->pIpWhiteList, sz);
   pOld->ipWhiteListVer = pNew->ipWhiteListVer;
 
@@ -1464,6 +1479,7 @@ void mndReleaseUser(SMnode *pMnode, SUserObj *pUser) {
 }
 
 static int32_t mndCreateUser(SMnode *pMnode, char *acct, SCreateUserReq *pCreate, SRpcMsg *pReq) {
+  int32_t  code = 0;
   SUserObj userObj = {0};
   if (pCreate->isImport != 1) {
     taosEncryptPass_c((uint8_t *)pCreate->pass, strlen(pCreate->pass), userObj.pass);
@@ -1481,14 +1497,16 @@ static int32_t mndCreateUser(SMnode *pMnode, char *acct, SCreateUserReq *pCreate
   userObj.createdb = pCreate->createDb;
 
   if (pCreate->numIpRanges == 0) {
-    userObj.pIpWhiteList = createDefaultIpWhiteList();
-
+    TAOS_CHECK_RETURN(createDefaultIpWhiteList(&userObj.pIpWhiteList));
   } else {
     SHashObj *pUniqueTab = taosHashInit(64, MurmurHash3_32, false, HASH_NO_LOCK);
+    if(pUniqueTab == NULL){
+      TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
+    }
     int32_t   dummpy = 0;
     for (int i = 0; i < pCreate->numIpRanges; i++) {
       SIpV4Range range = {.ip = pCreate->pIpRanges[i].ip, .mask = pCreate->pIpRanges[i].mask};
-      taosHashPut(pUniqueTab, &range, sizeof(range), &dummpy, sizeof(dummpy));
+      if(code = taosHashPut(pUniqueTab, &range, sizeof(range), &dummpy, sizeof(dummpy));
     }
     taosHashPut(pUniqueTab, &defaultIpRange, sizeof(defaultIpRange), &dummpy, sizeof(dummpy));
 
@@ -2575,6 +2593,7 @@ static void mndLoopHash(SHashObj *hash, char *priType, SSDataBlock *pBlock, int3
 }
 
 static int32_t mndRetrievePrivileges(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) {
+  int32_t   code = 0;
   SMnode   *pMnode = pReq->info.node;
   SSdb     *pSdb = pMnode->pSdb;
   int32_t   numOfRows = 0;
@@ -2806,15 +2825,15 @@ int32_t mndValidateUserAuthInfo(SMnode *pMnode, SUserAuthVersion *pUsers, int32_
   SUserAuthBatchRsp batchRsp = {0};
   batchRsp.pArray = taosArrayInit(numOfUses, sizeof(SGetUserAuthRsp));
   if (batchRsp.pArray == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
+    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); 
   }
 
   int32_t code = 0;
   for (int32_t i = 0; i < numOfUses; ++i) {
-    SUserObj *pUser = mndAcquireUser(pMnode, pUsers[i].user);
+    SUserObj *pUser = NULL;
+    code = mndAcquireUser(pMnode, pUsers[i].user, &pUser);
     if (pUser == NULL) {
-      if (TSDB_CODE_MND_USER_NOT_EXIST == terrno) {
+      if (TSDB_CODE_MND_USER_NOT_EXIST == code) {
         SGetUserAuthRsp rsp = {.dropped = 1};
         memcpy(rsp.user, pUsers[i].user, TSDB_USER_LEN);
         taosArrayPush(batchRsp.pArray, &rsp);
@@ -2837,7 +2856,7 @@ int32_t mndValidateUserAuthInfo(SMnode *pMnode, SUserAuthVersion *pUsers, int32_
       goto _OVER;
     }
 
-    taosArrayPush(batchRsp.pArray, &rsp);
+    (void)taosArrayPush(batchRsp.pArray, &rsp);
     mndReleaseUser(pMnode, pUser);
   }
 
@@ -2852,9 +2871,7 @@ int32_t mndValidateUserAuthInfo(SMnode *pMnode, SUserAuthVersion *pUsers, int32_
   int32_t rspLen = tSerializeSUserAuthBatchRsp(NULL, 0, &batchRsp);
   void   *pRsp = taosMemoryMalloc(rspLen);
   if (pRsp == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    tFreeSUserAuthBatchRsp(&batchRsp);
-    return -1;
+    TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, NULL, _OVER);
   }
   tSerializeSUserAuthBatchRsp(pRsp, rspLen, &batchRsp);
 
@@ -2870,7 +2887,7 @@ _OVER:
   *pRspLen = 0;
 
   tFreeSUserAuthBatchRsp(&batchRsp);
-  return code;
+  TAOS_RETURN(code);
 }
 
 int32_t mndUserRemoveDb(SMnode *pMnode, STrans *pTrans, char *db) {
@@ -2885,8 +2902,7 @@ int32_t mndUserRemoveDb(SMnode *pMnode, STrans *pTrans, char *db) {
     pIter = sdbFetch(pSdb, SDB_USER, pIter, (void **)&pUser);
     if (pIter == NULL) break;
 
-    code = -1;
-    if (mndUserDupObj(pUser, &newUser) != 0) {
+    if ((code = mndUserDupObj(pUser, &newUser)) != 0) {
       break;
     }
 
@@ -2897,7 +2913,8 @@ int32_t mndUserRemoveDb(SMnode *pMnode, STrans *pTrans, char *db) {
       (void)taosHashRemove(newUser.writeDbs, db, len);
 
       SSdbRaw *pCommitRaw = mndUserActionEncode(&newUser);
-      if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) {
+      if (pCommitRaw == NULL || (code = mndTransAppendCommitlog(pTrans, pCommitRaw)) != 0) {
+        code = terrno ? terrno : TSDB_CODE_OUT_OF_MEMORY;  // TODO: remove this line when terrno is removed
         break;
       }
       (void)sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY);
@@ -2905,13 +2922,12 @@ int32_t mndUserRemoveDb(SMnode *pMnode, STrans *pTrans, char *db) {
 
     mndUserFreeObj(&newUser);
     sdbRelease(pSdb, pUser);
-    code = 0;
   }
 
   if (pUser != NULL) sdbRelease(pSdb, pUser);
   if (pIter != NULL) sdbCancelFetch(pSdb, pIter);
   mndUserFreeObj(&newUser);
-  return code;
+  TAOS_RETURN(code);
 }
 
 int32_t mndUserRemoveStb(SMnode *pMnode, STrans *pTrans, char *stb) {
@@ -2926,8 +2942,7 @@ int32_t mndUserRemoveStb(SMnode *pMnode, STrans *pTrans, char *stb) {
     pIter = sdbFetch(pSdb, SDB_USER, pIter, (void **)&pUser);
     if (pIter == NULL) break;
 
-    code = -1;
-    if (mndUserDupObj(pUser, &newUser) != 0) {
+    if ((code = mndUserDupObj(pUser, &newUser)) != 0) {
       break;
     }
 
@@ -2940,7 +2955,8 @@ int32_t mndUserRemoveStb(SMnode *pMnode, STrans *pTrans, char *stb) {
       (void)taosHashRemove(newUser.alterTbs, stb, len);
 
       SSdbRaw *pCommitRaw = mndUserActionEncode(&newUser);
-      if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) {
+      if (pCommitRaw == NULL || (code = mndTransAppendCommitlog(pTrans, pCommitRaw)) != 0) {
+        code = terrno ? terrno : TSDB_CODE_OUT_OF_MEMORY;  // TODO: remove this line when terrno is removed
         break;
       }
       (void)sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY);
@@ -2948,13 +2964,12 @@ int32_t mndUserRemoveStb(SMnode *pMnode, STrans *pTrans, char *stb) {
 
     mndUserFreeObj(&newUser);
     sdbRelease(pSdb, pUser);
-    code = 0;
   }
 
   if (pUser != NULL) sdbRelease(pSdb, pUser);
   if (pIter != NULL) sdbCancelFetch(pSdb, pIter);
   mndUserFreeObj(&newUser);
-  return code;
+  TAOS_RETURN(code);
 }
 
 int32_t mndUserRemoveView(SMnode *pMnode, STrans *pTrans, char *view) {
@@ -2969,8 +2984,7 @@ int32_t mndUserRemoveView(SMnode *pMnode, STrans *pTrans, char *view) {
     pIter = sdbFetch(pSdb, SDB_USER, pIter, (void **)&pUser);
     if (pIter == NULL) break;
 
-    code = -1;
-    if (mndUserDupObj(pUser, &newUser) != 0) {
+    if ((code = mndUserDupObj(pUser, &newUser)) != 0) {
       break;
     }
 
@@ -2983,7 +2997,8 @@ int32_t mndUserRemoveView(SMnode *pMnode, STrans *pTrans, char *view) {
       (void)taosHashRemove(newUser.alterViews, view, len);
 
       SSdbRaw *pCommitRaw = mndUserActionEncode(&newUser);
-      if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) {
+      if (pCommitRaw == NULL || (code = mndTransAppendCommitlog(pTrans, pCommitRaw)) != 0) {
+        code = terrno ? terrno : TSDB_CODE_OUT_OF_MEMORY;  // TODO: remove this line when terrno is removed
         break;
       }
       (void)sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY);
@@ -2991,13 +3006,12 @@ int32_t mndUserRemoveView(SMnode *pMnode, STrans *pTrans, char *view) {
 
     mndUserFreeObj(&newUser);
     sdbRelease(pSdb, pUser);
-    code = 0;
   }
 
   if (pUser != NULL) sdbRelease(pSdb, pUser);
   if (pIter != NULL) sdbCancelFetch(pSdb, pIter);
   mndUserFreeObj(&newUser);
-  return code;
+  TAOS_RETURN(code); 
 }
 
 int32_t mndUserRemoveTopic(SMnode *pMnode, STrans *pTrans, char *topic) {
@@ -3014,8 +3028,7 @@ int32_t mndUserRemoveTopic(SMnode *pMnode, STrans *pTrans, char *topic) {
       break;
     }
 
-    code = -1;
-    if (mndUserDupObj(pUser, &newUser) != 0) {
+    if ((code = mndUserDupObj(pUser, &newUser)) != 0) {
       break;
     }
 
@@ -3023,7 +3036,8 @@ int32_t mndUserRemoveTopic(SMnode *pMnode, STrans *pTrans, char *topic) {
     if (inTopic) {
       (void)taosHashRemove(newUser.topics, topic, len);
       SSdbRaw *pCommitRaw = mndUserActionEncode(&newUser);
-      if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) {
+      if (pCommitRaw == NULL || (code = mndTransAppendCommitlog(pTrans, pCommitRaw)) != 0) {
+        code = terrno ? terrno : TSDB_CODE_OUT_OF_MEMORY;  // TODO: remove this line when terrno is removed
         break;
       }
       (void)sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY);
@@ -3031,13 +3045,12 @@ int32_t mndUserRemoveTopic(SMnode *pMnode, STrans *pTrans, char *topic) {
 
     mndUserFreeObj(&newUser);
     sdbRelease(pSdb, pUser);
-    code = 0;
   }
 
   if (pUser != NULL) sdbRelease(pSdb, pUser);
   if (pIter != NULL) sdbCancelFetch(pSdb, pIter);
   mndUserFreeObj(&newUser);
-  return code;
+  TAOS_RETURN(code);
 }
 
 int64_t mndGetUserIpWhiteListVer(SMnode *pMnode, SUserObj *pUser) {
diff --git a/source/libs/tfs/inc/tfsInt.h b/source/libs/tfs/inc/tfsInt.h
index b3bde3abba..3c2b67da01 100644
--- a/source/libs/tfs/inc/tfsInt.h
+++ b/source/libs/tfs/inc/tfsInt.h
@@ -74,16 +74,16 @@ typedef struct STfs {
   SHashObj        *hash;  // name to did map
 } STfs;
 
-STfsDisk *tfsNewDisk(int32_t level, int32_t id, int8_t disable, const char *dir);
+int32_t   tfsNewDisk(int32_t level, int32_t id, int8_t disable, const char *dir, STfsDisk **ppDisk);
 STfsDisk *tfsFreeDisk(STfsDisk *pDisk);
 int32_t   tfsUpdateDiskSize(STfsDisk *pDisk);
 
-int32_t   tfsInitTier(STfsTier *pTier, int32_t level);
-void      tfsDestroyTier(STfsTier *pTier);
-STfsDisk *tfsMountDiskToTier(STfsTier *pTier, SDiskCfg *pCfg);
-void      tfsUpdateTierSize(STfsTier *pTier);
-int32_t   tfsAllocDiskOnTier(STfsTier *pTier);
-void      tfsPosNextId(STfsTier *pTier);
+int32_t tfsInitTier(STfsTier *pTier, int32_t level);
+void    tfsDestroyTier(STfsTier *pTier);
+int32_t tfsMountDiskToTier(STfsTier *pTier, SDiskCfg *pCfg, STfsDisk **ppDisk);
+void    tfsUpdateTierSize(STfsTier *pTier);
+int32_t tfsAllocDiskOnTier(STfsTier *pTier);
+void    tfsPosNextId(STfsTier *pTier);
 
 #define tfsLockTier(pTier)   taosThreadSpinLock(&(pTier)->lock)
 #define tfsUnLockTier(pTier) taosThreadSpinUnlock(&(pTier)->lock)
diff --git a/source/libs/tfs/src/tfs.c b/source/libs/tfs/src/tfs.c
index 1c64885bf5..3432b2a069 100644
--- a/source/libs/tfs/src/tfs.c
+++ b/source/libs/tfs/src/tfs.c
@@ -495,7 +495,9 @@ static int32_t tfsMount(STfs *pTfs, SDiskCfg *pCfg) {
   }
 
   SDiskID   did = {.level = pCfg->level};
-  STfsDisk *pDisk = tfsMountDiskToTier(TFS_TIER_AT(pTfs, did.level), pCfg);
+  STfsDisk *pDisk = NULL;
+  
+  tfsMountDiskToTier(TFS_TIER_AT(pTfs, did.level), pCfg, &pDisk);
   if (pDisk == NULL) {
     fError("failed to mount disk %s to level %d since %s", pCfg->dir, pCfg->level, terrstr());
     return -1;
@@ -515,33 +517,28 @@ static int32_t tfsCheckAndFormatCfg(STfs *pTfs, SDiskCfg *pCfg) {
 
   if (pCfg->level < 0 || pCfg->level >= TFS_MAX_TIERS) {
     fError("failed to mount %s to FS since invalid level %d", pCfg->dir, pCfg->level);
-    terrno = TSDB_CODE_FS_INVLD_CFG;
-    return -1;
+    TAOS_RETURN(TSDB_CODE_FS_INVLD_CFG);
   }
 
   if (pCfg->primary < 0 || pCfg->primary > 1) {
     fError("failed to mount %s to FS since invalid primary %d", pCfg->dir, pCfg->primary);
-    terrno = TSDB_CODE_FS_INVLD_CFG;
-    return -1;
+    TAOS_RETURN(TSDB_CODE_FS_INVLD_CFG);
   }
 
   if (pCfg->disable < 0 || pCfg->disable > 1) {
     fError("failed to mount %s to FS since invalid disable %" PRIi8, pCfg->dir, pCfg->disable);
-    terrno = TSDB_CODE_FS_INVLD_CFG;
-    return -1;
+    TAOS_RETURN(TSDB_CODE_FS_INVLD_CFG);
   }
 
   if (pCfg->primary) {
     if (pCfg->level != 0) {
       fError("failed to mount %s to FS since disk is primary but level %d not 0", pCfg->dir, pCfg->level);
-      terrno = TSDB_CODE_FS_INVLD_CFG;
-      return -1;
+      TAOS_RETURN(TSDB_CODE_FS_INVLD_CFG);
     }
 
     if (TFS_PRIMARY_DISK(pTfs) != NULL) {
       fError("failed to mount %s to FS since duplicate primary mount", pCfg->dir);
-      terrno = TSDB_CODE_FS_DUP_PRIMARY;
-      return -1;
+      TAOS_RETURN(TSDB_CODE_FS_DUP_PRIMARY);
     }
   }
 
@@ -578,15 +575,14 @@ static int32_t tfsFormatDir(char *idir, char *odir) {
 
   int32_t code = wordexp(idir, &wep, 0);
   if (code != 0) {
-    terrno = TAOS_SYSTEM_ERROR(code);
-    return -1;
+    TAOS_RETURN(TAOS_SYSTEM_ERROR(code));
   }
 
   char tmp[PATH_MAX] = {0};
   if (taosRealPath(wep.we_wordv[0], tmp, PATH_MAX) != 0) {
-    terrno = TAOS_SYSTEM_ERROR(errno);
+    code = TAOS_SYSTEM_ERROR(errno);
     wordfree(&wep);
-    return -1;
+    TAOS_RETURN(code);
   }
   strcpy(odir, tmp);
 
@@ -597,23 +593,20 @@ static int32_t tfsFormatDir(char *idir, char *odir) {
 static int32_t tfsCheck(STfs *pTfs) {
   if (TFS_PRIMARY_DISK(pTfs) == NULL) {
     fError("no primary disk is set");
-    terrno = TSDB_CODE_FS_NO_PRIMARY_DISK;
-    return -1;
+    TAOS_RETURN(TSDB_CODE_FS_NO_PRIMARY_DISK);
   }
 
   for (int32_t level = 0; level < pTfs->nlevel; level++) {
     if (TFS_TIER_AT(pTfs, level)->ndisk == 0) {
       fError("no disk at level %d", level);
-      terrno = TSDB_CODE_FS_NO_MOUNT_AT_TIER;
-      return -1;
+      TAOS_RETURN(TSDB_CODE_FS_NO_MOUNT_AT_TIER);
     }
 
     if (level == 0) {
       tfsUpdateTierSize(TFS_TIER_AT(pTfs, level));
       if (TFS_TIER_AT(pTfs, level)->nAvailDisks == 0) {
         fError("no disk to create new file at level %d", level);
-        terrno = TSDB_CODE_FS_NO_VALID_DISK;
-        return -1;
+        TAOS_RETURN(TSDB_CODE_FS_NO_VALID_DISK);
       }
     }
   }
@@ -684,7 +677,9 @@ static STfsDisk *tfsNextDisk(STfs *pTfs, SDiskIter *pIter) {
 
 int32_t tfsGetMonitorInfo(STfs *pTfs, SMonDiskInfo *pInfo) {
   pInfo->datadirs = taosArrayInit(32, sizeof(SMonDiskDesc));
-  if (pInfo->datadirs == NULL) return -1;
+  if (pInfo->datadirs == NULL) {
+    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
+  }
 
   tfsUpdateSize(pTfs);
 
@@ -697,7 +692,12 @@ int32_t tfsGetMonitorInfo(STfs *pTfs, SMonDiskInfo *pInfo) {
       dinfo.size = pDisk->size;
       dinfo.level = pDisk->level;
       tstrncpy(dinfo.name, pDisk->path, sizeof(dinfo.name));
-      taosArrayPush(pInfo->datadirs, &dinfo);
+      if (taosArrayPush(pInfo->datadirs, &dinfo) == NULL) {
+        tfsUnLock(pTfs);
+        taosArrayDestroy(pInfo->datadirs);
+        pInfo->datadirs = NULL;
+        TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
+      }
     }
   }
   tfsUnLock(pTfs);
diff --git a/source/libs/tfs/src/tfsDisk.c b/source/libs/tfs/src/tfsDisk.c
index 06eb1cd42e..424eb886ba 100644
--- a/source/libs/tfs/src/tfsDisk.c
+++ b/source/libs/tfs/src/tfsDisk.c
@@ -16,25 +16,34 @@
 #define _DEFAULT_SOURCE
 #include "tfsInt.h"
 
-STfsDisk *tfsNewDisk(int32_t level, int32_t id, int8_t disable, const char *path) {
-  STfsDisk *pDisk = taosMemoryCalloc(1, sizeof(STfsDisk));
-  if (pDisk == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return NULL;
+int32_t tfsNewDisk(int32_t level, int32_t id, int8_t disable, const char *path, STfsDisk **ppDisk) {
+  int32_t   code = 0;
+  int32_t   lino = 0;
+  STfsDisk *pDisk = NULL;
+
+  if ((pDisk = taosMemoryCalloc(1, sizeof(STfsDisk))) == NULL) {
+    TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER);
   }
 
-  pDisk->path = taosStrdup(path);
-  if (pDisk->path == NULL) {
-    taosMemoryFree(pDisk);
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return NULL;
+  if ((pDisk->path = taosStrdup(path)) == NULL) {
+    TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER);
   }
 
   pDisk->level = level;
   pDisk->id = id;
   pDisk->disable = disable;
-  taosGetDiskSize(pDisk->path, &pDisk->size);
-  return pDisk;
+  if (taosGetDiskSize(pDisk->path, &pDisk->size) < 0) {
+    code = TAOS_SYSTEM_ERROR(errno);  // TODO: refactor this line
+    TAOS_CHECK_GOTO(code, &lino, _OVER);
+  }
+_OVER:
+  if (code != 0) {
+    pDisk = tfsFreeDisk(pDisk);
+    fError("%s failed at line %d since %s, disk:%s level:%d id:%d ", __func__, lino, tstrerror(code), path, level, id);
+  }
+  *ppDisk = pDisk;
+
+  TAOS_RETURN(code);
 }
 
 STfsDisk *tfsFreeDisk(STfsDisk *pDisk) {
@@ -48,9 +57,10 @@ STfsDisk *tfsFreeDisk(STfsDisk *pDisk) {
 
 int32_t tfsUpdateDiskSize(STfsDisk *pDisk) {
   if (taosGetDiskSize(pDisk->path, &pDisk->size) < 0) {
-    terrno = TAOS_SYSTEM_ERROR(errno);
-    fError("failed to get disk:%s size, level:%d id:%d since %s", pDisk->path, pDisk->level, pDisk->id, terrstr());
-    return -1;
+    int32_t code = TAOS_SYSTEM_ERROR(errno);  // TODO: refactor this line
+    fError("failed to get disk:%s size, level:%d id:%d since %s", pDisk->path, pDisk->level, pDisk->id,
+           tstrerror(code));
+    TAOS_RETURN(code);
   }
 
   return 0;
diff --git a/source/libs/tfs/src/tfsTier.c b/source/libs/tfs/src/tfsTier.c
index cb79c334bf..a0fece3691 100644
--- a/source/libs/tfs/src/tfsTier.c
+++ b/source/libs/tfs/src/tfsTier.c
@@ -22,8 +22,7 @@ int32_t tfsInitTier(STfsTier *pTier, int32_t level) {
   memset(pTier, 0, sizeof(STfsTier));
 
   if (taosThreadSpinInit(&pTier->lock, 0) != 0) {
-    terrno = TAOS_SYSTEM_ERROR(errno);
-    return -1;
+    TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
   }
 
   pTier->level = level;
@@ -39,10 +38,13 @@ void tfsDestroyTier(STfsTier *pTier) {
   taosThreadSpinDestroy(&pTier->lock);
 }
 
-STfsDisk *tfsMountDiskToTier(STfsTier *pTier, SDiskCfg *pCfg) {
+int32_t tfsMountDiskToTier(STfsTier *pTier, SDiskCfg *pCfg, STfsDisk **ppDisk) {
+  int32_t   code = 0;
+  int32_t   lino = 0;
+  STfsDisk *pDisk = NULL;
+
   if (pTier->ndisk >= TFS_MAX_DISKS_PER_TIER) {
-    terrno = TSDB_CODE_FS_TOO_MANY_MOUNT;
-    return NULL;
+    TAOS_CHECK_GOTO(TSDB_CODE_FS_TOO_MANY_MOUNT, &lino, _OVER);
   }
 
   int32_t id = 0;
@@ -61,18 +63,25 @@ STfsDisk *tfsMountDiskToTier(STfsTier *pTier, SDiskCfg *pCfg) {
   }
 
   if (id >= TFS_MAX_DISKS_PER_TIER) {
-    terrno = TSDB_CODE_FS_TOO_MANY_MOUNT;
-    return NULL;
+    TAOS_CHECK_GOTO(TSDB_CODE_FS_TOO_MANY_MOUNT, &lino, _OVER);
   }
 
-  STfsDisk *pDisk = tfsNewDisk(pCfg->level, id, pCfg->disable, pCfg->dir);
-  if (pDisk == NULL) return NULL;
+  TAOS_CHECK_GOTO(tfsNewDisk(pCfg->level, id, pCfg->disable, pCfg->dir, &pDisk), &lino, _OVER);
 
   pTier->disks[id] = pDisk;
   pTier->ndisk++;
 
-  fDebug("disk %s is mounted to tier level %d id %d", pCfg->dir, pCfg->level, id);
-  return pTier->disks[id];
+_OVER:
+  if (code != 0) {
+    pDisk = tfsFreeDisk(pDisk);
+    fError("%s failed at line %d since %s, disk:%s level:%d id:%d", __func__, lino, tstrerror(code), pCfg->dir,
+           pCfg->level, id);
+  } else {
+    *ppDisk = pTier->disks[id];
+    fDebug("disk %s is mounted to tier level %d id %d", pCfg->dir, pCfg->level, id);
+  }
+
+  TAOS_RETURN(code);
 }
 
 void tfsUpdateTierSize(STfsTier *pTier) {
@@ -100,13 +109,11 @@ void tfsUpdateTierSize(STfsTier *pTier) {
 
 // Round-Robin to allocate disk on a tier
 int32_t tfsAllocDiskOnTier(STfsTier *pTier) {
-  terrno = TSDB_CODE_FS_NO_VALID_DISK;
-
   tfsLockTier(pTier);
 
   if (pTier->ndisk <= 0 || pTier->nAvailDisks <= 0) {
     tfsUnLockTier(pTier);
-    return -1;
+    TAOS_RETURN(TSDB_CODE_FS_NO_VALID_DISK);
   }
 
   int32_t retId = -1;
@@ -149,6 +156,9 @@ int32_t tfsAllocDiskOnTier(STfsTier *pTier) {
   }
 
   tfsUnLockTier(pTier);
+  if (retId < 0) {
+    TAOS_RETURN(TSDB_CODE_FS_NO_VALID_DISK);
+  }
   return retId;
 }