diff --git a/include/util/taoserror.h b/include/util/taoserror.h
index 842c8a44e17abb55b1796cca5c7090cab89fbadc..450eb432802f5296bb30f97132417bdcbea2c624 100644
--- a/include/util/taoserror.h
+++ b/include/util/taoserror.h
@@ -185,7 +185,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_MND_BNODE_NOT_EXIST           TAOS_DEF_ERROR_CODE(0, 0x0357)
 #define TSDB_CODE_MND_TOO_FEW_MNODES            TAOS_DEF_ERROR_CODE(0, 0x0358)
 #define TSDB_CODE_MND_TOO_MANY_MNODES           TAOS_DEF_ERROR_CODE(0, 0x0359)
-#define TSDB_CODE_MND_CANT_DROP_MASTER          TAOS_DEF_ERROR_CODE(0, 0x035A)
+#define TSDB_CODE_MND_CANT_DROP_LEADER          TAOS_DEF_ERROR_CODE(0, 0x035A)
 
 // mnode-acct
 #define TSDB_CODE_MND_ACCT_ALREADY_EXIST        TAOS_DEF_ERROR_CODE(0, 0x0360)
diff --git a/source/dnode/mgmt/node_mgmt/src/dmTransport.c b/source/dnode/mgmt/node_mgmt/src/dmTransport.c
index 8b939d15ce35e4a8ccb9f032025250476a3b8a82..de7d46ed83b863c22e0d6eca7904115445648c4e 100644
--- a/source/dnode/mgmt/node_mgmt/src/dmTransport.c
+++ b/source/dnode/mgmt/node_mgmt/src/dmTransport.c
@@ -131,7 +131,8 @@ static void dmProcessRpcMsg(SDnode *pDnode, SRpcMsg *pRpc, SEpSet *pEpSet) {
 
 _OVER:
   if (code != 0) {
-    dTrace("msg:%p, failed to process since %s, type:%s", pMsg, terrstr(), TMSG_INFO(pRpc->msgType));
+    dTrace("failed to process msg:%p since %s, handle:%p", pMsg, terrstr(), pRpc->info.handle);
+
     if (terrno != 0) code = terrno;
 
     if (IsReq(pRpc)) {
@@ -149,8 +150,10 @@ _OVER:
       }
     }
 
-    dTrace("msg:%p, is freed", pMsg);
-    taosFreeQitem(pMsg);
+    if (pMsg != NULL) {
+      dTrace("msg:%p, is freed", pMsg);
+      taosFreeQitem(pMsg);
+    }
     rpcFreeCont(pRpc->pCont);
   }
 
diff --git a/source/dnode/mgmt/node_util/src/dmEps.c b/source/dnode/mgmt/node_util/src/dmEps.c
index 937c1ab7faa29191ea65f8770d0ffb2c531b3c35..6f6896ff9f11ae040e765e613e0cd2f7732a599e 100644
--- a/source/dnode/mgmt/node_util/src/dmEps.c
+++ b/source/dnode/mgmt/node_util/src/dmEps.c
@@ -318,9 +318,9 @@ void dmGetMnodeEpSet(SDnodeData *pData, SEpSet *pEpSet) {
 
 void dmGetMnodeEpSetForRedirect(SDnodeData *pData, SRpcMsg *pMsg, SEpSet *pEpSet) {
   dmGetMnodeEpSet(pData, pEpSet);
-  dDebug("msg:%p, is redirected, num:%d use:%d", pMsg, pEpSet->numOfEps, pEpSet->inUse);
+  dTrace("msg is redirected, handle:%p num:%d use:%d", pMsg->info.handle, pEpSet->numOfEps, pEpSet->inUse);
   for (int32_t i = 0; i < pEpSet->numOfEps; ++i) {
-    dDebug("mnode index:%d %s:%u", i, pEpSet->eps[i].fqdn, pEpSet->eps[i].port);
+    dTrace("mnode index:%d %s:%u", i, pEpSet->eps[i].fqdn, pEpSet->eps[i].port);
     if (strcmp(pEpSet->eps[i].fqdn, tsLocalFqdn) == 0 && pEpSet->eps[i].port == tsServerPort) {
       pEpSet->inUse = (i + 1) % pEpSet->numOfEps;
     }
diff --git a/source/dnode/mnode/impl/inc/mndTrans.h b/source/dnode/mnode/impl/inc/mndTrans.h
index 736fa3b36108e2e840b1f24a25c302262f83e6ca..5ac9d2233f376c4d0435464e6f3032ad105db613 100644
--- a/source/dnode/mnode/impl/inc/mndTrans.h
+++ b/source/dnode/mnode/impl/inc/mndTrans.h
@@ -36,19 +36,19 @@ typedef enum {
 } ETrnAct;
 
 typedef struct {
-  int32_t  id;
-  int32_t  errCode;
-  int32_t  acceptableCode;
-  int8_t   stage;
-  ETrnAct  actionType;
-  int8_t   rawWritten;
-  int8_t   msgSent;
-  int8_t   msgReceived;
-  tmsg_t   msgType;
-  SEpSet   epSet;
-  int32_t  contLen;
-  void    *pCont;
-  SSdbRaw *pRaw;
+  int32_t   id;
+  int32_t   errCode;
+  int32_t   acceptableCode;
+  ETrnStage stage;
+  ETrnAct   actionType;
+  int8_t    rawWritten;
+  int8_t    msgSent;
+  int8_t    msgReceived;
+  tmsg_t    msgType;
+  SEpSet    epSet;
+  int32_t   contLen;
+  void     *pCont;
+  SSdbRaw  *pRaw;
 } STransAction;
 
 typedef void (*TransCbFp)(SMnode *pMnode, void *param, int32_t paramLen);
diff --git a/source/dnode/mnode/impl/src/mndDnode.c b/source/dnode/mnode/impl/src/mndDnode.c
index c7e347fb8b9573423139565e92bd5e8d59ebf1cd..7be49393372f6d58ac9ce3e1205a52bec07889be 100644
--- a/source/dnode/mnode/impl/src/mndDnode.c
+++ b/source/dnode/mnode/impl/src/mndDnode.c
@@ -87,6 +87,10 @@ int32_t mndInitDnode(SMnode *pMnode) {
 void mndCleanupDnode(SMnode *pMnode) {}
 
 static int32_t mndCreateDefaultDnode(SMnode *pMnode) {
+  int32_t  code = -1;
+  SSdbRaw *pRaw = NULL;
+  STrans  *pTrans = NULL;
+
   SDnodeObj dnodeObj = {0};
   dnodeObj.id = 1;
   dnodeObj.createdTime = taosGetTimestampMs();
@@ -95,54 +99,42 @@ static int32_t mndCreateDefaultDnode(SMnode *pMnode) {
   memcpy(&dnodeObj.fqdn, pMnode->replicas[0].fqdn, TSDB_FQDN_LEN);
   snprintf(dnodeObj.ep, TSDB_EP_LEN, "%s:%u", dnodeObj.fqdn, dnodeObj.port);
 
-  SSdbRaw *pRaw = mndDnodeActionEncode(&dnodeObj);
-  if (pRaw == NULL) return -1;
-  if (sdbSetRawStatus(pRaw, SDB_STATUS_READY) != 0) return -1;
-
-  mDebug("dnode:%d, will be created when deploying, raw:%p", dnodeObj.id, pRaw);
-
-  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_GLOBAL, NULL);
-  if (pTrans == NULL) {
-    mError("dnode:%s, failed to create since %s", dnodeObj.ep, terrstr());
-    return -1;
-  }
-  mDebug("trans:%d, used to create dnode:%s", pTrans->id, dnodeObj.ep);
+  pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_GLOBAL, NULL);
+  if (pTrans == NULL) goto _OVER;
+  mDebug("trans:%d, used to create dnode:%s on first deploy", pTrans->id, dnodeObj.ep);
 
-  if (mndTransAppendCommitlog(pTrans, pRaw) != 0) {
-    mError("trans:%d, failed to append commit log since %s", pTrans->id, terrstr());
-    mndTransDrop(pTrans);
-    return -1;
-  }
+  pRaw = mndDnodeActionEncode(&dnodeObj);
+  if (pRaw == NULL || mndTransAppendCommitlog(pTrans, pRaw) != 0) goto _OVER;
   sdbSetRawStatus(pRaw, SDB_STATUS_READY);
+  pRaw = NULL;
 
-  if (mndTransPrepare(pMnode, pTrans) != 0) {
-    mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr());
-    mndTransDrop(pTrans);
-    return -1;
-  }
+  if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;
+  code = 0;
 
+_OVER:
   mndTransDrop(pTrans);
-  return 0;
+  sdbFreeRaw(pRaw);
+  return code;
 }
 
 static SSdbRaw *mndDnodeActionEncode(SDnodeObj *pDnode) {
   terrno = TSDB_CODE_OUT_OF_MEMORY;
 
   SSdbRaw *pRaw = sdbAllocRaw(SDB_DNODE, TSDB_DNODE_VER_NUMBER, sizeof(SDnodeObj) + TSDB_DNODE_RESERVE_SIZE);
-  if (pRaw == NULL) goto DNODE_ENCODE_OVER;
+  if (pRaw == NULL) goto _OVER;
 
   int32_t dataPos = 0;
-  SDB_SET_INT32(pRaw, dataPos, pDnode->id, DNODE_ENCODE_OVER)
-  SDB_SET_INT64(pRaw, dataPos, pDnode->createdTime, DNODE_ENCODE_OVER)
-  SDB_SET_INT64(pRaw, dataPos, pDnode->updateTime, DNODE_ENCODE_OVER)
-  SDB_SET_INT16(pRaw, dataPos, pDnode->port, DNODE_ENCODE_OVER)
-  SDB_SET_BINARY(pRaw, dataPos, pDnode->fqdn, TSDB_FQDN_LEN, DNODE_ENCODE_OVER)
-  SDB_SET_RESERVE(pRaw, dataPos, TSDB_DNODE_RESERVE_SIZE, DNODE_ENCODE_OVER)
-  SDB_SET_DATALEN(pRaw, dataPos, DNODE_ENCODE_OVER);
+  SDB_SET_INT32(pRaw, dataPos, pDnode->id, _OVER)
+  SDB_SET_INT64(pRaw, dataPos, pDnode->createdTime, _OVER)
+  SDB_SET_INT64(pRaw, dataPos, pDnode->updateTime, _OVER)
+  SDB_SET_INT16(pRaw, dataPos, pDnode->port, _OVER)
+  SDB_SET_BINARY(pRaw, dataPos, pDnode->fqdn, TSDB_FQDN_LEN, _OVER)
+  SDB_SET_RESERVE(pRaw, dataPos, TSDB_DNODE_RESERVE_SIZE, _OVER)
+  SDB_SET_DATALEN(pRaw, dataPos, _OVER);
 
   terrno = 0;
 
-DNODE_ENCODE_OVER:
+_OVER:
   if (terrno != 0) {
     mError("dnode:%d, failed to encode to raw:%p since %s", pDnode->id, pRaw, terrstr());
     sdbFreeRaw(pRaw);
@@ -154,33 +146,32 @@ DNODE_ENCODE_OVER:
 }
 
 static SSdbRow *mndDnodeActionDecode(SSdbRaw *pRaw) {
+  SSdbRow *pRow = NULL;
   terrno = TSDB_CODE_OUT_OF_MEMORY;
 
   int8_t sver = 0;
-  if (sdbGetRawSoftVer(pRaw, &sver) != 0) goto DNODE_DECODE_OVER;
-
+  if (sdbGetRawSoftVer(pRaw, &sver) != 0) goto _OVER;
   if (sver != TSDB_DNODE_VER_NUMBER) {
     terrno = TSDB_CODE_SDB_INVALID_DATA_VER;
-    goto DNODE_DECODE_OVER;
+    goto _OVER;
   }
 
-  SSdbRow *pRow = sdbAllocRow(sizeof(SDnodeObj));
-  if (pRow == NULL) goto DNODE_DECODE_OVER;
-
+  pRow = sdbAllocRow(sizeof(SDnodeObj));
+  if (pRow == NULL) goto _OVER;
   SDnodeObj *pDnode = sdbGetRowObj(pRow);
-  if (pDnode == NULL) goto DNODE_DECODE_OVER;
+  if (pDnode == NULL) goto _OVER;
 
   int32_t dataPos = 0;
-  SDB_GET_INT32(pRaw, dataPos, &pDnode->id, DNODE_DECODE_OVER)
-  SDB_GET_INT64(pRaw, dataPos, &pDnode->createdTime, DNODE_DECODE_OVER)
-  SDB_GET_INT64(pRaw, dataPos, &pDnode->updateTime, DNODE_DECODE_OVER)
-  SDB_GET_INT16(pRaw, dataPos, &pDnode->port, DNODE_DECODE_OVER)
-  SDB_GET_BINARY(pRaw, dataPos, pDnode->fqdn, TSDB_FQDN_LEN, DNODE_DECODE_OVER)
-  SDB_GET_RESERVE(pRaw, dataPos, TSDB_DNODE_RESERVE_SIZE, DNODE_DECODE_OVER)
+  SDB_GET_INT32(pRaw, dataPos, &pDnode->id, _OVER)
+  SDB_GET_INT64(pRaw, dataPos, &pDnode->createdTime, _OVER)
+  SDB_GET_INT64(pRaw, dataPos, &pDnode->updateTime, _OVER)
+  SDB_GET_INT16(pRaw, dataPos, &pDnode->port, _OVER)
+  SDB_GET_BINARY(pRaw, dataPos, pDnode->fqdn, TSDB_FQDN_LEN, _OVER)
+  SDB_GET_RESERVE(pRaw, dataPos, TSDB_DNODE_RESERVE_SIZE, _OVER)
 
   terrno = 0;
 
-DNODE_DECODE_OVER:
+_OVER:
   if (terrno != 0) {
     mError("dnode:%d, failed to decode from raw:%p since %s", pDnode->id, pRaw, terrstr());
     taosMemoryFreeClear(pRow);
@@ -246,6 +237,7 @@ static SDnodeObj *mndAcquireDnodeByEp(SMnode *pMnode, char *pEpStr) {
     sdbRelease(pSdb, pDnode);
   }
 
+  terrno = TSDB_CODE_MND_DNODE_NOT_EXIST;
   return NULL;
 }
 
@@ -290,25 +282,26 @@ static void mndGetDnodeData(SMnode *pMnode, SArray *pDnodeEps) {
   }
 }
 
-static int32_t mndCheckClusterCfgPara(SMnode *pMnode, const SClusterCfg *pCfg) {
+static int32_t mndCheckClusterCfgPara(SMnode *pMnode, SDnodeObj *pDnode, const SClusterCfg *pCfg) {
   if (pCfg->statusInterval != tsStatusInterval) {
-    mError("statusInterval [%d - %d] cfg inconsistent", pCfg->statusInterval, tsStatusInterval);
+    mError("dnode:%d, statusInterval:%d inconsistent with cluster:%d", pDnode->id, pCfg->statusInterval,
+           tsStatusInterval);
     return DND_REASON_STATUS_INTERVAL_NOT_MATCH;
   }
 
   if ((0 != strcasecmp(pCfg->timezone, tsTimezoneStr)) && (pMnode->checkTime != pCfg->checkTime)) {
-    mError("timezone [%s - %s] [%" PRId64 " - %" PRId64 "] cfg inconsistent", pCfg->timezone, tsTimezoneStr,
-           pCfg->checkTime, pMnode->checkTime);
+    mError("dnode:%d, timezone:%s checkTime:%" PRId64 " inconsistent with cluster %s %" PRId64, pDnode->id,
+           pCfg->timezone, pCfg->checkTime, tsTimezoneStr, pMnode->checkTime);
     return DND_REASON_TIME_ZONE_NOT_MATCH;
   }
 
   if (0 != strcasecmp(pCfg->locale, tsLocale)) {
-    mError("locale [%s - %s]  cfg inconsistent", pCfg->locale, tsLocale);
+    mError("dnode:%d, locale:%s inconsistent with cluster:%s", pDnode->id, pCfg->locale, tsLocale);
     return DND_REASON_LOCALE_NOT_MATCH;
   }
 
   if (0 != strcasecmp(pCfg->charset, tsCharset)) {
-    mError("charset [%s - %s] cfg inconsistent.", pCfg->charset, tsCharset);
+    mError("dnode:%d, charset:%s inconsistent with cluster:%s", pDnode->id, pCfg->charset, tsCharset);
     return DND_REASON_CHARSET_NOT_MATCH;
   }
 
@@ -323,15 +316,14 @@ static int32_t mndProcessStatusReq(SRpcMsg *pReq) {
 
   if (tDeserializeSStatusReq(pReq->pCont, pReq->contLen, &statusReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
-    goto PROCESS_STATUS_MSG_OVER;
+    goto _OVER;
   }
 
   if (statusReq.dnodeId == 0) {
     pDnode = mndAcquireDnodeByEp(pMnode, statusReq.dnodeEp);
     if (pDnode == NULL) {
       mDebug("dnode:%s, not created yet", statusReq.dnodeEp);
-      terrno = TSDB_CODE_MND_DNODE_NOT_EXIST;
-      goto PROCESS_STATUS_MSG_OVER;
+      goto _OVER;
     }
   } else {
     pDnode = mndAcquireDnode(pMnode, statusReq.dnodeId);
@@ -341,13 +333,11 @@ static int32_t mndProcessStatusReq(SRpcMsg *pReq) {
         pDnode->offlineReason = DND_REASON_DNODE_ID_NOT_MATCH;
       }
       mError("dnode:%d, %s not exist", statusReq.dnodeId, statusReq.dnodeEp);
-      terrno = TSDB_CODE_MND_DNODE_NOT_EXIST;
-      goto PROCESS_STATUS_MSG_OVER;
+      goto _OVER;
     }
   }
 
-  int32_t numOfVloads = (int32_t)taosArrayGetSize(statusReq.pVloads);
-  for (int32_t v = 0; v < numOfVloads; ++v) {
+  for (int32_t v = 0; v < taosArrayGetSize(statusReq.pVloads); ++v) {
     SVnodeLoad *pVload = taosArrayGet(statusReq.pVloads, v);
 
     SVgObj *pVgroup = mndAcquireVgroup(pMnode, pVload->vgId);
@@ -366,6 +356,7 @@ static int32_t mndProcessStatusReq(SRpcMsg *pReq) {
             roleChanged = true;
           }
           pVgroup->vnodeGid[vg].role = pVload->syncState;
+          break;
         }
       }
       if (roleChanged) {
@@ -405,11 +396,11 @@ static int32_t mndProcessStatusReq(SRpcMsg *pReq) {
       }
       mError("dnode:%d, status msg version:%d not match cluster:%d", statusReq.dnodeId, statusReq.sver, tsVersion);
       terrno = TSDB_CODE_VERSION_NOT_COMPATIBLE;
-      goto PROCESS_STATUS_MSG_OVER;
+      goto _OVER;
     }
 
     if (statusReq.dnodeId == 0) {
-      mDebug("dnode:%d, %s first access, set clusterId %" PRId64, pDnode->id, pDnode->ep, pMnode->clusterId);
+      mInfo("dnode:%d, %s first access, set clusterId %" PRId64, pDnode->id, pDnode->ep, pMnode->clusterId);
     } else {
       if (statusReq.clusterId != pMnode->clusterId) {
         if (pDnode != NULL) {
@@ -418,7 +409,7 @@ static int32_t mndProcessStatusReq(SRpcMsg *pReq) {
         mError("dnode:%d, clusterId %" PRId64 " not match exist %" PRId64, pDnode->id, statusReq.clusterId,
                pMnode->clusterId);
         terrno = TSDB_CODE_MND_INVALID_CLUSTER_ID;
-        goto PROCESS_STATUS_MSG_OVER;
+        goto _OVER;
       } else {
         pDnode->accessTimes++;
         mTrace("dnode:%d, status received, access times %d", pDnode->id, pDnode->accessTimes);
@@ -426,18 +417,17 @@ static int32_t mndProcessStatusReq(SRpcMsg *pReq) {
     }
 
     // Verify whether the cluster parameters are consistent when status change from offline to ready
-    int32_t ret = mndCheckClusterCfgPara(pMnode, &statusReq.clusterCfg);
-    if (0 != ret) {
-      pDnode->offlineReason = ret;
-      mError("dnode:%d, cluster cfg inconsistent since:%s", pDnode->id, offlineReason[ret]);
+    pDnode->offlineReason = mndCheckClusterCfgPara(pMnode, pDnode, &statusReq.clusterCfg);
+    if (pDnode->offlineReason != 0) {
+      mError("dnode:%d, cluster cfg inconsistent since:%s", pDnode->id, offlineReason[pDnode->offlineReason]);
       terrno = TSDB_CODE_MND_INVALID_CLUSTER_CFG;
-      goto PROCESS_STATUS_MSG_OVER;
+      goto _OVER;
     }
 
     if (!online) {
       mInfo("dnode:%d, from offline to online", pDnode->id);
     } else {
-      mDebug("dnode:%d, send dnode epset, online:%d ver:% " PRId64 ":%" PRId64 " reboot:%d", pDnode->id, online,
+      mDebug("dnode:%d, send dnode epset, online:%d dnode_ver:%" PRId64 ":%" PRId64 " reboot:%d", pDnode->id, online,
              statusReq.dnodeVer, dnodeVer, reboot);
     }
 
@@ -452,7 +442,7 @@ static int32_t mndProcessStatusReq(SRpcMsg *pReq) {
     statusRsp.pDnodeEps = taosArrayInit(mndGetDnodeSize(pMnode), sizeof(SDnodeEp));
     if (statusRsp.pDnodeEps == NULL) {
       terrno = TSDB_CODE_OUT_OF_MEMORY;
-      goto PROCESS_STATUS_MSG_OVER;
+      goto _OVER;
     }
 
     mndGetDnodeData(pMnode, statusRsp.pDnodeEps);
@@ -469,13 +459,17 @@ static int32_t mndProcessStatusReq(SRpcMsg *pReq) {
   pDnode->lastAccessTime = curMs;
   code = 0;
 
-PROCESS_STATUS_MSG_OVER:
+_OVER:
   mndReleaseDnode(pMnode, pDnode);
   taosArrayDestroy(statusReq.pVloads);
   return code;
 }
 
 static int32_t mndCreateDnode(SMnode *pMnode, SRpcMsg *pReq, SCreateDnodeReq *pCreate) {
+  int32_t  code = -1;
+  SSdbRaw *pRaw = NULL;
+  STrans  *pTrans = NULL;
+
   SDnodeObj dnodeObj = {0};
   dnodeObj.id = sdbGetMaxId(pMnode->pSdb, SDB_DNODE);
   dnodeObj.createdTime = taosGetTimestampMs();
@@ -484,29 +478,22 @@ static int32_t mndCreateDnode(SMnode *pMnode, SRpcMsg *pReq, SCreateDnodeReq *pC
   memcpy(dnodeObj.fqdn, pCreate->fqdn, TSDB_FQDN_LEN);
   snprintf(dnodeObj.ep, TSDB_EP_LEN, "%s:%u", dnodeObj.fqdn, dnodeObj.port);
 
-  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_CONFLICT_GLOBAL, pReq);
-  if (pTrans == NULL) {
-    mError("dnode:%s, failed to create since %s", dnodeObj.ep, terrstr());
-    return -1;
-  }
+  pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_CONFLICT_GLOBAL, pReq);
+  if (pTrans == NULL) goto _OVER;
   mDebug("trans:%d, used to create dnode:%s", pTrans->id, dnodeObj.ep);
 
-  SSdbRaw *pCommitRaw = mndDnodeActionEncode(&dnodeObj);
-  if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) {
-    mError("trans:%d, failed to append commit log since %s", pTrans->id, terrstr());
-    mndTransDrop(pTrans);
-    return -1;
-  }
-  sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY);
+  pRaw = mndDnodeActionEncode(&dnodeObj);
+  if (pRaw == NULL || mndTransAppendCommitlog(pTrans, pRaw) != 0) goto _OVER;
+  sdbSetRawStatus(pRaw, SDB_STATUS_READY);
+  pRaw = NULL;
 
-  if (mndTransPrepare(pMnode, pTrans) != 0) {
-    mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr());
-    mndTransDrop(pTrans);
-    return -1;
-  }
+  if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;
+  code = 0;
 
+_OVER:
   mndTransDrop(pTrans);
-  return 0;
+  sdbFreeRaw(pRaw);
+  return code;
 }
 
 static int32_t mndProcessCreateDnodeReq(SRpcMsg *pReq) {
@@ -518,38 +505,37 @@ static int32_t mndProcessCreateDnodeReq(SRpcMsg *pReq) {
 
   if (tDeserializeSCreateDnodeReq(pReq->pCont, pReq->contLen, &createReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
-    goto CREATE_DNODE_OVER;
+    goto _OVER;
   }
 
   mDebug("dnode:%s:%d, start to create", createReq.fqdn, createReq.port);
 
   if (createReq.fqdn[0] == 0 || createReq.port <= 0 || createReq.port > UINT16_MAX) {
     terrno = TSDB_CODE_MND_INVALID_DNODE_EP;
-    goto CREATE_DNODE_OVER;
+    goto _OVER;
   }
 
   char ep[TSDB_EP_LEN];
   snprintf(ep, TSDB_EP_LEN, "%s:%d", createReq.fqdn, createReq.port);
   pDnode = mndAcquireDnodeByEp(pMnode, ep);
   if (pDnode != NULL) {
-    terrno = TSDB_CODE_MND_DNODE_ALREADY_EXIST;
-    goto CREATE_DNODE_OVER;
+    goto _OVER;
   }
 
   pUser = mndAcquireUser(pMnode, pReq->conn.user);
   if (pUser == NULL) {
     terrno = TSDB_CODE_MND_NO_USER_FROM_CONN;
-    goto CREATE_DNODE_OVER;
+    goto _OVER;
   }
 
   if (mndCheckNodeAuth(pUser) != 0) {
-    goto CREATE_DNODE_OVER;
+    goto _OVER;
   }
 
   code = mndCreateDnode(pMnode, pReq, &createReq);
   if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;
 
-CREATE_DNODE_OVER:
+_OVER:
   if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS) {
     mError("dnode:%s:%d, failed to create since %s", createReq.fqdn, createReq.port, terrstr());
   }
@@ -559,7 +545,7 @@ CREATE_DNODE_OVER:
   return code;
 }
 
-static int32_t mndDropDnode(SMnode *pMnode, SRpcMsg *pReq, SDnodeObj *pDnode, SMnodeObj *pMObj) {
+static int32_t mndDropDnode(SMnode *pMnode, SRpcMsg *pReq, SDnodeObj *pDnode, SMnodeObj *pMObj, int32_t numOfVnodes) {
   int32_t  code = -1;
   SSdbRaw *pRaw = NULL;
   STrans  *pTrans = NULL;
@@ -579,8 +565,12 @@ static int32_t mndDropDnode(SMnode *pMnode, SRpcMsg *pReq, SDnodeObj *pDnode, SM
   sdbSetRawStatus(pRaw, SDB_STATUS_DROPPED);
   pRaw = NULL;
 
-  if (mndSetDropMnodeInfoToTrans(pMnode, pTrans, pMObj) != 0) goto _OVER;
-  if (mndSetMoveVgroupsInfoToTrans(pMnode, pTrans, pDnode->id) != 0) goto _OVER;
+  if (pMObj != NULL) {
+    if (mndSetDropMnodeInfoToTrans(pMnode, pTrans, pMObj) != 0) goto _OVER;
+  }
+  if (numOfVnodes > 0) {
+    if (mndSetMoveVgroupsInfoToTrans(pMnode, pTrans, pDnode->id) != 0) goto _OVER;
+  }
   if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;
 
   code = 0;
@@ -617,11 +607,6 @@ static int32_t mndProcessDropDnodeReq(SRpcMsg *pReq) {
     goto _OVER;
   }
 
-  if (!mndIsDnodeOnline(pDnode, taosGetTimestampMs())) {
-    terrno = TSDB_CODE_NODE_OFFLINE;
-    goto _OVER;
-  }
-
   pMObj = mndAcquireMnode(pMnode, dropReq.dnodeId);
   if (pMObj != NULL) {
     if (sdbGetSize(pMnode->pSdb, SDB_MNODE) <= 1) {
@@ -629,7 +614,17 @@ static int32_t mndProcessDropDnodeReq(SRpcMsg *pReq) {
       goto _OVER;
     }
     if (pMnode->selfDnodeId == dropReq.dnodeId) {
-      terrno = TSDB_CODE_MND_CANT_DROP_MASTER;
+      terrno = TSDB_CODE_MND_CANT_DROP_LEADER;
+      goto _OVER;
+    }
+  }
+
+  int32_t numOfVnodes = mndGetVnodesNum(pMnode, pDnode->id);
+  if (numOfVnodes > 0 || pMObj != NULL) {
+    if (!mndIsDnodeOnline(pDnode, taosGetTimestampMs())) {
+      terrno = TSDB_CODE_NODE_OFFLINE;
+      mError("dnode:%d, failed to drop since %s, has_mnode:%d numOfVnodes:%d", pDnode->id, terrstr(), pMObj != NULL,
+             numOfVnodes);
       goto _OVER;
     }
   }
@@ -644,7 +639,7 @@ static int32_t mndProcessDropDnodeReq(SRpcMsg *pReq) {
     goto _OVER;
   }
 
-  code = mndDropDnode(pMnode, pReq, pDnode, pMObj);
+  code = mndDropDnode(pMnode, pReq, pDnode, pMObj, numOfVnodes);
   if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;
 
 _OVER:
@@ -669,7 +664,6 @@ static int32_t mndProcessConfigDnodeReq(SRpcMsg *pReq) {
 
   SDnodeObj *pDnode = mndAcquireDnode(pMnode, cfgReq.dnodeId);
   if (pDnode == NULL) {
-    terrno = TSDB_CODE_MND_DNODE_NOT_EXIST;
     mError("dnode:%d, failed to config since %s ", cfgReq.dnodeId, terrstr());
     return -1;
   }
@@ -679,17 +673,18 @@ static int32_t mndProcessConfigDnodeReq(SRpcMsg *pReq) {
 
   int32_t bufLen = tSerializeSMCfgDnodeReq(NULL, 0, &cfgReq);
   void   *pBuf = rpcMallocCont(bufLen);
+
+  if (pBuf == NULL) return -1;
   tSerializeSMCfgDnodeReq(pBuf, bufLen, &cfgReq);
 
+  mDebug("dnode:%d, send config req to dnode, app:%p", cfgReq.dnodeId, pReq->info.ahandle);
   SRpcMsg rpcMsg = {.msgType = TDMT_DND_CONFIG_DNODE, .pCont = pBuf, .contLen = bufLen, .info = pReq->info};
-
-  mDebug("dnode:%d, send config req to dnode, app:%p", cfgReq.dnodeId, rpcMsg.info.ahandle);
   return tmsgSendReq(&epSet, &rpcMsg);
 }
 
 static int32_t mndProcessConfigDnodeRsp(SRpcMsg *pRsp) {
   mDebug("config rsp from dnode, app:%p", pRsp->info.ahandle);
-  return TSDB_CODE_SUCCESS;
+  return 0;
 }
 
 static int32_t mndRetrieveConfigs(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) {
@@ -698,7 +693,7 @@ static int32_t mndRetrieveConfigs(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *p
   int32_t numOfRows = 0;
   char   *cfgOpts[TSDB_CONFIG_NUMBER] = {0};
   char    cfgVals[TSDB_CONFIG_NUMBER][TSDB_CONIIG_VALUE_LEN + 1] = {0};
-  char   *pWrite;
+  char   *pWrite = NULL;
   int32_t cols = 0;
 
   cfgOpts[totalRows] = "statusInterval";
@@ -724,7 +719,6 @@ static int32_t mndRetrieveConfigs(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *p
     cols = 0;
 
     STR_WITH_MAXSIZE_TO_VARSTR(buf, cfgOpts[i], TSDB_CONFIG_OPTION_LEN);
-
     SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
     colDataAppend(pColInfo, numOfRows, (const char *)buf, false);
 
@@ -774,7 +768,6 @@ static int32_t mndRetrieveDnodes(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pB
 
     char b1[9] = {0};
     STR_TO_VARSTR(b1, online ? "ready" : "offline");
-
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
     colDataAppend(pColInfo, numOfRows, b1, false);
 
@@ -792,7 +785,6 @@ static int32_t mndRetrieveDnodes(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pB
   }
 
   pShow->numOfRows += numOfRows;
-
   return numOfRows;
 }
 
diff --git a/source/dnode/mnode/impl/src/mndMnode.c b/source/dnode/mnode/impl/src/mndMnode.c
index 072ad05f5abbc10cdb93ff36a30e493a570d811e..027de66b42ddf4cf6a42fbf5e02e39e50f479106 100644
--- a/source/dnode/mnode/impl/src/mndMnode.c
+++ b/source/dnode/mnode/impl/src/mndMnode.c
@@ -588,7 +588,7 @@ static int32_t mndProcessDropMnodeReq(SRpcMsg *pReq) {
   }
 
   if (pMnode->selfDnodeId == dropReq.dnodeId) {
-    terrno = TSDB_CODE_MND_CANT_DROP_MASTER;
+    terrno = TSDB_CODE_MND_CANT_DROP_LEADER;
     goto _OVER;
   }
 
diff --git a/source/dnode/mnode/impl/src/mndSync.c b/source/dnode/mnode/impl/src/mndSync.c
index 245f0938b906300af29bf3f6caf71c834877eaa1..ce025d55478a913681229a0ff6d2563512406711 100644
--- a/source/dnode/mnode/impl/src/mndSync.c
+++ b/source/dnode/mnode/impl/src/mndSync.c
@@ -193,7 +193,7 @@ int32_t mndInitSync(SMnode *pMnode) {
 void mndCleanupSync(SMnode *pMnode) {
   SSyncMgmt *pMgmt = &pMnode->syncMgmt;
   syncStop(pMgmt->sync);
-  mDebug("sync:%" PRId64 " is stopped", pMgmt->sync);
+  mDebug("mnode sync is stopped, id:%" PRId64, pMgmt->sync);
 
   tsem_destroy(&pMgmt->syncSem);
   if (pMgmt->pWal != NULL) {
diff --git a/source/dnode/mnode/impl/src/mndTrans.c b/source/dnode/mnode/impl/src/mndTrans.c
index 8c0ba65fb295758ed3b0bcbd517259b6ca7846ed..c2097c069b10fe2d7dcb2211d0f93cd5cc9048d7 100644
--- a/source/dnode/mnode/impl/src/mndTrans.c
+++ b/source/dnode/mnode/impl/src/mndTrans.c
@@ -117,10 +117,10 @@ static SSdbRaw *mndTransActionEncode(STrans *pTrans) {
 
   int32_t dataPos = 0;
   SDB_SET_INT32(pRaw, dataPos, pTrans->id, _OVER)
-  SDB_SET_INT16(pRaw, dataPos, pTrans->stage, _OVER)
-  SDB_SET_INT16(pRaw, dataPos, pTrans->policy, _OVER)
-  SDB_SET_INT16(pRaw, dataPos, pTrans->conflict, _OVER)
-  SDB_SET_INT16(pRaw, dataPos, pTrans->exec, _OVER)
+  SDB_SET_INT8(pRaw, dataPos, pTrans->stage, _OVER)
+  SDB_SET_INT8(pRaw, dataPos, pTrans->policy, _OVER)
+  SDB_SET_INT8(pRaw, dataPos, pTrans->conflict, _OVER)
+  SDB_SET_INT8(pRaw, dataPos, pTrans->exec, _OVER)
   SDB_SET_INT64(pRaw, dataPos, pTrans->createdTime, _OVER)
   SDB_SET_BINARY(pRaw, dataPos, pTrans->dbname, TSDB_DB_FNAME_LEN, _OVER)
   SDB_SET_INT32(pRaw, dataPos, pTrans->redoActionPos, _OVER)
@@ -256,15 +256,15 @@ static SSdbRow *mndTransActionDecode(SSdbRaw *pRaw) {
 
   SDB_GET_INT32(pRaw, dataPos, &pTrans->id, _OVER)
 
-  int16_t stage = 0;
-  int16_t policy = 0;
-  int16_t conflict = 0;
-  int16_t exec = 0;
-  int8_t  actionType = 0;
-  SDB_GET_INT16(pRaw, dataPos, &stage, _OVER)
-  SDB_GET_INT16(pRaw, dataPos, &policy, _OVER)
-  SDB_GET_INT16(pRaw, dataPos, &conflict, _OVER)
-  SDB_GET_INT16(pRaw, dataPos, &exec, _OVER)
+  int8_t stage = 0;
+  int8_t policy = 0;
+  int8_t conflict = 0;
+  int8_t exec = 0;
+  int8_t actionType = 0;
+  SDB_GET_INT8(pRaw, dataPos, &stage, _OVER)
+  SDB_GET_INT8(pRaw, dataPos, &policy, _OVER)
+  SDB_GET_INT8(pRaw, dataPos, &conflict, _OVER)
+  SDB_GET_INT8(pRaw, dataPos, &exec, _OVER)
   pTrans->stage = stage;
   pTrans->policy = policy;
   pTrans->conflict = conflict;
@@ -290,7 +290,8 @@ static SSdbRow *mndTransActionDecode(SSdbRaw *pRaw) {
     SDB_GET_INT32(pRaw, dataPos, &action.acceptableCode, _OVER)
     SDB_GET_INT8(pRaw, dataPos, &actionType, _OVER)
     action.actionType = actionType;
-    SDB_GET_INT8(pRaw, dataPos, &action.stage, _OVER)
+    SDB_GET_INT8(pRaw, dataPos, &stage, _OVER)
+    action.stage = stage;
     if (action.actionType == TRANS_ACTION_RAW) {
       SDB_GET_INT8(pRaw, dataPos, &action.rawWritten, _OVER)
       SDB_GET_INT32(pRaw, dataPos, &dataLen, _OVER)
@@ -322,7 +323,8 @@ static SSdbRow *mndTransActionDecode(SSdbRaw *pRaw) {
     SDB_GET_INT32(pRaw, dataPos, &action.acceptableCode, _OVER)
     SDB_GET_INT8(pRaw, dataPos, &actionType, _OVER)
     action.actionType = actionType;
-    SDB_GET_INT8(pRaw, dataPos, &action.stage, _OVER)
+    SDB_GET_INT8(pRaw, dataPos, &stage, _OVER)
+    action.stage = stage;
     if (action.actionType == TRANS_ACTION_RAW) {
       SDB_GET_INT8(pRaw, dataPos, &action.rawWritten, _OVER)
       SDB_GET_INT32(pRaw, dataPos, &dataLen, _OVER)
@@ -354,7 +356,8 @@ static SSdbRow *mndTransActionDecode(SSdbRaw *pRaw) {
     SDB_GET_INT32(pRaw, dataPos, &action.acceptableCode, _OVER)
     SDB_GET_INT8(pRaw, dataPos, &actionType, _OVER)
     action.actionType = actionType;
-    SDB_GET_INT8(pRaw, dataPos, &action.stage, _OVER)
+    SDB_GET_INT8(pRaw, dataPos, &stage, _OVER)
+    action.stage = stage;
     if (action.actionType) {
       SDB_GET_INT8(pRaw, dataPos, &action.rawWritten, _OVER)
       SDB_GET_INT32(pRaw, dataPos, &dataLen, _OVER)
@@ -878,7 +881,6 @@ static void mndTransResetActions(SMnode *pMnode, STrans *pTrans, SArray *pArray)
       mDebug("trans:%d, %s:%d execute status is reset", pTrans->id, mndTransStr(pAction->stage), action);
     }
     pAction->errCode = 0;
-    
   }
 }
 
@@ -890,11 +892,12 @@ static int32_t mndTransWriteSingleLog(SMnode *pMnode, STrans *pTrans, STransActi
     pAction->rawWritten = true;
     pAction->errCode = 0;
     code = 0;
-    mDebug("trans:%d, %s:%d write to sdb", pTrans->id, mndTransStr(pAction->stage), pAction->id);
+    mDebug("trans:%d, %s:%d write to sdb, type:%s status:%s", pTrans->id, mndTransStr(pAction->stage), pAction->id,
+           sdbTableName(pAction->pRaw->type), sdbStatusName(pAction->pRaw->status));
   } else {
     pAction->errCode = (terrno != 0) ? terrno : code;
-    mError("trans:%d, %s:%d failed to write sdb since %s", pTrans->id, mndTransStr(pAction->stage), pAction->id,
-           terrstr());
+    mError("trans:%d, %s:%d failed to write sdb since %s, type:%s status:%s", pTrans->id, mndTransStr(pAction->stage),
+           pAction->id, terrstr(), sdbTableName(pAction->pRaw->type), sdbStatusName(pAction->pRaw->status));
   }
 
   return code;
@@ -916,18 +919,26 @@ static int32_t mndTransSendSingleMsg(SMnode *pMnode, STrans *pTrans, STransActio
   }
   memcpy(rpcMsg.pCont, pAction->pCont, pAction->contLen);
 
+  char    detail[1024] = {0};
+  int32_t len = snprintf(detail, sizeof(detail), "msgType:%s numOfEps:%d inUse:%d", TMSG_INFO(pAction->msgType),
+                         pAction->epSet.numOfEps, pAction->epSet.inUse);
+  for (int32_t i = 0; i < pTrans->lastErrorEpset.numOfEps; ++i) {
+    len += snprintf(detail + len, sizeof(detail) - len, " ep:%d-%s:%u", i, pAction->epSet.eps[i].fqdn,
+                    pAction->epSet.eps[i].port);
+  }
+
   int32_t code = tmsgSendReq(&pAction->epSet, &rpcMsg);
   if (code == 0) {
     pAction->msgSent = 1;
     pAction->msgReceived = 0;
     pAction->errCode = 0;
-    mDebug("trans:%d, %s:%d is sent to %s:%u", pTrans->id, mndTransStr(pAction->stage), pAction->id,
-           pAction->epSet.eps[pAction->epSet.inUse].fqdn, pAction->epSet.eps[pAction->epSet.inUse].port);
+    mDebug("trans:%d, %s:%d is sent, %s", pTrans->id, mndTransStr(pAction->stage), pAction->id, detail);
   } else {
     pAction->msgSent = 0;
     pAction->msgReceived = 0;
     pAction->errCode = (terrno != 0) ? terrno : code;
-    mError("trans:%d, %s:%d not send since %s", pTrans->id, mndTransStr(pAction->stage), pAction->id, terrstr());
+    mError("trans:%d, %s:%d not send since %s, %s", pTrans->id, mndTransStr(pAction->stage), pAction->id, terrstr(),
+           detail);
   }
 
   return code;
@@ -1424,9 +1435,9 @@ static int32_t mndRetrieveTrans(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBl
       if (epset.numOfEps > 0) {
         len += snprintf(detail + len, sizeof(detail) - len, "msgType:%s numOfEps:%d inUse:%d ",
                         TMSG_INFO(pTrans->lastErrorMsgType), epset.numOfEps, epset.inUse);
-      }
-      for (int32_t i = 0; i < pTrans->lastErrorEpset.numOfEps; ++i) {
-        len += snprintf(detail + len, sizeof(detail) - len, "ep:%d-%s:%u ", i, epset.eps[i].fqdn, epset.eps[i].port);
+        for (int32_t i = 0; i < pTrans->lastErrorEpset.numOfEps; ++i) {
+          len += snprintf(detail + len, sizeof(detail) - len, "ep:%d-%s:%u ", i, epset.eps[i].fqdn, epset.eps[i].port);
+        }
       }
     }
     STR_WITH_MAXSIZE_TO_VARSTR(lastError, detail, pShow->pMeta->pSchemas[cols].bytes);
diff --git a/source/dnode/mnode/sdb/inc/sdb.h b/source/dnode/mnode/sdb/inc/sdb.h
index 4a00befa1e8ec1b4ef4ff20a51a066ed08cf1883..944454380433ed1ee4944269ba6ef864e33742ed 100644
--- a/source/dnode/mnode/sdb/inc/sdb.h
+++ b/source/dnode/mnode/sdb/inc/sdb.h
@@ -392,6 +392,7 @@ int32_t sdbStopWrite(SSdb *pSdb, SSdbIter *pIter, bool isApply);
 int32_t sdbDoWrite(SSdb *pSdb, SSdbIter *pIter, void *pBuf, int32_t len);
 
 const char *sdbTableName(ESdbType type);
+const char *sdbStatusName(ESdbStatus status);
 void        sdbPrintOper(SSdb *pSdb, SSdbRow *pRow, const char *oper);
 int32_t     sdbGetIdFromRaw(SSdb *pSdb, SSdbRaw *pRaw);
 
diff --git a/source/dnode/mnode/sdb/src/sdbHash.c b/source/dnode/mnode/sdb/src/sdbHash.c
index 162da2bd0aaa3e2400f14cefa0596b5022e7afbe..d1b1e3163574efe1152c282455af19ad1ff569f1 100644
--- a/source/dnode/mnode/sdb/src/sdbHash.c
+++ b/source/dnode/mnode/sdb/src/sdbHash.c
@@ -65,7 +65,7 @@ const char *sdbTableName(ESdbType type) {
   }
 }
 
-static const char *sdbStatusName(ESdbStatus status) {
+const char *sdbStatusName(ESdbStatus status) {
   switch (status) {
     case SDB_STATUS_CREATING:
       return "creating";
diff --git a/source/util/src/terror.c b/source/util/src/terror.c
index c14c279d8151d80a5009f70a1c3ca0b1142e794f..0357ce7b4b1a934dd2a380c0cc2e2e5a2cc6708b 100644
--- a/source/util/src/terror.c
+++ b/source/util/src/terror.c
@@ -188,9 +188,9 @@ TAOS_DEFINE_ERROR(TSDB_CODE_MND_SNODE_ALREADY_EXIST,      "Snode already exists"
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_SNODE_NOT_EXIST,          "Snode not there")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_BNODE_ALREADY_EXIST,      "Bnode already exists")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_BNODE_NOT_EXIST,          "Bnode not there")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_TOO_FEW_MNODES,           "The replicas of mnode cannot less than 1")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_TOO_MANY_MNODES,          "The replicas of mnode cannot exceed 3")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_CANT_DROP_MASTER,         "Can't drop mnode which is leader")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_TOO_FEW_MNODES,           "The replica of mnode cannot less than 1")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_TOO_MANY_MNODES,          "The replica of mnode cannot exceed 3")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_CANT_DROP_LEADER,         "Cannot drop mnode which is leader")
 
 // mnode-acct
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_ACCT_ALREADY_EXIST,       "Account already exists")
diff --git a/tests/script/jenkins/basic.txt b/tests/script/jenkins/basic.txt
index 32056e8d0ceb2d128b25b86e24ce9d42dfa6ba15..3249c02e8869e51a738914fb531a9e315d3e7c41 100644
--- a/tests/script/jenkins/basic.txt
+++ b/tests/script/jenkins/basic.txt
@@ -21,7 +21,7 @@
 ./test.sh -f tsim/db/taosdlog.sim
 
 # ---- dnode
-./test.sh -f tsim/dnode/basic1.sim
+./test.sh -f tsim/dnode/create_dnode.sim
 
 # ---- insert
 ./test.sh -f tsim/insert/basic0.sim
diff --git a/tests/script/tsim/dnode/basic1.sim b/tests/script/tsim/dnode/create_dnode.sim
similarity index 100%
rename from tests/script/tsim/dnode/basic1.sim
rename to tests/script/tsim/dnode/create_dnode.sim