From 91927e84a5ae62a8dff4d9dba902fca930dd67b1 Mon Sep 17 00:00:00 2001 From: wangjiaming0909 <604227650@qq.com> Date: Wed, 18 Sep 2024 14:27:51 +0800 Subject: [PATCH 1/6] ret check for memory allocation --- include/libs/nodes/nodes.h | 1 + source/dnode/mnode/impl/src/mndSma.c | 58 +++++++++++++------------ source/libs/nodes/src/nodesCloneFuncs.c | 9 ++++ source/libs/nodes/src/nodesCodeFuncs.c | 2 + source/libs/nodes/src/nodesUtilFuncs.c | 2 +- source/libs/parser/inc/parInsertUtil.h | 2 +- source/libs/parser/src/parAstCreater.c | 2 + source/libs/parser/src/parInsertSml.c | 12 ++++- source/libs/parser/src/parInsertSql.c | 9 ++-- source/libs/parser/src/parInsertStmt.c | 4 +- source/libs/parser/src/parInsertUtil.c | 13 ++++-- source/libs/parser/src/parTranslater.c | 39 ++++++++++++++++- source/libs/parser/src/parUtil.c | 35 ++++++++++++--- 13 files changed, 139 insertions(+), 49 deletions(-) diff --git a/include/libs/nodes/nodes.h b/include/libs/nodes/nodes.h index 24a062bfa3..72dd3ef3e0 100644 --- a/include/libs/nodes/nodes.h +++ b/include/libs/nodes/nodes.h @@ -173,6 +173,7 @@ int32_t nodesNodeToSQL(SNode* pNode, char* buf, int32_t bufSize, int32_t* len); char* nodesGetNameFromColumnNode(SNode* pNode); int32_t nodesGetOutputNumFromSlotList(SNodeList* pSlots); void nodesSortList(SNodeList** pList, int32_t (*)(SNode* pNode1, SNode* pNode2)); +void destroyFuncParam(void* pFuncStruct); #ifdef __cplusplus } diff --git a/source/dnode/mnode/impl/src/mndSma.c b/source/dnode/mnode/impl/src/mndSma.c index 19c9339af4..1a76ab2a8b 100644 --- a/source/dnode/mnode/impl/src/mndSma.c +++ b/source/dnode/mnode/impl/src/mndSma.c @@ -651,6 +651,9 @@ static int32_t mndCreateSma(SMnode *pMnode, SRpcMsg *pReq, SMCreateSmaReq *pCrea streamObj.targetDbUid = pDb->uid; streamObj.version = 1; streamObj.sql = taosStrdup(pCreate->sql); + if (!streamObj.sql) { + return terrno; + } streamObj.smaId = smaObj.uid; streamObj.conf.watermark = pCreate->watermark; streamObj.deleteMark = pCreate->deleteMark; @@ -658,6 +661,10 @@ static int32_t mndCreateSma(SMnode *pMnode, SRpcMsg *pReq, SMCreateSmaReq *pCrea streamObj.conf.trigger = STREAM_TRIGGER_WINDOW_CLOSE; streamObj.conf.triggerParam = pCreate->maxDelay; streamObj.ast = taosStrdup(smaObj.ast); + if (!streamObj.ast) { + taosMemoryFree(streamObj.sql); + return terrno; + } streamObj.indexForMultiAggBalance = -1; // check the maxDelay @@ -1509,6 +1516,9 @@ static int32_t mndRetrieveIdx(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBloc if (pShow->pIter == NULL) { pShow->pIter = taosMemoryCalloc(1, sizeof(SSmaAndTagIter)); } + if (!pShow->pIter) { + return terrno; + } int32_t read = mndRetrieveSma(pReq, pShow, pBlock, rows); if (read < rows) { read += mndRetrieveTagIdx(pReq, pShow, pBlock, rows - read); @@ -1555,27 +1565,6 @@ static void initSMAObj(SCreateTSMACxt* pCxt) { pCxt->pSma->ast = pCxt->pCreateSmaReq->ast; } -static void initStreamObj(SStreamObj *pStream, const char *streamName, const SMCreateSmaReq *pCreateReq, - const SDbObj *pDb, SSmaObj *pSma) { - tstrncpy(pStream->name, streamName, TSDB_STREAM_FNAME_LEN); - tstrncpy(pStream->sourceDb, pDb->name, TSDB_DB_FNAME_LEN); - tstrncpy(pStream->targetDb, pDb->name, TSDB_DB_FNAME_LEN); - pStream->createTime = taosGetTimestampMs(); - pStream->updateTime = pStream->createTime; - pStream->uid = mndGenerateUid(streamName, strlen(streamName)); - pStream->sourceDbUid = pDb->uid; - pStream->targetDbUid = pDb->uid; - pStream->version = 1; - pStream->sql = taosStrdup(pCreateReq->sql); - pStream->smaId = pSma->uid; - pStream->conf.watermark = 0; - pStream->deleteMark = 0; - pStream->conf.fillHistory = STREAM_FILL_HISTORY_ON; - pStream->conf.trigger = STREAM_TRIGGER_WINDOW_CLOSE; - pStream->conf.triggerParam = 10000; - pStream->ast = taosStrdup(pSma->ast); -} - static int32_t mndCreateTSMABuildCreateStreamReq(SCreateTSMACxt *pCxt) { tstrncpy(pCxt->pCreateStreamReq->name, pCxt->streamName, TSDB_STREAM_FNAME_LEN); tstrncpy(pCxt->pCreateStreamReq->sourceDB, pCxt->pDb->name, TSDB_DB_FNAME_LEN); @@ -1653,11 +1642,15 @@ static int32_t mndCreateTSMABuildCreateStreamReq(SCreateTSMACxt *pCxt) { return code; } -static void mndCreateTSMABuildDropStreamReq(SCreateTSMACxt* pCxt) { +static int32_t mndCreateTSMABuildDropStreamReq(SCreateTSMACxt* pCxt) { tstrncpy(pCxt->pDropStreamReq->name, pCxt->streamName, TSDB_STREAM_FNAME_LEN); pCxt->pDropStreamReq->igNotExists = false; pCxt->pDropStreamReq->sql = taosStrdup(pCxt->pDropSmaReq->name); + if (!pCxt->pDropStreamReq->sql) { + return terrno; + } pCxt->pDropStreamReq->sqlLen = strlen(pCxt->pDropStreamReq->sql); + return TSDB_CODE_SUCCESS; } static int32_t mndSetUpdateDbTsmaVersionPrepareLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pOld, SDbObj *pNew) { @@ -1815,7 +1808,10 @@ static int32_t mndCreateTSMA(SCreateTSMACxt *pCxt) { if (TSDB_CODE_SUCCESS != code) { goto _OVER; } - mndCreateTSMABuildDropStreamReq(pCxt); + code = mndCreateTSMABuildDropStreamReq(pCxt); + if (TSDB_CODE_SUCCESS != code) { + goto _OVER; + } if (TSDB_CODE_SUCCESS != (code = mndCreateTSMATxnPrepare(pCxt))) { goto _OVER; @@ -1985,7 +1981,10 @@ static int32_t mndDropTSMA(SCreateTSMACxt* pCxt) { } SMDropStreamReq dropStreamReq = {0}; pCxt->pDropStreamReq = &dropStreamReq; - mndCreateTSMABuildDropStreamReq(pCxt); + code = mndCreateTSMABuildDropStreamReq(pCxt); + if (TSDB_CODE_SUCCESS != code) { + goto _OVER; + } mndTransSetDbName(pTrans, pCxt->pDb->name, NULL); if (mndTransCheckConflict(pCxt->pMnode, pTrans) != 0) goto _OVER; mndTransSetSerial(pTrans); @@ -2141,12 +2140,15 @@ static int32_t mndRetrieveTSMA(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlo SMnode * pMnode = pReq->info.node; int32_t code = 0; SColumnInfoData *pColInfo; - if (pShow->db[0]) { - pDb = mndAcquireDb(pMnode, pShow->db); - } if (pShow->pIter == NULL) { pShow->pIter = taosMemoryCalloc(1, sizeof(SSmaAndTagIter)); } + if (!pShow->pIter) { + return terrno; + } + if (pShow->db[0]) { + pDb = mndAcquireDb(pMnode, pShow->db); + } SSmaAndTagIter *pIter = pShow->pIter; while (numOfRows < rows) { pIter->pSmaIter = sdbFetch(pMnode->pSdb, SDB_SMA, pIter->pSmaIter, (void **)&pSma); @@ -2273,7 +2275,7 @@ static int32_t mndRetrieveTSMA(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlo mndReleaseDb(pMnode, pSrcDb); if (TSDB_CODE_SUCCESS != code) { sdbCancelFetch(pMnode->pSdb, pIter->pSmaIter); - numOfRows = -1; + numOfRows = code; break; } } diff --git a/source/libs/nodes/src/nodesCloneFuncs.c b/source/libs/nodes/src/nodesCloneFuncs.c index b76e4448d3..d9b72b36b7 100644 --- a/source/libs/nodes/src/nodesCloneFuncs.c +++ b/source/libs/nodes/src/nodesCloneFuncs.c @@ -268,6 +268,7 @@ static SArray* functParamClone(const SArray* pSrc) { if (NULL == pDst) { return NULL; } + int32_t code = 0; for (int i = 0; i < TARRAY_SIZE(pSrc); ++i) { SFunctParam* pFunctParam = taosArrayGet(pSrc, i); SFunctParam* pNewFunctParam = (SFunctParam*)taosArrayPush(pDst, pFunctParam); @@ -277,8 +278,16 @@ static SArray* functParamClone(const SArray* pSrc) { } pNewFunctParam->type = pFunctParam->type; pNewFunctParam->pCol = taosMemoryCalloc(1, sizeof(SColumn)); + if (!pNewFunctParam->pCol) { + code = terrno; + break; + } memcpy(pNewFunctParam->pCol, pFunctParam->pCol, sizeof(SColumn)); } + if (TSDB_CODE_SUCCESS != code) { + taosArrayDestroyEx(pDst, destroyFuncParam); + return NULL; + } return pDst; } diff --git a/source/libs/nodes/src/nodesCodeFuncs.c b/source/libs/nodes/src/nodesCodeFuncs.c index 74879a53af..99d7c4e265 100644 --- a/source/libs/nodes/src/nodesCodeFuncs.c +++ b/source/libs/nodes/src/nodesCodeFuncs.c @@ -3954,6 +3954,7 @@ static int32_t datumToJson(const void* pObj, SJson* pJson) { case TSDB_DATA_TYPE_NCHAR: { // cJSON only support utf-8 encoding. Convert memory content to hex string. char* buf = taosMemoryCalloc(varDataLen(pNode->datum.p) * 2 + 1, sizeof(char)); + if (!buf) return terrno; code = taosHexEncode(varDataVal(pNode->datum.p), buf, varDataLen(pNode->datum.p)); if (code != TSDB_CODE_SUCCESS) { taosMemoryFree(buf); @@ -3971,6 +3972,7 @@ static int32_t datumToJson(const void* pObj, SJson* pJson) { case TSDB_DATA_TYPE_JSON: { int32_t len = getJsonValueLen(pNode->datum.p); char* buf = taosMemoryCalloc(len * 2 + 1, sizeof(char)); + if (!buf) return terrno; code = taosHexEncode(pNode->datum.p, buf, len); if (code != TSDB_CODE_SUCCESS) { taosMemoryFree(buf); diff --git a/source/libs/nodes/src/nodesUtilFuncs.c b/source/libs/nodes/src/nodesUtilFuncs.c index 9f831c05e9..22acf4df45 100644 --- a/source/libs/nodes/src/nodesUtilFuncs.c +++ b/source/libs/nodes/src/nodesUtilFuncs.c @@ -824,7 +824,7 @@ static void destroyTableCfg(STableCfg* pCfg) { static void destroySmaIndex(void* pIndex) { taosMemoryFree(((STableIndexInfo*)pIndex)->expr); } -static void destroyFuncParam(void* pValue) { taosMemoryFree(((SFunctParam*)pValue)->pCol); } +void destroyFuncParam(void* pValue) { taosMemoryFree(((SFunctParam*)pValue)->pCol); } static void destroyHintValue(EHintOption option, void* value) { switch (option) { diff --git a/source/libs/parser/inc/parInsertUtil.h b/source/libs/parser/inc/parInsertUtil.h index df9f698dc1..c5cce55d9a 100644 --- a/source/libs/parser/inc/parInsertUtil.h +++ b/source/libs/parser/inc/parInsertUtil.h @@ -42,7 +42,7 @@ typedef struct SVgroupDataCxt { int32_t insCreateSName(SName *pName, struct SToken *pTableName, int32_t acctId, const char *dbName, SMsgBuf *pMsgBuf); int16_t insFindCol(struct SToken *pColname, int16_t start, int16_t end, SSchema *pSchema); -void insBuildCreateTbReq(SVCreateTbReq *pTbReq, const char *tname, STag *pTag, int64_t suid, const char *sname, +int32_t insBuildCreateTbReq(SVCreateTbReq *pTbReq, const char *tname, STag *pTag, int64_t suid, const char *sname, SArray *tagName, uint8_t tagNum, int32_t ttl); int32_t insInitBoundColsInfo(int32_t numOfBound, SBoundColInfo *pInfo); void insResetBoundColsInfo(SBoundColInfo *pInfo); diff --git a/source/libs/parser/src/parAstCreater.c b/source/libs/parser/src/parAstCreater.c index fa6a3648e0..77d50ffd91 100644 --- a/source/libs/parser/src/parAstCreater.c +++ b/source/libs/parser/src/parAstCreater.c @@ -580,6 +580,7 @@ SNodeList* createHintNodeList(SAstCreateContext* pCxt, const SToken* pLiteral) { } SNodeList* pHintList = NULL; char* hint = strndup(pLiteral->z + 3, pLiteral->n - 5); + if (!hint) return NULL; int32_t i = 0; bool quit = false; bool inParamList = false; @@ -2775,6 +2776,7 @@ _err: static int32_t getIpV4RangeFromWhitelistItem(char* ipRange, SIpV4Range* pIpRange) { int32_t code = TSDB_CODE_SUCCESS; char* ipCopy = taosStrdup(ipRange); + if (!ipCopy) return terrno; char* slash = strchr(ipCopy, '/'); if (slash) { *slash = '\0'; diff --git a/source/libs/parser/src/parInsertSml.c b/source/libs/parser/src/parInsertSml.c index 929ec01f6a..6bfab0c9ce 100644 --- a/source/libs/parser/src/parInsertSml.c +++ b/source/libs/parser/src/parInsertSml.c @@ -274,6 +274,11 @@ int32_t smlBuildCol(STableDataCxt* pTableCxt, SSchema* schema, void* data, int32 } else if (kv->type == TSDB_DATA_TYPE_GEOMETRY || kv->type == TSDB_DATA_TYPE_VARBINARY) { pVal->value.nData = kv->length; pVal->value.pData = taosMemoryMalloc(kv->length); + if (!pVal->value.pData) { + ret = terrno; + uError("SML smlBuildCol malloc failed %s:%d, err: %s", __func__, __LINE__, tstrerror(ret)); + goto end; + } (void)memcpy(pVal->value.pData, (uint8_t*)kv->value, kv->length); } else { (void)memcpy(&pVal->value.val, &(kv->value), kv->length); @@ -318,8 +323,11 @@ int32_t smlBindData(SQuery* query, bool dataFormat, SArray* tags, SArray* colsSc ret = terrno; goto end; } - insBuildCreateTbReq(pCreateTblReq, tableName, pTag, pTableMeta->suid, NULL, tagName, pTableMeta->tableInfo.numOfTags, - ttl); + ret = insBuildCreateTbReq(pCreateTblReq, tableName, pTag, pTableMeta->suid, NULL, tagName, + pTableMeta->tableInfo.numOfTags, ttl); + if (TSDB_CODE_SUCCESS != ret) { + goto end; + } pCreateTblReq->ctb.stbName = taosMemoryCalloc(1, sTableNameLen + 1); if (pCreateTblReq->ctb.stbName == NULL){ diff --git a/source/libs/parser/src/parInsertSql.c b/source/libs/parser/src/parInsertSql.c index d15d305c95..a7e842f486 100644 --- a/source/libs/parser/src/parInsertSql.c +++ b/source/libs/parser/src/parInsertSql.c @@ -465,6 +465,7 @@ static int32_t parseVarbinary(SToken* pToken, uint8_t** pData, uint32_t* nData, *nData = size; } else { *pData = taosMemoryCalloc(1, pToken->n); + if (!pData) return terrno; int32_t len = trimString(pToken->z, pToken->n, *pData, pToken->n); *nData = len; @@ -639,6 +640,9 @@ static int32_t parseTagToken(const char** end, SToken* pToken, SSchema* pSchema, return generateSyntaxErrMsg(pMsgBuf, TSDB_CODE_PAR_VALUE_TOO_LONG, pSchema->name); } val->pData = taosStrdup(pToken->z); + if (!val->pData) { + return terrno; + } val->nData = pToken->n; break; } @@ -770,10 +774,9 @@ static int32_t buildCreateTbReq(SVnodeModifyOpStmt* pStmt, STag* pTag, SArray* p if (NULL == pStmt->pCreateTblReq) { return terrno; } - insBuildCreateTbReq(pStmt->pCreateTblReq, pStmt->targetTableName.tname, pTag, pStmt->pTableMeta->suid, + return insBuildCreateTbReq(pStmt->pCreateTblReq, pStmt->targetTableName.tname, pTag, pStmt->pTableMeta->suid, pStmt->usingTableName.tname, pTagName, pStmt->pTableMeta->tableInfo.numOfTags, TSDB_DEFAULT_TABLE_TTL); - return TSDB_CODE_SUCCESS; } int32_t checkAndTrimValue(SToken* pToken, char* tmpTokenBuf, SMsgBuf* pMsgBuf, int8_t type) { @@ -1919,7 +1922,7 @@ static int32_t processCtbAutoCreationAndCtbMeta(SInsertParseContext* pCxt, SVnod code = terrno; } if (code == TSDB_CODE_SUCCESS) { - insBuildCreateTbReq(pStbRowsCxt->pCreateCtbReq, pStbRowsCxt->ctbName.tname, pStbRowsCxt->pTag, + code = insBuildCreateTbReq(pStbRowsCxt->pCreateCtbReq, pStbRowsCxt->ctbName.tname, pStbRowsCxt->pTag, pStbRowsCxt->pStbMeta->uid, pStbRowsCxt->stbName.tname, pStbRowsCxt->aTagNames, getNumOfTags(pStbRowsCxt->pStbMeta), TSDB_DEFAULT_TABLE_TTL); pStbRowsCxt->pTag = NULL; diff --git a/source/libs/parser/src/parInsertStmt.c b/source/libs/parser/src/parInsertStmt.c index 7d68e80df9..ec4a6ee0e7 100644 --- a/source/libs/parser/src/parInsertStmt.c +++ b/source/libs/parser/src/parInsertStmt.c @@ -237,7 +237,7 @@ int32_t qBindStmtTagsValue(void* pBlock, void* boundTags, int64_t suid, const ch } } - insBuildCreateTbReq(pDataBlock->pData->pCreateTbReq, tName, pTag, suid, sTableName, tagName, + code = insBuildCreateTbReq(pDataBlock->pData->pCreateTbReq, tName, pTag, suid, sTableName, tagName, pDataBlock->pMeta->tableInfo.numOfTags, TSDB_DEFAULT_TABLE_TTL); pTag = NULL; @@ -585,7 +585,7 @@ int32_t qBindStmtTagsValue2(void* pBlock, void* boundTags, int64_t suid, const c } } - insBuildCreateTbReq(pDataBlock->pData->pCreateTbReq, tName, pTag, suid, sTableName, tagName, + code = insBuildCreateTbReq(pDataBlock->pData->pCreateTbReq, tName, pTag, suid, sTableName, tagName, pDataBlock->pMeta->tableInfo.numOfTags, TSDB_DEFAULT_TABLE_TTL); pTag = NULL; diff --git a/source/libs/parser/src/parInsertUtil.c b/source/libs/parser/src/parInsertUtil.c index e77678fb69..b3bfa3982c 100644 --- a/source/libs/parser/src/parInsertUtil.c +++ b/source/libs/parser/src/parInsertUtil.c @@ -146,19 +146,24 @@ int16_t insFindCol(SToken* pColname, int16_t start, int16_t end, SSchema* pSchem return -1; } -void insBuildCreateTbReq(SVCreateTbReq* pTbReq, const char* tname, STag* pTag, int64_t suid, const char* sname, +int32_t insBuildCreateTbReq(SVCreateTbReq* pTbReq, const char* tname, STag* pTag, int64_t suid, const char* sname, SArray* tagName, uint8_t tagNum, int32_t ttl) { pTbReq->type = TD_CHILD_TABLE; + pTbReq->ctb.pTag = (uint8_t*)pTag; pTbReq->name = taosStrdup(tname); + if (!pTbReq->name) return terrno; pTbReq->ctb.suid = suid; pTbReq->ctb.tagNum = tagNum; - if (sname) pTbReq->ctb.stbName = taosStrdup(sname); - pTbReq->ctb.pTag = (uint8_t*)pTag; + if (sname) { + pTbReq->ctb.stbName = taosStrdup(sname); + if (!pTbReq->ctb.stbName) return terrno; + } pTbReq->ctb.tagName = taosArrayDup(tagName, NULL); + if (!pTbReq->ctb.tagName) return terrno; pTbReq->ttl = ttl; pTbReq->commentLen = -1; - return; + return TSDB_CODE_SUCCESS; } static void initBoundCols(int32_t ncols, int16_t* pBoundCols) { diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c index 22d0fe846e..473b4f4b1a 100755 --- a/source/libs/parser/src/parTranslater.c +++ b/source/libs/parser/src/parTranslater.c @@ -2733,6 +2733,9 @@ static int32_t rewriteServerStatusFunc(STranslateContext* pCxt, SNode** pNode) { return TSDB_CODE_RPC_NETWORK_UNAVAIL; } char* pStatus = taosStrdup((void*)"1"); + if (!pStatus) { + return terrno; + } int32_t code = rewriteFuncToValue(pCxt, &pStatus, pNode); if (TSDB_CODE_SUCCESS != code) taosMemoryFree(pStatus); return code; @@ -4122,12 +4125,18 @@ static EDealRes doTranslateTbName(SNode** pNode, void* pContext) { pVal->literal = taosStrdup(pCxt->pTbName); if (NULL == pVal->literal) { pCxt->errCode = TSDB_CODE_OUT_OF_MEMORY; + nodesDestroyNode((SNode*)pVal); return DEAL_RES_ERROR; } pVal->translate = true; pVal->node.resType.type = TSDB_DATA_TYPE_BINARY; pVal->node.resType.bytes = tbLen + VARSTR_HEADER_SIZE; pVal->datum.p = taosMemoryCalloc(1, tbLen + VARSTR_HEADER_SIZE + 1); + if (!pVal->datum.p) { + pCxt->errCode = terrno; + nodesDestroyNode((SNode*)pVal); + return DEAL_RES_ERROR; + } varDataSetLen(pVal->datum.p, tbLen); strncpy(varDataVal(pVal->datum.p), pVal->literal, tbLen); strcpy(pVal->node.userAlias, pFunc->node.userAlias); @@ -5832,6 +5841,11 @@ static int32_t createDefaultEveryNode(STranslateContext* pCxt, SNode** pOutput) pEvery->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_BIGINT].bytes; pEvery->flag |= VALUE_FLAG_IS_DURATION; pEvery->literal = taosStrdup("1s"); + if (!pEvery->literal) { + code = terrno; + nodesDestroyNode((SNode*)pEvery); + return code; + } *pOutput = (SNode*)pEvery; return TSDB_CODE_SUCCESS; @@ -6333,6 +6347,10 @@ static int32_t setEqualTbnameTableVgroups(STranslateContext* pCxt, SSelectStmt* nTbls = taosArrayGetSize(pInfo->aTbnames); SVgroupsInfo* vgsInfo = taosMemoryMalloc(sizeof(SVgroupsInfo) + nTbls * sizeof(SVgroupInfo)); + if (!vgsInfo) { + code = terrno; + break; + } findVgroupsFromEqualTbname(pCxt, pInfo->aTbnames, pInfo->pRealTable->table.dbName, numOfVgs, vgsInfo); if (vgsInfo->numOfVgroups != 0) { taosMemoryFree(pInfo->pRealTable->pVgroupList); @@ -6360,6 +6378,7 @@ static int32_t setEqualTbnameTableVgroups(STranslateContext* pCxt, SSelectStmt* break; } if (NULL == taosArrayPush(pTbNames, &pNewTbName)) { + taosMemoryFreeClear(pNewTbName); code = terrno; break; } @@ -6374,15 +6393,19 @@ static int32_t setEqualTbnameTableVgroups(STranslateContext* pCxt, SSelectStmt* findVgroupsFromEqualTbname(pCxt, pTbNames, pInfo->pRealTable->table.dbName, numOfVgs, vgsInfo); if (vgsInfo->numOfVgroups != 0) { if (NULL == taosArrayPush(pInfo->pRealTable->tsmaTargetTbVgInfo, &vgsInfo)) { + taosMemoryFreeClear(vgsInfo); code = terrno; } } else { - taosMemoryFree(vgsInfo); + taosMemoryFreeClear(vgsInfo); } } taosArrayDestroyP(pTbNames, taosMemoryFree); if (code) break; } + if (TSDB_CODE_SUCCESS != code) { + break; + } } } @@ -9216,6 +9239,9 @@ static int32_t translateCreateUser(STranslateContext* pCxt, SCreateUserStmt* pSt createReq.numIpRanges = pStmt->numIpRanges; if (pStmt->numIpRanges > 0) { createReq.pIpRanges = taosMemoryMalloc(createReq.numIpRanges * sizeof(SIpV4Range)); + if (!createReq.pIpRanges) { + return terrno; + } memcpy(createReq.pIpRanges, pStmt->pIpRanges, sizeof(SIpV4Range) * createReq.numIpRanges); } code = buildCmdMsg(pCxt, TDMT_MND_CREATE_USER, (FSerializeFunc)tSerializeSCreateUserReq, &createReq); @@ -9259,6 +9285,9 @@ static int32_t translateAlterUser(STranslateContext* pCxt, SAlterUserStmt* pStmt alterReq.numIpRanges = pStmt->numIpRanges; if (pStmt->numIpRanges > 0) { alterReq.pIpRanges = taosMemoryMalloc(alterReq.numIpRanges * sizeof(SIpV4Range)); + if (!alterReq.pIpRanges) { + return terrno; + } memcpy(alterReq.pIpRanges, pStmt->pIpRanges, sizeof(SIpV4Range) * alterReq.numIpRanges); } code = buildCmdMsg(pCxt, TDMT_MND_ALTER_USER, (FSerializeFunc)tSerializeSAlterUserReq, &alterReq); @@ -13282,6 +13311,10 @@ static int32_t buildNormalTableBatchReq(int32_t acctId, const SCreateTableStmt* SVCreateTbReq req = {0}; req.type = TD_NORMAL_TABLE; req.name = taosStrdup(pStmt->tableName); + if (!req.name) { + tdDestroySVCreateTbReq(&req); + return terrno; + } req.ttl = pStmt->pOptions->ttl; if (pStmt->pOptions->commentNull == false) { req.comment = taosStrdup(pStmt->pOptions->comment); @@ -14001,6 +14034,7 @@ static int32_t constructParseFileContext(SCreateSubTableFromFileClause* pStmt, S int32_t code = TSDB_CODE_SUCCESS; SParseFileContext* pParFileCxt = taosMemoryCalloc(1, sizeof(SParseFileContext)); + if (!pParFileCxt) return terrno; pParFileCxt->pStbMeta = pSuperTableMeta; pParFileCxt->tagNameFilled = false; pParFileCxt->pTag = NULL; @@ -14265,6 +14299,9 @@ int32_t continueCreateTbFromFile(SParseContext* pParseCxt, SQuery** pQuery) { SMsgBuf tmpBuf = {0}; tmpBuf.buf = taosMemoryMalloc(1024); + if (!tmpBuf.buf) { + return terrno; + } int32_t code = createSubTableFromFile(&tmpBuf, pParseCxt, pModifyStmt); if (TSDB_CODE_SUCCESS != code) goto _OUT; diff --git a/source/libs/parser/src/parUtil.c b/source/libs/parser/src/parUtil.c index 94bd53ea68..d17b8ac6c2 100644 --- a/source/libs/parser/src/parUtil.c +++ b/source/libs/parser/src/parUtil.c @@ -1294,35 +1294,56 @@ int32_t getTsmaFromCache(SParseMetaCache* pMetaCache, const SName* pTsmaName, ST STableCfg* tableCfgDup(STableCfg* pCfg) { STableCfg* pNew = taosMemoryMalloc(sizeof(*pNew)); - + if (!pNew) { + return NULL; + } memcpy(pNew, pCfg, sizeof(*pNew)); - if (NULL != pNew->pComment) { + pNew->pComment = NULL; + pNew->pFuncs = NULL; + pNew->pTags = NULL; + pNew->pSchemas = NULL; + pNew->pSchemaExt = NULL; + if (NULL != pCfg->pComment) { pNew->pComment = taosMemoryCalloc(pNew->commentLen + 1, 1); + if (!pNew->pComment) goto err; memcpy(pNew->pComment, pCfg->pComment, pNew->commentLen); } - if (NULL != pNew->pFuncs) { - pNew->pFuncs = taosArrayDup(pNew->pFuncs, NULL); + if (NULL != pCfg->pFuncs) { + pNew->pFuncs = taosArrayDup(pCfg->pFuncs, NULL); + if (!pNew->pFuncs) goto err; } - if (NULL != pNew->pTags) { - pNew->pTags = taosMemoryCalloc(pNew->tagsLen + 1, 1); + if (NULL != pCfg->pTags) { + pNew->pTags = taosMemoryCalloc(pCfg->tagsLen + 1, 1); + if (!pNew->pTags) goto err; memcpy(pNew->pTags, pCfg->pTags, pNew->tagsLen); } int32_t schemaSize = (pCfg->numOfColumns + pCfg->numOfTags) * sizeof(SSchema); SSchema* pSchema = taosMemoryMalloc(schemaSize); + if (!pSchema) goto err; memcpy(pSchema, pCfg->pSchemas, schemaSize); + pNew->pSchemas = pSchema; + SSchemaExt* pSchemaExt = NULL; if (useCompress(pCfg->tableType) && pCfg->pSchemaExt) { int32_t schemaExtSize = pCfg->numOfColumns * sizeof(SSchemaExt); pSchemaExt = taosMemoryMalloc(schemaExtSize); + if (!pSchemaExt) goto err; memcpy(pSchemaExt, pCfg->pSchemaExt, schemaExtSize); } - pNew->pSchemas = pSchema; pNew->pSchemaExt = pSchemaExt; return pNew; +err: + if (pNew->pComment) taosMemoryFreeClear(pNew->pComment); + if (pNew->pFuncs) taosArrayDestroy(pNew->pFuncs); + if (pNew->pTags) taosMemoryFreeClear(pNew->pTags); + if (pNew->pSchemas) taosMemoryFreeClear(pNew->pSchemas); + if (pNew->pSchemaExt) taosMemoryFreeClear(pNew->pSchemaExt); + taosMemoryFreeClear(pNew); + return NULL; } int32_t getTableCfgFromCache(SParseMetaCache* pMetaCache, const SName* pName, STableCfg** pOutput) { From 1b53ba2df42e999324a074cd4bcba18078aca990 Mon Sep 17 00:00:00 2001 From: kailixu Date: Wed, 18 Sep 2024 23:17:08 +0800 Subject: [PATCH 2/6] enh: check memory allocation --- include/common/tvariant.h | 2 +- source/common/src/tname.c | 2 +- source/common/src/tvariant.c | 4 +++- source/dnode/mnode/impl/src/mndProfile.c | 3 +++ source/libs/function/src/builtinsimpl.c | 3 +-- source/util/src/tcache.c | 28 +++++++++++++++++++----- source/util/src/tconfig.c | 7 +++++- source/util/src/tlog.c | 3 ++- 8 files changed, 39 insertions(+), 13 deletions(-) diff --git a/include/common/tvariant.h b/include/common/tvariant.h index 9a0585dada..0d84b2414e 100644 --- a/include/common/tvariant.h +++ b/include/common/tvariant.h @@ -49,7 +49,7 @@ int32_t toUInteger(const char *z, int32_t n, int32_t base, uint64_t *value); */ int32_t toIntegerPure(const char *z, int32_t n, int32_t base, int64_t *value); -void taosVariantCreateFromBinary(SVariant *pVar, const char *pz, size_t len, uint32_t type); +int32_t taosVariantCreateFromBinary(SVariant *pVar, const char *pz, size_t len, uint32_t type); void taosVariantDestroy(SVariant *pV); diff --git a/source/common/src/tname.c b/source/common/src/tname.c index b725514d4f..a9dda87591 100644 --- a/source/common/src/tname.c +++ b/source/common/src/tname.c @@ -143,7 +143,7 @@ bool tNameIsValid(const SName* name) { SName* tNameDup(const SName* name) { SName* p = taosMemoryMalloc(sizeof(SName)); - memcpy(p, name, sizeof(SName)); + if (p) TAOS_MEMCPY(p, name, sizeof(SName)); return p; } diff --git a/source/common/src/tvariant.c b/source/common/src/tvariant.c index 3cb8d5f41e..60cf7963a8 100644 --- a/source/common/src/tvariant.c +++ b/source/common/src/tvariant.c @@ -368,7 +368,7 @@ int32_t toUInteger(const char *z, int32_t n, int32_t base, uint64_t *value) { * @param len * @param type */ -void taosVariantCreateFromBinary(SVariant *pVar, const char *pz, size_t len, uint32_t type) { +int32_t taosVariantCreateFromBinary(SVariant *pVar, const char *pz, size_t len, uint32_t type) { switch (type) { case TSDB_DATA_TYPE_BOOL: case TSDB_DATA_TYPE_TINYINT: { @@ -426,6 +426,7 @@ void taosVariantCreateFromBinary(SVariant *pVar, const char *pz, size_t len, uin size_t lenInwchar = len / TSDB_NCHAR_SIZE; pVar->ucs4 = taosMemoryCalloc(1, (lenInwchar + 1) * TSDB_NCHAR_SIZE); + if(!pVar->ucs4) return terrno; (void)memcpy(pVar->ucs4, pz, lenInwchar * TSDB_NCHAR_SIZE); pVar->nLen = (int32_t)len; @@ -446,6 +447,7 @@ void taosVariantCreateFromBinary(SVariant *pVar, const char *pz, size_t len, uin } pVar->nType = type; + return 0; } void taosVariantDestroy(SVariant *pVar) { diff --git a/source/dnode/mnode/impl/src/mndProfile.c b/source/dnode/mnode/impl/src/mndProfile.c index 5d91b0b0d8..645a187abb 100644 --- a/source/dnode/mnode/impl/src/mndProfile.c +++ b/source/dnode/mnode/impl/src/mndProfile.c @@ -846,6 +846,7 @@ static int32_t mndRetrieveConns(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBl if (pShow->pIter == NULL) { SProfileMgmt *pMgmt = &pMnode->profileMgmt; pShow->pIter = taosCacheCreateIter(pMgmt->connCache); + if (!pShow->pIter) return terrno; } while (numOfRows < rows) { @@ -1005,6 +1006,7 @@ static int32_t mndRetrieveQueries(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *p if (pShow->pIter == NULL) { SProfileMgmt *pMgmt = &pMnode->profileMgmt; pShow->pIter = taosCacheCreateIter(pMgmt->connCache); + if (!pShow->pIter) return terrno; } // means fetched some data last time for this conn @@ -1042,6 +1044,7 @@ static int32_t mndRetrieveApps(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlo if (pShow->pIter == NULL) { SProfileMgmt *pMgmt = &pMnode->profileMgmt; pShow->pIter = taosCacheCreateIter(pMgmt->appCache); + if (!pShow->pIter) return terrno; } while (numOfRows < rows) { diff --git a/source/libs/function/src/builtinsimpl.c b/source/libs/function/src/builtinsimpl.c index 5fc257db5b..1cb7e64d8d 100644 --- a/source/libs/function/src/builtinsimpl.c +++ b/source/libs/function/src/builtinsimpl.c @@ -3902,8 +3902,7 @@ int32_t doAddIntoResult(SqlFunctionCtx* pCtx, void* pData, int32_t rowIndex, SSD int32_t code = TSDB_CODE_SUCCESS; SVariant val = {0}; - // TODO(smj) : this func need err code - taosVariantCreateFromBinary(&val, pData, tDataTypes[type].bytes, type); + TAOS_CHECK_RETURN(taosVariantCreateFromBinary(&val, pData, tDataTypes[type].bytes, type)); STopBotResItem* pItems = pRes->pItems; diff --git a/source/util/src/tcache.c b/source/util/src/tcache.c index 3b5c46c2b3..40d282efb9 100644 --- a/source/util/src/tcache.c +++ b/source/util/src/tcache.c @@ -366,7 +366,7 @@ SCacheObj *taosCacheInit(int32_t keyType, int64_t refreshTimeInMs, bool extendLi SCacheObj *pCacheObj = (SCacheObj *)taosMemoryCalloc(1, sizeof(SCacheObj)); if (pCacheObj == NULL) { - uError("failed to allocate memory, reason:%s", strerror(errno)); + uError("failed to allocate memory, reason:%s", terrstr()); terrno = TSDB_CODE_OUT_OF_MEMORY; return NULL; } @@ -380,6 +380,14 @@ SCacheObj *taosCacheInit(int32_t keyType, int64_t refreshTimeInMs, bool extendLi return NULL; } + pCacheObj->name = taosStrdup(cacheName); + if (pCacheObj->name == NULL) { + taosMemoryFreeClear(pCacheObj->pEntryList); + taosMemoryFree(pCacheObj); + uError("failed to allocate memory, reason:%s", terrstr()); + return NULL; + } + // set free cache node callback function pCacheObj->hashFp = taosGetDefaultHashFunction(keyType); pCacheObj->freeFp = fn; @@ -389,13 +397,14 @@ SCacheObj *taosCacheInit(int32_t keyType, int64_t refreshTimeInMs, bool extendLi if (__trashcan_lock_init(pCacheObj) != 0) { taosMemoryFreeClear(pCacheObj->pEntryList); + taosMemoryFreeClear(pCacheObj->name); taosMemoryFree(pCacheObj); uError("failed to init lock, reason:%s", strerror(errno)); return NULL; } - pCacheObj->name = taosStrdup(cacheName); + (void)doRegisterCacheObj(pCacheObj); return pCacheObj; } @@ -746,8 +755,13 @@ void taosAddToTrashcan(SCacheObj *pCacheObj, SCacheNode *pNode) { return; } - __trashcan_wr_lock(pCacheObj); STrashElem *pElem = taosMemoryCalloc(1, sizeof(STrashElem)); + if (!pElem) { + uError("cache:%s key:%p, %p move to trashcan failed since %s, numOfElem in trashcan:%d", pCacheObj->name, + pNode->key, pNode->data, terrstr(), pCacheObj->numOfElemsInTrash); + return; + } + __trashcan_wr_lock(pCacheObj); pElem->pData = pNode; pElem->prev = NULL; pElem->next = NULL; @@ -928,9 +942,11 @@ size_t taosCacheGetNumOfObj(const SCacheObj *pCacheObj) { return pCacheObj->numO SCacheIter *taosCacheCreateIter(const SCacheObj *pCacheObj) { SCacheIter *pIter = taosMemoryCalloc(1, sizeof(SCacheIter)); - pIter->pCacheObj = (SCacheObj *)pCacheObj; - pIter->entryIndex = -1; - pIter->index = -1; + if (pIter) { + pIter->pCacheObj = (SCacheObj *)pCacheObj; + pIter->entryIndex = -1; + pIter->index = -1; + } return pIter; } diff --git a/source/util/src/tconfig.c b/source/util/src/tconfig.c index 0840fd571c..6868e6d0eb 100644 --- a/source/util/src/tconfig.c +++ b/source/util/src/tconfig.c @@ -426,7 +426,12 @@ int32_t cfgCheckRangeForDynUpdate(SConfig *pCfg, const char *name, const char *p switch (pItem->dtype) { case CFG_DTYPE_STRING: { if (strcasecmp(name, "slowLogScope") == 0) { - char *tmp = taosStrdup(pVal); + char *tmp = taosStrdup(pVal); + if (!tmp) { + cfgUnLock(pCfg); + uError("failed to config:%s since %s", name, terrstr()); + TAOS_RETURN(terrno); + } int32_t scope = 0; int32_t code = taosSetSlowLogScope(tmp, &scope); if (TSDB_CODE_SUCCESS != code) { diff --git a/source/util/src/tlog.c b/source/util/src/tlog.c index 7d905e843d..aea6647e4c 100644 --- a/source/util/src/tlog.c +++ b/source/util/src/tlog.c @@ -651,7 +651,8 @@ void taosPrintLongString(const char *flags, int32_t level, int32_t dflag, const if (!osLogSpaceSufficient()) return; if (!(dflag & DEBUG_FILE) && !(dflag & DEBUG_SCREEN)) return; - char *buffer = taosMemoryMalloc(LOG_MAX_LINE_DUMP_BUFFER_SIZE); + char *buffer = taosMemoryMalloc(LOG_MAX_LINE_DUMP_BUFFER_SIZE); + if (!buffer) return; int32_t len = taosBuildLogHead(buffer, flags); va_list argpointer; From 1add9ded8d2b0c579a8e32329ea4554cdce97e69 Mon Sep 17 00:00:00 2001 From: kailixu Date: Wed, 18 Sep 2024 23:19:00 +0800 Subject: [PATCH 3/6] enh: check memory allocation --- source/util/src/tcache.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/source/util/src/tcache.c b/source/util/src/tcache.c index 40d282efb9..81e50f6a6b 100644 --- a/source/util/src/tcache.c +++ b/source/util/src/tcache.c @@ -366,7 +366,7 @@ SCacheObj *taosCacheInit(int32_t keyType, int64_t refreshTimeInMs, bool extendLi SCacheObj *pCacheObj = (SCacheObj *)taosMemoryCalloc(1, sizeof(SCacheObj)); if (pCacheObj == NULL) { - uError("failed to allocate memory, reason:%s", terrstr()); + uError("failed to allocate memory, reason:%s", strerror(errno)); terrno = TSDB_CODE_OUT_OF_MEMORY; return NULL; } @@ -404,7 +404,6 @@ SCacheObj *taosCacheInit(int32_t keyType, int64_t refreshTimeInMs, bool extendLi return NULL; } - (void)doRegisterCacheObj(pCacheObj); return pCacheObj; } From 55d66102065a4097bd5ec73fb70a789a0383c3c7 Mon Sep 17 00:00:00 2001 From: Leo Xu <381899826@qq.com> Date: Thu, 19 Sep 2024 15:22:24 +0800 Subject: [PATCH 4/6] =?UTF-8?q?add=20case=20by=20TS-5392=20and=20improve?= =?UTF-8?q?=20=E2=80=98reset=20log=20file=E2=80=99=20check?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../0-others/test_hot_refresh_configurations.py | 16 +++++++++++++--- 1 file changed, 13 insertions(+), 3 deletions(-) diff --git a/tests/system-test/0-others/test_hot_refresh_configurations.py b/tests/system-test/0-others/test_hot_refresh_configurations.py index ad21e8ce7c..35137dfeb1 100644 --- a/tests/system-test/0-others/test_hot_refresh_configurations.py +++ b/tests/system-test/0-others/test_hot_refresh_configurations.py @@ -157,6 +157,12 @@ class TDTestCase: "alias": "tsLogKeepDays", "values": [-365000, 10, 365000], "except_values": [-365001, 365001] + }, + { + "name": "syncLogBufferMemoryAllowed", + "alias": "syncLogBufferMemoryAllowed", + "values": [104857600, 1048576000, 9223372036854775807], + "except_values": [-104857600, 104857599, 9223372036854775808] } ] } @@ -235,11 +241,15 @@ class TDTestCase: def run(self): # reset log - taosdLogAbsoluteFilename = tdCom.getTaosdPath() + "/log/" + "taosdlog*" + taosdLogPath = tdCom.getTaosdPath() + "/log/*" tdSql.execute("alter all dnodes 'resetlog';") - r = subprocess.Popen("cat {} | grep 'reset log file'".format(taosdLogAbsoluteFilename), shell=True, - stdout=subprocess.PIPE, stderr=subprocess.PIPE) + time.sleep(1) + cmd = "egrep 'reset log file' {}".format(taosdLogPath) + tdLog.debug("run cmd: {}".format(cmd)) + r = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) stdout, stderr = r.communicate() + tdLog.debug("stdout: {}".format(stdout.decode())) + tdLog.debug("stderr: {}".format(stderr.decode())) assert ('reset log file' in stdout.decode()) for key in self.configration_dic: From ae7dde1aa2bcee29917fae2eaf3bc52b6de968fc Mon Sep 17 00:00:00 2001 From: lyh250-666 Date: Thu, 19 Sep 2024 19:51:51 +0800 Subject: [PATCH 5/6] enh:modify error code passing --- source/dnode/vnode/src/tq/tqScan.c | 10 +-- source/dnode/vnode/src/tq/tqSink.c | 42 ++++----- source/dnode/vnode/src/tq/tqSnapshot.c | 2 +- source/dnode/vnode/src/tq/tqStreamStateSnap.c | 2 +- source/dnode/vnode/src/tq/tqStreamTask.c | 2 +- source/dnode/vnode/src/tq/tqStreamTaskSnap.c | 4 +- source/dnode/vnode/src/tq/tqUtil.c | 6 +- source/dnode/vnode/src/tqCommon/tqCommon.c | 2 +- source/dnode/vnode/src/tsdb/tsdbCache.c | 88 +++++++++---------- source/dnode/vnode/src/tsdb/tsdbCacheRead.c | 20 ++--- source/dnode/vnode/src/tsdb/tsdbCommit2.c | 6 +- source/dnode/vnode/src/tsdb/tsdbDataFileRW.c | 4 +- source/dnode/vnode/src/tsdb/tsdbFS.c | 38 ++++---- source/dnode/vnode/src/tsdb/tsdbFS2.c | 12 +-- source/dnode/vnode/src/tsdb/tsdbRead2.c | 20 ++--- 15 files changed, 129 insertions(+), 129 deletions(-) diff --git a/source/dnode/vnode/src/tq/tqScan.c b/source/dnode/vnode/src/tq/tqScan.c index 527001e679..14b347ce73 100644 --- a/source/dnode/vnode/src/tq/tqScan.c +++ b/source/dnode/vnode/src/tq/tqScan.c @@ -36,11 +36,11 @@ int32_t tqAddBlockDataToRsp(const SSDataBlock* pBlock, void* pRsp, int32_t numOf actualLen += sizeof(SRetrieveTableRspForTmq); if (taosArrayPush(((SMqDataRspCommon*)pRsp)->blockDataLen, &actualLen) == NULL){ taosMemoryFree(buf); - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } if (taosArrayPush(((SMqDataRspCommon*)pRsp)->blockData, &buf) == NULL) { taosMemoryFree(buf); - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } return TSDB_CODE_SUCCESS; @@ -52,7 +52,7 @@ static int32_t tqAddBlockSchemaToRsp(const STqExecHandle* pExec, void* pRsp) { return TSDB_CODE_OUT_OF_MEMORY; } if (taosArrayPush(((SMqDataRspCommon*)pRsp)->blockSchema, &pSW) == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } return 0; } @@ -327,12 +327,12 @@ static void tqProcessSubData(STQ* pTq, STqHandle* pHandle, STaosxRsp* pRsp, int3 if (pRsp->createTableNum == 0) { pRsp->createTableLen = taosArrayInit(0, sizeof(int32_t)); if (pRsp->createTableLen == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto END; } pRsp->createTableReq = taosArrayInit(0, sizeof(void*)); if (pRsp->createTableReq == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto END; } } diff --git a/source/dnode/vnode/src/tq/tqSink.c b/source/dnode/vnode/src/tq/tqSink.c index c42d5e7de5..b18fa42cae 100644 --- a/source/dnode/vnode/src/tq/tqSink.c +++ b/source/dnode/vnode/src/tq/tqSink.c @@ -198,7 +198,7 @@ int32_t initCreateTableMsg(SVCreateTbReq* pCreateTableReq, uint64_t suid, const pCreateTableReq->ctb.stbName = taosStrdup((char*)tNameGetTableName(&name)); if (pCreateTableReq->ctb.stbName == NULL) { // ignore this error code tqError("failed to duplicate the stb name:%s, failed to init create-table msg and create req table", stbFullName); - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; } } @@ -291,7 +291,7 @@ static int32_t doBuildAndSendCreateTableMsg(SVnode* pVnode, char* stbFullName, S void* p = taosArrayPush(tagArray, &tagVal); if (p == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } code = createDefaultTagColName(&pCreateTbReq->ctb.tagName); @@ -317,7 +317,7 @@ static int32_t doBuildAndSendCreateTableMsg(SVnode* pVnode, char* stbFullName, S } void* p = taosArrayPush(tagArray, &tagVal); if (p == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _end; } } @@ -356,7 +356,7 @@ static int32_t doBuildAndSendCreateTableMsg(SVnode* pVnode, char* stbFullName, S void* p = taosArrayPush(reqs.pArray, pCreateTbReq); if (p == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _end; } @@ -446,13 +446,13 @@ int32_t doMergeExistedRows(SSubmitTbData* pExisted, const SSubmitTbData* pNew, c if (pNewRow->ts < pOldRow->ts) { void* p = taosArrayPush(pFinal, &pNewRow); if (p == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } j += 1; } else if (pNewRow->ts > pOldRow->ts) { void* p = taosArrayPush(pFinal, &pOldRow); if (p == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } k += 1; @@ -461,7 +461,7 @@ int32_t doMergeExistedRows(SSubmitTbData* pExisted, const SSubmitTbData* pNew, c if (pNewRow->numOfPKs == 0) { void* p = taosArrayPush(pFinal, &pNewRow); if (p == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } k += 1; @@ -478,7 +478,7 @@ int32_t doMergeExistedRows(SSubmitTbData* pExisted, const SSubmitTbData* pNew, c if (ret <= 0) { void* p = taosArrayPush(pFinal, &pNewRow); if (p == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } j += 1; @@ -490,7 +490,7 @@ int32_t doMergeExistedRows(SSubmitTbData* pExisted, const SSubmitTbData* pNew, c } else { void* p = taosArrayPush(pFinal, &pOldRow); if (p == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } k += 1; @@ -503,7 +503,7 @@ int32_t doMergeExistedRows(SSubmitTbData* pExisted, const SSubmitTbData* pNew, c SRow* pRow = *(SRow**)TARRAY_GET_ELEM(pNew->aRowP, j++); void* p = taosArrayPush(pFinal, &pRow); if (p == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } } @@ -511,7 +511,7 @@ int32_t doMergeExistedRows(SSubmitTbData* pExisted, const SSubmitTbData* pNew, c SRow* pRow = *(SRow**)TARRAY_GET_ELEM(pExisted->aRowP, k++); void* p = taosArrayPush(pFinal, &pRow); if (p == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } } @@ -564,7 +564,7 @@ int32_t buildAutoCreateTableReq(const char* stbFullName, int64_t suid, int32_t n STagVal tagVal = {.cid = numOfCols, .type = TSDB_DATA_TYPE_UBIGINT, .i64 = pDataBlock->info.id.groupId}; void* p = taosArrayPush(pTagArray, &tagVal); if (p == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } code = tTagNew(pTagArray, 1, false, (STag**)&pCreateTbReq->ctb.pTag); @@ -604,7 +604,7 @@ int32_t buildSubmitMsgImpl(SSubmitReq2* pSubmitReq, int32_t vgId, void** pMsg, i pBuf = rpcMallocCont(len); if (NULL == pBuf) { tDestroySubmitReq(pSubmitReq, TSDB_MSG_FLG_ENCODE); - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } ((SSubmitReq2Msg*)pBuf)->header.vgId = vgId; @@ -652,7 +652,7 @@ int32_t doConvertRows(SSubmitTbData* pTableData, const STSchema* pTSchema, SSDat taosArrayDestroy(pTableData->aRowP); pTableData->aRowP = NULL; taosArrayDestroy(pVals); - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; tqError("s-task:%s failed to prepare write stream res blocks, code:%s", id, tstrerror(code)); return code; } @@ -695,7 +695,7 @@ int32_t doConvertRows(SSubmitTbData* pTableData, const STSchema* pTSchema, SSDat SColVal cv = COL_VAL_NULL(pCol->colId, pCol->type); void* p = taosArrayPush(pVals, &cv); if (p == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } } else { SColumnInfoData* pColData = taosArrayGet(pDataBlock->pDataBlock, dataIndex); @@ -713,7 +713,7 @@ int32_t doConvertRows(SSubmitTbData* pTableData, const STSchema* pTSchema, SSDat SColVal cv = COL_VAL_NULL(pCol->colId, pCol->type); void* p = taosArrayPush(pVals, &cv); if (p == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } dataIndex++; @@ -725,7 +725,7 @@ int32_t doConvertRows(SSubmitTbData* pTableData, const STSchema* pTSchema, SSDat SColVal cv = COL_VAL_VALUE(pCol->colId, sv); void* p = taosArrayPush(pVals, &cv); if (p == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } } else { SValue sv = {.type = pCol->type}; @@ -733,7 +733,7 @@ int32_t doConvertRows(SSubmitTbData* pTableData, const STSchema* pTSchema, SSDat SColVal cv = COL_VAL_VALUE(pCol->colId, sv); void* p = taosArrayPush(pVals, &cv); if (p == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } } dataIndex++; @@ -752,7 +752,7 @@ int32_t doConvertRows(SSubmitTbData* pTableData, const STSchema* pTSchema, SSDat void* p = taosArrayPush(pTableData->aRowP, &pRow); if (p == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } } @@ -1026,7 +1026,7 @@ void tqSinkDataIntoDstTable(SStreamTask* pTask, void* vnode, void* data) { SSubmitReq2 submitReq = {.aSubmitTbData = taosArrayInit(1, sizeof(SSubmitTbData))}; if (submitReq.aSubmitTbData == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; tqError("s-task:%s vgId:%d failed to prepare submit msg in sink task, code:%s", id, vgId, tstrerror(code)); return; } @@ -1066,7 +1066,7 @@ void tqSinkDataIntoDstTable(SStreamTask* pTask, void* vnode, void* data) { SSubmitReq2 submitReq = {.aSubmitTbData = taosArrayInit(1, sizeof(SSubmitTbData))}; if (submitReq.aSubmitTbData == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; tqError("s-task:%s vgId:%d failed to prepare submit msg in sink task, code:%s", id, vgId, tstrerror(code)); taosHashCleanup(pTableIndexMap); return; diff --git a/source/dnode/vnode/src/tq/tqSnapshot.c b/source/dnode/vnode/src/tq/tqSnapshot.c index e06301ef53..8861f1f49f 100644 --- a/source/dnode/vnode/src/tq/tqSnapshot.c +++ b/source/dnode/vnode/src/tq/tqSnapshot.c @@ -33,7 +33,7 @@ int32_t tqSnapReaderOpen(STQ* pTq, int64_t sver, int64_t ever, int8_t type, STqS // alloc pReader = (STqSnapReader*)taosMemoryCalloc(1, sizeof(STqSnapReader)); if (pReader == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _err; } pReader->pTq = pTq; diff --git a/source/dnode/vnode/src/tq/tqStreamStateSnap.c b/source/dnode/vnode/src/tq/tqStreamStateSnap.c index 70bda848bb..00e6104bd0 100644 --- a/source/dnode/vnode/src/tq/tqStreamStateSnap.c +++ b/source/dnode/vnode/src/tq/tqStreamStateSnap.c @@ -95,7 +95,7 @@ int32_t streamStateSnapRead(SStreamStateReader* pReader, uint8_t** ppData) { } *ppData = taosMemoryMalloc(sizeof(SSnapDataHdr) + len); if (*ppData == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _err; } // refactor later, avoid mem/free freq diff --git a/source/dnode/vnode/src/tq/tqStreamTask.c b/source/dnode/vnode/src/tq/tqStreamTask.c index 8cd04b48f6..ae3d113c66 100644 --- a/source/dnode/vnode/src/tq/tqStreamTask.c +++ b/source/dnode/vnode/src/tq/tqStreamTask.c @@ -96,7 +96,7 @@ int32_t tqScanWalInFuture(STQ* pTq, int32_t numOfTasks, int32_t idleDuration) { SBuildScanWalMsgParam* pParam = taosMemoryMalloc(sizeof(SBuildScanWalMsgParam)); if (pParam == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } pParam->pTq = pTq; diff --git a/source/dnode/vnode/src/tq/tqStreamTaskSnap.c b/source/dnode/vnode/src/tq/tqStreamTaskSnap.c index c49efdb042..2605d70c37 100644 --- a/source/dnode/vnode/src/tq/tqStreamTaskSnap.c +++ b/source/dnode/vnode/src/tq/tqStreamTaskSnap.c @@ -46,7 +46,7 @@ int32_t streamTaskSnapReaderOpen(STQ* pTq, int64_t sver, int64_t ever, SStreamTa pReader->ever = ever; pReader->tdbTbList = taosArrayInit(4, sizeof(STablePair)); if (pReader->tdbTbList == NULL) { - TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, NULL, _err); + TAOS_CHECK_GOTO(terrno, NULL, _err); } STablePair pair1 = {.tbl = pTq->pStreamMeta->pTaskDb, .type = SNAP_DATA_STREAM_TASK}; @@ -159,7 +159,7 @@ NextTbl: } *ppData = taosMemoryMalloc(sizeof(SSnapDataHdr) + vLen); if (*ppData == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _err; } diff --git a/source/dnode/vnode/src/tq/tqUtil.c b/source/dnode/vnode/src/tq/tqUtil.c index 495fcd771a..5b83df3217 100644 --- a/source/dnode/vnode/src/tq/tqUtil.c +++ b/source/dnode/vnode/src/tq/tqUtil.c @@ -25,7 +25,7 @@ int32_t tqInitDataRsp(SMqDataRspCommon* pRsp, STqOffsetVal pOffset) { pRsp->blockDataLen = taosArrayInit(0, sizeof(int32_t)); if (pRsp->blockData == NULL || pRsp->blockDataLen == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } tOffsetCopy(&pRsp->reqOffset, &pOffset); @@ -71,7 +71,7 @@ static int32_t tqInitTaosxRsp(SMqDataRspCommon* pRsp, STqOffsetVal pOffset) { taosArrayDestroy(pRsp->blockSchema); pRsp->blockSchema = NULL; } - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } return 0; @@ -540,7 +540,7 @@ int32_t tqDoSendDataRsp(const SRpcHandleInfo* pRpcHandleInfo, const void* pRsp, int32_t tlen = sizeof(SMqRspHead) + len; void* buf = rpcMallocCont(tlen); if (buf == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } SMqRspHead* pHead = (SMqRspHead*)buf; diff --git a/source/dnode/vnode/src/tqCommon/tqCommon.c b/source/dnode/vnode/src/tqCommon/tqCommon.c index 116acd4636..30be253b65 100644 --- a/source/dnode/vnode/src/tqCommon/tqCommon.c +++ b/source/dnode/vnode/src/tqCommon/tqCommon.c @@ -578,7 +578,7 @@ int32_t tqStreamTaskProcessCheckpointReadyMsg(SStreamMeta* pMeta, SRpcMsg* pMsg) { // send checkpoint ready rsp SMStreamCheckpointReadyRspMsg* pReadyRsp = rpcMallocCont(sizeof(SMStreamCheckpointReadyRspMsg)); if (pReadyRsp == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } pReadyRsp->upstreamTaskId = req.upstreamTaskId; diff --git a/source/dnode/vnode/src/tsdb/tsdbCache.c b/source/dnode/vnode/src/tsdb/tsdbCache.c index 9cdd4dcdb5..3983b6eded 100644 --- a/source/dnode/vnode/src/tsdb/tsdbCache.c +++ b/source/dnode/vnode/src/tsdb/tsdbCache.c @@ -425,7 +425,7 @@ static int32_t tsdbCacheSerialize(SLastCol *pLastCol, char **value, size_t *size *value = taosMemoryMalloc(*size); if (NULL == *value) { - TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); + TAOS_RETURN(terrno); } int32_t offset = tsdbCacheSerializeV0(*value, pLastCol); @@ -509,7 +509,7 @@ static int32_t reallocVarDataVal(SValue *pValue) { if (nData > 0) { uint8_t *p = taosMemoryMalloc(nData); if (!p) { - TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); + TAOS_RETURN(terrno); } pValue->pData = p; (void)memcpy(pValue->pData, pVal, nData); @@ -1115,11 +1115,11 @@ static int32_t tsdbCacheUpdate(STsdb *pTsdb, tb_uid_t suid, tb_uid_t uid, SArray if (!remainCols) { remainCols = taosArrayInit(num_keys * 2, sizeof(SIdxKey)); if (!remainCols) { - TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _exit); + TAOS_CHECK_GOTO(terrno, &lino, _exit); } } if (!taosArrayPush(remainCols, &(SIdxKey){i, *key})) { - TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _exit); + TAOS_CHECK_GOTO(terrno, &lino, _exit); } } } @@ -1273,7 +1273,7 @@ int32_t tsdbCacheRowFormatUpdate(STsdb *pTsdb, tb_uid_t suid, tb_uid_t uid, int6 for (SColVal *pColVal = tsdbRowIterNext(&iter); pColVal && iCol < nCol; pColVal = tsdbRowIterNext(&iter), iCol++) { SLastUpdateCtx updateCtx = {.lflag = LFLAG_LAST_ROW, .tsdbRowKey = tsdbRowKey, .colVal = *pColVal}; if (!taosArrayPush(ctxArray, &updateCtx)) { - TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _exit); + TAOS_CHECK_GOTO(terrno, &lino, _exit); } if (!COL_VAL_IS_VALUE(pColVal)) { @@ -1284,7 +1284,7 @@ int32_t tsdbCacheRowFormatUpdate(STsdb *pTsdb, tb_uid_t suid, tb_uid_t uid, int6 } updateCtx.lflag = LFLAG_LAST; if (!taosArrayPush(ctxArray, &updateCtx)) { - TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _exit); + TAOS_CHECK_GOTO(terrno, &lino, _exit); } } tsdbRowClose(&iter); @@ -1310,7 +1310,7 @@ int32_t tsdbCacheRowFormatUpdate(STsdb *pTsdb, tb_uid_t suid, tb_uid_t uid, int6 if (COL_VAL_IS_VALUE(&colVal)) { SLastUpdateCtx updateCtx = {.lflag = LFLAG_LAST, .tsdbRowKey = tsdbRowKey, .colVal = colVal}; if (!taosArrayPush(ctxArray, &updateCtx)) { - TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _exit); + TAOS_CHECK_GOTO(terrno, &lino, _exit); } (void)tSimpleHashIterateRemove(iColHash, &iCol, sizeof(iCol), &pIte, &iter); } @@ -1352,7 +1352,7 @@ int32_t tsdbCacheColFormatUpdate(STsdb *pTsdb, tb_uid_t suid, tb_uid_t uid, SBlo .colVal = COL_VAL_VALUE(PRIMARYKEY_TIMESTAMP_COL_ID, ((SValue){.type = TSDB_DATA_TYPE_TIMESTAMP, .val = lRow.pBlockData->aTSKEY[lRow.iRow]}))}; if (!taosArrayPush(ctxArray, &updateCtx)) { - TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _exit); + TAOS_CHECK_GOTO(terrno, &lino, _exit); } } @@ -1375,7 +1375,7 @@ int32_t tsdbCacheColFormatUpdate(STsdb *pTsdb, tb_uid_t suid, tb_uid_t uid, SBlo SLastUpdateCtx updateCtx = {.lflag = LFLAG_LAST, .tsdbRowKey = tsdbRowKey, .colVal = colVal}; if (!taosArrayPush(ctxArray, &updateCtx)) { - TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _exit); + TAOS_CHECK_GOTO(terrno, &lino, _exit); } break; } @@ -1388,7 +1388,7 @@ int32_t tsdbCacheColFormatUpdate(STsdb *pTsdb, tb_uid_t suid, tb_uid_t uid, SBlo for (SColVal *pColVal = tsdbRowIterNext(&iter); pColVal; pColVal = tsdbRowIterNext(&iter)) { SLastUpdateCtx updateCtx = {.lflag = LFLAG_LAST_ROW, .tsdbRowKey = tsdbRowKey, .colVal = *pColVal}; if (!taosArrayPush(ctxArray, &updateCtx)) { - TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _exit); + TAOS_CHECK_GOTO(terrno, &lino, _exit); } } tsdbRowClose(&iter); @@ -1423,7 +1423,7 @@ static int32_t tsdbCacheLoadFromRaw(STsdb *pTsdb, tb_uid_t uid, SArray *pLastArr SLastKey *key = &(SLastKey){.lflag = ltype, .uid = uid, .cid = PRIMARYKEY_TIMESTAMP_COL_ID}; if (!taosArrayInsert(remainCols, 0, &(SIdxKey){0, *key})) { - TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); + TAOS_RETURN(terrno); } } @@ -1447,7 +1447,7 @@ static int32_t tsdbCacheLoadFromRaw(STsdb *pTsdb, tb_uid_t uid, SArray *pLastArr int lastrowIndex = 0; if (!slotIds || !lastColIds || !lastSlotIds || !lastrowColIds || !lastrowSlotIds) { - TAOS_CHECK_EXIT(TSDB_CODE_OUT_OF_MEMORY); + TAOS_CHECK_EXIT(terrno); } for (int i = 0; i < num_keys; ++i) { @@ -1457,11 +1457,11 @@ static int32_t tsdbCacheLoadFromRaw(STsdb *pTsdb, tb_uid_t uid, SArray *pLastArr if (NULL == lastTmpIndexArray) { lastTmpIndexArray = taosArrayInit(num_keys, sizeof(int32_t)); if (!lastTmpIndexArray) { - TAOS_CHECK_EXIT(TSDB_CODE_OUT_OF_MEMORY); + TAOS_CHECK_EXIT(terrno); } } if (!taosArrayPush(lastTmpIndexArray, &(i))) { - TAOS_CHECK_EXIT(TSDB_CODE_OUT_OF_MEMORY); + TAOS_CHECK_EXIT(terrno); } lastColIds[lastIndex] = idxKey->key.cid; lastSlotIds[lastIndex] = pr->pSlotIds[idxKey->idx]; @@ -1470,11 +1470,11 @@ static int32_t tsdbCacheLoadFromRaw(STsdb *pTsdb, tb_uid_t uid, SArray *pLastArr if (NULL == lastrowTmpIndexArray) { lastrowTmpIndexArray = taosArrayInit(num_keys, sizeof(int32_t)); if (!lastrowTmpIndexArray) { - TAOS_CHECK_EXIT(TSDB_CODE_OUT_OF_MEMORY); + TAOS_CHECK_EXIT(terrno); } } if (!taosArrayPush(lastrowTmpIndexArray, &(i))) { - TAOS_CHECK_EXIT(TSDB_CODE_OUT_OF_MEMORY); + TAOS_CHECK_EXIT(terrno); } lastrowColIds[lastrowIndex] = idxKey->key.cid; lastrowSlotIds[lastrowIndex] = pr->pSlotIds[idxKey->idx]; @@ -1484,7 +1484,7 @@ static int32_t tsdbCacheLoadFromRaw(STsdb *pTsdb, tb_uid_t uid, SArray *pLastArr pTmpColArray = taosArrayInit(lastIndex + lastrowIndex, sizeof(SLastCol)); if (!pTmpColArray) { - TAOS_CHECK_EXIT(TSDB_CODE_OUT_OF_MEMORY); + TAOS_CHECK_EXIT(terrno); } if (lastTmpIndexArray != NULL) { @@ -1492,7 +1492,7 @@ static int32_t tsdbCacheLoadFromRaw(STsdb *pTsdb, tb_uid_t uid, SArray *pLastArr for (int i = 0; i < taosArrayGetSize(lastTmpColArray); i++) { if (!taosArrayInsert(pTmpColArray, *(int32_t *)taosArrayGet(lastTmpIndexArray, i), taosArrayGet(lastTmpColArray, i))) { - TAOS_CHECK_EXIT(TSDB_CODE_OUT_OF_MEMORY); + TAOS_CHECK_EXIT(terrno); } } } @@ -1502,7 +1502,7 @@ static int32_t tsdbCacheLoadFromRaw(STsdb *pTsdb, tb_uid_t uid, SArray *pLastArr for (int i = 0; i < taosArrayGetSize(lastrowTmpColArray); i++) { if (!taosArrayInsert(pTmpColArray, *(int32_t *)taosArrayGet(lastrowTmpIndexArray, i), taosArrayGet(lastrowTmpColArray, i))) { - TAOS_CHECK_EXIT(TSDB_CODE_OUT_OF_MEMORY); + TAOS_CHECK_EXIT(terrno); } } } @@ -1594,7 +1594,7 @@ static int32_t tsdbCacheLoadFromRocks(STsdb *pTsdb, tb_uid_t uid, SArray *pLastA if (!keys_list || !keys_list_sizes || !key_list) { taosMemoryFree(keys_list); taosMemoryFree(keys_list_sizes); - TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); + TAOS_RETURN(terrno); } char **values_list = NULL; size_t *values_list_sizes = NULL; @@ -1631,7 +1631,7 @@ static int32_t tsdbCacheLoadFromRocks(STsdb *pTsdb, tb_uid_t uid, SArray *pLastA SLastCol *pTmpLastCol = taosMemoryCalloc(1, sizeof(SLastCol)); if (!pTmpLastCol) { taosMemoryFreeClear(pToFree); - TAOS_CHECK_EXIT(TSDB_CODE_OUT_OF_MEMORY); + TAOS_CHECK_EXIT(terrno); } size_t charge = 0; @@ -1720,7 +1720,7 @@ int32_t tsdbCacheGetBatch(STsdb *pTsdb, tb_uid_t uid, SArray *pLastArray, SCache TAOS_CHECK_GOTO(tsdbCacheReallocSLastCol(&lastCol, NULL), NULL, _exit); if (taosArrayPush(pLastArray, &lastCol) == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _exit; } } else { @@ -1729,29 +1729,29 @@ int32_t tsdbCacheGetBatch(STsdb *pTsdb, tb_uid_t uid, SArray *pLastArray, SCache .colVal = COL_VAL_NONE(cid, pr->pSchema->columns[pr->pSlotIds[i]].type)}; if (taosArrayPush(pLastArray, &noneCol) == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _exit; } if (!remainCols) { if ((remainCols = taosArrayInit(numKeys, sizeof(SIdxKey))) == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _exit; } } if (!ignoreFromRocks) { if ((ignoreFromRocks = taosArrayInit(numKeys, sizeof(bool))) == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _exit; } } if (taosArrayPush(remainCols, &(SIdxKey){i, key}) == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _exit; } bool ignoreRocks = pLastCol ? (pLastCol->cacheStatus == TSDB_LAST_CACHE_NO_CACHE) : false; if (taosArrayPush(ignoreFromRocks, &ignoreRocks) == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _exit; } } @@ -1844,7 +1844,7 @@ int32_t tsdbCacheDel(STsdb *pTsdb, tb_uid_t suid, tb_uid_t uid, TSKEY sKey, TSKE remainCols = taosArrayInit(numCols * 2, sizeof(SIdxKey)); } if (!taosArrayPush(remainCols, &(SIdxKey){i, lastKey})) { - TAOS_CHECK_EXIT(TSDB_CODE_OUT_OF_MEMORY); + TAOS_CHECK_EXIT(terrno); } } } @@ -2032,7 +2032,7 @@ static int32_t getTableDelDataFromTbData(STbData *pTbData, SArray *aDelData) { for (; pDelData; pDelData = pDelData->pNext) { if (!taosArrayPush(aDelData, pDelData)) { - TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); + TAOS_RETURN(terrno); } } @@ -2098,7 +2098,7 @@ static int32_t loadTombFromBlk(const TTombBlkArray *pTombBlkArray, SCacheRowsRea uint64_t *uidList = getUidList(pReader); if (!uidList) { - TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); + TAOS_RETURN(terrno); } for (int i = 0, j = 0; i < pTombBlkArray->size && j < numOfTables; ++i) { @@ -2176,7 +2176,7 @@ static int32_t loadTombFromBlk(const TTombBlkArray *pTombBlkArray, SCacheRowsRea if (pInfo->pTombData == NULL) { pInfo->pTombData = taosArrayInit(4, sizeof(SDelData)); if (!pInfo->pTombData) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; finished = true; break; } @@ -2189,7 +2189,7 @@ static int32_t loadTombFromBlk(const TTombBlkArray *pTombBlkArray, SCacheRowsRea SDelData delData = {.version = record.version, .sKey = record.skey, .eKey = record.ekey}; if (!taosArrayPush(pInfo->pTombData, &delData)) { - TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); + TAOS_RETURN(terrno); } } } @@ -2397,7 +2397,7 @@ static int32_t getNextRowFromFS(void *iter, TSDBROW **ppRow, bool *pIgnoreEarlie if (!state->pIndexList) { state->pIndexList = taosArrayInit(1, sizeof(SBrinBlk)); if (!state->pIndexList) { - TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _err); + TAOS_CHECK_GOTO(terrno, &lino, _err); } } else { taosArrayClear(state->pIndexList); @@ -2410,7 +2410,7 @@ static int32_t getNextRowFromFS(void *iter, TSDBROW **ppRow, bool *pIgnoreEarlie if (state->suid >= pBrinBlk->minTbid.suid && state->suid <= pBrinBlk->maxTbid.suid) { if (state->uid >= pBrinBlk->minTbid.uid && state->uid <= pBrinBlk->maxTbid.uid) { if (!taosArrayPush(state->pIndexList, pBrinBlk)) { - TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _err); + TAOS_CHECK_GOTO(terrno, &lino, _err); } } } else if (state->suid > pBrinBlk->maxTbid.suid || @@ -2971,7 +2971,7 @@ static int32_t nextRowIterGet(CacheNextRowIter *pIter, TSDBROW **ppRow, bool *pI if (!pIter->pSkyline) { pIter->pSkyline = taosArrayInit(32, sizeof(TSDBKEY)); - TSDB_CHECK_NULL(pIter->pSkyline, code, lino, _err, TSDB_CODE_OUT_OF_MEMORY); + TSDB_CHECK_NULL(pIter->pSkyline, code, lino, _err, terrno); uint64_t uid = pIter->idx.uid; STableLoadInfo *pInfo = getTableLoadInfo(pIter->pr, uid); @@ -2979,7 +2979,7 @@ static int32_t nextRowIterGet(CacheNextRowIter *pIter, TSDBROW **ppRow, bool *pI if (pInfo->pTombData == NULL) { pInfo->pTombData = taosArrayInit(4, sizeof(SDelData)); - TSDB_CHECK_NULL(pInfo->pTombData, code, lino, _err, TSDB_CODE_OUT_OF_MEMORY); + TSDB_CHECK_NULL(pInfo->pTombData, code, lino, _err, terrno); } if (!taosArrayAddAll(pInfo->pTombData, pIter->pMemDelData)) { @@ -3024,7 +3024,7 @@ _err: static int32_t initLastColArrayPartial(STSchema *pTSchema, SArray **ppColArray, int16_t *slotIds, int nCols) { SArray *pColArray = taosArrayInit(nCols, sizeof(SLastCol)); if (NULL == pColArray) { - TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); + TAOS_RETURN(terrno); } for (int32_t i = 0; i < nCols; ++i) { @@ -3032,7 +3032,7 @@ static int32_t initLastColArrayPartial(STSchema *pTSchema, SArray **ppColArray, SLastCol col = {.rowKey.ts = 0, .colVal = COL_VAL_NULL(pTSchema->columns[slotId].colId, pTSchema->columns[slotId].type)}; if (!taosArrayPush(pColArray, &col)) { - TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); + TAOS_RETURN(terrno); } } *ppColArray = pColArray; @@ -3044,7 +3044,7 @@ static int32_t cloneTSchema(STSchema *pSrc, STSchema **ppDst) { int32_t len = sizeof(STSchema) + sizeof(STColumn) * pSrc->numOfCols; *ppDst = taosMemoryMalloc(len); if (NULL == *ppDst) { - TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); + TAOS_RETURN(terrno); } memcpy(*ppDst, pSrc, len); @@ -3083,14 +3083,14 @@ static int32_t mergeLastCid(tb_uid_t uid, STsdb *pTsdb, SArray **ppLastArray, SC if (NULL == aColArray) { taosArrayDestroy(pColArray); - TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); + TAOS_RETURN(terrno); } for (int i = 0; i < nCols; ++i) { if (!taosArrayPush(aColArray, &aCols[i])) { taosArrayDestroy(pColArray); - TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); + TAOS_RETURN(terrno); } } @@ -3260,14 +3260,14 @@ static int32_t mergeLastRowCid(tb_uid_t uid, STsdb *pTsdb, SArray **ppLastArray, if (NULL == aColArray) { taosArrayDestroy(pColArray); - TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); + TAOS_RETURN(terrno); } for (int i = 0; i < nCols; ++i) { if (!taosArrayPush(aColArray, &aCols[i])) { taosArrayDestroy(pColArray); - TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); + TAOS_RETURN(terrno); } } @@ -3496,7 +3496,7 @@ int32_t tsdbCacheSetPageS3(SLRUCache *pCache, STsdbFD *pFD, int64_t pgno, uint8_ _taos_lru_deleter_t deleter = deleteBCache; uint8_t *pPg = taosMemoryMalloc(charge); if (!pPg) { - TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); + TAOS_RETURN(terrno); } memcpy(pPg, pPage, charge); diff --git a/source/dnode/vnode/src/tsdb/tsdbCacheRead.c b/source/dnode/vnode/src/tsdb/tsdbCacheRead.c index a7a705fa78..55b2ede505 100644 --- a/source/dnode/vnode/src/tsdb/tsdbCacheRead.c +++ b/source/dnode/vnode/src/tsdb/tsdbCacheRead.c @@ -74,7 +74,7 @@ static int32_t saveOneRow(SArray* pRow, SSDataBlock* pBlock, SCacheRowsReader* p SArray* funcTypeBlockArray = taosArrayInit(pReader->numOfCols, sizeof(int32_t)); if (funcTypeBlockArray == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } for (int32_t i = 0; i < pReader->numOfCols; ++i) { @@ -98,7 +98,7 @@ static int32_t saveOneRow(SArray* pRow, SSDataBlock* pBlock, SCacheRowsReader* p void* px = taosArrayInsert(funcTypeBlockArray, dstSlotIds[i], pVal); if (px == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } } @@ -282,7 +282,7 @@ int32_t tsdbReuseCacherowsReader(void* reader, void* pTableIdList, int32_t numOf destroySttBlockReader(pReader->pLDataIterArray, NULL); pReader->pLDataIterArray = taosArrayInit(4, POINTER_BYTES); - return (pReader->pLDataIterArray != NULL) ? TSDB_CODE_SUCCESS : TSDB_CODE_OUT_OF_MEMORY; + return (pReader->pLDataIterArray != NULL) ? TSDB_CODE_SUCCESS : terrno; } int32_t tsdbCacherowsReaderOpen(void* pVnode, int32_t type, void* pTableIdList, int32_t numOfTables, int32_t numOfCols, @@ -339,7 +339,7 @@ int32_t tsdbCacherowsReaderOpen(void* pVnode, int32_t type, void* pTableIdList, p->transferBuf[i] = taosMemoryMalloc(p->pSchema->columns[i].bytes); if (p->transferBuf[i] == NULL) { tsdbCacherowsReaderClose(p); - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } } } @@ -448,7 +448,7 @@ int32_t tsdbRetrieveCacheRows(void* pReader, SSDataBlock* pResBlock, const int32 pr->pReadSnap = NULL; pRow = taosArrayInit(TARRAY_SIZE(pr->pCidList), sizeof(SLastCol)); if (pRow == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _end; } @@ -486,7 +486,7 @@ int32_t tsdbRetrieveCacheRows(void* pReader, SSDataBlock* pResBlock, const int32 if (HASTYPE(pr->type, CACHESCAN_RETRIEVE_TYPE_SINGLE)) { SArray* pLastCols = taosArrayInit(pr->numOfCols, sizeof(SLastCol)); if (pLastCols == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _end; } @@ -496,7 +496,7 @@ int32_t tsdbRetrieveCacheRows(void* pReader, SSDataBlock* pResBlock, const int32 SLastCol p = {.rowKey.ts = INT64_MIN, .colVal.value.type = TSDB_DATA_TYPE_BOOL, .colVal.flag = CV_FLAG_NULL}; void* px = taosArrayPush(pLastCols, &p); if (px == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _end; } continue; @@ -529,7 +529,7 @@ int32_t tsdbRetrieveCacheRows(void* pReader, SSDataBlock* pResBlock, const int32 void* px = taosArrayPush(pLastCols, &p); if (px == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _end; } } @@ -592,7 +592,7 @@ int32_t tsdbRetrieveCacheRows(void* pReader, SSDataBlock* pResBlock, const int32 if (TARRAY_SIZE(pTableUidList) == 0) { void* px = taosArrayPush(pTableUidList, &uid); if (px == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _end; } } else { @@ -668,7 +668,7 @@ int32_t tsdbRetrieveCacheRows(void* pReader, SSDataBlock* pResBlock, const int32 void* px = taosArrayPush(pTableUidList, &uid); if (px == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _end; } diff --git a/source/dnode/vnode/src/tsdb/tsdbCommit2.c b/source/dnode/vnode/src/tsdb/tsdbCommit2.c index d9d951d591..32371dc399 100644 --- a/source/dnode/vnode/src/tsdb/tsdbCommit2.c +++ b/source/dnode/vnode/src/tsdb/tsdbCommit2.c @@ -439,7 +439,7 @@ static int32_t tsdbCommitInfoInit(STsdb *pTsdb) { pTsdb->commitInfo->arr = taosArrayInit(0, sizeof(SFileSetCommitInfo *)); if (pTsdb->commitInfo->arr == NULL) { - TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit); + TSDB_CHECK_CODE(code = terrno, lino, _exit); } _exit: @@ -457,7 +457,7 @@ static int32_t tsdbCommitInfoAdd(STsdb *tsdb, int32_t fid) { SFileSetCommitInfo *tinfo; if ((tinfo = taosMemoryMalloc(sizeof(*tinfo))) == NULL) { - TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _exit); + TAOS_CHECK_GOTO(terrno, &lino, _exit); } tinfo->fid = fid; tinfo->fset = NULL; @@ -465,7 +465,7 @@ static int32_t tsdbCommitInfoAdd(STsdb *tsdb, int32_t fid) { TAOS_CHECK_GOTO(vHashPut(tsdb->commitInfo->ht, tinfo), &lino, _exit); if ((taosArrayPush(tsdb->commitInfo->arr, &tinfo)) == NULL) { - TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _exit); + TAOS_CHECK_GOTO(terrno, &lino, _exit); } taosArraySort(tsdb->commitInfo->arr, tFileSetCommitInfoPCompare); diff --git a/source/dnode/vnode/src/tsdb/tsdbDataFileRW.c b/source/dnode/vnode/src/tsdb/tsdbDataFileRW.c index e965221920..5a2f9628fb 100644 --- a/source/dnode/vnode/src/tsdb/tsdbDataFileRW.c +++ b/source/dnode/vnode/src/tsdb/tsdbDataFileRW.c @@ -183,7 +183,7 @@ int32_t tsdbDataFileReadBrinBlk(SDataFileReader *reader, const TBrinBlkArray **b if (reader->headFooter->brinBlkPtr->size > 0) { data = taosMemoryMalloc(reader->headFooter->brinBlkPtr->size); if (data == NULL) { - TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _exit); + TAOS_CHECK_GOTO(terrno, &lino, _exit); } int32_t encryptAlgorithm = reader->config->tsdb->pVnode->config.tsdbCfg.encryptAlgorithm; @@ -557,7 +557,7 @@ int32_t tsdbDataFileReadTombBlk(SDataFileReader *reader, const TTombBlkArray **t if (reader->tombFooter->tombBlkPtr->size > 0) { if ((data = taosMemoryMalloc(reader->tombFooter->tombBlkPtr->size)) == NULL) { - TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _exit); + TAOS_CHECK_GOTO(terrno, &lino, _exit); } int32_t encryptAlgorithm = reader->config->tsdb->pVnode->config.tsdbCfg.encryptAlgorithm; diff --git a/source/dnode/vnode/src/tsdb/tsdbFS.c b/source/dnode/vnode/src/tsdb/tsdbFS.c index d9b2112dbb..19e1f42726 100644 --- a/source/dnode/vnode/src/tsdb/tsdbFS.c +++ b/source/dnode/vnode/src/tsdb/tsdbFS.c @@ -72,13 +72,13 @@ static int32_t tsdbBinaryToFS(uint8_t *pData, int64_t nData, STsdbFS *pFS) { int32_t nt = tGetDFileSet(pData + n, &fSet); if (nt < 0) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _exit; } n += nt; if (taosArrayPush(pFS->aDFileSet, &fSet) == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _exit; } } @@ -102,7 +102,7 @@ static int32_t tsdbSaveFSToFile(STsdbFS *pFS, const char *fname) { int32_t size = tsdbFSToBinary(NULL, pFS) + sizeof(TSCKSUM); pData = taosMemoryMalloc(size); if (pData == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; TSDB_CHECK_CODE(code, lino, _exit); } int32_t tsize = tsdbFSToBinary(pData, pFS); @@ -140,7 +140,7 @@ int32_t tsdbFSCreate(STsdbFS *pFS) { pFS->pDelFile = NULL; pFS->aDFileSet = taosArrayInit(0, sizeof(SDFileSet)); if (pFS->aDFileSet == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; goto _exit; } @@ -306,7 +306,7 @@ static int32_t load_fs(const char *fname, STsdbFS *pFS) { pData = taosMemoryMalloc(size); if (pData == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; (void)taosCloseFile(&pFD); TSDB_CHECK_CODE(code, lino, _exit); } @@ -386,7 +386,7 @@ static int32_t tsdbNewFileSet(STsdb *pTsdb, SDFileSet *pSetTo, SDFileSet *pSetFr // head pSetTo->pHeadF = (SHeadFile *)taosMemoryMalloc(sizeof(SHeadFile)); if (pSetTo->pHeadF == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; TSDB_CHECK_CODE(code, lino, _exit); } *pSetTo->pHeadF = *pSetFrom->pHeadF; @@ -395,7 +395,7 @@ static int32_t tsdbNewFileSet(STsdb *pTsdb, SDFileSet *pSetTo, SDFileSet *pSetFr // data pSetTo->pDataF = (SDataFile *)taosMemoryMalloc(sizeof(SDataFile)); if (pSetTo->pDataF == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; TSDB_CHECK_CODE(code, lino, _exit); } *pSetTo->pDataF = *pSetFrom->pDataF; @@ -404,7 +404,7 @@ static int32_t tsdbNewFileSet(STsdb *pTsdb, SDFileSet *pSetTo, SDFileSet *pSetFr // sma pSetTo->pSmaF = (SSmaFile *)taosMemoryMalloc(sizeof(SSmaFile)); if (pSetTo->pSmaF == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; TSDB_CHECK_CODE(code, lino, _exit); } *pSetTo->pSmaF = *pSetFrom->pSmaF; @@ -414,7 +414,7 @@ static int32_t tsdbNewFileSet(STsdb *pTsdb, SDFileSet *pSetTo, SDFileSet *pSetFr for (int32_t iStt = 0; iStt < pSetFrom->nSttF; iStt++) { pSetTo->aSttF[iStt] = (SSttFile *)taosMemoryMalloc(sizeof(SSttFile)); if (pSetTo->aSttF[iStt] == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; TSDB_CHECK_CODE(code, lino, _exit); } @@ -442,7 +442,7 @@ static int32_t tsdbMergeFileSet(STsdb *pTsdb, SDFileSet *pSetOld, SDFileSet *pSe if ((!sameDisk) || (pHeadF->commitID != pSetNew->pHeadF->commitID)) { pSetOld->pHeadF = (SHeadFile *)taosMemoryMalloc(sizeof(SHeadFile)); if (pSetOld->pHeadF == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; TSDB_CHECK_CODE(code, lino, _exit); } *pSetOld->pHeadF = *pSetNew->pHeadF; @@ -465,7 +465,7 @@ static int32_t tsdbMergeFileSet(STsdb *pTsdb, SDFileSet *pSetOld, SDFileSet *pSe if ((!sameDisk) || (pDataF->commitID != pSetNew->pDataF->commitID)) { pSetOld->pDataF = (SDataFile *)taosMemoryMalloc(sizeof(SDataFile)); if (pSetOld->pDataF == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; TSDB_CHECK_CODE(code, lino, _exit); } *pSetOld->pDataF = *pSetNew->pDataF; @@ -486,7 +486,7 @@ static int32_t tsdbMergeFileSet(STsdb *pTsdb, SDFileSet *pSetOld, SDFileSet *pSe if ((!sameDisk) || (pSmaF->commitID != pSetNew->pSmaF->commitID)) { pSetOld->pSmaF = (SSmaFile *)taosMemoryMalloc(sizeof(SSmaFile)); if (pSetOld->pSmaF == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; TSDB_CHECK_CODE(code, lino, _exit); } *pSetOld->pSmaF = *pSetNew->pSmaF; @@ -507,7 +507,7 @@ static int32_t tsdbMergeFileSet(STsdb *pTsdb, SDFileSet *pSetOld, SDFileSet *pSe if (pSetNew->nSttF > pSetOld->nSttF) { pSetOld->aSttF[pSetOld->nSttF] = (SSttFile *)taosMemoryMalloc(sizeof(SSttFile)); if (pSetOld->aSttF[pSetOld->nSttF] == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; TSDB_CHECK_CODE(code, lino, _exit); } *pSetOld->aSttF[pSetOld->nSttF] = *pSetNew->aSttF[pSetOld->nSttF]; @@ -528,7 +528,7 @@ static int32_t tsdbMergeFileSet(STsdb *pTsdb, SDFileSet *pSetOld, SDFileSet *pSe pSetOld->nSttF = 1; pSetOld->aSttF[0] = (SSttFile *)taosMemoryMalloc(sizeof(SSttFile)); if (pSetOld->aSttF[0] == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; TSDB_CHECK_CODE(code, lino, _exit); } *pSetOld->aSttF[0] = *pSetNew->aSttF[0]; @@ -546,7 +546,7 @@ static int32_t tsdbMergeFileSet(STsdb *pTsdb, SDFileSet *pSetOld, SDFileSet *pSe pSetOld->aSttF[iStt] = (SSttFile *)taosMemoryMalloc(sizeof(SSttFile)); if (pSetOld->aSttF[iStt] == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; TSDB_CHECK_CODE(code, lino, _exit); } *pSetOld->aSttF[iStt] = *pSetNew->aSttF[iStt]; @@ -574,7 +574,7 @@ static int32_t tsdbMergeFileSet(STsdb *pTsdb, SDFileSet *pSetOld, SDFileSet *pSe for (int32_t iStt = 0; iStt < pSetNew->nSttF; iStt++) { pSetOld->aSttF[iStt] = (SSttFile *)taosMemoryMalloc(sizeof(SSttFile)); if (pSetOld->aSttF[iStt] == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; TSDB_CHECK_CODE(code, lino, _exit); } @@ -610,7 +610,7 @@ static int32_t tsdbFSApplyChange(STsdb *pTsdb, STsdbFS *pFS) { if (pDelFile == NULL || (pDelFile->commitID != pFS->pDelFile->commitID)) { pTsdb->fs.pDelFile = (SDelFile *)taosMemoryMalloc(sizeof(SDelFile)); if (pTsdb->fs.pDelFile == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; TSDB_CHECK_CODE(code, lino, _exit); } @@ -668,7 +668,7 @@ static int32_t tsdbFSApplyChange(STsdb *pTsdb, STsdbFS *pFS) { TSDB_CHECK_CODE(code, lino, _exit); if (taosArrayInsert(pTsdb->fs.aDFileSet, iOld, &fSet) == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; TSDB_CHECK_CODE(code, lino, _exit); } @@ -684,7 +684,7 @@ static int32_t tsdbFSApplyChange(STsdb *pTsdb, STsdbFS *pFS) { TSDB_CHECK_CODE(code, lino, _exit); if (taosArrayInsert(pTsdb->fs.aDFileSet, iOld, &fSet) == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; TSDB_CHECK_CODE(code, lino, _exit); } diff --git a/source/dnode/vnode/src/tsdb/tsdbFS2.c b/source/dnode/vnode/src/tsdb/tsdbFS2.c index 0db580dfe0..bcaa70f9a8 100644 --- a/source/dnode/vnode/src/tsdb/tsdbFS2.c +++ b/source/dnode/vnode/src/tsdb/tsdbFS2.c @@ -122,7 +122,7 @@ static int32_t load_json(const char *fname, cJSON **json) { data = taosMemoryMalloc(size + 1); if (data == NULL) { - TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit); + TSDB_CHECK_CODE(code = terrno, lino, _exit); } if (taosReadFile(fp, data, size) < 0) { @@ -387,7 +387,7 @@ static void tsdbFSDestroyFileObjHash(STFileHash *hash); static int32_t tsdbFSAddEntryToFileObjHash(STFileHash *hash, const char *fname) { STFileHashEntry *entry = taosMemoryMalloc(sizeof(*entry)); - if (entry == NULL) return TSDB_CODE_OUT_OF_MEMORY; + if (entry == NULL) return terrno; strncpy(entry->fname, fname, TSDB_FILENAME_LEN); @@ -752,7 +752,7 @@ int32_t tsdbDisableAndCancelAllBgTask(STsdb *pTsdb) { STFileSystem *fs = pTsdb->pFS; SArray *channelArray = taosArrayInit(0, sizeof(SVAChannelID)); if (channelArray == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } (void)taosThreadMutexLock(&pTsdb->mutex); @@ -913,7 +913,7 @@ int32_t tsdbFSEditCommit(STFileSystem *fs) { SMergeArg *arg = taosMemoryMalloc(sizeof(*arg)); if (arg == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; TSDB_CHECK_CODE(code, lino, _exit); } @@ -962,7 +962,7 @@ int32_t tsdbFSCreateCopySnapshot(STFileSystem *fs, TFileSetArray **fsetArr) { STFileSet *fset1; fsetArr[0] = taosMemoryMalloc(sizeof(TFileSetArray)); - if (fsetArr[0] == NULL) return TSDB_CODE_OUT_OF_MEMORY; + if (fsetArr[0] == NULL) return terrno; TARRAY2_INIT(fsetArr[0]); @@ -1058,7 +1058,7 @@ int32_t tsdbFSCreateCopyRangedSnapshot(STFileSystem *fs, TFileSetRangeArray *pRa SHashObj *pHash = NULL; fsetArr[0] = taosMemoryMalloc(sizeof(TFileSetArray)); - if (fsetArr == NULL) return TSDB_CODE_OUT_OF_MEMORY; + if (fsetArr == NULL) return terrno; TARRAY2_INIT(fsetArr[0]); if (pRanges) { diff --git a/source/dnode/vnode/src/tsdb/tsdbRead2.c b/source/dnode/vnode/src/tsdb/tsdbRead2.c index 731b733b52..32a9000173 100644 --- a/source/dnode/vnode/src/tsdb/tsdbRead2.c +++ b/source/dnode/vnode/src/tsdb/tsdbRead2.c @@ -388,7 +388,7 @@ int32_t resetDataBlockIterator(SDataBlockIter* pIter, int32_t order, bool needFr if (pIter->blockList == NULL) { pIter->blockList = taosArrayInit(4, sizeof(SFileDataBlockInfo)); if (pIter->blockList == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } } else { clearDataBlockIterator(pIter, needFree); @@ -691,7 +691,7 @@ static int32_t doLoadBlockIndex(STsdbReader* pReader, SDataFileReader* pFileRead void* p1 = taosArrayPush(pIndexList, pBrinBlk); if (p1 == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } i += 1; @@ -815,7 +815,7 @@ static int32_t loadFileBlockBrinInfo(STsdbReader* pReader, SArray* pIndexList, S pScanInfo->pBlockList = taosArrayInit(4, sizeof(SFileDataBlockInfo)); if (pScanInfo->pBlockList == NULL) { clearBrinBlockIter(&iter); - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } } @@ -823,7 +823,7 @@ static int32_t loadFileBlockBrinInfo(STsdbReader* pReader, SArray* pIndexList, S pScanInfo->pBlockIdxList = taosArrayInit(4, sizeof(STableDataBlockIdx)); if (pScanInfo->pBlockIdxList == NULL) { clearBrinBlockIter(&iter); - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } } @@ -832,7 +832,7 @@ static int32_t loadFileBlockBrinInfo(STsdbReader* pReader, SArray* pIndexList, S void* p1 = taosArrayPush(pScanInfo->pBlockList, &blockInfo); if (p1 == NULL) { clearBrinBlockIter(&iter); - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } // todo: refactor to record the fileset skey/ekey @@ -861,7 +861,7 @@ static int32_t loadFileBlockBrinInfo(STsdbReader* pReader, SArray* pIndexList, S if (p1 == NULL) { clearBrinBlockIter(&iter); - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } } @@ -2904,7 +2904,7 @@ int32_t initDelSkylineIterator(STableBlockScanInfo* pBlockScanInfo, int32_t orde } else { pBlockScanInfo->delSkyline = taosArrayInit(4, sizeof(TSDBKEY)); if (pBlockScanInfo->delSkyline == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } } @@ -3017,7 +3017,7 @@ static int32_t moveToNextFile(STsdbReader* pReader, SBlockNumber* pBlockNum, SAr size_t numOfTables = tSimpleHashGetSize(pReader->status.pTableMap); SArray* pIndexList = taosArrayInit(numOfTables, sizeof(SBrinBlk)); if (pIndexList == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } while (1) { @@ -3537,7 +3537,7 @@ static int32_t initForFirstBlockInFile(STsdbReader* pReader, SDataBlockIter* pBl SBlockNumber num = {0}; SArray* pTableList = taosArrayInit(40, POINTER_BYTES); if (pTableList == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } int32_t code = moveToNextFile(pReader, &num, pTableList); @@ -4931,7 +4931,7 @@ static int32_t doSuspendCurrentReader(STsdbReader* pCurrentReader) { destroySttBlockReader(pStatus->pLDataIterArray, &pCost->sttCost); pStatus->pLDataIterArray = taosArrayInit(4, POINTER_BYTES); if (pStatus->pLDataIterArray == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } } From 31b72f65370cfcc01bf2c5937c8ea1351b28af55 Mon Sep 17 00:00:00 2001 From: sheyanjie-qq <249478495@qq.com> Date: Thu, 19 Sep 2024 23:01:07 +0800 Subject: [PATCH 6/6] improve rest api doc --- .../14-reference/05-connector/60-rest-api.mdx | 39 ++++++++++++------- 1 file changed, 25 insertions(+), 14 deletions(-) diff --git a/docs/zh/14-reference/05-connector/60-rest-api.mdx b/docs/zh/14-reference/05-connector/60-rest-api.mdx index de0e7118d4..df6adadcab 100644 --- a/docs/zh/14-reference/05-connector/60-rest-api.mdx +++ b/docs/zh/14-reference/05-connector/60-rest-api.mdx @@ -118,21 +118,32 @@ curl -L -u username:password -d "" :/rest/sql/[db_name][?tz=timez ### HTTP 响应码 -从 `TDengine 3.0.3.0` 开始 `taosAdapter` 提供配置参数 `httpCodeServerError` 用来设置当 C 接口返回错误时是否返回非 200 的http状态码。 -无论是否设置此参数，响应 body 里都有详细的错误码和错误信息，具体请参考 [错误](../rest-api/#错误) 。 +默认情况下，`taosAdapter` 对大多数 C 接口调用出错时也会返回 200 响应码，但是 HTTP body 中包含错误信息。从 `TDengine 3.0.3.0` 开始 `taosAdapter` 提供配置参数 `httpCodeServerError` 用来设置当 C 接口返回错误时是否返回非 200 的 HTTP 响应码。无论是否设置此参数，响应 body 里都有详细的错误码和错误信息，具体请参考 [错误](../rest-api/#错误) 。 -| **说明** | **httpCodeServerError false** | **httpCodeServerError true** | -|--------------------|-------------------------------|---------------------------------------| -| taos_errno() 返回 0 | 200 | 200 | -| taos_errno() 返回 非0 | 200（除鉴权错误） | 500 （除鉴权错误和 400/502/503 错误） | -| 参数错误 | 400（仅处理 HTTP 请求 URL 参数错误） | 400 （处理 HTTP 请求 URL 参数错误和 taosd 返回错误） | -| 鉴权错误 | 401 | 401 | -| 接口不存在 | 404 | 404 | -| 集群不可用错误 | 502 | 502 | -| 系统资源不足 | 503 | 503 | +**当 httpCodeServerError 为 false 时：** -返回 400 的 C 错误码为： +| **分类说明** |**HTTP 响应码** | +|--------------------|-------------------------------| +| C 接口调用成功 | 200 | 200 | +| C 接口调用出错，且不是鉴权错误 | 200 | +| HTTP 请求 URL 参数错误 | 400 | +| C 接口调用鉴权错误 | 401 | +| 接口不存在 | 404 | +| 系统资源不足 | 503 | +**当 httpCodeServerError 为 true 时：** + +| **分类说明** | **HTTP 响应码** | +|--------------------|-------------------------------| +| C 接口调用成功 | 200 | +| HTTP 请求 URL 参数错误和 C 接口调用参数解析错误 | 400 | +| C 接口调用鉴权错误 | 401 | +| 接口不存在 | 404 | +| C 接口调用网络不可用错误 | 502 | +| 系统资源不足 |503 | +| 其他 C 接口调用错误 | 500 | + + C 接口参数解析相关错误码： - TSDB_CODE_TSC_SQL_SYNTAX_ERROR (0x0216) - TSDB_CODE_TSC_LINE_SYNTAX_ERROR (0x021B) - TSDB_CODE_PAR_SYNTAX_ERROR (0x2600) @@ -140,7 +151,7 @@ curl -L -u username:password -d "" :/rest/sql/[db_name][?tz=timez - TSDB_CODE_TSC_VALUE_OUT_OF_RANGE (0x0224) - TSDB_CODE_PAR_INVALID_FILL_TIME_RANGE (0x263B) -返回 401 的错误码为： +C 接口鉴权相关错误码： - TSDB_CODE_MND_USER_ALREADY_EXIST (0x0350) - TSDB_CODE_MND_USER_NOT_EXIST (0x0351) @@ -151,7 +162,7 @@ curl -L -u username:password -d "" :/rest/sql/[db_name][?tz=timez - TSDB_CODE_MND_INVALID_ALTER_OPER (0x0356) - TSDB_CODE_MND_AUTH_FAILURE (0x0357) -返回 502 的错误码为： +C 接口网络不可用相关错误码： - TSDB_CODE_RPC_NETWORK_UNAVAIL (0x000B)