Merge branch 'develop' into feature/TD-4034

cmake/define.inc

@@ -57,7 +57,7 @@ IF (TD_LINUX_64)
   ADD_DEFINITIONS(-D_M_X64)
   ADD_DEFINITIONS(-D_TD_LINUX_64)
   MESSAGE(STATUS "linux64 is defined")
-  SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -fPIC -gdwarf-2 -msse4.2 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
+  SET(COMMON_FLAGS "-Wall -Werror -fPIC -gdwarf-2 -msse4.2 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
   ADD_DEFINITIONS(-DUSE_LIBICONV)
 ENDIF ()
 
@@ -65,7 +65,7 @@ IF (TD_LINUX_32)
   ADD_DEFINITIONS(-D_TD_LINUX_32)
   ADD_DEFINITIONS(-DUSE_LIBICONV)
   MESSAGE(STATUS "linux32 is defined")
-  SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -fPIC -fsigned-char -munaligned-access -fpack-struct=8 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
+  SET(COMMON_FLAGS "-Wall -Werror -fPIC -fsigned-char -munaligned-access -fpack-struct=8 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
 ENDIF ()
 
 IF (TD_ARM_64)
@@ -73,7 +73,7 @@ IF (TD_ARM_64)
   ADD_DEFINITIONS(-D_TD_ARM_)
   ADD_DEFINITIONS(-DUSE_LIBICONV)
   MESSAGE(STATUS "arm64 is defined")
-  SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -fPIC -fsigned-char -fpack-struct=8 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
+  SET(COMMON_FLAGS "-Wall -Werror -fPIC -fsigned-char -fpack-struct=8 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
 ENDIF ()
 
 IF (TD_ARM_32)
@@ -81,7 +81,7 @@ IF (TD_ARM_32)
   ADD_DEFINITIONS(-D_TD_ARM_)
   ADD_DEFINITIONS(-DUSE_LIBICONV)
   MESSAGE(STATUS "arm32 is defined")
-  SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -fPIC -fsigned-char -fpack-struct=8 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE -Wno-pointer-to-int-cast -Wno-int-to-pointer-cast -Wno-incompatible-pointer-types ")
+  SET(COMMON_FLAGS "-Wall -Werror -fPIC -fsigned-char -fpack-struct=8 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE -Wno-pointer-to-int-cast -Wno-int-to-pointer-cast -Wno-incompatible-pointer-types ")
 ENDIF ()
 
 IF (TD_MIPS_64)
@@ -89,7 +89,7 @@ IF (TD_MIPS_64)
   ADD_DEFINITIONS(-D_TD_MIPS_64)
   ADD_DEFINITIONS(-DUSE_LIBICONV)
   MESSAGE(STATUS "mips64 is defined")
-  SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -fPIC -fsigned-char -fpack-struct=8 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
+  SET(COMMON_FLAGS "-Wall -Werror -fPIC -fsigned-char -fpack-struct=8 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
 ENDIF ()
 
 IF (TD_MIPS_32)
@@ -97,7 +97,7 @@ IF (TD_MIPS_32)
   ADD_DEFINITIONS(-D_TD_MIPS_32)
   ADD_DEFINITIONS(-DUSE_LIBICONV)
   MESSAGE(STATUS "mips32 is defined")
-  SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -fPIC -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
+  SET(COMMON_FLAGS "-Wall -Werror -fPIC -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
 ENDIF ()
 
 IF (TD_APLHINE)
@@ -138,7 +138,7 @@ IF (TD_DARWIN_64)
   ADD_DEFINITIONS(-D_REENTRANT -D__USE_POSIX -D_LIBC_REENTRANT)
   ADD_DEFINITIONS(-DUSE_LIBICONV)
   MESSAGE(STATUS "darwin64 is defined")
-  SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -Wno-missing-braces -fPIC -msse4.2 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
+  SET(COMMON_FLAGS "-Wall -Werror -Wno-missing-braces -fPIC -msse4.2 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
   SET(DEBUG_FLAGS "-O0 -g3 -DDEBUG")
   SET(RELEASE_FLAGS "-Og")
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/cJson/inc)

cmake/env.inc

@@ -32,6 +32,7 @@ ENDIF ()
 #
 
 # Set compiler options
+SET(COMMON_C_FLAGS "${COMMON_FLAGS} -std=gnu99")
 SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} ${COMMON_FLAGS} ${DEBUG_FLAGS}")
 SET(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${COMMON_FLAGS} ${RELEASE_FLAGS}")
 

documentation20/cn/06.queries/docs.md

@@ -12,7 +12,7 @@ TDengine 采用 SQL 作为查询语言。应用程序可以通过 C/C++, Java, G
 - 时间戳对齐的连接查询（Join Query: 隐式连接）操作
 - 多种聚合/计算函数: count, max, min, avg, sum, twa, stddev, leastsquares, top, bottom, first, last, percentile, apercentile, last_row, spread, diff等
 
-例如：在TAOS Shell中，从表d1001中查询出vlotage > 215的记录，按时间降序排列，仅仅输出2条。
+例如：在TAOS Shell中，从表d1001中查询出voltage > 215的记录，按时间降序排列，仅仅输出2条。
 ```mysql
 taos> select * from d1001 where voltage > 215 order by ts desc limit 2;
            ts            |       current        |   voltage   |        phase         |

src/client/src/tscParseInsert.c

@@ -68,7 +68,7 @@ int tsParseTime(SStrToken *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 = tsosStr2int64(pToken->z);
+    useconds = taosStr2int64(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/tscSQLParser.c

@@ -64,7 +64,7 @@ static char*   getAccountId(SSqlObj* pSql);
 
 static bool has(SArray* pFieldList, int32_t startIdx, const char* name);
 static char* cloneCurrentDBName(SSqlObj* pSql);
-static bool hasSpecifyDB(SStrToken* pTableName);
+static int32_t getDelimiterIndex(SStrToken* pTableName);
 static bool validateTableColumnInfo(SArray* pFieldList, SSqlCmd* pCmd);
 static bool validateTagParams(SArray* pTagsList, SArray* pFieldList, SSqlCmd* pCmd);
 
@@ -427,17 +427,12 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
 
     case TSDB_SQL_DESCRIBE_TABLE: {
       const char* msg1 = "invalid table name";
-      const char* msg2 = "table name too long";
 
       SStrToken* pToken = taosArrayGet(pInfo->pMiscInfo->a, 0);
       if (tscValidateName(pToken) != TSDB_CODE_SUCCESS) {
         return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
       }
 
-      if (!tscValidateTableNameLength(pToken->n)) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
-      }
-
       // additional msg has been attached already
       code = tscSetTableFullName(pTableMetaInfo, pToken, pSql);
       if (code != TSDB_CODE_SUCCESS) {
@@ -448,17 +443,12 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
     }
     case TSDB_SQL_SHOW_CREATE_TABLE: {
       const char* msg1 = "invalid table name";
-      const char* msg2 = "table name is too long";
 
       SStrToken* pToken = taosArrayGet(pInfo->pMiscInfo->a, 0);
       if (tscValidateName(pToken) != TSDB_CODE_SUCCESS) {
         return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
       }
 
-      if (!tscValidateTableNameLength(pToken->n)) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
-      }
-
       code = tscSetTableFullName(pTableMetaInfo, pToken, pSql);
       if (code != TSDB_CODE_SUCCESS) {
         return code;
@@ -983,11 +973,14 @@ int32_t tscSetTableFullName(STableMetaInfo* pTableMetaInfo, SStrToken* pTableNam
   const char* msg1 = "name too long";
   const char* msg2 = "acctId too long";
   const char* msg3 = "no acctId";
+  const char* msg4 = "db name too long";
+  const char* msg5 = "table name too long";
+  
 
   SSqlCmd* pCmd = &pSql->cmd;
   int32_t  code = TSDB_CODE_SUCCESS;
-
+  int32_t idx = getDelimiterIndex(pTableName); 
-  if (hasSpecifyDB(pTableName)) { // db has been specified in sql string so we ignore current db path
+  if (idx != -1) { // db has been specified in sql string so we ignore current db path
     char* acctId = getAccountId(pSql);
     if (acctId == NULL || strlen(acctId) <= 0) {
       return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
@@ -997,6 +990,13 @@ int32_t tscSetTableFullName(STableMetaInfo* pTableMetaInfo, SStrToken* pTableNam
     if (code != 0) {
       return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
     }
+    if (idx >= TSDB_DB_NAME_LEN) { 
+      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);
+    }
+   
+    if (pTableName->n - 1 - idx >= TSDB_TABLE_NAME_LEN) {
+       return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg5);
+    }
     
     char name[TSDB_TABLE_FNAME_LEN] = {0};
     strncpy(name, pTableName->z, pTableName->n);
@@ -1341,14 +1341,13 @@ static char* cloneCurrentDBName(SSqlObj* pSql) {
 }
 
 /* length limitation, strstr cannot be applied */
-static bool hasSpecifyDB(SStrToken* pTableName) {
+static int32_t getDelimiterIndex(SStrToken* pTableName) {
   for (uint32_t i = 0; i < pTableName->n; ++i) {
     if (pTableName->z[i] == TS_PATH_DELIMITER[0]) {
-      return true;
+      return i;
     }
   }
-
+  return -1;
-  return false;
 }
 
 int32_t setObjFullName(char* fullName, const char* account, SStrToken* pDB, SStrToken* tableName, int32_t* xlen) {

src/common/inc/tdataformat.h

@@ -15,10 +15,7 @@
 #ifndef _TD_DATA_FORMAT_H_
 #define _TD_DATA_FORMAT_H_
 
-#include <stdint.h>
+#include "os.h"
-#include <stdlib.h>
-#include <string.h>
-
 #include "talgo.h"
 #include "ttype.h"
 #include "tutil.h"

src/common/inc/tglobal.h

@@ -44,6 +44,7 @@ extern int32_t  tsDnodeId;
 // common
 extern int      tsRpcTimer;
 extern int      tsRpcMaxTime;
+extern int      tsRpcForceTcp; // all commands go to tcp protocol if this is enabled
 extern int32_t  tsMaxConnections;
 extern int32_t  tsMaxShellConns;
 extern int32_t  tsShellActivityTimer;

src/common/src/tglobal.c

@@ -48,6 +48,7 @@ int32_t  tsDnodeId = 0;
 // common
 int32_t tsRpcTimer       = 1000;
 int32_t tsRpcMaxTime     = 600;  // seconds;
+int32_t tsRpcForceTcp    = 0;  //disable this, means query, show command use udp protocol as default
 int32_t tsMaxShellConns  = 50000;
 int32_t tsMaxConnections = 5000;
 int32_t tsShellActivityTimer  = 3;  // second
@@ -625,6 +626,16 @@ static void doInitGlobalConfig(void) {
   cfg.unitType = TAOS_CFG_UTYPE_MS;
   taosInitConfigOption(cfg);
 
+  cfg.option = "rpcForceTcp";
+  cfg.ptr = &tsRpcForceTcp;
+  cfg.valType = TAOS_CFG_VTYPE_INT32;
+  cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_CLIENT;
+  cfg.minValue = 0;
+  cfg.maxValue = 1;
+  cfg.ptrLength = 0;
+  cfg.unitType = TAOS_CFG_UTYPE_NONE;
+  taosInitConfigOption(cfg);
+
   cfg.option = "rpcMaxTime";
   cfg.ptr = &tsRpcMaxTime;
   cfg.valType = TAOS_CFG_VTYPE_INT32;

src/dnode/src/dnodeCfg.c

@@ -158,7 +158,7 @@ static int32_t dnodeWriteCfg() {
   len += snprintf(content + len, maxLen - len, "}\n");
 
   fwrite(content, 1, len, fp);
-  fsync(fileno(fp));
+  taosFsync(fileno(fp));
   fclose(fp);
   free(content);
   terrno = 0;

src/dnode/src/dnodeEps.c

@@ -277,7 +277,7 @@ static int32_t dnodeWriteEps() {
   len += snprintf(content + len, maxLen - len, "}\n");
 
   fwrite(content, 1, len, fp);
-  fsync(fileno(fp));
+  taosFsync(fileno(fp));
   fclose(fp);
   free(content);
   terrno = 0;

src/dnode/src/dnodeMInfos.c

@@ -286,7 +286,7 @@ static int32_t dnodeWriteMInfos() {
   len += snprintf(content + len, maxLen - len, "}\n");
 
   fwrite(content, 1, len, fp);
-  fsync(fileno(fp));
+  taosFsync(fileno(fp));
   fclose(fp);
   free(content);
   terrno = 0;

src/inc/taosdef.h

@@ -22,7 +22,6 @@ extern "C" {
 
 #include <stdint.h>
 #include <stdbool.h>
-#include "osDef.h"
 #include "taos.h"
 
 #define TSDB__packed

src/inc/ttype.h

@@ -5,6 +5,8 @@
 extern "C" {
 #endif
 
+#include <stdbool.h>
+#include <stdint.h>
 #include "taosdef.h"
 
 // ----------------- For variable data types such as TSDB_DATA_TYPE_BINARY and TSDB_DATA_TYPE_NCHAR

src/kit/shell/src/shellCheck.c

@@ -142,7 +142,7 @@ static void *shellCheckThreadFp(void *arg) {
     taos_free_result(pSql);
   }
 
-  fsync(fileno(fp));
+  taosFsync(fileno(fp));
   fclose(fp);
 
   return NULL;

src/kit/taosdemo/taosdemo.c

@@ -771,48 +771,49 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
       }
       arguments->sqlFile = argv[++i];
     } else if (strcmp(argv[i], "-q") == 0) {
-      if ((argc == i+1) ||
+      if ((argc == i+1)
-        (!isStringNumber(argv[i+1]))) {
+              || (!isStringNumber(argv[i+1]))) {
         printHelp();
         errorPrint("%s", "\n\t-q need a number following!\nQuery mode -- 0: SYNC, 1: ASYNC. Default is SYNC.\n");
         exit(EXIT_FAILURE);
       }
       arguments->query_mode = atoi(argv[++i]);
     } else if (strcmp(argv[i], "-T") == 0) {
-      if ((argc == i+1) ||
+      if ((argc == i+1)
-        (!isStringNumber(argv[i+1]))) {
+              || (!isStringNumber(argv[i+1]))) {
         printHelp();
         errorPrint("%s", "\n\t-T need a number following!\n");
         exit(EXIT_FAILURE);
       }
       arguments->num_of_threads = atoi(argv[++i]);
     } else if (strcmp(argv[i], "-i") == 0) {
-      if ((argc == i+1) ||
+      if ((argc == i+1)
-        (!isStringNumber(argv[i+1]))) {
+              || (!isStringNumber(argv[i+1]))) {
         printHelp();
         errorPrint("%s", "\n\t-i need a number following!\n");
         exit(EXIT_FAILURE);
       }
       arguments->insert_interval = atoi(argv[++i]);
     } else if (strcmp(argv[i], "-qt") == 0) {
-      if ((argc == i+1) ||
+      if ((argc == i+1)
-        (!isStringNumber(argv[i+1]))) {
+              || (!isStringNumber(argv[i+1]))
+              || (atoi(argv[i+1]) <= 0)) {
         printHelp();
-        errorPrint("%s", "\n\t-qt need a number following!\n");
+        errorPrint("%s", "\n\t-qt need a valid (>0) number following!\n");
         exit(EXIT_FAILURE);
       }
       arguments->query_times = atoi(argv[++i]);
     } else if (strcmp(argv[i], "-B") == 0) {
-      if ((argc == i+1) ||
+      if ((argc == i+1)
-        (!isStringNumber(argv[i+1]))) {
+              || (!isStringNumber(argv[i+1]))) {
         printHelp();
         errorPrint("%s", "\n\t-B need a number following!\n");
         exit(EXIT_FAILURE);
       }
       arguments->interlace_rows = atoi(argv[++i]);
     } else if (strcmp(argv[i], "-r") == 0) {
-      if ((argc == i+1) ||
+      if ((argc == i+1)
-        (!isStringNumber(argv[i+1]))) {
+              || (!isStringNumber(argv[i+1]))) {
         printHelp();
         errorPrint("%s", "\n\t-r need a number following!\n");
         exit(EXIT_FAILURE);
@@ -1072,7 +1073,7 @@ static int queryDbExec(TAOS *taos, char *command, QUERY_TYPE type, bool quiet) {
   if (code != 0) {
     if (!quiet) {
       debugPrint("%s() LN%d - command: %s\n", __func__, __LINE__, command);
-      errorPrint("Failed to run %s, reason: %s\n", command, taos_errstr(res));
+      errorPrint("Failed to execute %s, reason: %s\n", command, taos_errstr(res));
     }
     taos_free_result(res);
     //taos_close(taos);
@@ -4040,9 +4041,9 @@ static bool getMetaFromQueryJsonFile(cJSON* root) {
 
   cJSON* gQueryTimes = cJSON_GetObjectItem(root, "query_times");
   if (gQueryTimes && gQueryTimes->type == cJSON_Number) {
-    if (gQueryTimes->valueint < 0) {
+    if (gQueryTimes->valueint <= 0) {
-      errorPrint("%s() LN%d, failed to read json, query_times input mistake\n",
+      errorPrint("%s() LN%d, failed to read json, query_times: %"PRId64", need be a valid (>0) number\n",
-        __func__, __LINE__);
+        __func__, __LINE__, gQueryTimes->valueint);
       goto PARSE_OVER;
     }
     g_args.query_times = gQueryTimes->valueint;
@@ -4091,9 +4092,9 @@ static bool getMetaFromQueryJsonFile(cJSON* root) {
     cJSON* specifiedQueryTimes = cJSON_GetObjectItem(specifiedQuery,
         "query_times");
     if (specifiedQueryTimes && specifiedQueryTimes->type == cJSON_Number) {
-      if (specifiedQueryTimes->valueint < 0) {
+      if (specifiedQueryTimes->valueint <= 0) {
-        errorPrint("%s() LN%d, failed to read json, query_times input mistake\n",
+        errorPrint("%s() LN%d, failed to read json, query_times: %"PRId64", need be a valid (>0) number\n",
-          __func__, __LINE__);
+                __func__, __LINE__, specifiedQueryTimes->valueint);
         goto PARSE_OVER;
 
       }
@@ -4235,9 +4236,9 @@ static bool getMetaFromQueryJsonFile(cJSON* root) {
 
     cJSON* superQueryTimes = cJSON_GetObjectItem(superQuery, "query_times");
     if (superQueryTimes && superQueryTimes->type == cJSON_Number) {
-      if (superQueryTimes->valueint < 0) {
+      if (superQueryTimes->valueint <= 0) {
-        errorPrint("%s() LN%d, failed to read json, query_times input mistake\n",
+        errorPrint("%s() LN%d, failed to read json, query_times: %"PRId64", need be a valid (>0) number\n",
-          __func__, __LINE__);
+                __func__, __LINE__, superQueryTimes->valueint);
         goto PARSE_OVER;
       }
       g_queryInfo.superQueryInfo.queryTimes = superQueryTimes->valueint;
@@ -5200,6 +5201,13 @@ static void* syncWriteInterlace(threadInfo *pThreadInfo) {
 
     startTs = taosGetTimestampMs();
 
+    if (recOfBatch == 0) {
+      errorPrint("[%d] %s() LN%d try inserting records of batch is %"PRIu64"\n",
+              pThreadInfo->threadID, __func__, __LINE__,
+              recOfBatch);
+      errorPrint("%s\n", "\tPlease check if the batch or the buffer length is proper value!\n");
+      goto free_of_interlace;
+    }
     int64_t affectedRows = execInsert(pThreadInfo, buffer, recOfBatch);
 
     endTs = taosGetTimestampMs();

src/mnode/src/mnodeUser.c

@@ -123,7 +123,7 @@ static void mnodePrintUserAuth() {
     mnodeDecUserRef(pUser);
   }
 
-  fsync(fileno(fp));
+  taosFsync(fileno(fp));
   fclose(fp);
 }
 

src/os/inc/os.h

@@ -20,45 +20,9 @@
 extern "C" {
 #endif
 
-#ifdef _TD_DARWIN_64
+#include "osInc.h"
-#include "osDarwin.h"
-#endif
-
-#ifdef _TD_ARM_64
-#include "osArm64.h"
-#endif
-
-#ifdef _TD_ARM_32
-#include "osArm32.h"
-#endif
-
-#ifdef _TD_MIPS_64
-#include "osMips64.h"
-#endif
-
-#ifdef _TD_LINUX_64
-#include "osLinux64.h"
-#endif
-
-#ifdef _TD_LINUX_32
-#include "osLinux32.h"
-#endif
-
-#ifdef _ALPINE
-#include "osAlpine.h"
-#endif
-
-#ifdef _TD_NINGSI_60
-#include "osNingsi.h"
-#endif
-
-#if defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
-#include "osWindows.h"
-#endif
-
 #include "osDef.h"
 #include "osAtomic.h"
-#include "osCommon.h"
 #include "osDir.h"
 #include "osFile.h"
 #include "osLz4.h"
@@ -67,6 +31,7 @@ extern "C" {
 #include "osRand.h"
 #include "osSemphone.h"
 #include "osSignal.h"
+#include "osSleep.h"
 #include "osSocket.h"
 #include "osString.h"
 #include "osSysinfo.h"

src/os/inc/osAlpine.h

@@ -1,92 +0,0 @@
-/*
- * 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_ALPINE_H
-#define TDENGINE_OS_ALPINE_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>
-#include <math.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/osArm32.h

@@ -1,92 +0,0 @@
-/*
- * 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_ARM32_H
-#define TDENGINE_OS_ARM32_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 <math.h>
-#include <poll.h>
-
-#define TAOS_OS_FUNC_LZ4
-  #define BUILDIN_CLZL(val) __builtin_clzll(val)
-  #define BUILDIN_CTZL(val) __builtin_ctzll(val)
-  #define BUILDIN_CLZ(val) __builtin_clz(val)
-  #define BUILDIN_CTZ(val) __builtin_ctz(val)
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

src/os/inc/osArm64.h

@@ -1,87 +0,0 @@
-/*
- * 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_ARM64_H
-#define TDENGINE_OS_ARM64_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>
-#include <math.h>
-#include <poll.h>
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

src/os/inc/osAtomic.h

@@ -20,7 +20,252 @@
 extern "C" {
 #endif
 
-#ifndef TAOS_OS_FUNC_ATOMIC
+#if defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
+  #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))
+
+  #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))
+  #ifdef _WIN64 
+    #define atomic_exchange_ptr(ptr, val) _InterlockedExchangePointer((void* volatile*)(ptr), (void*)(val)) 
+  #else
+    #define atomic_exchange_ptr(ptr, val) _InlineInterlockedExchangePointer((void* volatile*)(ptr), (void*)(val))
+  #endif
+  
+  #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);
+
+  char interlocked_and_fetch_8(char volatile* ptr, char val);
+  short interlocked_and_fetch_16(short volatile* ptr, short val);
+  long interlocked_and_fetch_32(long volatile* ptr, long val);
+  __int64 interlocked_and_fetch_64(__int64 volatile* ptr, __int64 val);
+
+  __int64 interlocked_fetch_and_64(__int64 volatile* ptr, __int64 val);
+
+  char interlocked_or_fetch_8(char volatile* ptr, char val);
+  short interlocked_or_fetch_16(short volatile* ptr, short val);
+  long interlocked_or_fetch_32(long volatile* ptr, long val);
+  __int64 interlocked_or_fetch_64(__int64 volatile* ptr, __int64 val);
+
+  char interlocked_xor_fetch_8(char volatile* ptr, char val);
+  short interlocked_xor_fetch_16(short volatile* ptr, short val);
+  long interlocked_xor_fetch_32(long volatile* ptr, long val);
+  __int64 interlocked_xor_fetch_64(__int64 volatile* ptr, __int64 val);
+
+  __int64 interlocked_fetch_xor_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 _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_8(ptr, val) _InterlockedExchangeAdd8((char volatile*)(ptr), (char)(val))
+  #define atomic_fetch_add_16(ptr, val) _InterlockedExchangeAdd16((short volatile*)(ptr), (short)(val))
+  #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))
+  
+  #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))
+
+  #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))
+
+  #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))
+  #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))
+
+  #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))
+  #define atomic_fetch_and_32(ptr, val) _InterlockedAnd((long volatile*)(ptr), (long)(val))
+  #define atomic_fetch_and_64(ptr, val) interlocked_fetch_and_64((__int64 volatile*)(ptr), (__int64)(val))
+
+  #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))
+  #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))
+
+  #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))
+  #define atomic_fetch_or_32(ptr, val) _InterlockedOr((long volatile*)(ptr), (long)(val))
+  #define atomic_fetch_or_64(ptr, val) interlocked_fetch_or_64((__int64 volatile*)(ptr), (__int64)(val))
+
+  #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))
+  #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))
+
+  #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))
+  #define atomic_fetch_xor_32(ptr, val) _InterlockedXor((long volatile*)(ptr), (long)(val))
+  #define atomic_fetch_xor_64(ptr, val) interlocked_fetch_xor_64((__int64 volatile*)(ptr), (__int64)(val))
+
+  #ifdef _WIN64
+    #define atomic_add_fetch_ptr atomic_add_fetch_64
+    #define atomic_fetch_add_ptr atomic_fetch_add_64
+    #define atomic_sub_fetch_ptr atomic_sub_fetch_64
+    #define atomic_fetch_sub_ptr atomic_fetch_sub_64
+    #define atomic_and_fetch_ptr atomic_and_fetch_64
+    #define atomic_fetch_and_ptr atomic_fetch_and_64
+    #define atomic_or_fetch_ptr  atomic_or_fetch_64
+    #define atomic_fetch_or_ptr  atomic_fetch_or_64
+    #define atomic_xor_fetch_ptr atomic_xor_fetch_64
+    #define atomic_fetch_xor_ptr atomic_fetch_xor_64
+  #else
+    #define atomic_add_fetch_ptr atomic_add_fetch_32
+    #define atomic_fetch_add_ptr atomic_fetch_add_32
+    #define atomic_sub_fetch_ptr atomic_sub_fetch_32
+    #define atomic_fetch_sub_ptr atomic_fetch_sub_32
+    #define atomic_and_fetch_ptr atomic_and_fetch_32
+    #define atomic_fetch_and_ptr atomic_fetch_and_32
+    #define atomic_or_fetch_ptr  atomic_or_fetch_32
+    #define atomic_fetch_or_ptr  atomic_fetch_or_32
+    #define atomic_xor_fetch_ptr atomic_xor_fetch_32
+    #define atomic_fetch_xor_ptr atomic_fetch_xor_32
+  #endif
+#elif defined(_TD_NINGSI_60)
+  /*
+  * type __sync_fetch_and_add (type *ptr, type value);
+  * type __sync_fetch_and_sub (type *ptr, type value);
+  * type __sync_fetch_and_or (type *ptr, type value);
+  * type __sync_fetch_and_and (type *ptr, type value);
+  * type __sync_fetch_and_xor (type *ptr, type value);
+  * type __sync_fetch_and_nand (type *ptr, type value);
+  * type __sync_add_and_fetch (type *ptr, type value);
+  * type __sync_sub_and_fetch (type *ptr, type value);
+  * type __sync_or_and_fetch (type *ptr, type value);
+  * type __sync_and_and_fetch (type *ptr, type value);
+  * type __sync_xor_and_fetch (type *ptr, type value);
+  * type __sync_nand_and_fetch (type *ptr, type value);
+  *
+  * bool __sync_bool_compare_and_swap (type*ptr, type oldval, type newval, ...)
+  * type __sync_val_compare_and_swap (type *ptr, type oldval, ?type newval, ...)
+  * */
+
+  #define atomic_load_8(ptr)   __sync_fetch_and_add((ptr), 0)
+  #define atomic_load_16(ptr)  __sync_fetch_and_add((ptr), 0)
+  #define atomic_load_32(ptr)  __sync_fetch_and_add((ptr), 0)
+  #define atomic_load_64(ptr)  __sync_fetch_and_add((ptr), 0)
+  #define atomic_load_ptr(ptr) __sync_fetch_and_add((ptr), 0)
+    
+  #define atomic_store_8(ptr, val)   (*(ptr)=(val))
+  #define atomic_store_16(ptr, val)  (*(ptr)=(val))
+  #define atomic_store_32(ptr, val)  (*(ptr)=(val))
+  #define atomic_store_64(ptr, val)  (*(ptr)=(val))
+  #define atomic_store_ptr(ptr, val) (*(ptr)=(val))
+
+  int8_t  atomic_exchange_8_impl(int8_t* ptr, int8_t val );
+  int16_t atomic_exchange_16_impl(int16_t* ptr, int16_t val );
+  int32_t atomic_exchange_32_impl(int32_t* ptr, int32_t val );
+  int64_t atomic_exchange_64_impl(int64_t* ptr, int64_t val );
+  void*   atomic_exchange_ptr_impl( void **ptr, void *val );
+
+  #define atomic_exchange_8(ptr, val)   atomic_exchange_8_impl((int8_t*)ptr, (int8_t)val)
+  #define atomic_exchange_16(ptr, val)  atomic_exchange_16_impl((int16_t*)ptr, (int16_t)val)
+  #define atomic_exchange_32(ptr, val)  atomic_exchange_32_impl((int32_t*)ptr, (int32_t)val)
+  #define atomic_exchange_64(ptr, val)  atomic_exchange_64_impl((int64_t*)ptr, (int64_t)val)
+  #define atomic_exchange_ptr(ptr, val) atomic_exchange_ptr_impl((void **)ptr, (void*)val)
+      
+  #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) __sync_add_and_fetch((ptr), (val))
+  #define atomic_add_fetch_16(ptr, val) __sync_add_and_fetch((ptr), (val))
+  #define atomic_add_fetch_32(ptr, val) __sync_add_and_fetch((ptr), (val))
+  #define atomic_add_fetch_64(ptr, val) __sync_add_and_fetch((ptr), (val))
+  #define atomic_add_fetch_ptr(ptr, val) __sync_add_and_fetch((ptr), (val))
+    
+  #define atomic_fetch_add_8(ptr, val) __sync_fetch_and_add((ptr), (val))
+  #define atomic_fetch_add_16(ptr, val) __sync_fetch_and_add((ptr), (val))
+  #define atomic_fetch_add_32(ptr, val) __sync_fetch_and_add((ptr), (val))
+  #define atomic_fetch_add_64(ptr, val) __sync_fetch_and_add((ptr), (val))
+  #define atomic_fetch_add_ptr(ptr, val) __sync_fetch_and_add((ptr), (val))
+    
+  #define atomic_sub_fetch_8(ptr, val) __sync_sub_and_fetch((ptr), (val))
+  #define atomic_sub_fetch_16(ptr, val) __sync_sub_and_fetch((ptr), (val))
+  #define atomic_sub_fetch_32(ptr, val) __sync_sub_and_fetch((ptr), (val))
+  #define atomic_sub_fetch_64(ptr, val) __sync_sub_and_fetch((ptr), (val))
+  #define atomic_sub_fetch_ptr(ptr, val) __sync_sub_and_fetch((ptr), (val))
+    
+  #define atomic_fetch_sub_8(ptr, val) __sync_fetch_and_sub((ptr), (val))
+  #define atomic_fetch_sub_16(ptr, val) __sync_fetch_and_sub((ptr), (val))
+  #define atomic_fetch_sub_32(ptr, val) __sync_fetch_and_sub((ptr), (val))
+  #define atomic_fetch_sub_64(ptr, val) __sync_fetch_and_sub((ptr), (val))
+  #define atomic_fetch_sub_ptr(ptr, val) __sync_fetch_and_sub((ptr), (val))
+    
+  #define atomic_and_fetch_8(ptr, val) __sync_and_and_fetch((ptr), (val))
+  #define atomic_and_fetch_16(ptr, val) __sync_and_and_fetch((ptr), (val))
+  #define atomic_and_fetch_32(ptr, val) __sync_and_and_fetch((ptr), (val))
+  #define atomic_and_fetch_64(ptr, val) __sync_and_and_fetch((ptr), (val))
+  #define atomic_and_fetch_ptr(ptr, val) __sync_and_and_fetch((ptr), (val))
+    
+  #define atomic_fetch_and_8(ptr, val) __sync_fetch_and_and((ptr), (val))
+  #define atomic_fetch_and_16(ptr, val) __sync_fetch_and_and((ptr), (val))
+  #define atomic_fetch_and_32(ptr, val) __sync_fetch_and_and((ptr), (val))
+  #define atomic_fetch_and_64(ptr, val) __sync_fetch_and_and((ptr), (val))
+  #define atomic_fetch_and_ptr(ptr, val) __sync_fetch_and_and((ptr), (val))
+    
+  #define atomic_or_fetch_8(ptr, val) __sync_or_and_fetch((ptr), (val))
+  #define atomic_or_fetch_16(ptr, val) __sync_or_and_fetch((ptr), (val))
+  #define atomic_or_fetch_32(ptr, val) __sync_or_and_fetch((ptr), (val))
+  #define atomic_or_fetch_64(ptr, val) __sync_or_and_fetch((ptr), (val))
+  #define atomic_or_fetch_ptr(ptr, val) __sync_or_and_fetch((ptr), (val))
+    
+  #define atomic_fetch_or_8(ptr, val) __sync_fetch_and_or((ptr), (val))
+  #define atomic_fetch_or_16(ptr, val) __sync_fetch_and_or((ptr), (val))
+  #define atomic_fetch_or_32(ptr, val) __sync_fetch_and_or((ptr), (val))
+  #define atomic_fetch_or_64(ptr, val) __sync_fetch_and_or((ptr), (val))
+  #define atomic_fetch_or_ptr(ptr, val) __sync_fetch_and_or((ptr), (val))
+    
+  #define atomic_xor_fetch_8(ptr, val) __sync_xor_and_fetch((ptr), (val))
+  #define atomic_xor_fetch_16(ptr, val) __sync_xor_and_fetch((ptr), (val))
+  #define atomic_xor_fetch_32(ptr, val) __sync_xor_and_fetch((ptr), (val))
+  #define atomic_xor_fetch_64(ptr, val) __sync_xor_and_fetch((ptr), (val))
+  #define atomic_xor_fetch_ptr(ptr, val) __sync_xor_and_fetch((ptr), (val))
+    
+  #define atomic_fetch_xor_8(ptr, val) __sync_fetch_and_xor((ptr), (val))
+  #define atomic_fetch_xor_16(ptr, val) __sync_fetch_and_xor((ptr), (val))
+  #define atomic_fetch_xor_32(ptr, val) __sync_fetch_and_xor((ptr), (val))
+  #define atomic_fetch_xor_64(ptr, val) __sync_fetch_and_xor((ptr), (val))
+  #define atomic_fetch_xor_ptr(ptr, val) __sync_fetch_and_xor((ptr), (val))
+
+#else
   #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)

src/os/inc/osDarwin.h

@@ -1,127 +0,0 @@
-/*
- * 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_DARWIN_H
-#define TDENGINE_OS_DARWIN_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>
-#include <math.h>
-
-#define TAOS_OS_FUNC_FILE_SENDIFLE
-
-#define TAOS_OS_FUNC_SEMPHONE
-  typedef struct tsem_s *tsem_t;
-  int tsem_init(tsem_t *sem, int pshared, unsigned int value);
-  int tsem_wait(tsem_t *sem);
-  int tsem_post(tsem_t *sem);
-  int tsem_destroy(tsem_t *sem);
-
-#define TAOS_OS_FUNC_SOCKET_SETSOCKETOPT
-#define TAOS_OS_FUNC_STRING_STR2INT64
-#define TAOS_OS_FUNC_SYSINFO
-#define TAOS_OS_FUNC_TIMER
-#define TAOS_OS_FUNC_SEMPHONE_PTHREAD
-
-// specific
-#define htobe64 htonll
-typedef int(*__compar_fn_t)(const void *, const void *);
-
-// for send function in tsocket.c
-#if defined(MSG_NOSIGNAL)
-#undef MSG_NOSIGNAL
-#endif
-
-#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
-
-#define TAOS_OS_FUNC_PTHREAD_RWLOCK
-
-int64_t tsosStr2int64(char *str);
-
-#include "eok.h"
-
-void taos_block_sigalrm(void);
-
-#define TAOS_OS_DEF_EPOLL
-  #define TAOS_EPOLL_WAIT_TIME 500
-  typedef int32_t SOCKET;
-  typedef SOCKET EpollFd;
-  #define EpollClose(pollFd) epoll_close(pollFd)
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

src/os/inc/osDef.h

@@ -20,17 +20,109 @@
 extern "C" {
 #endif
 
+#if defined(_TD_DARWIN_64)
+  // specific
+  typedef int(*__compar_fn_t)(const void *, const void *);
+
+  // for send function in tsocket.c
+  #if defined(MSG_NOSIGNAL)
+    #undef MSG_NOSIGNAL
+  #endif
+
+  #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
+#endif
+
+#if defined(_ALPINE)
+  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
+#endif
+
+#if defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
+  char *stpcpy (char *dest, const char *src);
+  char *stpncpy (char *dest, const char *src, size_t n);
+
+  // specific
+  typedef int (*__compar_fn_t)(const void *, const void *);
+  #define ssize_t int
+  #define bzero(ptr, size) memset((ptr), 0, (size))
+  #define strcasecmp  _stricmp
+  #define strncasecmp _strnicmp
+  #define wcsncasecmp _wcsnicmp
+  #define strtok_r strtok_s
+  #define snprintf _snprintf
+  #define in_addr_t unsigned long
+  #define socklen_t int
+
+  struct tm *localtime_r(const time_t *timep, struct tm *result);
+  char *     strptime(const char *buf, const char *fmt, struct tm *tm);
+  char *     strsep(char **stringp, const char *delim);
+  char *     getpass(const char *prefix);
+  int        flock(int fd, int option);
+  char *     strndup(const char *s, size_t n);
+  int        gettimeofday(struct timeval *ptv, void *pTimeZone);
+
+  // for send function in tsocket.c
+  #define MSG_NOSIGNAL             0
+  #define SO_NO_CHECK              0x1234
+  #define SOL_TCP                  0x1234
+
+  #ifndef TCP_KEEPCNT
+  #define TCP_KEEPCNT              0x1234
+  #endif
+
+  #ifndef TCP_KEEPIDLE
+  #define TCP_KEEPIDLE             0x1234
+  #endif
+
+  #ifndef TCP_KEEPINTVL
+  #define TCP_KEEPINTVL            0x1234
+  #endif
+
+  #define SHUT_RDWR                SD_BOTH
+  #define SHUT_RD                  SD_RECEIVE
+  #define SHUT_WR                  SD_SEND
+
+  #define LOCK_EX 1
+  #define LOCK_NB 2
+  #define LOCK_UN 3
+
+  #ifndef PATH_MAX
+  #define PATH_MAX 256
+  #endif
+
+  typedef struct {
+    int    we_wordc;
+    char  *we_wordv[1];
+    int    we_offs;
+    char   wordPos[1025];
+  } wordexp_t;
+  int  wordexp(char *words, wordexp_t *pwordexp, int flags);
+  void wordfree(wordexp_t *pwordexp);
+
+  #define openlog(a, b, c)
+  #define closelog()
+  #define LOG_ERR 0
+  #define LOG_INFO 1
+  void syslog(int unused, const char *format, ...);
+#endif
+
 #ifndef WINDOWS
   #ifndef O_BINARY
     #define O_BINARY 0
   #endif
 #endif
 
-#define FD_VALID(x) ((x) > STDERR_FILENO)
-#define FD_INITIALIZER  ((int32_t)-1)
-
-// #define WCHAR wchar_t
-
 #define POINTER_SHIFT(p, b) ((void *)((char *)(p) + (b)))
 #define POINTER_DISTANCE(p1, p2) ((char *)(p1) - (char *)(p2)) 
 
@@ -113,6 +205,12 @@ extern "C" {
   #define threadlocal __declspec( thread )
 #endif
 
+#if defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
+  #define PRIzu "ld"  
+#else
+  #define PRIzu "zu"  
+#endif
+
 #ifdef __cplusplus
 }
 #endif

src/os/inc/osDir.h

@@ -20,13 +20,10 @@
 extern "C" {
 #endif
 
-#include <sys/types.h>
-
-// TAOS_OS_FUNC_DIR
 void    taosRemoveDir(char *rootDir);
-int  taosMkDir(const char *pathname, mode_t mode); 
+int32_t taosMkDir(const char *pathname, mode_t mode);
 void    taosRemoveOldLogFiles(char *rootDir, int32_t keepDays);
-int32_t taosRename(char* oldName, char *newName);
+int32_t taosRename(char *oldName, char *newName);
 int32_t taosCompressFile(char *srcFileName, char *destFileName);
 
 #ifdef __cplusplus

src/os/inc/osEok.h

@@ -13,8 +13,8 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef _eok_h_fd274616_996c_400e_9023_ae70be881fa3_
+#ifndef TDENGINE_OS_EOK_H
-#define _eok_h_fd274616_996c_400e_9023_ae70be881fa3_
+#define TDENGINE_OS_EOK_H
 
 #include <stdint.h>
 

src/os/inc/osFile.h

@@ -22,48 +22,37 @@ extern "C" {
 
 #include "osSocket.h"
 
-int64_t taosReadImp(int32_t fd, void *buf, int64_t count);
+#define FD_VALID(x) ((x) > STDERR_FILENO)
-int64_t taosWriteImp(int32_t fd, void *buf, int64_t count);
+#define FD_INITIALIZER  ((int32_t)-1)
-int64_t taosLSeekImp(int32_t fd, int64_t offset, int32_t whence);
-int32_t taosRenameFile(char *fullPath, char *suffix, char delimiter, char **dstPath);
-int64_t taosCopy(char *from, char *to);
 
-#define taosRead(fd, buf, count) taosReadImp(fd, buf, count)
+#ifndef PATH_MAX
-#define taosWrite(fd, buf, count) taosWriteImp(fd, buf, count)
+  #define PATH_MAX 256
-#define taosLSeek(fd, offset, whence) taosLSeekImp(fd, offset, whence)
-#define taosClose(fd)      \
-  {                        \
-    if (FD_VALID(fd)) {    \
-      close(fd);           \
-      fd = FD_INITIALIZER; \
-    }                      \
-  }
-
-// TAOS_OS_FUNC_FILE_SENDIFLE
-int64_t taosSendFile(SOCKET dfd, int32_t sfd, int64_t *offset, int64_t size);
-int64_t taosFSendFile(FILE *outfile, FILE *infile, int64_t *offset, int64_t size);
-
-#ifdef TAOS_RANDOM_FILE_FAIL
-  void taosSetRandomFileFailFactor(int32_t factor);
-  void taosSetRandomFileFailOutput(const char *path);
-  #ifdef TAOS_RANDOM_FILE_FAIL_TEST
-    int64_t taosReadFileRandomFail(int32_t fd, void *buf, int32_t count, const char *file, uint32_t line);
-    int64_t taosWriteFileRandomFail(int32_t fd, void *buf, int32_t count, const char *file, uint32_t line);
-    int64_t taosLSeekRandomFail(int32_t fd, int64_t offset, int32_t whence, const char *file, uint32_t line);
-    #undef taosRead
-    #undef taosWrite
-    #undef taosLSeek
-    #define taosRead(fd, buf, count) taosReadFileRandomFail(fd, buf, count, __FILE__, __LINE__)
-    #define taosWrite(fd, buf, count) taosWriteFileRandomFail(fd, buf, count, __FILE__, __LINE__)
-    #define taosLSeek(fd, offset, whence) taosLSeekRandomFail(fd, offset, whence, __FILE__, __LINE__)
-  #endif  
 #endif
 
-// TAOS_OS_FUNC_FILE_GETTMPFILEPATH
+#if defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
-void taosGetTmpfilePath(const char *fileNamePrefix, char *dstPath);
+typedef int32_t FileFd;
+typedef SOCKET  SocketFd;
+#else
+typedef int32_t FileFd;
+typedef int32_t SocketFd;
+#endif
+
+int64_t taosRead(FileFd fd, void *buf, int64_t count);
+int64_t taosWrite(FileFd fd, void *buf, int64_t count);
+
+int64_t taosLSeek(FileFd fd, int64_t offset, int32_t whence);
+int32_t taosFtruncate(FileFd fd, int64_t length);
+int32_t taosFsync(FileFd fd);
+
+int32_t taosRename(char* oldName, char *newName);
+int64_t taosCopy(char *from, char *to);
+
+int64_t taosSendFile(SocketFd dfd, FileFd sfd, int64_t *offset, int64_t size);
+int64_t taosFSendFile(FILE *outfile, FILE *infile, int64_t *offset, int64_t size);
+
+void taosGetTmpfilePath(const char *fileNamePrefix, char *dstPath);
+void taosClose(FileFd fd);
 
-// TAOS_OS_FUNC_FILE_FTRUNCATE
-int32_t taosFtruncate(int32_t fd, int64_t length);
 #ifdef __cplusplus
 }
 #endif

src/os/inc/osInc.h

@@ -0,0 +1,118 @@
+/*
+ * 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_INC_H
+#define TDENGINE_OS_INC_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <assert.h>
+#include <ctype.h>
+#include <errno.h>
+#include <float.h>
+#include <inttypes.h>
+#include <locale.h>
+#include <math.h>
+#include <pthread.h>
+#include <semaphore.h>
+#include <signal.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#if defined(_TD_LINUX_64) || defined(_TD_LINUX_32) || defined(_TD_MIPS_64)  || defined(_TD_ARM_32) || defined(_TD_ARM_64)  || defined(_TD_DARWIN_64)
+  #include <arpa/inet.h>
+  #include <dirent.h>
+  #include <fcntl.h>
+  #include <inttypes.h>
+  #include <libgen.h>
+  #include <limits.h>
+  #include <netdb.h>
+  #include <netinet/in.h>
+  #include <netinet/ip.h>
+  #include <netinet/tcp.h>
+  #include <netinet/udp.h>
+  #include <pwd.h>
+  #include <regex.h>
+  #include <stddef.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 <sys/utsname.h>
+  #include <syslog.h>
+  #include <termios.h>
+  #include <unistd.h>
+  #include <wchar.h>
+  #include <wordexp.h>
+  #include <wctype.h>
+
+  #if defined(_TD_DARWIN_64)
+    #include <dispatch/dispatch.h>
+    #include "osEok.h"
+  #else
+    #include <argp.h> 
+    #include <endian.h>
+    #include <linux/sysctl.h>
+    #include <poll.h>
+    #include <sys/epoll.h>
+    #include <sys/eventfd.h>
+    #include <sys/resource.h>
+    #include <sys/sendfile.h>
+
+    #if !(defined(_ALPINE))
+      #include <error.h>
+    #endif
+  #endif
+#endif
+
+#if defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
+  #include <intrin.h>
+  #include <io.h>
+  #include "winsock2.h"
+  #include <WS2tcpip.h>
+  #include <winbase.h>
+  #include <Winsock2.h>
+  #include <time.h>
+  #include <conio.h>
+  #include "msvcProcess.h"
+  #include "msvcDirect.h"
+  #include "msvcFcntl.h"
+  #include "msvcLibgen.h"
+  #include "msvcStdio.h"
+  #include "msvcUnistd.h"
+  #include "msvcLibgen.h"
+  #include "sys/msvcStat.h"
+  #include "sys/msvcTypes.h"
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/os/inc/osLinux32.h

@@ -1,92 +0,0 @@
-/*
- * 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_LINUX32_H
-#define TDENGINE_OS_LINUX32_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 <math.h>
-#include <poll.h>
-
-#define TAOS_OS_FUNC_LZ4
-#define BUILDIN_CLZL(val) __builtin_clzll(val)
-#define BUILDIN_CTZL(val) __builtin_ctzll(val)
-#define BUILDIN_CLZ(val) __builtin_clz(val)
-#define BUILDIN_CTZ(val) __builtin_ctz(val)
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

src/os/inc/osLinux64.h

@@ -1,89 +0,0 @@
-/*
- * 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 <poll.h>
-#ifndef _ALPINE
-#include <error.h>
-#endif
-#include <linux/sysctl.h>
-#include <math.h>
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

src/os/inc/osLz4.h

@@ -20,7 +20,22 @@
 extern "C" {
 #endif
 
-#ifndef TAOS_OS_FUNC_LZ4
+#if defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
+  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);
+#elif defined (_TD_LINUX_32)
+  #define BUILDIN_CLZL(val) __builtin_clzll(val)
+  #define BUILDIN_CTZL(val) __builtin_ctzll(val)
+  #define BUILDIN_CLZ(val) __builtin_clz(val)
+  #define BUILDIN_CTZ(val) __builtin_ctz(val)
+#elif defined (_TD_ARM_32)
+  #define BUILDIN_CLZL(val) __builtin_clzll(val)
+  #define BUILDIN_CTZL(val) __builtin_ctzll(val)
+  #define BUILDIN_CLZ(val) __builtin_clz(val)
+  #define BUILDIN_CTZ(val) __builtin_ctz(val)
+#else
   #define BUILDIN_CLZL(val) __builtin_clzl(val)
   #define BUILDIN_CTZL(val) __builtin_ctzl(val)
   #define BUILDIN_CLZ(val) __builtin_clz(val)

src/os/inc/osMath.h

@@ -23,7 +23,19 @@ extern "C" {
 #define POW2(x) ((x) * (x))
 #define ABS(x) ((x) > 0 ? (x) : -(x))
 
-#ifndef TAOS_OS_FUNC_MATH
+#if defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
+
+  #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))
+
+#else
+
   #define SWAP(a, b, c)      \
     do {                     \
       typeof(a) __tmp = (a); \

src/os/inc/osMemory.h

@@ -43,9 +43,6 @@ void   taosTMemset(void *ptr, int c);
 #define tmalloc(size) malloc(size)
 #define tcalloc(num, size) calloc(num, size)
 #define trealloc(ptr, size) realloc(ptr, size)
-#define tstrdup(str) taosStrdupImp(str)
-#define tstrndup(str, size) taosStrndupImp(str, size)
-#define tgetline(lineptr, n, stream) taosGetlineImp(lineptr, n, stream)
 #define tfree(x)         \
   do {                   \
     if (x) {             \
@@ -71,13 +68,6 @@ void   taosTMemset(void *ptr, int c);
     #define tcalloc(num, size) taosCallocMem(num, size, __FILE__, __LINE__)
     #define trealloc(ptr, size) taosReallocMem(ptr, size, __FILE__, __LINE__)
     #define tfree(ptr) taosFreeMem(ptr, __FILE__, __LINE__) 
-    
-    // #undef tstrdup
-    // #undef tstrndup
-    // #undef tgetline
-    // #define taosStrdup(str) taos_strdup(str, __FILE__, __LINE__)
-    // #define taosStrndup(str, size) taos_strndup(str, size, __FILE__, __LINE__)
-    // #define tgetline(lineptr, n, stream) taos_getline(lineptr, n, stream, __FILE__, __LINE__)
   #endif  
 #endif
 

src/os/inc/osMips64.h

@@ -1,87 +0,0 @@
-/*
- * 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_MIPS64_H
-#define TDENGINE_OS_MIPS64_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>
-#include <math.h>
-#include <poll.h>
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

src/os/inc/osNingsi.h

@@ -1,136 +0,0 @@
-/*
- * 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_NINGSI_H
-#define TDENGINE_OS_NINGSI_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define  TAOS_OS_FUNC_ATOMIC
-/*
- * type __sync_fetch_and_add (type *ptr, type value);
- * type __sync_fetch_and_sub (type *ptr, type value);
- * type __sync_fetch_and_or (type *ptr, type value);
- * type __sync_fetch_and_and (type *ptr, type value);
- * type __sync_fetch_and_xor (type *ptr, type value);
- * type __sync_fetch_and_nand (type *ptr, type value);
- * type __sync_add_and_fetch (type *ptr, type value);
- * type __sync_sub_and_fetch (type *ptr, type value);
- * type __sync_or_and_fetch (type *ptr, type value);
- * type __sync_and_and_fetch (type *ptr, type value);
- * type __sync_xor_and_fetch (type *ptr, type value);
- * type __sync_nand_and_fetch (type *ptr, type value);
- *
- * bool __sync_bool_compare_and_swap (type*ptr, type oldval, type newval, ...)
- * type __sync_val_compare_and_swap (type *ptr, type oldval, ?type newval, ...)
- * */
-
-#define atomic_load_8(ptr)   __sync_fetch_and_add((ptr), 0)
-#define atomic_load_16(ptr)  __sync_fetch_and_add((ptr), 0)
-#define atomic_load_32(ptr)  __sync_fetch_and_add((ptr), 0)
-#define atomic_load_64(ptr)  __sync_fetch_and_add((ptr), 0)
-#define atomic_load_ptr(ptr) __sync_fetch_and_add((ptr), 0)
-  
-#define atomic_store_8(ptr, val)   (*(ptr)=(val))
-#define atomic_store_16(ptr, val)  (*(ptr)=(val))
-#define atomic_store_32(ptr, val)  (*(ptr)=(val))
-#define atomic_store_64(ptr, val)  (*(ptr)=(val))
-#define atomic_store_ptr(ptr, val) (*(ptr)=(val))
-
-int8_t  atomic_exchange_8_impl(int8_t* ptr, int8_t val );
-int16_t atomic_exchange_16_impl(int16_t* ptr, int16_t val );
-int32_t atomic_exchange_32_impl(int32_t* ptr, int32_t val );
-int64_t atomic_exchange_64_impl(int64_t* ptr, int64_t val );
-void*   atomic_exchange_ptr_impl( void **ptr, void *val );
-
-#define atomic_exchange_8(ptr, val)   atomic_exchange_8_impl((int8_t*)ptr, (int8_t)val)
-#define atomic_exchange_16(ptr, val)  atomic_exchange_16_impl((int16_t*)ptr, (int16_t)val)
-#define atomic_exchange_32(ptr, val)  atomic_exchange_32_impl((int32_t*)ptr, (int32_t)val)
-#define atomic_exchange_64(ptr, val)  atomic_exchange_64_impl((int64_t*)ptr, (int64_t)val)
-#define atomic_exchange_ptr(ptr, val) atomic_exchange_ptr_impl((void **)ptr, (void*)val)
-    
-#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) __sync_add_and_fetch((ptr), (val))
-#define atomic_add_fetch_16(ptr, val) __sync_add_and_fetch((ptr), (val))
-#define atomic_add_fetch_32(ptr, val) __sync_add_and_fetch((ptr), (val))
-#define atomic_add_fetch_64(ptr, val) __sync_add_and_fetch((ptr), (val))
-#define atomic_add_fetch_ptr(ptr, val) __sync_add_and_fetch((ptr), (val))
-  
-#define atomic_fetch_add_8(ptr, val) __sync_fetch_and_add((ptr), (val))
-#define atomic_fetch_add_16(ptr, val) __sync_fetch_and_add((ptr), (val))
-#define atomic_fetch_add_32(ptr, val) __sync_fetch_and_add((ptr), (val))
-#define atomic_fetch_add_64(ptr, val) __sync_fetch_and_add((ptr), (val))
-#define atomic_fetch_add_ptr(ptr, val) __sync_fetch_and_add((ptr), (val))
-  
-#define atomic_sub_fetch_8(ptr, val) __sync_sub_and_fetch((ptr), (val))
-#define atomic_sub_fetch_16(ptr, val) __sync_sub_and_fetch((ptr), (val))
-#define atomic_sub_fetch_32(ptr, val) __sync_sub_and_fetch((ptr), (val))
-#define atomic_sub_fetch_64(ptr, val) __sync_sub_and_fetch((ptr), (val))
-#define atomic_sub_fetch_ptr(ptr, val) __sync_sub_and_fetch((ptr), (val))
-  
-#define atomic_fetch_sub_8(ptr, val) __sync_fetch_and_sub((ptr), (val))
-#define atomic_fetch_sub_16(ptr, val) __sync_fetch_and_sub((ptr), (val))
-#define atomic_fetch_sub_32(ptr, val) __sync_fetch_and_sub((ptr), (val))
-#define atomic_fetch_sub_64(ptr, val) __sync_fetch_and_sub((ptr), (val))
-#define atomic_fetch_sub_ptr(ptr, val) __sync_fetch_and_sub((ptr), (val))
-  
-#define atomic_and_fetch_8(ptr, val) __sync_and_and_fetch((ptr), (val))
-#define atomic_and_fetch_16(ptr, val) __sync_and_and_fetch((ptr), (val))
-#define atomic_and_fetch_32(ptr, val) __sync_and_and_fetch((ptr), (val))
-#define atomic_and_fetch_64(ptr, val) __sync_and_and_fetch((ptr), (val))
-#define atomic_and_fetch_ptr(ptr, val) __sync_and_and_fetch((ptr), (val))
-  
-#define atomic_fetch_and_8(ptr, val) __sync_fetch_and_and((ptr), (val))
-#define atomic_fetch_and_16(ptr, val) __sync_fetch_and_and((ptr), (val))
-#define atomic_fetch_and_32(ptr, val) __sync_fetch_and_and((ptr), (val))
-#define atomic_fetch_and_64(ptr, val) __sync_fetch_and_and((ptr), (val))
-#define atomic_fetch_and_ptr(ptr, val) __sync_fetch_and_and((ptr), (val))
-  
-#define atomic_or_fetch_8(ptr, val) __sync_or_and_fetch((ptr), (val))
-#define atomic_or_fetch_16(ptr, val) __sync_or_and_fetch((ptr), (val))
-#define atomic_or_fetch_32(ptr, val) __sync_or_and_fetch((ptr), (val))
-#define atomic_or_fetch_64(ptr, val) __sync_or_and_fetch((ptr), (val))
-#define atomic_or_fetch_ptr(ptr, val) __sync_or_and_fetch((ptr), (val))
-  
-#define atomic_fetch_or_8(ptr, val) __sync_fetch_and_or((ptr), (val))
-#define atomic_fetch_or_16(ptr, val) __sync_fetch_and_or((ptr), (val))
-#define atomic_fetch_or_32(ptr, val) __sync_fetch_and_or((ptr), (val))
-#define atomic_fetch_or_64(ptr, val) __sync_fetch_and_or((ptr), (val))
-#define atomic_fetch_or_ptr(ptr, val) __sync_fetch_and_or((ptr), (val))
-  
-#define atomic_xor_fetch_8(ptr, val) __sync_xor_and_fetch((ptr), (val))
-#define atomic_xor_fetch_16(ptr, val) __sync_xor_and_fetch((ptr), (val))
-#define atomic_xor_fetch_32(ptr, val) __sync_xor_and_fetch((ptr), (val))
-#define atomic_xor_fetch_64(ptr, val) __sync_xor_and_fetch((ptr), (val))
-#define atomic_xor_fetch_ptr(ptr, val) __sync_xor_and_fetch((ptr), (val))
-  
-#define atomic_fetch_xor_8(ptr, val) __sync_fetch_and_xor((ptr), (val))
-#define atomic_fetch_xor_16(ptr, val) __sync_fetch_and_xor((ptr), (val))
-#define atomic_fetch_xor_32(ptr, val) __sync_fetch_and_xor((ptr), (val))
-#define atomic_fetch_xor_64(ptr, val) __sync_fetch_and_xor((ptr), (val))
-#define atomic_fetch_xor_ptr(ptr, val) __sync_fetch_and_xor((ptr), (val))
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

src/os/inc/osRand.h

@@ -20,7 +20,6 @@
 extern "C" {
 #endif
 
-// TAOS_OS_FUNC_RAND
 uint32_t taosRand(void);
 void     taosRandStr(char* str, int32_t size);
 uint32_t taosSafeRand(void);

src/os/inc/osSemphone.h

@@ -20,7 +20,13 @@
 extern "C" {
 #endif
 
-#ifndef TAOS_OS_FUNC_SEMPHONE
+#if defined (_TD_DARWIN_64)
+  typedef struct tsem_s *tsem_t;
+  int tsem_init(tsem_t *sem, int pshared, unsigned int value);
+  int tsem_wait(tsem_t *sem);
+  int tsem_post(tsem_t *sem);
+  int tsem_destroy(tsem_t *sem);
+#else
   #define tsem_t sem_t
   #define tsem_init sem_init
   int tsem_wait(tsem_t* sem);
@@ -28,7 +34,7 @@ extern "C" {
   #define tsem_destroy sem_destroy
 #endif
 
-#ifdef TAOS_OS_FUNC_PTHREAD_RWLOCK
+#if defined (_TD_DARWIN_64)
   #define pthread_rwlock_t pthread_mutex_t
   #define pthread_rwlock_init(lock, NULL) pthread_mutex_init(lock, NULL)
   #define pthread_rwlock_destroy(lock) pthread_mutex_destroy(lock)
@@ -43,7 +49,6 @@ extern "C" {
   #define pthread_spin_unlock(lock) pthread_mutex_unlock(lock)
 #endif
 
-// TAOS_OS_FUNC_SEMPHONE_PTHREAD
 bool    taosCheckPthreadValid(pthread_t thread);
 int64_t taosGetSelfPthreadId();
 int64_t taosGetPthreadId(pthread_t thread);

src/os/inc/osSignal.h

@@ -20,8 +20,6 @@
 extern "C" {
 #endif
 
-#include "os.h"
-#include "taosdef.h"
 #include <signal.h>
 
 #ifndef SIGALRM
@@ -57,4 +55,4 @@ void taosDflSignal(int32_t signum);
 }
 #endif
 
-#endif  // TDENGINE_TTIME_H
+#endif  // TDENGINE_OS_SIGNAL_H

src/os/inc/osSleep.h

@@ -13,16 +13,14 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef TDENGINE_OS_COMMON_H
+#ifndef TDENGINE_OS_SLEEP_H
-#define TDENGINE_OS_COMMON_H
+#define TDENGINE_OS_SLEEP_H
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#ifndef TAOS_OS_DEF_ZU
+void taosMsleep(int32_t ms);
-  #define PRIzu "zu"
-#endif
 
 #ifdef __cplusplus
 }

src/os/inc/osSocket.h

@@ -20,7 +20,14 @@
 extern "C" {
 #endif
 
-#ifndef TAOS_OS_FUNC_SOCKET_OP
+#if defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
+  #define taosSend(sockfd, buf, len, flags) send((SOCKET)sockfd, buf, len, flags)
+  #define taosSendto(sockfd, buf, len, flags, dest_addr, addrlen) sendto((SOCKET)sockfd, buf, len, flags, dest_addr, addrlen)
+  #define taosWriteSocket(fd, buf, len) send((SOCKET)fd, buf, len, 0)
+  #define taosReadSocket(fd, buf, len) recv((SOCKET)fd, buf, len, 0)
+  #define taosCloseSocketNoCheck(fd) closesocket((SOCKET)fd)
+  #define taosCloseSocket(fd) closesocket((SOCKET)fd)
+#else
   #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)
@@ -35,7 +42,21 @@ extern "C" {
     }
 #endif
 
-#ifndef TAOS_OS_DEF_EPOLL
+#if defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
+  #define TAOS_EPOLL_WAIT_TIME 100
+  typedef SOCKET eventfd_t; 
+  #define eventfd(a, b) -1
+  typedef SOCKET EpollFd; 
+  #define EpollClose(pollFd) epoll_close(pollFd) 
+  #ifndef EPOLLWAKEUP
+    #define EPOLLWAKEUP (1u << 29)
+  #endif
+#elif defined(_TD_DARWIN_64)
+  #define TAOS_EPOLL_WAIT_TIME 500
+  typedef int32_t SOCKET;
+  typedef SOCKET EpollFd;
+  #define EpollClose(pollFd) epoll_close(pollFd)
+#else
   #define TAOS_EPOLL_WAIT_TIME 500 
   typedef int32_t SOCKET;
   typedef SOCKET EpollFd;
@@ -59,21 +80,27 @@ extern "C" {
   #endif  
 #endif
 
-// TAOS_OS_FUNC_SOCKET
 int32_t taosSetNonblocking(SOCKET sock, int32_t on);
 void    taosIgnSIGPIPE();
 void    taosBlockSIGPIPE();
 void    taosSetMaskSIGPIPE();
-
-// TAOS_OS_FUNC_SOCKET_SETSOCKETOPT
 int32_t taosSetSockOpt(SOCKET socketfd, int32_t level, int32_t optname, void *optval, int32_t optlen);
-
 int32_t taosGetSockOpt(SOCKET socketfd, int32_t level, int32_t optname, void *optval, int32_t* optlen);
 
-// TAOS_OS_FUNC_SOCKET_INET
 uint32_t    taosInetAddr(char *ipAddr);
 const char *taosInetNtoa(struct in_addr ipInt);
 
+#if (defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)) 
+  #define htobe64 htonll
+  #if defined(_TD_GO_DLL_)
+    uint64_t htonll(uint64_t val);
+  #endif
+#endif
+
+#if defined(_TD_DARWIN_64)
+  #define htobe64 htonll
+#endif
+
 #ifdef __cplusplus
 }
 #endif

src/os/inc/osString.h

@@ -20,18 +20,15 @@
 extern "C" {
 #endif
 
-#ifndef TAOS_OS_FUNC_STRING_STRDUP
+#if defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
-  #define taosStrdupImp(str) strdup(str)
+  #define tstrdup(str) _strdup(str)
-  #define taosStrndupImp(str, size) strndup(str, size)
+  #define tstrndup(str, size) _strndup(str, size)  
-#endif
+  int32_t tgetline(char **lineptr, size_t *n, FILE *stream);
-
+  int32_t twcslen(const wchar_t *wcs);
-#ifndef TAOS_OS_FUNC_STRING_GETLINE
-  #define taosGetlineImp(lineptr, n, stream) getline(lineptr, n , stream)
 #else
-  int taosGetlineImp(char **lineptr, size_t *n, FILE *stream);
+  #define tstrdup(str) strdup(str)
-#endif
+  #define tstrndup(str, size) strndup(str, size)
-
+  #define tgetline(lineptr, n, stream) getline(lineptr, n, stream)
-#ifndef TAOS_OS_FUNC_STRING_WCHAR
   #define twcslen wcslen
 #endif
 
@@ -41,14 +38,12 @@ extern "C" {
     (dst)[(size)-1] = 0;            \
   } while (0)
 
-#ifndef TAOS_OS_FUNC_STRING_STR2INT64
+int64_t taosStr2int64(char *str);
-  int64_t tsosStr2int64(char *str);
-#endif  
 
 // USE_LIBICONV
 int32_t taosUcs4ToMbs(void *ucs4, int32_t ucs4_max_len, char *mbs);
-bool    taosMbsToUcs4(char *mbs, size_t mbs_len, char *ucs4, int32_t ucs4_max_len, int *len);
+bool    taosMbsToUcs4(char *mbs, size_t mbs_len, char *ucs4, int32_t ucs4_max_len, int32_t *len);
-int     tasoUcs4Compare(void *f1_ucs4, void *f2_ucs4, int bytes);
+int32_t tasoUcs4Compare(void *f1_ucs4, void *f2_ucs4, int32_t bytes);
 bool    taosValidateEncodec(const char *encodec);
 char *  taosCharsetReplace(char *charsetstr);
 

src/os/inc/osSysinfo.h

@@ -20,7 +20,6 @@
 extern "C" {
 #endif
 
-// TAOS_OS_FUNC_SYSINFO
 typedef struct {
   int64_t tsize;
   int64_t used;
@@ -32,16 +31,15 @@ void taosGetSystemInfo();
 bool    taosGetProcIO(float *readKB, float *writeKB);
 bool    taosGetBandSpeed(float *bandSpeedKb);
 void    taosGetDisk();
-bool taosGetCpuUsage(float *sysCpuUsage, float *procCpuUsage) ;
+bool    taosGetCpuUsage(float *sysCpuUsage, float *procCpuUsage);
-bool taosGetProcMemory(float *memoryUsedMB) ;
+bool    taosGetProcMemory(float *memoryUsedMB);
 bool    taosGetSysMemory(float *memoryUsedMB);
 void    taosPrintOsInfo();
-int  taosSystem(const char * cmd) ;
+int     taosSystem(const char *cmd);
 void    taosKillSystem();
 bool    taosGetSystemUid(char *uid);
-char *taosGetCmdlineByPID(int pid);
+char *  taosGetCmdlineByPID(int pid);
 
-// TAOS_OS_FUNC_SYSINFO_CORE
 void taosSetCoreDump();
 
 #ifdef __cplusplus

src/os/inc/osTime.h

@@ -23,9 +23,16 @@ extern "C" {
 #include "os.h"
 #include "taosdef.h"
 
-#ifndef TAOS_OS_FUNC_TIME_DEF
+#if defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
+  #ifdef _TD_GO_DLL_
+    #define MILLISECOND_PER_SECOND (1000LL)
+  #else
+    #define MILLISECOND_PER_SECOND (1000i64)
+  #endif
+#else
   #define MILLISECOND_PER_SECOND ((int64_t)1000L)
 #endif
+
 #define MILLISECOND_PER_MINUTE (MILLISECOND_PER_SECOND * 60)
 #define MILLISECOND_PER_HOUR   (MILLISECOND_PER_MINUTE * 60)
 #define MILLISECOND_PER_DAY    (MILLISECOND_PER_HOUR * 24)

src/os/inc/osTimer.h

@@ -20,8 +20,6 @@
 extern "C" {
 #endif
 
-// TAOS_OS_FUNC_TIMER
-void taosMsleep(int mseconds);
 int taosInitTimer(void (*callback)(int), int ms);
 void taosUninitTimer();
 

src/os/inc/osWindows.h

@@ -1,352 +0,0 @@
-/*
-* 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_WINDOWS_H
-#define TDENGINE_OS_WINDOWS_H
-
-#include <assert.h>
-#include <ctype.h>
-#include <errno.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 "winsock2.h"
-#include <WS2tcpip.h>
-#include <winbase.h>
-#include <Winsock2.h>
-#include <time.h>
-#include <inttypes.h>
-#include <conio.h>
-#include <math.h>
-#include "msvcProcess.h"
-#include "msvcDirect.h"
-#include "msvcFcntl.h"
-#include "msvcLibgen.h"
-#include "msvcStdio.h"
-#include "msvcUnistd.h"
-#include "msvcLibgen.h"
-#include "sys/msvcStat.h"
-#include "sys/msvcTypes.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define TAOS_OS_FUNC_LZ4
-  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);
-
-#define TAOS_OS_FUNC_FILE
-#define TAOS_OS_FUNC_FILE_ISREG
-#define TAOS_OS_FUNC_FILE_ISDIR
-#define TAOS_OS_FUNC_FILE_ISLNK
-#define TAOS_OS_FUNC_FILE_SENDIFLE
-#define TAOS_OS_FUNC_FILE_GETTMPFILEPATH
-#define TAOS_OS_FUNC_FILE_FTRUNCATE 
-
-#define TAOS_OS_FUNC_DIR
-
-#define TAOS_OS_FUNC_MATH
-  #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))
-
-#define TAOS_OS_FUNC_SEMPHONE_PTHREAD
-
-#define TAOS_OS_FUNC_SOCKET
-#define TAOS_OS_FUNC_SOCKET_SETSOCKETOPT
-#define TAOS_OS_FUNC_SOCKET_OP
-  #define taosSend(sockfd, buf, len, flags) send((SOCKET)sockfd, buf, len, flags)
-  #define taosSendto(sockfd, buf, len, flags, dest_addr, addrlen) sendto((SOCKET)sockfd, buf, len, flags, dest_addr, addrlen)
-  #define taosWriteSocket(fd, buf, len) send((SOCKET)fd, buf, len, 0)
-  #define taosReadSocket(fd, buf, len) recv((SOCKET)fd, buf, len, 0)
-  #define taosCloseSocketNoCheck(fd) closesocket((SOCKET)fd)
-  #define taosCloseSocket(fd) closesocket((SOCKET)fd)
-typedef SOCKET eventfd_t; 
-#define eventfd(a, b) -1
-
-#define TAOS_OS_DEF_EPOLL
-  #define TAOS_EPOLL_WAIT_TIME 100
-  typedef SOCKET EpollFd; 
-  #define EpollClose(pollFd) epoll_close(pollFd) 
-  
-#ifndef EPOLLWAKEUP
-  #define EPOLLWAKEUP (1u << 29)
-#endif
-
-#define TAOS_OS_DEF_ZU
-  #define PRIzu "ld"  
-
-#define TAOS_OS_FUNC_STRING_WCHAR
-  int twcslen(const wchar_t *wcs);
-#define TAOS_OS_FUNC_STRING_GETLINE
-#define TAOS_OS_FUNC_STRING_STR2INT64
-  #ifdef _TD_GO_DLL_
-    int64_t tsosStr2int64(char *str);
-    uint64_t htonll(uint64_t val);
-  #else
-    #define tsosStr2int64 _atoi64
-  #endif
-#define TAOS_OS_FUNC_STRING_STRDUP
-  #define taosStrdupImp(str) _strdup(str)
-  #define taosStrndupImp(str, size) _strndup(str, size)  
-
-char *stpcpy (char *dest, const char *src);
-char *stpncpy (char *dest, const char *src, size_t n);
-
-#define TAOS_OS_FUNC_SYSINFO
-
-#define TAOS_OS_FUNC_TIME_DEF
-  #ifdef _TD_GO_DLL_
-    #define MILLISECOND_PER_SECOND (1000LL)
-  #else
-    #define MILLISECOND_PER_SECOND (1000i64)
-  #endif
-
-#define TAOS_OS_FUNC_TIMER_SLEEP
-#define TAOS_OS_FUNC_TIMER
-
-// specific
-typedef int (*__compar_fn_t)(const void *, const void *);
-#define ssize_t int
-#define bzero(ptr, size) memset((ptr), 0, (size))
-#define strcasecmp  _stricmp
-#define strncasecmp _strnicmp
-#define wcsncasecmp _wcsnicmp
-#define strtok_r strtok_s
-#define snprintf _snprintf
-#define in_addr_t unsigned long
-#define socklen_t int
-#define htobe64 htonll
-
-struct tm *localtime_r(const time_t *timep, struct tm *result);
-char *     strptime(const char *buf, const char *fmt, struct tm *tm);
-char *     strsep(char **stringp, const char *delim);
-char *     getpass(const char *prefix);
-int        flock(int fd, int option);
-int        fsync(int filedes);
-char *     strndup(const char *s, size_t n);
-int        gettimeofday(struct timeval *ptv, void *pTimeZone);
-
-// for send function in tsocket.c
-#define MSG_NOSIGNAL             0
-#define SO_NO_CHECK              0x1234
-#define SOL_TCP                  0x1234
-
-#ifndef TCP_KEEPCNT
-  #define TCP_KEEPCNT              0x1234
-#endif
-
-#ifndef TCP_KEEPIDLE
-  #define TCP_KEEPIDLE             0x1234
-#endif
-
-#ifndef TCP_KEEPINTVL
-  #define TCP_KEEPINTVL            0x1234
-#endif
-
-#ifdef _MSC_VER
-//#if _MSC_VER >= 1900
-  #define TAOS_OS_FUNC_SOCKET_INET
-//#endif
-#endif
-
-#define SHUT_RDWR                SD_BOTH
-#define SHUT_RD                  SD_RECEIVE
-#define SHUT_WR                  SD_SEND
-
-#define LOCK_EX 1
-#define LOCK_NB 2
-#define LOCK_UN 3
-
-#ifndef PATH_MAX
-  #define PATH_MAX 256
-#endif
-
-#define TAOS_OS_FUNC_SIGNAL
-
-typedef struct {
-  int    we_wordc;
-  char  *we_wordv[1];
-  int    we_offs;
-  char   wordPos[1025];
-} wordexp_t;
-int  wordexp(char *words, wordexp_t *pwordexp, int flags);
-void wordfree(wordexp_t *pwordexp);
-
-#define openlog(a, b, c)
-#define closelog()
-#define LOG_ERR 0
-#define LOG_INFO 1
-void syslog(int unused, const char *format, ...);
-
-#define TAOS_OS_FUNC_ATOMIC
-  #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))
-
-  #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))
-  #ifdef _WIN64 
-    #define atomic_exchange_ptr(ptr, val) _InterlockedExchangePointer((void* volatile*)(ptr), (void*)(val)) 
-  #else
-    #define atomic_exchange_ptr(ptr, val) _InlineInterlockedExchangePointer((void* volatile*)(ptr), (void*)(val))
-  #endif
-  
-  #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);
-
-  char interlocked_and_fetch_8(char volatile* ptr, char val);
-  short interlocked_and_fetch_16(short volatile* ptr, short val);
-  long interlocked_and_fetch_32(long volatile* ptr, long val);
-  __int64 interlocked_and_fetch_64(__int64 volatile* ptr, __int64 val);
-
-  __int64 interlocked_fetch_and_64(__int64 volatile* ptr, __int64 val);
-
-  char interlocked_or_fetch_8(char volatile* ptr, char val);
-  short interlocked_or_fetch_16(short volatile* ptr, short val);
-  long interlocked_or_fetch_32(long volatile* ptr, long val);
-  __int64 interlocked_or_fetch_64(__int64 volatile* ptr, __int64 val);
-
-  char interlocked_xor_fetch_8(char volatile* ptr, char val);
-  short interlocked_xor_fetch_16(short volatile* ptr, short val);
-  long interlocked_xor_fetch_32(long volatile* ptr, long val);
-  __int64 interlocked_xor_fetch_64(__int64 volatile* ptr, __int64 val);
-
-  __int64 interlocked_fetch_xor_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 _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_8(ptr, val) _InterlockedExchangeAdd8((char volatile*)(ptr), (char)(val))
-  #define atomic_fetch_add_16(ptr, val) _InterlockedExchangeAdd16((short volatile*)(ptr), (short)(val))
-  #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))
-  
-  #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))
-
-  #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))
-
-  #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))
-  #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))
-
-  #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))
-  #define atomic_fetch_and_32(ptr, val) _InterlockedAnd((long volatile*)(ptr), (long)(val))
-  #define atomic_fetch_and_64(ptr, val) interlocked_fetch_and_64((__int64 volatile*)(ptr), (__int64)(val))
-
-  #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))
-  #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))
-
-  #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))
-  #define atomic_fetch_or_32(ptr, val) _InterlockedOr((long volatile*)(ptr), (long)(val))
-  #define atomic_fetch_or_64(ptr, val) interlocked_fetch_or_64((__int64 volatile*)(ptr), (__int64)(val))
-
-  #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))
-  #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))
-
-  #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))
-  #define atomic_fetch_xor_32(ptr, val) _InterlockedXor((long volatile*)(ptr), (long)(val))
-  #define atomic_fetch_xor_64(ptr, val) interlocked_fetch_xor_64((__int64 volatile*)(ptr), (__int64)(val))
-
-  #ifdef _WIN64
-    #define atomic_add_fetch_ptr atomic_add_fetch_64
-    #define atomic_fetch_add_ptr atomic_fetch_add_64
-    #define atomic_sub_fetch_ptr atomic_sub_fetch_64
-    #define atomic_fetch_sub_ptr atomic_fetch_sub_64
-    #define atomic_and_fetch_ptr atomic_and_fetch_64
-    #define atomic_fetch_and_ptr atomic_fetch_and_64
-    #define atomic_or_fetch_ptr  atomic_or_fetch_64
-    #define atomic_fetch_or_ptr  atomic_fetch_or_64
-    #define atomic_xor_fetch_ptr atomic_xor_fetch_64
-    #define atomic_fetch_xor_ptr atomic_fetch_xor_64
-  #else
-    #define atomic_add_fetch_ptr atomic_add_fetch_32
-    #define atomic_fetch_add_ptr atomic_fetch_add_32
-    #define atomic_sub_fetch_ptr atomic_sub_fetch_32
-    #define atomic_fetch_sub_ptr atomic_fetch_sub_32
-    #define atomic_and_fetch_ptr atomic_and_fetch_32
-    #define atomic_fetch_and_ptr atomic_fetch_and_32
-    #define atomic_or_fetch_ptr  atomic_or_fetch_32
-    #define atomic_fetch_or_ptr  atomic_fetch_or_32
-    #define atomic_xor_fetch_ptr atomic_xor_fetch_32
-    #define atomic_fetch_xor_ptr atomic_fetch_xor_32
-  #endif
-#ifdef __cplusplus
-}
-#endif
-#endif

src/os/src/alpine/CMakeLists.txt

@@ -1,7 +0,0 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
-PROJECT(TDengine)
-
-AUX_SOURCE_DIRECTORY(. SRC)
-ADD_LIBRARY(os ${SRC})
-TARGET_LINK_LIBRARIES(os m rt)
-

src/os/src/alpine/alpineEnv.c

@@ -1,32 +0,0 @@
-/*
- * 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"
-
-void osInit() {
-  if (configDir[0] == 0) {
-    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/darwin/CMakeLists.txt

@@ -2,4 +2,4 @@ CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
 PROJECT(TDengine)
 
 AUX_SOURCE_DIRECTORY(. SRC)
-ADD_LIBRARY(os ${SRC})
+ADD_LIBRARY(osdarwin ${SRC})

src/os/src/darwin/darwinFile.c

@@ -1,65 +0,0 @@
-/*
- * 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"
-
-int64_t taosFSendFile(FILE *out_file, FILE *in_file, int64_t *offset, int64_t count) {
-  int r = 0;
-  if (offset) {
-    r = fseek(in_file, *offset, SEEK_SET);
-    if (r==-1) return -1;
-  }
-  off_t len = count;
-  while (len>0) {
-    char buf[1024*16];
-    off_t n = sizeof(buf);
-    if (len<n) n = len;
-    size_t m = fread(buf, 1, n, in_file);
-    if (m<n) {
-      int e = ferror(in_file);
-      if (e) return -1;
-    }
-    if (m==0) break;
-    if (m!=fwrite(buf, 1, m, out_file)) {
-      return -1;
-    }
-    len -= m;
-  }
-  return count - len;
-}
-
-int64_t taosSendFile(SOCKET dfd, int32_t sfd, int64_t* offset, int64_t count) {
-  int r = 0;
-  if (offset) {
-    r = lseek(sfd, *offset, SEEK_SET);
-    if (r==-1) return -1;
-  }
-  off_t len = count;
-  while (len>0) {
-    char buf[1024*16];
-    off_t n = sizeof(buf);
-    if (len<n) n = len;
-    size_t m = read(sfd, buf, n);
-    if (m==-1) return -1;
-    if (m==0) break;
-    size_t l = write(dfd, buf, m);
-    if (l==-1) return -1;
-    len -= l;
-  }
-  return count - len;
-}
-

src/os/src/darwin/darwinString.c

@@ -1,22 +0,0 @@
-/*
- * 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"
-
-int64_t tsosStr2int64(char *str) {
-  char *endptr = NULL;
-  return strtoll(str, &endptr, 10);
-}

src/os/src/darwin/dwEok.c

@@ -18,9 +18,9 @@
 // https://stackoverflow.com/questions/4393197/erlangs-let-it-crash-philosophy-applicable-elsewhere
 // experimentally, we follow log-and-crash here
 
-#include "eok.h"
+#define _DEFAULT_SOURCE
-
 #include "os.h"
+#include "osEok.h"
 
 #include <sys/event.h>
 
@@ -415,8 +415,6 @@ int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event) {
 static struct timespec do_timespec_diff(struct timespec *from, struct timespec *to);
 
 int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout) {
-  taos_block_sigalrm();
-
   int e = 0;
   if (!events) {
     errno = EINVAL;

src/os/src/darwin/dwSemphone.c

@@ -20,7 +20,6 @@
 
 #define _DEFAULT_SOURCE
 #include "os.h"
-
 #include <libproc.h>
 
 // #define SEM_USE_PTHREAD

src/os/src/darwin/dwSysInfo.c

@@ -22,7 +22,6 @@
 #include <errno.h>
 #include <libproc.h>
 
-
 static void taosGetSystemTimezone() {
   SGlobalCfg *cfg_timezone = taosGetConfigOption("timezone");
   if (cfg_timezone == NULL) return;

src/os/src/detail/CMakeLists.txt

@@ -7,10 +7,15 @@ 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})
+ADD_LIBRARY(os ${SRC})
-TARGET_LINK_LIBRARIES(osdetail os)
 
-IF (TD_ARM_32 OR TD_LINUX_32)
+IF (TD_LINUX)
-  TARGET_LINK_LIBRARIES(osdetail atomic)
+  TARGET_LINK_LIBRARIES(os oslinux)
+  IF (TD_ARM_32 OR TD_LINUX_32)
+    TARGET_LINK_LIBRARIES(os atomic)
+  ENDIF ()
+ELSEIF (TD_DARWIN)
+  TARGET_LINK_LIBRARIES(os osdarwin)
+ELSEIF (TD_WINDOWS)
+  TARGET_LINK_LIBRARIES(os oswindows)
 ENDIF ()
-

src/os/src/detail/osAtomic.c

@@ -53,4 +53,3 @@ int64_t atomic_exchange_64_impl(int64_t* ptr, int64_t val ) {
   return old;
 }
 #endif
-

src/os/src/detail/osDir.c

@@ -51,22 +51,6 @@ int taosMkDir(const char *path, mode_t mode) {
   return code;
 }
 
-
-#ifndef TAOS_OS_FUNC_DIR
-
-int32_t taosRename(char* oldName, char *newName) {
-  int32_t code = rename(oldName, newName);
-  if (code < 0) {
-    uError("failed to rename file %s to %s, reason:%s", oldName, newName, strerror(errno));
-  } else {
-    uTrace("successfully to rename file %s to %s", oldName, newName);
-  }
-
-  return code;
-}
-
-#endif
-
 void taosRemoveOldLogFiles(char *rootDir, int32_t keepDays) {
   DIR *dir = opendir(rootDir);
   if (dir == NULL) return;

src/os/src/detail/osFile.c

@@ -16,8 +16,39 @@
 #define _DEFAULT_SOURCE
 #include "os.h"
 #include "tglobal.h"
+#include "tulog.h"
 
-#ifndef TAOS_OS_FUNC_FILE_GETTMPFILEPATH
+void taosClose(FileFd fd) {
+  close(fd);
+  fd = FD_INITIALIZER;
+}
+
+#if defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
+
+void taosGetTmpfilePath(const char *fileNamePrefix, char *dstPath) {
+  const char *tdengineTmpFileNamePrefix = "tdengine-";
+  char        tmpPath[PATH_MAX];
+
+  int32_t len = (int32_t)strlen(tsTempDir);
+  memcpy(tmpPath, tsTempDir, len);
+
+  if (tmpPath[len - 1] != '/' && tmpPath[len - 1] != '\\') {
+    tmpPath[len++] = '\\';
+  }
+
+  strcpy(tmpPath + len, tdengineTmpFileNamePrefix);
+  strcat(tmpPath, tdengineTmpFileNamePrefix);
+  if (strlen(tmpPath) + strlen(fileNamePrefix) + strlen("-%d-%s") < PATH_MAX) {
+    strcat(tmpPath, fileNamePrefix);
+    strcat(tmpPath, "-%d-%s");
+  }
+
+  char rand[8] = {0};
+  taosRandStr(rand, tListLen(rand) - 1);
+  snprintf(dstPath, PATH_MAX, tmpPath, getpid(), rand);
+}
+
+#else
 
 void taosGetTmpfilePath(const char *fileNamePrefix, char *dstPath) {
   const char *tdengineTmpFileNamePrefix = "tdengine-";
@@ -39,42 +70,14 @@ void taosGetTmpfilePath(const char *fileNamePrefix, char *dstPath) {
 
   char rand[32] = {0};
 
-  sprintf(rand, "%"PRIu64, atomic_add_fetch_64(&seqId, 1));
+  sprintf(rand, "%" PRIu64, atomic_add_fetch_64(&seqId, 1));
 
   snprintf(dstPath, PATH_MAX, tmpPath, getpid(), rand);
 }
 
 #endif
 
-int32_t taosRenameFile(char *fullPath, char *suffix, char delimiter, char **dstPath) {
+int64_t taosRead(FileFd fd, void *buf, int64_t count) {
-  int32_t ts = taosGetTimestampSec();
-
-  char fname[PATH_MAX] = {0};  // max file name length must be less than 255
-
-  char *delimiterPos = strrchr(fullPath, delimiter);
-  if (delimiterPos == NULL) return -1;
-
-  int32_t fileNameLen = 0;
-  if (suffix) {
-    fileNameLen = snprintf(fname, PATH_MAX, "%s.%d.%s", delimiterPos + 1, ts, suffix);
-  } else {
-    fileNameLen = snprintf(fname, PATH_MAX, "%s.%d", delimiterPos + 1, ts);
-  }
-
-  int32_t len = (int32_t)((delimiterPos - fullPath) + fileNameLen + 1);
-  if (*dstPath == NULL) {
-    *dstPath = calloc(1, len + 1);
-    if (*dstPath == NULL) return -1;
-  }
-
-  strncpy(*dstPath, fullPath, (size_t)(delimiterPos - fullPath + 1));
-  strncat(*dstPath, fname, (size_t)fileNameLen);
-  (*dstPath)[len] = 0;
-
-  return rename(fullPath, *dstPath);
-}
-
-int64_t taosReadImp(int32_t fd, void *buf, int64_t count) {
   int64_t leftbytes = count;
   int64_t readbytes;
   char *  tbuf = (char *)buf;
@@ -98,7 +101,7 @@ int64_t taosReadImp(int32_t fd, void *buf, int64_t count) {
   return count;
 }
 
-int64_t taosWriteImp(int32_t fd, void *buf, int64_t n) {
+int64_t taosWrite(FileFd fd, void *buf, int64_t n) {
   int64_t nleft = n;
   int64_t nwritten = 0;
   char *  tbuf = (char *)buf;
@@ -118,9 +121,7 @@ int64_t taosWriteImp(int32_t fd, void *buf, int64_t n) {
   return n;
 }
 
-int64_t taosLSeekImp(int32_t fd, int64_t offset, int32_t whence) {
+int64_t taosLSeek(FileFd fd, int64_t offset, int32_t whence) { return (int64_t)lseek(fd, (long)offset, whence); }
-  return (int64_t)lseek(fd, (long)offset, whence);
-}
 
 int64_t taosCopy(char *from, char *to) {
   char    buffer[4096];
@@ -145,22 +146,139 @@ int64_t taosCopy(char *from, char *to) {
     if (bytes < sizeof(buffer)) break;
   }
 
-  fsync(fidto);
+  taosFsync(fidto);
 
-  close(fidfrom);
+  taosClose(fidfrom);
-  close(fidto);
+  taosClose(fidto);
   return size;
 
 _err:
-  if (fidfrom >= 0) close(fidfrom);
+  if (fidfrom >= 0) taosClose(fidfrom);
-  if (fidto >= 0) close(fidto);
+  if (fidto >= 0) taosClose(fidto);
   remove(to);
   return -1;
 }
 
-#ifndef TAOS_OS_FUNC_FILE_SENDIFLE
+#if defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
 
-int64_t taosSendFile(SOCKET dfd, int32_t sfd, int64_t *offset, int64_t size) {
+#define _SEND_FILE_STEP_ 1000
+
+int64_t taosFSendFile(FILE *out_file, FILE *in_file, int64_t *offset, int64_t count) {
+  fseek(in_file, (int32_t)(*offset), 0);
+  int64_t writeLen = 0;
+  uint8_t buffer[_SEND_FILE_STEP_] = {0};
+
+  for (int64_t 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 (int64_t)(writeLen + rlen);
+    } else {
+      fwrite(buffer, 1, _SEND_FILE_STEP_, in_file);
+      writeLen += _SEND_FILE_STEP_;
+    }
+  }
+
+  int64_t remain = count - writeLen;
+  if (remain > 0) {
+    size_t rlen = fread(buffer, 1, (size_t)remain, in_file);
+    if (rlen <= 0) {
+      return writeLen;
+    } else {
+      fwrite(buffer, 1, (size_t)remain, out_file);
+      writeLen += remain;
+    }
+  }
+
+  return writeLen;
+}
+
+int64_t taosSendFile(SocketFd dfd, FileFd sfd, int64_t *offset, int64_t count) {
+  if (offset != NULL) lseek(sfd, (int32_t)(*offset), 0);
+
+  int64_t writeLen = 0;
+  uint8_t buffer[_SEND_FILE_STEP_] = {0};
+
+  for (int64_t len = 0; len < (count - _SEND_FILE_STEP_); len += _SEND_FILE_STEP_) {
+    int32_t rlen = (int32_t)read(sfd, buffer, _SEND_FILE_STEP_);
+    if (rlen <= 0) {
+      return writeLen;
+    } else if (rlen < _SEND_FILE_STEP_) {
+      taosWriteSocket(dfd, buffer, rlen);
+      return (int64_t)(writeLen + rlen);
+    } else {
+      taosWriteSocket(dfd, buffer, _SEND_FILE_STEP_);
+      writeLen += _SEND_FILE_STEP_;
+    }
+  }
+
+  int64_t remain = count - writeLen;
+  if (remain > 0) {
+    int32_t rlen = read(sfd, buffer, (int32_t)remain);
+    if (rlen <= 0) {
+      return writeLen;
+    } else {
+      taosWriteSocket(sfd, buffer, (int32_t)remain);
+      writeLen += remain;
+    }
+  }
+
+  return writeLen;
+}
+
+#elif defined(_TD_DARWIN_64)
+
+int64_t taosFSendFile(FILE *out_file, FILE *in_file, int64_t *offset, int64_t count) {
+  int r = 0;
+  if (offset) {
+    r = fseek(in_file, *offset, SEEK_SET);
+    if (r == -1) return -1;
+  }
+  off_t len = count;
+  while (len > 0) {
+    char  buf[1024 * 16];
+    off_t n = sizeof(buf);
+    if (len < n) n = len;
+    size_t m = fread(buf, 1, n, in_file);
+    if (m < n) {
+      int e = ferror(in_file);
+      if (e) return -1;
+    }
+    if (m == 0) break;
+    if (m != fwrite(buf, 1, m, out_file)) {
+      return -1;
+    }
+    len -= m;
+  }
+  return count - len;
+}
+
+int64_t taosSendFile(SocketFd dfd, FileFd sfd, int64_t *offset, int64_t count) {
+  int r = 0;
+  if (offset) {
+    r = lseek(sfd, *offset, SEEK_SET);
+    if (r == -1) return -1;
+  }
+  off_t len = count;
+  while (len > 0) {
+    char  buf[1024 * 16];
+    off_t n = sizeof(buf);
+    if (len < n) n = len;
+    size_t m = read(sfd, buf, n);
+    if (m == -1) return -1;
+    if (m == 0) break;
+    size_t l = write(dfd, buf, m);
+    if (l == -1) return -1;
+    len -= l;
+  }
+  return count - len;
+}
+
+#else
+
+int64_t taosSendFile(SocketFd dfd, FileFd sfd, int64_t *offset, int64_t size) {
   int64_t leftbytes = size;
   int64_t sentbytes;
 
@@ -188,10 +306,96 @@ int64_t taosFSendFile(FILE *outfile, FILE *infile, int64_t *offset, int64_t size
 
 #endif
 
-#ifndef TAOS_OS_FUNC_FILE_FTRUNCATE
+#if defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
 
-int32_t taosFtruncate(int32_t fd, int64_t length) {
+int32_t taosFtruncate(int32_t fd, int64_t l_size) {
-  return ftruncate(fd, length);
+  if (fd < 0) {
+    errno = EBADF;
+    uError("%s\n", "fd arg was negative");
+    return -1;
+  }
+
+  HANDLE h = (HANDLE)_get_osfhandle(fd);
+
+  LARGE_INTEGER li_0;
+  li_0.QuadPart = (int64_t)0;
+  BOOL cur = SetFilePointerEx(h, li_0, NULL, FILE_CURRENT);
+  if (!cur) {
+    uError("SetFilePointerEx Error getting current position in file.\n");
+    return -1;
+  }
+
+  LARGE_INTEGER li_size;
+  li_size.QuadPart = l_size;
+  BOOL cur2 = SetFilePointerEx(h, li_size, NULL, FILE_BEGIN);
+  if (cur2 == 0) {
+    int error = GetLastError();
+    uError("SetFilePointerEx GetLastError is: %d\n", error);
+    switch (error) {
+      case ERROR_INVALID_HANDLE:
+        errno = EBADF;
+        break;
+      default:
+        errno = EIO;
+        break;
+    }
+    return -1;
+  }
+
+  if (!SetEndOfFile(h)) {
+    int error = GetLastError();
+    uError("SetEndOfFile GetLastError is:%d", error);
+    switch (error) {
+      case ERROR_INVALID_HANDLE:
+        errno = EBADF;
+        break;
+      default:
+        errno = EIO;
+        break;
+    }
+    return -1;
+  }
+
+  return 0;
+}
+
+int32_t taosFsync(FileFd fd) {
+  if (fd < 0) {
+    errno = EBADF;
+    uError("%s\n", "fd arg was negative");
+    return -1;
+  }
+
+  HANDLE h = (HANDLE)_get_osfhandle(fd);
+
+  return FlushFileBuffers(h);
+}
+
+int32_t taosRename(char *oldName, char *newName) {
+  int32_t code = MoveFileEx(oldName, newName, MOVEFILE_REPLACE_EXISTING | MOVEFILE_COPY_ALLOWED);
+  if (code < 0) {
+    uError("failed to rename file %s to %s, reason:%s", oldName, newName, strerror(errno));
+  } else {
+    uTrace("successfully to rename file %s to %s", oldName, newName);
+  }
+
+  return code;
+}
+
+#else
+
+int32_t taosFtruncate(FileFd fd, int64_t length) { return ftruncate(fd, length); }
+int32_t taosFsync(FileFd fd) { return fsync(fd); }
+
+int32_t taosRename(char *oldName, char *newName) {
+  int32_t code = rename(oldName, newName);
+  if (code < 0) {
+    uError("failed to rename file %s to %s, reason:%s", oldName, newName, strerror(errno));
+  } else {
+    uTrace("successfully to rename file %s to %s", oldName, newName);
+  }
+
+  return code;
 }
 
 #endif

src/os/src/detail/osRand.c

@@ -16,8 +16,6 @@
 #define _DEFAULT_SOURCE
 #include "os.h"
 
-#ifndef TAOS_OS_FUNC_RAND
-
 uint32_t taosRand(void) { return rand(); }
 
 uint32_t taosSafeRand(void) {
@@ -38,8 +36,6 @@ uint32_t taosSafeRand(void) {
   return (uint32_t)seed;
 }
 
-#endif
-
 void taosRandStr(char* str, int32_t size) {
   const char* set = "abcdefghijklmnopqrstuvwxyz0123456789-_.";
   int32_t     len = 39;

src/os/src/detail/osSemphone.c

@@ -16,9 +16,9 @@
 #define _DEFAULT_SOURCE
 #include "os.h"
 
-#ifndef TAOS_OS_FUNC_SEMPHONE
+#if !defined (_TD_DARWIN_64)
 
-int tsem_wait(tsem_t* sem) {
+int32_t tsem_wait(tsem_t* sem) {
   int ret = 0;
   do {
     ret = sem_wait(sem);
@@ -28,7 +28,7 @@ int tsem_wait(tsem_t* sem) {
 
 #endif
 
-#ifndef TAOS_OS_FUNC_SEMPHONE_PTHREAD
+#if !(defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32) || defined (_TD_DARWIN_64))
 
 bool taosCheckPthreadValid(pthread_t thread) { return thread != 0; }
 

src/os/src/detail/osSignal.c

@@ -15,11 +15,13 @@
 
 #define _DEFAULT_SOURCE
 #include "os.h"
+#include "taosdef.h"
 #include "tconfig.h"
 #include "tglobal.h"
 #include "tulog.h"
 
-#ifndef TAOS_OS_FUNC_SIGNAL
+#if !(defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32))
+
 typedef void (*FLinuxSignalHandler)(int32_t signum, siginfo_t *sigInfo, void *context);
 
 void taosSetSignal(int32_t signum, FSignalHandler sigfp) {

src/os/src/detail/osSleep.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/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+
+#if defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
+
+void taosMsleep(int32_t ms) { Sleep(ms); }
+
+#else
+
+/*
+  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(int32_t mseconds) {
+#if 1
+  usleep(mseconds * 1000);
+#else
+  struct timeval timeout;
+  int32_t        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); */
+#endif
+}
+
+#endif

src/os/src/detail/osSocket.c

@@ -17,7 +17,7 @@
 #include "os.h"
 #include "tulog.h"
 
-#ifndef TAOS_OS_FUNC_SOCKET
+#if !(defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32))
 
 int32_t taosSetNonblocking(SOCKET sock, int32_t on) {
   int32_t flags = 0;
@@ -65,7 +65,7 @@ void taosSetMaskSIGPIPE() {
 
 #endif
 
-#ifndef TAOS_OS_FUNC_SOCKET_SETSOCKETOPT
+#if !(defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32) || defined(_TD_DARWIN_32))
 
 int32_t taosSetSockOpt(SOCKET socketfd, int32_t level, int32_t optname, void *optval, int32_t optlen) {
   return setsockopt(socketfd, level, optname, optval, (socklen_t)optlen);
@@ -74,9 +74,10 @@ int32_t taosSetSockOpt(SOCKET socketfd, int32_t level, int32_t optname, void *op
 int32_t taosGetSockOpt(SOCKET socketfd, int32_t level, int32_t optname, void *optval, int32_t* optlen) {
   return getsockopt(socketfd, level, optname, optval, (socklen_t *)optlen);
 } 
+
 #endif
 
-#ifndef TAOS_OS_FUNC_SOCKET_INET
+#if !( (defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)) && defined(_MSC_VER) )
 
 uint32_t taosInetAddr(char *ipAddr) {
   return inet_addr(ipAddr);

src/os/src/detail/osString.c

@@ -17,17 +17,17 @@
 #include "os.h"
 #include "tglobal.h"
 
-#ifndef TAOS_OS_FUNC_STRING_STR2INT64
+int64_t taosStr2int64(char *str) {
-int64_t tsosStr2int64(char *str) {
   char *endptr = NULL;
   return strtoll(str, &endptr, 10);
 }
-#endif
 
-#ifndef TAOS_OS_FUNC_STRING_WCHAR
+#if !(defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32))
-int tasoUcs4Compare(void *f1_ucs4, void *f2_ucs4, int bytes) {
+
+int32_t tasoUcs4Compare(void *f1_ucs4, void *f2_ucs4, int32_t bytes) {
   return wcsncmp((wchar_t *)f1_ucs4, (wchar_t *)f2_ucs4, bytes / TSDB_NCHAR_SIZE);
 }
+
 #endif
 
 #ifdef USE_LIBICONV

src/os/src/detail/osSysinfo.c

@@ -20,7 +20,7 @@
 #include "tulog.h"
 #include "taoserror.h"
 
-#ifndef TAOS_OS_FUNC_SYSINFO
+#if !(defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32) || defined (_TD_DARWIN_64))
 
 #define PROCESS_ITEM 12
 

src/os/src/detail/osTimer.c

@@ -18,7 +18,7 @@
 #include "ttimer.h"
 #include "tulog.h"
 
-#ifndef TAOS_OS_FUNC_TIMER
+#if !(defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32) || defined(_TD_DARWIN_64))
 
 static void taosDeleteTimer(void *tharg) {
   timer_t *pTimer = tharg;
@@ -104,42 +104,3 @@ void taosUninitTimer() {
 }
 
 #endif
-
-#ifndef TAOS_OS_FUNC_TIMER_SLEEP
-/*
-  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) {
-#ifdef __APPLE__
-  taos_block_sigalrm();
-#endif // __APPLE__
-#if 1
-  usleep(mseconds * 1000);
-#else
-  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); */
-#endif
-
-}
-
-#endif

src/os/src/linux/CMakeLists.txt

@@ -2,6 +2,6 @@ CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
 PROJECT(TDengine)
 
 AUX_SOURCE_DIRECTORY(. SRC)
+ADD_LIBRARY(oslinux ${SRC})
 
-ADD_LIBRARY(os ${SRC})
+TARGET_LINK_LIBRARIES(oslinux m rt z)
-TARGET_LINK_LIBRARIES(os m rt z)

src/os/src/linux/linuxEnv.c

@@ -40,9 +40,8 @@ void osInit() {
   strcpy(tsOsName, "Linux");
 }
 
-char cmdline[1024];
-
 char* taosGetCmdlineByPID(int pid) {
+  static char cmdline[1024];
   sprintf(cmdline, "/proc/%d/cmdline", pid);
   FILE* f = fopen(cmdline, "r");
   if (f) {

src/os/src/windows/CMakeLists.txt

@@ -2,6 +2,6 @@ CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
 PROJECT(TDengine)
 
 AUX_SOURCE_DIRECTORY(. SRC)
-ADD_LIBRARY(os ${SRC})
+ADD_LIBRARY(oswindows ${SRC})
 
-TARGET_LINK_LIBRARIES(os winmm IPHLPAPI ws2_32 MsvcLibXw)
+TARGET_LINK_LIBRARIES(oswindows winmm IPHLPAPI ws2_32 MsvcLibXw)

src/os/src/windows/wFile.c

@@ -1,184 +0,0 @@
-/*
- * 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 "osSocket.h"
-#include "tglobal.h"
-#include "tulog.h"
-
-void taosGetTmpfilePath(const char *fileNamePrefix, char *dstPath) {
-  const char *tdengineTmpFileNamePrefix = "tdengine-";
-  char        tmpPath[PATH_MAX];
-
-  int32_t len = (int32_t)strlen(tsTempDir);
-  memcpy(tmpPath, tsTempDir, len);
-
-  if (tmpPath[len - 1] != '/' && tmpPath[len - 1] != '\\') {
-    tmpPath[len++] = '\\';
-  }
-
-  strcpy(tmpPath + len, tdengineTmpFileNamePrefix);
-  strcat(tmpPath, tdengineTmpFileNamePrefix);
-  if (strlen(tmpPath) + strlen(fileNamePrefix) + strlen("-%d-%s") < PATH_MAX) {
-    strcat(tmpPath, fileNamePrefix);
-    strcat(tmpPath, "-%d-%s");
-  }
-
-  char rand[8] = {0};
-  taosRandStr(rand, tListLen(rand) - 1);
-  snprintf(dstPath, PATH_MAX, tmpPath, getpid(), rand);
-}
-
-#define _SEND_FILE_STEP_ 1000
-
-int64_t taosFSendFile(FILE *out_file, FILE *in_file, int64_t *offset, int64_t count) {
-  fseek(in_file, (int32_t)(*offset), 0);
-  int64_t writeLen = 0;
-  uint8_t buffer[_SEND_FILE_STEP_] = {0};
-
-  for (int64_t 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 (int64_t)(writeLen + rlen);
-    } else {
-      fwrite(buffer, 1, _SEND_FILE_STEP_, in_file);
-      writeLen += _SEND_FILE_STEP_;
-    }
-  }
-
-  int64_t remain = count - writeLen;
-  if (remain > 0) {
-    size_t rlen = fread(buffer, 1, (size_t)remain, in_file);
-    if (rlen <= 0) {
-      return writeLen;
-    } else {
-      fwrite(buffer, 1, (size_t)remain, out_file);
-      writeLen += remain;
-    }
-  }
-
-  return writeLen;
-}
-
-int64_t taosSendFile(SOCKET dfd, int32_t sfd, int64_t *offset, int64_t count) {
-  if (offset != NULL) lseek(sfd, (int32_t)(*offset), 0);
-
-  int64_t writeLen = 0;
-  uint8_t buffer[_SEND_FILE_STEP_] = {0};
-
-  for (int64_t len = 0; len < (count - _SEND_FILE_STEP_); len += _SEND_FILE_STEP_) {
-    int32_t rlen = (int32_t)read(sfd, buffer, _SEND_FILE_STEP_);
-    if (rlen <= 0) {
-      return writeLen;
-    } else if (rlen < _SEND_FILE_STEP_) {
-      taosWriteSocket(dfd, buffer, rlen);
-      return (int64_t)(writeLen + rlen);
-    } else {
-      taosWriteSocket(dfd, buffer, _SEND_FILE_STEP_);
-      writeLen += _SEND_FILE_STEP_;
-    }
-  }
-
-  int64_t remain = count - writeLen;
-  if (remain > 0) {
-    int32_t rlen = read(sfd, buffer, (int32_t)remain);
-    if (rlen <= 0) {
-      return writeLen;
-    } else {
-      taosWriteSocket(sfd, buffer, (int32_t)remain);
-      writeLen += remain;
-    }
-  }
-
-  return writeLen;
-}
-
-int32_t taosFtruncate(int32_t fd, int64_t l_size) {
-  if (fd < 0) {
-    errno = EBADF;
-    uError("%s\n", "fd arg was negative");
-    return -1;
-  }
-
-  HANDLE h = (HANDLE)_get_osfhandle(fd);
-
-  LARGE_INTEGER li_0;
-  li_0.QuadPart = (int64_t)0;
-  BOOL cur = SetFilePointerEx(h, li_0, NULL, FILE_CURRENT);
-  if (!cur) {
-    uError("SetFilePointerEx Error getting current position in file.\n");
-    return -1;
-  }
-
-  LARGE_INTEGER li_size;
-  li_size.QuadPart = l_size;
-  BOOL cur2 = SetFilePointerEx(h, li_size, NULL, FILE_BEGIN);
-  if (cur2 == 0) {
-    int error = GetLastError();
-    uError("SetFilePointerEx GetLastError is: %d\n", error);
-    switch (error) {
-      case ERROR_INVALID_HANDLE:
-        errno = EBADF;
-        break;
-      default:
-        errno = EIO;
-        break;
-    }
-    return -1;
-  }
-
-  if (!SetEndOfFile(h)) {
-    int error = GetLastError();
-    uError("SetEndOfFile GetLastError is:%d", error);
-    switch (error) {
-      case ERROR_INVALID_HANDLE:
-        errno = EBADF;
-        break;
-      default:
-        errno = EIO;
-        break;
-    }
-    return -1;
-  }
-
-  return 0;
-}
-
-int fsync(int filedes) { 
-  if (filedes < 0) {
-    errno = EBADF;
-    uError("%s\n", "fd arg was negative");
-    return -1;
-  }
-
-  HANDLE h = (HANDLE)_get_osfhandle(filedes);
-  
-  return FlushFileBuffers(h);
-}
-
-int32_t taosRename(char* oldName, char *newName) {
-  int32_t code = MoveFileEx(oldName, newName, MOVEFILE_REPLACE_EXISTING | MOVEFILE_COPY_ALLOWED);
-  if (code < 0) {
-    uError("failed to rename file %s to %s, reason:%s", oldName, newName, strerror(errno));
-  } else {
-    uTrace("successfully to rename file %s to %s", oldName, newName);
-  }
-
-  return code;
-}

src/os/src/windows/wGetline.c

@@ -22,6 +22,7 @@ General Public License for more details.  */
 #include <stdio.h>
 #include <assert.h>
 #include <errno.h>
+#include <stdint.h>
 
 #if STDC_HEADERS
 #include <stdlib.h>
@@ -40,10 +41,10 @@ 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(char **lineptr, size_t *n, FILE *stream, char terminator, int offset) {
+int32_t getstr(char **lineptr, size_t *n, FILE *stream, char terminator, int32_t offset) {
-  int   nchars_avail; /* Allocated but unused chars in *LINEPTR.  */
+  int32_t nchars_avail; /* Allocated but unused chars in *LINEPTR.  */
-  char *read_pos;     /* Where we're reading into *LINEPTR. */
+  char *  read_pos;     /* Where we're reading into *LINEPTR. */
-  int   ret;
+  int32_t ret;
 
   if (!lineptr || !n || !stream) {
     errno = EINVAL;
@@ -59,12 +60,12 @@ int getstr(char **lineptr, size_t *n, FILE *stream, char terminator, int offset)
     }
   }
 
-  nchars_avail = (int)(*n - offset);
+  nchars_avail = (int32_t)(*n - offset);
   read_pos = *lineptr + offset;
 
   for (;;) {
-    int          save_errno;
+    int32_t          save_errno;
-    register int c = getc(stream);
+    register int32_t c = getc(stream);
 
     save_errno = errno;
 
@@ -79,7 +80,7 @@ int getstr(char **lineptr, size_t *n, FILE *stream, char terminator, int offset)
       else
         *n += MIN_CHUNK;
 
-      nchars_avail = (int)(*n + *lineptr - read_pos);
+      nchars_avail = (int32_t)(*n + *lineptr - read_pos);
       *lineptr = realloc(*lineptr, *n);
       if (!*lineptr) {
         errno = ENOMEM;
@@ -115,10 +116,8 @@ int getstr(char **lineptr, size_t *n, FILE *stream, char terminator, int offset)
   /* Done - NUL terminate and return the number of chars read.  */
   *read_pos = '\0';
 
-  ret = (int)(read_pos - (*lineptr + offset));
+  ret = (int32_t)(read_pos - (*lineptr + offset));
   return ret;
 }
 
-int taosGetlineImp(char **lineptr, size_t *n, FILE *stream) { 
+int32_t tgetline(char **lineptr, size_t *n, FILE *stream) { return getstr(lineptr, n, stream, '\n', 0); }
-  return getstr(lineptr, n, stream, '\n', 0);
-}

src/os/src/windows/wGodll.c

@@ -1,33 +0,0 @@
-/*
- * 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"
-
-#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/windows/wSocket.c

@@ -70,7 +70,8 @@ int32_t taosSetSockOpt(SOCKET socketfd, int32_t level, int32_t optname, void *op
   return setsockopt(socketfd, level, optname, optval, optlen);
 }
 
-#ifdef TAOS_OS_FUNC_SOCKET_INET
+#ifdef _MSC_VER
+//#if _MSC_VER >= 1900
 
 uint32_t taosInetAddr(char *ipAddr) {
   uint32_t value;
@@ -88,4 +89,11 @@ const char *taosInetNtoa(struct in_addr ipInt) {
   return inet_ntop(AF_INET, &ipInt, tmpDstStr, INET6_ADDRSTRLEN);
 }
 
+//#endif
+#endif
+
+#if defined(_TD_GO_DLL_)
+
+uint64_t htonll(uint64_t val) { return (((uint64_t)htonl(val)) << 32) + htonl(val >> 32); }
+
 #endif

src/os/src/windows/wString.c

@@ -33,9 +33,9 @@
  * If *stringp is NULL, strsep returns NULL.
  */
 char *strsep(char **stringp, const char *delim) {
-  char *s;
+  char *      s;
   const char *spanp;
-  int c, sc;
+  int32_t     c, sc;
   char *tok;
   if ((s = *stringp) == NULL)
     return (NULL);
@@ -75,13 +75,13 @@ char *getpass(const char *prefix) {
   return passwd;
 }
 
-int twcslen(const wchar_t *wcs) {
+int32_t twcslen(const wchar_t *wcs) {
-  int *wstr = (int *)wcs;
+  int32_t *wstr = (int32_t *)wcs;
   if (NULL == wstr) {
     return 0;
   }
 
-  int n = 0;
+  int32_t n = 0;
   while (1) {
     if (0 == *wstr++) {
       break;
@@ -92,8 +92,8 @@ int twcslen(const wchar_t *wcs) {
   return n;
 }
 
-int tasoUcs4Compare(void *f1_ucs4, void *f2_ucs4, int bytes) {
+int32_t tasoUcs4Compare(void *f1_ucs4, void *f2_ucs4, int32_t bytes) {
-  for (int i = 0; i < bytes; ++i) {
+  for (int32_t i = 0; i < bytes; ++i) {
     int32_t f1 = *(int32_t *)((char *)f1_ucs4 + i * 4);
     int32_t f2 = *(int32_t *)((char *)f2_ucs4 + i * 4);
 
@@ -127,7 +127,6 @@ int tasoUcs4Compare(void *f1_ucs4, void *f2_ucs4, int bytes) {
 #endif
 }
 
-
 /* Copy memory to memory until the specified number of bytes
 has been copied, return pointer to following byte.
 Overlap is NOT handled correctly. */

src/os/src/windows/wTimer.c

@@ -43,7 +43,3 @@ int taosInitTimer(win_timer_f callback, int ms) {
 void taosUninitTimer() {
   timeKillEvent(timerId);
 }
-
-void taosMsleep(int mseconds) {
-  Sleep(mseconds);
-}

src/os/tests/CMakeLists.txt

@@ -11,5 +11,5 @@ IF (HEADER_GTEST_INCLUDE_DIR AND LIB_GTEST_STATIC_DIR)
     AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} SOURCE_LIST)
 
     ADD_EXECUTABLE(osTest ${SOURCE_LIST})
-    TARGET_LINK_LIBRARIES(osTest taos osdetail tutil common gtest pthread)
+    TARGET_LINK_LIBRARIES(osTest taos os tutil common gtest pthread)
 ENDIF()

src/query/src/qTsbuf.c

@@ -484,7 +484,7 @@ void tsBufFlush(STSBuf* pTSBuf) {
       .magic = TS_COMP_FILE_MAGIC, .numOfGroup = pTSBuf->numOfGroups, .tsOrder = pTSBuf->tsOrder};
   STSBufUpdateHeader(pTSBuf, &header);
   
-  fsync(fileno(pTSBuf->f));
+  taosFsync(fileno(pTSBuf->f));
 }
 
 static int32_t tsBufFindGroupById(STSGroupBlockInfoEx* pGroupInfoEx, int32_t numOfGroups, int32_t id) {
@@ -868,7 +868,7 @@ STSBuf* tsBufCreateFromCompBlocks(const char* pData, int32_t numOfBlocks, int32_
       .magic = TS_COMP_FILE_MAGIC, .numOfGroup = pTSBuf->numOfGroups, .tsOrder = pTSBuf->tsOrder};
   STSBufUpdateHeader(pTSBuf, &header);
   
-  fsync(fileno(pTSBuf->f));
+  taosFsync(fileno(pTSBuf->f));
   
   return pTSBuf;
 }

src/rpc/src/rpcMain.c

@@ -399,7 +399,7 @@ void rpcSendRequest(void *shandle, const SRpcEpSet *pEpSet, SRpcMsg *pMsg, int64
   pContext->oldInUse = pEpSet->inUse;
 
   pContext->connType = RPC_CONN_UDPC; 
-  if (contLen > tsRpcMaxUdpSize) pContext->connType = RPC_CONN_TCPC;
+  if (contLen > tsRpcMaxUdpSize || tsRpcForceTcp ) pContext->connType = RPC_CONN_TCPC;
 
   // connection type is application specific. 
   // for TDengine, all the query, show commands shall have TCP connection

src/rpc/src/rpcTcp.c

@@ -529,9 +529,6 @@ static void *taosProcessTcpData(void *param) {
   struct epoll_event events[maxEvents];
   SRecvInfo          recvInfo;
 
-#ifdef __APPLE__
-  taos_block_sigalrm();
-#endif // __APPLE__
   while (1) {
     int fdNum = epoll_wait(pThreadObj->pollFd, events, maxEvents, TAOS_EPOLL_WAIT_TIME);
     if (pThreadObj->stop) {

src/rpc/test/rserver.c

@@ -52,7 +52,7 @@ void processShellMsg() {
 
     if (commit >=2) {
       num += numOfMsgs;
-      if ( fsync(dataFd) < 0 ) {
+      if ( taosFsync(dataFd) < 0 ) {
         tInfo("failed to flush data to file, reason:%s", strerror(errno));
       }
 

src/sync/CMakeLists.txt

@@ -11,6 +11,6 @@ TARGET_LINK_LIBRARIES(sync tutil pthread common)
 LIST(APPEND BIN_SRC src/syncArbitrator.c)
 LIST(APPEND BIN_SRC src/syncTcp.c)
 ADD_EXECUTABLE(tarbitrator ${BIN_SRC})
-TARGET_LINK_LIBRARIES(tarbitrator sync common osdetail tutil)
+TARGET_LINK_LIBRARIES(tarbitrator sync common os tutil)
 
 #ADD_SUBDIRECTORY(test)

src/tsdb/inc/tsdbFile.h

@@ -32,7 +32,7 @@
 #define TSDB_FILE_SET_CLOSED(f) (TSDB_FILE_FD(f) = -1)
 #define TSDB_FILE_LEVEL(tf) TFILE_LEVEL(TSDB_FILE_F(tf))
 #define TSDB_FILE_ID(tf) TFILE_ID(TSDB_FILE_F(tf))
-#define TSDB_FILE_FSYNC(tf) fsync(TSDB_FILE_FD(tf))
+#define TSDB_FILE_FSYNC(tf) taosFsync(TSDB_FILE_FD(tf))
 #define TSDB_FILE_STATE(tf) ((tf)->state)
 #define TSDB_FILE_SET_STATE(tf, s) ((tf)->state = (s))
 #define TSDB_FILE_IS_OK(tf) (TSDB_FILE_STATE(tf) == TSDB_FILE_STATE_OK)

src/tsdb/src/tsdbFS.c

@@ -390,7 +390,7 @@ static int tsdbSaveFSStatus(SFSStatus *pStatus, int vid) {
   }
 
   // fsync, close and rename
-  if (fsync(fd) < 0) {
+  if (taosFsync(fd) < 0) {
     terrno = TAOS_SYSTEM_ERROR(errno);
     close(fd);
     remove(tfname);

src/util/CMakeLists.txt

@@ -6,7 +6,7 @@ INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/sync/inc)
 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/rmonotonic/inc)
 AUX_SOURCE_DIRECTORY(src SRC)
 ADD_LIBRARY(tutil ${SRC})
-TARGET_LINK_LIBRARIES(tutil pthread osdetail lz4 z rmonotonic)
+TARGET_LINK_LIBRARIES(tutil pthread os lz4 z rmonotonic)
 
 IF (TD_LINUX)
   TARGET_LINK_LIBRARIES(tutil m rt)

src/util/src/exception.c

@@ -1,7 +1,21 @@
+/*
+ * 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 "exception.h"
 
-
 static threadlocal SExceptionNode* expList;
 
 void exceptionPushNode( SExceptionNode* node ) {

src/util/src/tarray.c

@@ -13,6 +13,7 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "os.h"
 #include "tarray.h"
 
 void* taosArrayInit(size_t size, size_t elemSize) {

src/util/src/tbase64.c

@@ -1,23 +1,19 @@
-/**
+/*
- * Copyright (c) 2006-2008 Apple Inc. All rights reserved.
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
  *
- * Licensed under the Apache License, Version 2.0 (the "License");
+ * This program is free software: you can use, redistribute, and/or modify
- * you may not use this file except in compliance with the License.
+ * it under the terms of the GNU Affero General Public License, version 3
- * You may obtain a copy of the License at
+ * or later ("AGPL"), as published by the Free Software Foundation.
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ * 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.
  *
- * Unless required by applicable law or agreed to in writing, software
+ * You should have received a copy of the GNU Affero General Public License
- * distributed under the License is distributed on an "AS IS" BASIS,
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ */
- * See the License for the specific language governing permissions and
- * limitations under the License.
- **/
 
-#include <assert.h>
+#include "os.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
 
 // deprecated this file for bug prone
 // base64 encode

src/util/src/tbuffer.c

@@ -14,12 +14,9 @@
  */
 
 #include "os.h"
-#include <stdlib.h>
-#include <memory.h>
-#include <assert.h>
 #include "tbuffer.h"
 #include "exception.h"
-#include <taoserror.h>
+#include "taoserror.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 // reader functions

src/util/src/tcache.c

@@ -661,11 +661,7 @@ void* taosCacheTimedRefresh(void *handle) {
 
   int64_t count = 0;
   while(1) {
-#if defined LINUX
-    usleep(500*1000);
-#else
     taosMsleep(500);
-#endif
 
     // check if current cache object will be deleted every 500ms.
     if (pCacheObj->deleting) {

src/util/src/tcompare.c

@@ -1,3 +1,19 @@
+/*
+ * 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 "ttype.h"
 #include "tcompare.h"
 #include "tarray.h"

src/util/src/tcompression.c

@@ -47,8 +47,8 @@
  *
  */
 
-#include "lz4.h"
 #include "os.h"
+#include "lz4.h"
 #include "taosdef.h"
 #include "tscompression.h"
 #include "tulog.h"

src/util/src/tcrc32c.c

@@ -17,6 +17,7 @@
 	  misrepresented as being the original software.
 	  3. This notice may not be removed or altered from any source distribution.
 	*/
+
 #ifndef _TD_ARM_
 #include <nmmintrin.h>
 #endif

src/util/src/tdes.c

@@ -1,3 +1,17 @@
+/*
+ * 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 "tkey.h"

src/util/src/terror.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 TAOS Data, Inc. <jhtao@taosdata.com>
+ * 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
@@ -13,10 +13,7 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <stdint.h>
+#include "os.h"
-#include <pthread.h>
-#include <stdlib.h>
-#include <string.h>
 
 #define TAOS_ERROR_C
  

src/util/src/tfile.c

@@ -98,7 +98,7 @@ int32_t tfFsync(int64_t tfd) {
   if (p == NULL) return -1;
 
   int32_t fd = (int32_t)(uintptr_t)p;
-  int32_t code = fsync(fd);
+  int32_t code = taosFsync(fd);
 
   taosReleaseRef(tsFileRsetId, tfd);
   return code;

src/util/src/thashutil.c

@@ -1,12 +1,19 @@
-/**
+/*
- * MurmurHash3 by Austin Appleby
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- * @ref
- * https://github.com/aappleby/smhasher/blob/master/src/MurmurHash3.cpp
  *
- * Plese refers to the link above for the complete implementation of
+ * This program is free software: you can use, redistribute, and/or modify
- * MurmurHash algorithm
+ * 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 "hashfunc.h"
 #include "tutil.h"
 

src/util/src/tidpool.c

@@ -15,7 +15,6 @@
 
 #include "os.h"
 #include "tulog.h"
-#include <stdbool.h>
 
 typedef struct {
   int             maxId;

src/util/src/tlist.c

@@ -12,9 +12,8 @@
  * 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 <stdlib.h>
-#include <string.h>
 
+#include "os.h"
 #include "tlist.h"
 
 SList *tdListNew(int eleSize) {

src/util/src/tlockfree.c

@@ -12,9 +12,8 @@
  * 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 _GNU_SOURCE
-// #include <pthread.h>
 
+#include "os.h"
 #include "tlockfree.h"
 
 #define TD_RWLATCH_WRITE_FLAG 0x40000000