diff --git a/documentation/tdenginedocs-cn/taos-sql/index.html b/documentation/tdenginedocs-cn/taos-sql/index.html
index ec3e42d0901cf4730f54cc33d7a60890a64c2136..207bfe03fd41fb91322c34b754e07fd77711881e 100644
--- a/documentation/tdenginedocs-cn/taos-sql/index.html
+++ b/documentation/tdenginedocs-cn/taos-sql/index.html
@@ -359,9 +359,9 @@ SELECT function_list FROM tb_name
 
 SELECT function_list FROM stb_name 
   [WHERE where_condition]
-  [GROUP BY tags]
+  [FILL ({ VALUE | PREV | NULL | LINEAR})]
   INTERVAL (interval)
-  [FILL ({ VALUE | PREV | NULL | LINEAR})]</code></pre>
+  [GROUP BY tags]</code></pre>
 <ul>
 <li>聚合时间段的长度由关键词INTERVAL指定，最短时间间隔10毫秒（10a）。聚合查询中，能够同时执行的聚合和选择函数仅限于单个输出的函数：count、avg、sum 、stddev、leastsquares、percentile、min、max、first、last，不能使用具有多行输出结果的函数（例如：top、bottom、diff以及四则运算）。</li>
 <li>WHERE语句可以指定查询的起止时间和其他过滤条件 </li>
diff --git a/documentation/webdocs/markdowndocs/Super Table-ch.md b/documentation/webdocs/markdowndocs/Super Table-ch.md
index 9267e00a70454d15431e1aa8d7ae8a52d5e4965a..e75a8d46c38e3501b2c17b4a05b68c0e8fa4a707 100644
--- a/documentation/webdocs/markdowndocs/Super Table-ch.md	
+++ b/documentation/webdocs/markdowndocs/Super Table-ch.md	
@@ -54,7 +54,7 @@ STable从属于库，一个STable只属于一个库，但一个库可以有一
     说明：
 
     1. TAGS列总长度不能超过512 bytes；
-    2. TAGS列的数据类型不能是timestamp和nchar类型；
+    2. TAGS列的数据类型不能是timestamp；
     3. TAGS列名不能与其他列名相同;
     4. TAGS列名不能为预留关键字. 
 
@@ -169,7 +169,7 @@ SELECT function<field_name>,…
 
 以温度传感器采集时序数据作为例，示范STable的使用。 在这个例子中，对每个温度计都会建立一张表，表名为温度计的ID，温度计读数的时刻记为ts，采集的值记为degree。通过tags给每个采集器打上不同的标签，其中记录温度计的地区和类型，以方便我们后面的查询。所有温度计的采集量都一样，因此我们用STable来定义表结构。
 
-###定义STable表结构并使用它创建子表
+###1:定义STable表结构并使用它创建子表
 
 创建STable语句如下：
 
@@ -189,7 +189,7 @@ CREATE TABLE therm4 USING thermometer TAGS ('shanghai', 3);
 
 其中therm1，therm2，therm3，therm4是超级表thermometer四个具体的子表，也即普通的Table。以therm1为例，它表示采集器therm1的数据，表结构完全由thermometer定义，标签location=”beijing”, type=1表示therm1的地区是北京，类型是第1类的温度计。
 
-###写入数据
+###2:写入数据
 
 注意，写入数据时不能直接对STable操作，而是要对每张子表进行操作。我们分别向四张表therm1，therm2， therm3， therm4写入一条数据，写入语句如下：
 
@@ -200,7 +200,7 @@ INSERT INTO therm3 VALUES ('2018-01-01 00:00:00.000', 24);
 INSERT INTO therm4 VALUES ('2018-01-01 00:00:00.000', 23);
 ```
 
-### 按标签聚合查询
+###3:按标签聚合查询
 
 查询位于北京(beijing)和天津(tianjing)两个地区的温度传感器采样值的数量count(*)、平均温度avg(degree)、最高温度max(degree)、最低温度min(degree)，并将结果按所处地域(location)和传感器类型(type)进行聚合。
 
@@ -211,14 +211,14 @@ WHERE location='beijing' or location='tianjin'
 GROUP BY location, type 
 ```
 
-### 按时间周期聚合查询
+###4:按时间周期聚合查询
 
 查询仅位于北京以外地区的温度传感器最近24小时(24h)采样值的数量count(*)、平均温度avg(degree)、最高温度max(degree)和最低温度min(degree)，将采集结果按照10分钟为周期进行聚合，并将结果按所处地域(location)和传感器类型(type)再次进行聚合。
 
 ```mysql
 SELECT COUNT(*), AVG(degree), MAX(degree), MIN(degree)
 FROM thermometer
-WHERE name<>'beijing' and ts>=now-1d
+WHERE location<>'beijing' and ts>=now-1d
 INTERVAL(10M)
 GROUP BY location, type
 ```
diff --git a/documentation/webdocs/markdowndocs/Super Table.md b/documentation/webdocs/markdowndocs/Super Table.md
index 79a1650924373d4fbaa483115694aee1e753d203..609dd11bd278da3398330fa33f857fac65ffb3d5 100644
--- a/documentation/webdocs/markdowndocs/Super Table.md	
+++ b/documentation/webdocs/markdowndocs/Super Table.md	
@@ -23,7 +23,7 @@ New keyword "tags" is introduced, where tag_name is the tag name, and tag_type i
 Note：
 
 1. The bytes of all tags together shall be less than 512 
-2. Tag's data type can not be time stamp or nchar
+2. Tag's data type can not be time stamp
 3. Tag name shall be different from the field name
 4. Tag name shall not be the same as system keywords
 5. Maximum number of tags is 6 
@@ -102,7 +102,7 @@ List the number of records, average, maximum, and minimum temperature every 10 m
 ```mysql
 SELECT COUNT(*), AVG(degree), MAX(degree), MIN(degree)
 FROM thermometer
-WHERE name='beijing' and type=10 and ts>=now-1d
+WHERE location='beijing' and type=10 and ts>=now-1d
 INTERVAL(10M)
 ```
 
diff --git a/documentation/webdocs/markdowndocs/TAOS SQL-ch.md b/documentation/webdocs/markdowndocs/TAOS SQL-ch.md
index a6a1b4872afb82499352592599e7919646575ff4..6a8549bbd237a3413abfb28f26e0064140fe47d9 100644
--- a/documentation/webdocs/markdowndocs/TAOS SQL-ch.md	
+++ b/documentation/webdocs/markdowndocs/TAOS SQL-ch.md	
@@ -424,9 +424,9 @@ SELECT function_list FROM tb_name
 
 SELECT function_list FROM stb_name 
   [WHERE where_condition]
-  [GROUP BY tags]
   INTERVAL (interval)
   [FILL ({ VALUE | PREV | NULL | LINEAR})]
+  [GROUP BY tags]
 ```
 
 - 聚合时间段的长度由关键词INTERVAL指定，最短时间间隔10毫秒（10a）。聚合查询中，能够同时执行的聚合和选择函数仅限于单个输出的函数：count、avg、sum 、stddev、leastsquares、percentile、min、max、first、last，不能使用具有多行输出结果的函数（例如：top、bottom、diff以及四则运算）。
diff --git a/documentation/webdocs/markdowndocs/TAOS SQL.md b/documentation/webdocs/markdowndocs/TAOS SQL.md
index 2431514fa5e1f02738eaaed2e3440c315afeda12..870529417fbb4dd9dd1e73bb253962e9293e94f4 100644
--- a/documentation/webdocs/markdowndocs/TAOS SQL.md	
+++ b/documentation/webdocs/markdowndocs/TAOS SQL.md	
@@ -474,9 +474,9 @@ SELECT function_list FROM tb_name
 
 SELECT function_list FROM stb_name 
   [WHERE where_condition]
-  [GROUP BY tags]
   INTERVAL (interval)
   [FILL ({ VALUE | PREV | NULL | LINEAR})]
+  [GROUP BY tags]
 ```
 
 The downsampling time window is defined by `interval`, which is at least 10 milliseconds. The query returns a new series of downsampled data that has a series of fixed timestamps with an increment of `interval`. 
diff --git a/packaging/deb/makedeb.sh b/packaging/deb/makedeb.sh
index d54953113adf0b872bf538f17b97034f96483c37..e4c795f1b893f78a267faccd38cf1476aa30eba3 100755
--- a/packaging/deb/makedeb.sh
+++ b/packaging/deb/makedeb.sh
@@ -49,6 +49,7 @@ cp ${compile_dir}/build/bin/taosd                   ${pkg_dir}${install_home_pat
 cp ${compile_dir}/build/bin/taos                    ${pkg_dir}${install_home_path}/bin
 cp ${compile_dir}/build/lib/${libfile}              ${pkg_dir}${install_home_path}/driver 
 cp ${compile_dir}/../src/inc/taos.h                 ${pkg_dir}${install_home_path}/include
+cp ${compile_dir}/../src/inc/taoserror.h            ${pkg_dir}${install_home_path}/include
 cp -r ${top_dir}/tests/examples/*                   ${pkg_dir}${install_home_path}/examples
 cp -r ${top_dir}/src/connector/grafana              ${pkg_dir}${install_home_path}/connector
 cp -r ${top_dir}/src/connector/python               ${pkg_dir}${install_home_path}/connector
diff --git a/packaging/rpm/tdengine.spec b/packaging/rpm/tdengine.spec
index 6e9e5e6f8776607abb3ccc11296d0cf14cd90ba3..9ede4102e7c2e1903a2788c3559b5e41dd3cd196 100644
--- a/packaging/rpm/tdengine.spec
+++ b/packaging/rpm/tdengine.spec
@@ -62,6 +62,7 @@ cp %{_compiledir}/build/bin/taosdemo                %{buildroot}%{homepath}/bin
 cp %{_compiledir}/build/bin/taosdump                %{buildroot}%{homepath}/bin
 cp %{_compiledir}/build/lib/${libfile}              %{buildroot}%{homepath}/driver
 cp %{_compiledir}/../src/inc/taos.h                 %{buildroot}%{homepath}/include
+cp %{_compiledir}/../src/inc/taoserror.h            %{buildroot}%{homepath}/include
 cp -r %{_compiledir}/../src/connector/grafana       %{buildroot}%{homepath}/connector
 cp -r %{_compiledir}/../src/connector/python        %{buildroot}%{homepath}/connector
 cp -r %{_compiledir}/../src/connector/go            %{buildroot}%{homepath}/connector
@@ -138,6 +139,7 @@ if [ $1 -eq 0 ];then
     ${csudo} rm -f ${bin_link_dir}/taosdump   || :
     ${csudo} rm -f ${cfg_link_dir}/*          || :
     ${csudo} rm -f ${inc_link_dir}/taos.h     || :
+    ${csudo} rm -f ${inc_link_dir}/taoserror.h     || :
     ${csudo} rm -f ${lib_link_dir}/libtaos.*  || :
     
     ${csudo} rm -f ${log_link_dir}            || :
diff --git a/packaging/tools/install.sh b/packaging/tools/install.sh
index acd6c6ccce220479ce5778344edea4fbf85ea93f..4b653dec9c8307c1f893bad08d4ded6f7ece2b92 100755
--- a/packaging/tools/install.sh
+++ b/packaging/tools/install.sh
@@ -98,9 +98,10 @@ function install_lib() {
 }
 
 function install_header() {
-    ${csudo} rm -f ${inc_link_dir}/taos.h     || :    
+    ${csudo} rm -f ${inc_link_dir}/taos.h ${inc_link_dir}/taoserror.h    || :    
     ${csudo} cp -f ${script_dir}/inc/* ${install_main_dir}/include && ${csudo} chmod 644 ${install_main_dir}/include/*    
     ${csudo} ln -s ${install_main_dir}/include/taos.h ${inc_link_dir}/taos.h
+    ${csudo} ln -s ${install_main_dir}/include/taoserror.h ${inc_link_dir}/taoserror.h
 }
 
 function install_config() {
diff --git a/packaging/tools/make_install.sh b/packaging/tools/make_install.sh
index 4660ba5b2aafb197f086fc7b4804c910116f49be..c43f918e8d520a38a0184f0a2a970f6fd78b7cf5 100755
--- a/packaging/tools/make_install.sh
+++ b/packaging/tools/make_install.sh
@@ -109,9 +109,10 @@ function install_lib() {
 
 function install_header() {
 
-    ${csudo} rm -f ${inc_link_dir}/taos.h     || :    
-    ${csudo} cp -f ${source_dir}/src/inc/taos.h ${install_main_dir}/include && ${csudo} chmod 644 ${install_main_dir}/include/*    
+    ${csudo} rm -f ${inc_link_dir}/taos.h ${inc_link_dir}/taoserror.h    || :    
+    ${csudo} cp -f ${source_dir}/src/inc/taos.h ${source_dir}/src/inc/taoserror.h ${install_main_dir}/include && ${csudo} chmod 644 ${install_main_dir}/include/*    
     ${csudo} ln -s ${install_main_dir}/include/taos.h ${inc_link_dir}/taos.h
+    ${csudo} ln -s ${install_main_dir}/include/taoserror.h ${inc_link_dir}/taoserror.h
 }
 
 function install_config() {
diff --git a/packaging/tools/makepkg.sh b/packaging/tools/makepkg.sh
index 1a24ae8a1f4481abc69e27d6e654bf80cbb3225c..967b14cee915d17aa9b8e5aacd1698a2382c4e5b 100755
--- a/packaging/tools/makepkg.sh
+++ b/packaging/tools/makepkg.sh
@@ -22,7 +22,7 @@ install_dir="${release_dir}/taos-${version}-${package_name}-$(echo ${build_time}
 bin_files="${build_dir}/bin/taosd ${build_dir}/bin/taos ${build_dir}/bin/taosdemo ${build_dir}/bin/taosdump ${script_dir}/remove.sh"
 versioninfo=$(${script_dir}/get_version.sh ${code_dir}/util/src/version.c)
 lib_files="${build_dir}/lib/libtaos.so.${versioninfo}"
-header_files="${code_dir}/inc/taos.h"
+header_files="${code_dir}/inc/taos.h ${code_dir}/inc/taoserror.h"
 cfg_files="${top_dir}/packaging/cfg/*.cfg"
 install_files="${script_dir}/install.sh ${script_dir}/install_client.sh"
 
diff --git a/packaging/tools/post.sh b/packaging/tools/post.sh
index 9e1878365737d614369d536932ba0b00918d2a4f..11f3ab9a9ba0ca75d62c0bca1d81d7b03ff3eb4c 100755
--- a/packaging/tools/post.sh
+++ b/packaging/tools/post.sh
@@ -61,8 +61,9 @@ function kill_taosd() {
 }
 
 function install_include() {
-    ${csudo} rm -f ${inc_link_dir}/taos.h || :
+    ${csudo} rm -f ${inc_link_dir}/taos.h ${inc_link_dir}/taoserror.h|| :
     ${csudo} ln -s ${inc_dir}/taos.h ${inc_link_dir}/taos.h  
+    ${csudo} ln -s ${inc_dir}/taoserror.h ${inc_link_dir}/taoserror.h  
 }
 
 function install_lib() {
diff --git a/packaging/tools/preun.sh b/packaging/tools/preun.sh
index 4566db1b5afd185c415238f6501277da3638fcdc..a08f4e304e6f46116644b16f346074660bb445c5 100755
--- a/packaging/tools/preun.sh
+++ b/packaging/tools/preun.sh
@@ -94,6 +94,7 @@ ${csudo} rm -f ${bin_link_dir}/taosdemo   || :
 ${csudo} rm -f ${bin_link_dir}/taosdump   || :
 ${csudo} rm -f ${cfg_link_dir}/*          || :
 ${csudo} rm -f ${inc_link_dir}/taos.h     || :
+${csudo} rm -f ${inc_link_dir}/taoserror.h     || :
 ${csudo} rm -f ${lib_link_dir}/libtaos.*  || :
 
 ${csudo} rm -f ${log_link_dir}            || :
diff --git a/packaging/tools/remove.sh b/packaging/tools/remove.sh
index 4ada19762c55034751d64de0dd063100424b3503..6c2c6d5ea84fc25e8b3abe94a53e459b2bdb9a28 100755
--- a/packaging/tools/remove.sh
+++ b/packaging/tools/remove.sh
@@ -61,6 +61,7 @@ function clean_lib() {
 function clean_header() {
     # Remove link
     ${csudo} rm -f ${inc_link_dir}/taos.h       || :
+    ${csudo} rm -f ${inc_link_dir}/taoserror.h       || :
 }
 
 function clean_config() {
diff --git a/src/client/inc/tscCache.h b/src/client/inc/tscCache.h
index 096a6618f6e9fdef2a39886b9c55c2f960bc3c44..4c6acec096c01db64b09c4f0d18f404b8825f7b6 100644
--- a/src/client/inc/tscCache.h
+++ b/src/client/inc/tscCache.h
@@ -24,9 +24,9 @@ void *taosOpenConnCache(int maxSessions, void (*cleanFp)(void *), void *tmrCtrl,
 
 void taosCloseConnCache(void *handle);
 
-void *taosAddConnIntoCache(void *handle, void *data, uint32_t ip, short port, char *user);
+void *taosAddConnIntoCache(void *handle, void *data, uint32_t ip, uint16_t port, char *user);
 
-void *taosGetConnFromCache(void *handle, uint32_t ip, short port, char *user);
+void *taosGetConnFromCache(void *handle, uint32_t ip, uint16_t port, char *user);
 
 #ifdef __cplusplus
 }
diff --git a/src/client/inc/tscUtil.h b/src/client/inc/tscUtil.h
index e0c073d153bba06ab62277817a3c069829d8023a..47f25babe048394047092eb2ca40a25235b8d39b 100644
--- a/src/client/inc/tscUtil.h
+++ b/src/client/inc/tscUtil.h
@@ -226,7 +226,7 @@ void doAddGroupColumnForSubquery(SSqlCmd* pCmd, int32_t tagIndex);
 
 int16_t tscGetJoinTagColIndexByUid(SSqlCmd* pCmd, uint64_t uid);
 
-TAOS* taos_connect_a(char* ip, char* user, char* pass, char* db, int port, void (*fp)(void*, TAOS_RES*, int),
+TAOS* taos_connect_a(char* ip, char* user, char* pass, char* db, uint16_t port, void (*fp)(void*, TAOS_RES*, int),
                      void* param, void** taos);
 
 void sortRemoveDuplicates(STableDataBlocks* dataBuf);
diff --git a/src/client/inc/tsclient.h b/src/client/inc/tsclient.h
index 44bfc978a39223f5f2d67b9f922f8f09bcdd44df..7341d674d35d4ccdc5e122b5a9a9d4205f7f8306 100644
--- a/src/client/inc/tsclient.h
+++ b/src/client/inc/tsclient.h
@@ -342,7 +342,7 @@ typedef struct _tsc_obj {
   void *           signature;
   void *           pTimer;
   char             mgmtIp[TSDB_USER_LEN];
-  short            mgmtPort;
+  uint16_t         mgmtPort;
   char             user[TSDB_USER_LEN];
   char             pass[TSDB_KEY_LEN];
   char             acctId[TSDB_DB_NAME_LEN];
diff --git a/src/client/src/tscCache.c b/src/client/src/tscCache.c
index f508857ce1bc1477dc898de400b96c234ffe9bd8..1ac32d7502ee99c38f84445cfeb767ad316b06ed 100644
--- a/src/client/src/tscCache.c
+++ b/src/client/src/tscCache.c
@@ -25,7 +25,7 @@
 
 typedef struct _c_hash_t {
   uint32_t          ip;
-  short             port;
+  uint16_t          port;
   struct _c_hash_t *prev;
   struct _c_hash_t *next;
   void *            data;
@@ -45,14 +45,14 @@ typedef struct {
   void *pTimer;
 } SConnCache;
 
-int taosHashConn(void *handle, uint32_t ip, short port, char *user) {
+int taosHashConn(void *handle, uint32_t ip, uint16_t port, char *user) {
   SConnCache *pObj = (SConnCache *)handle;
   int         hash = 0;
   // size_t    user_len = strlen(user);
 
   hash = ip >> 16;
   hash += (unsigned short)(ip & 0xFFFF);
-  hash += (unsigned short)port;
+  hash += port;
   while (*user != '\0') {
     hash += *user;
     user++;
@@ -74,7 +74,7 @@ void taosRemoveExpiredNodes(SConnCache *pObj, SConnHash *pNode, int hash, uint64
     pNext = pNode->next;
     pObj->total--;
     pObj->count[hash]--;
-    tscTrace("%p ip:0x%x:%d:%d:%p removed, connections in cache:%d", pNode->data, pNode->ip, pNode->port, hash, pNode,
+    tscTrace("%p ip:0x%x:%hu:%d:%p removed, connections in cache:%d", pNode->data, pNode->ip, pNode->port, hash, pNode,
              pObj->count[hash]);
     taosMemPoolFree(pObj->connHashMemPool, (char *)pNode);
     pNode = pNext;
@@ -86,7 +86,7 @@ void taosRemoveExpiredNodes(SConnCache *pObj, SConnHash *pNode, int hash, uint64
     pObj->connHashList[hash] = NULL;
 }
 
-void *taosAddConnIntoCache(void *handle, void *data, uint32_t ip, short port, char *user) {
+void *taosAddConnIntoCache(void *handle, void *data, uint32_t ip, uint16_t port, char *user) {
   int         hash;
   SConnHash * pNode;
   SConnCache *pObj;
@@ -125,7 +125,7 @@ void *taosAddConnIntoCache(void *handle, void *data, uint32_t ip, short port, ch
 
   pthread_mutex_unlock(&pObj->mutex);
 
-  tscTrace("%p ip:0x%x:%d:%d:%p added, connections in cache:%d", data, ip, port, hash, pNode, pObj->count[hash]);
+  tscTrace("%p ip:0x%x:%hu:%d:%p added, connections in cache:%d", data, ip, port, hash, pNode, pObj->count[hash]);
 
   return pObj;
 }
@@ -152,7 +152,7 @@ void taosCleanConnCache(void *handle, void *tmrId) {
   taosTmrReset(taosCleanConnCache, pObj->keepTimer * 2, pObj, pObj->tmrCtrl, &pObj->pTimer);
 }
 
-void *taosGetConnFromCache(void *handle, uint32_t ip, short port, char *user) {
+void *taosGetConnFromCache(void *handle, uint32_t ip, uint16_t port, char *user) {
   int         hash;
   SConnHash * pNode;
   SConnCache *pObj;
@@ -201,7 +201,7 @@ void *taosGetConnFromCache(void *handle, uint32_t ip, short port, char *user) {
   pthread_mutex_unlock(&pObj->mutex);
 
   if (pData) {
-    tscTrace("%p ip:0x%x:%d:%d:%p retrieved, connections in cache:%d", pData, ip, port, hash, pNode, pObj->count[hash]);
+    tscTrace("%p ip:0x%x:%hu:%d:%p retrieved, connections in cache:%d", pData, ip, port, hash, pNode, pObj->count[hash]);
   }
 
   return pData;
diff --git a/src/client/src/tscParseInsert.c b/src/client/src/tscParseInsert.c
index c8ce728de15858e2628bb6a8debd011197ecd184..abebea64df05c1bc6d9e48059074343724290a31 100644
--- a/src/client/src/tscParseInsert.c
+++ b/src/client/src/tscParseInsert.c
@@ -191,10 +191,10 @@ int32_t tsParseOneColumnData(SSchema *pSchema, SSQLToken *pToken, char *payload,
         *((int8_t *)payload) = TSDB_DATA_TINYINT_NULL;
       } else {
         numType = tscToInteger(pToken, &iv, &endptr);
-        if (errno == ERANGE || iv > INT8_MAX || iv <= INT8_MIN) {
-          INVALID_SQL_RET_MSG(msg, "data is overflow");
-        } else if (TK_ILLEGAL == numType) {
+        if (TK_ILLEGAL == numType) {
           INVALID_SQL_RET_MSG(msg, "data is illegal");
+        } else if (errno == ERANGE || iv > INT8_MAX || iv <= INT8_MIN) {
+          INVALID_SQL_RET_MSG(msg, "data is overflow");
         }
 
         *((int8_t *)payload) = (int8_t)iv;
@@ -210,10 +210,10 @@ int32_t tsParseOneColumnData(SSchema *pSchema, SSQLToken *pToken, char *payload,
         *((int16_t *)payload) = TSDB_DATA_SMALLINT_NULL;
       } else {
         numType = tscToInteger(pToken, &iv, &endptr);
-        if (errno == ERANGE || iv > INT16_MAX || iv <= INT16_MIN) {
-          INVALID_SQL_RET_MSG(msg, "data is overflow");
-        } else if (TK_ILLEGAL == numType) {
+        if (TK_ILLEGAL == numType) {
           INVALID_SQL_RET_MSG(msg, "data is illegal");
+        } else if (errno == ERANGE || iv > INT16_MAX || iv <= INT16_MIN) {
+          INVALID_SQL_RET_MSG(msg, "data is overflow");
         }
 
         *((int16_t *)payload) = (int16_t)iv;
@@ -228,10 +228,10 @@ int32_t tsParseOneColumnData(SSchema *pSchema, SSQLToken *pToken, char *payload,
         *((int32_t *)payload) = TSDB_DATA_INT_NULL;
       } else {
         numType = tscToInteger(pToken, &iv, &endptr);
-        if (errno == ERANGE || iv > INT32_MAX || iv <= INT32_MIN) {
-          INVALID_SQL_RET_MSG(msg, "data is overflow");
-        } else if (TK_ILLEGAL == numType) {
+        if (TK_ILLEGAL == numType) {
           INVALID_SQL_RET_MSG(msg, "data is illegal");
+        } else if (errno == ERANGE || iv > INT32_MAX || iv <= INT32_MIN) {
+          INVALID_SQL_RET_MSG(msg, "data is overflow");
         }
 
         *((int32_t *)payload) = (int32_t)iv;
@@ -247,10 +247,10 @@ int32_t tsParseOneColumnData(SSchema *pSchema, SSQLToken *pToken, char *payload,
         *((int64_t *)payload) = TSDB_DATA_BIGINT_NULL;
       } else {
         numType = tscToInteger(pToken, &iv, &endptr);
-        if (errno == ERANGE || iv > INT64_MAX || iv <= INT64_MIN) {
-          INVALID_SQL_RET_MSG(msg, "data is overflow");
-        } else if (TK_ILLEGAL == numType) {
+        if (TK_ILLEGAL == numType) {
           INVALID_SQL_RET_MSG(msg, "data is illegal");
+        } else if (errno == ERANGE || iv > INT64_MAX || iv <= INT64_MIN) {
+          INVALID_SQL_RET_MSG(msg, "data is overflow");
         }
 
         *((int64_t *)payload) = iv;
diff --git a/src/client/src/tscProfile.c b/src/client/src/tscProfile.c
index 350167a3b35ba8e1dbf32c5b93bb6011e09adddf..61bc9dd99ee7254015f6c457843b70c4c60223d1 100644
--- a/src/client/src/tscProfile.c
+++ b/src/client/src/tscProfile.c
@@ -23,7 +23,7 @@
 void  tscSaveSlowQueryFp(void *handle, void *tmrId);
 void *tscSlowQueryConn = NULL;
 bool  tscSlowQueryConnInitialized = false;
-TAOS *taos_connect_a(char *ip, char *user, char *pass, char *db, int port, void (*fp)(void *, TAOS_RES *, int),
+TAOS *taos_connect_a(char *ip, char *user, char *pass, char *db, uint16_t port, void (*fp)(void *, TAOS_RES *, int),
                      void *param, void **taos);
 
 void tscInitConnCb(void *param, TAOS_RES *result, int code) {
diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index c66d524fee1912f8bcb963a7d009efea0c87da80..f5727677c57bf38922bed9f7fc3fd7b9bd81ab63 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -2669,7 +2669,7 @@ int32_t setKillInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
     return TSDB_CODE_INVALID_SQL;
   }
 
-  int32_t port = strtol(portStr, NULL, 10);
+  uint16_t port = (uint16_t)strtol(portStr, NULL, 10);
   if (port <= 0 || port > 65535) {
     memset(pCmd->payload, 0, tListLen(pCmd->payload));
 
diff --git a/src/client/src/tscSql.c b/src/client/src/tscSql.c
index 9dd9649a01c5c735f8937f04e627e885b55e3d51..54064d4c83645d861629c9ca4d7f2f3d398c806b 100644
--- a/src/client/src/tscSql.c
+++ b/src/client/src/tscSql.c
@@ -28,7 +28,7 @@
 #include "ttimer.h"
 #include "tutil.h"
 
-TAOS *taos_connect_imp(const char *ip, const char *user, const char *pass, const char *db, int port, void (*fp)(void *, TAOS_RES *, int),
+TAOS *taos_connect_imp(const char *ip, const char *user, const char *pass, const char *db, uint16_t port, void (*fp)(void *, TAOS_RES *, int),
                        void *param, void **taos) {
   STscObj *pObj;
 
@@ -153,7 +153,7 @@ TAOS *taos_connect_imp(const char *ip, const char *user, const char *pass, const
   return pObj;
 }
 
-TAOS *taos_connect(const char *ip, const char *user, const char *pass, const char *db, int port) {
+TAOS *taos_connect(const char *ip, const char *user, const char *pass, const char *db, uint16_t port) {
   if (ip == NULL || (ip != NULL && (strcmp("127.0.0.1", ip) == 0 || strcasecmp("localhost", ip) == 0))) {
 #ifdef CLUSTER
     ip = tsPrivateIp;
@@ -205,7 +205,7 @@ TAOS *taos_connect(const char *ip, const char *user, const char *pass, const cha
   return taos;
 }
 
-TAOS *taos_connect_a(char *ip, char *user, char *pass, char *db, int port, void (*fp)(void *, TAOS_RES *, int),
+TAOS *taos_connect_a(char *ip, char *user, char *pass, char *db, uint16_t port, void (*fp)(void *, TAOS_RES *, int),
                      void *param, void **taos) {
 #ifndef CLUSTER
   if (ip == NULL) {
diff --git a/src/client/src/tscSystem.c b/src/client/src/tscSystem.c
index 2842754e408b56ee8373161c8e21cdfe9dc2ad45..2c5ad2939a0ee7f13a233bcc387f39ba89ba94b4 100644
--- a/src/client/src/tscSystem.c
+++ b/src/client/src/tscSystem.c
@@ -83,6 +83,8 @@ void taos_init_imp() {
     tscTrace("Local IP address is:%s", tsLocalIp);
   }
 
+  taosSetCoreDump();
+
 #ifdef CLUSTER
   tscMgmtIpList.numOfIps = 2;
   strcpy(tscMgmtIpList.ipstr[0], tsMasterIp);
diff --git a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBDriver.java b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBDriver.java
index 7881c06b6a3e6e61685abb9329b9ca36af803ee5..c297fb67b063355b4499b1020499104e1e10f627 100755
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBDriver.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBDriver.java
@@ -273,6 +273,9 @@ public class TSDBDriver implements java.sql.Driver {
 		String user = "";
 		for (String queryStr : queryStrings) {
 			String[] kvPair = queryStr.trim().split("=");
+			if (kvPair.length < 2){
+				continue;
+			}
 			switch (kvPair[0].toLowerCase()) {
 				case PROPERTY_KEY_USER:
 					urlProps.setProperty(PROPERTY_KEY_USER, kvPair[1]);
diff --git a/src/inc/sdb.h b/src/inc/sdb.h
index 4a1969b700bef0b0fbce3e7058c7f33146174bdf..389aecfb7b6a3ea047251d45d853b8f3e873021d 100644
--- a/src/inc/sdb.h
+++ b/src/inc/sdb.h
@@ -23,10 +23,10 @@ extern "C" {
 #include "taosmsg.h"
 #include "tsdb.h"
 
-extern short    sdbPeerPort;
-extern short    sdbSyncPort;
+extern uint16_t    tsMgmtMgmtPort;
+extern uint16_t    tsMgmtSyncPort;
 extern int      sdbMaxNodes;
-extern int      sdbHbTimer;  // seconds
+extern int      tsMgmtPeerHBTimer;  // seconds
 extern char     sdbZone[];
 extern char     sdbMasterIp[];
 extern char     sdbPrivateIp[];
diff --git a/src/inc/taos.h b/src/inc/taos.h
index 05acc9155135581c0798b89a0f3bf52ecea3e2b9..2fd6d8be927a310e0131b62a8f0ecf55ae943ef2 100644
--- a/src/inc/taos.h
+++ b/src/inc/taos.h
@@ -59,7 +59,7 @@ typedef struct taosField {
 
 void  taos_init();
 int   taos_options(TSDB_OPTION option, const void *arg, ...);
-TAOS *taos_connect(const char *ip, const char *user, const char *pass, const char *db, int port);
+TAOS *taos_connect(const char *ip, const char *user, const char *pass, const char *db, uint16_t port);
 void  taos_close(TAOS *taos);
 
 typedef struct TAOS_BIND {
diff --git a/src/inc/taoserror.h b/src/inc/taoserror.h
index fbb7bf86dabf079850874dc15f4d8af91dff4db1..5510212dbc37f6ce3ebb33c43d34ca93fc0649c1 100644
--- a/src/inc/taoserror.h
+++ b/src/inc/taoserror.h
@@ -134,6 +134,8 @@ extern "C" {
 #define TSDB_CODE_INVALID_SUBMIT_MSG         113
 #define TSDB_CODE_NOT_ACTIVE_TABLE           114
 #define TSDB_CODE_INVALID_TABLE_ID           115
+#define TSDB_CODE_INVALID_VNODE_STATUS       116
+#define TSDB_CODE_FAILED_TO_LOCK_RESOURCES   117
 
 #ifdef __cplusplus
 }
diff --git a/src/inc/taosmsg.h b/src/inc/taosmsg.h
index e75404ad988f6b78a60a96df15a51c2b0b473b5b..d02251c2121966633e96d5167bb44f452512bb7a 100644
--- a/src/inc/taosmsg.h
+++ b/src/inc/taosmsg.h
@@ -222,7 +222,7 @@ typedef struct {
   // internal part
   uint32_t destId;
   char     meterId[TSDB_UNI_LEN];
-  short    port;  // for UDP only
+  uint16_t port;  // for UDP only
   char     empty[1];
   char     msgType;
   int32_t  msgLen;
diff --git a/src/inc/tglobalcfg.h b/src/inc/tglobalcfg.h
index 09ced23c91c073ba9b6208a13be1cf789ef17dd5..577f3e8c8975bbb6cf734dc75d37d69793327813 100644
--- a/src/inc/tglobalcfg.h
+++ b/src/inc/tglobalcfg.h
@@ -57,12 +57,12 @@ extern char scriptDir[];
 
 extern char  tsMasterIp[];
 extern char  tsSecondIp[];
-extern short tsMgmtVnodePort;
-extern short tsMgmtShellPort;
-extern short tsVnodeShellPort;
-extern short tsVnodeVnodePort;
-extern short tsMgmtMgmtPort;
-extern short tsMgmtSyncPort;
+extern uint16_t tsMgmtVnodePort;
+extern uint16_t tsMgmtShellPort;
+extern uint16_t tsVnodeShellPort;
+extern uint16_t tsVnodeVnodePort;
+extern uint16_t tsMgmtMgmtPort;
+extern uint16_t tsMgmtSyncPort;
 
 extern int tsStatusInterval;
 extern int tsShellActivityTimer;
@@ -141,7 +141,7 @@ extern int     tsProjectExecInterval;
 extern int64_t tsMaxRetentWindow;
 
 extern char  tsHttpIp[];
-extern short tsHttpPort;
+extern uint16_t tsHttpPort;
 extern int   tsHttpCacheSessions;
 extern int   tsHttpSessionExpire;
 extern int   tsHttpMaxThreads;
diff --git a/src/inc/trpc.h b/src/inc/trpc.h
index 3ae6e9ea97fc21df0b5f6fad1d240162f975159e..97a0c905f8c3584fee0de46b064f79a78db19f15 100644
--- a/src/inc/trpc.h
+++ b/src/inc/trpc.h
@@ -25,7 +25,6 @@ extern "C" {
 
 #define TAOS_CONN_UDPS     0
 #define TAOS_CONN_UDPC     1
-#define TAOS_CONN_UDP      1
 #define TAOS_CONN_TCPS     2
 #define TAOS_CONN_TCPC     3
 #define TAOS_CONN_HTTPS    4
@@ -39,7 +38,7 @@ extern "C" {
 #define TAOS_ID_REALLOCATE 2
 
 #define TAOS_CONN_SOCKET_TYPE_S()  ((strcasecmp(tsSocketType, TAOS_SOCKET_TYPE_NAME_UDP) == 0)? TAOS_CONN_UDPS:TAOS_CONN_TCPS)
-#define TAOS_CONN_SOCKET_TYPE_C()  ((strcasecmp(tsSocketType, TAOS_SOCKET_TYPE_NAME_UDP) == 0)? TAOS_CONN_UDP:TAOS_CONN_TCPC)
+#define TAOS_CONN_SOCKET_TYPE_C()  ((strcasecmp(tsSocketType, TAOS_SOCKET_TYPE_NAME_UDP) == 0)? TAOS_CONN_UDPC:TAOS_CONN_TCPC)
 
 #define taosSendMsgToPeer(x, y, z) taosSendMsgToPeerH(x, y, z, NULL)
 #define taosOpenRpcChann(x, y, z) taosOpenRpcChannWithQ(x,y,z,NULL)
@@ -48,7 +47,7 @@ extern "C" {
 
 typedef struct {
   char *localIp;                        // local IP used
-  short localPort;                      // local port
+  uint16_t localPort;                      // local port
   char *label;                          // for debug purpose
   int   numOfThreads;                   // number of threads to handle connections
   void *(*fp)(char *, void *, void *);  // function to process the incoming msg
@@ -73,7 +72,7 @@ typedef struct {
   void *   shandle;   // pointer returned by taosOpenRpc
   void *   ahandle;   // handle provided by app
   char *   peerIp;    // peer IP string
-  short    peerPort;  // peer port
+  uint16_t    peerPort;  // peer port
   char     spi;       // security parameter index
   char     encrypt;   // encrypt algorithm
   char *   secret;    // key for authentication
@@ -108,7 +107,7 @@ int taosSendSimpleRsp(void *thandle, char rsptype, char code);
 
 int taosSetSecurityInfo(int cid, int sid, char *id, int spi, int encrypt, char *secret, char *ckey);
 
-void taosGetRpcConnInfo(void *thandle, uint32_t *peerId, uint32_t *peerIp, short *peerPort, int *cid, int *sid);
+void taosGetRpcConnInfo(void *thandle, uint32_t *peerId, uint32_t *peerIp, uint16_t *peerPort, int *cid, int *sid);
 
 int taosGetOutType(void *thandle);
 
diff --git a/src/inc/tsdb.h b/src/inc/tsdb.h
index 4c43171283b5341fd8aff41c3c8c9637803c1f1d..771046d4d192b27275cf5765018ba4ba2adec462 100644
--- a/src/inc/tsdb.h
+++ b/src/inc/tsdb.h
@@ -44,22 +44,40 @@ extern "C" {
 #define TSDB_TIME_PRECISION_MILLI_STR "ms"
 #define TSDB_TIME_PRECISION_MICRO_STR "us"
 
-enum _status {
-  TSDB_STATUS_OFFLINE,
-  TSDB_STATUS_CREATING,
-  TSDB_STATUS_UNSYNCED,
-  TSDB_STATUS_SLAVE,
-  TSDB_STATUS_MASTER,
-  TSDB_STATUS_READY,
+  enum _vnode_status {
+  TSDB_VNODE_STATUS_OFFLINE,
+  TSDB_VNODE_STATUS_CREATING,
+  TSDB_VNODE_STATUS_UNSYNCED,
+  TSDB_VNODE_STATUS_SLAVE,
+  TSDB_VNODE_STATUS_MASTER,
+  TSDB_VNODE_STATUS_CLOSING,
+  TSDB_VNODE_STATUS_DELETING,
 };
 
-enum _syncstatus {
+enum _vnode_sync_status {
   STDB_SSTATUS_INIT,
   TSDB_SSTATUS_SYNCING,
   TSDB_SSTATUS_SYNC_CACHE,
   TSDB_SSTATUS_SYNC_FILE,
 };
 
+enum _dnode_status {
+    TSDB_DNODE_STATUS_OFFLINE,
+    TSDB_DNODE_STATUS_READY
+};
+
+enum _dnode_balance_status {
+    LB_DNODE_STATE_BALANCED,
+    LB_DNODE_STATE_BALANCING,
+    LB_DNODE_STATE_OFFLINE_REMOVING,
+    LB_DNODE_STATE_SHELL_REMOVING
+};
+
+enum _vgroup_status {
+    LB_VGROUP_STATE_READY,
+    LB_VGROUP_STATE_UPDATE
+};
+
 #define TSDB_DATA_TYPE_BOOL       1     // 1 bytes
 #define TSDB_DATA_TYPE_TINYINT    2     // 1 byte
 #define TSDB_DATA_TYPE_SMALLINT   3     // 2 bytes
diff --git a/src/inc/tsocket.h b/src/inc/tsocket.h
index 0a02fcf551d210ed2de5e53ca83e1697a2cfcd11..9eb4c26464538fc3ea9d6f088cfb209192636493 100644
--- a/src/inc/tsocket.h
+++ b/src/inc/tsocket.h
@@ -33,19 +33,19 @@ int taosWriteMsg(int fd, void *ptr, int nbytes);
 
 int taosReadMsg(int fd, void *ptr, int nbytes);
 
-int taosOpenUdpSocket(char *ip, short port);
+int taosOpenUdpSocket(char *ip, uint16_t port);
 
-int taosOpenTcpClientSocket(char *ip, short port, char *localIp);
+int taosOpenTcpClientSocket(char *ip, uint16_t port, char *localIp);
 
-int taosOpenTcpServerSocket(char *ip, short port);
+int taosOpenTcpServerSocket(char *ip, uint16_t port);
 
 int taosKeepTcpAlive(int sockFd);
 
 void taosCloseTcpSocket(int sockFd);
 
-int taosOpenUDServerSocket(char *ip, short port);
+int taosOpenUDServerSocket(char *ip, uint16_t port);
 
-int taosOpenUDClientSocket(char *ip, short port);
+int taosOpenUDClientSocket(char *ip, uint16_t port);
 
 int taosOpenRawSocket(char *ip);
 
diff --git a/src/inc/tstatus.h b/src/inc/tstatus.h
index 34bc7c6f27385c92838a41489eac160b8733d03f..34319e40b356a7514ce6192e40e1f9a27bbaf9ee 100644
--- a/src/inc/tstatus.h
+++ b/src/inc/tstatus.h
@@ -20,10 +20,11 @@
 extern "C" {
 #endif
 
-extern char *sdbDnodeStatusStr[];
-extern char *sdbDnodeBalanceStateStr[];
-extern char *sdbVnodeDropStateStr[];
-extern char *sdbVnodeSyncStatusStr[];
+const char* taosGetVnodeStatusStr(int vnodeStatus);
+const char* taosGetDnodeStatusStr(int dnodeStatus);
+const char* taosGetDnodeBalanceStateStr(int dnodeBalanceStatus);
+const char* taosGetVnodeSyncStatusStr(int vnodeSyncStatus);
+const char* taosGetVnodeDropStatusStr(int dropping);
 
 #ifdef __cplusplus
 }
diff --git a/src/kit/taosdemo/taosdemo.c b/src/kit/taosdemo/taosdemo.c
index 47ed92e2f7fd7be1c83f181d2fbcaeb00cc2dbe0..37530e1e8ce87d3a2a8e0a74abbb154ead6b770f 100644
--- a/src/kit/taosdemo/taosdemo.c
+++ b/src/kit/taosdemo/taosdemo.c
@@ -67,7 +67,7 @@ static struct argp_option options[] = {
 /* Used by main to communicate with parse_opt. */
 struct arguments {
   char  *host;
-  int    port;
+  uint16_t    port;
   char  *user;
   char  *password;
   char  *database;
@@ -310,7 +310,7 @@ int main(int argc, char *argv[]) {
   
   enum MODE query_mode = arguments.mode;
   char *ip_addr = arguments.host;
-  int port = arguments.port;
+  uint16_t port = arguments.port;
   char *user = arguments.user;
   char *pass = arguments.password;
   char *db_name = arguments.database;
@@ -343,7 +343,7 @@ int main(int argc, char *argv[]) {
   struct tm tm = *localtime(&tTime);
 
   fprintf(fp, "###################################################################\n");
-  fprintf(fp, "# Server IP:                         %s:%d\n", ip_addr == NULL ? "localhost" : ip_addr, port);
+  fprintf(fp, "# Server IP:                         %s:%hu\n", ip_addr == NULL ? "localhost" : ip_addr, port);
   fprintf(fp, "# User:                              %s\n", user);
   fprintf(fp, "# Password:                          %s\n", pass);
   fprintf(fp, "# Use metric:                        %s\n", use_metric ? "true" : "false");
diff --git a/src/kit/taosdump/taosdump.c b/src/kit/taosdump/taosdump.c
index f168a0d90fd68477d57019f81af0494e643a0c7f..c8ef3bc0481c72d284485d7c369db97de6d780e9 100644
--- a/src/kit/taosdump/taosdump.c
+++ b/src/kit/taosdump/taosdump.c
@@ -172,7 +172,7 @@ struct arguments {
   char *host;
   char *user;
   char *password;
-  int port;
+  uint16_t port;
   // output file
   char output[TSDB_FILENAME_LEN + 1];
   char input[TSDB_FILENAME_LEN + 1];
diff --git a/src/modules/http/inc/httpHandle.h b/src/modules/http/inc/httpHandle.h
index e7ac0365c25109512be67e390cf7c6c4868ed3ef..72ef9f222ab3b541d928b6b948a20133becd15be 100644
--- a/src/modules/http/inc/httpHandle.h
+++ b/src/modules/http/inc/httpHandle.h
@@ -210,7 +210,7 @@ typedef struct HttpThread {
 typedef struct _http_server_obj_ {
   char              label[HTTP_LABEL_SIZE];
   char              serverIp[16];
-  short             serverPort;
+  uint16_t          serverPort;
   int               cacheContext;
   int               sessionExpire;
   int               numOfThreads;
@@ -233,7 +233,7 @@ bool httpCheckUsedbSql(char *sql);
 void httpTimeToString(time_t t, char *buf, int buflen);
 
 // http init method
-void *httpInitServer(char *ip, short port, char *label, int numOfThreads, void *fp, void *shandle);
+void *httpInitServer(char *ip, uint16_t port, char *label, int numOfThreads, void *fp, void *shandle);
 void httpCleanUpServer(HttpServer *pServer);
 
 // http server connection
diff --git a/src/modules/http/src/httpSql.c b/src/modules/http/src/httpSql.c
index 9254658d58818166b9ff45e7ac765735e4f47f9a..0e3b211abba01387085489e0433b9b9940cf2f5c 100644
--- a/src/modules/http/src/httpSql.c
+++ b/src/modules/http/src/httpSql.c
@@ -25,7 +25,7 @@
 #include "taos.h"
 #include "tsclient.h"
 
-void *taos_connect_a(char *ip, char *user, char *pass, char *db, int port, void (*fp)(void *, TAOS_RES *, int),
+void *taos_connect_a(char *ip, char *user, char *pass, char *db, uint16_t port, void (*fp)(void *, TAOS_RES *, int),
                      void *param, void **taos);
 void httpProcessMultiSql(HttpContext *pContext);
 void taosNotePrint(const char * const format, ...);
diff --git a/src/modules/monitor/src/monitorSystem.c b/src/modules/monitor/src/monitorSystem.c
index 4d6577c8f3718ad9ecd576a55a19049ad0513c1b..c4b04365d39890e5d8041b2c48aa9b180575f10f 100644
--- a/src/modules/monitor/src/monitorSystem.c
+++ b/src/modules/monitor/src/monitorSystem.c
@@ -61,7 +61,7 @@ typedef struct {
 
 MonitorConn *monitor = NULL;
 
-TAOS *taos_connect_a(char *ip, char *user, char *pass, char *db, int port, void (*fp)(void *, TAOS_RES *, int),
+TAOS *taos_connect_a(char *ip, char *user, char *pass, char *db, uint16_t port, void (*fp)(void *, TAOS_RES *, int),
                      void *param, void **taos);
 void monitorInitConn(void *para, void *unused);
 void monitorInitConnCb(void *param, TAOS_RES *result, int code);
diff --git a/src/os/darwin/src/tdarwin.c b/src/os/darwin/src/tdarwin.c
index 71e8a56466fbbfad778d0cdc49d38c5c9bf8c009..133bb4893cc9aa2f8b561036ffaff6a53e0db3a7 100644
--- a/src/os/darwin/src/tdarwin.c
+++ b/src/os/darwin/src/tdarwin.c
@@ -170,12 +170,12 @@ int taosSetSockOpt(int socketfd, int level, int optname, void *optval, int optle
   return setsockopt(socketfd, level, optname, optval, (socklen_t)optlen);
 }
 
-int taosOpenUDClientSocket(char *ip, short port) {
+int taosOpenUDClientSocket(char *ip, uint16_t port) {
   int                sockFd = 0;
   struct sockaddr_un serverAddr;
   int                ret;
   char               name[128];
-  sprintf(name, "%s.%d", ip, port);
+  sprintf(name, "%s.%hu", ip, port);
 
   sockFd = socket(AF_UNIX, SOCK_STREAM, 0);
 
@@ -198,14 +198,13 @@ int taosOpenUDClientSocket(char *ip, short port) {
   return sockFd;
 }
 
-int taosOpenUDServerSocket(char *ip, short port) {
+int taosOpenUDServerSocket(char *ip, uint16_t port) {
   struct sockaddr_un serverAdd;
   int                sockFd;
   char               name[128];
 
   pTrace("open ud socket:%s", name);
-  // if (tsAllowLocalhost) ip = "0.0.0.0";
-  sprintf(name, "%s.%d", ip, port);
+  sprintf(name, "%s.%hu", ip, port);
 
   bzero((char *)&serverAdd, sizeof(serverAdd));
   serverAdd.sun_family = AF_UNIX;
@@ -296,7 +295,7 @@ void taosGetSystemInfo() {
   taosGetSystemLocale();
 }
 
-void *taosInitTcpClient(char *ip, short port, char *flabel, int num, void *fp, void *shandle) {
+void *taosInitTcpClient(char *ip, uint16_t port, char *flabel, int num, void *fp, void *shandle) {
   tError("function taosInitTcpClient is not implemented in darwin system, exit!");
   exit(0);
 }
@@ -306,12 +305,12 @@ void taosCloseTcpClientConnection(void *chandle) {
   exit(0);
 }
 
-void *taosOpenTcpClientConnection(void *shandle, void *thandle, char *ip, short port) {
+void *taosOpenTcpClientConnection(void *shandle, void *thandle, char *ip, uint16_t port) {
   tError("function taosOpenTcpClientConnection is not implemented in darwin system, exit!");
   exit(0);
 }
 
-int taosSendTcpClientData(unsigned int ip, short port, char *data, int len, void *chandle) {
+int taosSendTcpClientData(unsigned int ip, uint16_t port, char *data, int len, void *chandle) {
   tError("function taosSendTcpClientData is not implemented in darwin system, exit!");
   exit(0);
 }
@@ -331,12 +330,12 @@ void taosCleanUpTcpServer(void *handle) {
   exit(0);
 }
 
-void *taosInitTcpServer(char *ip, short port, char *label, int numOfThreads, void *fp, void *shandle) {
+void *taosInitTcpServer(char *ip, uint16_t port, char *label, int numOfThreads, void *fp, void *shandle) {
   tError("function taosInitTcpServer is not implemented in darwin system, exit!");
   exit(0);
 }
 
-int taosSendTcpServerData(unsigned int ip, short port, char *data, int len, void *chandle) {
+int taosSendTcpServerData(unsigned int ip, uint16_t port, char *data, int len, void *chandle) {
   tError("function taosSendTcpServerData is not implemented in darwin system, exit!");
   exit(0);
 }
diff --git a/src/os/linux/inc/os.h b/src/os/linux/inc/os.h
index dc3dc1cfdfd991ed7f340e153ee6cc49f45d71e8..82cb439a9462b1f324f6f98876d009e89490d860 100644
--- a/src/os/linux/inc/os.h
+++ b/src/os/linux/inc/os.h
@@ -222,6 +222,9 @@ bool taosSkipSocketCheck();
 
 int64_t str2int64(char *str);
 
+void taosSetCoreDump();
+
+
 #define BUILDIN_CLZL(val) __builtin_clzl(val)
 #define BUILDIN_CLZ(val) __builtin_clz(val)
 #define BUILDIN_CTZL(val) __builtin_ctzl(val)
diff --git a/src/os/linux/src/tlinux.c b/src/os/linux/src/tlinux.c
index f78250cb52629b533048628ac1ffa1bcdb9dd1b8..a166603615b41c23d792cd0f384f3de9e4625e70 100644
--- a/src/os/linux/src/tlinux.c
+++ b/src/os/linux/src/tlinux.c
@@ -163,12 +163,12 @@ int taosSetSockOpt(int socketfd, int level, int optname, void *optval, int optle
   return setsockopt(socketfd, level, optname, optval, (socklen_t)optlen);
 }
 
-int taosOpenUDClientSocket(char *ip, short port) {
+int taosOpenUDClientSocket(char *ip, uint16_t port) {
   int                sockFd = 0;
   struct sockaddr_un serverAddr;
   int                ret;
   char               name[128];
-  sprintf(name, "%s.%d", ip, port);
+  sprintf(name, "%s.%hu", ip, port);
 
   sockFd = socket(AF_UNIX, SOCK_STREAM, 0);
 
@@ -191,14 +191,13 @@ int taosOpenUDClientSocket(char *ip, short port) {
   return sockFd;
 }
 
-int taosOpenUDServerSocket(char *ip, short port) {
+int taosOpenUDServerSocket(char *ip, uint16_t port) {
   struct sockaddr_un serverAdd;
   int                sockFd;
   char               name[128];
 
   pTrace("open ud socket:%s", name);
-  // if (tsAllowLocalhost) ip = "0.0.0.0";
-  sprintf(name, "%s.%d", ip, port);
+  sprintf(name, "%s.%hu", ip, port);
 
   bzero((char *)&serverAdd, sizeof(serverAdd));
   serverAdd.sun_family = AF_UNIX;
diff --git a/src/os/linux/src/tsystem.c b/src/os/linux/src/tsystem.c
index ccf9266f9bcddbe747211f8b3ad4ecf2b580c325..fa41e8e6d0b077048daa339ca2704c8ae0688106 100644
--- a/src/os/linux/src/tsystem.c
+++ b/src/os/linux/src/tsystem.c
@@ -25,6 +25,14 @@
 #include <sys/types.h>
 #include <sys/utsname.h>
 #include <unistd.h>
+#include <sys/types.h>
+#include <sys/resource.h>
+#include <sys/sysctl.h>
+#include <sys/syscall.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <linux/sysctl.h>
 
 #include "tglobalcfg.h"
 #include "tlog.h"
@@ -576,4 +584,123 @@ void taosKillSystem() {
   // SIGINT
   pPrint("taosd will shut down soon");
   kill(tsProcId, 2);
-}
\ No newline at end of file
+}
+
+
+int _sysctl(struct __sysctl_args *args );
+void taosSetCoreDump() {
+  // 1. set ulimit -c unlimited
+  struct rlimit rlim;
+  struct rlimit rlim_new;
+  if (getrlimit(RLIMIT_CORE, &rlim) == 0) {
+    pPrint("the old unlimited para: rlim_cur=%d, rlim_max=%d", rlim.rlim_cur, rlim.rlim_max);
+    rlim_new.rlim_cur = RLIM_INFINITY;
+    rlim_new.rlim_max = RLIM_INFINITY;
+    if (setrlimit(RLIMIT_CORE, &rlim_new) != 0) {
+      pPrint("set unlimited fail, error: %s", strerror(errno));
+      rlim_new.rlim_cur = rlim.rlim_max;
+      rlim_new.rlim_max = rlim.rlim_max;
+      (void)setrlimit(RLIMIT_CORE, &rlim_new);
+    }
+  }
+
+  if (getrlimit(RLIMIT_CORE, &rlim) == 0) {
+    pPrint("the new unlimited para: rlim_cur=%d, rlim_max=%d", rlim.rlim_cur, rlim.rlim_max);
+  }
+
+  // 2. set the path for saving core file
+  struct __sysctl_args args;
+  int     old_usespid = 0;
+  size_t  old_len     = 0;
+  int     new_usespid = 1;
+  size_t  new_len     = sizeof(new_usespid);
+  
+  int name[] = {CTL_KERN, KERN_CORE_USES_PID};
+  
+  memset(&args, 0, sizeof(struct __sysctl_args));
+  args.name    = name;
+  args.nlen    = sizeof(name)/sizeof(name[0]);
+  args.oldval  = &old_usespid;
+  args.oldlenp = &old_len;
+  args.newval  = &new_usespid;
+  args.newlen  = new_len;
+  
+  old_len = sizeof(old_usespid);
+  
+  if (syscall(SYS__sysctl, &args) == -1) {
+      pPrint("_sysctl(kern_core_uses_pid) set fail: %s", strerror(errno));
+  }
+  
+  pPrint("The old core_uses_pid[%d]: %d", old_len, old_usespid);
+
+
+  old_usespid = 0;
+  old_len     = 0;
+  memset(&args, 0, sizeof(struct __sysctl_args));
+  args.name    = name;
+  args.nlen    = sizeof(name)/sizeof(name[0]);
+  args.oldval  = &old_usespid;
+  args.oldlenp = &old_len;
+  
+  old_len = sizeof(old_usespid);
+  
+  if (syscall(SYS__sysctl, &args) == -1) {
+      pPrint("_sysctl(kern_core_uses_pid) get fail: %s", strerror(errno));
+  }
+  
+  pPrint("The new core_uses_pid[%d]: %d", old_len, old_usespid);
+  
+#if 0
+  // 3. set the path for saving core file
+  int status; 
+  char coredump_dir[32] = "/var/log/taosdump";
+  if (opendir(coredump_dir) == NULL) {
+    status = mkdir(coredump_dir, S_IRWXU | S_IRWXG | S_IRWXO); 
+    if (status) {
+      pPrint("mkdir fail, error: %s\n", strerror(errno));
+    }
+  }
+
+  // 4. set kernel.core_pattern
+   struct __sysctl_args args;
+   char    old_corefile[128];
+   size_t  old_len;
+   char    new_corefile[128] = "/var/log/taosdump/core-%e-%p";
+   size_t  new_len = sizeof(new_corefile);
+   
+   int name[] = {CTL_KERN, KERN_CORE_PATTERN};
+
+   memset(&args, 0, sizeof(struct __sysctl_args));
+   args.name    = name;
+   args.nlen    = sizeof(name)/sizeof(name[0]);
+   args.oldval  = old_corefile;
+   args.oldlenp = &old_len;
+   args.newval  = new_corefile;
+   args.newlen  = new_len;
+
+   old_len = sizeof(old_corefile);
+
+   if (syscall(SYS__sysctl, &args) == -1) {
+       pPrint("_sysctl(kern_core_pattern) set fail: %s", strerror(errno));
+   }
+   
+   pPrint("The old kern_core_pattern: %*s\n", old_len, old_corefile);
+
+
+   memset(&args, 0, sizeof(struct __sysctl_args));
+   args.name    = name;
+   args.nlen    = sizeof(name)/sizeof(name[0]);
+   args.oldval  = old_corefile;
+   args.oldlenp = &old_len;
+   
+   old_len = sizeof(old_corefile);
+
+   if (syscall(SYS__sysctl, &args) == -1) {
+       pPrint("_sysctl(kern_core_pattern) get fail: %s", strerror(errno));
+   }
+   
+   pPrint("The new kern_core_pattern: %*s\n", old_len, old_corefile);
+#endif
+  
+}
+
diff --git a/src/os/windows/src/twintcpclient.c b/src/os/windows/src/twintcpclient.c
index 17293c3915aa73aac226df0fdb798b523a66bdbc..9f40dae434b0dba2c511cf9b837a53a8a8910250 100644
--- a/src/os/windows/src/twintcpclient.c
+++ b/src/os/windows/src/twintcpclient.c
@@ -15,7 +15,7 @@
 
 #include "tlog.h"
 
-void *taosInitTcpClient(char *ip, short port, char *label, int num, void *fp, void *shandle) {
+void *taosInitTcpClient(char *ip, uint16_t port, char *label, int num, void *fp, void *shandle) {
   tError("InitTcpClient not support in windows");
   return 0;
 }
@@ -24,12 +24,12 @@ void taosCloseTcpClientConnection(void *chandle) {
   tError("CloseTcpClientConnection not support in windows");
 }
 
-void *taosOpenTcpClientConnection(void *shandle, void *thandle, char *ip, short port) {
+void *taosOpenTcpClientConnection(void *shandle, void *thandle, char *ip, uint16_t port) {
   tError("OpenTcpClientConnection not support in windows");
   return 0;
 }
 
-int taosSendTcpClientData(unsigned int ip, short port, char *data, int len, void *chandle) {
+int taosSendTcpClientData(unsigned int ip, uint16_t port, char *data, int len, void *chandle) {
   tError("SendTcpClientData not support in windows");
   return 0;
 }
diff --git a/src/os/windows/src/twintcpserver.c b/src/os/windows/src/twintcpserver.c
index a51d807aa2481b59129d54a5a48d008c06d18d70..d5e25693d0b591eddf0a5da2469e86972bb5be00 100644
--- a/src/os/windows/src/twintcpserver.c
+++ b/src/os/windows/src/twintcpserver.c
@@ -23,12 +23,12 @@ void taosCleanUpTcpServer(void *handle) {
   tError("CleanUpTcpServer not support in windows");
 }
 
-void *taosInitTcpServer(char *ip, short port, char *label, int numOfThreads, void *fp, void *shandle) {
+void *taosInitTcpServer(char *ip, uint16_t port, char *label, int numOfThreads, void *fp, void *shandle) {
   tError("InitTcpServer not support in windows");
   return 0;
 }
 
-int taosSendTcpServerData(unsigned int ip, short port, char *data, int len, void *chandle) {
+int taosSendTcpServerData(unsigned int ip, uint16_t port, char *data, int len, void *chandle) {
   tError("SendTcpServerData not support in windows");
   return 0;
 }
diff --git a/src/rpc/inc/thaship.h b/src/rpc/inc/thaship.h
index 262673af6299df3b474fa385e6a9191f8e213d77..4acf8b3fbbab14702b3f4e98dc40b0f68fa3a3e2 100644
--- a/src/rpc/inc/thaship.h
+++ b/src/rpc/inc/thaship.h
@@ -18,8 +18,8 @@
 
 void *taosOpenIpHash(int maxSessions);
 void taosCloseIpHash(void *handle);
-void *taosAddIpHash(void *handle, void *pData, uint32_t ip, short port);
-void taosDeleteIpHash(void *handle, uint32_t ip, short port);
-void *taosGetIpHash(void *handle, uint32_t ip, short port);
+void *taosAddIpHash(void *handle, void *pData, uint32_t ip, uint16_t port);
+void taosDeleteIpHash(void *handle, uint32_t ip, uint16_t port);
+void *taosGetIpHash(void *handle, uint32_t ip, uint16_t port);
 
 #endif
diff --git a/src/rpc/inc/ttcpclient.h b/src/rpc/inc/ttcpclient.h
index 8c2131f1f6bbdb9a90712caef73d6361ca361e1b..8427c6f162fa0906af0c51e9ff49ad7e85c4b5a5 100644
--- a/src/rpc/inc/ttcpclient.h
+++ b/src/rpc/inc/ttcpclient.h
@@ -18,10 +18,10 @@
 
 #include "tsdb.h"
 
-void *taosInitTcpClient(char *ip, short port, char *label, int num, void *fp, void *shandle);
+void *taosInitTcpClient(char *ip, uint16_t port, char *label, int num, void *fp, void *shandle);
 void taosCleanUpTcpClient(void *chandle);
-void *taosOpenTcpClientConnection(void *shandle, void *thandle, char *ip, short port);
+void *taosOpenTcpClientConnection(void *shandle, void *thandle, char *ip, uint16_t port);
 void taosCloseTcpClientConnection(void *chandle);
-int taosSendTcpClientData(uint32_t ip, short port, char *data, int len, void *chandle);
+int taosSendTcpClientData(uint32_t ip, uint16_t port, char *data, int len, void *chandle);
 
 #endif
diff --git a/src/rpc/inc/ttcpserver.h b/src/rpc/inc/ttcpserver.h
index 3e3feb46918f3767da89a5a6fa9353fc0a89a17a..ba3bd25719f05372ab97b1dc67a92d244e03ae64 100644
--- a/src/rpc/inc/ttcpserver.h
+++ b/src/rpc/inc/ttcpserver.h
@@ -18,9 +18,9 @@
 
 #include "tsdb.h"
 
-void *taosInitTcpServer(char *ip, short port, char *label, int numOfThreads, void *fp, void *shandle);
+void *taosInitTcpServer(char *ip, uint16_t port, char *label, int numOfThreads, void *fp, void *shandle);
 void taosCleanUpTcpServer(void *param);
 void taosCloseTcpServerConnection(void *param);
-int taosSendTcpServerData(uint32_t ip, short port, char *data, int len, void *chandle);
+int taosSendTcpServerData(uint32_t ip, uint16_t port, char *data, int len, void *chandle);
 
 #endif
diff --git a/src/rpc/inc/tudp.h b/src/rpc/inc/tudp.h
index c90e21f510dd424d898c22980995fabb2285fee0..27c7593090d89d34b77ba34cf6c2f8b8366f2bd6 100644
--- a/src/rpc/inc/tudp.h
+++ b/src/rpc/inc/tudp.h
@@ -18,11 +18,11 @@
 
 #include "tsdb.h"
 
-void *taosInitUdpServer(char *ip, short port, char *label, int, void *fp, void *shandle);
-void *taosInitUdpClient(char *ip, short port, char *label, int, void *fp, void *shandle);
+void *taosInitUdpServer(char *ip, uint16_t port, char *label, int, void *fp, void *shandle);
+void *taosInitUdpClient(char *ip, uint16_t port, char *label, int, void *fp, void *shandle);
 void taosCleanUpUdpConnection(void *handle);
-int taosSendUdpData(uint32_t ip, short port, char *data, int dataLen, void *chandle);
-void *taosOpenUdpConnection(void *shandle, void *thandle, char *ip, short port);
+int taosSendUdpData(uint32_t ip, uint16_t port, char *data, int dataLen, void *chandle);
+void *taosOpenUdpConnection(void *shandle, void *thandle, char *ip, uint16_t port);
 
 void taosFreeMsgHdr(void *hdr);
 int taosMsgHdrSize(void *hdr);
diff --git a/src/rpc/src/thaship.c b/src/rpc/src/thaship.c
index 2c46e53258968df951fc00c4270036c08c076270..6b76c4b59e236418c408fabaac5c717cbbafcc55 100644
--- a/src/rpc/src/thaship.c
+++ b/src/rpc/src/thaship.c
@@ -19,7 +19,7 @@
 
 typedef struct _ip_hash_t {
   uint32_t           ip;
-  short              port;
+  uint16_t           port;
   int                hash;
   struct _ip_hash_t *prev;
   struct _ip_hash_t *next;
@@ -32,20 +32,20 @@ typedef struct {
   int       maxSessions;
 } SHashObj;
 
-int taosHashIp(void *handle, uint32_t ip, short port) {
+int taosHashIp(void *handle, uint32_t ip, uint16_t port) {
   SHashObj *pObj = (SHashObj *)handle;
   int       hash = 0;
 
   hash = (int)(ip >> 16);
   hash += (unsigned short)(ip & 0xFFFF);
-  hash += (unsigned short)port;
+  hash += port;
 
   hash = hash % pObj->maxSessions;
 
   return hash;
 }
 
-void *taosAddIpHash(void *handle, void *data, uint32_t ip, short port) {
+void *taosAddIpHash(void *handle, void *data, uint32_t ip, uint16_t port) {
   int       hash;
   SIpHash * pNode;
   SHashObj *pObj;
@@ -68,7 +68,7 @@ void *taosAddIpHash(void *handle, void *data, uint32_t ip, short port) {
   return pObj;
 }
 
-void taosDeleteIpHash(void *handle, uint32_t ip, short port) {
+void taosDeleteIpHash(void *handle, uint32_t ip, uint16_t port) {
   int       hash;
   SIpHash * pNode;
   SHashObj *pObj;
@@ -100,7 +100,7 @@ void taosDeleteIpHash(void *handle, uint32_t ip, short port) {
   }
 }
 
-void *taosGetIpHash(void *handle, uint32_t ip, short port) {
+void *taosGetIpHash(void *handle, uint32_t ip, uint16_t port) {
   int       hash;
   SIpHash * pNode;
   SHashObj *pObj;
diff --git a/src/rpc/src/trpc.c b/src/rpc/src/trpc.c
index de21598dd92c54ca83c8e575ebbf45d035af01ea..643622dfa7a66fe88b0137720772d22a5b9a0a77 100644
--- a/src/rpc/src/trpc.c
+++ b/src/rpc/src/trpc.c
@@ -51,10 +51,10 @@ typedef struct {
   uint8_t  secret[TSDB_KEY_LEN];
   uint8_t  ckey[TSDB_KEY_LEN];
 
-  short              localPort;  // for UDP only
+  uint16_t           localPort;  // for UDP only
   uint32_t           peerUid;
   uint32_t           peerIp;         // peer IP
-  short              peerPort;       // peer port
+  uint16_t           peerPort;       // peer port
   char               peerIpstr[20];  // peer IP string
   uint16_t           tranId;         // outgoing transcation ID, for build message
   uint16_t           outTranId;      // outgoing transcation ID
@@ -99,7 +99,7 @@ typedef struct rpc_server {
   int   idleTime;  // milliseconds;
   int   noFree;    // do not free the request msg when rsp is received
   int   index;     // for UDP server, next thread for new connection
-  short localPort;
+  uint16_t localPort;
   char  label[12];
   void *(*fp)(char *, void *ahandle, void *thandle);
   void (*efp)(int);                                                                     // FP to report error
@@ -114,16 +114,16 @@ int      tsRpcProgressTime = 10;  // milliseocnds
 int tsRpcMaxRetry;
 int tsRpcHeadSize;
 
-void *(*taosInitConn[])(char *ip, short port, char *label, int threads, void *fp, void *shandle) = {
+void *(*taosInitConn[])(char *ip, uint16_t port, char *label, int threads, void *fp, void *shandle) = {
     taosInitUdpServer, taosInitUdpClient, taosInitTcpServer, taosInitTcpClient};
 
 void (*taosCleanUpConn[])(void *thandle) = {taosCleanUpUdpConnection, taosCleanUpUdpConnection, taosCleanUpTcpServer,
                                             taosCleanUpTcpClient};
 
-int (*taosSendData[])(uint32_t ip, short port, char *data, int len, void *chandle) = {
+int (*taosSendData[])(uint32_t ip, uint16_t port, char *data, int len, void *chandle) = {
     taosSendUdpData, taosSendUdpData, taosSendTcpServerData, taosSendTcpClientData};
 
-void *(*taosOpenConn[])(void *shandle, void *thandle, char *ip, short port) = {
+void *(*taosOpenConn[])(void *shandle, void *thandle, char *ip, uint16_t port) = {
     taosOpenUdpConnection,
     taosOpenUdpConnection,
     NULL,
@@ -134,7 +134,7 @@ void (*taosCloseConn[])(void *chandle) = {NULL, NULL, taosCloseTcpServerConnecti
 
 int   taosReSendRspToPeer(SRpcConn *pConn);
 void  taosProcessTaosTimer(void *, void *);
-void *taosProcessDataFromPeer(char *data, int dataLen, uint32_t ip, short port, void *shandle, void *thandle,
+void *taosProcessDataFromPeer(char *data, int dataLen, uint32_t ip, uint16_t port, void *shandle, void *thandle,
                               void *chandle);
 int   taosSendDataToPeer(SRpcConn *pConn, char *data, int dataLen);
 void  taosProcessSchedMsg(SSchedMsg *pMsg);
@@ -354,6 +354,8 @@ int taosOpenRpcChannWithQ(void *handle, int cid, int sessions, void *qhandle) {
   STaosRpc * pServer = (STaosRpc *)handle;
   SRpcChann *pChann;
 
+  tTrace("cid:%d, handle:%p open rpc chann", cid, handle);
+
   if (pServer == NULL) return -1;
   if (cid >= pServer->numOfChanns || cid < 0) {
     tError("%s: cid:%d, chann is out of range, max:%d", pServer->label, cid, pServer->numOfChanns);
@@ -402,6 +404,8 @@ void taosCloseRpcChann(void *handle, int cid) {
   STaosRpc * pServer = (STaosRpc *)handle;
   SRpcChann *pChann;
 
+  tTrace("cid:%d, handle:%p close rpc chann", cid, handle);
+
   if (pServer == NULL) return;
   if (cid >= pServer->numOfChanns || cid < 0) {
     tError("%s cid:%d, chann is out of range, max:%d", pServer->label, cid, pServer->numOfChanns);
@@ -716,7 +720,7 @@ void taosProcessResponse(SRpcConn *pConn) {
 }
 
 int taosProcessMsgHeader(STaosHeader *pHeader, SRpcConn **ppConn, STaosRpc *pServer, int dataLen, uint32_t ip,
-                         short port, void *chandle) {
+                         uint16_t port, void *chandle) {
   int        chann, sid, code = 0;
   SRpcConn * pConn = NULL;
   SRpcChann *pChann;
@@ -1005,7 +1009,7 @@ void taosProcessIdleTimer(void *param, void *tmrId) {
   pthread_mutex_unlock(&pChann->mutex);
 }
 
-void *taosProcessDataFromPeer(char *data, int dataLen, uint32_t ip, short port, void *shandle, void *thandle,
+void *taosProcessDataFromPeer(char *data, int dataLen, uint32_t ip, uint16_t port, void *shandle, void *thandle,
                               void *chandle) {
   STaosHeader *pHeader;
   uint8_t      code;
@@ -1071,6 +1075,7 @@ void *taosProcessDataFromPeer(char *data, int dataLen, uint32_t ip, short port,
     // parsing error
 
     if (pHeader->msgType & 1) {
+      memset(pReply, 0, sizeof(pReply));
       msgLen = taosBuildErrorMsgToPeer(data, code, pReply);
       (*taosSendData[pServer->type])(ip, port, pReply, msgLen, chandle);
       tTrace("%s cid:%d sid:%d id:%s, %s is sent with error code:%u pConn:%p", pServer->label, chann, sid,
@@ -1307,7 +1312,7 @@ void taosProcessTaosTimer(void *param, void *tmrId) {
 
 }
 
-void taosGetRpcConnInfo(void *thandle, uint32_t *peerId, uint32_t *peerIp, short *peerPort, int *cid, int *sid) {
+void taosGetRpcConnInfo(void *thandle, uint32_t *peerId, uint32_t *peerIp, uint16_t *peerPort, int *cid, int *sid) {
   SRpcConn *pConn = (SRpcConn *)thandle;
 
   *peerId = pConn->peerId;
diff --git a/src/rpc/src/tstring.c b/src/rpc/src/tstring.c
index 9978ba9f5dccda8b73de9b5ccab321f4973a49e4..e3daca130a83c1c363dad3eeb9bef1d2394842b2 100644
--- a/src/rpc/src/tstring.c
+++ b/src/rpc/src/tstring.c
@@ -240,4 +240,6 @@ char *tsError[] = {"success",
                    "invalid submit message",
                    "not active table(not created yet or deleted already)",  //114
                    "invalid table id",
+                   "invalid vnode status",    //116
+                   "failed to lock resources",
 };
diff --git a/src/rpc/src/ttcpclient.c b/src/rpc/src/ttcpclient.c
index 8e6f91a66158722afc3b601538a21554ad847d50..3d39be92fe4fd1c4476e35d56b88ed2fa5c9e474 100644
--- a/src/rpc/src/ttcpclient.c
+++ b/src/rpc/src/ttcpclient.c
@@ -30,7 +30,7 @@ typedef struct _tcp_fd {
   void *              thandle;
   uint32_t            ip;
   char                ipstr[20];
-  short               port;
+  uint16_t            port;
   struct _tcp_client *pTcp;
   struct _tcp_fd *    prev, *next;
 } STcpFd;
@@ -45,7 +45,7 @@ typedef struct _tcp_client {
   char            label[12];
   char            ipstr[20];
   void *          shandle;  // handle passed by upper layer during server initialization
-  void *(*processData)(char *data, int dataLen, unsigned int ip, short port, void *shandle, void *thandle,
+  void *(*processData)(char *data, int dataLen, unsigned int ip, uint16_t port, void *shandle, void *thandle,
                        void *chandle);
   // char   buffer[128000];
 } STcpClient;
@@ -194,7 +194,7 @@ static void *taosReadTcpData(void *param) {
   return NULL;
 }
 
-void *taosInitTcpClient(char *ip, short port, char *label, int num, void *fp, void *shandle) {
+void *taosInitTcpClient(char *ip, uint16_t port, char *label, int num, void *fp, void *shandle) {
   STcpClient *   pTcp;
   pthread_attr_t thattr;
 
@@ -229,7 +229,7 @@ void *taosInitTcpClient(char *ip, short port, char *label, int num, void *fp, vo
     return NULL;
   }
 
-  tTrace("%s TCP client is initialized, ip:%s port:%u", label, ip, port);
+  tTrace("%s TCP client is initialized, ip:%s port:%hu", label, ip, port);
 
   return pTcp;
 }
@@ -242,7 +242,7 @@ void taosCloseTcpClientConnection(void *chandle) {
   taosCleanUpTcpFdObj(pFdObj);
 }
 
-void *taosOpenTcpClientConnection(void *shandle, void *thandle, char *ip, short port) {
+void *taosOpenTcpClientConnection(void *shandle, void *thandle, char *ip, uint16_t port) {
   STcpClient *       pTcp = (STcpClient *)shandle;
   STcpFd *           pFdObj;
   struct epoll_event event;
@@ -301,12 +301,12 @@ void *taosOpenTcpClientConnection(void *shandle, void *thandle, char *ip, short
 
   pthread_mutex_unlock(&(pTcp->mutex));
 
-  tTrace("%s TCP connection to ip:%s port:%u is created, numOfFds:%d", pTcp->label, ip, port, pTcp->numOfFds);
+  tTrace("%s TCP connection to ip:%s port:%hu is created, numOfFds:%d", pTcp->label, ip, port, pTcp->numOfFds);
 
   return pFdObj;
 }
 
-int taosSendTcpClientData(uint32_t ip, short port, char *data, int len, void *chandle) {
+int taosSendTcpClientData(uint32_t ip, uint16_t port, char *data, int len, void *chandle) {
   STcpFd *pFdObj = (STcpFd *)chandle;
 
   if (chandle == NULL) return -1;
diff --git a/src/rpc/src/ttcpserver.c b/src/rpc/src/ttcpserver.c
index 04078abb648debb86229d831e4801da56770e4b6..29ada20bc427455edf8c5b771178a33aa8214ba3 100644
--- a/src/rpc/src/ttcpserver.c
+++ b/src/rpc/src/ttcpserver.c
@@ -32,7 +32,7 @@ typedef struct _fd_obj {
   void *              thandle;  // handle from upper layer, like TAOS
   char                ipstr[TAOS_IPv4ADDR_LEN];
   unsigned int        ip;
-  unsigned short      port;
+  uint16_t            port;
   struct _thread_obj *pThreadObj;
   struct _fd_obj *    prev, *next;
 } SFdObj;
@@ -48,13 +48,13 @@ typedef struct _thread_obj {
   char            label[12];
   // char    buffer[128000];  // buffer to receive data
   void *shandle;  // handle passed by upper layer during server initialization
-  void *(*processData)(char *data, int dataLen, unsigned int ip, short port, void *shandle, void *thandle,
+  void *(*processData)(char *data, int dataLen, unsigned int ip, uint16_t port, void *shandle, void *thandle,
                        void *chandle);
 } SThreadObj;
 
 typedef struct {
   char        ip[40];
-  short       port;
+  uint16_t    port;
   char        label[12];
   int         numOfThreads;
   void *      shandle;
@@ -185,8 +185,9 @@ static void taosProcessTcpData(void *param) {
 
       void *buffer = malloc(1024);
       int   headLen = taosReadMsg(pFdObj->fd, buffer, sizeof(STaosHeader));
+
       if (headLen != sizeof(STaosHeader)) {
-        tError("%s read error, headLen:%d", pThreadObj->label, headLen);
+        tError("%s read error, headLen:%d, errno:%d", pThreadObj->label, headLen, errno);
         taosCleanUpFdObj(pFdObj);
         tfree(buffer);
         continue;
@@ -208,7 +209,7 @@ static void taosProcessTcpData(void *param) {
         continue;
       }
 
-      pFdObj->thandle = (*(pThreadObj->processData))(buffer, dataLen, pFdObj->ip, (int16_t)pFdObj->port,
+      pFdObj->thandle = (*(pThreadObj->processData))(buffer, dataLen, pFdObj->ip, pFdObj->port,
                                                      pThreadObj->shandle, pFdObj->thandle, pFdObj);
 
       if (pFdObj->thandle == NULL) taosCleanUpFdObj(pFdObj);
@@ -231,10 +232,10 @@ void taosAcceptTcpConnection(void *arg) {
   sockFd = taosOpenTcpServerSocket(pServerObj->ip, pServerObj->port);
 
   if (sockFd < 0) {
-    tError("%s failed to open TCP socket, ip:%s, port:%u", pServerObj->label, pServerObj->ip, pServerObj->port);
+    tError("%s failed to open TCP socket, ip:%s, port:%hu", pServerObj->label, pServerObj->ip, pServerObj->port);
     return;
   } else {
-    tTrace("%s TCP server is ready, ip:%s, port:%u", pServerObj->label, pServerObj->ip, pServerObj->port);
+    tTrace("%s TCP server is ready, ip:%s, port:%hu", pServerObj->label, pServerObj->ip, pServerObj->port);
   }
 
   while (1) {
@@ -246,7 +247,7 @@ void taosAcceptTcpConnection(void *arg) {
       continue;
     }
 
-    tTrace("%s TCP connection from ip:%s port:%u", pServerObj->label, inet_ntoa(clientAddr.sin_addr),
+    tTrace("%s TCP connection from ip:%s port:%hu", pServerObj->label, inet_ntoa(clientAddr.sin_addr),
            htons(clientAddr.sin_port));
     taosKeepTcpAlive(connFd);
 
@@ -291,7 +292,7 @@ void taosAcceptTcpConnection(void *arg) {
 
     pthread_mutex_unlock(&(pThreadObj->threadMutex));
 
-    tTrace("%s TCP thread:%d, a new connection, ip:%s port:%u, numOfFds:%d", pServerObj->label, pThreadObj->threadId,
+    tTrace("%s TCP thread:%d, a new connection, ip:%s port:%hu, numOfFds:%d", pServerObj->label, pThreadObj->threadId,
            pFdObj->ipstr, pFdObj->port, pThreadObj->numOfFds);
 
     // pick up next thread for next connection
@@ -313,10 +314,10 @@ void taosAcceptUDConnection(void *arg) {
   sockFd = taosOpenUDServerSocket(pServerObj->ip, pServerObj->port);
 
   if (sockFd < 0) {
-    tError("%s failed to open UD socket, ip:%s, port:%u", pServerObj->label, pServerObj->ip, pServerObj->port);
+    tError("%s failed to open UD socket, ip:%s, port:%hu", pServerObj->label, pServerObj->ip, pServerObj->port);
     return;
   } else {
-    tTrace("%s UD server is ready, ip:%s, port:%u", pServerObj->label, pServerObj->ip, pServerObj->port);
+    tTrace("%s UD server is ready, ip:%s, port:%hu", pServerObj->label, pServerObj->ip, pServerObj->port);
   }
 
   while (1) {
@@ -373,7 +374,7 @@ void taosAcceptUDConnection(void *arg) {
   }
 }
 
-void *taosInitTcpServer(char *ip, short port, char *label, int numOfThreads, void *fp, void *shandle) {
+void *taosInitTcpServer(char *ip, uint16_t port, char *label, int numOfThreads, void *fp, void *shandle) {
   int            i;
   SServerObj *   pServerObj;
   pthread_attr_t thattr;
@@ -441,7 +442,7 @@ void *taosInitTcpServer(char *ip, short port, char *label, int numOfThreads, voi
     }
   */
   pthread_attr_destroy(&thattr);
-  tTrace("%s TCP server is initialized, ip:%s port:%u numOfThreads:%d", label, ip, port, numOfThreads);
+  tTrace("%s TCP server is initialized, ip:%s port:%hu numOfThreads:%d", label, ip, port, numOfThreads);
 
   return (void *)pServerObj;
 }
@@ -467,7 +468,7 @@ void taosListTcpConnection(void *handle, char *buffer) {
     msg = msg + strlen(msg);
     pFdObj = pThreadObj->pHead;
     while (pFdObj) {
-      sprintf("   ip:%s port:%u\n", pFdObj->ipstr, pFdObj->port);
+      sprintf("   ip:%s port:%hu\n", pFdObj->ipstr, pFdObj->port);
       msg = msg + strlen(msg);
       numOfFds++;
       numOfConns++;
@@ -486,7 +487,7 @@ void taosListTcpConnection(void *handle, char *buffer) {
   return;
 }
 
-int taosSendTcpServerData(uint32_t ip, short port, char *data, int len, void *chandle) {
+int taosSendTcpServerData(uint32_t ip, uint16_t port, char *data, int len, void *chandle) {
   SFdObj *pFdObj = (SFdObj *)chandle;
 
   if (chandle == NULL) return -1;
diff --git a/src/rpc/src/tudp.c b/src/rpc/src/tudp.c
index 7a4961f90c2b7d71991ece4d4d64afac32e33fd6..43fee4c08900663e0a78e34e42472f42bfadaa6c 100644
--- a/src/rpc/src/tudp.c
+++ b/src/rpc/src/tudp.c
@@ -35,8 +35,8 @@ typedef struct {
   void *          signature;
   int             index;
   int             fd;
-  short           port;       // peer port
-  short           localPort;  // local port
+  uint16_t        port;       // peer port
+  uint16_t        localPort;  // local port
   char            label[12];  // copy from udpConnSet;
   pthread_t       thread;
   pthread_mutex_t mutex;
@@ -44,7 +44,7 @@ typedef struct {
   void *          hash;
   void *          shandle;  // handle passed by upper layer during server initialization
   void *          pSet;
-  void *(*processData)(char *data, int dataLen, unsigned int ip, short port, void *shandle, void *thandle,
+  void *(*processData)(char *data, int dataLen, unsigned int ip, uint16_t port, void *shandle, void *thandle,
                        void *chandle);
   char buffer[RPC_MAX_UDP_SIZE];  // buffer to receive data
 } SUdpConn;
@@ -53,21 +53,21 @@ typedef struct {
   int       index;
   int       server;
   char      ip[16];   // local IP
-  short     port;     // local Port
+  uint16_t  port;     // local Port
   void *    shandle;  // handle passed by upper layer during server initialization
   int       threads;
   char      label[12];
   void *    tmrCtrl;
   pthread_t tcpThread;
   int       tcpFd;
-  void *(*fp)(char *data, int dataLen, uint32_t ip, short port, void *shandle, void *thandle, void *chandle);
+  void *(*fp)(char *data, int dataLen, uint32_t ip, uint16_t port, void *shandle, void *thandle, void *chandle);
   SUdpConn udpConn[];
 } SUdpConnSet;
 
 typedef struct {
   void *             signature;
   uint32_t           ip;    // dest IP
-  short              port;  // dest Port
+  uint16_t           port;  // dest Port
   SUdpConn *         pConn;
   struct sockaddr_in destAdd;
   void *             msgHdr;
@@ -144,12 +144,12 @@ void *taosReadTcpData(void *argv) {
   pInfo->msgLen = (int32_t)htonl((uint32_t)pInfo->msgLen);
 
   tinet_ntoa(ipstr, pMonitor->ip);
-  tTrace("%s receive packet via TCP:%s:%d, msgLen:%d, handle:0x%x, source:0x%08x dest:0x%08x tranId:%d", pSet->label,
+  tTrace("%s receive packet via TCP:%s:%hu, msgLen:%d, handle:0x%x, source:0x%08x dest:0x%08x tranId:%d", pSet->label,
          ipstr, pInfo->port, pInfo->msgLen, pInfo->handle, pHead->sourceId, pHead->destId, pHead->tranId);
 
   fd = taosOpenTcpClientSocket(ipstr, (int16_t)pInfo->port, tsLocalIp);
   if (fd < 0) {
-    tError("%s failed to open TCP client socket ip:%s:%d", pSet->label, ipstr, pInfo->port);
+    tError("%s failed to open TCP client socket ip:%s:%hu", pSet->label, ipstr, pInfo->port);
     pMonitor->pSet = NULL;
     return NULL;
   }
@@ -180,7 +180,7 @@ void *taosReadTcpData(void *argv) {
       tError("%s failed to read data from server, msgLen:%d retLen:%d", pSet->label, pInfo->msgLen, retLen);
       tfree(buffer);
     } else {
-      (*pSet->fp)(buffer, pInfo->msgLen, pMonitor->ip, (int16_t)pInfo->port, pSet->shandle, NULL, pMonitor->pConn);
+      (*pSet->fp)(buffer, pInfo->msgLen, pMonitor->ip, pInfo->port, pSet->shandle, NULL, pMonitor->pConn);
     }
   }
 
@@ -224,7 +224,7 @@ void *taosRecvUdpData(void *param) {
   struct sockaddr_in sourceAdd;
   unsigned int       addLen, dataLen;
   SUdpConn *         pConn = (SUdpConn *)param;
-  short              port;
+  uint16_t           port;
   int                minSize = sizeof(STaosHeader);
 
   memset(&sourceAdd, 0, sizeof(sourceAdd));
@@ -242,7 +242,7 @@ void *taosRecvUdpData(void *param) {
       continue;
     }
 
-    port = (int16_t)ntohs(sourceAdd.sin_port);
+    port = ntohs(sourceAdd.sin_port);
 
     int   processedLen = 0, leftLen = 0;
     int   msgLen = 0;
@@ -307,7 +307,7 @@ void *taosTransferDataViaTcp(void *argv) {
 
   if (handle == 0) {
     // receive a packet from client
-    tTrace("%s data will be received via TCP from 0x%x:%d", pSet->label, pTransfer->ip, pTransfer->port);
+    tTrace("%s data will be received via TCP from 0x%x:%hu", pSet->label, pTransfer->ip, pTransfer->port);
     retLen = taosReadMsg(connFd, &head, sizeof(STaosHeader));
     if (retLen != (int)sizeof(STaosHeader)) {
       tError("%s failed to read msg header, retLen:%d", pSet->label, retLen);
@@ -345,7 +345,7 @@ void *taosTransferDataViaTcp(void *argv) {
         tError("%s failed to read data from client, leftLen:%d retLen:%d, error:%s", pSet->label, leftLen, retLen,
                strerror(errno));
       } else {
-        tTrace("%s data is received from client via TCP from 0x%x:%d, msgLen:%d", pSet->label, pTransfer->ip,
+        tTrace("%s data is received from client via TCP from 0x%x:%hu, msgLen:%d", pSet->label, pTransfer->ip,
                pTransfer->port, msgLen);
         pSet->index = (pSet->index + 1) % pSet->threads;
         SUdpConn *pConn = pSet->udpConn + pSet->index;
@@ -388,7 +388,7 @@ void *taosTransferDataViaTcp(void *argv) {
       if (retLen != msgLen) {
         tError("%s failed to send data to client, msgLen:%d retLen:%d", pSet->label, msgLen, retLen);
       } else {
-        tTrace("%s data is sent to client successfully via TCP to 0x%x:%d, size:%d", pSet->label, pTransfer->ip,
+        tTrace("%s data is sent to client successfully via TCP to 0x%x:%hu, size:%d", pSet->label, pTransfer->ip,
                pTransfer->port, msgLen);
       }
     }
@@ -413,13 +413,13 @@ void *taosUdpTcpConnection(void *argv) {
 
   pSet->tcpFd = taosOpenTcpServerSocket(pSet->ip, pSet->port);
   if (pSet->tcpFd < 0) {
-    tPrint("%s failed to create TCP socket %s:%d for UDP server, reason:%s", pSet->label, pSet->ip, pSet->port,
+    tPrint("%s failed to create TCP socket %s:%hu for UDP server, reason:%s", pSet->label, pSet->ip, pSet->port,
            strerror(errno));
     taosKillSystem();
     return NULL;
   }
 
-  tTrace("%s UDP server is created, ip:%s:%d", pSet->label, pSet->ip, pSet->port);
+  tTrace("%s UDP server is created, ip:%s:%hu", pSet->label, pSet->ip, pSet->port);
 
   pthread_attr_init(&thattr);
   pthread_attr_setdetachstate(&thattr, PTHREAD_CREATE_DETACHED);
@@ -455,7 +455,7 @@ void *taosUdpTcpConnection(void *argv) {
   return NULL;
 }
 
-void *taosInitUdpConnection(char *ip, short port, char *label, int threads, void *fp, void *shandle) {
+void *taosInitUdpConnection(char *ip, uint16_t port, char *label, int threads, void *fp, void *shandle) {
   pthread_attr_t thAttr;
   SUdpConn *     pConn;
   SUdpConnSet *  pSet;
@@ -488,13 +488,13 @@ void *taosInitUdpConnection(char *ip, short port, char *label, int threads, void
   pthread_attr_init(&thAttr);
   pthread_attr_setdetachstate(&thAttr, PTHREAD_CREATE_JOINABLE);
 
-  short ownPort;
+  uint16_t ownPort;
   for (int i = 0; i < threads; ++i) {
     pConn = pSet->udpConn + i;
-    ownPort = (int16_t)(port ? port + i : 0);
+    ownPort = (port ? port + i : 0);
     pConn->fd = taosOpenUdpSocket(ip, ownPort);
     if (pConn->fd < 0) {
-      tError("%s failed to open UDP socket %s:%d", label, ip, port);
+      tError("%s failed to open UDP socket %s:%hu", label, ip, port);
       taosCleanUpUdpConnection(pSet);
       return NULL;
     }
@@ -528,12 +528,12 @@ void *taosInitUdpConnection(char *ip, short port, char *label, int threads, void
   }
 
   pthread_attr_destroy(&thAttr);
-  tTrace("%s UDP connection is initialized, ip:%s port:%u threads:%d", label, ip, port, threads);
+  tTrace("%s UDP connection is initialized, ip:%s port:%hu threads:%d", label, ip, port, threads);
 
   return pSet;
 }
 
-void *taosInitUdpServer(char *ip, short port, char *label, int threads, void *fp, void *shandle) {
+void *taosInitUdpServer(char *ip, uint16_t port, char *label, int threads, void *fp, void *shandle) {
   SUdpConnSet *pSet;
   pSet = taosInitUdpConnection(ip, port, label, threads, fp, shandle);
   if (pSet == NULL) return NULL;
@@ -554,7 +554,7 @@ void *taosInitUdpServer(char *ip, short port, char *label, int threads, void *fp
   return pSet;
 }
 
-void *taosInitUdpClient(char *ip, short port, char *label, int threads, void *fp, void *shandle) {
+void *taosInitUdpClient(char *ip, uint16_t port, char *label, int threads, void *fp, void *shandle) {
   return taosInitUdpConnection(ip, port, label, threads, fp, shandle);
 }
 
@@ -590,7 +590,7 @@ void taosCleanUpUdpConnection(void *handle) {
   tfree(pSet);
 }
 
-void *taosOpenUdpConnection(void *shandle, void *thandle, char *ip, short port) {
+void *taosOpenUdpConnection(void *shandle, void *thandle, char *ip, uint16_t port) {
   SUdpConnSet *pSet = (SUdpConnSet *)shandle;
 
   pSet->index = (pSet->index + 1) % pSet->threads;
@@ -598,7 +598,7 @@ void *taosOpenUdpConnection(void *shandle, void *thandle, char *ip, short port)
   SUdpConn *pConn = pSet->udpConn + pSet->index;
   pConn->port = port;
 
-  tTrace("%s UDP connection is setup, ip: %s:%d, local: %s:%d", pConn->label, ip, port, pSet->ip,
+  tTrace("%s UDP connection is setup, ip: %s:%hu, local: %s:%d", pConn->label, ip, port, pSet->ip,
          ntohs((uint16_t)pConn->localPort));
 
   return pConn;
@@ -642,7 +642,7 @@ void taosProcessUdpBufTimer(void *param, void *tmrId) {
   if (pBuf) taosTmrReset(taosProcessUdpBufTimer, RPC_UDP_BUF_TIME, pBuf, pConn->tmrCtrl, &pBuf->timer);
 }
 
-SUdpBuf *taosCreateUdpBuf(SUdpConn *pConn, uint32_t ip, short port) {
+SUdpBuf *taosCreateUdpBuf(SUdpConn *pConn, uint32_t ip, uint16_t port) {
   SUdpBuf *pBuf = (SUdpBuf *)malloc(sizeof(SUdpBuf));
   memset(pBuf, 0, sizeof(SUdpBuf));
 
@@ -652,7 +652,7 @@ SUdpBuf *taosCreateUdpBuf(SUdpConn *pConn, uint32_t ip, short port) {
 
   pBuf->destAdd.sin_family = AF_INET;
   pBuf->destAdd.sin_addr.s_addr = ip;
-  pBuf->destAdd.sin_port = (uint16_t)htons((uint16_t)port);
+  pBuf->destAdd.sin_port = (uint16_t)htons(port);
   taosInitMsgHdr(&(pBuf->msgHdr), &(pBuf->destAdd), RPC_MAX_UDP_PKTS);
   pBuf->signature = pBuf;
   taosTmrReset(taosProcessUdpBufTimer, RPC_UDP_BUF_TIME, pBuf, pConn->tmrCtrl, &pBuf->timer);
@@ -663,7 +663,7 @@ SUdpBuf *taosCreateUdpBuf(SUdpConn *pConn, uint32_t ip, short port) {
   return pBuf;
 }
 
-int taosSendPacketViaTcp(uint32_t ip, short port, char *data, int dataLen, void *chandle) {
+int taosSendPacketViaTcp(uint32_t ip, uint16_t port, char *data, int dataLen, void *chandle) {
   SUdpConn *   pConn = (SUdpConn *)chandle;
   SUdpConnSet *pSet = (SUdpConnSet *)pConn->pSet;
   int          code = -1, retLen, msgLen;
@@ -680,13 +680,13 @@ int taosSendPacketViaTcp(uint32_t ip, short port, char *data, int dataLen, void
 
     SPacketInfo *pInfo = (SPacketInfo *)pHead->content;
     pInfo->handle = (uint64_t)data;
-    pInfo->port = (uint16_t)pSet->port;
+    pInfo->port   = pSet->port;
     pInfo->msgLen = pHead->msgLen;
 
     msgLen = sizeof(STaosHeader) + sizeof(SPacketInfo);
     pHead->msgLen = (int32_t)htonl((uint32_t)msgLen);
     code = taosSendUdpData(ip, port, buffer, msgLen, chandle);
-    tTrace("%s data from server will be sent via TCP:%d, msgType:%d, length:%d, handle:0x%x", pSet->label, pInfo->port,
+    tTrace("%s data from server will be sent via TCP:%hu, msgType:%d, length:%d, handle:0x%x", pSet->label, pInfo->port,
            pHead->msgType, htonl((uint32_t)pInfo->msgLen), pInfo->handle);
     if (code > 0) code = dataLen;
   } else {
@@ -706,7 +706,7 @@ int taosSendPacketViaTcp(uint32_t ip, short port, char *data, int dataLen, void
     tinet_ntoa(ipstr, ip);
     int fd = taosOpenTcpClientSocket(ipstr, pConn->port, tsLocalIp);
     if (fd < 0) {
-      tError("%s failed to open TCP socket to:%s:%u to send packet", pSet->label, ipstr, pConn->port);
+      tError("%s failed to open TCP socket to:%s:%hu to send packet", pSet->label, ipstr, pConn->port);
     } else {
       SHandleViaTcp handleViaTcp;
       taosInitHandleViaTcp(&handleViaTcp, 0);
@@ -734,7 +734,7 @@ int taosSendPacketViaTcp(uint32_t ip, short port, char *data, int dataLen, void
   return code;
 }
 
-int taosSendUdpData(uint32_t ip, short port, char *data, int dataLen, void *chandle) {
+int taosSendUdpData(uint32_t ip, uint16_t port, char *data, int dataLen, void *chandle) {
   SUdpConn *pConn = (SUdpConn *)chandle;
   SUdpBuf * pBuf;
 
@@ -747,7 +747,7 @@ int taosSendUdpData(uint32_t ip, short port, char *data, int dataLen, void *chan
     memset(&destAdd, 0, sizeof(destAdd));
     destAdd.sin_family = AF_INET;
     destAdd.sin_addr.s_addr = ip;
-    destAdd.sin_port = htons((uint16_t)port);
+    destAdd.sin_port = htons(port);
 
     int ret = (int)sendto(pConn->fd, data, (size_t)dataLen, 0, (struct sockaddr *)&destAdd, sizeof(destAdd));
     tTrace("%s msg is sent to 0x%x:%hu len:%d ret:%d localPort:%hu chandle:0x%x", pConn->label, destAdd.sin_addr.s_addr,
diff --git a/src/system/detail/inc/mgmt.h b/src/system/detail/inc/mgmt.h
index 702eb008758a2974990db5ada64dd4d92bc6be04..7cdc36a4465e1b71cce722719083d5476c27dd12 100644
--- a/src/system/detail/inc/mgmt.h
+++ b/src/system/detail/inc/mgmt.h
@@ -233,7 +233,7 @@ typedef struct _connObj {
   uint32_t         queryId;             // query ID to be killed
   uint32_t         streamId;            // stream ID to be killed
   uint32_t         ip;                  // shell IP
-  short            port;                // shell port
+  uint16_t         port;                // shell port
   void *           thandle;
   SQList *         pQList;  // query list
   SSList *         pSList;  // stream list
diff --git a/src/system/detail/inc/mgmtBalance.h b/src/system/detail/inc/mgmtBalance.h
index 7d478416accbc0b4e4cb5a56ef6f50daa8203320..67bfd55db2ae54ab8dc4a49f7d3dc79f30b1b524 100644
--- a/src/system/detail/inc/mgmtBalance.h
+++ b/src/system/detail/inc/mgmtBalance.h
@@ -28,15 +28,6 @@ extern "C" {
 #include "tstatus.h"
 #include "ttime.h"
 
-enum {
-  LB_DNODE_STATE_BALANCED,
-  LB_DNODE_STATE_BALANCING,
-  LB_DNODE_STATE_OFFLINE_REMOVING,
-  LB_DNODE_STATE_SHELL_REMOVING
-};
-
-enum { LB_VGROUP_STATE_READY, LB_VGROUP_STATE_UPDATE };
-
 void mgmtCreateDnodeOrderList();
 
 void mgmtReleaseDnodeOrderList();
diff --git a/src/system/detail/inc/vnode.h b/src/system/detail/inc/vnode.h
index 35b5c010ab45087ae2c1b86aeb7f15169498d0b6..c944c06d31e29d400cba26f8387cd6264583a15f 100644
--- a/src/system/detail/inc/vnode.h
+++ b/src/system/detail/inc/vnode.h
@@ -92,7 +92,7 @@ typedef struct {
   SVPeerDesc          vpeers[TSDB_VNODES_SUPPORT];
   SVnodePeer *        peerInfo[TSDB_VNODES_SUPPORT];
   char                selfIndex;
-  char                status;
+  char                vnodeStatus;
   char                accessState;  // Vnode access state, Readable/Writable
   char                syncStatus;
   char                commitInProcess;
diff --git a/src/system/detail/inc/vnodeShell.h b/src/system/detail/inc/vnodeShell.h
index e450983dd7ef6d90d33f9eb5e1d4e2e502fefd32..25646fbb1a88e2bd971d90b35fa8ecaf4cc42374 100644
--- a/src/system/detail/inc/vnodeShell.h
+++ b/src/system/detail/inc/vnodeShell.h
@@ -26,7 +26,7 @@ typedef struct {
   int      sid;
   int      vnode;
   uint32_t ip;
-  short    port;
+  uint16_t port;
   int      count;             // track the number of imports
   int      code;              // track the code of imports
   int      numOfTotalPoints;  // track the total number of points imported
diff --git a/src/system/detail/src/dnodeMgmt.c b/src/system/detail/src/dnodeMgmt.c
index ac651f05f291f1d92744da465fead6707b45cb4e..630e50b44d2de5d1a888f8342f730a8a288324ec 100644
--- a/src/system/detail/src/dnodeMgmt.c
+++ b/src/system/detail/src/dnodeMgmt.c
@@ -26,6 +26,7 @@
 #include "vnodeMgmt.h"
 #include "vnodeSystem.h"
 #include "vnodeUtil.h"
+#include "tstatus.h"
 
 SMgmtObj mgmtObj;
 extern uint64_t tsCreatedTime;
@@ -330,7 +331,7 @@ int vnodeProcessVPeerCfg(char *msg, int msgLen, SMgmtObj *pMgmtObj) {
     return -1;
   }
 
-  if (vnodeList[vnode].status == TSDB_STATUS_CREATING) {
+  if (vnodeList[vnode].vnodeStatus == TSDB_VNODE_STATUS_CREATING) {
     dTrace("vid:%d, vnode is still under creating", vnode);
     return 0;
   }
@@ -359,13 +360,27 @@ int vnodeProcessVPeerCfg(char *msg, int msgLen, SMgmtObj *pMgmtObj) {
   }
 
   if (vnodeList[vnode].cfg.maxSessions == 0) {
+    dTrace("vid:%d, vnode is empty", vnode);
     if (pCfg->maxSessions > 0) {
-      return vnodeCreateVnode(vnode, pCfg, pMsg->vpeerDesc);
+      if (vnodeList[vnode].vnodeStatus == TSDB_VNODE_STATUS_OFFLINE) {
+        dTrace("vid:%d, status:%s, start to create vnode", vnode, taosGetVnodeStatusStr(vnodeList[vnode].vnodeStatus));
+        return vnodeCreateVnode(vnode, pCfg, pMsg->vpeerDesc);
+      } else {
+        dTrace("vid:%d, status:%s, cannot preform create vnode operation", vnode, taosGetVnodeStatusStr(vnodeList[vnode].vnodeStatus));
+        return TSDB_CODE_INVALID_VNODE_STATUS;
+      }
     }
   } else {
+    dTrace("vid:%d, vnode is not empty", vnode);
     if (pCfg->maxSessions > 0) {
+      if (vnodeList[vnode].vnodeStatus == TSDB_VNODE_STATUS_DELETING) {
+        dTrace("vid:%d, status:%s, wait vnode delete finished", vnode, taosGetVnodeStatusStr(vnodeList[vnode].vnodeStatus));
+      } else {
+        dTrace("vid:%d, status:%s, start to update vnode", vnode, taosGetVnodeStatusStr(vnodeList[vnode].vnodeStatus));
+      }
+      /*
       if (pCfg->maxSessions != vnodeList[vnode].cfg.maxSessions) {
-          vnodeCleanUpOneVnode(vnode);
+        vnodeCleanUpOneVnode(vnode);
       }
 
       vnodeConfigVPeers(vnode, pCfg->replications, pMsg->vpeerDesc);
@@ -376,7 +391,10 @@ int vnodeProcessVPeerCfg(char *msg, int msgLen, SMgmtObj *pMgmtObj) {
         vnodeList[vnode].cfg.maxSessions = pCfg->maxSessions;
         vnodeOpenVnode(vnode);
       }
+      */
+      return 0;
     } else {
+      dTrace("vid:%d, status:%s, start to delete vnode", vnode, taosGetVnodeStatusStr(vnodeList[vnode].vnodeStatus));
       vnodeRemoveVnode(vnode);
     }
   }
@@ -434,11 +452,11 @@ int vnodeProcessFreeVnodeRequest(char *pMsg, int msgLen, SMgmtObj *pMgmtObj) {
   pFree->vnode = htons(pFree->vnode);
 
   if (pFree->vnode < 0 || pFree->vnode >= TSDB_MAX_VNODES) {
-    dWarn("vid:%d out of range", pFree->vnode);
+    dWarn("vid:%d, out of range", pFree->vnode);
     return -1;
   }
 
-  dTrace("vid:%d receive free vnode message", pFree->vnode);
+  dTrace("vid:%d, receive free vnode message", pFree->vnode);
   int32_t code = vnodeRemoveVnode(pFree->vnode);
   assert(code == TSDB_CODE_SUCCESS || code == TSDB_CODE_ACTION_IN_PROGRESS);
 
diff --git a/src/system/detail/src/dnodeSystem.c b/src/system/detail/src/dnodeSystem.c
index a6392cee4d6e116cf3e858016a9441bcb317b394..8815a8f42dd494a508161744a583d711a11e7e6e 100644
--- a/src/system/detail/src/dnodeSystem.c
+++ b/src/system/detail/src/dnodeSystem.c
@@ -139,6 +139,8 @@ int dnodeInitSystem() {
   tsPrintGlobalConfig();
   dPrint("Server IP address is:%s", tsInternalIp);
 
+  taosSetCoreDump();
+
   signal(SIGPIPE, SIG_IGN);
 
   dnodeInitModules();
diff --git a/src/system/detail/src/mgmtConn.c b/src/system/detail/src/mgmtConn.c
index 40385d2fc4b6d61727c679d7781ec8cc6c5e49f5..13275300a6f2cc024b17a48346fcb148ec85e1f5 100644
--- a/src/system/detail/src/mgmtConn.c
+++ b/src/system/detail/src/mgmtConn.c
@@ -25,7 +25,7 @@ typedef struct {
   char     user[TSDB_METER_ID_LEN];
   uint64_t stime;
   uint32_t ip;
-  short    port;
+  uint16_t port;
 } SConnInfo;
 
 typedef struct {
diff --git a/src/system/detail/src/mgmtDb.c b/src/system/detail/src/mgmtDb.c
index e87266aa4b3ee29123e48fe9bcea3e32ea7aa8d3..16a028d2dec2a58dcc77b56716c90f07ce2f431a 100644
--- a/src/system/detail/src/mgmtDb.c
+++ b/src/system/detail/src/mgmtDb.c
@@ -141,11 +141,10 @@ int mgmtCheckDbParams(SCreateDbMsg *pCreate) {
   if (pCreate->cacheNumOfBlocks.fraction < 0) pCreate->cacheNumOfBlocks.fraction = tsAverageCacheBlocks;  //
   //-1 for balance
 
-#ifdef CLUSTER
-  if (pCreate->replications > TSDB_VNODES_SUPPORT - 1) pCreate->replications = TSDB_VNODES_SUPPORT - 1;
-#else
-  pCreate->replications = 1;
-#endif
+  if (pCreate->replications <= 0 || pCreate->replications > TSDB_REPLICA_MAX_NUM) {
+    mTrace("invalid db option replications: %d", pCreate->replications);
+    return TSDB_CODE_INVALID_OPTION;
+  }
 
   if (pCreate->commitLog < 0 || pCreate->commitLog > 1) {
     mTrace("invalid db option commitLog: %d", pCreate->commitLog);
@@ -316,7 +315,7 @@ bool mgmtCheckDropDbFinished(SDbObj *pDb) {
       SDnodeObj *pDnode = mgmtGetDnode(pVnodeGid->ip);
 
       if (pDnode == NULL) continue;
-      if (pDnode->status == TSDB_STATUS_OFFLINE) continue;
+      if (pDnode->status == TSDB_DNODE_STATUS_OFFLINE) continue;
 
       SVnodeLoad *pVload = &pDnode->vload[pVnodeGid->vnode];
       if (pVload->dropStatus == TSDB_VN_STATUS_DROPPING) {
diff --git a/src/system/detail/src/mgmtDnode.c b/src/system/detail/src/mgmtDnode.c
index 3a4936041c54f3cec2f5b2c1fb91213bc1997acf..d8cfbbe917ee044709cafd6fd33b76b5e88ce109 100644
--- a/src/system/detail/src/mgmtDnode.c
+++ b/src/system/detail/src/mgmtDnode.c
@@ -21,6 +21,7 @@
 #include "mgmt.h"
 #include "tschemautil.h"
 #include "tstatus.h"
+#include "tstatus.h"
 
 bool mgmtCheckModuleInDnode(SDnodeObj *pDnode, int moduleType);
 int  mgmtGetDnodesNum();
@@ -43,9 +44,9 @@ void mgmtSetDnodeMaxVnodes(SDnodeObj *pDnode) {
   pDnode->openVnodes = 0;
 
 #ifdef CLUSTER
-  pDnode->status = TSDB_STATUS_OFFLINE;
+  pDnode->status = TSDB_DNODE_STATUS_OFFLINE;
 #else
-  pDnode->status = TSDB_STATUS_READY;
+  pDnode->status = TSDB_DNODE_STATUS_READY;
 #endif
 }
 
@@ -57,9 +58,9 @@ void mgmtCalcNumOfFreeVnodes(SDnodeObj *pDnode) {
     if (pVload->vgId != 0) {
       mTrace("dnode:%s, calc free vnodes, exist vnode:%d, vgroup:%d, state:%d %s, dropstate:%d %s, syncstatus:%d %s",
              taosIpStr(pDnode->privateIp), i, pVload->vgId,
-             pVload->status, sdbDnodeStatusStr[pVload->status],
-             pVload->dropStatus, sdbVnodeDropStateStr[pVload->dropStatus],
-             pVload->syncStatus, sdbVnodeSyncStatusStr[pVload->syncStatus]);
+             pVload->status, taosGetDnodeStatusStr(pVload->status),
+             pVload->dropStatus, taosGetVnodeDropStatusStr(pVload->dropStatus),
+             pVload->syncStatus, taosGetVnodeSyncStatusStr(pVload->syncStatus));
       totalVnodes++;
     }
   }
@@ -196,11 +197,11 @@ int mgmtRetrieveDnodes(SShowObj *pShow, char *data, int rows, SConnObj *pConn) {
     cols++;
 
     pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    strcpy(pWrite, sdbDnodeStatusStr[pDnode->status]);
+    strcpy(pWrite, taosGetDnodeStatusStr(pDnode->status) );
     cols++;
 
     pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    strcpy(pWrite, sdbDnodeBalanceStateStr[pDnode->lbState]);
+    strcpy(pWrite, taosGetDnodeBalanceStateStr(pDnode->lbState));
     cols++;
 
     tinet_ntoa(ipstr, pDnode->publicIp);
@@ -292,7 +293,7 @@ int mgmtRetrieveModules(SShowObj *pShow, char *data, int rows, SConnObj *pConn)
       cols++;
 
       pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      strcpy(pWrite, sdbDnodeStatusStr[pDnode->status]);
+      strcpy(pWrite, taosGetDnodeStatusStr(pDnode->status) );
       cols++;
 
       numOfRows++;
diff --git a/src/system/detail/src/mgmtDnodeInt.c b/src/system/detail/src/mgmtDnodeInt.c
index af86757d5165b4ccec638443282a55f9924184fe..9310182a14b0ba278c3d9ac2e6b85932e85d404d 100644
--- a/src/system/detail/src/mgmtDnodeInt.c
+++ b/src/system/detail/src/mgmtDnodeInt.c
@@ -128,7 +128,7 @@ int mgmtProcessVPeersRsp(char *msg, int msgLen, SDnodeObj *pObj) {
   }
 
   if (pDb->vgStatus != TSDB_VG_STATUS_IN_PROGRESS) {
-    mTrace("dnode:%s, db:%s vpeer rsp already disposed, code:%d", taosIpStr(pObj->privateIp), pRsp->more, pRsp->code);
+    mTrace("dnode:%s, db:%s vpeer rsp already disposed, vgroup status:%d code:%d", taosIpStr(pObj->privateIp), pRsp->more, pDb->vgStatus, pRsp->code);
     return 0;
   }
 
@@ -140,10 +140,11 @@ int mgmtProcessVPeersRsp(char *msg, int msgLen, SDnodeObj *pObj) {
 
   if (pRsp->code == TSDB_CODE_VG_COMMITLOG_INIT_FAILED) {
     pDb->vgStatus = TSDB_VG_STATUS_COMMITLOG_INIT_FAILED;
+    mError("dnode:%s, db:%s vgroup commit log init failed, code:%d", taosIpStr(pObj->privateIp), pRsp->more, pRsp->code);
   } else {
     pDb->vgStatus = TSDB_VG_STATUS_INIT_FAILED;
+    mError("dnode:%s, db:%s vgroup init failed, code:%d", taosIpStr(pObj->privateIp), pRsp->more, pRsp->code);
   }
-  mError("dnode:%s, db:%s vgroup create failed, code:%d", taosIpStr(pObj->privateIp), pRsp->more, pRsp->code);
 
   return 0;
 }
@@ -331,7 +332,6 @@ char *mgmtBuildVpeersIe(char *pMsg, SVgObj *pVgroup, int vnode) {
   pCfg->replications = (char)pVgroup->numOfVnodes;
   pCfg->rowsInFileBlock = htonl(pCfg->rowsInFileBlock);
 
-#ifdef CLUSTER
   SVPeerDesc *vpeerDesc = pVPeers->vpeerDesc;
 
   pMsg = (char *)(pVPeers->vpeerDesc);
@@ -341,7 +341,6 @@ char *mgmtBuildVpeersIe(char *pMsg, SVgObj *pVgroup, int vnode) {
     vpeerDesc[j].vnode = htonl(pVgroup->vnodeGid[j].vnode);
     pMsg += sizeof(SVPeerDesc);
   }
-#endif
 
   return pMsg;
 }
diff --git a/src/system/detail/src/mgmtMeter.c b/src/system/detail/src/mgmtMeter.c
index d4ffabe4b7a5444cbc6a71ee29c02e03035a4e9e..80ea5142e960abe0462da9e9f3341c658c803ea2 100644
--- a/src/system/detail/src/mgmtMeter.c
+++ b/src/system/detail/src/mgmtMeter.c
@@ -502,7 +502,7 @@ int mgmtCreateMeter(SDbObj *pDb, SCreateTableMsg *pCreate) {
 
   int numOfTables = sdbGetNumOfRows(meterSdb);
   if (numOfTables >= tsMaxTables) {
-    mWarn("numOfTables:%d, exceed tsMaxTables:%d", numOfTables, tsMaxTables);
+    mError("table:%s, numOfTables:%d exceed maxTables:%d", pCreate->meterId, numOfTables, tsMaxTables);
     return TSDB_CODE_TOO_MANY_TABLES;
   }
 
@@ -510,6 +510,7 @@ int mgmtCreateMeter(SDbObj *pDb, SCreateTableMsg *pCreate) {
   assert(pAcct != NULL);
   int code = mgmtCheckMeterLimit(pAcct, pCreate);
   if (code != 0) {
+    mError("table:%s, exceed the limit", pCreate->meterId);
     return code;
   }
 
@@ -517,8 +518,10 @@ int mgmtCreateMeter(SDbObj *pDb, SCreateTableMsg *pCreate) {
   pMeter = mgmtGetMeter(pCreate->meterId);
   if (pMeter) {
     if (pCreate->igExists) {
+      mError("table:%s, igExists is true", pCreate->meterId);
       return TSDB_CODE_SUCCESS;
     } else {
+      mError("table:%s, table is already exist", pCreate->meterId);
       return TSDB_CODE_TABLE_ALREADY_EXIST;
     }
   }
@@ -533,6 +536,7 @@ int mgmtCreateMeter(SDbObj *pDb, SCreateTableMsg *pCreate) {
     char *pTagData = (char *)pCreate->schema;  // it is a tag key
     pMetric = mgmtGetMeter(pTagData);
     if (pMetric == NULL) {
+      mError("table:%s, corresponding super table does not exist", pCreate->meterId);
       return TSDB_CODE_INVALID_TABLE;
     }
 
@@ -545,6 +549,7 @@ int mgmtCreateMeter(SDbObj *pDb, SCreateTableMsg *pCreate) {
     pMeter->schema = (char *)malloc(size);
     if (pMeter->schema == NULL) {
       mgmtDestroyMeter(pMeter);
+      mError("table:%s, corresponding super table schema is null", pCreate->meterId);
       return TSDB_CODE_INVALID_TABLE;
     }
     memset(pMeter->schema, 0, size);
@@ -556,13 +561,13 @@ int mgmtCreateMeter(SDbObj *pDb, SCreateTableMsg *pCreate) {
     pMeter->pTagData = pMeter->schema;
     pMeter->nextColId = pMetric->nextColId;
     memcpy(pMeter->pTagData, pTagData, size);
-
   } else {
     int numOfCols = pCreate->numOfColumns + pCreate->numOfTags;
     size = numOfCols * sizeof(SSchema) + pCreate->sqlLen;
     pMeter->schema = (char *)malloc(size);
     if (pMeter->schema == NULL) {
       mgmtDestroyMeter(pMeter);
+      mError("table:%s, no schema input", pCreate->meterId);
       return TSDB_CODE_SERV_OUT_OF_MEMORY;
     }
     memset(pMeter->schema, 0, size);
@@ -583,7 +588,7 @@ int mgmtCreateMeter(SDbObj *pDb, SCreateTableMsg *pCreate) {
       pMeter->pSql = pMeter->schema + numOfCols * sizeof(SSchema);
       memcpy(pMeter->pSql, (char *)(pCreate->schema) + numOfCols * sizeof(SSchema), pCreate->sqlLen);
       pMeter->pSql[pCreate->sqlLen - 1] = 0;
-      mTrace("stream sql len:%d, sql:%s", pCreate->sqlLen, pMeter->pSql);
+      mTrace("table:%s, stream sql len:%d sql:%s", pCreate->meterId, pCreate->sqlLen, pMeter->pSql);
     } else {
       if (pCreate->numOfTags > 0) {
         pMeter->meterType = TSDB_METER_METRIC;
@@ -596,13 +601,14 @@ int mgmtCreateMeter(SDbObj *pDb, SCreateTableMsg *pCreate) {
   pMeter->createdTime = taosGetTimestampMs();
   strcpy(pMeter->meterId, pCreate->meterId);
   if (pthread_rwlock_init(&pMeter->rwLock, NULL)) {
-    mError("Failed to init meter lock");
+    mError("table:%s, failed to init meter lock", pCreate->meterId);
     mgmtDestroyMeter(pMeter);
-    return TSDB_CODE_OTHERS;
+    return TSDB_CODE_FAILED_TO_LOCK_RESOURCES;
   }
 
   code = mgmtCheckMeterGrant(pCreate, pMeter);
   if (code != 0) {
+    mError("table:%s, grant expired", pCreate->meterId);
     return code;
   }
 
@@ -611,21 +617,25 @@ int mgmtCreateMeter(SDbObj *pDb, SCreateTableMsg *pCreate) {
 
     if (pDb->vgStatus == TSDB_VG_STATUS_IN_PROGRESS) {
       mgmtDestroyMeter(pMeter);
+      mTrace("table:%s, vgroup in creating progress", pCreate->meterId);
       return TSDB_CODE_ACTION_IN_PROGRESS;
     }
 
     if (pDb->vgStatus == TSDB_VG_STATUS_FULL) {
       mgmtDestroyMeter(pMeter);
+      mError("table:%s, vgroup is full", pCreate->meterId);
       return TSDB_CODE_NO_ENOUGH_DNODES;
     }
 
     if (pDb->vgStatus == TSDB_VG_STATUS_COMMITLOG_INIT_FAILED) {
       mgmtDestroyMeter(pMeter);
+      mError("table:%s, commit log init failed", pCreate->meterId);
       return TSDB_CODE_VG_COMMITLOG_INIT_FAILED;
     }
 
     if (pDb->vgStatus == TSDB_VG_STATUS_INIT_FAILED) {
       mgmtDestroyMeter(pMeter);
+      mError("table:%s, vgroup init failed", pCreate->meterId);
       return TSDB_CODE_VG_INIT_FAILED;
     }
 
@@ -633,12 +643,13 @@ int mgmtCreateMeter(SDbObj *pDb, SCreateTableMsg *pCreate) {
       pDb->vgStatus = TSDB_VG_STATUS_IN_PROGRESS;
       mgmtCreateVgroup(pDb);
       mgmtDestroyMeter(pMeter);
+      mTrace("table:%s, vgroup malloced, wait for create progress finished", pCreate->meterId);
       return TSDB_CODE_ACTION_IN_PROGRESS;
     }
 
     int sid = taosAllocateId(pVgroup->idPool);
     if (sid < 0) {
-      mWarn("db:%s, vgroup:%d, run out of ID, num:%d", pDb->name, pVgroup->vgId, taosIdPoolNumOfUsed(pVgroup->idPool));
+      mWarn("table:%s, vgroup:%d run out of ID, num:%d", pCreate->meterId, pVgroup->vgId, taosIdPoolNumOfUsed(pVgroup->idPool));
       pDb->vgStatus = TSDB_VG_STATUS_IN_PROGRESS;
       mgmtCreateVgroup(pDb);
       mgmtDestroyMeter(pMeter);
@@ -650,18 +661,21 @@ int mgmtCreateMeter(SDbObj *pDb, SCreateTableMsg *pCreate) {
     pMeter->uid = (((uint64_t)pMeter->gid.vgId) << 40) + ((((uint64_t)pMeter->gid.sid) & ((1ul << 24) - 1ul)) << 16) +
                   ((uint64_t)sdbVersion & ((1ul << 16) - 1ul));
 
-    mTrace("meter:%s, create meter in vgroup, vgId:%d, sid:%d, vnode:%d, uid:%d",
-           pMeter->meterId, pVgroup->vgId, sid, pVgroup->vnodeGid[0].vnode, pMeter->uid);
+    mTrace("table:%s, create table in vgroup, vgId:%d sid:%d vnode:%d uid:%d db:%s",
+           pMeter->meterId, pVgroup->vgId, sid, pVgroup->vnodeGid[0].vnode, pMeter->uid, pDb->name);
   } else {
     pMeter->uid = (((uint64_t)pMeter->createdTime) << 16) + ((uint64_t)sdbVersion & ((1ul << 16) - 1ul));
   }
 
-  if (sdbInsertRow(meterSdb, pMeter, 0) < 0) return TSDB_CODE_SDB_ERROR;
+  if (sdbInsertRow(meterSdb, pMeter, 0) < 0) {
+    mError("table:%s, update sdb error", pCreate->meterId);
+    return TSDB_CODE_SDB_ERROR;
+  }
 
   // send create message to the selected vnode servers
   if (pCreate->numOfTags == 0) {
-    mTrace("meter:%s, send msg to dnode, vgId:%d, sid:%d, vnode:%d, dbname:%s",
-           pMeter->meterId, pMeter->gid.vgId, pMeter->gid.sid, pVgroup->vnodeGid[0].vnode, pDb->name);
+    mTrace("table:%s, send create msg to dnode, vgId:%d, sid:%d, vnode:%d",
+           pMeter->meterId, pMeter->gid.vgId, pMeter->gid.sid, pVgroup->vnodeGid[0].vnode);
 
     grantAddTimeSeries(pMeter->numOfColumns - 1);
     mgmtSendCreateMsgToVgroup(pMeter, pVgroup);
@@ -881,7 +895,10 @@ void mgmtCleanUpMeters() { sdbCloseTable(meterSdb); }
 int mgmtGetMeterMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn) {
   int cols = 0;
 
-  if (pConn->pDb == NULL) return TSDB_CODE_DB_NOT_SELECTED;
+  SDbObj *pDb = NULL;
+  if (pConn->pDb != NULL) pDb = mgmtGetDb(pConn->pDb->name);
+
+  if (pDb == NULL) return TSDB_CODE_DB_NOT_SELECTED;
 
   SSchema *pSchema = tsGetSchema(pMeta);
 
@@ -916,7 +933,7 @@ int mgmtGetMeterMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn) {
   for (int i = 1; i < cols; ++i) pShow->offset[i] = pShow->offset[i - 1] + pShow->bytes[i - 1];
 
   //  pShow->numOfRows = sdbGetNumOfRows (meterSdb);
-  pShow->numOfRows = pConn->pDb->numOfTables;
+  pShow->numOfRows = pDb->numOfTables;
   pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
 
   return 0;
@@ -1208,8 +1225,12 @@ int mgmtRetrieveMeters(SShowObj *pShow, char *data, int rows, SConnObj *pConn) {
   int      numOfRead = 0;
   char     prefix[20] = {0};
 
-  if (pConn->pDb == NULL) return 0;
-  strcpy(prefix, pConn->pDb->name);
+  SDbObj *pDb = NULL;
+  if (pConn->pDb != NULL) pDb = mgmtGetDb(pConn->pDb->name);
+
+  if (pDb == NULL) return 0;
+
+  strcpy(prefix, pDb->name);
   strcat(prefix, TS_PATH_DELIMITER);
   prefixLen = strlen(prefix);
 
@@ -1269,7 +1290,10 @@ int mgmtRetrieveMeters(SShowObj *pShow, char *data, int rows, SConnObj *pConn) {
 int mgmtGetMetricMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn) {
   int cols = 0;
 
-  if (pConn->pDb == NULL) return TSDB_CODE_DB_NOT_SELECTED;
+  SDbObj *pDb = NULL;
+  if (pConn->pDb != NULL) pDb = mgmtGetDb(pConn->pDb->name);
+
+  if (pDb == NULL) return TSDB_CODE_DB_NOT_SELECTED;
 
   SSchema *pSchema = tsGetSchema(pMeta);
 
@@ -1309,8 +1333,8 @@ int mgmtGetMetricMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn) {
   pShow->offset[0] = 0;
   for (int i = 1; i < cols; ++i) pShow->offset[i] = pShow->offset[i - 1] + pShow->bytes[i - 1];
 
-  pShow->numOfRows = pConn->pDb->numOfMetrics;
-  pShow->pNode = pConn->pDb->pMetric;
+  pShow->numOfRows = pDb->numOfMetrics;
+  pShow->pNode = pDb->pMetric;
   pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
 
   return 0;
diff --git a/src/system/detail/src/mgmtProfile.c b/src/system/detail/src/mgmtProfile.c
index bd5540e5ee806ad0534dca0b238f63906fe7053f..e7dbeaaa254da098dcdac5a15b6b0feccb5f32f2 100644
--- a/src/system/detail/src/mgmtProfile.c
+++ b/src/system/detail/src/mgmtProfile.c
@@ -23,7 +23,7 @@
 
 typedef struct {
   uint32_t ip;
-  short    port;
+  uint16_t port;
   char     user[TSDB_METER_ID_LEN];
 } SCDesc;
 
@@ -180,7 +180,7 @@ int mgmtKillQuery(char *qidstr, SConnObj *pConn) {
   chr = strchr(temp, ':');
   if (chr == NULL) goto _error;
   *chr = 0;
-  short port = htons(atoi(temp));
+  uint16_t port = htons(atoi(temp));
 
   temp = chr + 1;
   uint32_t queryId = atoi(temp);
@@ -448,7 +448,7 @@ int mgmtKillStream(char *qidstr, SConnObj *pConn) {
   chr = strchr(temp, ':');
   if (chr == NULL) goto _error;
   *chr = 0;
-  short port = htons(atoi(temp));
+  uint16_t port = htons(atoi(temp));
 
   temp = chr + 1;
   uint32_t streamId = atoi(temp);
diff --git a/src/system/detail/src/mgmtShell.c b/src/system/detail/src/mgmtShell.c
index efd863a7efb08ffb447d58ec8959e0b1e6a98385..450527d009e6304f539cd7d5924c307e257e8e96 100644
--- a/src/system/detail/src/mgmtShell.c
+++ b/src/system/detail/src/mgmtShell.c
@@ -189,8 +189,11 @@ int mgmtProcessMeterMetaMsg(char *pMsg, int msgLen, SConnObj *pConn) {
   int size = sizeof(STaosHeader) + sizeof(STaosRsp) + sizeof(SMeterMeta) + sizeof(SSchema) * TSDB_MAX_COLUMNS +
              sizeof(SSchema) * TSDB_MAX_TAGS + TSDB_MAX_TAGS_LEN + TSDB_EXTRA_PAYLOAD_SIZE;
 
+  SDbObj *pDb = NULL;
+  if (pConn->pDb != NULL) pDb = mgmtGetDb(pConn->pDb->name);
+
   // todo db check should be extracted
-  if (pConn->pDb == NULL || (pConn->pDb != NULL && pConn->pDb->dropStatus != TSDB_DB_STATUS_READY)) {
+  if (pDb == NULL || (pDb != NULL && pDb->dropStatus != TSDB_DB_STATUS_READY)) {
 
     if ((pStart = mgmtAllocMsg(pConn, size, &pMsg, &pRsp)) == NULL) {
       taosSendSimpleRsp(pConn->thandle, TSDB_MSG_TYPE_METERINFO_RSP, TSDB_CODE_SERV_OUT_OF_MEMORY);
@@ -223,10 +226,10 @@ int mgmtProcessMeterMetaMsg(char *pMsg, int msgLen, SConnObj *pConn) {
 
     SDbObj* pMeterDb = mgmtGetDbByMeterId(pCreateMsg->meterId);
     mTrace("meter:%s, pConnDb:%p, pConnDbName:%s, pMeterDb:%p, pMeterDbName:%s",
-           pCreateMsg->meterId, pConn->pDb, pConn->pDb->name, pMeterDb, pMeterDb->name);
-    assert(pConn->pDb == pMeterDb);
+           pCreateMsg->meterId, pDb, pDb->name, pMeterDb, pMeterDb->name);
+    assert(pDb == pMeterDb);
 
-    int32_t code = mgmtCreateMeter(pConn->pDb, pCreateMsg);
+    int32_t code = mgmtCreateMeter(pDb, pCreateMsg);
 
     char stableName[TSDB_METER_ID_LEN] = {0};
     strncpy(stableName, pInfo->tags, TSDB_METER_ID_LEN);
@@ -256,7 +259,7 @@ int mgmtProcessMeterMetaMsg(char *pMsg, int msgLen, SConnObj *pConn) {
   }
 
   if (pMeterObj == NULL) {
-    if (pConn->pDb)
+    if (pDb)
       pRsp->code = TSDB_CODE_INVALID_TABLE;
     else
       pRsp->code = TSDB_CODE_DB_NOT_SELECTED;
@@ -274,7 +277,7 @@ int mgmtProcessMeterMetaMsg(char *pMsg, int msgLen, SConnObj *pConn) {
     pMeta->vgid = htonl(pMeterObj->gid.vgId);
     pMeta->sversion = htons(pMeterObj->sversion);
 
-    pMeta->precision = pConn->pDb->cfg.precision;
+    pMeta->precision = pDb->cfg.precision;
 
     pMeta->numOfTags = pMeterObj->numOfTags;
     pMeta->numOfColumns = htons(pMeterObj->numOfColumns);
@@ -505,7 +508,10 @@ int mgmtProcessMetricMetaMsg(char *pMsg, int msgLen, SConnObj *pConn) {
   SMetricMetaElemMsg *pElem = (SMetricMetaElemMsg *)(((char *)pMetricMetaMsg) + pMetricMetaMsg->metaElem[0]);
   pMetric = mgmtGetMeter(pElem->meterId);
 
-  if (pMetric == NULL || (pConn->pDb != NULL && pConn->pDb->dropStatus != TSDB_DB_STATUS_READY)) {
+  SDbObj *pDb = NULL;
+  if (pConn->pDb != NULL) pDb = mgmtGetDb(pConn->pDb->name);
+
+  if (pMetric == NULL || (pDb != NULL && pDb->dropStatus != TSDB_DB_STATUS_READY)) {
     pStart = taosBuildRspMsg(pConn->thandle, TSDB_MSG_TYPE_METRIC_META_RSP);
     if (pStart == NULL) {
       taosSendSimpleRsp(pConn->thandle, TSDB_MSG_TYPE_METRIC_META_RSP, TSDB_CODE_SERV_OUT_OF_MEMORY);
@@ -514,7 +520,7 @@ int mgmtProcessMetricMetaMsg(char *pMsg, int msgLen, SConnObj *pConn) {
 
     pMsg = pStart;
     pRsp = (STaosRsp *)pMsg;
-    if (pConn->pDb)
+    if (pDb)
       pRsp->code = TSDB_CODE_INVALID_TABLE;
     else
       pRsp->code = TSDB_CODE_DB_NOT_SELECTED;
@@ -957,17 +963,23 @@ int mgmtProcessCreateTableMsg(char *pMsg, int msgLen, SConnObj *pConn) {
       pSchema++;
     }
 
-    if (pConn->pDb) {
-      code = mgmtCreateMeter(pConn->pDb, pCreate);
-      if (code == 0) {
-        mTrace("meter:%s is created by %s", pCreate->meterId, pConn->pUser->user);
-        // mLPrint("meter:%s is created by %s", pCreate->meterId, pConn->pUser->user);
-      }
+    SDbObj *pDb = NULL;
+    if (pConn->pDb != NULL) pDb = mgmtGetDb(pConn->pDb->name);
+
+    if (pDb) {
+      code = mgmtCreateMeter(pDb, pCreate);
     } else {
       code = TSDB_CODE_DB_NOT_SELECTED;
     }
   }
 
+  if (code != 0) {
+    mError("table:%s, failed to create table, code:%d", pCreate->meterId, code);
+  } else {
+    mTrace("table:%s, table is created by %s", pCreate->meterId, pConn->pUser->user);
+    //mLPrint("meter:%s is created by %s", pCreate->meterId, pConn->pUser->user);
+  }
+
   taosSendSimpleRsp(pConn->thandle, TSDB_MSG_TYPE_CREATE_TABLE_RSP, code);
 
   return 0;
@@ -984,7 +996,10 @@ int mgmtProcessDropTableMsg(char *pMsg, int msgLen, SConnObj *pConn) {
   if (!pConn->writeAuth) {
     code = TSDB_CODE_NO_RIGHTS;
   } else {
-    code = mgmtDropMeter(pConn->pDb, pDrop->meterId, pDrop->igNotExists);
+    SDbObj *pDb = NULL;
+    if (pConn->pDb != NULL) pDb = mgmtGetDb(pConn->pDb->name);
+
+    code = mgmtDropMeter(pDb, pDrop->meterId, pDrop->igNotExists);
     if (code == 0) {
       mTrace("meter:%s is dropped by user:%s", pDrop->meterId, pConn->pUser->user);
       // mLPrint("meter:%s is dropped by user:%s", pDrop->meterId, pConn->pUser->user);
@@ -1014,12 +1029,15 @@ int mgmtProcessAlterTableMsg(char *pMsg, int msgLen, SConnObj *pConn) {
       mError("meter:%s error numOfCols:%d in alter table", pAlter->meterId, pAlter->numOfCols);
       code = TSDB_CODE_APP_ERROR;
     } else {
-      if (pConn->pDb) {
+      SDbObj *pDb = NULL;
+      if (pConn->pDb != NULL) pDb = mgmtGetDb(pConn->pDb->name);
+
+      if (pDb) {
         for (int32_t i = 0; i < pAlter->numOfCols; ++i) {
           pAlter->schema[i].bytes = htons(pAlter->schema[i].bytes);
         }
 
-        code = mgmtAlterMeter(pConn->pDb, pAlter);
+        code = mgmtAlterMeter(pDb, pAlter);
         if (code == 0) {
           mLPrint("meter:%s is altered by %s", pAlter->meterId, pConn->pUser->user);
         }
@@ -1258,13 +1276,12 @@ void *mgmtProcessMsgFromShell(char *msg, void *ahandle, void *thandle) {
       if (pConn->pUser) {
         pConn->pAcct = mgmtGetAcct(pConn->pUser->acct);
         mgmtEstablishConn(pConn);
-        mTrace("login from:%x:%d", pConn->ip, htons(pConn->port));
+        mTrace("login from:%x:%hu", pConn->ip, htons(pConn->port));
       }
     }
 
     if (pConn->pAcct) {
-      if (pConn->pDb == NULL ||
-          strncmp(pConn->pDb->name, pHead->db, tListLen(pConn->pDb->name)) != 0) {
+      if (pConn->pDb == NULL || strncmp(pConn->pDb->name, pHead->db, tListLen(pConn->pDb->name)) != 0) {
         pConn->pDb = mgmtGetDb(pHead->db);
       }
 
diff --git a/src/system/detail/src/mgmtVgroup.c b/src/system/detail/src/mgmtVgroup.c
index 3b1da25a0a7aff4a86ca50537cb88b394d4ccff2..97a7343e1e8c72e2ad49543a27ce5dda9dd9c8d1 100644
--- a/src/system/detail/src/mgmtVgroup.c
+++ b/src/system/detail/src/mgmtVgroup.c
@@ -123,7 +123,7 @@ void mgmtProcessVgTimer(void *handle, void *tmrId) {
   if (pDb == NULL) return;
 
   if (pDb->vgStatus > TSDB_VG_STATUS_IN_PROGRESS) {
-    mTrace("db:%s, set vgstatus from %d to %d", pDb->name, pDb->vgStatus, TSDB_VG_STATUS_READY);
+    mTrace("db:%s, set vgroup status from %d to ready", pDb->name, pDb->vgStatus);
     pDb->vgStatus = TSDB_VG_STATUS_READY;
   }
 
@@ -143,7 +143,7 @@ SVgObj *mgmtCreateVgroup(SDbObj *pDb) {
 
   // based on load balance, create a new one
   if (mgmtAllocVnodes(pVgroup) != 0) {
-    mError("no enough free dnode");
+    mError("db:%s, no enough free dnode to alloc %d vnodes", pDb->name, pVgroup->numOfVnodes);
     free(pVgroup);
     pDb->vgStatus = TSDB_VG_STATUS_FULL;
     taosTmrReset(mgmtProcessVgTimer, 5000, pDb, mgmtTmr, &pDb->vgTimer);
@@ -152,9 +152,9 @@ SVgObj *mgmtCreateVgroup(SDbObj *pDb) {
 
   sdbInsertRow(vgSdb, pVgroup, 0);
 
-  mTrace("vgroup:%d, db:%s replica:%d is created", pVgroup->vgId, pDb->name, pVgroup->numOfVnodes);
+  mTrace("vgroup:%d, vgroup is created, db:%s replica:%d", pVgroup->vgId, pDb->name, pVgroup->numOfVnodes);
   for (int i = 0; i < pVgroup->numOfVnodes; ++i)
-    mTrace("dnode:%s, vgroup:%d, vnode:%d is created", taosIpStr(pVgroup->vnodeGid[i].ip), pVgroup->vgId, pVgroup->vnodeGid[i].vnode);
+    mTrace("vgroup:%d, dnode:%s vnode:%d is created", pVgroup->vgId, taosIpStr(pVgroup->vnodeGid[i].ip), pVgroup->vnodeGid[i].vnode);
 
   mgmtSendVPeersMsg(pVgroup);
 
@@ -206,7 +206,10 @@ void mgmtCleanUpVgroups() { sdbCloseTable(vgSdb); }
 int mgmtGetVgroupMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn) {
   int cols = 0;
 
-  if (pConn->pDb == NULL) return TSDB_CODE_DB_NOT_SELECTED;
+  SDbObj *pDb = NULL;
+  if (pConn->pDb != NULL) pDb = mgmtGetDb(pConn->pDb->name);
+
+  if (pDb == NULL) return TSDB_CODE_DB_NOT_SELECTED;
 
   SSchema *pSchema = tsGetSchema(pMeta);
 
@@ -229,7 +232,7 @@ int mgmtGetVgroupMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn) {
   cols++;
 
   int     maxReplica = 0;
-  SVgObj *pVgroup = pConn->pDb->pHead;
+  SVgObj *pVgroup = pDb->pHead;
   while (pVgroup != NULL) {
     maxReplica = pVgroup->numOfVnodes > maxReplica ? pVgroup->numOfVnodes : maxReplica;
     pVgroup = pVgroup->next;
@@ -267,8 +270,8 @@ int mgmtGetVgroupMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn) {
   pShow->offset[0] = 0;
   for (int i = 1; i < cols; ++i) pShow->offset[i] = pShow->offset[i - 1] + pShow->bytes[i - 1];
 
-  pShow->numOfRows = pConn->pDb->numOfVgroups;
-  pShow->pNode = pConn->pDb->pHead;
+  pShow->numOfRows = pDb->numOfVgroups;
+  pShow->pNode = pDb->pHead;
   pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
 
   return 0;
@@ -282,7 +285,11 @@ int mgmtRetrieveVgroups(SShowObj *pShow, char *data, int rows, SConnObj *pConn)
   char    ipstr[20];
 
   int maxReplica = 0;
-  pVgroup = pConn->pDb->pHead;
+
+  SDbObj *pDb = NULL;
+  if (pConn->pDb != NULL) pDb = mgmtGetDb(pConn->pDb->name);
+
+  pVgroup = pDb->pHead;
   while (pVgroup != NULL) {
     maxReplica = pVgroup->numOfVnodes > maxReplica ? pVgroup->numOfVnodes : maxReplica;
     pVgroup = pVgroup->next;
diff --git a/src/system/detail/src/vnodeCache.c b/src/system/detail/src/vnodeCache.c
index 94ac006060c83785f24ced70bddd4269105a2b7d..938e655b49ab15312ff1fa429867f8fa33b1840d 100644
--- a/src/system/detail/src/vnodeCache.c
+++ b/src/system/detail/src/vnodeCache.c
@@ -172,6 +172,7 @@ int vnodeFreeCacheBlock(SCacheBlock *pCacheBlock) {
     SCachePool *pPool = (SCachePool *)vnodeList[pObj->vnode].pCachePool;
     if (pCacheBlock->notFree) {
       pPool->notFreeSlots--;
+      pInfo->unCommittedBlocks--;
       dTrace("vid:%d sid:%d id:%s, cache block is not free, slot:%d, index:%d notFreeSlots:%d",
              pObj->vnode, pObj->sid, pObj->meterId, pCacheBlock->slot, pCacheBlock->index, pPool->notFreeSlots);
     }
@@ -296,7 +297,7 @@ pthread_t vnodeCreateCommitThread(SVnodeObj *pVnode) {
 
   taosTmrStopA(&pVnode->commitTimer);
 
-  if (pVnode->status == TSDB_STATUS_UNSYNCED) {
+  if (pVnode->vnodeStatus == TSDB_VNODE_STATUS_UNSYNCED) {
     taosTmrReset(vnodeProcessCommitTimer, pVnode->cfg.commitTime * 1000, pVnode, vnodeTmrCtrl, &pVnode->commitTimer);
     dTrace("vid:%d, it is in unsyc state, commit later", pVnode->vnode);
     return pVnode->commitThread;
diff --git a/src/system/detail/src/vnodeFile.c b/src/system/detail/src/vnodeFile.c
index 5292f5bac7280af505e1d657c33a95e00984ba1c..c8c7d2debe96dd3138147034d369fe1a6d8014df 100644
--- a/src/system/detail/src/vnodeFile.c
+++ b/src/system/detail/src/vnodeFile.c
@@ -208,6 +208,7 @@ int vnodeOpenCommitFiles(SVnodeObj *pVnode, int noTempLast) {
   if (numOfFiles >= pVnode->numOfFiles) {
     // create empty header files backward
     filesAdded = numOfFiles - pVnode->numOfFiles + 1;
+    assert(filesAdded <= pVnode->maxFiles + 2);
     for (int i = 0; i < filesAdded; ++i) {
       fileId = pVnode->fileId - pVnode->numOfFiles - i;
       if (vnodeCreateEmptyCompFile(vnode, fileId) < 0) 
@@ -1289,7 +1290,7 @@ int vnodeWriteBlockToFile(SMeterObj *pObj, SCompBlock *pCompBlock, SData *data[]
     pCompBlock->len += wlen;
   }
 
-  dTrace("vid: %d vnode compStorage size is: %ld", pObj->vnode, pVnode->vnodeStatistic.compStorage);
+  dTrace("vid:%d, vnode compStorage size is: %ld", pObj->vnode, pVnode->vnodeStatistic.compStorage);
 
   pCompBlock->algorithm = pCfg->compression;
   pCompBlock->numOfPoints = points;
diff --git a/src/system/detail/src/vnodeImport.c b/src/system/detail/src/vnodeImport.c
index 260d5312002880d8396a032049355933a05d6eb2..0d3cd2b338574dc4c7256fbbcbcf8fd86db62950 100644
--- a/src/system/detail/src/vnodeImport.c
+++ b/src/system/detail/src/vnodeImport.c
@@ -479,7 +479,7 @@ int vnodeImportToFile(SImportInfo *pImport) {
         slot = (slot + 1 + pInfo->maxBlocks) % pInfo->maxBlocks;
       }
 
-      // last slot, the uncommitted slots shall be shifted
+      // last slot, the uncommitted slots shall be shifted, a cache block may have empty rows
       SCacheBlock *pCacheBlock = pInfo->cacheBlocks[slot];
       int          points = pCacheBlock->numOfPoints - pInfo->commitPoint;
       if (points > 0) {
@@ -568,7 +568,7 @@ int vnodeImportToCache(SImportInfo *pImport, char *payload, int rows) {
     }
   }
 
-  // copy the overwritten data into buffer
+  // copy the overwritten data into buffer, merge cache blocks
   tpoints = rows;
   pos = pImport->pos;
   slot = pImport->slot;
@@ -603,6 +603,19 @@ int vnodeImportToCache(SImportInfo *pImport, char *payload, int rows) {
     pos = 0;
     tpoints -= points;
 
+    if (tpoints == 0) {
+      // free the rest of cache blocks, since cache blocks are merged
+      int currentSlot = slot;
+      while (slot != pInfo->currentSlot) {
+        slot = (slot + 1) % pInfo->maxBlocks;
+        pCacheBlock = pInfo->cacheBlocks[slot];
+        vnodeFreeCacheBlock(pCacheBlock);
+      }
+
+      pInfo->currentSlot = currentSlot;
+      slot = currentSlot; // make sure to exit from the while loop
+    }
+
     if (slot == pInfo->currentSlot) break;
     slot = (slot + 1) % pInfo->maxBlocks;
   }
diff --git a/src/system/detail/src/vnodeShell.c b/src/system/detail/src/vnodeShell.c
index 47b7b470bb1a4a220f51c1606ca6e1398645c5fe..a5f5259887efbf66dcdd16416e61cec952b992d0 100644
--- a/src/system/detail/src/vnodeShell.c
+++ b/src/system/detail/src/vnodeShell.c
@@ -27,6 +27,7 @@
 #include "vnode.h"
 #include "vnodeRead.h"
 #include "vnodeUtil.h"
+#include "vnodeStore.h"
 
 #pragma GCC diagnostic ignored "-Wint-conversion"
 extern int tsMaxQueues;
@@ -46,7 +47,7 @@ void *vnodeProcessMsgFromShell(char *msg, void *ahandle, void *thandle) {
   SShellObj *pObj = (SShellObj *)ahandle;
   SIntMsg *  pMsg = (SIntMsg *)msg;
   uint32_t   peerId, peerIp;
-  short      peerPort;
+  uint16_t   peerPort;
   char       ipstr[20];
 
   if (msg == NULL) {
@@ -89,9 +90,9 @@ void *vnodeProcessMsgFromShell(char *msg, void *ahandle, void *thandle) {
   // if ( vnodeList[vnode].status != TSDB_STATUS_MASTER && pMsg->msgType != TSDB_MSG_TYPE_RETRIEVE ) {
 
 #ifdef CLUSTER
-  if (vnodeList[vnode].status != TSDB_STATUS_MASTER) {
+  if (vnodeList[vnode].vnodeStatus != TSDB_VNODE_STATUS_MASTER) {
     taosSendSimpleRsp(thandle, pMsg->msgType + 1, TSDB_CODE_NOT_READY);
-    dTrace("vid:%d sid:%d, shell msg is ignored since in state:%d", vnode, sid, vnodeList[vnode].status);
+    dTrace("vid:%d sid:%d, shell msg is ignored since in state:%d", vnode, sid, vnodeList[vnode].vnodeStatus);
   } else {
 #endif
     dTrace("vid:%d sid:%d, msg:%s is received pConn:%p", vnode, sid, taosMsg[pMsg->msgType], thandle);
@@ -154,6 +155,11 @@ int vnodeInitShell() {
 }
 
 int vnodeOpenShellVnode(int vnode) {
+  if (shellList[vnode] != NULL) {
+    dError("vid:%d, shell is already opened", vnode);
+    return -1;
+  }
+
   const int32_t MIN_NUM_OF_SESSIONS = 300;
 
   SVnodeCfg *pCfg = &vnodeList[vnode].cfg;
@@ -162,23 +168,29 @@ int vnodeOpenShellVnode(int vnode) {
   size_t size = sessions * sizeof(SShellObj);
   shellList[vnode] = (SShellObj *)calloc(1, size);
   if (shellList[vnode] == NULL) {
-    dError("vid:%d failed to allocate shellObj, size:%d", vnode, size);
+    dError("vid:%d, sessions:%d, failed to allocate shellObj, size:%d", vnode, pCfg->maxSessions, size);
     return -1;
   }
 
   if(taosOpenRpcChannWithQ(pShellServer, vnode, sessions, rpcQhandle[(vnode+1)%tsMaxQueues]) != TSDB_CODE_SUCCESS) {
+    dError("vid:%d, sessions:%d, failed to open shell", vnode, pCfg->maxSessions);
     return -1;
   }
 
+  dTrace("vid:%d, sessions:%d, shell is opened", vnode, pCfg->maxSessions);
   return TSDB_CODE_SUCCESS;
 }
 
 static void vnodeDelayedFreeResource(void *param, void *tmrId) {
   int32_t vnode = *(int32_t*) param;
-  taosCloseRpcChann(pShellServer, vnode); // close connection
-  tfree (shellList[vnode]);  //free SShellObj
+  dTrace("vid:%d, start to free resources", vnode);
 
+  taosCloseRpcChann(pShellServer, vnode); // close connection
+  tfree(shellList[vnode]);  //free SShellObj
   tfree(param);
+
+  memset(vnodeList + vnode, 0, sizeof(SVnodeObj));
+  vnodeCalcOpenVnodes();
 }
 
 void vnodeCloseShellVnode(int vnode) {
diff --git a/src/system/detail/src/vnodeStore.c b/src/system/detail/src/vnodeStore.c
index d299d7fbf8971ff07baa8618828ab0c31440c979..572bd88cf7b8c6c8cbe0450bed0f1fe51296d22b 100644
--- a/src/system/detail/src/vnodeStore.c
+++ b/src/system/detail/src/vnodeStore.c
@@ -22,6 +22,7 @@
 #include "vnode.h"
 #include "vnodeStore.h"
 #include "vnodeUtil.h"
+#include "tstatus.h"
 
 #pragma GCC diagnostic push
 #pragma GCC diagnostic warning "-Woverflow"
@@ -30,12 +31,14 @@ int        tsMaxVnode = -1;
 int        tsOpenVnodes = 0;
 SVnodeObj *vnodeList = NULL;
 
-int vnodeInitStoreVnode(int vnode) {
+static int vnodeInitStoreVnode(int vnode) {
   SVnodeObj *pVnode = vnodeList + vnode;
 
   pVnode->vnode = vnode;
   vnodeOpenMetersVnode(vnode);
-  if (pVnode->cfg.maxSessions == 0) return 0;
+  if (pVnode->cfg.maxSessions <= 0) {
+    return TSDB_CODE_SUCCESS;
+  }
 
   pVnode->firstKey = taosGetTimestamp(pVnode->cfg.precision);
 
@@ -45,9 +48,10 @@ int vnodeInitStoreVnode(int vnode) {
     return -1;
   }
 
-  if (vnodeInitFile(vnode) < 0) return -1;
-
-  // vnodeOpenMeterMgmtStoreVnode(vnode);
+  if (vnodeInitFile(vnode) < 0) {
+    dError("vid:%d, files init failed.", pVnode->vnode);
+    return -1;
+  }
 
   if (vnodeInitCommit(vnode) < 0) {
     dError("vid:%d, commit init failed.", pVnode->vnode);
@@ -70,10 +74,17 @@ int vnodeOpenVnode(int vnode) {
   pVnode->accessState = TSDB_VN_ALL_ACCCESS;
 
   // vnode is empty
-  if (pVnode->cfg.maxSessions == 0) return 0;
+  if (pVnode->cfg.maxSessions <= 0) {
+    return TSDB_CODE_SUCCESS;
+  }
+
+  if (!(pVnode->vnodeStatus == TSDB_VNODE_STATUS_OFFLINE || pVnode->vnodeStatus == TSDB_VNODE_STATUS_CREATING)) {
+    dError("vid:%d, status:%s, cannot enter open operation", vnode, taosGetVnodeStatusStr(pVnode->vnodeStatus));
+    return TSDB_CODE_INVALID_VNODE_STATUS;
+  }
 
+  dTrace("vid:%d, status:%s, start to open", vnode, taosGetVnodeStatusStr(pVnode->vnodeStatus));
   pthread_mutex_lock(&dmutex);
-  // vnodeOpenMeterMgmtVnode(vnode);
 
   // not enough memory, abort
   if ((code = vnodeOpenShellVnode(vnode)) != TSDB_CODE_SUCCESS) {
@@ -93,14 +104,13 @@ int vnodeOpenVnode(int vnode) {
   vnodeOpenStreams(pVnode, NULL);
 #endif
 
-  dTrace("vid:%d, vnode is opened, openVnodes:%d", vnode, tsOpenVnodes);
+  dTrace("vid:%d, vnode is opened, openVnodes:%d, status:%s", vnode, tsOpenVnodes, taosGetVnodeStatusStr(pVnode->vnodeStatus));
 
-  return 0;
+  return TSDB_CODE_SUCCESS;
 }
 
 static int32_t vnodeMarkAllMetersDropped(SVnodeObj* pVnode) {
   if (pVnode->meterList == NULL) {
-    assert(pVnode->cfg.maxSessions == 0);
     return TSDB_CODE_SUCCESS;
   }
 
@@ -119,7 +129,7 @@ static int32_t vnodeMarkAllMetersDropped(SVnodeObj* pVnode) {
   return ready? TSDB_CODE_SUCCESS:TSDB_CODE_ACTION_IN_PROGRESS;
 }
 
-int vnodeCloseVnode(int vnode) {
+static int vnodeCloseVnode(int vnode) {
   if (vnodeList == NULL) return TSDB_CODE_SUCCESS;
 
   SVnodeObj* pVnode = &vnodeList[vnode];
@@ -130,12 +140,23 @@ int vnodeCloseVnode(int vnode) {
     return TSDB_CODE_SUCCESS;
   }
 
+  if (pVnode->vnodeStatus == TSDB_VNODE_STATUS_DELETING) {
+    dTrace("vid:%d, status:%s, another thread performed delete operation", vnode, taosGetVnodeStatusStr(pVnode->vnodeStatus));
+    return TSDB_CODE_SUCCESS;
+  } else {
+    dTrace("vid:%d, status:%s, enter close operation", vnode, taosGetVnodeStatusStr(pVnode->vnodeStatus));
+    pVnode->vnodeStatus = TSDB_VNODE_STATUS_CLOSING;
+  }
+
   // set the meter is dropped flag 
   if (vnodeMarkAllMetersDropped(pVnode) != TSDB_CODE_SUCCESS) {
     pthread_mutex_unlock(&dmutex);
     return TSDB_CODE_ACTION_IN_PROGRESS;
   }
 
+  dTrace("vid:%d, status:%s, enter delete operation", vnode, taosGetVnodeStatusStr(pVnode->vnodeStatus));
+  pVnode->vnodeStatus = TSDB_VNODE_STATUS_DELETING;
+
   vnodeCloseStream(vnodeList + vnode);
   vnodeCancelCommit(vnodeList + vnode);
   vnodeClosePeerVnode(vnode);
@@ -149,9 +170,6 @@ int vnodeCloseVnode(int vnode) {
   if (tsMaxVnode == vnode) tsMaxVnode = vnode - 1;
 
   tfree(vnodeList[vnode].meterIndex);
-  memset(vnodeList + vnode, 0, sizeof(SVnodeObj));
-
-  vnodeCalcOpenVnodes();
 
   pthread_mutex_unlock(&dmutex);
   return TSDB_CODE_SUCCESS;
@@ -160,7 +178,12 @@ int vnodeCloseVnode(int vnode) {
 int vnodeCreateVnode(int vnode, SVnodeCfg *pCfg, SVPeerDesc *pDesc) {
   char fileName[128];
 
-  vnodeList[vnode].status = TSDB_STATUS_CREATING;
+  if (vnodeList[vnode].vnodeStatus != TSDB_VNODE_STATUS_OFFLINE) {
+    dError("vid:%d, status:%s, cannot enter create operation", vnode, taosGetVnodeStatusStr(vnodeList[vnode].vnodeStatus));
+    return TSDB_CODE_INVALID_VNODE_STATUS;
+  }
+
+  vnodeList[vnode].vnodeStatus = TSDB_VNODE_STATUS_CREATING;
 
   sprintf(fileName, "%s/vnode%d", tsDirectory, vnode);
   mkdir(fileName, 0755);
@@ -177,14 +200,14 @@ int vnodeCreateVnode(int vnode, SVnodeCfg *pCfg, SVPeerDesc *pDesc) {
     return TSDB_CODE_VG_INIT_FAILED;
   }
 
-  if (vnodeInitStoreVnode(vnode) != 0) {
+  if (vnodeInitStoreVnode(vnode) < 0) {
     return TSDB_CODE_VG_COMMITLOG_INIT_FAILED;
   }
 
   return vnodeOpenVnode(vnode);
 }
 
-void vnodeRemoveDataFiles(int vnode) {
+static void vnodeRemoveDataFiles(int vnode) {
   char           vnodeDir[TSDB_FILENAME_LEN];
   char           dfilePath[TSDB_FILENAME_LEN];
   char           linkFile[TSDB_FILENAME_LEN];
@@ -227,19 +250,28 @@ void vnodeRemoveDataFiles(int vnode) {
 
   sprintf(vnodeDir, "%s/vnode%d", tsDirectory, vnode);
   rmdir(vnodeDir);
-  dTrace("vnode %d is removed!", vnode);
+  dTrace("vid:%d, vnode is removed!", vnode);
 }
 
 int vnodeRemoveVnode(int vnode) {
   if (vnodeList == NULL) return TSDB_CODE_SUCCESS;
 
   if (vnodeList[vnode].cfg.maxSessions > 0) {
-    int32_t ret = vnodeCloseVnode(vnode);
-    if (ret != TSDB_CODE_SUCCESS) {
-      return ret;
+    SVnodeObj* pVnode = &vnodeList[vnode];
+    if (pVnode->vnodeStatus == TSDB_VNODE_STATUS_CREATING
+        || pVnode->vnodeStatus == TSDB_VNODE_STATUS_OFFLINE
+        || pVnode->vnodeStatus == TSDB_VNODE_STATUS_DELETING) {
+      dError("vid:%d, status:%s, cannot enter close/delete operation", vnode, taosGetVnodeStatusStr(pVnode->vnodeStatus));
+      return TSDB_CODE_ACTION_IN_PROGRESS;
+    } else {
+      int32_t ret = vnodeCloseVnode(vnode);
+      if (ret != TSDB_CODE_SUCCESS) {
+        return ret;
+      }
+
+      vnodeRemoveDataFiles(vnode);
     }
 
-    vnodeRemoveDataFiles(vnode);
   } else {
     dTrace("vid:%d, max sessions:%d, this vnode already dropped!!!", vnode, vnodeList[vnode].cfg.maxSessions);
     vnodeList[vnode].cfg.maxSessions = 0;  //reset value
@@ -293,7 +325,7 @@ void vnodeCleanUpOneVnode(int vnode) {
   again = 1;
 
   if (vnodeList[vnode].pCachePool) {
-    vnodeList[vnode].status = TSDB_STATUS_OFFLINE;
+    vnodeList[vnode].vnodeStatus = TSDB_VNODE_STATUS_OFFLINE;
     vnodeClosePeerVnode(vnode);
   }
 
@@ -322,7 +354,7 @@ void vnodeCleanUpVnodes() {
 
   for (int vnode = 0; vnode < TSDB_MAX_VNODES; ++vnode) {
     if (vnodeList[vnode].pCachePool) {
-      vnodeList[vnode].status = TSDB_STATUS_OFFLINE;
+      vnodeList[vnode].vnodeStatus = TSDB_VNODE_STATUS_OFFLINE;
       vnodeClosePeerVnode(vnode);
     }
   }
diff --git a/src/system/detail/src/vnodeStream.c b/src/system/detail/src/vnodeStream.c
index 0667ee77bdab731e06147af28195fecfc48fc79b..562b7eb73c80d67664c4f3148757eab03f517634 100644
--- a/src/system/detail/src/vnodeStream.c
+++ b/src/system/detail/src/vnodeStream.c
@@ -171,7 +171,7 @@ void vnodeCloseStream(SVnodeObj *pVnode) {
 void vnodeUpdateStreamRole(SVnodeObj *pVnode) {
   /* SMeterObj *pObj; */
 
-  int newRole = (pVnode->status == TSDB_STATUS_MASTER) ? 1 : 0;
+  int newRole = (pVnode->vnodeStatus == TSDB_VNODE_STATUS_MASTER) ? 1 : 0;
   if (newRole != pVnode->streamRole) {
     dTrace("vid:%d, stream role is changed to:%d", pVnode->vnode, newRole);
     pVnode->streamRole = newRole;
diff --git a/src/system/lite/src/dnodeMgmt.spec.c b/src/system/lite/src/dnodeMgmt.spec.c
index 00e7e469c04847f6578f24c2f0a2ce30f09934d6..6c424a85af38022fd5acdc433b0442982d288471 100644
--- a/src/system/lite/src/dnodeMgmt.spec.c
+++ b/src/system/lite/src/dnodeMgmt.spec.c
@@ -50,7 +50,7 @@ char *taosBuildReqMsgToMnode(SMgmtObj *pObj, char type) {
 }
 
 int taosSendMsgToMnode(SMgmtObj *pObj, char *msg, int msgLen) {
-  mTrace("msg:%s is sent to mnode", taosMsg[*(msg-1)]);
+  dTrace("msg:%s is sent to mnode", taosMsg[*(msg-1)]);
 
   /*
    * Lite version has no message header, so minus one
diff --git a/src/system/lite/src/mgmtDnode.spec.c b/src/system/lite/src/mgmtDnode.spec.c
index c34ac58c0084686438e2221a293414845bad705e..3c7c7f06ba8281adbcaf4424032d5c9b9aac8f36 100644
--- a/src/system/lite/src/mgmtDnode.spec.c
+++ b/src/system/lite/src/mgmtDnode.spec.c
@@ -30,7 +30,7 @@ int mgmtInitDnodes() {
   dnodeObj.createdTime = (int64_t)tsRebootTime * 1000;
   dnodeObj.lastReboot = tsRebootTime;
   dnodeObj.numOfCores = (uint16_t)tsNumOfCores;
-  dnodeObj.status = TSDB_STATUS_READY;
+  dnodeObj.status = TSDB_DNODE_STATUS_READY;
   dnodeObj.alternativeRole = TSDB_DNODE_ROLE_ANY;
   dnodeObj.numOfTotalVnodes = tsNumOfTotalVnodes;
   dnodeObj.thandle = (void*)(1);  //hack way
diff --git a/src/system/lite/src/mgmtDnodeInt.spec.c b/src/system/lite/src/mgmtDnodeInt.spec.c
index acde36e7b84bb94fa3f471cc7a18a0fa7bd8c2a7..10628d0fb0bb12ecb6cbd914051c33a2f616c4c5 100644
--- a/src/system/lite/src/mgmtDnodeInt.spec.c
+++ b/src/system/lite/src/mgmtDnodeInt.spec.c
@@ -82,7 +82,7 @@ void mgmtCleanUpDnodeInt() {}
 void mgmtProcessDnodeStatus(void *handle, void *tmrId) {
   SDnodeObj *pObj = &dnodeObj;
   pObj->openVnodes = tsOpenVnodes;
-  pObj->status = TSDB_STATUS_READY;
+  pObj->status = TSDB_DNODE_STATUS_READY;
 
   float memoryUsedMB = 0;
   taosGetSysMemory(&memoryUsedMB);
@@ -97,7 +97,7 @@ void mgmtProcessDnodeStatus(void *handle, void *tmrId) {
       if (vnodeList[vnode].cfg.maxSessions <= 0) {
         pVload->dropStatus = TSDB_VN_STATUS_READY;
         pVload->status = TSDB_VN_STATUS_READY;
-        mPrint("vid:%d, drop finished", pObj->privateIp, vnode);
+        mPrint("dnode:%s, vid:%d, drop finished", taosIpStr(pObj->privateIp), vnode);
         taosTmrStart(mgmtMonitorDbDrop, 10000, NULL, mgmtTmr);
       }
     }
diff --git a/src/system/lite/src/vnodePeer.spec.c b/src/system/lite/src/vnodePeer.spec.c
index 1ceb8465c3fd5743da4ba105c9d32580fadca9ae..d33e4ead6e176d8da7a02098dfbf92af44032c15 100644
--- a/src/system/lite/src/vnodePeer.spec.c
+++ b/src/system/lite/src/vnodePeer.spec.c
@@ -15,6 +15,7 @@
 
 #define _DEFAULT_SOURCE
 #include "vnode.h"
+#include "tstatus.h"
 
 int vnodeInitPeer(int numOfThreads) { return 0; }
 
@@ -30,8 +31,8 @@ void vnodeBroadcastStatusToUnsyncedPeer(SVnodeObj *pVnode) {}
 
 int vnodeOpenPeerVnode(int vnode) {
   SVnodeObj *pVnode = vnodeList + vnode;
-  pVnode->status = (pVnode->cfg.replications > 1) ? TSDB_STATUS_UNSYNCED : TSDB_STATUS_MASTER;
-  dTrace("vid:%d, vnode status:%d numOfPeers:%d", vnode, pVnode->status, pVnode->cfg.replications-1);
+  pVnode->vnodeStatus = (pVnode->cfg.replications > 1) ? TSDB_VNODE_STATUS_UNSYNCED : TSDB_VNODE_STATUS_MASTER;
+  dTrace("vid:%d, status:%s numOfPeers:%d", vnode, taosGetVnodeStatusStr(pVnode->vnodeStatus), pVnode->cfg.replications - 1);
   vnodeUpdateStreamRole(pVnode);
   return 0;
 }
diff --git a/src/util/src/tglobalcfg.c b/src/util/src/tglobalcfg.c
index bac89db7e23aaef36e4cc4f73737ba36e517496f..99c2b8e5301c0b8b96962b83111c1fdd3bc6a100 100644
--- a/src/util/src/tglobalcfg.c
+++ b/src/util/src/tglobalcfg.c
@@ -58,12 +58,12 @@ int64_t tsMsPerDay[] = {86400000L, 86400000000L};
 
 char  tsMasterIp[TSDB_IPv4ADDR_LEN] = {0};
 char  tsSecondIp[TSDB_IPv4ADDR_LEN] = {0};
-short tsMgmtShellPort = 6030;   // udp[6030-6034] tcp[6030]
-short tsVnodeShellPort = 6035;  // udp[6035-6039] tcp[6035]
-short tsMgmtVnodePort = 6040;   // udp[6040-6044] tcp[6040]
-short tsVnodeVnodePort = 6045;  // tcp[6045]
-short tsMgmtMgmtPort = 6050;    // sdbPeerPort only udp, numOfVnodes fixed to 1, range udp[6050]
-short tsMgmtSyncPort = 6050;    // sdbSyncPort only tcp, range tcp[6050]
+uint16_t tsMgmtShellPort = 6030;   // udp[6030-6034] tcp[6030]
+uint16_t tsVnodeShellPort = 6035;  // udp[6035-6039] tcp[6035]
+uint16_t tsMgmtVnodePort = 6040;   // udp[6040-6044] tcp[6040]
+uint16_t tsVnodeVnodePort = 6045;  // tcp[6045]
+uint16_t tsMgmtMgmtPort = 6050;    // udp, numOfVnodes fixed to 1, range udp[6050]
+uint16_t tsMgmtSyncPort = 6050;    // tcp, range tcp[6050]
 
 int tsStatusInterval = 1;         // second
 int tsShellActivityTimer = 3;     // second
@@ -77,7 +77,7 @@ float tsRatioOfQueryThreads = 0.5;
 char  tsPublicIp[TSDB_IPv4ADDR_LEN] = {0};
 char  tsInternalIp[TSDB_IPv4ADDR_LEN] = {0};
 char  tsPrivateIp[TSDB_IPv4ADDR_LEN] = {0};
-char  tsServerIpStr[TSDB_IPv4ADDR_LEN] = "0.0.0.0";
+char  tsServerIpStr[TSDB_IPv4ADDR_LEN] = "127.0.0.1";
 short tsNumOfVnodesPerCore = 8;
 short tsNumOfTotalVnodes = 0;
 short tsCheckHeaderFile = 0;
@@ -152,8 +152,8 @@ int     tsProjectExecInterval = 10000;   // every 10sec, the projection will be
 int64_t tsMaxRetentWindow = 24 * 3600L;  // maximum time window tolerance
 
 char  tsHttpIp[TSDB_IPv4ADDR_LEN] = "0.0.0.0";
-short tsHttpPort = 6020;                 // only tcp, range tcp[6020]
-// short tsNginxPort = 6060;             //only tcp, range tcp[6060]
+uint16_t tsHttpPort = 6020;                 // only tcp, range tcp[6020]
+// uint16_t tsNginxPort = 6060;             //only tcp, range tcp[6060]
 int tsHttpCacheSessions = 100;
 int tsHttpSessionExpire = 36000;
 int tsHttpMaxThreads = 2;
diff --git a/src/util/src/tsocket.c b/src/util/src/tsocket.c
index 8de70f8a01147d211dced1ef73f57ef87c4c22ee..6e8379c0a486aa35433742dea1af7b10ea3be682 100644
--- a/src/util/src/tsocket.c
+++ b/src/util/src/tsocket.c
@@ -261,20 +261,19 @@ int taosReadn(int fd, char *ptr, int nbytes) {
   return (nbytes - nleft);
 }
 
-int taosOpenUdpSocket(char *ip, short port) {
+int taosOpenUdpSocket(char *ip, uint16_t port) {
   struct sockaddr_in localAddr;
   int                sockFd;
   int                ttl = 128;
   int                reuse, nocheck;
   int                bufSize = 8192000;
 
-  pTrace("open udp socket:%s:%d", ip, port);
-  // if (tsAllowLocalhost) ip = "0.0.0.0";
+  pTrace("open udp socket:%s:%hu", ip, port);
 
   memset((char *)&localAddr, 0, sizeof(localAddr));
   localAddr.sin_family = AF_INET;
   localAddr.sin_addr.s_addr = inet_addr(ip);
-  localAddr.sin_port = (uint16_t)htons((uint16_t)port);
+  localAddr.sin_port = (uint16_t)htons(port);
 
   if ((sockFd = (int)socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
     pError("failed to open udp socket: %d (%s)", errno, strerror(errno));
@@ -320,7 +319,7 @@ int taosOpenUdpSocket(char *ip, short port) {
 
   /* bind socket to local address */
   if (bind(sockFd, (struct sockaddr *)&localAddr, sizeof(localAddr)) < 0) {
-    pError("failed to bind udp socket: %d (%s), %s:%d", errno, strerror(errno), ip, port);
+    pError("failed to bind udp socket: %d (%s), %s:%hu", errno, strerror(errno), ip, port);
     taosCloseSocket(sockFd);
     return -1;
   }
@@ -328,13 +327,12 @@ int taosOpenUdpSocket(char *ip, short port) {
   return sockFd;
 }
 
-int taosOpenTcpClientSocket(char *destIp, short destPort, char *clientIp) {
+int taosOpenTcpClientSocket(char *destIp, uint16_t destPort, char *clientIp) {
   int                sockFd = 0;
   struct sockaddr_in serverAddr, clientAddr;
   int                ret;
 
   pTrace("open tcp client socket:%s:%d", destIp, destPort);
-  // if (tsAllowLocalhost) destIp = "0.0.0.0";
 
   sockFd = (int)socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
 
@@ -366,7 +364,7 @@ int taosOpenTcpClientSocket(char *destIp, short destPort, char *clientIp) {
   ret = connect(sockFd, (struct sockaddr *)&serverAddr, sizeof(serverAddr));
 
   if (ret != 0) {
-    pError("failed to connect socket, ip:%s, port:%d, reason: %s", destIp, destPort, strerror(errno));
+    pError("failed to connect socket, ip:%s, port:%hu, reason: %s", destIp, destPort, strerror(errno));
     taosCloseSocket(sockFd);
     sockFd = -1;
   }
@@ -424,18 +422,17 @@ int taosKeepTcpAlive(int sockFd) {
   return 0;
 }
 
-int taosOpenTcpServerSocket(char *ip, short port) {
+int taosOpenTcpServerSocket(char *ip, uint16_t port) {
   struct sockaddr_in serverAdd;
   int                sockFd;
   int                reuse;
 
-  pTrace("open tcp server socket:%s:%d", ip, port);
-  // if (tsAllowLocalhost) ip = "0.0.0.0";
+  pTrace("open tcp server socket:%s:%hu", ip, port);
 
   bzero((char *)&serverAdd, sizeof(serverAdd));
   serverAdd.sin_family = AF_INET;
   serverAdd.sin_addr.s_addr = inet_addr(ip);
-  serverAdd.sin_port = (uint16_t)htons((uint16_t)port);
+  serverAdd.sin_port = (uint16_t)htons(port);
 
   if ((sockFd = (int)socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
     pError("failed to open TCP socket: %d (%s)", errno, strerror(errno));
@@ -452,7 +449,7 @@ int taosOpenTcpServerSocket(char *ip, short port) {
 
   /* bind socket to server address */
   if (bind(sockFd, (struct sockaddr *)&serverAdd, sizeof(serverAdd)) < 0) {
-    pError("bind tcp server socket failed, %s:%d, reason:%d(%s)", ip, port, errno, strerror(errno));
+    pError("bind tcp server socket failed, %s:%hu, reason:%d(%s)", ip, port, errno, strerror(errno));
     close(sockFd);
     return -1;
   }
@@ -460,7 +457,7 @@ int taosOpenTcpServerSocket(char *ip, short port) {
   if (taosKeepTcpAlive(sockFd) < 0) return -1;
 
   if (listen(sockFd, 10) < 0) {
-    pError("listen tcp server socket failed, %s:%d, reason:%d(%s)", ip, port, errno, strerror(errno));
+    pError("listen tcp server socket failed, %s:%hu, reason:%d(%s)", ip, port, errno, strerror(errno));
     return -1;
   }
 
@@ -472,7 +469,6 @@ int taosOpenRawSocket(char *ip) {
   struct sockaddr_in rawAdd;
 
   pTrace("open udp raw socket:%s", ip);
-  // if (tsAllowLocalhost) ip = "0.0.0.0";
 
   fd = (int)socket(AF_INET, SOCK_RAW, IPPROTO_UDP);
   if (fd < 0) {
diff --git a/src/util/src/tstatus.c b/src/util/src/tstatus.c
index 570ba547eb238d8951b73ab21a1f78e743e8e753..1e212859600126b581a5333a422a627fc883b8bd 100644
--- a/src/util/src/tstatus.c
+++ b/src/util/src/tstatus.c
@@ -13,10 +13,54 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-char* sdbDnodeStatusStr[] = {"offline", "creating", "unsynced", "slave", "master", "ready"};
+#include "taosmsg.h"
+#include "tsdb.h"
 
-char* sdbDnodeBalanceStateStr[] = {"balanced", "balancing", "offline removing", "shell removing"};
+const char* taosGetVnodeStatusStr(int vnodeStatus) {
+  switch (vnodeStatus) {
+    case TSDB_VNODE_STATUS_OFFLINE:return "offline";
+    case TSDB_VNODE_STATUS_CREATING: return "creating";
+    case TSDB_VNODE_STATUS_UNSYNCED: return "unsynced";
+    case TSDB_VNODE_STATUS_SLAVE: return "slave";
+    case TSDB_VNODE_STATUS_MASTER: return "master";
+    case TSDB_VNODE_STATUS_CLOSING: return "closing";
+    case TSDB_VNODE_STATUS_DELETING: return "deleting";
+    default: return "undefined";
+  }
+}
 
-char* sdbVnodeSyncStatusStr[] = {"init", "syncing", "sync_cache", "sync_file"};
+const char* taosGetDnodeStatusStr(int dnodeStatus) {
+  switch (dnodeStatus) {
+    case TSDB_DNODE_STATUS_OFFLINE: return "offline";
+    case TSDB_DNODE_STATUS_READY: return "ready";
+    default: return "undefined";
+  }
+}
 
-char* sdbVnodeDropStateStr[] = {"ready", "dropping"};
+const char* taosGetDnodeBalanceStateStr(int dnodeBalanceStatus) {
+  switch (dnodeBalanceStatus) {
+    case LB_DNODE_STATE_BALANCED: return "balanced";
+    case LB_DNODE_STATE_BALANCING: return "balancing";
+    case LB_DNODE_STATE_OFFLINE_REMOVING: return "offline removing";
+    case LB_DNODE_STATE_SHELL_REMOVING: return "removing";
+    default: return "undefined";
+  }
+}
+
+const char* taosGetVnodeSyncStatusStr(int vnodeSyncStatus) {
+  switch (vnodeSyncStatus) {
+    case STDB_SSTATUS_INIT: return "init";
+    case TSDB_SSTATUS_SYNCING: return "syncing";
+    case TSDB_SSTATUS_SYNC_CACHE: return "sync_cache";
+    case TSDB_SSTATUS_SYNC_FILE: return "sync_file";
+    default: return "undefined";
+  }
+}
+
+const char* taosGetVnodeDropStatusStr(int dropping) {
+  switch (dropping) {
+    case 0: return "ready";
+    case 1: return "dropping";
+    default: return "undefined";
+  }
+}
\ No newline at end of file
diff --git a/src/util/src/ttimer.c b/src/util/src/ttimer.c
index 9dad1e4e1e70fa74bbdc95f64a66328520208922..a1a356b13b6b43e066439be97786ed799775a149 100644
--- a/src/util/src/ttimer.c
+++ b/src/util/src/ttimer.c
@@ -549,7 +549,9 @@ void* taosTmrInit(int maxNumOfTmrs, int resolution, int longest, const char* lab
 
 void taosTmrCleanUp(void* handle) {
   tmr_ctrl_t* ctrl = (tmr_ctrl_t*)handle;
-  assert(ctrl != NULL && ctrl->label[0] != 0);
+  if (ctrl == NULL || ctrl->label[0] == 0) {
+    return;
+  }
 
   tmrTrace("%s timer controller is cleaned up.", ctrl->label);
   ctrl->label[0] = 0;