add some os files

deps/CMakeLists.txt

@@ -8,7 +8,13 @@ target_include_directories(
     # see https://stackoverflow.com/questions/25676277/cmake-target-include-directories-prints-an-error-when-i-try-to-add-the-source
     PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/cJson>
 )
+
 add_subdirectory(lz4/build/cmake)
+target_include_directories(
+    lz4_static
+    PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/lz4/lib
+)
+
 add_subdirectory(zlib)
 target_include_directories(
     zlib

include/common/taosdef.h

@@ -41,15 +41,6 @@ extern "C" {
 // Bytes for each type.
 extern const int32_t TYPE_BYTES[15];
 
-// TODO: replace and remove code below
-#define CHAR_BYTES    sizeof(char)
-#define SHORT_BYTES   sizeof(int16_t)
-#define INT_BYTES     sizeof(int32_t)
-#define LONG_BYTES    sizeof(int64_t)
-#define FLOAT_BYTES   sizeof(float)
-#define DOUBLE_BYTES  sizeof(double)
-#define POINTER_BYTES sizeof(void *)  // 8 by default  assert(sizeof(ptrdiff_t) == sizseof(void*)
-
 #define TSDB_KEYSIZE            sizeof(TSKEY)
 
 #if LINUX

include/os/os.h

@@ -21,22 +21,29 @@ extern "C" {
 #endif
 
 #include <assert.h>
+#include <ctype.h>
 #include <errno.h>
+#include <float.h>
 #include <inttypes.h>
-#include <sched.h>
+#include <locale.h>
+#include <math.h>
+#include <signal.h>
+#include <stdarg.h>
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <time.h>
 
-#include <arpa/inet.h>
-#include <pthread.h>
-#include <semaphore.h>
-#include <signal.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include<sys/time.h>
+// #include <arpa/inet.h>
+// #include <fcntl.h>
+// #include <pthread.h>
+// // #include <sched.h>
+// 
+// #include <signal.h>
+// #include <sys/time.h>
+// #include <unistd.h>
 
 #include "osAtomic.h"
 #include "osDef.h"
@@ -48,7 +55,9 @@ extern "C" {
 #include "osSemaphore.h"
 #include "osSocket.h"
 #include "osString.h"
+#include "osSleep.h"
 #include "osTime.h"
+#include "osThread.h"
 
 #ifdef __cplusplus
 }

include/os/osDef.h

@@ -29,11 +29,6 @@ extern "C" {
 #define POINTER_SHIFT(p, b) ((void *)((char *)(p) + (b)))
 #define POINTER_DISTANCE(p1, p2) ((char *)(p1) - (char *)(p2)) 
 
-#ifndef PATH_MAX
-  #define PATH_MAX 1024
-#endif
-
-
 #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)
   #if defined(_TD_DARWIN_64)
     // MacOS
@@ -53,6 +48,16 @@ extern "C" {
 #endif
 
 
+
+// TODO: replace and remove code below
+#define CHAR_BYTES    sizeof(char)
+#define SHORT_BYTES   sizeof(int16_t)
+#define INT_BYTES     sizeof(int32_t)
+#define LONG_BYTES    sizeof(int64_t)
+#define FLOAT_BYTES   sizeof(float)
+#define DOUBLE_BYTES  sizeof(double)
+#define POINTER_BYTES sizeof(void *)  // 8 by default  assert(sizeof(ptrdiff_t) == sizseof(void*)
+
 #ifdef __cplusplus
 }
 #endif

include/os/osFile.h

@@ -13,8 +13,8 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef TDENGINE_OS_FILE_H
-#define TDENGINE_OS_FILE_H
+#ifndef _TD_OS_FILE_H_
+#define _TD_OS_FILE_H_
 
 #ifdef __cplusplus
 extern "C" {
@@ -22,13 +22,6 @@ extern "C" {
 
 #include "osSocket.h"
 
-#define FD_VALID(x) ((x) > STDERR_FILENO)
-#define FD_INITIALIZER  ((int32_t)-1)
-
-#ifndef PATH_MAX
-  #define PATH_MAX 256
-#endif
-
 #if defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
 typedef int32_t FileFd;
 typedef SOCKET  SocketFd;
@@ -37,40 +30,44 @@ 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);
+#define FD_INITIALIZER ((int32_t)-1)
+
+#ifndef PATH_MAX
+#define PATH_MAX 256
+#endif
+
+int32_t taosLockFile(FileFd fd);
+int32_t taosUnLockFile(FileFd fd);
+
+int32_t taosUmaskFile(FileFd fd);
 
-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 taosStatFile(const char *path, int64_t *size, int32_t *mtime);
+int32_t taosFStatFile(FileFd fd, int64_t *size, int32_t *mtime);
 
-int32_t taosRename(char* oldName, char *newName);
-int64_t taosCopy(char *from, char *to);
+FileFd taosOpenFileWrite(const char *path);
+FileFd taosOpenFileCreateWrite(const char *path);
+FileFd taosOpenFileTruncCreateWrite(const char *path);
+FileFd taosOpenFileRead(const char *path);
+
+int64_t taosLSeekFile(FileFd fd, int64_t offset, int32_t whence);
+int32_t taosFtruncateFile(FileFd fd, int64_t length);
+int32_t taosFsyncFile(FileFd fd);
+
+int64_t taosReadFile(FileFd fd, void *buf, int64_t count);
+int64_t taosWriteFile(FileFd fd, void *buf, int64_t count);
+
+void taosCloseFile(FileFd fd);
+
+int32_t taosRenameFile(char *oldName, char *newName);
+int64_t taosCopyFile(char *from, char *to);
+
+void taosGetTmpfilePath(const char *inputTmpDir, const char *fileNamePrefix, char *dstPath);
 
 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);
-
-#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
-
 #ifdef __cplusplus
 }
 #endif
 
-#endif
+#endif /*_TD_OS_FILE_H_*/

include/os/osRand.h

+/*
+ * 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_RAND_H
+#define TDENGINE_OS_RAND_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+uint32_t taosRand(void);
+void     taosRandStr(char* str, int32_t size);
+uint32_t taosSafeRand(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

include/os/osSemaphore.h

@@ -20,6 +20,8 @@
 extern "C" {
 #endif
 
+#include <semaphore.h>
+
 #if defined (_TD_DARWIN_64)
   typedef struct tsem_s *tsem_t;
   int tsem_init(tsem_t *sem, int pshared, unsigned int value);

include/os/osSleep.h

+/*
+ * 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_SLEEP_H
+#define TDENGINE_OS_SLEEP_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void taosMsleep(int32_t ms);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
\ No newline at end of file

include/os/osSocket.h

@@ -20,6 +20,19 @@
 extern "C" {
 #endif
 
+#if defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
+  #include "winsock2.h"
+  #include <WS2tcpip.h>
+  #include <winbase.h>
+  #include <Winsock2.h>
+#else
+  #include <netinet/in.h>
+  #include <netinet/ip.h>
+  #include <netinet/tcp.h>
+  #include <netinet/udp.h>
+  #include <unistd.h>
+#endif
+
 #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)
@@ -35,50 +48,20 @@ extern "C" {
   #define taosCloseSocketNoCheck(x) close(x)
   #define taosCloseSocket(x) \
     {                        \
-      if (FD_VALID(x)) {     \
+      if ((x) > -1) {        \
         close(x);            \
         x = FD_INITIALIZER;  \
       }                      \
     }
 #endif
 
-#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;
-  #define EpollClose(pollFd) taosCloseSocket(pollFd)
-#endif  
+#define TAOS_EPOLL_WAIT_TIME 500 
+typedef int32_t SOCKET;
+typedef SOCKET EpollFd;
+#define EpollClose(pollFd) taosCloseSocket(pollFd)
 
-#ifdef TAOS_RANDOM_NETWORK_FAIL
-  #ifdef TAOS_RANDOM_NETWORK_FAIL_TEST
-    int64_t taosSendRandomFail(int32_t sockfd, const void *buf, size_t len, int32_t flags);
-    int64_t taosSendToRandomFail(int32_t sockfd, const void *buf, size_t len, int32_t flags, const struct sockaddr *dest_addr, socklen_t addrlen);
-    int64_t taosReadSocketRandomFail(int32_t fd, void *buf, size_t count);
-    int64_t taosWriteSocketRandomFail(int32_t fd, const void *buf, size_t count);
-    #undef taosSend
-    #undef taosSendto
-    #undef taosReadSocket
-    #undef taosWriteSocket
-    #define taosSend(sockfd, buf, len, flags) taosSendRandomFail(sockfd, buf, len, flags)
-    #define taosSendto(sockfd, buf, len, flags, dest_addr, addrlen) taosSendToRandomFail(sockfd, buf, len, flags, dest_addr, addrlen)
-    #define taosReadSocket(fd, buf, len) taosReadSocketRandomFail(fd, buf, len)
-    #define taosWriteSocket(fd, buf, len) taosWriteSocketRandomFail(fd, buf, len)
-  #endif  
-#endif
+void taosShutDownSocketRD(SOCKET fd);
+void taosShutDownSocketWR(SOCKET fd);
 
 int32_t taosSetNonblocking(SOCKET sock, int32_t on);
 void    taosIgnSIGPIPE();
@@ -88,9 +71,7 @@ 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);
 
 uint32_t    taosInetAddr(char *ipAddr);
-#if 0
 const char *taosInetNtoa(struct in_addr ipInt);
-#endif
 
 #if (defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)) 
   #define htobe64 htonll

include/os/osThread.h

+/*
+ * 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 _TD_OS_THREAD_H_
+#define _TD_OS_THREAD_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <pthread.h>
+#include <semaphore.h>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_OS_THREAD_H_*/

include/os/osTime.h

@@ -20,20 +20,22 @@
 extern "C" {
 #endif
 
+int32_t taosGetTimeOfDay(struct timeval *tv);
+
 //@return timestamp in second
 int32_t taosGetTimestampSec();
 
 //@return timestamp in millisecond
 static FORCE_INLINE int64_t taosGetTimestampMs() {
   struct timeval systemTime;
-  gettimeofday(&systemTime, NULL);
+  taosGetTimeOfDay(&systemTime);
   return (int64_t)systemTime.tv_sec * 1000L + (int64_t)systemTime.tv_usec / 1000;
 }
 
 //@return timestamp in microsecond
 static FORCE_INLINE int64_t taosGetTimestampUs() {
   struct timeval systemTime;
-  gettimeofday(&systemTime, NULL);
+  taosGetTimeOfDay(&systemTime);
   return (int64_t)systemTime.tv_sec * 1000000L + (int64_t)systemTime.tv_usec;
 }
 

include/util/tidpool.h

+/*
+ * 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_TIDPOOL_H
+#define TDENGINE_TIDPOOL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void *taosInitIdPool(int maxId);
+
+int taosUpdateIdPool(void *handle, int maxId);
+
+int taosIdPoolMaxSize(void *handle);
+
+int taosAllocateId(void *handle);
+
+void taosFreeId(void *handle, int id);
+
+void taosIdPoolCleanUp(void *handle);
+
+int taosIdPoolNumOfUsed(void *handle);
+
+bool taosIdPoolMarkStatus(void *handle, int id);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

include/util/tmempool.h

+/*
+ * 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_TMEMPOOL_H
+#define TDENGINE_TMEMPOOL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define mpool_h void *
+
+mpool_h taosMemPoolInit(int maxNum, int blockSize);
+
+char *taosMemPoolMalloc(mpool_h handle);
+
+void taosMemPoolFree(mpool_h handle, char *p);
+
+void taosMemPoolCleanUp(mpool_h handle);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

include/util/tref.h

+
+/*
+ * 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_TREF_H
+#define TDENGINE_TREF_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// open a reference set, max is the mod used by hash, fp is the pointer to free resource function
+// return rsetId which will be used by other APIs. On error, -1 is returned, and terrno is set appropriately
+int taosOpenRef(int max, void (*fp)(void *)); 
+
+// close the reference set, refId is the return value by taosOpenRef
+// return 0 if success. On error, -1 is returned, and terrno is set appropriately
+int taosCloseRef(int refId); 
+
+// add ref, p is the pointer to resource or pointer ID
+// return Reference ID(rid) allocated. On error, -1 is returned, and terrno is set appropriately
+int64_t taosAddRef(int refId, void *p);   
+
+// remove ref, rid is the reference ID returned by taosAddRef
+// return 0 if success. On error, -1 is returned, and terrno is set appropriately
+int taosRemoveRef(int rsetId, int64_t rid);
+
+// acquire ref, rid is the reference ID returned by taosAddRef
+// return the resource p. On error, NULL is returned, and terrno is set appropriately
+void *taosAcquireRef(int rsetId, int64_t rid);
+
+// release ref, rid is the reference ID returned by taosAddRef
+// return 0 if success. On error, -1 is returned, and terrno is set appropriately
+int taosReleaseRef(int rsetId, int64_t rid);
+
+// return the first reference if rid is 0, otherwise return the next after current reference. 
+// if return value is NULL, it means list is over(if terrno is set, it means error happens)
+void *taosIterateRef(int rsetId, int64_t rid);
+
+// return the number of references in system
+int  taosListRef();  
+
+#define RID_VALID(x) ((x) > 0)
+
+/* sample code to iterate the refs 
+
+void demoIterateRefs(int rsetId) {
+
+  void *p = taosIterateRef(refId, 0);
+  while (p) {
+    // process P
+    
+    // get the rid from p
+
+    p = taosIterateRef(rsetId, rid);
+  }
+}
+
+*/
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TDENGINE_TREF_H

include/util/tutil.h

@@ -23,7 +23,6 @@ extern "C" {
 #include "os.h"
 #include "tmd5.h"
 #include "tcrc32c.h"
-#include "taosdef.h"
 
 int32_t strdequote(char *src);
 int32_t strRmquote(char *z, int32_t len);
@@ -46,14 +45,19 @@ int  taosCheckVersion(char *input_client_version, char *input_server_version, in
 char *   taosIpStr(uint32_t ipInt);
 uint32_t ip2uint(const char *const ip_addr);
 
-static FORCE_INLINE void taosEncryptPass(uint8_t *inBuf, size_t inLen, char *target) {
+static FORCE_INLINE void taosEncryptPass(uint8_t *inBuf, size_t inLen, char *target, int32_t keylen) {
   MD5_CTX context;
   MD5Init(&context);
   MD5Update(&context, inBuf, (unsigned int)inLen);
   MD5Final(&context);
-  memcpy(target, context.digest, TSDB_KEY_LEN);
+  memcpy(target, context.digest, keylen);
 }
 
+#ifdef tListLen
+#undefine tListLen
+#endif
+#define tListLen(x) (sizeof(x) / sizeof((x)[0]))
+
 #ifdef __cplusplus
 }
 #endif

source/libs/transport/CMakeLists.txt

@@ -4,4 +4,12 @@ target_include_directories(
     transport
     PUBLIC "${CMAKE_SOURCE_DIR}/include/libs/transport"
     PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
+)
+
+target_link_libraries(
+    transport
+    PUBLIC lz4_static
+    PUBLIC os
+    PUBLIC util
+    PUBLIC common
 )
\ No newline at end of file

source/libs/transport/src/rpcTcp.c

@@ -22,6 +22,9 @@
 #include "rpcHead.h"
 #include "rpcTcp.h"
 
+
+#include <sys/epoll.h>
+
 typedef struct SFdObj {
   void              *signature;
   SOCKET             fd;          // TCP socket FD
@@ -195,16 +198,7 @@ void taosStopTcpServer(void *handle) {
   pServerObj->stop = 1;
 
   if (pServerObj->fd >= 0) {
-#ifdef WINDOWS
-    closesocket(pServerObj->fd);
-#elif defined(__APPLE__)
-    if (pServerObj->fd!=-1) {
-      close(pServerObj->fd);
-      pServerObj->fd = -1;
-    }
-#else
-    shutdown(pServerObj->fd, SHUT_RD);
-#endif
+    taosShutDownSocketRD(pServerObj->fd);
   }
   if (taosCheckPthreadValid(pServerObj->thread)) {
     if (taosComparePthread(pServerObj->thread, pthread_self())) {
@@ -267,8 +261,8 @@ static void *taosAcceptTcpConnection(void *arg) {
     int32_t ret = taosSetSockOpt(connFd, SOL_SOCKET, SO_RCVTIMEO, &to, sizeof(to));
     if (ret != 0) {
       taosCloseSocket(connFd);
-      tError("%s failed to set recv timeout fd(%s)for connection from:%s:%hu", pServerObj->label, strerror(errno),
-             taosInetNtoa(caddr.sin_addr), htons(caddr.sin_port));
+      tError("%s failed to set recv timeout fd(%s)for connection from:%hu", pServerObj->label, strerror(errno),
+             htons(caddr.sin_port));
       continue;
     }
 
@@ -280,12 +274,12 @@ static void *taosAcceptTcpConnection(void *arg) {
     if (pFdObj) {
       pFdObj->ip = caddr.sin_addr.s_addr;
       pFdObj->port = htons(caddr.sin_port);
-      tDebug("%s new TCP connection from %s:%hu, fd:%d FD:%p numOfFds:%d", pServerObj->label,
-              taosInetNtoa(caddr.sin_addr), pFdObj->port, connFd, pFdObj, pThreadObj->numOfFds);
+      tDebug("%s new TCP connection from %hu, fd:%d FD:%p numOfFds:%d", pServerObj->label,
+              pFdObj->port, connFd, pFdObj, pThreadObj->numOfFds);
     } else {
       taosCloseSocket(connFd);
-      tError("%s failed to malloc FdObj(%s) for connection from:%s:%hu", pServerObj->label, strerror(errno),
-             taosInetNtoa(caddr.sin_addr), htons(caddr.sin_port));
+      tError("%s failed to malloc FdObj(%s) for connection from:%hu", pServerObj->label, strerror(errno),
+             htons(caddr.sin_port));
     }
 
     // pick up next thread for next connection
@@ -436,7 +430,7 @@ void taosCloseTcpConnection(void *chandle) {
 
   // pFdObj->thandle = NULL;
   pFdObj->closedByApp = 1;
-  shutdown(pFdObj->fd, SHUT_WR);
+  taosShutDownSocketWR(pFdObj->fd);
 }
 
 int taosSendTcpData(uint32_t ip, uint16_t port, void *data, int len, void *chandle) {
@@ -456,7 +450,7 @@ static void taosReportBrokenLink(SFdObj *pFdObj) {
 
   // notify the upper layer, so it will clean the associated context
   if (pFdObj->closedByApp == 0) {
-    shutdown(pFdObj->fd, SHUT_WR);
+    taosShutDownSocketWR(pFdObj->fd);
 
     SRecvInfo recvInfo;
     recvInfo.msg = NULL;

src/os/src/detail/osFile.c → source/os/src/osFile.c

@@ -13,24 +13,29 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#define _DEFAULT_SOURCE
 #include "os.h"
-#include "tglobal.h"
-#include "tulog.h"
 
-void taosClose(FileFd fd) {
+#if defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
+#else
+#include <fcntl.h>
+#include <sys/file.h>
+#include <sys/sendfile.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#endif
+
+void taosCloseFile(FileFd fd) {
   close(fd);
   fd = FD_INITIALIZER;
 }
 
+void taosGetTmpfilePath(const char * inputTmpDir, const char *fileNamePrefix, char *dstPath) {
 #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);
+  int32_t len = (int32_t)strlen(inputTmpDir);
+  memcpy(tmpPath, inputTmpDir, len);
 
   if (tmpPath[len - 1] != '/' && tmpPath[len - 1] != '\\') {
     tmpPath[len++] = '\\';
@@ -46,16 +51,14 @@ void taosGetTmpfilePath(const char *fileNamePrefix, char *dstPath) {
   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-";
 
-  char    tmpPath[PATH_MAX];
-  int32_t len = strlen(tsTempDir);
-  memcpy(tmpPath, tsTempDir, len);
+  char tmpPath[PATH_MAX];
+  int32_t len = strlen(inputTmpDir);
+  memcpy(tmpPath, inputTmpDir, len);
   static uint64_t seqId = 0;
 
   if (tmpPath[len - 1] != '/') {
@@ -73,11 +76,11 @@ void taosGetTmpfilePath(const char *fileNamePrefix, char *dstPath) {
   sprintf(rand, "%" PRIu64, atomic_add_fetch_64(&seqId, 1));
 
   snprintf(dstPath, PATH_MAX, tmpPath, getpid(), rand);
-}
 
 #endif
+}
 
-int64_t taosRead(FileFd fd, void *buf, int64_t count) {
+int64_t taosReadFile(FileFd fd, void *buf, int64_t count) {
   int64_t leftbytes = count;
   int64_t readbytes;
   char *  tbuf = (char *)buf;
@@ -101,7 +104,7 @@ int64_t taosRead(FileFd fd, void *buf, int64_t count) {
   return count;
 }
 
-int64_t taosWrite(FileFd fd, void *buf, int64_t n) {
+int64_t taosWriteFile(FileFd fd, void *buf, int64_t n) {
   int64_t nleft = n;
   int64_t nwritten = 0;
   char *  tbuf = (char *)buf;
@@ -121,42 +124,46 @@ int64_t taosWrite(FileFd fd, void *buf, int64_t n) {
   return n;
 }
 
-int64_t taosLSeek(FileFd fd, int64_t offset, int32_t whence) { return (int64_t)lseek(fd, (long)offset, whence); }
+int64_t taosLSeekFile(FileFd fd, int64_t offset, int32_t whence) { return (int64_t)lseek(fd, (long)offset, whence); }
 
-int64_t taosCopy(char *from, char *to) {
+int64_t taosCopyFile(char *from, char *to) {
+#if defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
+  return 0;
+#else
   char    buffer[4096];
   int     fidto = -1, fidfrom = -1;
   int64_t size = 0;
   int64_t bytes;
 
-  fidfrom = open(from, O_RDONLY | O_BINARY);
+  fidfrom = open(from, O_RDONLY);
   if (fidfrom < 0) goto _err;
 
-  fidto = open(to, O_WRONLY | O_CREAT | O_EXCL | O_BINARY, 0755);
+  fidto = open(to, O_WRONLY | O_CREAT | O_EXCL, 0755);
   if (fidto < 0) goto _err;
 
   while (true) {
-    bytes = taosRead(fidfrom, buffer, sizeof(buffer));
+    bytes = taosReadFile(fidfrom, buffer, sizeof(buffer));
     if (bytes < 0) goto _err;
     if (bytes == 0) break;
 
     size += bytes;
 
-    if (taosWrite(fidto, (void *)buffer, bytes) < bytes) goto _err;
+    if (taosWriteFile(fidto, (void *)buffer, bytes) < bytes) goto _err;
     if (bytes < sizeof(buffer)) break;
   }
 
-  taosFsync(fidto);
+  taosFsyncFile(fidto);
 
-  taosClose(fidfrom);
-  taosClose(fidto);
+  taosCloseFile(fidfrom);
+  taosCloseFile(fidto);
   return size;
 
 _err:
-  if (fidfrom >= 0) taosClose(fidfrom);
-  if (fidto >= 0) taosClose(fidto);
+  if (fidfrom >= 0) taosCloseFile(fidfrom);
+  if (fidto >= 0) taosCloseFile(fidto);
   remove(to);
   return -1;
+#endif
 }
 
 #if defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
@@ -306,9 +313,8 @@ int64_t taosFSendFile(FILE *outfile, FILE *infile, int64_t *offset, int64_t size
 
 #endif
 
+int32_t taosFtruncateFile(FileFd fd, int64_t l_size) {
 #if defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
-
-int32_t taosFtruncate(int32_t fd, int64_t l_size) {
   if (fd < 0) {
     errno = EBADF;
     uError("%s\n", "fd arg was negative");
@@ -357,9 +363,13 @@ int32_t taosFtruncate(int32_t fd, int64_t l_size) {
   }
 
   return 0;
+#else
+  return ftruncate(fd, l_size);
+#endif
 }
 
-int32_t taosFsync(FileFd fd) {
+int32_t taosFsyncFile(FileFd fd) {
+#if defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
   if (fd < 0) {
     errno = EBADF;
     uError("%s\n", "fd arg was negative");
@@ -369,33 +379,126 @@ int32_t taosFsync(FileFd fd) {
   HANDLE h = (HANDLE)_get_osfhandle(fd);
 
   return FlushFileBuffers(h);
+#else
+  return fsync(fd);
+#endif
 }
 
-int32_t taosRename(char *oldName, char *newName) {
+int32_t taosRenameFile(char *oldName, char *newName) {
+#if defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
   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);
+    printf("failed to rename file %s to %s, reason:%s", oldName, newName, strerror(errno));
+  }
+
+  return code;
+#else
+  int32_t code = rename(oldName, newName);
+  if (code < 0) {
+    printf("failed to rename file %s to %s, reason:%s", oldName, newName, strerror(errno));
   }
 
   return code;
+#endif
+}
+
+
+int32_t taosLockFile(int32_t fd) {
+#if defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
+  return 0;
+#else
+  return (int32_t)flock(fd, LOCK_EX | LOCK_NB);
+#endif
 }
 
+int32_t taosUnLockFile(int32_t fd) {
+#if defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
+  return 0;
 #else
+  return (int32_t)flock(fd, LOCK_UN | LOCK_NB);
+#endif
+}
 
-int32_t taosFtruncate(FileFd fd, int64_t length) { return ftruncate(fd, length); }
-int32_t taosFsync(FileFd fd) { return fsync(fd); }
+int32_t taosUmaskFile(int32_t val) {
+#if defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
+  return 0;
+#else
+  return umask(val);
+#endif
+}
 
-int32_t taosRename(char *oldName, char *newName) {
-  int32_t code = rename(oldName, newName);
+int32_t taosStatFile(const char *path, int64_t *size, int32_t *mtime) {
+#if defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
+  return 0;
+#else
+  struct stat fileStat;
+  int32_t     code = stat(path, &fileStat);
   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;
   }
 
-  return code;
+  if (size != NULL) {
+    *size = fileStat.st_size;
+  }
+
+  if (mtime != NULL) {
+    *mtime = fileStat.st_mtime;
+  }
+
+  return 0;
+#endif
 }
 
+int32_t taosFStatFile(int32_t fd, int64_t *size, int32_t *mtime) {
+#if defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
+  return 0;
+#else
+  struct stat fileStat;
+  int32_t     code = fstat(fd, &fileStat);
+  if (code < 0) {
+    return code;
+  }
+
+  if (size != NULL) {
+    *size = fileStat.st_size;
+  }
+
+  if (mtime != NULL) {
+    *mtime = fileStat.st_mtime;
+  }
+
+  return 0;
+#endif
+}
+
+int32_t taosOpenFileWrite(const char *path) {
+#if defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
+  return 0;
+#else
+  return open(path, O_WRONLY, S_IRWXU | S_IRWXG | S_IRWXO);
+#endif
+}
+
+FileFd taosOpenFileRead(const char *path) {
+  #if defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
+  return 0;
+#else
+  return open(path, O_RDONLY);
+#endif
+}
+
+int32_t taosOpenFileCreateWrite(const char *path) {
+#if defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
+  return 0;
+#else
+  return open(path, O_WRONLY | O_CREAT, S_IRWXU | S_IRWXG | S_IRWXO);
+#endif
+}
+
+int32_t taosOpenFileTruncCreateWrite(const char *path) {
+#if defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
+  return 0;
+#else
+  return open(path, O_WRONLY | O_CREAT | O_TRUNC, S_IRWXU | S_IRWXG | S_IRWXO);
 #endif
+}
\ No newline at end of file

src/os/src/detail/osSocket.c → source/os/src/osSocket.c

@@ -15,7 +15,26 @@
 
 #define _DEFAULT_SOURCE
 #include "os.h"
-#include "tulog.h"
+
+void taosShutDownSocketRD(SOCKET fd) {
+#ifdef WINDOWS
+  closesocket(fd);
+#elif __APPLE__
+  close(fd);
+#else
+  shutdown(fd, SHUT_RD);
+#endif
+}
+
+void taosShutDownSocketWR(SOCKET fd) {
+#ifdef WINDOWS
+  closesocket(fd);
+#elif __APPLE__
+  close(fd);
+#else
+  shutdown(fd, SHUT_WR);
+#endif
+}
 
 #if !(defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32))
 
@@ -87,4 +106,19 @@ const char *taosInetNtoa(struct in_addr ipInt) {
   return inet_ntoa(ipInt);
 }
 
+#else
+
+const char *taosInetNtoa(struct in_addr ipInt) {
+  // not thread safe, only for debug usage while print log
+  static char tmpDstStr[16];
+  return inet_ntop(AF_INET, &ipInt, tmpDstStr, INET6_ADDRSTRLEN);
+}
+
 #endif
+
+
+#if defined(_TD_GO_DLL_)
+
+uint64_t htonll(uint64_t val) { return (((uint64_t)htonl(val)) << 32) + htonl(val >> 32); }
+
+#endif
\ No newline at end of file

source/os/src/osTime.c

+/*
+ * 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"
+
+#if defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
+#include <winsock2.h>
+#else
+#endif
+
+FORCE_INLINE int32_t taosGetTimeOfDay(struct timeval *tv) {
+#if defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
+    time_t t;
+  t = time(NULL);
+  SYSTEMTIME st;
+  GetLocalTime(&st);
+
+  tv->tv_sec = (long)t;
+  tv->tv_usec = st.wMilliseconds * 1000;
+
+  return 0;
+#else
+  return gettimeofday(tv, NULL);
+#endif
+}
\ No newline at end of file

source/server/dnode/src/dnodeCfg.c

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

source/server/dnode/src/dnodeEps.c

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

source/server/dnode/src/dnodeMnodeEps.c

@@ -82,7 +82,7 @@ static int32_t dnodeWriteMnodeEps(DnMnEps *meps) {
   len += snprintf(content + len, maxLen - len, "}\n");
 
   fwrite(content, 1, len, fp);
-  taosFsync(fileno(fp));
+  taosFsyncFile(fileno(fp));
   fclose(fp);
   free(content);
   terrno = 0;

source/server/dnode/src/dnodeTelemetry.c

@@ -15,7 +15,6 @@
 
 #define _DEFAULT_SOURCE
 #include "os.h"
-// #include "osTime.h"
 #include "tbuffer.h"
 #include "tglobal.h"
 #include "tsocket.h"
@@ -255,16 +254,16 @@ static void* dnodeTelemThreadFp(void* param) {
 }
 
 static void dnodeGetEmail(DnTelem* telem, char* filepath) {
-  int32_t fd = open(filepath, O_RDONLY);
+  int32_t fd = taosOpenFileRead(filepath);
   if (fd < 0) {
     return;
   }
 
-  if (taosRead(fd, (void*)telem->email, TSDB_FQDN_LEN) < 0) {
+  if (taosReadFile(fd, (void*)telem->email, TSDB_FQDN_LEN) < 0) {
     dError("failed to read %d bytes from file %s since %s", TSDB_FQDN_LEN, filepath, strerror(errno));
   }
 
-  taosClose(fd);
+  taosCloseFile(fd);
 }
 
 int32_t dnodeInitTelemetry(Dnode* dnode, DnTelem** out) {

source/server/dnode/src/dnodeTrans.c

@@ -242,7 +242,7 @@ static void dnodeProcessMsgFromShell(DnTrans *trans, SRpcMsg *pMsg, SRpcEpSet *p
 static int32_t dnodeAuthNetTest(char *user, char *spi, char *encrypt, char *secret, char *ckey) {
   if (strcmp(user, "nettestinternal") == 0) {
     char pass[32] = {0};
-    taosEncryptPass((uint8_t *)user, strlen(user), pass);
+    taosEncryptPass((uint8_t *)user, strlen(user), pass, TSDB_KEY_LEN);
     *spi = 0;
     *encrypt = 0;
     *ckey = 0;

source/util/CMakeLists.txt

@@ -3,7 +3,7 @@ add_library(util ${UTIL_SRC})
 target_include_directories(
     util
     PUBLIC "${CMAKE_SOURCE_DIR}/include/util"
-    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/include"
+    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
 )
 target_link_libraries(
     util

source/util/inc/tulog.h

+/*
+ * 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_COMMON_ULOG_H
+#define TDENGINE_COMMON_ULOG_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "tlog.h"
+
+extern int32_t uDebugFlag;
+extern int8_t  tscEmbedded;
+
+#define uFatal(...) { if (uDebugFlag & DEBUG_FATAL) { taosPrintLog("UTL FATAL", tscEmbedded ? 255 : uDebugFlag, __VA_ARGS__); }}
+#define uError(...) { if (uDebugFlag & DEBUG_ERROR) { taosPrintLog("UTL ERROR ", tscEmbedded ? 255 : uDebugFlag, __VA_ARGS__); }}
+#define uWarn(...)  { if (uDebugFlag & DEBUG_WARN)  { taosPrintLog("UTL WARN ", tscEmbedded ? 255 : uDebugFlag, __VA_ARGS__); }}
+#define uInfo(...)  { if (uDebugFlag & DEBUG_INFO)  { taosPrintLog("UTL ", tscEmbedded ? 255 : uDebugFlag, __VA_ARGS__); }}
+#define uDebug(...) { if (uDebugFlag & DEBUG_DEBUG) { taosPrintLog("UTL ", uDebugFlag, __VA_ARGS__); }}
+#define uTrace(...) { if (uDebugFlag & DEBUG_TRACE) { taosPrintLog("UTL ", uDebugFlag, __VA_ARGS__); }}
+
+#define pError(...) { taosPrintLog("APP ERROR ", 255, __VA_ARGS__); }  
+#define pPrint(...) { taosPrintLog("APP ", 255, __VA_ARGS__); }  
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/util/src/tlog.c → source/util/src/tlog.c

@@ -19,7 +19,7 @@
 #include "tlog.h"
 #include "tnote.h"
 #include "tutil.h"
-
+  
 #define MAX_LOGLINE_SIZE              (1000)
 #define MAX_LOGLINE_BUFFER_SIZE       (MAX_LOGLINE_SIZE + 10)
 #define MAX_LOGLINE_CONTENT_SIZE      (MAX_LOGLINE_SIZE - 100)
@@ -85,6 +85,8 @@ int64_t dbgWSize = 0;
 char    tsLogDir[TSDB_FILENAME_LEN] = "/var/log/power";
 #elif (_TD_TQ_ == true)
 char    tsLogDir[TSDB_FILENAME_LEN] = "/var/log/tq";
+#elif (_TD_PRO_ == true)
+char    tsLogDir[TSDB_FILENAME_LEN] = "/var/log/ProDB";
 #else
 char    tsLogDir[PATH_MAX] = "/var/log/taos";
 #endif
@@ -134,11 +136,11 @@ void taosCloseLog() {
   // taosCloseLog();
 }
 
-static bool taosLockFile(int32_t fd) {
+static bool taosLockLogFile(int32_t fd) {
   if (fd < 0) return false;
 
   if (tsLogObj.fileNum > 1) {
-    int32_t ret = flock(fd, LOCK_EX | LOCK_NB);
+    int32_t ret = taosUnLockFile(fd);
     if (ret == 0) {
       return true;
     }
@@ -147,11 +149,11 @@ static bool taosLockFile(int32_t fd) {
   return false;
 }
 
-static void taosUnLockFile(int32_t fd) {
+static void taosUnLockLogFile(int32_t fd) {
   if (fd < 0) return;
 
   if (tsLogObj.fileNum > 1) {
-    flock(fd, LOCK_UN | LOCK_NB);
+    taosUnLockFile(fd);
   }
 }
 
@@ -183,9 +185,9 @@ static void *taosThreadToOpenNewFile(void *param) {
   char name[LOG_FILE_NAME_LEN + 20];
   sprintf(name, "%s.%d", tsLogObj.logName, tsLogObj.flag);
 
-  umask(0);
+  taosUmaskFile(0);
 
-  int32_t fd = open(name, O_WRONLY | O_CREAT | O_TRUNC, S_IRWXU | S_IRWXG | S_IRWXO);
+  int32_t fd = taosOpenFileTruncCreateWrite(name);
   if (fd < 0) {
     tsLogObj.openInProgress = 0;
     tsLogObj.lines = tsLogObj.maxLines - 1000;
@@ -193,8 +195,8 @@ static void *taosThreadToOpenNewFile(void *param) {
     return NULL;
   }
 
-  taosLockFile(fd);
-  (void)lseek(fd, 0, SEEK_SET);
+  taosLockLogFile(fd);
+  (void)taosLSeekFile(fd, 0, SEEK_SET);
 
   int32_t oldFd = tsLogObj.logHandle->fd;
   tsLogObj.logHandle->fd = fd;
@@ -246,7 +248,7 @@ void taosResetLog() {
 }
 
 static bool taosCheckFileIsOpen(char *logFileName) {
-  int32_t fd = open(logFileName, O_WRONLY, S_IRWXU | S_IRWXG | S_IRWXO);
+  int32_t fd = taosOpenFileWrite(logFileName);
   if (fd < 0) {
     if (errno == ENOENT) {
       return false;
@@ -256,12 +258,12 @@ static bool taosCheckFileIsOpen(char *logFileName) {
     }
   }
 
-  if (taosLockFile(fd)) {
-    taosUnLockFile(fd);
-    taosClose(fd);
+  if (taosLockLogFile(fd)) {
+    taosUnLockLogFile(fd);
+    taosCloseFile(fd);
     return false;
   } else {
-    taosClose(fd);
+    taosCloseFile(fd);
     return true;
   }
 }
@@ -298,9 +300,9 @@ static int32_t taosOpenLogFile(char *fn, int32_t maxLines, int32_t maxFileNum) {
   maxFileNum = 1;
 #endif
 
-  char        name[LOG_FILE_NAME_LEN + 50] = "\0";
-  struct stat logstat0, logstat1;
-  int32_t     size;
+  char    name[LOG_FILE_NAME_LEN + 50] = "\0";
+  int32_t logstat0_mtime, logstat1_mtime;
+  int32_t size;
 
   tsLogObj.maxLines = maxLines;
   tsLogObj.fileNum = maxFileNum;
@@ -310,14 +312,14 @@ static int32_t taosOpenLogFile(char *fn, int32_t maxLines, int32_t maxFileNum) {
     strcpy(name, fn);
     strcat(name, ".0");
   }
-  bool log0Exist = stat(name, &logstat0) >= 0;
+  bool log0Exist = taosStatFile(name, NULL, &logstat0_mtime) >= 0;
 
   if (strlen(fn) < LOG_FILE_NAME_LEN + 50 - 2) {
     strcpy(name, fn);
     strcat(name, ".1");
   }
-  bool log1Exist = stat(name, &logstat1) >= 0;
-  
+  bool log1Exist = taosStatFile(name, NULL, &logstat1_mtime) >= 0;
+
   // if none of the log files exist, open 0, if both exists, open the old one
   if (!log0Exist && !log1Exist) {
     tsLogObj.flag = 0;
@@ -326,39 +328,39 @@ static int32_t taosOpenLogFile(char *fn, int32_t maxLines, int32_t maxFileNum) {
   } else if (!log0Exist) {
     tsLogObj.flag = 1;
   } else {
-    tsLogObj.flag = (logstat0.st_mtime > logstat1.st_mtime) ? 0 : 1;
+    tsLogObj.flag = (logstat0_mtime > logstat1_mtime) ? 0 : 1;
   }
 
   char fileName[LOG_FILE_NAME_LEN + 50] = "\0";
   sprintf(fileName, "%s.%d", tsLogObj.logName, tsLogObj.flag);
   pthread_mutex_init(&tsLogObj.logMutex, NULL);
 
-  umask(0);
-  tsLogObj.logHandle->fd = open(fileName, O_WRONLY | O_CREAT, S_IRWXU | S_IRWXG | S_IRWXO);
+  taosUmaskFile(0);
+  tsLogObj.logHandle->fd = taosOpenFileCreateWrite(fileName);
 
   if (tsLogObj.logHandle->fd < 0) {
     printf("\nfailed to open log file:%s, reason:%s\n", fileName, strerror(errno));
     return -1;
   }
-  taosLockFile(tsLogObj.logHandle->fd);
+  taosLockLogFile(tsLogObj.logHandle->fd);
 
   // only an estimate for number of lines
-  struct stat filestat;
-  if (fstat(tsLogObj.logHandle->fd, &filestat) < 0) {
+  int64_t filesize = 0;
+  if (taosFStatFile(tsLogObj.logHandle->fd, &filesize, NULL) < 0) {
     printf("\nfailed to fstat log file:%s, reason:%s\n", fileName, strerror(errno));
     return -1;
   }
-  size = (int32_t)filestat.st_size;
+  size = (int32_t)filesize;
   tsLogObj.lines = size / 60;
 
-  lseek(tsLogObj.logHandle->fd, 0, SEEK_END);
+  taosLSeekFile(tsLogObj.logHandle->fd, 0, SEEK_END);
 
   sprintf(name, "==================================================\n");
-  taosWrite(tsLogObj.logHandle->fd, name, (uint32_t)strlen(name));
+  taosWriteFile(tsLogObj.logHandle->fd, name, (uint32_t)strlen(name));
   sprintf(name, "                new log file                      \n");
-  taosWrite(tsLogObj.logHandle->fd, name, (uint32_t)strlen(name));
+  taosWriteFile(tsLogObj.logHandle->fd, name, (uint32_t)strlen(name));
   sprintf(name, "==================================================\n");
-  taosWrite(tsLogObj.logHandle->fd, name, (uint32_t)strlen(name));
+  taosWriteFile(tsLogObj.logHandle->fd, name, (uint32_t)strlen(name));
 
   return 0;
 }
@@ -377,7 +379,7 @@ void taosPrintLog(const char *flags, int32_t dflag, const char *format, ...) {
   struct timeval timeSecs;
   time_t         curTime;
 
-  gettimeofday(&timeSecs, NULL);
+  taosGetTimeOfDay(&timeSecs);
   curTime = timeSecs.tv_sec;
   ptm = localtime_r(&curTime, &Tm);
 
@@ -408,7 +410,7 @@ void taosPrintLog(const char *flags, int32_t dflag, const char *format, ...) {
     if (tsAsyncLog) {
       taosPushLogBuffer(tsLogObj.logHandle, buffer, len);
     } else {
-      taosWrite(tsLogObj.logHandle->fd, buffer, len);
+      taosWriteFile(tsLogObj.logHandle->fd, buffer, len);
     }
 
     if (tsLogObj.maxLines > 0) {
@@ -419,7 +421,7 @@ void taosPrintLog(const char *flags, int32_t dflag, const char *format, ...) {
   }
 
   if (dflag & DEBUG_SCREEN)
-      taosWrite(1, buffer, (uint32_t)len);
+      taosWriteFile(1, buffer, (uint32_t)len);
   if (dflag == 255) nInfo(buffer, len);
 }
 
@@ -439,7 +441,7 @@ void taosDumpData(unsigned char *msg, int32_t len) {
     pos += 3;
     if (c >= 16) {
       temp[pos++] = '\n';
-      taosWrite(tsLogObj.logHandle->fd, temp, (uint32_t)pos);
+      taosWriteFile(tsLogObj.logHandle->fd, temp, (uint32_t)pos);
       c = 0;
       pos = 0;
     }
@@ -447,7 +449,7 @@ void taosDumpData(unsigned char *msg, int32_t len) {
 
   temp[pos++] = '\n';
 
-  taosWrite(tsLogObj.logHandle->fd, temp, (uint32_t)pos);
+  taosWriteFile(tsLogObj.logHandle->fd, temp, (uint32_t)pos);
 }
 
 void taosPrintLongString(const char *flags, int32_t dflag, const char *format, ...) {
@@ -464,7 +466,7 @@ void taosPrintLongString(const char *flags, int32_t dflag, const char *format, .
   struct timeval timeSecs;
   time_t         curTime;
 
-  gettimeofday(&timeSecs, NULL);
+  taosGetTimeOfDay(&timeSecs);
   curTime = timeSecs.tv_sec;
   ptm = localtime_r(&curTime, &Tm);
 
@@ -485,7 +487,7 @@ void taosPrintLongString(const char *flags, int32_t dflag, const char *format, .
     if (tsAsyncLog) {
       taosPushLogBuffer(tsLogObj.logHandle, buffer, len);
     } else {
-      taosWrite(tsLogObj.logHandle->fd, buffer, len);
+      taosWriteFile(tsLogObj.logHandle->fd, buffer, len);
     }
     
     if (tsLogObj.maxLines > 0) {
@@ -495,7 +497,7 @@ void taosPrintLongString(const char *flags, int32_t dflag, const char *format, .
     }
   }
 
-  if (dflag & DEBUG_SCREEN) taosWrite(1, buffer, (uint32_t)len);
+  if (dflag & DEBUG_SCREEN) taosWriteFile(1, buffer, (uint32_t)len);
 }
 
 #if 0
@@ -506,8 +508,8 @@ void taosCloseLog() {
 
 static void taosCloseLogByFd(int32_t fd) {
   if (fd >= 0) {
-    taosUnLockFile(fd);
-    taosClose(fd);
+    taosUnLockLogFile(fd);
+    taosCloseFile(fd);
   }
 }
 
@@ -644,12 +646,12 @@ static void taosWriteLog(SLogBuff *tLogBuff) {
     }
 
     if (start < end) {
-      taosWrite(tLogBuff->fd, LOG_BUF_BUFFER(tLogBuff) + start, pollSize);
+      taosWriteFile(tLogBuff->fd, LOG_BUF_BUFFER(tLogBuff) + start, pollSize);
     } else {
         int32_t tsize = LOG_BUF_SIZE(tLogBuff) - start;
-        taosWrite(tLogBuff->fd, LOG_BUF_BUFFER(tLogBuff) + start, tsize);
+        taosWriteFile(tLogBuff->fd, LOG_BUF_BUFFER(tLogBuff) + start, tsize);
 
-        taosWrite(tLogBuff->fd, LOG_BUF_BUFFER(tLogBuff), end);
+        taosWriteFile(tLogBuff->fd, LOG_BUF_BUFFER(tLogBuff), end);
     }
 
     dbgWN++;