[TD-992] refactor codes

CMakeLists.txt

@@ -1,7 +1,6 @@
 CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
 PROJECT(TDengine)
 
-SET(TD_SYNC FALSE)
 SET(TD_ACCOUNT FALSE)
 SET(TD_ADMIN FALSE)
 SET(TD_GRANT FALSE)

cmake/define.inc

@@ -1,10 +1,6 @@
 CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
 PROJECT(TDengine)
 
-IF (TD_SYNC)
-  ADD_DEFINITIONS(-D_SYNC)
-ENDIF ()
-
 IF (TD_ACCOUNT)
   ADD_DEFINITIONS(-D_ACCT)
 ENDIF ()

cmake/env.inc

@@ -9,7 +9,6 @@ SET(LIBRARY_OUTPUT_PATH ${PROJECT_BINARY_DIR}/build/lib)
 SET(EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR}/build/bin)
 SET(TD_TESTS_OUTPUT_DIR ${PROJECT_BINARY_DIR}/test)
 
-MESSAGE(STATUS "Operating system dependency directory: " ${TD_OS_DIR})
 MESSAGE(STATUS "Project source directory: " ${PROJECT_SOURCE_DIR})
 MESSAGE(STATUS "Project binary files output path: " ${PROJECT_BINARY_DIR})
 MESSAGE(STATUS "Project executable files output path: " ${EXECUTABLE_OUTPUT_PATH})

cmake/platform.inc

@@ -33,20 +33,23 @@ IF (${CPUTYPE} MATCHES "aarch32")
   SET(TD_PAGMODE_LITE TRUE)
   ADD_DEFINITIONS(-D_TD_ARM_)
   ADD_DEFINITIONS(-D_TD_ARM_32_)
+  MESSAGE(STATUS "input cpuType: aarch32")
 ELSEIF (${CPUTYPE} MATCHES "aarch64")
   SET(TD_ARM TRUE)
   SET(TD_ARM_64 TRUE)
   ADD_DEFINITIONS(-D_TD_ARM_)
   ADD_DEFINITIONS(-D_TD_ARM_64_)
+   MESSAGE(STATUS "input cpuType: aarch64")
 ELSEIF (${CPUTYPE} MATCHES "mips64")
   SET(TD_MIPS TRUE)
   SET(TD_MIPS_64 TRUE)
   ADD_DEFINITIONS(-D_TD_MIPS_)
   ADD_DEFINITIONS(-D_TD_MIPS_64_)
+  MESSAGE(STATUS "input cpuType: mips64")
 ELSEIF (${CPUTYPE} MATCHES "x64")
-  MESSAGE(STATUS "input cpuType: " ${CPUTYPE})
+  MESSAGE(STATUS "input cpuType: x64")
 ELSEIF (${CPUTYPE} MATCHES "x86")
-  MESSAGE(STATUS "input cpuType: " ${CPUTYPE})
+  MESSAGE(STATUS "input cpuType: x86")
 ELSE ()
   MESSAGE(STATUS "input cpuType: " ${CPUTYPE})
 ENDIF ()
@@ -61,13 +64,13 @@ MESSAGE(STATUS "The current os is " ${TD_OS_INFO})
 IF (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
   IF (${CMAKE_SIZEOF_VOID_P} MATCHES 8)
     SET(TD_LINUX_64 TRUE)
-    SET(TD_OS_DIR ${TD_COMMUNITY_DIR}/src/os/linux)
     ADD_DEFINITIONS(-D_M_X64)
+    ADD_DEFINITIONS(-D_TD_LINUX_64)
     MESSAGE(STATUS "The current platform is Linux 64-bit")
   ELSEIF (${CMAKE_SIZEOF_VOID_P} MATCHES 4)
+    SET(TD_LINUX_32 TRUE)
+    ADD_DEFINITIONS(-D_TD_LINUX_32)
     IF (TD_ARM)
-      SET(TD_LINUX_32 TRUE)
-      SET(TD_OS_DIR ${TD_COMMUNITY_DIR}/src/os/linux)
       #ADD_DEFINITIONS(-D_M_IX86)
       MESSAGE(STATUS "The current platform is Linux 32-bit")
     ELSE ()
@@ -81,7 +84,7 @@ IF (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
 ELSEIF (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
   IF (${CMAKE_SIZEOF_VOID_P} MATCHES 8)
     SET(TD_DARWIN_64 TRUE)
-    SET(TD_OS_DIR ${TD_COMMUNITY_DIR}/src/os/darwin)
+    ADD_DEFINITIONS(-D_TD_DARWIN_64)
     MESSAGE(STATUS "The current platform is Darwin 64-bit")
   ELSE ()
     MESSAGE(FATAL_ERROR "The current platform is Darwin 32-bit, not supported yet")
@@ -90,10 +93,12 @@ ELSEIF (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
 ELSEIF (${CMAKE_SYSTEM_NAME} MATCHES "Windows")
   IF (${CMAKE_SIZEOF_VOID_P} MATCHES 8)
     SET(TD_WINDOWS_64 TRUE)
-    SET(TD_OS_DIR ${TD_COMMUNITY_DIR}/src/os/windows)
     ADD_DEFINITIONS(-D_M_X64)
+    ADD_DEFINITIONS(-D_TD_WINDOWS_64)
     MESSAGE(STATUS "The current platform is Windows 64-bit")
   ELSE ()
+    SET(TD_WINDOWS_32 TRUE)
+    ADD_DEFINITIONS(-D_TD_WINDOWS_32)
     MESSAGE(FATAL_ERROR "The current platform is Windows 32-bit, not supported yet")
     EXIT ()
   ENDIF ()

src/balance/CMakeLists.txt

@@ -0,0 +1,16 @@
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+PROJECT(TDengine)
+
+IF ((TD_LINUX_64) OR (TD_LINUX_32 AND TD_ARM))
+  INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/inc)
+  INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/os/inc)
+  INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/util/inc)
+  INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/common/inc)
+  INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/mnode/inc)
+  INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/dnode/inc)
+  INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/sdb/inc)
+  INCLUDE_DIRECTORIES(${TD_ENTERPRISE_DIR}/src/inc)
+  INCLUDE_DIRECTORIES(inc)
+  AUX_SOURCE_DIRECTORY(src SRC)
+  ADD_LIBRARY(balance ${SRC})
+ENDIF ()

src/client/CMakeLists.txt

@@ -4,11 +4,11 @@ PROJECT(TDengine)
 INCLUDE_DIRECTORIES(inc)
 INCLUDE_DIRECTORIES(jni)
 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/inc)
+INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/os/inc)
 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/util/inc)
 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/query/inc)
 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/common/inc)
 INCLUDE_DIRECTORIES(${TD_ENTERPRISE_DIR}/src/inc)
-INCLUDE_DIRECTORIES(${TD_OS_DIR}/inc)
 AUX_SOURCE_DIRECTORY(src SRC)
 
 IF ((TD_LINUX_64) OR (TD_LINUX_32 AND TD_ARM))

src/client/src/tscParseInsert.c

@@ -104,7 +104,7 @@ int tsParseTime(SSQLToken *pToken, int64_t *time, char **next, char *error, int1
   } else if (strncmp(pToken->z, "0", 1) == 0 && pToken->n == 1) {
     // do nothing
   } else if (pToken->type == TK_INTEGER) {
-    useconds = str2int64(pToken->z);
+    useconds = tsosStr2int64(pToken->z);
   } else {
     // strptime("2001-11-12 18:31:01", "%Y-%m-%d %H:%M:%S", &tm);
     if (taosParseTime(pToken->z, time, pToken->n, timePrec, tsDaylight) != TSDB_CODE_SUCCESS) {

src/client/src/tscSystem.c

@@ -220,7 +220,7 @@ static int taos_options_imp(TSDB_OPTION option, const char *pStr) {
 
         if (strlen(tsLocale) == 0) { // locale does not set yet
           char* defaultLocale = setlocale(LC_CTYPE, "");
-          tstrncpy(tsLocale, defaultLocale, sizeof(tsLocale));
+          tstrncpy(tsLocale, defaultLocale, TSDB_LOCALE_LEN);
         }
 
         // set the user specified locale
@@ -234,7 +234,7 @@ static int taos_options_imp(TSDB_OPTION option, const char *pStr) {
           tscInfo("failed to set locale:%s, current locale:%s", pStr, tsLocale);
         }
 
-        tstrncpy(tsLocale, locale, sizeof(tsLocale));
+        tstrncpy(tsLocale, locale, TSDB_LOCALE_LEN);
 
         char *charset = strrchr(tsLocale, sep);
         if (charset != NULL) {
@@ -249,7 +249,7 @@ static int taos_options_imp(TSDB_OPTION option, const char *pStr) {
               tscInfo("charset changed from %s to %s", tsCharset, charset);
             }
 
-            tstrncpy(tsCharset, charset, sizeof(tsCharset));
+            tstrncpy(tsCharset, charset, TSDB_LOCALE_LEN);
             cfg->cfgStatus = TAOS_CFG_CSTATUS_OPTION;
 
           } else {
@@ -286,7 +286,7 @@ static int taos_options_imp(TSDB_OPTION option, const char *pStr) {
             tscInfo("charset changed from %s to %s", tsCharset, pStr);
           }
 
-          tstrncpy(tsCharset, pStr, sizeof(tsCharset));
+          tstrncpy(tsCharset, pStr, TSDB_LOCALE_LEN);
           cfg->cfgStatus = TAOS_CFG_CSTATUS_OPTION;
         } else {
           tscInfo("charset:%s not valid", pStr);
@@ -304,7 +304,7 @@ static int taos_options_imp(TSDB_OPTION option, const char *pStr) {
       assert(cfg != NULL);
     
       if (cfg->cfgStatus <= TAOS_CFG_CSTATUS_OPTION) {
-        tstrncpy(tsTimezone, pStr, sizeof(tsTimezone));
+        tstrncpy(tsTimezone, pStr, TSDB_TIMEZONE_LEN);
         tsSetTimeZone();
         cfg->cfgStatus = TAOS_CFG_CSTATUS_OPTION;
         tscDebug("timezone set:%s, input:%s by taos_options", tsTimezone, pStr);

src/common/CMakeLists.txt

@@ -1,12 +1,11 @@
 CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
 PROJECT(TDengine)
 
-IF ((TD_LINUX_64) OR (TD_LINUX_32 AND TD_ARM))
+INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/inc)
-  INCLUDE_DIRECTORIES(${TD_OS_DIR}/inc)
+INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/os/inc)
-  INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/inc)
+INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/util/inc)
-  INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/util/inc)
+INCLUDE_DIRECTORIES(inc)
-  INCLUDE_DIRECTORIES(inc)
+
-  AUX_SOURCE_DIRECTORY(src SRC)
+AUX_SOURCE_DIRECTORY(src SRC)
-  ADD_LIBRARY(common ${SRC})
+ADD_LIBRARY(common ${SRC})
-  TARGET_LINK_LIBRARIES(common tutil)
+TARGET_LINK_LIBRARIES(common tutil)
-ENDIF ()

src/common/inc/tglobal.h

@@ -43,9 +43,9 @@ extern uint32_t tsMaxTmrCtrl;
 extern float    tsNumOfThreadsPerCore;
 extern float    tsRatioOfQueryThreads;
 extern int8_t   tsDaylight;
-extern char     tsTimezone[64];
+extern char     tsTimezone[];
-extern char     tsLocale[64];
+extern char     tsLocale[];
-extern char     tsCharset[64];  // default encode string
+extern char     tsCharset[];  // default encode string
 extern int32_t  tsEnableCoreFile;
 extern int32_t  tsCompressMsgSize;
 

src/common/src/tglobal.c

@@ -50,7 +50,7 @@ int32_t tsShellActivityTimer = 3;  // second
 float   tsNumOfThreadsPerCore = 1.0;
 float   tsRatioOfQueryThreads = 0.5;
 int8_t  tsDaylight = 0;
-char    tsTimezone[64] = {0};
+char    tsTimezone[TSDB_TIMEZONE_LEN] = {0};
 char    tsLocale[TSDB_LOCALE_LEN] = {0};
 char    tsCharset[TSDB_LOCALE_LEN] = {0};  // default encode string
 int32_t tsEnableCoreFile = 0;

src/cq/CMakeLists.txt

@@ -1,8 +1,8 @@
 CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
 PROJECT(TDengine)
 
-INCLUDE_DIRECTORIES(${TD_OS_DIR}/inc)
 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/inc)
+INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/os/inc)
 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/util/inc)
 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/common/inc)
 INCLUDE_DIRECTORIES(inc)

src/cq/test/CMakeLists.txt

@@ -1,17 +1,12 @@
 CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
 PROJECT(TDengine)
 
-IF ((TD_LINUX_64) OR (TD_LINUX_32 AND TD_ARM))
+INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/inc)
-  INCLUDE_DIRECTORIES(${TD_OS_DIR}/inc)
+INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/os/inc)
-  INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/inc)
+INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/util/inc)
-  INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/util/inc)
+INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/common/inc)
-  INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/common/inc)
+INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/cq/inc)
-  INCLUDE_DIRECTORIES(../inc)
-
-  LIST(APPEND CQTEST_SRC ./cqtest.c)
-  ADD_EXECUTABLE(cqtest ${CQTEST_SRC})
-  TARGET_LINK_LIBRARIES(cqtest tcq)
-
-ENDIF ()
-
 
+LIST(APPEND CQTEST_SRC ./cqtest.c)
+ADD_EXECUTABLE(cqtest ${CQTEST_SRC})
+TARGET_LINK_LIBRARIES(cqtest tcq)

src/dnode/CMakeLists.txt

@@ -2,8 +2,8 @@ CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
 PROJECT(TDengine)
 
 IF ((TD_LINUX_64) OR (TD_LINUX_32 AND TD_ARM))
-  INCLUDE_DIRECTORIES(${TD_OS_DIR}/inc)
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/inc)
+  INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/os/inc)
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/util/inc)
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/query/inc)
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/mnode/inc)
@@ -16,7 +16,7 @@ IF ((TD_LINUX_64) OR (TD_LINUX_32 AND TD_ARM))
   AUX_SOURCE_DIRECTORY(src SRC)
 
   ADD_EXECUTABLE(taosd ${SRC})
-  TARGET_LINK_LIBRARIES(taosd mnode taos_static monitor http mqtt tsdb twal vnode cJson lz4)
+  TARGET_LINK_LIBRARIES(taosd mnode taos_static monitor http mqtt tsdb twal vnode cJson lz4 balance sync)
 
   IF (TD_ACCOUNT)
     TARGET_LINK_LIBRARIES(taosd account)
@@ -26,10 +26,6 @@ IF ((TD_LINUX_64) OR (TD_LINUX_32 AND TD_ARM))
     TARGET_LINK_LIBRARIES(taosd grant)
   ENDIF ()
 
-  IF (TD_SYNC)
-    TARGET_LINK_LIBRARIES(taosd balance sync)
-  ENDIF ()
-
   SET(PREPARE_ENV_CMD "prepare_env_cmd")
   SET(PREPARE_ENV_TARGET "prepare_env_target")
   ADD_CUSTOM_COMMAND(OUTPUT ${PREPARE_ENV_CMD}

src/dnode/src/dnodeSystem.c

@@ -20,7 +20,6 @@
 #include "tglobal.h"
 #include "dnodeInt.h"
 #include "dnodeMain.h"
-#include "tfile.h"
 
 static void signal_handler(int32_t signum, siginfo_t *sigInfo, void *context);
 static sem_t exitSem;
@@ -40,7 +39,7 @@ int32_t main(int32_t argc, char *argv[]) {
         exit(EXIT_FAILURE);
       }
     } else if (strcmp(argv[i], "-V") == 0) {
-#ifdef _SYNC
+#ifdef _ACCT
       char *versionStr = "enterprise";
 #else
       char *versionStr = "community";

src/inc/taosdef.h

@@ -250,7 +250,7 @@ void tsDataSwap(void *pLeft, void *pRight, int32_t type, int32_t size);
 #define TSDB_STATE_LEN            20
 #define TSDB_COUNTRY_LEN          20
 #define TSDB_LOCALE_LEN           64
-#define TSDB_TIMEZONE_LEN         64
+#define TSDB_TIMEZONE_LEN         96
 #define TSDB_LABEL_LEN            8 
 
 #define TSDB_FQDN_LEN             128

src/kit/shell/CMakeLists.txt

@@ -2,11 +2,11 @@ CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
 PROJECT(TDengine)
 
 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/inc)
+INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/os/inc)
 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/util/inc)
 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/client/inc)
 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/query/inc)
 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/common/inc)
-INCLUDE_DIRECTORIES(${TD_OS_DIR}/inc)
 INCLUDE_DIRECTORIES(inc)
 
 IF ((TD_LINUX_64) OR (TD_LINUX_32 AND TD_ARM))

src/kit/taosdemo/CMakeLists.txt

@@ -2,9 +2,9 @@ CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
 PROJECT(TDengine)
 
 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/inc)
+INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/os/inc)
 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/client/inc)
 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/util/inc)
-INCLUDE_DIRECTORIES(${TD_OS_DIR}/inc)
 INCLUDE_DIRECTORIES(inc)
 
 IF ((TD_LINUX_64) OR (TD_LINUX_32 AND TD_ARM))

src/kit/taosdump/CMakeLists.txt

@@ -2,11 +2,11 @@ CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
 PROJECT(TDengine)
 
 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/inc)
+INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/os/inc)
 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/common/inc)
 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/client/inc)
 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/util/inc)
 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/query/inc)
-INCLUDE_DIRECTORIES(${TD_OS_DIR}/inc)
 INCLUDE_DIRECTORIES(inc)
 
 IF ((TD_LINUX_64) OR (TD_LINUX_32 AND TD_ARM))

src/kit/taosdump/taosdump.c

@@ -545,7 +545,7 @@ int32_t taosSaveAllNormalTableToTempFile(TAOS *taosCon, char*meter, char* metric
   strcpy(tableRecord.name, meter);
   strcpy(tableRecord.metric, metric);
 
-  twrite(*fd, &tableRecord, sizeof(STableRecord));
+  taosTWrite(*fd, &tableRecord, sizeof(STableRecord));
   return 0;
 }
 
@@ -600,7 +600,7 @@ int32_t taosSaveTableOfMetricToTempFile(TAOS *taosCon, char* metric, struct argu
     strncpy(tableRecord.name, (char *)row[0], fields[0].bytes);
     strcpy(tableRecord.metric, metric);
 
-    twrite(fd, &tableRecord, sizeof(STableRecord));
+    taosTWrite(fd, &tableRecord, sizeof(STableRecord));
 
     numOfTable++;
 
@@ -1196,7 +1196,7 @@ int32_t taosDumpCreateSuperTableClause(TAOS* taosCon, char* dbName, FILE *fp)
   while ((row = taos_fetch_row(tmpResult)) != NULL) {  
     memset(&tableRecord, 0, sizeof(STableRecord));
     strncpy(tableRecord.name, (char *)row[TSDB_SHOW_TABLES_NAME_INDEX], fields[TSDB_SHOW_TABLES_NAME_INDEX].bytes);
-    twrite(fd, &tableRecord, sizeof(STableRecord));
+    taosTWrite(fd, &tableRecord, sizeof(STableRecord));
   }  
   
   taos_free_result(tmpResult);
@@ -1282,7 +1282,7 @@ int taosDumpDb(SDbInfo *dbInfo, struct arguments *arguments, FILE *fp, TAOS *tao
     strncpy(tableRecord.name, (char *)row[TSDB_SHOW_TABLES_NAME_INDEX], fields[TSDB_SHOW_TABLES_NAME_INDEX].bytes);
     strncpy(tableRecord.metric, (char *)row[TSDB_SHOW_TABLES_METRIC_INDEX], fields[TSDB_SHOW_TABLES_METRIC_INDEX].bytes);
 
-    twrite(fd, &tableRecord, sizeof(STableRecord));
+    taosTWrite(fd, &tableRecord, sizeof(STableRecord));
 
     numOfTable++;
 

src/kit/taosmigrate/CMakeLists.txt

@@ -2,8 +2,8 @@ CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
 PROJECT(TDengine)
 
 IF ((TD_LINUX_64) OR (TD_LINUX_32 AND TD_ARM))
-  INCLUDE_DIRECTORIES(${TD_OS_DIR}/inc)
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/inc)
+  INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/os/inc)
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/util/inc)
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/mnode/inc) 
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/vnode/inc)

src/mnode/CMakeLists.txt

@@ -2,8 +2,8 @@ CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
 PROJECT(TDengine)
 
 IF ((TD_LINUX_64) OR (TD_LINUX_32 AND TD_ARM))
-  INCLUDE_DIRECTORIES(${TD_OS_DIR}/inc)
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/inc)
+  INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/os/inc)
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/common/inc)
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/util/inc)
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/query/inc)

src/mnode/src/mnodeDb.c

@@ -301,13 +301,6 @@ static int32_t mnodeCheckDbCfg(SDbCfg *pCfg) {
     return TSDB_CODE_MND_INVALID_DB_OPTION;
   }
 
-#ifndef _SYNC
-  if (pCfg->replications != 1) {
-    mError("invalid db option replications:%d can only be 1 in this version", pCfg->replications);
-    return TSDB_CODE_MND_INVALID_DB_OPTION;
-  }
-#endif
-
   return TSDB_CODE_SUCCESS;
 }
 

src/mnode/src/mnodeDnode.c

@@ -79,9 +79,6 @@ static int32_t mnodeDnodeActionInsert(SSdbOper *pOper) {
 static int32_t mnodeDnodeActionDelete(SSdbOper *pOper) {
   SDnodeObj *pDnode = pOper->pObj;
  
-#ifndef _SYNC 
-  mnodeDropAllDnodeVgroups(pDnode);
-#endif  
   mnodeDropMnodeLocal(pDnode->dnodeId);
   balanceAsyncNotify();
 
@@ -552,12 +549,7 @@ static int32_t mnodeDropDnodeByEp(char *ep, SMnodeMsg *pMsg) {
 
   mInfo("dnode:%d, start to drop it", pDnode->dnodeId);
 
-#ifndef _SYNC
-  int32_t code = mnodeDropDnode(pDnode, pMsg);
-#else
   int32_t code = balanceDropDnode(pDnode);
-#endif
-
   mnodeDecDnodeRef(pDnode);
   return code;
 }

src/os/CMakeLists.txt

@@ -1,6 +1,16 @@
 CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
 PROJECT(TDengine)
 
-ADD_SUBDIRECTORY(linux)
+IF (TD_LINUX_64)
-ADD_SUBDIRECTORY(windows)
+  ADD_SUBDIRECTORY(src/linux64)
-ADD_SUBDIRECTORY(darwin)
+ELSEIF (TD_LINUX_32)
+  ADD_SUBDIRECTORY(src/linux32)
+ELSEIF (TD_DARWIN_64)
+  ADD_SUBDIRECTORY(src/darwin64)  
+ELSEIF (TD_WINDOWS_64)
+  ADD_SUBDIRECTORY(src/windows64)
+ELSEIF (TD_WINDOWS_32)
+  ADD_SUBDIRECTORY(src/windows32)
+ENDIF ()
+
+ADD_SUBDIRECTORY(src/detail)

src/os/inc/os.h

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef TDENGINE_OS_H
+#define TDENGINE_OS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef _TD_DARWIN_64
+#include "osDarwin64.h"
+#endif
+
+#ifdef _TD_LINUX_64
+#include "osLinux64.h"
+#endif
+
+#ifdef _TD_LINUX_32
+#include "osLinux32.h"
+#endif
+
+#ifdef _TD_ALPINE
+#include "osAlpine.h"
+#endif
+
+#ifdef _TD_WINDOWS_64
+#include "osWindows64.h"
+#endif
+
+#ifdef _TD_WINDOWS_32
+#include "osWindows32.h"
+#endif
+
+#include "osSpec.h"
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/os/inc/osAlpine.h

@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef TDENGINE_OS_LINUX64_H
+#define TDENGINE_OS_LINUX64_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <argp.h>
+#include <arpa/inet.h>
+#include <assert.h>
+#include <ctype.h>
+#include <dirent.h>
+#include <endian.h>
+#include <errno.h>
+#include <float.h>
+#include <ifaddrs.h>
+#include <libgen.h>
+#include <limits.h>
+#include <locale.h>
+#include <math.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <netinet/ip.h>
+#include <netinet/tcp.h>
+#include <netinet/udp.h>
+#include <pthread.h>
+#include <pwd.h>
+#include <regex.h>
+#include <semaphore.h>
+#include <signal.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+#include <strings.h>
+#include <sys/epoll.h>
+#include <sys/eventfd.h>
+#include <sys/file.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <sys/sendfile.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/syscall.h>
+#include <sys/statvfs.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/uio.h>
+#include <sys/un.h>
+#include <syslog.h>
+#include <termios.h>
+#include <unistd.h>
+#include <wchar.h>
+#include <wordexp.h>
+#include <wctype.h>
+#include <inttypes.h>
+#include <fcntl.h>
+#include <sys/utsname.h>
+#include <sys/resource.h>
+#include <linux/sysctl.h>
+
+typedef int(*__compar_fn_t)(const void *, const void *);
+void  error (int, int, const char *);
+#ifndef PTHREAD_MUTEX_RECURSIVE_NP
+  #define  PTHREAD_MUTEX_RECURSIVE_NP PTHREAD_MUTEX_RECURSIVE
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/os/inc/osDarwin64.h

@@ -0,0 +1,277 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef TDENGINE_PLATFORM_LINUX_H
+#define TDENGINE_PLATFORM_LINUX_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <arpa/inet.h>
+#include <assert.h>
+#include <ctype.h>
+#include <dirent.h>
+#include <errno.h>
+#include <float.h>
+#include <ifaddrs.h>
+#include <libgen.h>
+#include <limits.h>
+#include <locale.h>
+#include <math.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <netinet/ip.h>
+#include <netinet/tcp.h>
+#include <netinet/udp.h>
+#include <pthread.h>
+#include <pwd.h>
+#include <regex.h>
+#include <semaphore.h>
+#include <signal.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+#include <strings.h>
+#include <sys/file.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/syscall.h>
+#include <sys/statvfs.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/uio.h>
+#include <sys/un.h>
+#include <syslog.h>
+#include <termios.h>
+#include <unistd.h>
+#include <wchar.h>
+#include <wordexp.h>
+#include <wctype.h>
+#include <inttypes.h>
+#include <dispatch/dispatch.h>
+#include <fcntl.h>
+#include <sys/utsname.h>
+
+#define htobe64 htonll
+
+#define taosCloseSocket(x) \
+  {                        \
+    if (FD_VALID(x)) {     \
+      close(x);            \
+      x = FD_INITIALIZER;  \
+    }                      \
+  }
+  
+#define taosWriteSocket(fd, buf, len) write(fd, buf, len)
+#define taosReadSocket(fd, buf, len) read(fd, buf, len)
+
+#define atomic_load_8(ptr) __atomic_load_n((ptr), __ATOMIC_SEQ_CST)
+#define atomic_load_16(ptr) __atomic_load_n((ptr), __ATOMIC_SEQ_CST)
+#define atomic_load_32(ptr) __atomic_load_n((ptr), __ATOMIC_SEQ_CST)
+#define atomic_load_64(ptr) __atomic_load_n((ptr), __ATOMIC_SEQ_CST)
+#define atomic_load_ptr(ptr) __atomic_load_n((ptr), __ATOMIC_SEQ_CST)
+
+#define atomic_store_8(ptr, val) __atomic_store_n((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_store_16(ptr, val) __atomic_store_n((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_store_32(ptr, val) __atomic_store_n((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_store_64(ptr, val) __atomic_store_n((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_store_ptr(ptr, val) __atomic_store_n((ptr), (val), __ATOMIC_SEQ_CST)
+
+#define atomic_exchange_8(ptr, val) __atomic_exchange_n((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_exchange_16(ptr, val) __atomic_exchange_n((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_exchange_32(ptr, val) __atomic_exchange_n((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_exchange_64(ptr, val) __atomic_exchange_n((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_exchange_ptr(ptr, val) __atomic_exchange_n((ptr), (val), __ATOMIC_SEQ_CST)
+
+#define atomic_val_compare_exchange_8 __sync_val_compare_and_swap
+#define atomic_val_compare_exchange_16 __sync_val_compare_and_swap
+#define atomic_val_compare_exchange_32 __sync_val_compare_and_swap
+#define atomic_val_compare_exchange_64 __sync_val_compare_and_swap
+#define atomic_val_compare_exchange_ptr __sync_val_compare_and_swap
+
+#define atomic_add_fetch_8(ptr, val) __atomic_add_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_add_fetch_16(ptr, val) __atomic_add_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_add_fetch_32(ptr, val) __atomic_add_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_add_fetch_64(ptr, val) __atomic_add_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_add_fetch_ptr(ptr, val) __atomic_add_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+
+#define atomic_fetch_add_8(ptr, val) __atomic_fetch_add((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_fetch_add_16(ptr, val) __atomic_fetch_add((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_fetch_add_32(ptr, val) __atomic_fetch_add((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_fetch_add_64(ptr, val) __atomic_fetch_add((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_fetch_add_ptr(ptr, val) __atomic_fetch_add((ptr), (val), __ATOMIC_SEQ_CST)
+
+#define atomic_sub_fetch_8(ptr, val) __atomic_sub_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_sub_fetch_16(ptr, val) __atomic_sub_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_sub_fetch_32(ptr, val) __atomic_sub_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_sub_fetch_64(ptr, val) __atomic_sub_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_sub_fetch_ptr(ptr, val) __atomic_sub_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+
+#define atomic_fetch_sub_8(ptr, val) __atomic_fetch_sub((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_fetch_sub_16(ptr, val) __atomic_fetch_sub((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_fetch_sub_32(ptr, val) __atomic_fetch_sub((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_fetch_sub_64(ptr, val) __atomic_fetch_sub((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_fetch_sub_ptr(ptr, val) __atomic_fetch_sub((ptr), (val), __ATOMIC_SEQ_CST)
+
+#define atomic_and_fetch_8(ptr, val) __atomic_and_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_and_fetch_16(ptr, val) __atomic_and_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_and_fetch_32(ptr, val) __atomic_and_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_and_fetch_64(ptr, val) __atomic_and_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_and_fetch_ptr(ptr, val) __atomic_and_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+
+#define atomic_fetch_and_8(ptr, val) __atomic_fetch_and((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_fetch_and_16(ptr, val) __atomic_fetch_and((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_fetch_and_32(ptr, val) __atomic_fetch_and((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_fetch_and_64(ptr, val) __atomic_fetch_and((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_fetch_and_ptr(ptr, val) __atomic_fetch_and((ptr), (val), __ATOMIC_SEQ_CST)
+
+#define atomic_or_fetch_8(ptr, val) __atomic_or_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_or_fetch_16(ptr, val) __atomic_or_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_or_fetch_32(ptr, val) __atomic_or_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_or_fetch_64(ptr, val) __atomic_or_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_or_fetch_ptr(ptr, val) __atomic_or_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+
+#define atomic_fetch_or_8(ptr, val) __atomic_fetch_or((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_fetch_or_16(ptr, val) __atomic_fetch_or((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_fetch_or_32(ptr, val) __atomic_fetch_or((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_fetch_or_64(ptr, val) __atomic_fetch_or((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_fetch_or_ptr(ptr, val) __atomic_fetch_or((ptr), (val), __ATOMIC_SEQ_CST)
+
+#define atomic_xor_fetch_8(ptr, val) __atomic_xor_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_xor_fetch_16(ptr, val) __atomic_xor_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_xor_fetch_32(ptr, val) __atomic_xor_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_xor_fetch_64(ptr, val) __atomic_xor_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_xor_fetch_ptr(ptr, val) __atomic_xor_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+
+#define atomic_fetch_xor_8(ptr, val) __atomic_fetch_xor((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_fetch_xor_16(ptr, val) __atomic_fetch_xor((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_fetch_xor_32(ptr, val) __atomic_fetch_xor((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_fetch_xor_64(ptr, val) __atomic_fetch_xor((ptr), (val), __ATOMIC_SEQ_CST)
+#define atomic_fetch_xor_ptr(ptr, val) __atomic_fetch_xor((ptr), (val), __ATOMIC_SEQ_CST)
+
+#define SWAP(a, b, c)      \
+  do {                     \
+    typeof(a) __tmp = (a); \
+    (a) = (b);             \
+    (b) = __tmp;           \
+  } while (0)
+
+#define MAX(a, b)            \
+  ({                         \
+    typeof(a) __a = (a);     \
+    typeof(b) __b = (b);     \
+    (__a > __b) ? __a : __b; \
+  })
+
+#define MIN(a, b)            \
+  ({                         \
+    typeof(a) __a = (a);     \
+    typeof(b) __b = (b);     \
+    (__a < __b) ? __a : __b; \
+  })
+
+#define MILLISECOND_PER_SECOND ((int64_t)1000L)
+
+#define tsem_t dispatch_semaphore_t
+
+int tsem_init(dispatch_semaphore_t *sem, int pshared, unsigned int value);
+int tsem_wait(dispatch_semaphore_t *sem);
+int tsem_post(dispatch_semaphore_t *sem);
+int tsem_destroy(dispatch_semaphore_t *sem);
+
+void osInit();
+
+ssize_t tread(int fd, void *buf, size_t count);
+
+ssize_t twrite(int fd, void *buf, size_t n);
+
+char *taosCharsetReplace(char *charsetstr);
+
+bool taosCheckPthreadValid(pthread_t thread);
+
+void taosResetPthread(pthread_t *thread);
+
+int64_t taosGetPthreadId();
+
+int taosSetNonblocking(int sock, int on);
+
+int taosSetSockOpt(int socketfd, int level, int optname, void *optval, int optlen);
+
+void taosPrintOsInfo();
+
+char *taosCharsetReplace(char *charsetstr);
+
+void taosPrintOsInfo();
+
+void taosGetSystemInfo();
+
+void taosKillSystem();
+
+bool taosSkipSocketCheck();
+
+bool taosGetDisk();
+
+int fsendfile(FILE* out_file, FILE* in_file, int64_t* offset, int32_t count);
+
+void taosSetCoreDump();
+
+int tSystem(const char * cmd);
+
+typedef int(*__compar_fn_t)(const void *, const void *);
+
+// for send function in tsocket.c
+#define MSG_NOSIGNAL             0
+#define SO_NO_CHECK              0x1234
+#define SOL_TCP                  0x1234
+#define TCP_KEEPIDLE             0x1234
+
+#ifndef PTHREAD_MUTEX_RECURSIVE_NP
+  #define  PTHREAD_MUTEX_RECURSIVE_NP PTHREAD_MUTEX_RECURSIVE
+#endif
+
+#ifndef _TD_ARM_32_
+#define BUILDIN_CLZL(val) __builtin_clzl(val)
+#define BUILDIN_CTZL(val) __builtin_ctzl(val)
+#else
+#define BUILDIN_CLZL(val) __builtin_clzll(val)
+#define BUILDIN_CTZL(val) __builtin_ctzll(val)
+#endif
+#define BUILDIN_CLZ(val)  __builtin_clz(val)
+#define BUILDIN_CTZ(val)  __builtin_ctz(val)
+
+#undef threadlocal
+#ifdef _ISOC11_SOURCE
+  #define threadlocal _Thread_local
+#elif defined(__APPLE__)
+  #define threadlocal
+#elif defined(__GNUC__) && !defined(threadlocal)
+  #define threadlocal __thread
+#else
+  #define threadlocal
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/os/inc/osLinux32.h

@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef TDENGINE_OS_LINUX64_H
+#define TDENGINE_OS_LINUX64_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <argp.h>
+#include <arpa/inet.h>
+#include <assert.h>
+#include <ctype.h>
+#include <dirent.h>
+#include <endian.h>
+#include <errno.h>
+#include <float.h>
+#include <ifaddrs.h>
+#include <libgen.h>
+#include <limits.h>
+#include <locale.h>
+#include <math.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <netinet/ip.h>
+#include <netinet/tcp.h>
+#include <netinet/udp.h>
+#include <pthread.h>
+#include <pwd.h>
+#include <regex.h>
+#include <semaphore.h>
+#include <signal.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+#include <strings.h>
+#include <sys/epoll.h>
+#include <sys/eventfd.h>
+#include <sys/file.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <sys/sendfile.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/syscall.h>
+#include <sys/statvfs.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/uio.h>
+#include <sys/un.h>
+#include <syslog.h>
+#include <termios.h>
+#include <unistd.h>
+#include <wchar.h>
+#include <wordexp.h>
+#include <wctype.h>
+#include <inttypes.h>
+#include <fcntl.h>
+#include <sys/utsname.h>
+#include <sys/resource.h>
+#include <error.h>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/os/inc/osLinux64.h

@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef TDENGINE_OS_LINUX64_H
+#define TDENGINE_OS_LINUX64_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <argp.h>
+#include <arpa/inet.h>
+#include <assert.h>
+#include <ctype.h>
+#include <dirent.h>
+#include <endian.h>
+#include <errno.h>
+#include <float.h>
+#include <ifaddrs.h>
+#include <libgen.h>
+#include <limits.h>
+#include <locale.h>
+#include <math.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <netinet/ip.h>
+#include <netinet/tcp.h>
+#include <netinet/udp.h>
+#include <pthread.h>
+#include <pwd.h>
+#include <regex.h>
+#include <semaphore.h>
+#include <signal.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+#include <strings.h>
+#include <sys/epoll.h>
+#include <sys/eventfd.h>
+#include <sys/file.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <sys/sendfile.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/syscall.h>
+#include <sys/statvfs.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/uio.h>
+#include <sys/un.h>
+#include <syslog.h>
+#include <termios.h>
+#include <unistd.h>
+#include <wchar.h>
+#include <wordexp.h>
+#include <wctype.h>
+#include <inttypes.h>
+#include <fcntl.h>
+#include <sys/utsname.h>
+#include <sys/resource.h>
+#include <error.h>
+#include <linux/sysctl.h>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/os/inc/osSpec.h

@@ -0,0 +1,240 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef TDENGINE_OS_SPEC_H
+#define TDENGINE_OS_SPEC_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef TAOS_OS_FUNC_MATH
+  #define SWAP(a, b, c)        \
+    do {                       \
+        typeof(a) __tmp = (a); \
+        (a) = (b);             \
+        (b) = __tmp;           \
+    } while (0)
+
+  #define MAX(a, b)              \
+    ({                           \
+        typeof(a) __a = (a);     \
+        typeof(b) __b = (b);     \
+        (__a > __b) ? __a : __b; \
+    })
+
+  #define MIN(a, b)              \
+    ({                           \
+        typeof(a) __a = (a);     \
+        typeof(b) __b = (b);     \
+        (__a < __b) ? __a : __b; \
+    })
+#endif
+
+#ifndef TAOS_OS_DEF_TIME
+  #define MILLISECOND_PER_SECOND ((int64_t)1000L)
+#endif
+
+#ifndef TAOS_OS_FUNC_SEMPHONE
+  #define tsem_t sem_t
+  #define tsem_init sem_init
+  #define tsem_wait sem_wait
+  #define tsem_post sem_post
+  #define tsem_destroy sem_destroy
+#endif
+
+#ifndef TAOS_OS_FUNC_ATOMIC
+  #define atomic_load_8(ptr) __atomic_load_n((ptr), __ATOMIC_SEQ_CST)
+  #define atomic_load_16(ptr) __atomic_load_n((ptr), __ATOMIC_SEQ_CST)
+  #define atomic_load_32(ptr) __atomic_load_n((ptr), __ATOMIC_SEQ_CST)
+  #define atomic_load_64(ptr) __atomic_load_n((ptr), __ATOMIC_SEQ_CST)
+  #define atomic_load_ptr(ptr) __atomic_load_n((ptr), __ATOMIC_SEQ_CST)
+
+  #define atomic_store_8(ptr, val) __atomic_store_n((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_store_16(ptr, val) __atomic_store_n((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_store_32(ptr, val) __atomic_store_n((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_store_64(ptr, val) __atomic_store_n((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_store_ptr(ptr, val) __atomic_store_n((ptr), (val), __ATOMIC_SEQ_CST)
+
+  #define atomic_exchange_8(ptr, val) __atomic_exchange_n((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_exchange_16(ptr, val) __atomic_exchange_n((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_exchange_32(ptr, val) __atomic_exchange_n((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_exchange_64(ptr, val) __atomic_exchange_n((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_exchange_ptr(ptr, val) __atomic_exchange_n((ptr), (val), __ATOMIC_SEQ_CST)
+
+  #define atomic_val_compare_exchange_8 __sync_val_compare_and_swap
+  #define atomic_val_compare_exchange_16 __sync_val_compare_and_swap
+  #define atomic_val_compare_exchange_32 __sync_val_compare_and_swap
+  #define atomic_val_compare_exchange_64 __sync_val_compare_and_swap
+  #define atomic_val_compare_exchange_ptr __sync_val_compare_and_swap
+
+  #define atomic_add_fetch_8(ptr, val) __atomic_add_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_add_fetch_16(ptr, val) __atomic_add_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_add_fetch_32(ptr, val) __atomic_add_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_add_fetch_64(ptr, val) __atomic_add_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_add_fetch_ptr(ptr, val) __atomic_add_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+
+  #define atomic_fetch_add_8(ptr, val) __atomic_fetch_add((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_fetch_add_16(ptr, val) __atomic_fetch_add((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_fetch_add_32(ptr, val) __atomic_fetch_add((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_fetch_add_64(ptr, val) __atomic_fetch_add((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_fetch_add_ptr(ptr, val) __atomic_fetch_add((ptr), (val), __ATOMIC_SEQ_CST)
+
+  #define atomic_sub_fetch_8(ptr, val) __atomic_sub_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_sub_fetch_16(ptr, val) __atomic_sub_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_sub_fetch_32(ptr, val) __atomic_sub_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_sub_fetch_64(ptr, val) __atomic_sub_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_sub_fetch_ptr(ptr, val) __atomic_sub_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+
+  #define atomic_fetch_sub_8(ptr, val) __atomic_fetch_sub((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_fetch_sub_16(ptr, val) __atomic_fetch_sub((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_fetch_sub_32(ptr, val) __atomic_fetch_sub((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_fetch_sub_64(ptr, val) __atomic_fetch_sub((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_fetch_sub_ptr(ptr, val) __atomic_fetch_sub((ptr), (val), __ATOMIC_SEQ_CST)
+
+  #define atomic_and_fetch_8(ptr, val) __atomic_and_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_and_fetch_16(ptr, val) __atomic_and_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_and_fetch_32(ptr, val) __atomic_and_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_and_fetch_64(ptr, val) __atomic_and_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_and_fetch_ptr(ptr, val) __atomic_and_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+
+  #define atomic_fetch_and_8(ptr, val) __atomic_fetch_and((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_fetch_and_16(ptr, val) __atomic_fetch_and((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_fetch_and_32(ptr, val) __atomic_fetch_and((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_fetch_and_64(ptr, val) __atomic_fetch_and((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_fetch_and_ptr(ptr, val) __atomic_fetch_and((ptr), (val), __ATOMIC_SEQ_CST)
+
+  #define atomic_or_fetch_8(ptr, val) __atomic_or_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_or_fetch_16(ptr, val) __atomic_or_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_or_fetch_32(ptr, val) __atomic_or_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_or_fetch_64(ptr, val) __atomic_or_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_or_fetch_ptr(ptr, val) __atomic_or_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+
+  #define atomic_fetch_or_8(ptr, val) __atomic_fetch_or((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_fetch_or_16(ptr, val) __atomic_fetch_or((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_fetch_or_32(ptr, val) __atomic_fetch_or((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_fetch_or_64(ptr, val) __atomic_fetch_or((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_fetch_or_ptr(ptr, val) __atomic_fetch_or((ptr), (val), __ATOMIC_SEQ_CST)
+
+  #define atomic_xor_fetch_8(ptr, val) __atomic_xor_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_xor_fetch_16(ptr, val) __atomic_xor_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_xor_fetch_32(ptr, val) __atomic_xor_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_xor_fetch_64(ptr, val) __atomic_xor_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_xor_fetch_ptr(ptr, val) __atomic_xor_fetch((ptr), (val), __ATOMIC_SEQ_CST)
+
+  #define atomic_fetch_xor_8(ptr, val) __atomic_fetch_xor((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_fetch_xor_16(ptr, val) __atomic_fetch_xor((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_fetch_xor_32(ptr, val) __atomic_fetch_xor((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_fetch_xor_64(ptr, val) __atomic_fetch_xor((ptr), (val), __ATOMIC_SEQ_CST)
+  #define atomic_fetch_xor_ptr(ptr, val) __atomic_fetch_xor((ptr), (val), __ATOMIC_SEQ_CST)
+#endif
+
+ssize_t taosTReadImp(int fd, void *buf, size_t count);
+ssize_t taosTWriteImp(int fd, void *buf, size_t count);
+ssize_t taosTSendFileImp(int dfd, int sfd, off_t *offset, size_t size);
+#ifndef TAOS_OS_FUNC_FILE
+  #define taosTRead(fd, buf, count) taosTReadImp(fd, buf, count)
+  #define taosTWrite(fd, buf, count) taosTWriteImp(fd, buf, count)
+  #define taosLSeek(fd, offset, whence) lseek(fd, offset, whence)
+  #define taosTSendFile(dfd, sfd, offset, size) taosTSendFileImp(dfd, sfd, offset, size)
+#endif
+
+#ifdef TAOS_RANDOM_FILE_FAIL
+  void taosSetRandomFileFailFactor(int factor);
+  void taosSetRandomFileFailOutput(const char *path);
+  ssize_t taosReadFileRandomFail(int fd, void *buf, size_t count, const char *file, uint32_t line);
+  ssize_t taosWriteFileRandomFail(int fd, void *buf, size_t count, const char *file, uint32_t line);
+  off_t taosLSeekRandomFail(int fd, off_t offset, int whence, const char *file, uint32_t line);
+  #define taosTRead(fd, buf, count) taosReadFileRandomFail(fd, buf, count, __FILE__, __LINE__)
+  #define taosTWrite(fd, buf, count) taosWriteFileRandomFail(fd, buf, count, __FILE__, __LINE__)
+  #define taosLSeek(fd, offset, whence) taosLSeekRandomFail(fd, offset, whence, __FILE__, __LINE__)
+#endif
+
+#ifndef TAOS_OS_FUNC_NETWORK
+  #define taosSend(sockfd, buf, len, flags) send(sockfd, buf, len, flags)
+  #define taosSendto(sockfd, buf, len, flags, dest_addr, addrlen) sendto(sockfd, buf, len, flags, dest_addr, addrlen)
+  #define taosReadSocket(fd, buf, len) read(fd, buf, len)
+  #define taosWriteSocket(fd, buf, len) write(fd, buf, len)
+  #define taosCloseSocket(x) \
+    {                        \
+      if (FD_VALID(x)) {     \
+        close(x);            \
+        x = FD_INITIALIZER;  \
+      }                      \
+    }
+#endif
+
+#ifdef TAOS_RANDOM_NETWORK_FAIL
+  ssize_t taosSendRandomFail(int sockfd, const void *buf, size_t len, int flags);
+  ssize_t taosSendToRandomFail(int sockfd, const void *buf, size_t len, int flags, const struct sockaddr *dest_addr, socklen_t addrlen);
+  ssize_t taosReadSocketRandomFail(int fd, void *buf, size_t count);
+  ssize_t taosWriteSocketRandomFail(int fd, const void *buf, size_t count);
+  #define taosSend(sockfd, buf, len, flags) taosSendRandomFail(sockfd, buf, len, flags)
+  #define taosSendto(sockfd, buf, len, flags, dest_addr, addrlen) taosSendToRandomFail(sockfd, buf, len, flags, dest_addr, addrlen)
+  #define taosReadSocket(fd, buf, len) taosReadSocketRandomFail(fd, buf, len)
+  #define taosWriteSocket(fd, buf, len) taosWriteSocketRandomFail(fd, buf, len)
+#endif
+
+#ifndef TAOS_OS_FUNC_LZ4
+  #define BUILDIN_CLZL(val) __builtin_clzl(val)
+  #define BUILDIN_CTZL(val) __builtin_ctzl(val)
+  #define BUILDIN_CLZ(val) __builtin_clz(val)
+  #define BUILDIN_CTZ(val) __builtin_ctz(val)
+#endif
+
+#undef threadlocal
+#ifdef _ISOC11_SOURCE
+  #define threadlocal _Thread_local
+#elif defined(__APPLE__)
+  #define threadlocal
+#elif defined(__GNUC__) && !defined(threadlocal)
+  #define threadlocal __thread
+#else
+  #define threadlocal
+#endif
+
+void osInit();
+
+// TAOS_OS_FUNC_PTHREAD
+bool taosCheckPthreadValid(pthread_t thread);
+int64_t taosGetPthreadId();
+
+// TAOS_OS_FUNC_SOCKET
+int taosSetNonblocking(int sock, int on);
+int taosSetSockOpt(int socketfd, int level, int optname, void *optval, int optlen);
+void taosBlockSIGPIPE();
+
+// TAOS_OS_FUNC_SYSINFO
+void taosGetSystemInfo();
+void taosPrintOsInfo();
+void taosKillSystem();
+int tSystem(const char * cmd) ;
+
+// TAOS_OS_FUNC_CORE
+void taosSetCoreDump();
+
+// TAOS_OS_FUNC_UTIL
+int64_t tsosStr2int64(char *str);
+
+// TAOS_OS_FUNC_TIMER
+void taosMsleep(int mseconds);
+int taosInitTimer(void (*callback)(int), int ms);
+void taosUninitTimer();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/os/inc/osWindows32.h

@@ -0,0 +1,54 @@
+/*
+* Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+*
+* This program is free software: you can use, redistribute, and/or modify
+* it under the terms of the GNU Affero General Public License, version 3
+* or later ("AGPL"), as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but WITHOUT
+* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+* FITNESS FOR A PARTICULAR PURPOSE.
+*
+* You should have received a copy of the GNU Affero General Public License
+* along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef TDENGINE_PLATFORM_WINDOWS32_H
+#define TDENGINE_PLATFORM_WINDOWS32_H
+
+#include <assert.h>
+#include <ctype.h>
+#include <direct.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <float.h>
+#include <locale.h>
+#include <intrin.h>
+#include <io.h>
+#include <math.h>
+#include <pthread.h>
+#include <semaphore.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <signal.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <time.h>
+#include <inttypes.h>
+#include "winsock2.h"
+#include <WS2tcpip.h>
+#include <winbase.h>
+#include <Winsock2.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif

src/os/inc/osWindows64.h

@@ -0,0 +1,423 @@
+/*
+* Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+*
+* This program is free software: you can use, redistribute, and/or modify
+* it under the terms of the GNU Affero General Public License, version 3
+* or later ("AGPL"), as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but WITHOUT
+* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+* FITNESS FOR A PARTICULAR PURPOSE.
+*
+* You should have received a copy of the GNU Affero General Public License
+* along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef TDENGINE_PLATFORM_WINDOWS_H
+#define TDENGINE_PLATFORM_WINDOWS_H
+
+#include <assert.h>
+#include <ctype.h>
+#include <direct.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <float.h>
+#include <locale.h>
+#include <intrin.h>
+#include <io.h>
+#include <math.h>
+#include <pthread.h>
+#include <semaphore.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <signal.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <time.h>
+#include <inttypes.h>
+#include "winsock2.h"
+#include <WS2tcpip.h>
+#include <winbase.h>
+#include <Winsock2.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// for function open in stat.h 
+#define S_IRWXU                  _S_IREAD
+#define S_IRWXG                  _S_IWRITE
+#define S_IRWXO                  _S_IWRITE
+
+// for access function in io.h
+#define F_OK 00  //Existence only
+#define W_OK 02  //Write - only
+#define R_OK 04  //Read - only
+#define X_OK 06  //Read and write
+
+// for send function in tsocket.c
+#define MSG_NOSIGNAL             0
+#define SO_NO_CHECK              0x1234
+#define SOL_TCP                  0x1234
+#define TCP_KEEPCNT              0x1234
+#define TCP_KEEPIDLE             0x1234
+#define TCP_KEEPINTVL            0x1234
+
+#define LOCK_EX 1
+#define LOCK_NB 2
+#define LOCK_UN 3
+
+#define bzero(ptr, size) memset((ptr), 0, (size))
+#define mkdir(pathname, mode) _mkdir(pathname)
+#define strcasecmp  _stricmp
+#define strncasecmp _strnicmp
+#define wcsncasecmp _wcsnicmp
+#define strtok_r strtok_s
+#ifdef _TD_GO_DLL_
+  int64_t tsosStr2int64(char *str);
+  uint64_t htonll(uint64_t val);
+#else
+  #define tsosStr2int64 _atoi64
+#endif
+
+#define snprintf _snprintf
+#define in_addr_t unsigned long
+#define socklen_t int
+#define htobe64 htonll
+#define twrite write
+
+#ifndef PATH_MAX
+  #define PATH_MAX 256
+#endif
+
+#define taosCloseSocket(fd) closesocket(fd)
+#define taosWriteSocket(fd, buf, len) send(fd, buf, len, 0)
+#define taosReadSocket(fd, buf, len) recv(fd, buf, len, 0)
+
+#if defined(_M_ARM) || defined(_M_ARM64)
+
+/* the '__iso_volatile' functions does not use a memory fence, so these
+ * definitions are incorrect, comment out as we don't support Windows on
+ * ARM at present.
+
+#define atomic_load_8(ptr) __iso_volatile_load8((const volatile __int8*)(ptr))
+#define atomic_load_16(ptr) __iso_volatile_load16((const volatile __int16*)(ptr))
+#define atomic_load_32(ptr) __iso_volatile_load32((const volatile __int32*)(ptr))
+#define atomic_load_64(ptr) __iso_volatile_load64((const volatile __int64*)(ptr))
+
+#define atomic_store_8(ptr, val) __iso_volatile_store8((volatile __int8*)(ptr), (__int8)(val))
+#define atomic_store_16(ptr, val) __iso_volatile_store16((volatile __int16*)(ptr), (__int16)(val))
+#define atomic_store_32(ptr, val) __iso_volatile_store32((volatile __int32*)(ptr), (__int32)(val))
+#define atomic_store_64(ptr, val) __iso_volatile_store64((volatile __int64*)(ptr), (__int64)(val))
+
+#ifdef _M_ARM64
+#define atomic_load_ptr atomic_load_64
+#define atomic_store_ptr atomic_store_64
+#else
+#define atomic_load_ptr atomic_load_32
+#define atomic_store_ptr atomic_store_32
+#endif
+*/
+#else
+
+#define atomic_load_8(ptr) (*(char volatile*)(ptr))
+#define atomic_load_16(ptr) (*(short volatile*)(ptr))
+#define atomic_load_32(ptr) (*(long volatile*)(ptr))
+#define atomic_load_64(ptr) (*(__int64 volatile*)(ptr))
+#define atomic_load_ptr(ptr) (*(void* volatile*)(ptr))
+
+#define atomic_store_8(ptr, val) ((*(char volatile*)(ptr)) = (char)(val))
+#define atomic_store_16(ptr, val) ((*(short volatile*)(ptr)) = (short)(val))
+#define atomic_store_32(ptr, val) ((*(long volatile*)(ptr)) = (long)(val))
+#define atomic_store_64(ptr, val) ((*(__int64 volatile*)(ptr)) = (__int64)(val))
+#define atomic_store_ptr(ptr, val) ((*(void* volatile*)(ptr)) = (void*)(val))
+
+#endif
+
+#define atomic_exchange_8(ptr, val) _InterlockedExchange8((char volatile*)(ptr), (char)(val))
+#define atomic_exchange_16(ptr, val) _InterlockedExchange16((short volatile*)(ptr), (short)(val))
+#define atomic_exchange_32(ptr, val) _InterlockedExchange((long volatile*)(ptr), (long)(val))
+#define atomic_exchange_64(ptr, val) _InterlockedExchange64((__int64 volatile*)(ptr), (__int64)(val))
+#define atomic_exchange_ptr(ptr, val) _InterlockedExchangePointer((void* volatile*)(ptr), (void*)(val))
+
+#ifdef _TD_GO_DLL_
+  #define atomic_val_compare_exchange_8 __sync_val_compare_and_swap
+#else
+  #define atomic_val_compare_exchange_8(ptr, oldval, newval) _InterlockedCompareExchange8((char volatile*)(ptr), (char)(newval), (char)(oldval))
+#endif
+
+#define atomic_val_compare_exchange_16(ptr, oldval, newval) _InterlockedCompareExchange16((short volatile*)(ptr), (short)(newval), (short)(oldval))
+#define atomic_val_compare_exchange_32(ptr, oldval, newval) _InterlockedCompareExchange((long volatile*)(ptr), (long)(newval), (long)(oldval))
+#define atomic_val_compare_exchange_64(ptr, oldval, newval) _InterlockedCompareExchange64((__int64 volatile*)(ptr), (__int64)(newval), (__int64)(oldval))
+#define atomic_val_compare_exchange_ptr(ptr, oldval, newval) _InterlockedCompareExchangePointer((void* volatile*)(ptr), (void*)(newval), (void*)(oldval))
+
+char    interlocked_add_fetch_8(char volatile *ptr, char val);
+short   interlocked_add_fetch_16(short volatile *ptr, short val);
+long    interlocked_add_fetch_32(long volatile *ptr, long val);
+__int64 interlocked_add_fetch_64(__int64 volatile *ptr, __int64 val);
+
+#define atomic_add_fetch_8(ptr, val) interlocked_add_fetch_8((char volatile*)(ptr), (char)(val))
+#define atomic_add_fetch_16(ptr, val) interlocked_add_fetch_16((short volatile*)(ptr), (short)(val))
+#define atomic_add_fetch_32(ptr, val) interlocked_add_fetch_32((long volatile*)(ptr), (long)(val))
+#define atomic_add_fetch_64(ptr, val) interlocked_add_fetch_64((__int64 volatile*)(ptr), (__int64)(val))
+#ifdef _WIN64
+  #define atomic_add_fetch_ptr atomic_add_fetch_64
+#else
+  #define atomic_add_fetch_ptr atomic_add_fetch_32
+#endif
+#ifdef _TD_GO_DLL_
+  #define atomic_fetch_add_8 __sync_fetch_and_ad
+  #define atomic_fetch_add_16 __sync_fetch_and_add
+#else
+  #define atomic_fetch_add_8(ptr, val) _InterlockedExchangeAdd8((char volatile*)(ptr), (char)(val))
+  #define atomic_fetch_add_16(ptr, val) _InterlockedExchangeAdd16((short volatile*)(ptr), (short)(val))
+#endif
+
+#define atomic_fetch_add_32(ptr, val) _InterlockedExchangeAdd((long volatile*)(ptr), (long)(val))
+#define atomic_fetch_add_64(ptr, val) _InterlockedExchangeAdd64((__int64 volatile*)(ptr), (__int64)(val))
+#ifdef _WIN64
+  #define atomic_fetch_add_ptr atomic_fetch_add_64
+#else
+  #define atomic_fetch_add_ptr atomic_fetch_add_32
+#endif
+
+#define atomic_sub_fetch_8(ptr, val) interlocked_add_fetch_8((char volatile*)(ptr), -(char)(val))
+#define atomic_sub_fetch_16(ptr, val) interlocked_add_fetch_16((short volatile*)(ptr), -(short)(val))
+#define atomic_sub_fetch_32(ptr, val) interlocked_add_fetch_32((long volatile*)(ptr), -(long)(val))
+#define atomic_sub_fetch_64(ptr, val) interlocked_add_fetch_64((__int64 volatile*)(ptr), -(__int64)(val))
+#ifdef _WIN64
+  #define atomic_sub_fetch_ptr atomic_sub_fetch_64
+#else
+  #define atomic_sub_fetch_ptr atomic_sub_fetch_32
+#endif
+
+#define atomic_fetch_sub_8(ptr, val) _InterlockedExchangeAdd8((char volatile*)(ptr), -(char)(val))
+#define atomic_fetch_sub_16(ptr, val) _InterlockedExchangeAdd16((short volatile*)(ptr), -(short)(val))
+#define atomic_fetch_sub_32(ptr, val) _InterlockedExchangeAdd((long volatile*)(ptr), -(long)(val))
+#define atomic_fetch_sub_64(ptr, val) _InterlockedExchangeAdd64((__int64 volatile*)(ptr), -(__int64)(val))
+#ifdef _WIN64
+  #define atomic_fetch_sub_ptr atomic_fetch_sub_64
+#else
+  #define atomic_fetch_sub_ptr atomic_fetch_sub_32
+#endif
+#ifndef _TD_GO_DLL_
+ char interlocked_and_fetch_8(char volatile* ptr, char val);
+ short interlocked_and_fetch_16(short volatile* ptr, short val);
+#endif
+long interlocked_and_fetch_32(long volatile* ptr, long val);
+__int64 interlocked_and_fetch_64(__int64 volatile* ptr, __int64 val);
+
+#ifndef _TD_GO_DLL_
+  #define atomic_and_fetch_8(ptr, val) interlocked_and_fetch_8((char volatile*)(ptr), (char)(val))
+  #define atomic_and_fetch_16(ptr, val) interlocked_and_fetch_16((short volatile*)(ptr), (short)(val))
+#endif
+#define atomic_and_fetch_32(ptr, val) interlocked_and_fetch_32((long volatile*)(ptr), (long)(val))
+#define atomic_and_fetch_64(ptr, val) interlocked_and_fetch_64((__int64 volatile*)(ptr), (__int64)(val))
+#ifdef _WIN64
+  #define atomic_and_fetch_ptr atomic_and_fetch_64
+#else
+  #define atomic_and_fetch_ptr atomic_and_fetch_32
+#endif
+#ifndef _TD_GO_DLL_
+  #define atomic_fetch_and_8(ptr, val) _InterlockedAnd8((char volatile*)(ptr), (char)(val))
+  #define atomic_fetch_and_16(ptr, val) _InterlockedAnd16((short volatile*)(ptr), (short)(val))
+#endif
+#define atomic_fetch_and_32(ptr, val) _InterlockedAnd((long volatile*)(ptr), (long)(val))
+
+#ifdef _M_IX86
+  __int64 interlocked_fetch_and_64(__int64 volatile* ptr, __int64 val);
+  #define atomic_fetch_and_64(ptr, val) interlocked_fetch_and_64((__int64 volatile*)(ptr), (__int64)(val))
+#else
+  #define atomic_fetch_and_64(ptr, val) _InterlockedAnd64((__int64 volatile*)(ptr), (__int64)(val))
+#endif
+
+#ifdef _WIN64
+  #define atomic_fetch_and_ptr atomic_fetch_and_64
+#else
+  #define atomic_fetch_and_ptr atomic_fetch_and_32
+#endif
+#ifndef _TD_GO_DLL_
+  char interlocked_or_fetch_8(char volatile* ptr, char val);
+  short interlocked_or_fetch_16(short volatile* ptr, short val);
+#endif
+long interlocked_or_fetch_32(long volatile* ptr, long val);
+__int64 interlocked_or_fetch_64(__int64 volatile* ptr, __int64 val);
+
+#ifndef _TD_GO_DLL_
+  #define atomic_or_fetch_8(ptr, val) interlocked_or_fetch_8((char volatile*)(ptr), (char)(val))
+  #define atomic_or_fetch_16(ptr, val) interlocked_or_fetch_16((short volatile*)(ptr), (short)(val))
+#endif
+#define atomic_or_fetch_32(ptr, val) interlocked_or_fetch_32((long volatile*)(ptr), (long)(val))
+#define atomic_or_fetch_64(ptr, val) interlocked_or_fetch_64((__int64 volatile*)(ptr), (__int64)(val))
+#ifdef _WIN64
+  #define atomic_or_fetch_ptr atomic_or_fetch_64
+#else
+  #define atomic_or_fetch_ptr atomic_or_fetch_32
+#endif
+#ifndef _TD_GO_DLL_
+  #define atomic_fetch_or_8(ptr, val) _InterlockedOr8((char volatile*)(ptr), (char)(val))
+  #define atomic_fetch_or_16(ptr, val) _InterlockedOr16((short volatile*)(ptr), (short)(val))
+#endif
+#define atomic_fetch_or_32(ptr, val) _InterlockedOr((long volatile*)(ptr), (long)(val))
+
+#ifdef _M_IX86
+  __int64 interlocked_fetch_or_64(__int64 volatile* ptr, __int64 val);
+  #define atomic_fetch_or_64(ptr, val) interlocked_fetch_or_64((__int64 volatile*)(ptr), (__int64)(val))
+#else
+  #define atomic_fetch_or_64(ptr, val) _InterlockedOr64((__int64 volatile*)(ptr), (__int64)(val))
+#endif
+
+#ifdef _WIN64
+  #define atomic_fetch_or_ptr atomic_fetch_or_64
+#else
+  #define atomic_fetch_or_ptr atomic_fetch_or_32
+#endif
+
+#ifndef _TD_GO_DLL_
+  char interlocked_xor_fetch_8(char volatile* ptr, char val);
+  short interlocked_xor_fetch_16(short volatile* ptr, short val);
+#endif
+long interlocked_xor_fetch_32(long volatile* ptr, long val);
+__int64 interlocked_xor_fetch_64(__int64 volatile* ptr, __int64 val);
+
+#ifndef _TD_GO_DLL_
+  #define atomic_xor_fetch_8(ptr, val) interlocked_xor_fetch_8((char volatile*)(ptr), (char)(val))
+  #define atomic_xor_fetch_16(ptr, val) interlocked_xor_fetch_16((short volatile*)(ptr), (short)(val))
+#endif
+#define atomic_xor_fetch_32(ptr, val) interlocked_xor_fetch_32((long volatile*)(ptr), (long)(val))
+#define atomic_xor_fetch_64(ptr, val) interlocked_xor_fetch_64((__int64 volatile*)(ptr), (__int64)(val))
+#ifdef _WIN64
+  #define atomic_xor_fetch_ptr atomic_xor_fetch_64
+#else
+  #define atomic_xor_fetch_ptr atomic_xor_fetch_32
+#endif
+
+#ifndef _TD_GO_DLL_
+  #define atomic_fetch_xor_8(ptr, val) _InterlockedXor8((char volatile*)(ptr), (char)(val))
+  #define atomic_fetch_xor_16(ptr, val) _InterlockedXor16((short volatile*)(ptr), (short)(val))
+#endif
+#define atomic_fetch_xor_32(ptr, val) _InterlockedXor((long volatile*)(ptr), (long)(val))
+
+#ifdef _M_IX86
+  __int64 interlocked_fetch_xor_64(__int64 volatile* ptr, __int64 val);
+  #define atomic_fetch_xor_64(ptr, val) interlocked_fetch_xor_64((__int64 volatile*)(ptr), (__int64)(val))
+#else
+  #define atomic_fetch_xor_64(ptr, val) _InterlockedXor64((__int64 volatile*)(ptr), (__int64)(val))
+#endif
+
+#ifdef _WIN64
+  #define atomic_fetch_xor_ptr atomic_fetch_xor_64
+#else
+  #define atomic_fetch_xor_ptr atomic_fetch_xor_32
+#endif
+
+#define SWAP(a, b, c)      \
+  do {                     \
+    c __tmp = (c)(a);      \
+    (a) = (c)(b);          \
+    (b) = __tmp;           \
+  } while (0)
+
+#define MAX(a,b)  (((a)>(b))?(a):(b))
+#define MIN(a,b)  (((a)<(b))?(a):(b))
+
+#ifdef _TD_GO_DLL_
+  #define MILLISECOND_PER_SECOND (1000LL)
+#else
+  #define MILLISECOND_PER_SECOND (1000i64)
+#endif
+
+#define tsem_t sem_t
+#define tsem_init sem_init
+#define tsem_wait sem_wait
+#define tsem_post sem_post
+#define tsem_destroy sem_destroy
+
+void osInit();
+
+int getline(char **lineptr, size_t *n, FILE *stream);
+
+int taosWinSetTimer(int ms, void(*callback)(int));
+
+int gettimeofday(struct timeval *tv, struct timezone *tz);
+
+struct tm *localtime_r(const time_t *timep, struct tm *result);
+
+char *strptime(const char *buf, const char *fmt, struct tm *tm);
+
+bool taosCheckPthreadValid(pthread_t thread);
+
+void taosResetPthread(pthread_t *thread);
+
+int64_t taosGetPthreadId();
+
+int taosSetNonblocking(int sock, int on);
+
+int taosSetSockOpt(int socketfd, int level, int optname, void *optval, int optlen);
+
+char *taosCharsetReplace(char *charsetstr);
+
+void taosPrintOsInfo();
+
+void taosGetSystemInfo();
+
+void taosKillSystem();
+
+int32_t BUILDIN_CLZL(uint64_t val);
+int32_t BUILDIN_CLZ(uint32_t val);
+int32_t BUILDIN_CTZL(uint64_t val);
+int32_t BUILDIN_CTZ(uint32_t val);
+
+//for signal, not dispose
+#define SIGALRM 1234
+typedef int sigset_t;
+
+struct sigaction {
+  void (*sa_handler)(int);
+};
+
+typedef struct {
+  int we_wordc;
+  char **we_wordv;
+  int we_offs;
+  char wordPos[20];
+} wordexp_t;
+
+int wordexp(const char *words, wordexp_t *pwordexp, int flags);
+
+void wordfree(wordexp_t *pwordexp);
+
+int flock(int fd, int option);
+
+int fsync(int filedes);
+
+char *getpass(const char *prefix);
+
+char *strsep(char **stringp, const char *delim);
+
+typedef int(*__compar_fn_t)(const void *, const void *);
+
+int sigaction(int, struct sigaction *, void *);
+
+void sleep(int mseconds);
+
+bool taosSkipSocketCheck();
+
+int fsendfile(FILE* out_file, FILE* in_file, int64_t* offset, int32_t count);
+
+#define ssize_t int
+
+#define strdup _strdup
+
+char *strndup(const char *s, size_t n);
+
+void taosSetCoreDump();
+
+#ifdef __cplusplus
+}
+#endif
+#endif

src/os/src/alpine/CMakeLists.txt

@@ -0,0 +1,12 @@
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+PROJECT(TDengine)
+
+INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/inc)
+INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/os/inc)
+INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/util/inc)
+INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/common/inc)
+AUX_SOURCE_DIRECTORY(. SRC)
+
+ADD_LIBRARY(os ${SRC})
+TARGET_LINK_LIBRARIES(os m rt)
+

src/os/src/alpine/alpineEnv.c

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "tglobal.h"
+#include "tulog.h"
+
+void osInit() {
+  strcpy(configDir, "/etc/taos");
+  strcpy(tsVnodeDir, "");
+  strcpy(tsDnodeDir, "");
+  strcpy(tsMnodeDir, "");
+  strcpy(tsDataDir, "/var/lib/taos");
+  strcpy(tsLogDir, "/var/log/taos");
+  strcpy(tsScriptDir, "/etc/taos");
+  strcpy(tsOsName, "Linux");
+}

src/os/src/darwin64/CMakeLists.txt

@@ -0,0 +1,13 @@
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+PROJECT(TDengine)
+
+IF (TD_DARWIN_64)
+  INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/inc)
+  INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/os/inc)
+  INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/util/inc)
+  INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/common/inc)
+  INCLUDE_DIRECTORIES(inc)
+  AUX_SOURCE_DIRECTORY(src SRC)
+  ADD_LIBRARY(os ${SRC})
+ENDIF ()
+

src/os/src/darwin64/darwinEnv.c

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "tglobal.h"
+#include "tulog.h"
+
+void osInit() {
+  strcpy(configDir, "/etc/taos");
+  strcpy(tsVnodeDir, "");
+  strcpy(tsDnodeDir, "");
+  strcpy(tsMnodeDir, "");
+  strcpy(tsDataDir, "/var/lib/taos");
+  strcpy(tsLogDir, "~/TDengineLog");
+  strcpy(tsScriptDir, "/etc/taos");
+  strcpy(tsOsName, "Darwin");
+}

src/os/src/darwin64/darwinPlatform.c

@@ -0,0 +1,370 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "os.h"
+#include "taosdef.h"
+#include "tglobal.h"
+#include "tconfig.h"
+#include "ttimer.h"
+#include "tulog.h"
+#include "tutil.h"
+
+int64_t tsosStr2int64(char *str) {
+  char *endptr = NULL;
+  return strtoll(str, &endptr, 10);
+}
+
+/*
+  to make taosMsleep work,
+   signal SIGALRM shall be blocked in the calling thread,
+
+  sigset_t set;
+  sigemptyset(&set);
+  sigaddset(&set, SIGALRM);
+  pthread_sigmask(SIG_BLOCK, &set, NULL);
+*/
+void taosMsleep(int mseconds) {
+  struct timeval timeout;
+  int            seconds, useconds;
+
+  seconds = mseconds / 1000;
+  useconds = (mseconds % 1000) * 1000;
+  timeout.tv_sec = seconds;
+  timeout.tv_usec = useconds;
+
+  /* sigset_t set; */
+  /* sigemptyset(&set); */
+  /* sigaddset(&set, SIGALRM); */
+  /* pthread_sigmask(SIG_BLOCK, &set, NULL); */
+
+  select(0, NULL, NULL, NULL, &timeout);
+
+  /* pthread_sigmask(SIG_UNBLOCK, &set, NULL); */
+}
+
+bool taosCheckPthreadValid(pthread_t thread) { return thread != 0; }
+
+void taosResetPthread(pthread_t *thread) { *thread = 0; }
+
+int64_t taosGetPthreadId() { return (int64_t)pthread_self(); }
+
+/*
+* Function to get the private ip address of current machine. If get IP
+* successfully, return 0, else, return -1. The return values is ip.
+*
+* Use:
+* if (taosGetPrivateIp(ip) != 0) {
+*     perror("Fail to get private IP address\n");
+*     exit(EXIT_FAILURE);
+* }
+*/
+int taosGetPrivateIp(char *const ip) {
+  bool hasLoCard = false;
+
+  struct ifaddrs *ifaddr, *ifa;
+  int             family, s;
+  char            host[NI_MAXHOST];
+
+  if (getifaddrs(&ifaddr) == -1) {
+    return -1;
+  }
+
+  /* Walk through linked list, maintaining head pointer so we can free list later */
+  int flag = 0;
+  for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) {
+    if (ifa->ifa_addr == NULL) continue;
+
+    family = ifa->ifa_addr->sa_family;
+    if (strcmp("lo", ifa->ifa_name) == 0) {
+      hasLoCard = true;
+      continue;
+    }
+
+    if (family == AF_INET) {
+      /* printf("%-8s", ifa->ifa_name); */
+      s = getnameinfo(ifa->ifa_addr, (family == AF_INET) ? sizeof(struct sockaddr_in) : sizeof(struct sockaddr_in6),
+                      host, NI_MAXHOST, NULL, 0, NI_NUMERICHOST);
+      if (s != 0) {
+        freeifaddrs(ifaddr);
+        return -1;
+      }
+
+      strcpy(ip, host);
+      flag = 1;
+      break;
+    }
+  }
+
+  freeifaddrs(ifaddr);
+  if (flag) {
+    return 0;
+  } else {
+    if (hasLoCard) {
+      uInfo("no net card was found, use lo:127.0.0.1 as default");
+      strcpy(ip, "127.0.0.1");
+      return 0;
+    }
+    return -1;
+  }
+}
+
+int taosSetNonblocking(int sock, int on) {
+  int flags = 0;
+  if ((flags = fcntl(sock, F_GETFL, 0)) < 0) {
+    uError("fcntl(F_GETFL) error: %d (%s)\n", errno, strerror(errno));
+    return 1;
+  }
+
+  if (on)
+    flags |= O_NONBLOCK;
+  else
+    flags &= ~O_NONBLOCK;
+
+  if ((flags = fcntl(sock, F_SETFL, flags)) < 0) {
+    uError("fcntl(F_SETFL) error: %d (%s)\n", errno, strerror(errno));
+    return 1;
+  }
+
+  return 0;
+}
+
+int taosSetSockOpt(int socketfd, int level, int optname, void *optval, int optlen) {
+  if (level == SOL_SOCKET && optname == SO_SNDBUF) {
+    return 0;
+  }
+
+  if (level == SOL_SOCKET && optname == SO_RCVBUF) {
+    return 0;
+  }
+
+  return setsockopt(socketfd, level, optname, optval, (socklen_t)optlen);
+}
+
+int taosInitTimer(void (*callback)(int), int ms) {
+  signal(SIGALRM, callback);
+
+  struct itimerval tv;
+  tv.it_interval.tv_sec = 0;  /* my timer resolution */
+  tv.it_interval.tv_usec = 1000 * ms;  // resolution is in msecond
+  tv.it_value = tv.it_interval;
+
+  setitimer(ITIMER_REAL, &tv, NULL);
+
+  return 0;
+}
+
+void taosUninitTimer() {
+  struct itimerval tv = { 0 };
+  setitimer(ITIMER_REAL, &tv, NULL);
+}
+
+void taosGetSystemTimezone() {
+  // get and set default timezone
+  SGlobalCfg *cfg_timezone = taosGetConfigOption("timezone");
+  if (cfg_timezone && cfg_timezone->cfgStatus < TAOS_CFG_CSTATUS_DEFAULT) {
+    char *tz = getenv("TZ");
+    if (tz == NULL || strlen(tz) == 0) {
+      strcpy(tsTimezone, "not configured");
+    }
+    else {
+      strcpy(tsTimezone, tz);
+    }
+    cfg_timezone->cfgStatus = TAOS_CFG_CSTATUS_DEFAULT;
+    uInfo("timezone not configured, use default");
+  }
+}
+
+void taosGetSystemLocale() {
+  // get and set default locale
+  SGlobalCfg *cfg_locale = taosGetConfigOption("locale");
+  if (cfg_locale && cfg_locale->cfgStatus < TAOS_CFG_CSTATUS_DEFAULT) {
+    char *locale = setlocale(LC_CTYPE, "chs");
+    if (locale != NULL) {
+      tstrncpy(tsLocale, locale, sizeof(tsLocale));
+      cfg_locale->cfgStatus = TAOS_CFG_CSTATUS_DEFAULT;
+      uInfo("locale not configured, set to default:%s", tsLocale);
+    }
+  }
+
+  SGlobalCfg *cfg_charset = taosGetConfigOption("charset");
+  if (cfg_charset && cfg_charset->cfgStatus < TAOS_CFG_CSTATUS_DEFAULT) {
+    strcpy(tsCharset, "cp936");
+    cfg_charset->cfgStatus = TAOS_CFG_CSTATUS_DEFAULT;
+    uInfo("charset not configured, set to default:%s", tsCharset);
+  }
+}
+
+
+void taosPrintOsInfo() {}
+
+void taosKillSystem() {
+  uError("function taosKillSystem, exit!");
+  exit(0);
+}
+
+bool taosGetDisk() {
+  return true;
+}
+
+void taosGetSystemInfo() {
+  taosGetSystemTimezone();
+  taosGetSystemLocale();
+}
+
+void *taosInitTcpClient(char *ip, uint16_t port, char *flabel, int num, void *fp, void *shandle) {
+  uError("function taosInitTcpClient is not implemented in darwin system, exit!");
+  exit(0);
+}
+
+void taosCloseTcpClientConnection(void *chandle) {
+  uError("function taosCloseTcpClientConnection is not implemented in darwin system, exit!");
+  exit(0);
+}
+
+void *taosOpenTcpClientConnection(void *shandle, void *thandle, char *ip, uint16_t port) {
+  uError("function taosOpenTcpClientConnection is not implemented in darwin system, exit!");
+  exit(0);
+}
+
+int taosSendTcpClientData(unsigned int ip, uint16_t port, char *data, int len, void *chandle) {
+  uError("function taosSendTcpClientData is not implemented in darwin system, exit!");
+  exit(0);
+}
+
+void taosCleanUpTcpClient(void *chandle) {
+  uError("function taosCleanUpTcpClient is not implemented in darwin system, exit!");
+  exit(0);
+}
+
+void taosCloseTcpServerConnection(void *chandle) {
+  uError("function taosCloseTcpServerConnection is not implemented in darwin system, exit!");
+  exit(0);
+}
+
+void taosCleanUpTcpServer(void *handle) {
+  uError("function taosCleanUpTcpServer is not implemented in darwin system, exit!");
+  exit(0);
+}
+
+void *taosInitTcpServer(char *ip, uint16_t port, char *label, int numOfThreads, void *fp, void *shandle) {
+  uError("function taosInitTcpServer is not implemented in darwin system, exit!");
+  exit(0);
+}
+
+int taosSendTcpServerData(unsigned int ip, uint16_t port, char *data, int len, void *chandle) {
+  uError("function taosSendTcpServerData is not implemented in darwin system, exit!");
+  exit(0);
+}
+
+void taosFreeMsgHdr(void *hdr) {
+  uError("function taosFreeMsgHdr is not implemented in darwin system, exit!");
+  exit(0);
+}
+
+int taosMsgHdrSize(void *hdr) {
+  uError("function taosMsgHdrSize is not implemented in darwin system, exit!");
+  exit(0);
+}
+
+void taosSendMsgHdr(void *hdr, int fd) {
+  uError("function taosSendMsgHdr is not implemented in darwin system, exit!");
+  exit(0);
+}
+
+void taosInitMsgHdr(void **hdr, void *dest, int maxPkts) {
+  uError("function taosInitMsgHdr is not implemented in darwin system, exit!");
+  exit(0);
+}
+
+void taosSetMsgHdrData(void *hdr, char *data, int dataLen) {
+  uError("function taosSetMsgHdrData is not implemented in darwin system, exit!");
+  exit(0);
+}
+
+bool taosSkipSocketCheck() {
+  return true;
+}
+
+int tsem_init(dispatch_semaphore_t *sem, int pshared, unsigned int value) {
+  *sem = dispatch_semaphore_create(value);
+  if (*sem == NULL) {
+    return -1;
+  } else {
+    return 0;
+  }
+}
+
+int tsem_wait(dispatch_semaphore_t *sem) {
+  dispatch_semaphore_wait(*sem, DISPATCH_TIME_FOREVER);
+  return 0;
+}
+
+int tsem_post(dispatch_semaphore_t *sem) {
+  dispatch_semaphore_signal(*sem);
+  return 0;
+}
+
+int tsem_destroy(dispatch_semaphore_t *sem) {
+  return 0;
+}
+
+int32_t __sync_val_load_32(int32_t *ptr) {
+  return __atomic_load_n(ptr, __ATOMIC_ACQUIRE);
+}
+
+void __sync_val_restore_32(int32_t *ptr, int32_t newval) {
+  __atomic_store_n(ptr, newval, __ATOMIC_RELEASE);
+}
+
+#define _SEND_FILE_STEP_ 1000
+
+int fsendfile(FILE* out_file, FILE* in_file, int64_t* offset, int32_t count) {
+  fseek(in_file, (int32_t)(*offset), 0);
+  int writeLen = 0;
+  uint8_t buffer[_SEND_FILE_STEP_] = { 0 };
+
+  for (int len = 0; len < (count - _SEND_FILE_STEP_); len += _SEND_FILE_STEP_) {
+    size_t rlen = fread(buffer, 1, _SEND_FILE_STEP_, in_file);
+    if (rlen <= 0) {
+      return writeLen;
+    }
+    else if (rlen < _SEND_FILE_STEP_) {
+      fwrite(buffer, 1, rlen, out_file);
+      return (int)(writeLen + rlen);
+    }
+    else {
+      fwrite(buffer, 1, _SEND_FILE_STEP_, in_file);
+      writeLen += _SEND_FILE_STEP_;
+    }
+  }
+
+  int remain = count - writeLen;
+  if (remain > 0) {
+    size_t rlen = fread(buffer, 1, remain, in_file);
+    if (rlen <= 0) {
+      return writeLen;
+    }
+    else {
+      fwrite(buffer, 1, remain, out_file);
+      writeLen += remain;
+    }
+  }
+
+  return writeLen;
+}
+
+void taosSetCoreDump() {}

src/os/src/detail/CMakeLists.txt

@@ -0,0 +1,14 @@
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+PROJECT(TDengine)
+
+INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/inc)
+INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/os/inc)
+INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/util/inc)
+INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/common/inc)
+INCLUDE_DIRECTORIES(.)
+AUX_SOURCE_DIRECTORY(. SRC)
+SET_SOURCE_FILES_PROPERTIES(osSysinfo.c PROPERTIES COMPILE_FLAGS -w)
+SET_SOURCE_FILES_PROPERTIES(osCoredump.c PROPERTIES COMPILE_FLAGS -w)
+
+ADD_LIBRARY(osdetail ${SRC})
+TARGET_LINK_LIBRARIES(osdetail os)

src/os/src/detail/osCoredump.c

@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "tconfig.h"
+#include "tglobal.h"
+#include "tulog.h"
+#include "tutil.h"
+#include "tsystem.h"
+
+#ifndef TAOS_OS_FUNC_CORE
+
+int _sysctl(struct __sysctl_args *args );
+
+void taosSetCoreDump() {
+  if (0 == tsEnableCoreFile) {
+    return;
+  }
+  
+  // 1. set ulimit -c unlimited
+  struct rlimit rlim;
+  struct rlimit rlim_new;
+  if (getrlimit(RLIMIT_CORE, &rlim) == 0) {
+    uInfo("the old unlimited para: rlim_cur=%" PRIu64 ", rlim_max=%" PRIu64, 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) {
+      uInfo("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) {
+    uInfo("the new unlimited para: rlim_cur=%" PRIu64 ", rlim_max=%" PRIu64, rlim.rlim_cur, rlim.rlim_max);
+  }
+
+#ifndef _TD_ARM_
+  // 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) {
+      uInfo("_sysctl(kern_core_uses_pid) set fail: %s", strerror(errno));
+  }
+  
+  uInfo("The old core_uses_pid[%" PRIu64 "]: %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) {
+      uInfo("_sysctl(kern_core_uses_pid) get fail: %s", strerror(errno));
+  }
+  
+  uInfo("The new core_uses_pid[%" PRIu64 "]: %d", old_len, old_usespid);
+#endif
+
+}
+
+#endif

src/os/src/detail/osFail.c

@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+
+#define RANDOM_NETWORK_FAIL_FACTOR  20
+
+#ifdef TAOS_RANDOM_NETWORK_FAIL
+
+ssize_t taosSendRandomFail(int sockfd, const void *buf, size_t len, int flags) {
+  if (rand() % RANDOM_NETWORK_FAIL_FACTOR == 0) {
+    errno = ECONNRESET;
+    return -1;
+  }
+
+  return send(sockfd, buf, len, flags);
+}
+
+ssize_t taosSendToRandomFail(int sockfd, const void *buf, size_t len, int flags, const struct sockaddr *dest_addr,
+                           socklen_t addrlen) {
+  if (rand() % RANDOM_NETWORK_FAIL_FACTOR == 0) {
+    errno = ECONNRESET;
+    return -1;
+  }
+
+  return sendto(sockfd, buf, len, flags, dest_addr, addrlen);
+}
+
+ssize_t taosReadSocketRandomFail(int fd, void *buf, size_t count) {
+  if (rand() % RANDOM_NETWORK_FAIL_FACTOR == 0) {
+    errno = ECONNRESET;
+    return -1;
+  }
+
+  return read(fd, buf, count);
+}
+
+ssize_t taosWriteSocketRandomFail(int fd, const void *buf, size_t count) {
+  if (rand() % RANDOM_NETWORK_FAIL_FACTOR == 0) {
+    errno = EINTR;
+    return -1;
+  }
+
+  return write(fd, buf, count);
+}
+
+#endif //TAOS_RANDOM_NETWORK_FAIL
+
+#ifdef TAOS_RANDOM_FILE_FAIL
+
+static int random_file_fail_factor = 20;
+static FILE *fpRandomFileFailOutput = NULL;
+
+void taosSetRandomFileFailFactor(int factor) { 
+  random_file_fail_factor = factor;
+}
+
+static void close_random_file_fail_output() {
+  if (fpRandomFileFailOutput != NULL) {
+    if (fpRandomFileFailOutput != stdout) {
+      fclose(fpRandomFileFailOutput);
+    }
+    fpRandomFileFailOutput = NULL;
+  }
+}
+
+static void random_file_fail_output_sig(int sig) {
+  fprintf(fpRandomFileFailOutput, "signal %d received.\n", sig);
+
+  struct sigaction act = {0};
+  act.sa_handler = SIG_DFL;
+  sigaction(sig, &act, NULL);
+
+  close_random_file_fail_output();
+  exit(EXIT_FAILURE);
+}
+
+void taosSetRandomFileFailOutput(const char *path) {
+  if (path == NULL) {
+    fpRandomFileFailOutput = stdout;
+  } else if ((fpRandomFileFailOutput = fopen(path, "w")) != NULL) {
+    atexit(close_random_file_fail_output);
+  } else {
+    printf("failed to open random file fail log file '%s', errno=%d\n", path, errno);
+    return;
+  }
+
+  struct sigaction act = {0};
+  act.sa_handler = random_file_fail_output_sig;
+  sigaction(SIGFPE, &act, NULL);
+  sigaction(SIGSEGV, &act, NULL);
+  sigaction(SIGILL, &act, NULL);
+}
+
+ssize_t taosReadFileRandomFail(int fd, void *buf, size_t count, const char *file, uint32_t line) {
+  if (random_file_fail_factor > 0) {
+    if (rand() % random_file_fail_factor == 0) {
+      errno = EIO;
+      return -1;
+    }
+  }
+
+  return taosTReadImp(fd, buf, count);
+}
+
+ssize_t taosWriteFileRandomFail(int fd, void *buf, size_t count, const char *file, uint32_t line) {
+  if (random_file_fail_factor > 0) {
+    if (rand() % random_file_fail_factor == 0) {
+      errno = EIO;
+      return -1;
+    }
+  }
+
+  return taosTWriteImp(fd, buf, count);
+}
+
+off_t taosLSeekRandomFail(int fd, off_t offset, int whence, const char *file, uint32_t line) {
+  if (random_file_fail_factor > 0) {
+    if (rand() % random_file_fail_factor == 0) {
+      errno = EIO;
+      return -1;
+    }
+  }
+
+  return lseek(fd, offset, whence);
+}
+
+#endif //TAOS_RANDOM_FILE_FAIL

src/os/src/detail/osFile.c

@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+
+ssize_t taosTReadImp(int fd, void *buf, size_t count) {
+  size_t  leftbytes = count;
+  ssize_t readbytes;
+  char *  tbuf = (char *)buf;
+
+  while (leftbytes > 0) {
+    readbytes = read(fd, (void *)tbuf, leftbytes);
+    if (readbytes < 0) {
+      if (errno == EINTR) {
+        continue;
+      } else {
+        return -1;
+      }
+    } else if (readbytes == 0) {
+      return (ssize_t)(count - leftbytes);
+    }
+
+    leftbytes -= readbytes;
+    tbuf += readbytes;
+  }
+
+  return (ssize_t)count;
+}
+
+ssize_t taosTSendFileImp(int dfd, int sfd, off_t *offset, size_t size) {
+  size_t  leftbytes = size;
+  ssize_t sentbytes;
+
+  while (leftbytes > 0) {
+    /*
+     * TODO : Think to check if file is larger than 1GB
+     */
+    //if (leftbytes > 1000000000) leftbytes = 1000000000;
+    sentbytes = sendfile(dfd, sfd, offset, leftbytes);
+    if (sentbytes == -1) {
+      if (errno == EINTR) {
+        continue;
+      }
+      else {
+        return -1;
+      }
+    } else if (sentbytes == 0) {
+      return (ssize_t)(size - leftbytes);
+    }
+
+    leftbytes -= sentbytes;
+  }
+
+  return size;
+}
+
+ssize_t taosTWriteImp(int fd, void *buf, size_t n) {
+  size_t nleft = n; 
+  ssize_t nwritten = 0;
+  char *tbuf = (char *)buf;
+
+  while (nleft > 0) {
+    nwritten = write(fd, (void *)tbuf, nleft);
+    if (nwritten < 0) {
+      if (errno == EINTR) {
+        continue;
+      }
+      return -1;
+    }
+    nleft -= nwritten;
+    tbuf += nwritten;
+  }
+
+  return n;
+}

src/os/src/detail/osPThread.c

@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+
+#ifndef TAOS_OS_FUNC_PTHREAD
+
+bool    taosCheckPthreadValid(pthread_t thread) { return thread != 0; }
+int64_t taosGetPthreadId() { return (int64_t)pthread_self(); }
+
+#endif

src/os/src/detail/osSocket.c

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "tulog.h"
+
+#ifndef TAOS_OS_FUNC_SOCKET
+
+int taosSetNonblocking(int sock, int on) {
+  int flags = 0;
+  if ((flags = fcntl(sock, F_GETFL, 0)) < 0) {
+    uError("fcntl(F_GETFL) error: %d (%s)\n", errno, strerror(errno));
+    return 1;
+  }
+
+  if (on)
+    flags |= O_NONBLOCK;
+  else
+    flags &= ~O_NONBLOCK;
+
+  if ((flags = fcntl(sock, F_SETFL, flags)) < 0) {
+    uError("fcntl(F_SETFL) error: %d (%s)\n", errno, strerror(errno));
+    return 1;
+  }
+
+  return 0;
+}
+
+int taosSetSockOpt(int socketfd, int level, int optname, void *optval, int optlen) {
+  return setsockopt(socketfd, level, optname, optval, (socklen_t)optlen);
+}
+
+void taosBlockSIGPIPE() {
+  sigset_t signal_mask;
+  sigemptyset(&signal_mask);
+  sigaddset(&signal_mask, SIGPIPE);
+  int rc = pthread_sigmask(SIG_BLOCK, &signal_mask, NULL);
+  if (rc != 0) {
+    uError("failed to block SIGPIPE");
+  }
+}
+
+#endif

src/os/src/detail/osSysinfo.c

@@ -0,0 +1,573 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "tconfig.h"
+#include "tglobal.h"
+#include "tulog.h"
+#include "tutil.h"
+#include "tsystem.h"
+
+#ifndef TAOS_OS_FUNC_SYSINFO
+
+#define PROCESS_ITEM 12
+
+typedef struct {
+  uint64_t user;
+  uint64_t nice;
+  uint64_t system;
+  uint64_t idle;
+} SysCpuInfo;
+
+typedef struct {
+  uint64_t utime;   // user time
+  uint64_t stime;   // kernel time
+  uint64_t cutime;  // all user time
+  uint64_t cstime;  // all dead time
+} ProcCpuInfo;
+
+static pid_t tsProcId;
+static char  tsSysNetFile[] = "/proc/net/dev";
+static char  tsSysCpuFile[] = "/proc/stat";
+static char  tsProcCpuFile[25] = {0};
+static char  tsProcMemFile[25] = {0};
+static char  tsProcIOFile[25] = {0};
+static float tsPageSizeKB = 0;
+
+bool taosGetSysMemory(float *memoryUsedMB) {
+  float memoryAvailMB = (float)sysconf(_SC_AVPHYS_PAGES) * tsPageSizeKB / 1024;
+  *memoryUsedMB = (float)tsTotalMemoryMB - memoryAvailMB;
+  return true;
+}
+
+bool taosGetProcMemory(float *memoryUsedMB) {
+  FILE *fp = fopen(tsProcMemFile, "r");
+  if (fp == NULL) {
+    uError("open file:%s failed", tsProcMemFile);
+    return false;
+  }
+
+  size_t len;
+  char * line = NULL;
+  while (!feof(fp)) {
+    tfree(line);
+    len = 0;
+    getline(&line, &len, fp);
+    if (line == NULL) {
+      break;
+    }
+    if (strstr(line, "VmRSS:") != NULL) {
+      break;
+    }
+  }
+
+  if (line == NULL) {
+    uError("read file:%s failed", tsProcMemFile);
+    fclose(fp);
+    return false;
+  }
+
+  int64_t memKB = 0;
+  char    tmp[10];
+  sscanf(line, "%s %" PRId64, tmp, &memKB);
+  *memoryUsedMB = (float)((double)memKB / 1024);
+
+  tfree(line);
+  fclose(fp);
+  return true;
+}
+
+static bool taosGetSysCpuInfo(SysCpuInfo *cpuInfo) {
+  FILE *fp = fopen(tsSysCpuFile, "r");
+  if (fp == NULL) {
+    uError("open file:%s failed", tsSysCpuFile);
+    return false;
+  }
+
+  size_t len;
+  char * line = NULL;
+  getline(&line, &len, fp);
+  if (line == NULL) {
+    uError("read file:%s failed", tsSysCpuFile);
+    fclose(fp);
+    return false;
+  }
+
+  char cpu[10] = {0};
+  sscanf(line, "%s %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64, cpu, &cpuInfo->user, &cpuInfo->nice, &cpuInfo->system, &cpuInfo->idle);
+
+  tfree(line);
+  fclose(fp);
+  return true;
+}
+
+static bool taosGetProcCpuInfo(ProcCpuInfo *cpuInfo) {
+  FILE *fp = fopen(tsProcCpuFile, "r");
+  if (fp == NULL) {
+    uError("open file:%s failed", tsProcCpuFile);
+    return false;
+  }
+
+  size_t len = 0;
+  char * line = NULL;
+  getline(&line, &len, fp);
+  if (line == NULL) {
+    uError("read file:%s failed", tsProcCpuFile);
+    fclose(fp);
+    return false;
+  }
+
+  for (int i = 0, blank = 0; line[i] != 0; ++i) {
+    if (line[i] == ' ') blank++;
+    if (blank == PROCESS_ITEM) {
+      sscanf(line + i + 1, "%" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64, &cpuInfo->utime, &cpuInfo->stime, &cpuInfo->cutime, &cpuInfo->cstime);
+      break;
+    }
+  }
+
+  tfree(line);
+  fclose(fp);
+  return true;
+}
+
+static void taosGetSystemTimezone() {
+  SGlobalCfg *cfg_timezone = taosGetConfigOption("timezone");
+  if (cfg_timezone == NULL) return;
+  if (cfg_timezone->cfgStatus >= TAOS_CFG_CSTATUS_DEFAULT) {
+    return;
+  }
+
+  /*
+   * NOTE: do not remove it.
+   * Enforce set the correct daylight saving time(DST) flag according
+   * to current time
+   */
+  time_t    tx1 = time(NULL);
+  struct tm tm1;
+  localtime_r(&tx1, &tm1);
+
+  /* load time zone string from /etc/timezone */
+  FILE *f = fopen("/etc/timezone", "r");
+  char  buf[68] = {0};
+  if (f != NULL) {
+    int len = fread(buf, 64, 1, f);
+    if(len < 64 && ferror(f)) {
+      fclose(f);
+      uError("read /etc/timezone error, reason:%s", strerror(errno));
+      return;
+    }
+    
+    fclose(f);
+
+    char *lineEnd = strstr(buf, "\n");
+    if (lineEnd != NULL) {
+      *lineEnd = 0;
+    }
+
+    // for CentOS system, /etc/timezone does not exist. Ignore the TZ environment variables
+    if (strlen(buf) > 0) {
+      setenv("TZ", buf, 1);
+    }
+  }
+  // get and set default timezone
+  tzset();
+
+  /*
+   * get CURRENT time zone.
+   * system current time zone is affected by daylight saving time(DST)
+   *
+   * e.g., the local time zone of London in DST is GMT+01:00,
+   * otherwise is GMT+00:00
+   */
+  int32_t tz = (-timezone * MILLISECOND_PER_SECOND) / MILLISECOND_PER_HOUR;
+  tz += daylight;
+
+  /*
+   * format example:
+   *
+   * Asia/Shanghai   (CST, +0800)
+   * Europe/London   (BST, +0100)
+   */
+  snprintf(tsTimezone, TSDB_TIMEZONE_LEN, "%s (%s, %s%02d00)", buf, tzname[daylight], tz >= 0 ? "+" : "-", abs(tz));
+
+  // cfg_timezone->cfgStatus = TAOS_CFG_CSTATUS_DEFAULT;
+  uInfo("timezone not configured, set to system default:%s", tsTimezone);
+}
+
+/*
+ * POSIX format locale string:
+ * (Language Strings)_(Country/Region Strings).(code_page)
+ *
+ * example: en_US.UTF-8, zh_CN.GB18030, zh_CN.UTF-8,
+ *
+ * if user does not specify the locale in taos.cfg the program use default LC_CTYPE as system locale.
+ *
+ * In case of some CentOS systems, their default locale is "en_US.utf8", which is not valid code_page
+ * for libiconv that is employed to convert string in this system. This program will automatically use
+ * UTF-8 instead as the charset.
+ *
+ * In case of windows client, the locale string is not valid POSIX format, user needs to set the
+ * correct code_page for libiconv. Usually, the code_page of windows system with simple chinese is
+ * CP936, CP437 for English charset.
+ *
+ */
+static void taosGetSystemLocale() {  // get and set default locale
+  char  sep = '.';
+  char *locale = NULL;
+
+  SGlobalCfg *cfg_locale = taosGetConfigOption("locale");
+  if (cfg_locale && cfg_locale->cfgStatus < TAOS_CFG_CSTATUS_DEFAULT) {
+    locale = setlocale(LC_CTYPE, "");
+    if (locale == NULL) {
+      uError("can't get locale from system, set it to en_US.UTF-8");
+      strcpy(tsLocale, "en_US.UTF-8");
+    } else {
+      tstrncpy(tsLocale, locale, TSDB_LOCALE_LEN);
+      uError("locale not configured, set to system default:%s", tsLocale);
+    }
+  }
+
+  /* if user does not specify the charset, extract it from locale */
+  SGlobalCfg *cfg_charset = taosGetConfigOption("charset");
+  if (cfg_charset && cfg_charset->cfgStatus < TAOS_CFG_CSTATUS_DEFAULT) {
+    char *str = strrchr(tsLocale, sep);
+    if (str != NULL) {
+      str++;
+
+      char *revisedCharset = taosCharsetReplace(str);
+      tstrncpy(tsCharset, revisedCharset, TSDB_LOCALE_LEN);
+
+      free(revisedCharset);
+      uWarn("charset not configured, set to system default:%s", tsCharset);
+    } else {
+      strcpy(tsCharset, "UTF-8");
+      uWarn("can't get locale and charset from system, set it to UTF-8");
+    }
+  }
+}
+
+bool taosGetCpuUsage(float *sysCpuUsage, float *procCpuUsage) {
+  static uint64_t lastSysUsed = 0;
+  static uint64_t lastSysTotal = 0;
+  static uint64_t lastProcTotal = 0;
+
+  SysCpuInfo  sysCpu;
+  ProcCpuInfo procCpu;
+  if (!taosGetSysCpuInfo(&sysCpu)) {
+    return false;
+  }
+  if (!taosGetProcCpuInfo(&procCpu)) {
+    return false;
+  }
+
+  uint64_t curSysUsed = sysCpu.user + sysCpu.nice + sysCpu.system;
+  uint64_t curSysTotal = curSysUsed + sysCpu.idle;
+  uint64_t curProcTotal = procCpu.utime + procCpu.stime + procCpu.cutime + procCpu.cstime;
+
+  if (lastSysUsed == 0 || lastSysTotal == 0 || lastProcTotal == 0) {
+    lastSysUsed = curSysUsed > 1 ? curSysUsed : 1;
+    lastSysTotal = curSysTotal > 1 ? curSysTotal : 1;
+    lastProcTotal = curProcTotal > 1 ? curProcTotal : 1;
+    return false;
+  }
+
+  if (curSysTotal == lastSysTotal) {
+    return false;
+  }
+
+  *sysCpuUsage = (float)((double)(curSysUsed - lastSysUsed) / (double)(curSysTotal - lastSysTotal) * 100);
+  *procCpuUsage = (float)((double)(curProcTotal - lastProcTotal) / (double)(curSysTotal - lastSysTotal) * 100);
+
+  lastSysUsed = curSysUsed;
+  lastSysTotal = curSysTotal;
+  lastProcTotal = curProcTotal;
+
+  return true;
+}
+
+bool taosGetDisk() {
+  struct statvfs info;
+  const double   unit = 1024 * 1024 * 1024;
+  
+  if (tscEmbedded) {
+    if (statvfs(tsDataDir, &info)) {
+      //tsTotalDataDirGB = 0;
+      //tsAvailDataDirGB = 0;
+      uError("failed to get disk size, dataDir:%s errno:%s", tsDataDir, strerror(errno));
+      return false;
+    } else {
+      tsTotalDataDirGB = (float)((double)info.f_blocks * (double)info.f_frsize / unit);
+      tsAvailDataDirGB = (float)((double)info.f_bavail * (double)info.f_frsize / unit);
+    }
+  }
+
+  if (statvfs(tsLogDir, &info)) {
+    //tsTotalLogDirGB = 0;
+    //tsAvailLogDirGB = 0;
+    uError("failed to get disk size, logDir:%s errno:%s", tsLogDir, strerror(errno));
+    return false;
+  } else {
+    tsTotalLogDirGB = (float)((double)info.f_blocks * (double)info.f_frsize / unit);
+    tsAvailLogDirGB = (float)((double)info.f_bavail * (double)info.f_frsize / unit);
+  }
+
+  if (statvfs("/tmp", &info)) {
+    //tsTotalTmpDirGB = 0;
+    //tsAvailTmpDirectorySpace = 0;
+    uError("failed to get disk size, tmpDir:/tmp errno:%s", strerror(errno));
+    return false;
+  } else {
+    tsTotalTmpDirGB = (float)((double)info.f_blocks * (double)info.f_frsize / unit);
+    tsAvailTmpDirectorySpace = (float)((double)info.f_bavail * (double)info.f_frsize / unit);
+  }
+
+  return true;
+}
+
+static bool taosGetCardInfo(int64_t *bytes) {
+  *bytes = 0;
+  FILE *fp = fopen(tsSysNetFile, "r");
+  if (fp == NULL) {
+    uError("open file:%s failed", tsSysNetFile);
+    return false;
+  }
+
+
+  size_t len = 2048;
+  char * line = calloc(1, len);
+
+  while (!feof(fp)) {
+    memset(line, 0, len);
+    
+    int64_t rbytes = 0;
+    int64_t rpackts = 0;
+    int64_t tbytes = 0;
+    int64_t tpackets = 0;
+    int64_t nouse1 = 0;
+    int64_t nouse2 = 0;
+    int64_t nouse3 = 0;
+    int64_t nouse4 = 0;
+    int64_t nouse5 = 0;
+    int64_t nouse6 = 0;
+    char    nouse0[200] = {0};
+
+    getline(&line, &len, fp);
+    line[len - 1] = 0;
+
+    if (strstr(line, "lo:") != NULL) {
+      continue;
+    }
+
+    sscanf(line,
+           "%s %" PRId64 " %" PRId64 " %" PRId64 " %" PRId64 " %" PRId64 " %" PRId64 " %" PRId64 " %" PRId64 " %" PRId64
+           " %" PRId64,
+           nouse0, &rbytes, &rpackts, &nouse1, &nouse2, &nouse3, &nouse4, &nouse5, &nouse6, &tbytes, &tpackets);
+    *bytes += (rbytes + tbytes);
+  }
+
+  tfree(line);
+  fclose(fp);
+
+  return true;
+}
+
+bool taosGetBandSpeed(float *bandSpeedKb) {
+  static int64_t lastBytes = 0;
+  static time_t  lastTime = 0;
+  int64_t        curBytes = 0;
+  time_t         curTime = time(NULL);
+
+  if (!taosGetCardInfo(&curBytes)) {
+    return false;
+  }
+
+  if (lastTime == 0 || lastBytes == 0) {
+    lastTime = curTime;
+    lastBytes = curBytes;
+    *bandSpeedKb = 0;
+    return true;
+  }
+
+  if (lastTime >= curTime || lastBytes > curBytes) {
+    lastTime = curTime;
+    lastBytes = curBytes;
+    *bandSpeedKb = 0;
+    return true;
+  }
+
+  double totalBytes = (double)(curBytes - lastBytes) / 1024 * 8;  // Kb
+  *bandSpeedKb = (float)(totalBytes / (double)(curTime - lastTime));
+
+  // uInfo("bandwidth lastBytes:%ld, lastTime:%ld, curBytes:%ld, curTime:%ld,
+  // speed:%f", lastBytes, lastTime, curBytes, curTime, *bandSpeed);
+
+  lastTime = curTime;
+  lastBytes = curBytes;
+
+  return true;
+}
+
+static bool taosReadProcIO(int64_t *readbyte, int64_t *writebyte) {
+  FILE *fp = fopen(tsProcIOFile, "r");
+  if (fp == NULL) {
+    uError("open file:%s failed", tsProcIOFile);
+    return false;
+  }
+
+  size_t len;
+  char * line = NULL;
+  char   tmp[10];
+  int    readIndex = 0;
+
+  while (!feof(fp)) {
+    tfree(line);
+    len = 0;
+    getline(&line, &len, fp);
+    if (line == NULL) {
+      break;
+    }
+    if (strstr(line, "rchar:") != NULL) {
+      sscanf(line, "%s %" PRId64, tmp, readbyte);
+      readIndex++;
+    } else if (strstr(line, "wchar:") != NULL) {
+      sscanf(line, "%s %" PRId64, tmp, writebyte);
+      readIndex++;
+    } else {
+    }
+
+    if (readIndex >= 2) break;
+  }
+
+  tfree(line);
+  fclose(fp);
+
+  if (readIndex < 2) {
+    uError("read file:%s failed", tsProcIOFile);
+    return false;
+  }
+
+  return true;
+}
+
+bool taosGetProcIO(float *readKB, float *writeKB) {
+  static int64_t lastReadbyte = -1;
+  static int64_t lastWritebyte = -1;
+
+  int64_t curReadbyte  = 0;
+  int64_t curWritebyte = 0;
+
+  if (!taosReadProcIO(&curReadbyte, &curWritebyte)) {
+    return false;
+  }
+
+  if (lastReadbyte == -1 || lastWritebyte == -1) {
+    lastReadbyte = curReadbyte;
+    lastWritebyte = curWritebyte;
+    return false;
+  }
+
+  *readKB = (float)((double)(curReadbyte - lastReadbyte) / 1024);
+  *writeKB = (float)((double)(curWritebyte - lastWritebyte) / 1024);
+  if (*readKB < 0) *readKB = 0;
+  if (*writeKB < 0) *writeKB = 0;
+
+  lastReadbyte = curReadbyte;
+  lastWritebyte = curWritebyte;
+
+  return true;
+}
+
+void taosGetSystemInfo() {
+  tsNumOfCores = (int32_t)sysconf(_SC_NPROCESSORS_ONLN);
+  tsPageSize = sysconf(_SC_PAGESIZE);
+  tsOpenMax = sysconf(_SC_OPEN_MAX);
+  tsStreamMax = sysconf(_SC_STREAM_MAX);
+
+  tsProcId = (pid_t)syscall(SYS_gettid);
+  tsPageSizeKB = (float)(sysconf(_SC_PAGESIZE)) / 1024;
+  tsTotalMemoryMB = (int32_t)((float)sysconf(_SC_PHYS_PAGES) * tsPageSizeKB / 1024);
+
+  snprintf(tsProcMemFile, 25, "/proc/%d/status", tsProcId);
+  snprintf(tsProcCpuFile, 25, "/proc/%d/stat", tsProcId);
+  snprintf(tsProcIOFile, 25, "/proc/%d/io", tsProcId);
+
+  float tmp1, tmp2;
+  taosGetSysMemory(&tmp1);
+  taosGetProcMemory(&tmp2);
+  taosGetDisk();
+  taosGetBandSpeed(&tmp1);
+  taosGetCpuUsage(&tmp1, &tmp2);
+  taosGetProcIO(&tmp1, &tmp2);
+
+  taosGetSystemTimezone();
+  taosGetSystemLocale();
+}
+
+void taosPrintOsInfo() {
+  uInfo(" os pageSize:            %" PRId64 "(KB)", tsPageSize);
+  uInfo(" os openMax:             %" PRId64, tsOpenMax);
+  uInfo(" os streamMax:           %" PRId64, tsStreamMax);
+  uInfo(" os numOfCores:          %d", tsNumOfCores);
+  uInfo(" os totalDisk:           %f(GB)", tsTotalDataDirGB);
+  uInfo(" os totalMemory:         %d(MB)", tsTotalMemoryMB);
+
+  struct utsname buf;
+  if (uname(&buf)) {
+    uInfo(" can't fetch os info");
+    return;
+  }
+  uInfo(" os sysname:             %s", buf.sysname);
+  uInfo(" os nodename:            %s", buf.nodename);
+  uInfo(" os release:             %s", buf.release);
+  uInfo(" os version:             %s", buf.version);
+  uInfo(" os machine:             %s", buf.machine);
+  uInfo("==================================");
+}
+
+void taosKillSystem() {
+  // SIGINT
+  uInfo("taosd will shut down soon");
+  kill(tsProcId, 2);
+}
+
+int tSystem(const char *cmd) {
+  FILE *fp;
+  int   res;
+  char  buf[1024];
+  if (cmd == NULL) {
+    uError("tSystem cmd is NULL!\n");
+    return -1;
+  }
+
+  if ((fp = popen(cmd, "r")) == NULL) {
+    uError("popen cmd:%s error: %s/n", cmd, strerror(errno));
+    return -1;
+  } else {
+    while (fgets(buf, sizeof(buf), fp)) {
+      uDebug("popen result:%s", buf);
+    }
+
+    if ((res = pclose(fp)) == -1) {
+      uError("close popen file pointer fp error!\n");
+    } else {
+      uDebug("popen res is :%d\n", res);
+    }
+
+    return res;
+  }
+}
+
+#endif

src/os/src/detail/osTimer.c

@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "os.h"
+#include "taosdef.h"
+#include "tglobal.h"
+#include "ttimer.h"
+#include "tulog.h"
+#include "tutil.h"
+#include <signal.h>
+
+#ifndef TAOS_OS_FUNC_TIMER
+
+/*
+  to make taosMsleep work,
+   signal SIGALRM shall be blocked in the calling thread,
+
+  sigset_t set;
+  sigemptyset(&set);
+  sigaddset(&set, SIGALRM);
+  pthread_sigmask(SIG_BLOCK, &set, NULL);
+*/
+void taosMsleep(int mseconds) {
+  struct timeval timeout;
+  int            seconds, useconds;
+
+  seconds = mseconds / 1000;
+  useconds = (mseconds % 1000) * 1000;
+  timeout.tv_sec = seconds;
+  timeout.tv_usec = useconds;
+
+  /* sigset_t set; */
+  /* sigemptyset(&set); */
+  /* sigaddset(&set, SIGALRM); */
+  /* pthread_sigmask(SIG_BLOCK, &set, NULL); */
+
+  select(0, NULL, NULL, NULL, &timeout);
+
+  /* pthread_sigmask(SIG_UNBLOCK, &set, NULL); */
+}
+
+
+static void taosDeleteTimer(void *tharg) {
+  timer_t *pTimer = tharg;
+  timer_delete(*pTimer);
+}
+
+static pthread_t timerThread;
+static timer_t         timerId;
+static volatile bool stopTimer = false;
+static void *taosProcessAlarmSignal(void *tharg) {
+  // Block the signal
+  sigset_t sigset;
+  sigemptyset(&sigset);
+  sigaddset(&sigset, SIGALRM);
+  sigprocmask(SIG_BLOCK, &sigset, NULL);
+  void (*callback)(int) = tharg;
+
+  struct sigevent sevent = {{0}};
+
+  #ifdef _ALPINE
+    sevent.sigev_notify = SIGEV_THREAD;
+    sevent.sigev_value.sival_int = syscall(__NR_gettid);
+  #else
+    sevent.sigev_notify = SIGEV_THREAD_ID;
+    sevent._sigev_un._tid = syscall(__NR_gettid);
+  #endif
+  
+  sevent.sigev_signo = SIGALRM;
+
+  if (timer_create(CLOCK_REALTIME, &sevent, &timerId) == -1) {
+    uError("Failed to create timer");
+  }
+
+  pthread_cleanup_push(taosDeleteTimer, &timerId);
+
+  struct itimerspec ts;
+  ts.it_value.tv_sec = 0;
+  ts.it_value.tv_nsec = 1000000 * MSECONDS_PER_TICK;
+  ts.it_interval.tv_sec = 0;
+  ts.it_interval.tv_nsec = 1000000 * MSECONDS_PER_TICK;
+
+  if (timer_settime(timerId, 0, &ts, NULL)) {
+    uError("Failed to init timer");
+    return NULL;
+  }
+
+  int signo;
+  while (!stopTimer) {
+    if (sigwait(&sigset, &signo)) {
+      uError("Failed to wait signal: number %d", signo);
+      continue;
+    }
+    /* printf("Signal handling: number %d ......\n", signo); */
+
+    callback(0);
+  }
+  
+  pthread_cleanup_pop(1);
+
+  return NULL;
+}
+
+int taosInitTimer(void (*callback)(int), int ms) {
+  pthread_attr_t tattr;
+  pthread_attr_init(&tattr);
+  int code = pthread_create(&timerThread, &tattr, taosProcessAlarmSignal, callback);
+  pthread_attr_destroy(&tattr);
+  if (code != 0) {
+    uError("failed to create timer thread");
+    return -1;
+  }
+  return 0;
+}
+
+void taosUninitTimer() {
+  stopTimer = true;
+  pthread_join(timerThread, NULL);
+}
+
+#endif

src/os/src/detail/osUtil.c

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+
+#ifndef TAOS_OS_FUNC_UTIL
+
+int64_t tsosStr2int64(char *str) {
+  char *endptr = NULL;
+  return strtoll(str, &endptr, 10);
+}
+
+#endif

src/os/src/linux64/CMakeLists.txt

@@ -0,0 +1,12 @@
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+PROJECT(TDengine)
+
+INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/inc)
+INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/os/inc)
+INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/util/inc)
+INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/common/inc)
+AUX_SOURCE_DIRECTORY(. SRC)
+
+ADD_LIBRARY(os ${SRC})
+TARGET_LINK_LIBRARIES(os m rt)
+

src/os/src/linux64/linuxEnv.c

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "tglobal.h"
+#include "tulog.h"
+
+void osInit() {
+  strcpy(configDir, "/etc/taos");
+  strcpy(tsVnodeDir, "");
+  strcpy(tsDnodeDir, "");
+  strcpy(tsMnodeDir, "");
+  strcpy(tsDataDir, "/var/lib/taos");
+  strcpy(tsLogDir, "/var/log/taos");
+  strcpy(tsScriptDir, "/etc/taos");
+  strcpy(tsOsName, "Linux");
+}

src/os/src/windows64/CMakeLists.txt

@@ -0,0 +1,11 @@
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+PROJECT(TDengine)
+
+IF (TD_WINDOWS_64)
+  INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/pthread)
+  INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/inc)
+  INCLUDE_DIRECTORIES(inc)
+  AUX_SOURCE_DIRECTORY(src SRC)
+  ADD_LIBRARY(os ${SRC})
+  TARGET_LINK_LIBRARIES(os winmm IPHLPAPI ws2_32)
+ENDIF ()

src/os/src/windows64/twindows.c

@@ -0,0 +1,410 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "taosdef.h"
+#include "tglobal.h"
+#include "ttimer.h"
+#include "tulog.h"
+#include "tutil.h"
+
+bool taosCheckPthreadValid(pthread_t thread) {
+  return thread.p != NULL;
+}
+
+void taosResetPthread(pthread_t *thread) {
+  thread->p = 0;
+}
+
+int64_t taosGetPthreadId() {
+#ifdef PTW32_VERSION
+  return pthread_getw32threadid_np(pthread_self());
+#else
+  return (int64_t)pthread_self();
+#endif
+}
+
+int taosSetSockOpt(int socketfd, int level, int optname, void *optval, int optlen) {
+  if (level == SOL_SOCKET && optname == TCP_KEEPCNT) {
+    return 0;
+  }
+
+  if (level == SOL_TCP && optname == TCP_KEEPIDLE) {
+    return 0;
+  }
+
+  if (level == SOL_TCP && optname == TCP_KEEPINTVL) {
+    return 0;
+  }
+
+  return setsockopt(socketfd, level, optname, optval, optlen);
+}
+
+// add
+char interlocked_add_fetch_8(char volatile* ptr, char val) {
+  #ifdef _TD_GO_DLL_
+    return __sync_fetch_and_add(ptr, val) + val;
+  #else
+    return _InterlockedExchangeAdd8(ptr, val) + val;
+  #endif
+}
+
+short interlocked_add_fetch_16(short volatile* ptr, short val) {
+  #ifdef _TD_GO_DLL_
+    return __sync_fetch_and_add(ptr, val) + val;
+  #else
+    return _InterlockedExchangeAdd16(ptr, val) + val;
+  #endif
+}
+
+long interlocked_add_fetch_32(long volatile* ptr, long val) {
+  return _InterlockedExchangeAdd(ptr, val) + val;
+}
+
+__int64 interlocked_add_fetch_64(__int64 volatile* ptr, __int64 val) {
+  return _InterlockedExchangeAdd64(ptr, val) + val;
+}
+
+// and
+#ifndef _TD_GO_DLL_
+char interlocked_and_fetch_8(char volatile* ptr, char val) {
+  return _InterlockedAnd8(ptr, val) & val;
+}
+
+short interlocked_and_fetch_16(short volatile* ptr, short val) {
+  return _InterlockedAnd16(ptr, val) & val;
+}
+#endif
+
+long interlocked_and_fetch_32(long volatile* ptr, long val) {
+  return _InterlockedAnd(ptr, val) & val;
+}
+
+#ifndef _M_IX86
+
+__int64 interlocked_and_fetch_64(__int64 volatile* ptr, __int64 val) {
+  return _InterlockedAnd64(ptr, val) & val;
+}
+
+#else
+
+__int64 interlocked_and_fetch_64(__int64 volatile* ptr, __int64 val) {
+  __int64 old, res;
+  do {
+    old = *ptr;
+    res = old & val;
+  } while(_InterlockedCompareExchange64(ptr, res, old) != old);
+  return res;
+}
+
+__int64 interlocked_fetch_and_64(__int64 volatile* ptr, __int64 val) {
+  __int64 old;
+  do {
+    old = *ptr;
+  } while(_InterlockedCompareExchange64(ptr, old & val, old) != old);
+  return old;
+}
+
+#endif
+
+// or
+#ifndef _TD_GO_DLL_
+char interlocked_or_fetch_8(char volatile* ptr, char val) {
+  return _InterlockedOr8(ptr, val) | val;
+}
+
+short interlocked_or_fetch_16(short volatile* ptr, short val) {
+  return _InterlockedOr16(ptr, val) | val;
+}
+#endif
+long interlocked_or_fetch_32(long volatile* ptr, long val) {
+  return _InterlockedOr(ptr, val) | val;
+}
+
+#ifndef _M_IX86
+
+__int64 interlocked_or_fetch_64(__int64 volatile* ptr, __int64 val) {
+  return _InterlockedOr64(ptr, val) & val;
+}
+
+#else
+
+__int64 interlocked_or_fetch_64(__int64 volatile* ptr, __int64 val) {
+  __int64 old, res;
+  do {
+    old = *ptr;
+    res = old | val;
+  } while(_InterlockedCompareExchange64(ptr, res, old) != old);
+  return res;
+}
+
+__int64 interlocked_fetch_or_64(__int64 volatile* ptr, __int64 val) {
+  __int64 old;
+  do {
+    old = *ptr;
+  } while(_InterlockedCompareExchange64(ptr, old | val, old) != old);
+  return old;
+}
+
+#endif
+
+// xor
+#ifndef _TD_GO_DLL_
+char interlocked_xor_fetch_8(char volatile* ptr, char val) {
+  return _InterlockedXor8(ptr, val) ^ val;
+}
+
+short interlocked_xor_fetch_16(short volatile* ptr, short val) {
+  return _InterlockedXor16(ptr, val) ^ val;
+}
+#endif
+long interlocked_xor_fetch_32(long volatile* ptr, long val) {
+  return _InterlockedXor(ptr, val) ^ val;
+}
+
+#ifndef _M_IX86
+
+__int64 interlocked_xor_fetch_64(__int64 volatile* ptr, __int64 val) {
+  return _InterlockedXor64(ptr, val) ^ val;
+}
+
+#else
+
+__int64 interlocked_xor_fetch_64(__int64 volatile* ptr, __int64 val) {
+  __int64 old, res;
+  do {
+    old = *ptr;
+    res = old ^ val;
+  } while(_InterlockedCompareExchange64(ptr, res, old) != old);
+  return res;
+}
+
+__int64 interlocked_fetch_xor_64(__int64 volatile* ptr, __int64 val) {
+  __int64 old;
+  do {
+    old = *ptr;
+  } while(_InterlockedCompareExchange64(ptr, old ^ val, old) != old);
+  return old;
+}
+
+#endif
+
+void taosPrintOsInfo() {}
+
+void taosGetSystemTimezone() {
+  // get and set default timezone
+  SGlobalCfg *cfg_timezone = taosGetConfigOption("timezone");
+  if (cfg_timezone && cfg_timezone->cfgStatus < TAOS_CFG_CSTATUS_DEFAULT) {
+    char *tz = getenv("TZ");
+    if (tz == NULL || strlen(tz) == 0) {
+      strcpy(tsTimezone, "not configured");
+    }
+    else {
+      strcpy(tsTimezone, tz);
+    }
+    cfg_timezone->cfgStatus = TAOS_CFG_CSTATUS_DEFAULT;
+    uInfo("timezone not configured, use default");
+  }
+}
+
+void taosGetSystemLocale() {
+  // get and set default locale
+  SGlobalCfg *cfg_locale = taosGetConfigOption("locale");
+  if (cfg_locale && cfg_locale->cfgStatus < TAOS_CFG_CSTATUS_DEFAULT) {
+    char *locale = setlocale(LC_CTYPE, "chs");
+    if (locale != NULL) {
+      tstrncpy(tsLocale, locale, sizeof(tsLocale));
+      cfg_locale->cfgStatus = TAOS_CFG_CSTATUS_DEFAULT;
+      uInfo("locale not configured, set to default:%s", tsLocale);
+    }
+  }
+
+  SGlobalCfg *cfg_charset = taosGetConfigOption("charset");
+  if (cfg_charset && cfg_charset->cfgStatus < TAOS_CFG_CSTATUS_DEFAULT) {
+    strcpy(tsCharset, "cp936");
+    cfg_charset->cfgStatus = TAOS_CFG_CSTATUS_DEFAULT;
+    uInfo("charset not configured, set to default:%s", tsCharset);
+  }
+}
+
+void taosGetSystemInfo() {
+  taosGetSystemTimezone();
+  taosGetSystemLocale();
+}
+
+void taosKillSystem() {
+  exit(0);
+}
+
+/*
+ * Get next token from string *stringp, where tokens are possibly-empty
+ * strings separated by characters from delim.
+ *
+ * Writes NULs into the string at *stringp to end tokens.
+ * delim need not remain constant from call to call.
+ * On return, *stringp points past the last NUL written (if there might
+ * be further tokens), or is NULL (if there are definitely no moretokens).
+ *
+ * If *stringp is NULL, strsep returns NULL.
+ */
+char *strsep(char **stringp, const char *delim) {
+  char *s;
+  const char *spanp;
+  int c, sc;
+  char *tok;
+  if ((s = *stringp) == NULL)
+    return (NULL);
+  for (tok = s;;) {
+    c = *s++;
+    spanp = delim;
+    do {
+      if ((sc = *spanp++) == c) {
+        if (c == 0)
+          s = NULL;
+        else
+          s[-1] = 0;
+        *stringp = s;
+        return (tok);
+      }
+    } while (sc != 0);
+  }
+  /* NOTREACHED */
+}
+
+char *getpass(const char *prefix) {
+  static char passwd[TSDB_KEY_LEN] = {0};
+
+  printf("%s", prefix);
+  scanf("%s", passwd);
+
+  char n = getchar();
+  return passwd;
+}
+
+int flock(int fd, int option) {
+  return 0;
+}
+
+int fsync(int filedes) {
+  return 0;
+}
+
+int sigaction(int sig, struct sigaction *d, void *p) {
+  return 0;
+}
+
+int wordexp(const char *words, wordexp_t *pwordexp, int flags) {
+  pwordexp->we_offs = 0;
+  pwordexp->we_wordc = 1;
+  pwordexp->we_wordv = (char **)(pwordexp->wordPos);
+  pwordexp->we_wordv[0] = (char *)words;
+  return 0;
+}
+
+void wordfree(wordexp_t *pwordexp) {}
+
+void taosGetDisk() {}
+
+bool taosSkipSocketCheck() {
+  return false;
+}
+
+#define _SEND_FILE_STEP_ 1000
+
+int fsendfile(FILE* out_file, FILE* in_file, int64_t* offset, int32_t count) {
+  fseek(in_file, (int32_t)(*offset), 0);
+  int writeLen = 0;
+  uint8_t buffer[_SEND_FILE_STEP_] = { 0 };
+  
+  for (int len = 0; len < (count - _SEND_FILE_STEP_); len += _SEND_FILE_STEP_) {
+    size_t rlen = fread(buffer, 1, _SEND_FILE_STEP_, in_file);
+    if (rlen <= 0) {
+      return writeLen;
+    }
+    else if (rlen < _SEND_FILE_STEP_) {
+      fwrite(buffer, 1, rlen, out_file);
+      return (int)(writeLen + rlen);
+    }
+    else {
+      fwrite(buffer, 1, _SEND_FILE_STEP_, in_file);
+      writeLen += _SEND_FILE_STEP_;
+    }
+  }
+
+  int remain = count - writeLen;
+  if (remain > 0) {
+    size_t rlen = fread(buffer, 1, remain, in_file);
+    if (rlen <= 0) {
+      return writeLen;
+    }
+    else {
+      fwrite(buffer, 1, remain, out_file);
+      writeLen += remain;
+    }
+  }
+
+  return writeLen;
+}
+
+int32_t BUILDIN_CLZL(uint64_t val) {
+  unsigned long r = 0;
+  _BitScanReverse64(&r, val);
+  return (int)(r >> 3);
+}
+
+int32_t BUILDIN_CLZ(uint32_t val) {
+  unsigned long r = 0;
+  _BitScanReverse(&r, val);
+  return (int)(r >> 3);
+}
+
+int32_t BUILDIN_CTZL(uint64_t val) {
+  unsigned long r = 0;
+  _BitScanForward64(&r, val);
+  return (int)(r >> 3);
+}
+
+int32_t BUILDIN_CTZ(uint32_t val) {
+  unsigned long r = 0;
+  _BitScanForward(&r, val);
+  return (int)(r >> 3);
+}
+
+char *strndup(const char *s, size_t n) {
+  int len = strlen(s);
+  if (len >= n) {
+    len = n;
+  }
+
+  char *r = calloc(len + 1, 1);
+  memcpy(r, s, len);
+  r[len] = 0;
+  return r;
+}
+
+void taosSetCoreDump() {}
+
+#ifdef _TD_GO_DLL_
+int64_t tsosStr2int64(char *str) {
+  char *endptr = NULL;
+  return strtoll(str, &endptr, 10);
+}
+
+uint64_t htonll(uint64_t val)
+{
+    return (((uint64_t) htonl(val)) << 32) + htonl(val >> 32);
+}
+#endif

src/os/src/windows64/twinenv.c

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "tglobal.h"
+#include "tulog.h"
+
+void osInit() {
+  strcpy(configDir, "C:/TDengine/cfg");
+  strcpy(tsVnodeDir, "C:/TDengine/data");
+  strcpy(tsDnodeDir, "");
+  strcpy(tsMnodeDir, "");
+  strcpy(tsDataDir, "C:/TDengine/data");
+  strcpy(tsLogDir, "C:/TDengine/log");
+  strcpy(tsScriptDir, "C:/TDengine/script");
+  strcpy(tsOsName, "Windows");
+}

src/os/src/windows64/twingetline.c

@@ -0,0 +1,145 @@
+/* getline.c -- Replacement for GNU C library function getline
+
+Copyright (C) 1993 Free Software Foundation, Inc.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 2 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.  */
+
+/* Written by Jan Brittenson, bson@gnu.ai.mit.edu.  */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <sys/types.h>
+#include <stdio.h>
+#include <assert.h>
+#include <errno.h>
+
+#if STDC_HEADERS
+#include <stdlib.h>
+#else
+char *malloc(), *realloc();
+#endif
+
+/* Always add at least this many bytes when extending the buffer.  */
+#define MIN_CHUNK 64
+
+/* Read up to (and including) a TERMINATOR from STREAM into *LINEPTR
++ OFFSET (and null-terminate it). *LINEPTR is a pointer returned from
+malloc (or NULL), pointing to *N characters of space.  It is realloc'd
+as necessary.  Return the number of characters read (not including the
+null terminator), or -1 on error or EOF.  On a -1 return, the caller
+should check feof(), if not then errno has been set to indicate
+the error.  */
+
+int
+getstr(lineptr, n, stream, terminator, offset)
+char **lineptr;
+size_t *n;
+FILE *stream;
+char terminator;
+int offset;
+{
+    int nchars_avail;		/* Allocated but unused chars in *LINEPTR.  */
+    char *read_pos;		/* Where we're reading into *LINEPTR. */
+    int ret;
+
+    if (!lineptr || !n || !stream)
+    {
+        errno = EINVAL;
+        return -1;
+    }
+
+    if (!*lineptr)
+    {
+        *n = MIN_CHUNK;
+        *lineptr = malloc(*n);
+        if (!*lineptr)
+        {
+            errno = ENOMEM;
+            return -1;
+        }
+    }
+
+    nchars_avail = (int)(*n - offset);
+    read_pos = *lineptr + offset;
+
+    for (;;)
+    {
+        int save_errno;
+        register int c = getc(stream);
+
+        save_errno = errno;
+
+        /* We always want at least one char left in the buffer, since we
+        always (unless we get an error while reading the first char)
+        NUL-terminate the line buffer.  */
+
+        assert((*lineptr + *n) == (read_pos + nchars_avail));
+        if (nchars_avail < 2)
+        {
+            if (*n > MIN_CHUNK)
+                *n *= 2;
+            else
+                *n += MIN_CHUNK;
+
+            nchars_avail = (int)(*n + *lineptr - read_pos);
+            *lineptr = realloc(*lineptr, *n);
+            if (!*lineptr)
+            {
+                errno = ENOMEM;
+                return -1;
+            }
+            read_pos = *n - nchars_avail + *lineptr;
+            assert((*lineptr + *n) == (read_pos + nchars_avail));
+        }
+
+        if (ferror(stream))
+        {
+            /* Might like to return partial line, but there is no
+            place for us to store errno.  And we don't want to just
+            lose errno.  */
+            errno = save_errno;
+            return -1;
+        }
+
+        if (c == EOF)
+        {
+            /* Return partial line, if any.  */
+            if (read_pos == *lineptr)
+                return -1;
+            else
+                break;
+        }
+
+        *read_pos++ = c;
+        nchars_avail--;
+
+        if (c == terminator)
+            /* Return the line.  */
+            break;
+    }
+
+    /* Done - NUL terminate and return the number of chars read.  */
+    *read_pos = '\0';
+
+    ret = (int)(read_pos - (*lineptr + offset));
+    return ret;
+}
+
+int
+getline(lineptr, n, stream)
+char **lineptr;
+size_t *n;
+FILE *stream;
+{
+    return getstr(lineptr, n, stream, '\n', 0);
+}

src/os/src/windows64/twinmsghdr.c

@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <winsock2.h>
+
+void taosFreeMsgHdr(void *hdr) {
+    WSAMSG *msgHdr = (WSAMSG *)hdr;
+    free(msgHdr->lpBuffers);
+}
+
+int taosMsgHdrSize(void *hdr) {
+    WSAMSG *msgHdr = (WSAMSG *)hdr;
+    return msgHdr->dwBufferCount;
+}
+
+void taosSendMsgHdr(void *hdr, int fd) {
+    WSAMSG *msgHdr = (WSAMSG *)hdr;
+    DWORD len;
+
+    WSASendMsg(fd, msgHdr, 0, &len, 0, 0);
+    msgHdr->dwBufferCount = 0;
+}
+
+void taosInitMsgHdr(void **hdr, void *dest, int maxPkts) {
+    WSAMSG *msgHdr = (WSAMSG *)malloc(sizeof(WSAMSG));
+    memset(msgHdr, 0, sizeof(WSAMSG));
+    *hdr = msgHdr;
+
+    // see ws2def.h
+    // the size of LPSOCKADDR and sockaddr_in * is same, so it's safe
+    msgHdr->name = (LPSOCKADDR)dest;
+    msgHdr->namelen = sizeof(struct sockaddr_in);
+    int size = sizeof(WSABUF) * maxPkts;
+    msgHdr->lpBuffers = (LPWSABUF)malloc(size);
+    memset(msgHdr->lpBuffers, 0, size);
+    msgHdr->dwBufferCount = 0;
+}
+
+void taosSetMsgHdrData(void *hdr, char *data, int dataLen) {
+    WSAMSG *msgHdr = (WSAMSG *)hdr;
+    msgHdr->lpBuffers[msgHdr->dwBufferCount].buf = data;
+    msgHdr->lpBuffers[msgHdr->dwBufferCount].len = dataLen;
+    msgHdr->dwBufferCount++;
+}
+

src/os/src/windows64/twinsocket.c

@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <WS2tcpip.h>  
+#include <IPHlpApi.h>  
+#include <winsock2.h>  
+#include <stdio.h>
+#include <string.h>
+#include <ws2def.h>
+#include <tchar.h>
+
+void taosWinSocketInit() {
+    static char flag = 0;
+    if (flag == 0) {
+        WORD wVersionRequested;
+        WSADATA wsaData;
+        wVersionRequested = MAKEWORD(1, 1);
+        if (WSAStartup(wVersionRequested, &wsaData) == 0) {
+            flag = 1;
+        }
+    }
+}
+
+int taosSetNonblocking(SOCKET sock, int on) {
+    u_long mode;
+    if (on) {
+        mode = 1;
+        ioctlsocket(sock, FIONBIO, &mode);
+    }
+    else {
+        mode = 0;
+        ioctlsocket(sock, FIONBIO, &mode);
+    }
+    return 0;
+}
+
+int taosGetPrivateIp(char *const ip) {
+    PIP_ADAPTER_ADDRESSES pAddresses = 0;
+    IP_ADAPTER_DNS_SERVER_ADDRESS *pDnServer = 0;
+    ULONG outBufLen = 0;
+    DWORD dwRetVal = 0;
+    char buff[100];
+    DWORD bufflen = 100;
+    int i;
+    int flag = -1;
+
+    taosWinSocketInit();
+    GetAdaptersAddresses(AF_UNSPEC, 0, NULL, pAddresses, &outBufLen);
+    pAddresses = (IP_ADAPTER_ADDRESSES *)malloc(outBufLen);
+    if ((dwRetVal = GetAdaptersAddresses(AF_INET, GAA_FLAG_SKIP_ANYCAST, NULL, pAddresses, &outBufLen)) == NO_ERROR) {
+        while (pAddresses) {
+            if (wcsstr(pAddresses->FriendlyName, L"Loopback") != 0) {
+                pAddresses = pAddresses->Next;
+                continue;
+            }
+            if (pAddresses->OperStatus == IfOperStatusUp) {
+                //printf("%s, Status: active\n", pAddresses->FriendlyName);
+            }
+            else {
+                //printf("%s, Status: deactive\n", pAddresses->FriendlyName);
+                pAddresses = pAddresses->Next;
+                continue;
+            }
+
+            PIP_ADAPTER_UNICAST_ADDRESS pUnicast = pAddresses->FirstUnicastAddress;
+            for (i = 0; pUnicast != NULL; i++) {
+                if (pUnicast->Address.lpSockaddr->sa_family == AF_INET) {
+                    struct sockaddr_in *sa_in = (struct sockaddr_in *)pUnicast->Address.lpSockaddr;
+                    strcpy(ip, inet_ntop(AF_INET, &(sa_in->sin_addr), buff, bufflen));
+                    flag = 0;
+                    //printf("%s\n", ip);
+                }
+                else if (pUnicast->Address.lpSockaddr->sa_family == AF_INET6) {
+                    struct sockaddr_in6 *sa_in6 = (struct sockaddr_in6 *)pUnicast->Address.lpSockaddr;
+                    strcpy(ip, inet_ntop(AF_INET6, &(sa_in6->sin6_addr), buff, bufflen));
+                    flag = 0;
+                    //printf("%s\n", ip);
+                }
+                else {
+                }
+                pUnicast = pUnicast->Next;
+            }
+            pAddresses = pAddresses->Next;
+        }
+    }
+    else {
+        LPVOID lpMsgBuf;
+        printf("Call to GetAdaptersAddresses failed.\n");
+        if (FormatMessage(
+          FORMAT_MESSAGE_ALLOCATE_BUFFER |
+          FORMAT_MESSAGE_FROM_SYSTEM |
+          FORMAT_MESSAGE_IGNORE_INSERTS,
+          NULL,
+          dwRetVal,
+          MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+          (LPTSTR) & lpMsgBuf,
+          0,
+          NULL)) {
+            printf("\tError: %s", lpMsgBuf);
+        }
+        LocalFree(lpMsgBuf);
+    }
+    free(pAddresses);
+    return flag;
+}

src/os/src/windows64/twinstrptime.c

@@ -0,0 +1,398 @@
+/*	$Id$	*/
+/*	$NetBSD: strptime.c,v 1.18 1999/04/29 02:58:30 tv Exp $	*/
+
+/*-
+* Copyright (c) 1997, 1998 The NetBSD Foundation, Inc.
+* All rights reserved.
+*
+* This code was contributed to The NetBSD Foundation by Klaus Klein.
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions
+* are met:
+* 1. Redistributions of source code must retain the above copyright
+*    notice, this list of conditions and the following disclaimer.
+* 2. Redistributions in binary form must reproduce the above copyright
+*    notice, this list of conditions and the following disclaimer in the
+*    documentation and/or other materials provided with the distribution.
+* 3. All advertising materials mentioning features or use of this software
+*    must display the following acknowledgement:
+*        This product includes software developed by the NetBSD
+*        Foundation, Inc. and its contributors.
+* 4. Neither the name of The NetBSD Foundation nor the names of its
+*    contributors may be used to endorse or promote products derived
+*    from this software without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+* PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+* POSSIBILITY OF SUCH DAMAGE.
+*/
+//
+//#include "lukemftp.h"
+#include <time.h>  
+#include <stdlib.h>  
+#include <string.h>
+#include <winsock2.h>
+//#define TM_YEAR_BASE 1970 //origin
+#define TM_YEAR_BASE 1900 //slguan
+/*
+* We do not implement alternate representations. However, we always
+* check whether a given modifier is allowed for a certain conversion.
+*/
+#define ALT_E			0x01
+#define ALT_O			0x02
+#define	LEGAL_ALT(x)		{ if (alt_format & ~(x)) return (0); }
+
+
+static	int conv_num(const char **, int *, int, int);
+
+static const char *day[7] = {
+    "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday",
+    "Friday", "Saturday"
+};
+static const char *abday[7] = {
+    "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
+};
+static const char *mon[12] = {
+    "January", "February", "March", "April", "May", "June", "July",
+    "August", "September", "October", "November", "December"
+};
+static const char *abmon[12] = {
+    "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+    "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
+};
+static const char *am_pm[2] = {
+    "AM", "PM"
+};
+
+
+char *
+strptime(const char *buf, const char *fmt, struct tm *tm)
+{
+    char c;
+    const char *bp;
+    size_t len = 0;
+    int alt_format, i, split_year = 0;
+
+    bp = buf;
+
+    while ((c = *fmt) != '\0') {
+        /* Clear `alternate' modifier prior to new conversion. */
+        alt_format = 0;
+
+        /* Eat up white-space. */
+        if (isspace(c)) {
+            while (isspace(*bp))
+                bp++;
+
+            fmt++;
+            continue;
+        }
+
+        if ((c = *fmt++) != '%')
+            goto literal;
+
+
+    again:		switch (c = *fmt++) {
+    case '%':	/* "%%" is converted to "%". */
+        literal :
+            if (c != *bp++)
+                return (0);
+        break;
+
+        /*
+        * "Alternative" modifiers. Just set the appropriate flag
+        * and start over again.
+        */
+    case 'E':	/* "%E?" alternative conversion modifier. */
+        LEGAL_ALT(0);
+        alt_format |= ALT_E;
+        goto again;
+
+    case 'O':	/* "%O?" alternative conversion modifier. */
+        LEGAL_ALT(0);
+        alt_format |= ALT_O;
+        goto again;
+
+        /*
+        * "Complex" conversion rules, implemented through recursion.
+        */
+    case 'c':	/* Date and time, using the locale's format. */
+        LEGAL_ALT(ALT_E);
+        if (!(bp = strptime(bp, "%x %X", tm)))
+            return (0);
+        break;
+
+    case 'D':	/* The date as "%m/%d/%y". */
+        LEGAL_ALT(0);
+        if (!(bp = strptime(bp, "%m/%d/%y", tm)))
+            return (0);
+        break;
+
+    case 'R':	/* The time as "%H:%M". */
+        LEGAL_ALT(0);
+        if (!(bp = strptime(bp, "%H:%M", tm)))
+            return (0);
+        break;
+
+    case 'r':	/* The time in 12-hour clock representation. */
+        LEGAL_ALT(0);
+        if (!(bp = strptime(bp, "%I:%M:%S %p", tm)))
+            return (0);
+        break;
+
+    case 'T':	/* The time as "%H:%M:%S". */
+        LEGAL_ALT(0);
+        if (!(bp = strptime(bp, "%H:%M:%S", tm)))
+            return (0);
+        break;
+
+    case 'X':	/* The time, using the locale's format. */
+        LEGAL_ALT(ALT_E);
+        if (!(bp = strptime(bp, "%H:%M:%S", tm)))
+            return (0);
+        break;
+
+    case 'x':	/* The date, using the locale's format. */
+        LEGAL_ALT(ALT_E);
+        if (!(bp = strptime(bp, "%m/%d/%y", tm)))
+            return (0);
+        break;
+
+        /*
+        * "Elementary" conversion rules.
+        */
+    case 'A':	/* The day of week, using the locale's form. */
+    case 'a':
+        LEGAL_ALT(0);
+        for (i = 0; i < 7; i++) {
+            /* Full name. */
+            len = strlen(day[i]);
+            if (strncmp(day[i], bp, len) == 0)
+                break;
+
+            /* Abbreviated name. */
+            len = strlen(abday[i]);
+            if (strncmp(abday[i], bp, len) == 0)
+                break;
+        }
+
+        /* Nothing matched. */
+        if (i == 7)
+            return (0);
+
+        tm->tm_wday = i;
+        bp += len;
+        break;
+
+    case 'B':	/* The month, using the locale's form. */
+    case 'b':
+    case 'h':
+        LEGAL_ALT(0);
+        for (i = 0; i < 12; i++) {
+            /* Full name. */
+            len = strlen(mon[i]);
+            if (strncmp(mon[i], bp, len) == 0)
+                break;
+
+            /* Abbreviated name. */
+            len = strlen(abmon[i]);
+            if (strncmp(abmon[i], bp, len) == 0)
+                break;
+        }
+
+        /* Nothing matched. */
+        if (i == 12)
+            return (0);
+
+        tm->tm_mon = i;
+        bp += len;
+        break;
+
+    case 'C':	/* The century number. */
+        LEGAL_ALT(ALT_E);
+        if (!(conv_num(&bp, &i, 0, 99)))
+            return (0);
+
+        if (split_year) {
+            tm->tm_year = (tm->tm_year % 100) + (i * 100);
+        }
+        else {
+            tm->tm_year = i * 100;
+            split_year = 1;
+        }
+        break;
+
+    case 'd':	/* The day of month. */
+    case 'e':
+        LEGAL_ALT(ALT_O);
+        if (!(conv_num(&bp, &tm->tm_mday, 1, 31)))
+            return (0);
+        break;
+
+    case 'k':	/* The hour (24-hour clock representation). */
+        LEGAL_ALT(0);
+        /* FALLTHROUGH */
+    case 'H':
+        LEGAL_ALT(ALT_O);
+        if (!(conv_num(&bp, &tm->tm_hour, 0, 23)))
+            return (0);
+        break;
+
+    case 'l':	/* The hour (12-hour clock representation). */
+        LEGAL_ALT(0);
+        /* FALLTHROUGH */
+    case 'I':
+        LEGAL_ALT(ALT_O);
+        if (!(conv_num(&bp, &tm->tm_hour, 1, 12)))
+            return (0);
+        if (tm->tm_hour == 12)
+            tm->tm_hour = 0;
+        break;
+
+    case 'j':	/* The day of year. */
+        LEGAL_ALT(0);
+        if (!(conv_num(&bp, &i, 1, 366)))
+            return (0);
+        tm->tm_yday = i - 1;
+        break;
+
+    case 'M':	/* The minute. */
+        LEGAL_ALT(ALT_O);
+        if (!(conv_num(&bp, &tm->tm_min, 0, 59)))
+            return (0);
+        break;
+
+    case 'm':	/* The month. */
+        LEGAL_ALT(ALT_O);
+        if (!(conv_num(&bp, &i, 1, 12)))
+            return (0);
+        tm->tm_mon = i - 1;
+        break;
+
+    case 'p':	/* The locale's equivalent of AM/PM. */
+        LEGAL_ALT(0);
+        /* AM? */
+        if (strcmp(am_pm[0], bp) == 0) {
+            if (tm->tm_hour > 11)
+                return (0);
+
+            bp += strlen(am_pm[0]);
+            break;
+        }
+        /* PM? */
+        else if (strcmp(am_pm[1], bp) == 0) {
+            if (tm->tm_hour > 11)
+                return (0);
+
+            tm->tm_hour += 12;
+            bp += strlen(am_pm[1]);
+            break;
+        }
+
+        /* Nothing matched. */
+        return (0);
+
+    case 'S':	/* The seconds. */
+        LEGAL_ALT(ALT_O);
+        if (!(conv_num(&bp, &tm->tm_sec, 0, 61)))
+            return (0);
+        break;
+
+    case 'U':	/* The week of year, beginning on sunday. */
+    case 'W':	/* The week of year, beginning on monday. */
+        LEGAL_ALT(ALT_O);
+        /*
+        * XXX This is bogus, as we can not assume any valid
+        * information present in the tm structure at this
+        * point to calculate a real value, so just check the
+        * range for now.
+        */
+        if (!(conv_num(&bp, &i, 0, 53)))
+            return (0);
+        break;
+
+    case 'w':	/* The day of week, beginning on sunday. */
+        LEGAL_ALT(ALT_O);
+        if (!(conv_num(&bp, &tm->tm_wday, 0, 6)))
+            return (0);
+        break;
+
+    case 'Y':	/* The year. */
+        LEGAL_ALT(ALT_E);
+        if (!(conv_num(&bp, &i, 0, 9999)))
+            return (0);
+
+        tm->tm_year = i - TM_YEAR_BASE;
+        break;
+
+    case 'y':	/* The year within 100 years of the epoch. */
+        LEGAL_ALT(ALT_E | ALT_O);
+        if (!(conv_num(&bp, &i, 0, 99)))
+            return (0);
+
+        if (split_year) {
+            tm->tm_year = ((tm->tm_year / 100) * 100) + i;
+            break;
+        }
+        split_year = 1;
+        if (i <= 68)
+            tm->tm_year = i + 2000 - TM_YEAR_BASE;
+        else
+            tm->tm_year = i + 1900 - TM_YEAR_BASE;
+        break;
+
+        /*
+        * Miscellaneous conversions.
+        */
+    case 'n':	/* Any kind of white-space. */
+    case 't':
+        LEGAL_ALT(0);
+        while (isspace(*bp))
+            bp++;
+        break;
+
+
+    default:	/* Unknown/unsupported conversion. */
+        return (0);
+    }
+
+
+    }
+
+    /* LINTED functional specification */
+    return ((char *)bp);
+}
+
+
+static int
+conv_num(const char **buf, int *dest, int llim, int ulim)
+{
+    int result = 0;
+
+    /* The limit also determines the number of valid digits. */
+    int rulim = ulim;
+
+    if (**buf < '0' || **buf > '9')
+        return (0);
+
+    do {
+        result *= 10;
+        result += *(*buf)++ - '0';
+        rulim /= 10;
+    } while ((result * 10 <= ulim) && rulim && **buf >= '0' && **buf <= '9');
+
+    if (result < llim || result > ulim)
+        return (0);
+
+    *dest = result;
+    return (1);
+}

src/os/src/windows64/twintcpclient.c

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "tulog.h"
+
+void *taosInitTcpClient(char *ip, uint16_t port, char *label, int num, void *fp, void *shandle) {
+  tError("InitTcpClient not support in windows");
+  return 0;
+}
+
+void taosCloseTcpClientConnection(void *chandle) {
+  tError("CloseTcpClientConnection not support in windows");
+}
+
+void *taosOpenTcpClientConnection(void *shandle, void *thandle, char *ip, uint16_t port) {
+  tError("OpenTcpClientConnection not support in windows");
+  return 0;
+}
+
+int taosSendTcpClientData(unsigned int ip, uint16_t port, char *data, int len, void *chandle) {
+  tError("SendTcpClientData not support in windows");
+  return 0;
+}
+
+void taosCleanUpTcpClient(void *chandle) {
+  tError("SendTcpClientData not support in windows");
+}

src/os/src/windows64/twintcpserver.c

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "tulog.h"
+
+void taosCloseTcpServerConnection(void *chandle) {
+  tError("CloseTcpServerConnection not support in windows");
+}
+
+void taosCleanUpTcpServer(void *handle) {
+  tError("CleanUpTcpServer not support in windows");
+}
+
+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, uint16_t port, char *data, int len, void *chandle) {
+  tError("SendTcpServerData not support in windows");
+  return 0;
+}

src/os/src/windows64/twintime.c

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <time.h>  
+#include <winsock2.h>
+
+int gettimeofday(struct timeval *tv, struct timezone *tz) {
+  time_t t;
+  t = time(NULL);
+  SYSTEMTIME st;
+  GetLocalTime(&st);
+
+  tv->tv_sec = (long)t;
+  tv->tv_usec = st.wMilliseconds * 1000;
+
+  return 0;
+}
+
+struct tm *localtime_r(const time_t *timep, struct tm *result) {
+  localtime_s(result, timep);
+  return result;
+}

src/os/src/windows64/twintimer.c

@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <Windows.h>
+#include <Mmsystem.h>
+#include <stdio.h>
+#include <stdint.h>
+
+#pragma warning( disable : 4244 )
+
+typedef void (*win_timer_f)(int signo);
+
+void WINAPI taosWinOnTimer(UINT wTimerID, UINT msg, DWORD_PTR dwUser, DWORD_PTR dwl, DWORD_PTR dw2)
+{
+  win_timer_f callback = *((win_timer_f *)&dwUser);
+  if (callback != NULL) {
+    callback(0);
+  }
+}
+
+static MMRESULT timerId;
+int taosInitTimer(win_timer_f callback, int ms) {
+  DWORD_PTR param = *((int64_t *) & callback);
+
+  timerId = timeSetEvent(ms, 1, (LPTIMECALLBACK)taosWinOnTimer, param, TIME_PERIODIC);
+  if (timerId == 0) {
+    return -1;
+  }
+  return 0;
+}
+
+void taosUninitTimer() {
+  timeKillEvent(timerId);
+}
+
+void taosMsleep(int mseconds) {
+  Sleep(mseconds);
+}
+
+void sleep(int mseconds) {
+  taosMsleep(mseconds);
+}

src/plugins/CMakeLists.txt

@@ -4,3 +4,5 @@ PROJECT(TDengine)
 ADD_SUBDIRECTORY(monitor)
 ADD_SUBDIRECTORY(http)
 ADD_SUBDIRECTORY(mqtt)
+ADD_SUBDIRECTORY(balance)
+ADD_SUBDIRECTORY(sync)

src/plugins/http/CMakeLists.txt

@@ -3,6 +3,7 @@ PROJECT(TDengine)
 
 IF ((TD_LINUX_64) OR (TD_LINUX_32 AND TD_ARM))
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/inc)
+  INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/os/inc)
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/client/inc)
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/util/inc)
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/query/inc)
@@ -10,7 +11,6 @@ IF ((TD_LINUX_64) OR (TD_LINUX_32 AND TD_ARM))
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/zlib-1.2.11/inc)
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/cJson/inc)
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/lz4/inc)
-  INCLUDE_DIRECTORIES(${TD_OS_DIR}/inc)
   INCLUDE_DIRECTORIES(inc)
   AUX_SOURCE_DIRECTORY(src SRC)
   ADD_LIBRARY(http ${SRC})

src/plugins/http/src/httpJson.c

@@ -45,7 +45,7 @@ int httpWriteBufByFd(struct HttpContext* pContext, const char* buf, int sz) {
 
   do {
     if (pContext->fd > 2){
-      len = (int)send(pContext->fd, buf + writeLen, (size_t)(sz - writeLen), MSG_NOSIGNAL);
+      len = (int)taosSend(pContext->fd, buf + writeLen, (size_t)(sz - writeLen), MSG_NOSIGNAL);
     }
     else {
       return sz;

src/plugins/monitor/CMakeLists.txt

@@ -3,11 +3,11 @@ PROJECT(TDengine)
 
 IF ((TD_LINUX_64) OR (TD_LINUX_32 AND TD_ARM))
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/inc)
+  INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/os/inc)
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/client/inc)
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/util/inc)
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/query/inc)
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/common/inc)
-  INCLUDE_DIRECTORIES(${TD_OS_DIR}/inc)
   INCLUDE_DIRECTORIES(inc)
   AUX_SOURCE_DIRECTORY(./src SRC)
   ADD_LIBRARY(monitor ${SRC})

src/plugins/mqtt/CMakeLists.txt

@@ -3,6 +3,7 @@ PROJECT(TDengine)
 
 IF ((TD_LINUX_64) OR (TD_LINUX_32 AND TD_ARM))
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/inc)
+  INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/os/inc)
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/client/inc)
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/util/inc)
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/query/inc)
@@ -10,7 +11,6 @@ IF ((TD_LINUX_64) OR (TD_LINUX_32 AND TD_ARM))
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/cJson/inc)
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/MQTT-C/include)
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/MQTT-C/examples/templates)
-  INCLUDE_DIRECTORIES(${TD_OS_DIR}/inc)
   INCLUDE_DIRECTORIES(inc)
   AUX_SOURCE_DIRECTORY(src SRC)
   ADD_LIBRARY(mqtt ${SRC})

src/query/CMakeLists.txt

@@ -1,9 +1,9 @@
 CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
 PROJECT(TDengine)
 
-INCLUDE_DIRECTORIES(${TD_OS_DIR}/inc)
 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/inc)
-INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/util/inc)
+INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/os/inc)
+  INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/util/inc)
 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/common/inc)
 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/tsdb/inc)
 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/client/inc)

src/query/src/qTsbuf.c

@@ -740,7 +740,7 @@ int32_t tsBufMerge(STSBuf* pDestBuf, const STSBuf* pSrcBuf, int32_t vnodeId) {
   int32_t size = pSrcBuf->fileSize - offset;
 
 #ifdef LINUX
-  ssize_t rc = tsendfile(fileno(pDestBuf->f), fileno(pSrcBuf->f), &offset, size);
+  ssize_t rc = taosTSendFile(fileno(pDestBuf->f), fileno(pSrcBuf->f), &offset, size);
 #else
   ssize_t rc = fsendfile(pDestBuf->f, pSrcBuf->f, &offset, size);
 #endif

src/rpc/CMakeLists.txt

@@ -1,8 +1,8 @@
 CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
 PROJECT(TDengine)
 
-INCLUDE_DIRECTORIES(${TD_OS_DIR}/inc)
 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/inc)
+INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/os/inc)
 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/util/inc)
 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/common/inc)
 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/cJson/inc)
@@ -12,10 +12,11 @@ INCLUDE_DIRECTORIES(inc)
 IF ((TD_LINUX_64) OR (TD_LINUX_32 AND TD_ARM))
   AUX_SOURCE_DIRECTORY(./src SRC)
 ELSEIF (TD_DARWIN_64)
-  LIST(APPEND SRC ./src/thaship.c)
+  #LIST(APPEND SRC ./src/thaship.c)
-  LIST(APPEND SRC ./src/trpc.c)
+  #LIST(APPEND SRC ./src/trpc.c)
-  LIST(APPEND SRC ./src/tstring.c)
+  #LIST(APPEND SRC ./src/tstring.c)
-  LIST(APPEND SRC ./src/tudp.c)
+  #LIST(APPEND SRC ./src/tudp.c)
+  AUX_SOURCE_DIRECTORY(src SRC)
 ELSEIF (TD_WINDOWS_64)
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/pthread)
   LIST(APPEND SRC ./src/thaship.c)

src/rpc/src/rpcUdp.c

@@ -242,7 +242,7 @@ int taosSendUdpData(uint32_t ip, uint16_t port, void *data, int dataLen, void *c
   destAdd.sin_addr.s_addr = ip;
   destAdd.sin_port = htons(port);
 
-  int ret = (int)sendto(pConn->fd, data, (size_t)dataLen, 0, (struct sockaddr *)&destAdd, sizeof(destAdd));
+  int ret = (int)taosSendto(pConn->fd, data, (size_t)dataLen, 0, (struct sockaddr *)&destAdd, sizeof(destAdd));
 
   return ret;
 }

src/rpc/test/CMakeLists.txt

@@ -1,13 +1,13 @@
 CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
 PROJECT(TDengine)
 
-IF ((TD_LINUX_64) OR (TD_LINUX_32 AND TD_ARM))
+INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/inc)
-  INCLUDE_DIRECTORIES(${TD_OS_DIR}/inc)
+INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/os/inc)
-  INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/inc)
+INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/util/inc)
-  INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/util/inc)
+INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/common/inc)
-  INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/common/inc)
+INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/rpc/inc)
-  INCLUDE_DIRECTORIES(../inc)
 
+IF ((TD_LINUX_64) OR (TD_LINUX_32 AND TD_ARM))
   LIST(APPEND CLIENT_SRC ./rclient.c)
   ADD_EXECUTABLE(rclient ${CLIENT_SRC})
   TARGET_LINK_LIBRARIES(rclient trpc)

src/tsdb/CMakeLists.txt

@@ -2,8 +2,8 @@ CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
 PROJECT(TDengine)
 
 IF ((TD_LINUX_64) OR (TD_LINUX_32 AND TD_ARM))
-  INCLUDE_DIRECTORIES(${TD_OS_DIR}/inc)
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/inc)
+  INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/os/inc)
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/util/inc)
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/common/inc)
   # INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/vnode/common/inc)

src/tsdb/src/tsdbFile.c

@@ -12,23 +12,14 @@
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
-#include <dirent.h>
+#define _DEFAULT_SOURCE
-#include <fcntl.h>
+#include "os.h"
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <unistd.h>
-#include <libgen.h>
 
 #include "talgo.h"
 #include "tchecksum.h"
 #include "tsdbMain.h"
 #include "tutil.h"
 #include "ttime.h"
-#include "tfile.h"
 
 #ifdef TSDB_IDX
 const char *tsdbFileSuffix[] = {".idx", ".head", ".data", ".last", "", ".i", ".h", ".l"};
@@ -317,7 +308,7 @@ int tsdbUpdateFileHeader(SFile *pFile, uint32_t version) {
     terrno = TAOS_SYSTEM_ERROR(errno);
     return -1;
   }
-  if (twrite(pFile->fd, (void *)buf, TSDB_FILE_HEAD_SIZE) < TSDB_FILE_HEAD_SIZE) {
+  if (taosTWrite(pFile->fd, (void *)buf, TSDB_FILE_HEAD_SIZE) < TSDB_FILE_HEAD_SIZE) {
     tsdbError("failed to write %d bytes to file %s since %s", TSDB_FILE_HEAD_SIZE, pFile->fname, strerror(errno));
     terrno = TAOS_SYSTEM_ERROR(errno);
     return -1;
@@ -383,7 +374,7 @@ static int tsdbInitFile(SFile *pFile, STsdbRepo *pRepo, int fid, int type) {
   pFile->fd = -1;
   if (tsdbOpenFile(pFile, O_RDONLY) < 0) goto _err;
 
-  if (tread(pFile->fd, buf, TSDB_FILE_HEAD_SIZE) < TSDB_FILE_HEAD_SIZE) {
+  if (taosTRead(pFile->fd, buf, TSDB_FILE_HEAD_SIZE) < TSDB_FILE_HEAD_SIZE) {
     tsdbError("vgId:%d failed to read %d bytes from file %s since %s", REPO_ID(pRepo), TSDB_FILE_HEAD_SIZE,
               pFile->fname, strerror(errno));
     terrno = TAOS_SYSTEM_ERROR(errno);

src/tsdb/src/tsdbMain.c

@@ -545,7 +545,7 @@ static int32_t tsdbSaveConfig(char *rootDir, STsdbCfg *pCfg) {
 
   taosCalcChecksumAppend(0, (uint8_t *)buf, TSDB_FILE_HEAD_SIZE);
 
-  if (twrite(fd, (void *)buf, TSDB_FILE_HEAD_SIZE) < TSDB_FILE_HEAD_SIZE) {
+  if (taosTWrite(fd, (void *)buf, TSDB_FILE_HEAD_SIZE) < TSDB_FILE_HEAD_SIZE) {
     tsdbError("vgId:%d failed to write %d bytes to file %s since %s", pCfg->tsdbId, TSDB_FILE_HEAD_SIZE, fname,
               strerror(errno));
     terrno = TAOS_SYSTEM_ERROR(errno);
@@ -586,7 +586,7 @@ static int tsdbLoadConfig(char *rootDir, STsdbCfg *pCfg) {
     goto _err;
   }
 
-  if (tread(fd, (void *)buf, TSDB_FILE_HEAD_SIZE) < TSDB_FILE_HEAD_SIZE) {
+  if (taosTRead(fd, (void *)buf, TSDB_FILE_HEAD_SIZE) < TSDB_FILE_HEAD_SIZE) {
     tsdbError("failed to read %d bytes from file %s since %s", TSDB_FILE_HEAD_SIZE, fname, strerror(errno));
     terrno = TAOS_SYSTEM_ERROR(errno);
     goto _err;

src/tsdb/src/tsdbRWHelper.c

@@ -13,13 +13,13 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#define _DEFAULT_SOURCE
 #include "os.h"
 #include "talgo.h"
 #include "tchecksum.h"
 #include "tcoding.h"
 #include "tscompression.h"
 #include "tsdbMain.h"
-#include "tfile.h"
 
 #define TSDB_GET_COMPCOL_LEN(nCols) (sizeof(SCompData) + sizeof(SCompCol) * (nCols) + sizeof(TSCKSUM))
 #define TSDB_KEY_COL_OFFSET 0
@@ -379,7 +379,7 @@ int tsdbMoveLastBlockIfNeccessary(SRWHelper *pHelper) {
         return -1;
       }
 
-      if (tsendfile(helperNewLastF(pHelper)->fd, helperLastF(pHelper)->fd, NULL, pCompBlock->len) < pCompBlock->len) {
+      if (taosTSendFile(helperNewLastF(pHelper)->fd, helperLastF(pHelper)->fd, NULL, pCompBlock->len) < pCompBlock->len) {
         tsdbError("vgId:%d failed to sendfile from file %s to file %s since %s", REPO_ID(pHelper->pRepo),
                   helperLastF(pHelper)->fname, helperNewLastF(pHelper)->fname, strerror(errno));
         terrno = TAOS_SYSTEM_ERROR(errno);
@@ -424,7 +424,7 @@ int tsdbWriteCompInfo(SRWHelper *pHelper) {
     pIdx->tid = pHelper->tableInfo.tid;
     ASSERT(pIdx->offset >= TSDB_FILE_HEAD_SIZE);
 
-    if (twrite(pFile->fd, (void *)(pHelper->pCompInfo), pIdx->len) < pIdx->len) {
+    if (taosTWrite(pFile->fd, (void *)(pHelper->pCompInfo), pIdx->len) < pIdx->len) {
       tsdbError("vgId:%d failed to write %d bytes to file %s since %s", REPO_ID(pHelper->pRepo), pIdx->len,
                 pFile->fname, strerror(errno));
       terrno = TAOS_SYSTEM_ERROR(errno);
@@ -481,7 +481,7 @@ int tsdbWriteCompIdx(SRWHelper *pHelper) {
 
   pFile->info.offset = offset;
 
-  if (twrite(pFile->fd, (void *)pHelper->pWIdx, pFile->info.len) < pFile->info.len) {
+  if (taosTWrite(pFile->fd, (void *)pHelper->pWIdx, pFile->info.len) < pFile->info.len) {
     tsdbError("vgId:%d failed to write %d bytes to file %s since %s", REPO_ID(pHelper->pRepo), pFile->info.len,
               pFile->fname, strerror(errno));
     terrno = TAOS_SYSTEM_ERROR(errno);
@@ -514,7 +514,7 @@ int tsdbLoadCompIdx(SRWHelper *pHelper, void *target) {
         return -1;
       }
 
-      if (tread(fd, (void *)(pHelper->pBuffer), pFile->info.len) < pFile->info.len) {
+      if (taosTRead(fd, (void *)(pHelper->pBuffer), pFile->info.len) < pFile->info.len) {
         tsdbError("vgId:%d failed to read %d bytes from file %s since %s", REPO_ID(pHelper->pRepo), pFile->info.len,
                   pFile->fname, strerror(errno));
         terrno = TAOS_SYSTEM_ERROR(errno);
@@ -585,7 +585,7 @@ int tsdbLoadCompInfo(SRWHelper *pHelper, void *target) {
       }
 
       pHelper->pCompInfo = trealloc((void *)pHelper->pCompInfo, pIdx->len);
-      if (tread(fd, (void *)(pHelper->pCompInfo), pIdx->len) < pIdx->len) {
+      if (taosTRead(fd, (void *)(pHelper->pCompInfo), pIdx->len) < pIdx->len) {
         tsdbError("vgId:%d failed to read %d bytes from file %s since %s", REPO_ID(pHelper->pRepo), pIdx->len,
                   helperHeadF(pHelper)->fname, strerror(errno));
         terrno = TAOS_SYSTEM_ERROR(errno);
@@ -626,7 +626,7 @@ int tsdbLoadCompData(SRWHelper *pHelper, SCompBlock *pCompBlock, void *target) {
     return -1;
   }
 
-  if (tread(pFile->fd, (void *)pHelper->pCompData, tsize) < tsize) {
+  if (taosTRead(pFile->fd, (void *)pHelper->pCompData, tsize) < tsize) {
     tsdbError("vgId:%d failed to read %zu bytes from file %s since %s", REPO_ID(pHelper->pRepo), tsize, pFile->fname,
               strerror(errno));
     terrno = TAOS_SYSTEM_ERROR(errno);
@@ -841,7 +841,7 @@ static int tsdbWriteBlockToFile(SRWHelper *pHelper, SFile *pFile, SDataCols *pDa
                                        sizeof(TSCKSUM));
 
   // Write the whole block to file
-  if (twrite(pFile->fd, (void *)pCompData, lsize) < lsize) {
+  if (taosTWrite(pFile->fd, (void *)pCompData, lsize) < lsize) {
     tsdbError("vgId:%d failed to write %d bytes to file %s since %s", REPO_ID(helperRepo(pHelper)), lsize, pFile->fname,
               strerror(errno));
     terrno = TAOS_SYSTEM_ERROR(errno);
@@ -1222,7 +1222,7 @@ static int tsdbLoadColData(SRWHelper *pHelper, SFile *pFile, SCompBlock *pCompBl
     return -1;
   }
 
-  if (tread(pFile->fd, pHelper->pBuffer, pCompCol->len) < pCompCol->len) {
+  if (taosTRead(pFile->fd, pHelper->pBuffer, pCompCol->len) < pCompCol->len) {
     tsdbError("vgId:%d failed to read %d bytes from file %s since %s", REPO_ID(pHelper->pRepo), pCompCol->len, pFile->fname,
               strerror(errno));
     terrno = TAOS_SYSTEM_ERROR(errno);
@@ -1337,7 +1337,7 @@ static int tsdbLoadBlockDataImpl(SRWHelper *pHelper, SCompBlock *pCompBlock, SDa
     terrno = TAOS_SYSTEM_ERROR(errno);
     goto _err;
   }
-  if (tread(fd, (void *)pCompData, pCompBlock->len) < pCompBlock->len) {
+  if (taosTRead(fd, (void *)pCompData, pCompBlock->len) < pCompBlock->len) {
     tsdbError("vgId:%d failed to read %d bytes from file %s since %s", REPO_ID(pHelper->pRepo), pCompBlock->len,
               pFile->fname, strerror(errno));
     terrno = TAOS_SYSTEM_ERROR(errno);

src/util/CMakeLists.txt

@@ -1,8 +1,8 @@
 CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
 PROJECT(TDengine)
 
-INCLUDE_DIRECTORIES(${TD_OS_DIR}/inc)
 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/inc)
+INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/os/inc)
 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/util/inc)
 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/common/inc)
 
@@ -11,7 +11,7 @@ IF ((TD_LINUX_64) OR (TD_LINUX_32 AND TD_ARM))
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/lz4/inc)
   AUX_SOURCE_DIRECTORY(src SRC)
   ADD_LIBRARY(tutil ${SRC})
-  TARGET_LINK_LIBRARIES(tutil pthread os m rt lz4)
+  TARGET_LINK_LIBRARIES(tutil pthread osdetail m rt lz4)
   FIND_PATH(ICONV_INCLUDE_EXIST iconv.h /usr/include/ /usr/local/include/)
   IF (ICONV_INCLUDE_EXIST)
     ADD_DEFINITIONS(-DUSE_LIBICONV)
@@ -68,44 +68,12 @@ ELSEIF (TD_WINDOWS_64)
   LIST(APPEND SRC ./src/tutil.c)
   LIST(APPEND SRC ./src/version.c)
   ADD_LIBRARY(tutil ${SRC}) 
-  TARGET_LINK_LIBRARIES(tutil iconv regex pthread os winmm IPHLPAPI ws2_32 lz4)
+  TARGET_LINK_LIBRARIES(tutil iconv regex pthread osdetail winmm IPHLPAPI ws2_32 lz4)
 ELSEIF(TD_DARWIN_64)
   ADD_DEFINITIONS(-DUSE_LIBICONV)
-  LIST(APPEND SRC ./src/hash.c)
+  AUX_SOURCE_DIRECTORY(src SRC)
-  LIST(APPEND SRC ./src/ihash.c)
-  LIST(APPEND SRC ./src/lz4.c)
-  LIST(APPEND SRC ./src/shash.c)
-  LIST(APPEND SRC ./src/tbase64.c)
-  LIST(APPEND SRC ./src/tcache.c)
-  LIST(APPEND SRC ./src/tcompression.c)
-  LIST(APPEND SRC ./src/textbuffer.c)
-  LIST(APPEND SRC ./src/tglobalcfg.c)
-  LIST(APPEND SRC ./src/thash.c)
-  LIST(APPEND SRC ./src/thashutil.c)
-  LIST(APPEND SRC ./src/thistogram.c)
-  LIST(APPEND SRC ./src/tidpool.c)
-  LIST(APPEND SRC ./src/tinterpolation.c)
-  LIST(APPEND SRC ./src/tlog.c)
-  LIST(APPEND SRC ./src/tlosertree.c)
-  LIST(APPEND SRC ./src/tmd5.c)
-  LIST(APPEND SRC ./src/tmem.c)
-  LIST(APPEND SRC ./src/tmempool.c)
-  LIST(APPEND SRC ./src/tmodule.c)
-  LIST(APPEND SRC ./src/tnote.c)
-  LIST(APPEND SRC ./src/tpercentile.c)
-  LIST(APPEND SRC ./src/tsched.c)
-  LIST(APPEND SRC ./src/tskiplist.c)
-  LIST(APPEND SRC ./src/tsocket.c)
-  LIST(APPEND SRC ./src/tstrbuild.c)
-  LIST(APPEND SRC ./src/ttime.c)
-  LIST(APPEND SRC ./src/ttimer.c)
-  LIST(APPEND SRC ./src/ttokenizer.c)
-  LIST(APPEND SRC ./src/ttypes.c)
-  LIST(APPEND SRC ./src/tutil.c)
-  LIST(APPEND SRC ./src/version.c)
-  LIST(APPEND SRC ./src/hash.c)
   ADD_LIBRARY(tutil ${SRC})
-  TARGET_LINK_LIBRARIES(tutil iconv pthread os lz4)
+  TARGET_LINK_LIBRARIES(tutil iconv pthread osdetail lz4)
 ENDIF()
 
 #  TARGET_LINK_LIBRARIES(tutil mstorage)

src/util/inc/talgo.h

@@ -20,6 +20,8 @@
 extern "C" {
 #endif
 
+#include "os.h"
+
 #define TD_EQ 0x1
 #define TD_GT 0x2
 #define TD_LT 0x4

src/util/inc/tutil.h

@@ -143,8 +143,6 @@ char *strbetween(char *string, char *begin, char *end);
 
 char *paGetToken(char *src, char **token, int32_t *tokenLen);
 
-void taosMsleep(int32_t mseconds);
-
 int32_t taosByteArrayToHexStr(char bytes[], int32_t len, char hexstr[]);
 
 int32_t taosHexStrToByteArray(char hexstr[], char bytes[]);
@@ -225,6 +223,9 @@ ssize_t taos_getline(char **lineptr, size_t *n, FILE *stream, const char *file,
 
 #endif // TAOS_MEM_CHECK
 
+
+char *taosCharsetReplace(char *charsetstr);
+
 #ifdef __cplusplus
 }
 #endif

src/util/src/tbuffer.c

@@ -13,6 +13,7 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "os.h"
 #include <stdlib.h>
 #include <memory.h>
 #include <assert.h>

src/util/src/tcache.c

@@ -259,7 +259,7 @@ SCacheObj *taosCacheInit(int32_t keyType, int64_t refreshTimeInSeconds, bool ext
     return NULL;
   }
 
-  pthread_attr_t thattr = {{0}};
+  pthread_attr_t thattr;
   pthread_attr_init(&thattr);
   pthread_attr_setdetachstate(&thattr, PTHREAD_CREATE_JOINABLE);
 
@@ -288,7 +288,7 @@ void *taosCachePut(SCacheObj *pCacheObj, const void *key, size_t keyLen, const v
       uDebug("cache:%s, key:%p, %p added into cache, added:%" PRIu64 ", expire:%" PRIu64 ", totalNum:%d totalSize:%" PRId64
              "bytes size:%" PRId64 "bytes",
              pCacheObj->name, key, pNode->data, pNode->addedTime, pNode->expireTime,
-             (int32_t)taosHashGetSize(pCacheObj->pHashTable), pCacheObj->totalSize, dataSize);
+             (int32_t)taosHashGetSize(pCacheObj->pHashTable), pCacheObj->totalSize, (int64_t)dataSize);
     } else {
       uError("cache:%s, key:%p, failed to added into cache, out of memory", pCacheObj->name, key);
     }

src/util/src/tkvstore.c

@@ -12,22 +12,15 @@
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
-#include <errno.h>
-#include <fcntl.h>
-#include <libgen.h>
-#include <string.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <unistd.h>
 
-#include "hash.h"
+#define _DEFAULT_SOURCE
 #include "os.h"
+#include "hash.h"
 #include "taoserror.h"
 #include "tchecksum.h"
 #include "tcoding.h"
 #include "tkvstore.h"
 #include "tulog.h"
-#include "tfile.h"
 
 #define TD_KVSTORE_HEADER_SIZE 512
 #define TD_KVSTORE_MAJOR_VERSION 1
@@ -182,7 +175,7 @@ int tdKVStoreStartCommit(SKVStore *pStore) {
     goto _err;
   }
 
-  if (tsendfile(pStore->sfd, pStore->fd, NULL, TD_KVSTORE_HEADER_SIZE) < TD_KVSTORE_HEADER_SIZE) {
+  if (taosTSendFile(pStore->sfd, pStore->fd, NULL, TD_KVSTORE_HEADER_SIZE) < TD_KVSTORE_HEADER_SIZE) {
     uError("failed to send file %d bytes since %s", TD_KVSTORE_HEADER_SIZE, strerror(errno));
     terrno = TAOS_SYSTEM_ERROR(errno);
     goto _err;
@@ -242,13 +235,13 @@ int tdUpdateKVStoreRecord(SKVStore *pStore, uint64_t uid, void *cont, int contLe
   ASSERT(tlen == POINTER_DISTANCE(pBuf, buf));
   ASSERT(tlen == sizeof(SKVRecord));
 
-  if (twrite(pStore->fd, buf, tlen) < tlen) {
+  if (taosTWrite(pStore->fd, buf, tlen) < tlen) {
     uError("failed to write %d bytes to file %s since %s", tlen, pStore->fname, strerror(errno));
     terrno = TAOS_SYSTEM_ERROR(errno);
     return -1;
   }
 
-  if (twrite(pStore->fd, cont, contLen) < contLen) {
+  if (taosTWrite(pStore->fd, cont, contLen) < contLen) {
     uError("failed to write %d bytes to file %s since %s", contLen, pStore->fname, strerror(errno));
     return -1;
   }
@@ -286,8 +279,8 @@ int tdDropKVStoreRecord(SKVStore *pStore, uint64_t uid) {
   void *pBuf = buf;
   tdEncodeKVRecord(&pBuf, &rInfo);
 
-  if (twrite(pStore->fd, buf, POINTER_DISTANCE(pBuf, buf)) < POINTER_DISTANCE(pBuf, buf)) {
+  if (taosTWrite(pStore->fd, buf, POINTER_DISTANCE(pBuf, buf)) < POINTER_DISTANCE(pBuf, buf)) {
-    uError("failed to write %" PRId64 " bytes to file %s since %s", POINTER_DISTANCE(pBuf, buf), pStore->fname, strerror(errno));
+    uError("failed to write %" PRId64 " bytes to file %s since %s", (int64_t)(POINTER_DISTANCE(pBuf, buf)), pStore->fname, strerror(errno));
     terrno = TAOS_SYSTEM_ERROR(errno);
     return -1;
   }
@@ -335,7 +328,7 @@ static int tdLoadKVStoreHeader(int fd, char *fname, SStoreInfo *pInfo) {
     return -1;
   }
 
-  if (tread(fd, buf, TD_KVSTORE_HEADER_SIZE) < TD_KVSTORE_HEADER_SIZE) {
+  if (taosTRead(fd, buf, TD_KVSTORE_HEADER_SIZE) < TD_KVSTORE_HEADER_SIZE) {
     uError("failed to read %d bytes from file %s since %s", TD_KVSTORE_HEADER_SIZE, fname, strerror(errno));
     terrno = TAOS_SYSTEM_ERROR(errno);
     return -1;
@@ -366,7 +359,7 @@ static int tdUpdateKVStoreHeader(int fd, char *fname, SStoreInfo *pInfo) {
   ASSERT(POINTER_DISTANCE(pBuf, buf) + sizeof(TSCKSUM) <= TD_KVSTORE_HEADER_SIZE);
 
   taosCalcChecksumAppend(0, (uint8_t *)buf, TD_KVSTORE_HEADER_SIZE);
-  if (twrite(fd, buf, TD_KVSTORE_HEADER_SIZE) < TD_KVSTORE_HEADER_SIZE) {
+  if (taosTWrite(fd, buf, TD_KVSTORE_HEADER_SIZE) < TD_KVSTORE_HEADER_SIZE) {
     uError("failed to write %d bytes to file %s since %s", TD_KVSTORE_HEADER_SIZE, fname, strerror(errno));
     terrno = TAOS_SYSTEM_ERROR(errno);
     return -1;
@@ -499,7 +492,7 @@ static int tdRestoreKVStore(SKVStore *pStore) {
   ASSERT(pStore->info.size == TD_KVSTORE_HEADER_SIZE);
 
   while (true) {
-    ssize_t tsize = tread(pStore->fd, tbuf, sizeof(SKVRecord));
+    ssize_t tsize = taosTRead(pStore->fd, tbuf, sizeof(SKVRecord));
     if (tsize == 0) break;
     if (tsize < sizeof(SKVRecord)) {
       uError("failed to read %zu bytes from file %s at offset %" PRId64 "since %s", sizeof(SKVRecord), pStore->fname,
@@ -562,7 +555,7 @@ static int tdRestoreKVStore(SKVStore *pStore) {
       goto _err;
     }
 
-    if (tread(pStore->fd, buf, pRecord->size) < pRecord->size) {
+    if (taosTRead(pStore->fd, buf, pRecord->size) < pRecord->size) {
       uError("failed to read %" PRId64 " bytes from file %s since %s, offset %" PRId64, pRecord->size, pStore->fname,
              strerror(errno), pRecord->offset);
       terrno = TAOS_SYSTEM_ERROR(errno);

src/util/src/tlog.c

@@ -301,11 +301,11 @@ static int32_t taosOpenLogFile(char *fn, int32_t maxLines, int32_t maxFileNum) {
   lseek(tsLogObj.logHandle->fd, 0, SEEK_END);
 
   sprintf(name, "==================================================\n");
-  twrite(tsLogObj.logHandle->fd, name, (uint32_t)strlen(name));
+  taosTWrite(tsLogObj.logHandle->fd, name, (uint32_t)strlen(name));
   sprintf(name, "                new log file                      \n");
-  twrite(tsLogObj.logHandle->fd, name, (uint32_t)strlen(name));
+  taosTWrite(tsLogObj.logHandle->fd, name, (uint32_t)strlen(name));
   sprintf(name, "==================================================\n");
-  twrite(tsLogObj.logHandle->fd, name, (uint32_t)strlen(name));
+  taosTWrite(tsLogObj.logHandle->fd, name, (uint32_t)strlen(name));
 
   return 0;
 }
@@ -355,7 +355,7 @@ void taosPrintLog(const char *flags, int32_t dflag, const char *format, ...) {
     if (tsAsyncLog) {
       taosPushLogBuffer(tsLogObj.logHandle, buffer, len);
     } else {
-      twrite(tsLogObj.logHandle->fd, buffer, len);
+      taosTWrite(tsLogObj.logHandle->fd, buffer, len);
     }
 
     if (tsLogObj.maxLines > 0) {
@@ -365,7 +365,7 @@ void taosPrintLog(const char *flags, int32_t dflag, const char *format, ...) {
     }
   }
 
-  if (dflag & DEBUG_SCREEN) twrite(1, buffer, (uint32_t)len);
+  if (dflag & DEBUG_SCREEN) taosTWrite(1, buffer, (uint32_t)len);
 }
 
 void taosDumpData(unsigned char *msg, int32_t len) {
@@ -384,7 +384,7 @@ void taosDumpData(unsigned char *msg, int32_t len) {
     pos += 3;
     if (c >= 16) {
       temp[pos++] = '\n';
-      twrite(tsLogObj.logHandle->fd, temp, (uint32_t)pos);
+      taosTWrite(tsLogObj.logHandle->fd, temp, (uint32_t)pos);
       c = 0;
       pos = 0;
     }
@@ -392,7 +392,7 @@ void taosDumpData(unsigned char *msg, int32_t len) {
 
   temp[pos++] = '\n';
 
-  twrite(tsLogObj.logHandle->fd, temp, (uint32_t)pos);
+  taosTWrite(tsLogObj.logHandle->fd, temp, (uint32_t)pos);
 
   return;
 }
@@ -432,7 +432,7 @@ void taosPrintLongString(const char *flags, int32_t dflag, const char *format, .
     if (tsAsyncLog) {
       taosPushLogBuffer(tsLogObj.logHandle, buffer, len);
     } else {
-      twrite(tsLogObj.logHandle->fd, buffer, len);
+      taosTWrite(tsLogObj.logHandle->fd, buffer, len);
     }
     
     if (tsLogObj.maxLines > 0) {
@@ -442,7 +442,7 @@ void taosPrintLongString(const char *flags, int32_t dflag, const char *format, .
     }
   }
 
-  if (dflag & DEBUG_SCREEN) twrite(1, buffer, (uint32_t)len);
+  if (dflag & DEBUG_SCREEN) taosTWrite(1, buffer, (uint32_t)len);
 }
 
 #if 0
@@ -571,7 +571,7 @@ static void *taosAsyncOutputLog(void *param) {
     while (1) {
       log_size = taosPollLogBuffer(tLogBuff, tempBuffer, TSDB_DEFAULT_LOG_BUF_UNIT);
       if (log_size) {
-        twrite(tLogBuff->fd, tempBuffer, log_size);
+        taosTWrite(tLogBuff->fd, tempBuffer, log_size);
         LOG_BUF_START(tLogBuff) = (LOG_BUF_START(tLogBuff) + log_size) % LOG_BUF_SIZE(tLogBuff);
       } else {
         break;

src/util/src/tnote.c

@@ -264,7 +264,7 @@ void taosNotePrint(taosNoteInfo * pNote, const char * const format, ...)
     buffer[len] = 0;
 
     if (pNote->taosNoteFd >= 0)  {
-        twrite(pNote->taosNoteFd, buffer, (unsigned int)len);
+        taosTWrite(pNote->taosNoteFd, buffer, (unsigned int)len);
 
         if (pNote->taosNoteMaxLines > 0) {
             pNote->taosNoteLines++;

src/util/src/tsocket.c

@@ -164,7 +164,7 @@ int taosNonblockwrite(int fd, char *ptr, int nbytes) {
       return -1;
     }
 
-    nwritten = (int)send(fd, ptr, (size_t)nleft, MSG_NOSIGNAL);
+    nwritten = (int)taosSend(fd, ptr, (size_t)nleft, MSG_NOSIGNAL);
     if (nwritten <= 0) {
       if (errno == EAGAIN || errno == EINTR) continue;
 

src/vnode/CMakeLists.txt

@@ -2,8 +2,8 @@ CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
 PROJECT(TDengine)
 
 IF ((TD_LINUX_64) OR (TD_LINUX_32 AND TD_ARM))
-  INCLUDE_DIRECTORIES(${TD_OS_DIR}/inc)
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/inc)
+  INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/os/inc)
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/util/inc)
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/query/inc)
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/tsdb/inc)

src/vnode/src/vnodeMain.c

@@ -46,15 +46,6 @@ static int      vnodeGetWalInfo(void *ahandle, char *name, uint32_t *index);
 static void     vnodeNotifyRole(void *ahandle, int8_t role);
 static int      vnodeNotifyFileSynced(void *ahandle, uint64_t fversion);
 
-#ifndef _SYNC
-tsync_h syncStart(const SSyncInfo *info) { return NULL; }
-int32_t syncForwardToPeer(tsync_h shandle, void *pHead, void *mhandle, int qtype) { return 0; }
-void    syncStop(tsync_h shandle) {}
-int32_t syncReconfig(tsync_h shandle, const SSyncCfg * cfg) { return 0; }
-int     syncGetNodesRole(tsync_h shandle, SNodesRole * cfg) { return 0; }
-void    syncConfirmForward(tsync_h shandle, uint64_t version, int32_t code) {}
-#endif
-
 int32_t vnodeInitResources() {
   vnodeInitWriteFp();
   vnodeInitReadFp();
@@ -289,14 +280,10 @@ int32_t vnodeOpen(int32_t vnode, char *rootDir) {
   syncInfo.notifyFileSynced = vnodeNotifyFileSynced;
   pVnode->sync = syncStart(&syncInfo);
 
-#ifndef _SYNC
-  pVnode->role = TAOS_SYNC_ROLE_MASTER;
-#else
   if (pVnode->sync == NULL) {
     vnodeCleanUp(pVnode);
     return terrno;
   }
-#endif
 
   pVnode->qMgmt = qOpenQueryMgmt(pVnode->vgId);
   pVnode->events = NULL;

src/wal/CMakeLists.txt

@@ -1,9 +1,9 @@
 CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
 PROJECT(TDengine)
 
-INCLUDE_DIRECTORIES(${TD_OS_DIR}/inc)
 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/inc)
-INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/util/inc)
+INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/os/inc)
+  INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/util/inc)
 INCLUDE_DIRECTORIES(inc)
 
 AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/src SRC)

src/wal/src/walMain.c

@@ -13,14 +13,7 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <stdint.h>
+#define _DEFAULT_SOURCE
-#include <stdio.h>
-#include <stdlib.h>
-#include <sys/types.h>
-#include <dirent.h>
-#include <unistd.h>
-#include <fcntl.h> 
-
 #include "os.h"
 #include "tlog.h"
 #include "tchecksum.h"
@@ -29,7 +22,6 @@
 #include "taoserror.h"
 #include "twal.h"
 #include "tqueue.h"
-#include "tfile.h"
 
 #define walPrefix "wal"
 
@@ -214,7 +206,7 @@ int walWrite(void *handle, SWalHead *pHead) {
   taosCalcChecksumAppend(0, (uint8_t *)pHead, sizeof(SWalHead));
   int contLen = pHead->len + sizeof(SWalHead);
 
-  if(twrite(pWal->fd, pHead, contLen) != contLen) {
+  if(taosTWrite(pWal->fd, pHead, contLen) != contLen) {
     wError("wal:%s, failed to write(%s)", pWal->name, strerror(errno));
     terrno = TAOS_SYSTEM_ERROR(errno);
   } else {
@@ -373,7 +365,7 @@ static int walRestoreWalFile(SWal *pWal, void *pVnode, FWalWrite writeFp) {
   wDebug("wal:%s, start to restore", name);
 
   while (1) {
-    int ret = tread(fd, pHead, sizeof(SWalHead));
+    int ret = taosTRead(fd, pHead, sizeof(SWalHead));
     if ( ret == 0)  break;  
 
     if (ret != sizeof(SWalHead)) {
@@ -388,7 +380,7 @@ static int walRestoreWalFile(SWal *pWal, void *pVnode, FWalWrite writeFp) {
       break;
     } 
 
-    ret = tread(fd, pHead->cont, pHead->len);
+    ret = taosTRead(fd, pHead->cont, pHead->len);
     if ( ret != pHead->len) {
       wWarn("wal:%s, failed to read body, skip, len:%d ret:%d", name, pHead->len, ret);
       terrno = TAOS_SYSTEM_ERROR(errno);

src/wal/test/CMakeLists.txt

@@ -2,8 +2,8 @@ CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
 PROJECT(TDengine)
 
 IF ((TD_LINUX_64) OR (TD_LINUX_32 AND TD_ARM))
-  INCLUDE_DIRECTORIES(${TD_OS_DIR}/inc)
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/inc)
+  INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/os/inc)
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/util/inc)
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/common/inc)
   INCLUDE_DIRECTORIES(../inc)