Merge pull request #26682 from taosdata/enh--refactor-return-code

enh: refactor return code

source/util/src/tarray.c

@@ -34,12 +34,14 @@ SArray* taosArrayInit(size_t size, size_t elemSize) {
 
   SArray* pArray = taosMemoryMalloc(sizeof(SArray));
   if (pArray == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
     return NULL;
   }
 
   pArray->size = 0;
   pArray->pData = taosMemoryCalloc(size, elemSize);
   if (pArray->pData == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
     taosMemoryFree(pArray);
     return NULL;
   }
@@ -167,6 +169,7 @@ void* taosArrayAddAll(SArray* pArray, const SArray* pInput) {
   if (pInput) {
     return taosArrayAddBatch(pArray, pInput->pData, (int32_t)taosArrayGetSize(pInput));
   } else {
+    terrno = TSDB_CODE_INVALID_PARA;
     return NULL;
   }
 }
@@ -197,11 +200,13 @@ void* taosArrayPop(SArray* pArray) {
 
 void* taosArrayGet(const SArray* pArray, size_t index) {
   if (NULL == pArray) {
+    terrno = TSDB_CODE_INVALID_PARA;
     return NULL;
   }
 
   if (index >= pArray->size) {
     uError("index is out of range, current:%" PRIzu " max:%" PRIzu, index, pArray->size);
+    terrno = TSDB_CODE_OUT_OF_RANGE;
     return NULL;
   }
 
@@ -218,6 +223,7 @@ void* taosArrayGetP(const SArray* pArray, size_t index) {
 
 void* taosArrayGetLast(const SArray* pArray) {
   if (pArray->size == 0) {
+    terrno = TSDB_CODE_INVALID_PARA;
     return NULL;
   }
 
@@ -244,6 +250,7 @@ void* taosArrayInsert(SArray* pArray, size_t index, const void* pData) {
   if (pArray->size >= pArray->capacity) {
     int32_t ret = taosArrayResize(pArray);
     if (ret < 0) {
+      terrno = ret;
       return NULL;
     }
   }
@@ -329,6 +336,7 @@ SArray* taosArrayFromList(const void* src, size_t size, size_t elemSize) {
 
 SArray* taosArrayDup(const SArray* pSrc, __array_item_dup_fn_t fn) {
   if (NULL == pSrc) {
+    terrno = TSDB_CODE_INVALID_PARA;
     return NULL;
   }
 

source/util/src/tlist.c

@@ -23,7 +23,10 @@ void tdListInit(SList *list, int32_t eleSize) {
 
 SList *tdListNew(int32_t eleSize) {
   SList *list = (SList *)taosMemoryMalloc(sizeof(SList));
-  if (list == NULL) return NULL;
+  if (list == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return NULL;
+  }
 
   tdListInit(list, eleSize);
   return list;
@@ -68,7 +71,9 @@ void tdListAppendNode(SList *list, SListNode *node) { TD_DLIST_APPEND(list, node
 
 int32_t tdListPrepend(SList *list, void *data) {
   SListNode *node = (SListNode *)taosMemoryMalloc(sizeof(SListNode) + list->eleSize);
-  if (node == NULL) return -1;
+  if (node == NULL) {
+    return terrno = TSDB_CODE_OUT_OF_MEMORY;
+  }
 
   memcpy((void *)(node->data), data, list->eleSize);
   TD_DLIST_PREPEND(list, node);
@@ -78,7 +83,9 @@ int32_t tdListPrepend(SList *list, void *data) {
 
 int32_t tdListAppend(SList *list, const void *data) {
   SListNode *node = (SListNode *)taosMemoryCalloc(1, sizeof(SListNode) + list->eleSize);
-  if (node == NULL) return -1;
+  if (node == NULL) {
+    return terrno = TSDB_CODE_OUT_OF_MEMORY;
+  }
 
   memcpy((void *)(node->data), data, list->eleSize);
   TD_DLIST_APPEND(list, node);
@@ -88,7 +95,10 @@ int32_t tdListAppend(SList *list, const void *data) {
 // return the node pointer
 SListNode *tdListAdd(SList *list, const void *data) {
   SListNode *node = (SListNode *)taosMemoryCalloc(1, sizeof(SListNode) + list->eleSize);
-  if (node == NULL) return NULL;
+  if (node == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return NULL;
+  }
 
   memcpy((void *)(node->data), data, list->eleSize);
   TD_DLIST_APPEND(list, node);

source/util/src/tskiplist.c

@@ -21,7 +21,7 @@
 #include "tutil.h"
 
 static int32_t            initForwardBackwardPtr(SSkipList *pSkipList);
-static SSkipListNode *    getPriorNode(SSkipList *pSkipList, const char *val, int32_t order, SSkipListNode **pCur);
+static SSkipListNode     *getPriorNode(SSkipList *pSkipList, const char *val, int32_t order, SSkipListNode **pCur);
 static void               tSkipListRemoveNodeImpl(SSkipList *pSkipList, SSkipListNode *pNode);
 static void               tSkipListCorrectLevel(SSkipList *pSkipList);
 static SSkipListIterator *doCreateSkipListIterator(SSkipList *pSkipList, int32_t order);
@@ -39,8 +39,12 @@ static FORCE_INLINE int32_t getSkipListRandLevel(SSkipList *pSkipList);
 
 SSkipList *tSkipListCreate(uint8_t maxLevel, uint8_t keyType, uint16_t keyLen, __compar_fn_t comparFn, uint8_t flags,
                            __sl_key_fn_t fn) {
+  int32_t    code = 0;
   SSkipList *pSkipList = (SSkipList *)taosMemoryCalloc(1, sizeof(SSkipList));
-  if (pSkipList == NULL) return NULL;
+  if (pSkipList == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return NULL;
+  }
 
   if (maxLevel > MAX_SKIP_LIST_LEVEL) {
     maxLevel = MAX_SKIP_LIST_LEVEL;
@@ -64,8 +68,10 @@ SSkipList *tSkipListCreate(uint8_t maxLevel, uint8_t keyType, uint16_t keyLen, _
   pSkipList->comparFn = comparFn;
 #endif
 
-  if (initForwardBackwardPtr(pSkipList) < 0) {
+  code = initForwardBackwardPtr(pSkipList);
+  if (code) {
     tSkipListDestroy(pSkipList);
+    terrno = code;
     return NULL;
   }
 
@@ -73,11 +79,14 @@ SSkipList *tSkipListCreate(uint8_t maxLevel, uint8_t keyType, uint16_t keyLen, _
     pSkipList->lock = (TdThreadRwlock *)taosMemoryCalloc(1, sizeof(TdThreadRwlock));
     if (pSkipList->lock == NULL) {
       tSkipListDestroy(pSkipList);
+      terrno = TSDB_CODE_OUT_OF_MEMORY;
       return NULL;
     }
 
-    if (taosThreadRwlockInit(pSkipList->lock, NULL) != 0) {
+    int32_t rc = taosThreadRwlockInit(pSkipList->lock, NULL);
+    if (rc) {
       tSkipListDestroy(pSkipList);
+      terrno = TAOS_SYSTEM_ERROR(rc);
       return NULL;
     }
   }
@@ -137,8 +146,8 @@ void tSkipListPutBatchByIter(SSkipList *pSkipList, void *iter, iter_next_fn_t it
   SSkipListNode *backward[MAX_SKIP_LIST_LEVEL] = {0};
   SSkipListNode *forward[MAX_SKIP_LIST_LEVEL] = {0};
   bool           hasDup = false;
-  char *         pKey = NULL;
+  char          *pKey = NULL;
-  char *         pDataKey = NULL;
+  char          *pDataKey = NULL;
   int32_t        compare = 0;
 
   tSkipListWLock(pSkipList);
@@ -265,13 +274,17 @@ void tSkipListRemoveNode(SSkipList *pSkipList, SSkipListNode *pNode) {
 #endif
 
 SSkipListIterator *tSkipListCreateIter(SSkipList *pSkipList) {
-  if (pSkipList == NULL) return NULL;
+  if (pSkipList == NULL) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return NULL;
+  }
 
   return doCreateSkipListIterator(pSkipList, TSDB_ORDER_ASC);
 }
 
 SSkipListIterator *tSkipListCreateIterFromVal(SSkipList *pSkipList, const char *val, int32_t type, int32_t order) {
   if (order != TSDB_ORDER_ASC && order != TSDB_ORDER_DESC) {
+    terrno = TSDB_CODE_INVALID_PARA;
     return NULL;
   }
 
@@ -362,7 +375,7 @@ void tSkipListPrint(SSkipList *pSkipList, int16_t nlevel) {
   SSkipListNode *p = SL_NODE_GET_FORWARD_POINTER(pSkipList->pHead, nlevel - 1);
 
   int32_t id = 1;
-  char *  prev = NULL;
+  char   *prev = NULL;
 
   while (p != pSkipList->pTail) {
     char *key = SL_GET_NODE_KEY(pSkipList, p);
@@ -427,6 +440,10 @@ static void tSkipListDoInsert(SSkipList *pSkipList, SSkipListNode **direction, S
 
 static SSkipListIterator *doCreateSkipListIterator(SSkipList *pSkipList, int32_t order) {
   SSkipListIterator *iter = taosMemoryCalloc(1, sizeof(SSkipListIterator));
+  if (iter == NULL) {
+    terrno = TSDB_CODE_OUT_OF_BUFFER;
+    return NULL;
+  }
 
   iter->pSkipList = pSkipList;
   iter->order = order;
@@ -465,7 +482,7 @@ static FORCE_INLINE int32_t tSkipListUnlock(SSkipList *pSkipList) {
 static bool tSkipListGetPosToPut(SSkipList *pSkipList, SSkipListNode **backward, void *pData) {
   int32_t compare = 0;
   bool    hasDupKey = false;
-  char *  pDataKey = pSkipList->keyFn(pData);
+  char   *pDataKey = pSkipList->keyFn(pData);
 
   if (pSkipList->size == 0) {
     for (int32_t i = 0; i < pSkipList->maxLevel; i++) {
@@ -651,13 +668,15 @@ static int32_t initForwardBackwardPtr(SSkipList *pSkipList) {
 
   // head info
   pSkipList->pHead = tSkipListNewNode(maxLevel);
-  if (pSkipList->pHead == NULL) return -1;
+  if (pSkipList->pHead == NULL) {
+    return terrno;
+  }
 
   // tail info
   pSkipList->pTail = tSkipListNewNode(maxLevel);
   if (pSkipList->pTail == NULL) {
     tSkipListFreeNode(pSkipList->pHead);
-    return -1;
+    return terrno;
   }
 
   for (uint32_t i = 0; i < maxLevel; ++i) {
@@ -672,7 +691,10 @@ static SSkipListNode *tSkipListNewNode(uint8_t level) {
   int32_t tsize = sizeof(SSkipListNode) + sizeof(SSkipListNode *) * level * 2;
 
   SSkipListNode *pNode = (SSkipListNode *)taosMemoryCalloc(1, tsize);
-  if (pNode == NULL) return NULL;
+  if (pNode == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return NULL;
+  }
 
   pNode->level = level;
   return pNode;
@@ -699,6 +721,9 @@ static SSkipListNode *tSkipListPutImpl(SSkipList *pSkipList, void *pData, SSkipL
     if (pNode != NULL) {
       pNode->pData = pData;
       tSkipListDoInsert(pSkipList, direction, pNode, isForward);
+    } else {
+      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      return NULL;
     }
   }
 

source/util/src/tthread.c

@@ -18,6 +18,11 @@
 
 TdThread* taosCreateThread(void* (*__start_routine)(void*), void* param) {
   TdThread* pthread = (TdThread*)taosMemoryMalloc(sizeof(TdThread));
+  if (pthread == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return NULL;
+  }
+
   TdThreadAttr thattr;
   taosThreadAttrInit(&thattr);
   taosThreadAttrSetDetachState(&thattr, PTHREAD_CREATE_JOINABLE);
@@ -26,6 +31,7 @@ TdThread* taosCreateThread(void* (*__start_routine)(void*), void* param) {
 
   if (ret != 0) {
     taosMemoryFree(pthread);
+    terrno = TAOS_SYSTEM_ERROR(ret);
     return NULL;
   }
   return pthread;

source/util/src/tunit.c

@@ -23,7 +23,7 @@
 #define UNIT_ONE_PEBIBYTE        (UNIT_ONE_TEBIBYTE * UNIT_SIZE_CONVERT_FACTOR)
 #define UNIT_ONE_EXBIBYTE        (UNIT_ONE_PEBIBYTE * UNIT_SIZE_CONVERT_FACTOR)
 
-static int32_t parseCfgIntWithUnit(const char* str, double *res) {
+static int32_t parseCfgIntWithUnit(const char* str, double* res) {
   double val, temp = (double)INT64_MAX;
   char*  endPtr;
   errno = 0;
@@ -33,8 +33,7 @@ static int32_t parseCfgIntWithUnit(const char* str, double *res) {
     val = taosStr2Double(str, &endPtr);
   }
   if (endPtr == str || errno == ERANGE || isnan(val)) {
-    terrno = TSDB_CODE_INVALID_CFG_VALUE;
+    return terrno = TSDB_CODE_INVALID_CFG_VALUE;
-    return -1;
   }
   while (isspace((unsigned char)*endPtr)) endPtr++;
   uint64_t factor = 1;
@@ -66,27 +65,24 @@ static int32_t parseCfgIntWithUnit(const char* str, double *res) {
         factor = UNIT_ONE_KIBIBYTE;
       } break;
       default:
-        terrno = TSDB_CODE_INVALID_CFG_VALUE;
+        return terrno = TSDB_CODE_INVALID_CFG_VALUE;
-        return -1;
     }
     if ((val > 0 && val > temp) || (val < 0 && val < -temp)) {
-      terrno = TSDB_CODE_OUT_OF_RANGE;
+      return terrno = TSDB_CODE_OUT_OF_RANGE;
-      return -1;
     }
     endPtr++;
     val *= factor;
   }
   while (isspace((unsigned char)*endPtr)) endPtr++;
   if (*endPtr) {
-    terrno = TSDB_CODE_INVALID_CFG_VALUE;
+    return terrno = TSDB_CODE_INVALID_CFG_VALUE;
-    return -1;
   }
   val = rint(val);
   *res = val;
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t taosStrHumanToInt64(const char* str, int64_t *out) {
+int32_t taosStrHumanToInt64(const char* str, int64_t* out) {
   double  res;
   int32_t code = parseCfgIntWithUnit(str, &res);
   if (code == TSDB_CODE_SUCCESS) *out = (int64_t)res;
@@ -117,8 +113,7 @@ int32_t taosStrHumanToInt32(const char* str, int32_t* out) {
   int32_t code = parseCfgIntWithUnit(str, &res);
   if (code == TSDB_CODE_SUCCESS) {
     if (res < INT32_MIN || res > INT32_MAX) {
-      terrno = TSDB_CODE_OUT_OF_RANGE;
+      return terrno = TSDB_CODE_OUT_OF_RANGE;
-      return -1;
     }
     *out = (int32_t)res;
   }

source/util/src/tversion.c

@@ -19,8 +19,7 @@
 
 int32_t taosVersionStrToInt(const char *vstr, int32_t *vint) {
   if (vstr == NULL) {
-    terrno = TSDB_CODE_INVALID_VERSION_STRING;
+    return terrno = TSDB_CODE_INVALID_VERSION_STRING;
-    return -1;
   }
 
   int32_t vnum[4] = {0};
@@ -44,8 +43,7 @@ int32_t taosVersionStrToInt(const char *vstr, int32_t *vint) {
   }
 
   if (vnum[0] <= 0) {
-    terrno = TSDB_CODE_INVALID_VERSION_STRING;
+    return terrno = TSDB_CODE_INVALID_VERSION_STRING;
-    return -1;
   }
 
   *vint = vnum[0] * 1000000 + vnum[1] * 10000 + vnum[2] * 100 + vnum[3];
@@ -58,8 +56,7 @@ int32_t taosVersionIntToStr(int32_t vint, char *vstr, int32_t len) {
   int32_t s3 = (vint % 10000) / 100;
   int32_t s4 = vint % 100;
   if (s1 <= 0) {
-    terrno = TSDB_CODE_INVALID_VERSION_NUMBER;
+    return terrno = TSDB_CODE_INVALID_VERSION_NUMBER;
-    return -1;
   }
 
   snprintf(vstr, len, "%02d.%02d.%02d.%02d", s1, s2, s3, s4);
@@ -104,8 +101,5 @@ int32_t taosCheckVersionCompatibleFromStr(const char *pClientVersion, const char
   if (TSDB_CODE_SUCCESS == code) {
     code = taosCheckVersionCompatible(clientVersion, serverVersion, comparedSegments);
   }
-  if (TSDB_CODE_SUCCESS != code) {
-    code = terrno;
-  }
   return code;
 }

source/util/src/tworker.c

@@ -309,8 +309,7 @@ int32_t tWWorkerInit(SWWorkerPool *pool) {
   pool->nextId = 0;
   pool->workers = taosMemoryCalloc(pool->max, sizeof(SWWorker));
   if (pool->workers == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
   }
 
   (void)taosThreadMutexInit(&pool->mutex, NULL);
@@ -434,6 +433,7 @@ _OVER:
     if (queue != NULL) taosCloseQueue(queue);
     if (worker->qset != NULL) taosCloseQset(worker->qset);
     if (worker->qall != NULL) taosFreeQall(worker->qall);
+    terrno = code;
     return NULL;
   } else {
     while (worker->pid <= 0) taosMsleep(10);
@@ -450,6 +450,7 @@ void tWWorkerFreeQueue(SWWorkerPool *pool, STaosQueue *queue) {
 }
 
 int32_t tSingleWorkerInit(SSingleWorker *pWorker, const SSingleWorkerCfg *pCfg) {
+  int32_t code;
   pWorker->poolType = pCfg->poolType;
   pWorker->name = pCfg->name;
 
@@ -457,32 +458,38 @@ int32_t tSingleWorkerInit(SSingleWorker *pWorker, const SSingleWorkerCfg *pCfg)
     case QWORKER_POOL: {
       SQWorkerPool *pPool = taosMemoryCalloc(1, sizeof(SQWorkerPool));
       if (!pPool) {
-        terrno = TSDB_CODE_OUT_OF_MEMORY;
+        return terrno = TSDB_CODE_OUT_OF_MEMORY;
-        return -1;
       }
       pPool->name = pCfg->name;
       pPool->min = pCfg->min;
       pPool->max = pCfg->max;
       pWorker->pool = pPool;
-      if (tQWorkerInit(pPool) != 0) return -1;
+      if ((code = tQWorkerInit(pPool))) {
+        return (terrno = code);
+      }
 
       pWorker->queue = tQWorkerAllocQueue(pPool, pCfg->param, pCfg->fp);
-      if (pWorker->queue == NULL) return -1;
+      if (pWorker->queue == NULL) {
+        return terrno;
+      }
     } break;
     case QUERY_AUTO_QWORKER_POOL: {
       SQueryAutoQWorkerPool *pPool = taosMemoryCalloc(1, sizeof(SQueryAutoQWorkerPool));
       if (!pPool) {
-        terrno = TSDB_CODE_OUT_OF_MEMORY;
+        return (terrno = TSDB_CODE_OUT_OF_MEMORY);
-        return -1;
       }
       pPool->name = pCfg->name;
       pPool->min = pCfg->min;
       pPool->max = pCfg->max;
       pWorker->pool = pPool;
-      if (tQueryAutoQWorkerInit(pPool) != 0) return -1;
+
+      code = tQueryAutoQWorkerInit(pPool);
+      if (code) return code;
 
       pWorker->queue = tQueryAutoQWorkerAllocQueue(pPool, pCfg->param, pCfg->fp);
-      if (!pWorker->queue) return -1;
+      if (!pWorker->queue) {
+        return terrno;
+      }
     } break;
     default:
       assert(0);
@@ -516,10 +523,14 @@ int32_t tMultiWorkerInit(SMultiWorker *pWorker, const SMultiWorkerCfg *pCfg) {
   SWWorkerPool *pPool = &pWorker->pool;
   pPool->name = pCfg->name;
   pPool->max = pCfg->max;
-  if (tWWorkerInit(pPool) != 0) return -1;
+
+  int32_t code = tWWorkerInit(pPool);
+  if (code) return code;
 
   pWorker->queue = tWWorkerAllocQueue(pPool, pCfg->param, pCfg->fp);
-  if (pWorker->queue == NULL) return -1;
+  if (pWorker->queue == NULL) {
+    return terrno;
+  }
 
   pWorker->name = pCfg->name;
   return 0;