xxq250
/
homework-jianmu
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

TD-1848

This commit is contained in:
Shengliang Guan 2020-11-10 06:44:12 +00:00
parent 817c3b2f36
commit 95d3e55042
75 changed files with 441 additions and 565 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/client/src/tscFunctionImpl.c
View File

@ -2117,7 +2117,7 @@ static void copyTopBotRes(SQLFunctionCtx *pCtx, int32_t type) {
}
}
taosTFree(pData);
tfree(pData);
}
/*

62
src/client/src/tscLocalMerge.c
View File

@ -227,7 +227,7 @@ void tscCreateLocalReducer(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrd
if (ds == NULL) {
tscError("%p failed to create merge structure", pSql);
pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
taosTFree(pReducer);
tfree(pReducer);
return;
}
@ -254,7 +254,7 @@ void tscCreateLocalReducer(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrd
if (ds->filePage.num == 0) { // no data in this flush, the index does not increase
tscDebug("%p flush data is empty, ignore %d flush record", pSql, idx);
taosTFree(ds);
tfree(ds);
continue;
}
@ -264,7 +264,7 @@ void tscCreateLocalReducer(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrd
// no data actually, no need to merge result.
if (idx == 0) {
taosTFree(pReducer);
tfree(pReducer);
return;
}
@ -272,7 +272,7 @@ void tscCreateLocalReducer(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrd
SCompareParam *param = malloc(sizeof(SCompareParam));
if (param == NULL) {
taosTFree(pReducer);
tfree(pReducer);
return;
}
@ -286,8 +286,8 @@ void tscCreateLocalReducer(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrd
pRes->code = tLoserTreeCreate(&pReducer->pLoserTree, pReducer->numOfBuffer, param, treeComparator);
if (pReducer->pLoserTree == NULL || pRes->code != 0) {
taosTFree(param);
taosTFree(pReducer);
tfree(param);
tfree(pReducer);
return;
}
@ -330,14 +330,14 @@ void tscCreateLocalReducer(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrd
if (pReducer->pTempBuffer == NULL || pReducer->discardData == NULL || pReducer->pResultBuf == NULL ||
/*pReducer->pBufForInterpo == NULL || */pReducer->pFinalRes == NULL || pReducer->prevRowOfInput == NULL) {
taosTFree(pReducer->pTempBuffer);
taosTFree(pReducer->discardData);
taosTFree(pReducer->pResultBuf);
taosTFree(pReducer->pFinalRes);
taosTFree(pReducer->prevRowOfInput);
taosTFree(pReducer->pLoserTree);
taosTFree(param);
taosTFree(pReducer);
tfree(pReducer->pTempBuffer);
tfree(pReducer->discardData);
tfree(pReducer->pResultBuf);
tfree(pReducer->pFinalRes);
tfree(pReducer->prevRowOfInput);
tfree(pReducer->pLoserTree);
tfree(param);
tfree(pReducer);
pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
return;
}
@ -495,33 +495,33 @@ void tscDestroyLocalReducer(SSqlObj *pSql) {
SQLFunctionCtx *pCtx = &pLocalReducer->pCtx[i];
tVariantDestroy(&pCtx->tag);
taosTFree(pCtx->resultInfo);
tfree(pCtx->resultInfo);
if (pCtx->tagInfo.pTagCtxList != NULL) {
taosTFree(pCtx->tagInfo.pTagCtxList);
tfree(pCtx->tagInfo.pTagCtxList);
}
}
taosTFree(pLocalReducer->pCtx);
tfree(pLocalReducer->pCtx);
}
taosTFree(pLocalReducer->prevRowOfInput);
tfree(pLocalReducer->prevRowOfInput);
taosTFree(pLocalReducer->pTempBuffer);
taosTFree(pLocalReducer->pResultBuf);
tfree(pLocalReducer->pTempBuffer);
tfree(pLocalReducer->pResultBuf);
if (pLocalReducer->pLoserTree) {
taosTFree(pLocalReducer->pLoserTree->param);
taosTFree(pLocalReducer->pLoserTree);
tfree(pLocalReducer->pLoserTree->param);
tfree(pLocalReducer->pLoserTree);
}
taosTFree(pLocalReducer->pFinalRes);
taosTFree(pLocalReducer->discardData);
tfree(pLocalReducer->pFinalRes);
tfree(pLocalReducer->discardData);
tscLocalReducerEnvDestroy(pLocalReducer->pExtMemBuffer, pLocalReducer->pDesc, pLocalReducer->resColModel,
pLocalReducer->numOfVnode);
for (int32_t i = 0; i < pLocalReducer->numOfBuffer; ++i) {
taosTFree(pLocalReducer->pLocalDataSrc[i]);
tfree(pLocalReducer->pLocalDataSrc[i]);
}
pLocalReducer->numOfBuffer = 0;
@ -588,7 +588,7 @@ static int32_t createOrderDescriptor(tOrderDescriptor **pOrderDesc, SSqlCmd *pCm
}
*pOrderDesc = tOrderDesCreate(orderColIndexList, numOfGroupByCols, pModel, pQueryInfo->order.order);
taosTFree(orderColIndexList);
tfree(orderColIndexList);
if (*pOrderDesc == NULL) {
return TSDB_CODE_TSC_OUT_OF_MEMORY;
@ -699,7 +699,7 @@ int32_t tscLocalReducerEnvCreate(SSqlObj *pSql, tExtMemBuffer ***pMemBuffer, tOr
if (createOrderDescriptor(pOrderDesc, pCmd, pModel) != TSDB_CODE_SUCCESS) {
pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
taosTFree(pSchema);
tfree(pSchema);
return pRes->code;
}
@ -736,7 +736,7 @@ int32_t tscLocalReducerEnvCreate(SSqlObj *pSql, tExtMemBuffer ***pMemBuffer, tOr
}
*pFinalModel = createColumnModel(pSchema, (int32_t)size, capacity);
taosTFree(pSchema);
tfree(pSchema);
return TSDB_CODE_SUCCESS;
}
@ -756,7 +756,7 @@ void tscLocalReducerEnvDestroy(tExtMemBuffer **pMemBuffer, tOrderDescriptor *pDe
pMemBuffer[i] = destoryExtMemBuffer(pMemBuffer[i]);
}
taosTFree(pMemBuffer);
tfree(pMemBuffer);
}
/**
@ -978,10 +978,10 @@ static void doFillResult(SSqlObj *pSql, SLocalReducer *pLocalReducer, bool doneO
pBeforeFillData->num = 0;
for (int32_t i = 0; i < pQueryInfo->fieldsInfo.numOfOutput; ++i) {
taosTFree(pResPages[i]);
tfree(pResPages[i]);
}
taosTFree(pResPages);
tfree(pResPages);
}
static void savePreviousRow(SLocalReducer *pLocalReducer, tFilePage *tmpBuffer) {

10
src/client/src/tscParseInsert.c
View File

@ -1406,7 +1406,7 @@ static void parseFileSendDataBlock(void *param, TAOS_RES *tres, int code) {
assert(taos_errno(pSql) == code);
taos_free_result(pSql);
taosTFree(pSupporter);
tfree(pSupporter);
fclose(fp);
pParentSql->res.code = code;
@ -1445,7 +1445,7 @@ static void parseFileSendDataBlock(void *param, TAOS_RES *tres, int code) {
char *tokenBuf = calloc(1, 4096);
while ((readLen = taosGetline(&line, &n, fp)) != -1) {
while ((readLen = tgetline(&line, &n, fp)) != -1) {
if (('\r' == line[readLen - 1]) || ('\n' == line[readLen - 1])) {
line[--readLen] = 0;
}
@ -1470,7 +1470,7 @@ static void parseFileSendDataBlock(void *param, TAOS_RES *tres, int code) {
}
}
taosTFree(tokenBuf);
tfree(tokenBuf);
free(line);
if (count > 0) {
@ -1483,7 +1483,7 @@ static void parseFileSendDataBlock(void *param, TAOS_RES *tres, int code) {
} else {
taos_free_result(pSql);
taosTFree(pSupporter);
tfree(pSupporter);
fclose(fp);
pParentSql->fp = pParentSql->fetchFp;
@ -1513,7 +1513,7 @@ void tscProcessMultiVnodesImportFromFile(SSqlObj *pSql) {
pSql->res.code = TAOS_SYSTEM_ERROR(errno);
tscError("%p failed to open file %s to load data from file, code:%s", pSql, pCmd->payload, tstrerror(pSql->res.code));
taosTFree(pSupporter)
tfree(pSupporter)
tscQueueAsyncRes(pSql);
return;

4
src/client/src/tscSQLParser.c
View File

@ -3957,7 +3957,7 @@ static int32_t setTableCondForSTableQuery(SSqlCmd* pCmd, SQueryInfo* pQueryInfo,
int32_t ret = setObjFullName(idBuf, account, &dbToken, &t, &xlen);
if (ret != TSDB_CODE_SUCCESS) {
taosStringBuilderDestroy(&sb1);
taosTFree(segments);
tfree(segments);
invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg);
return ret;
@ -3970,7 +3970,7 @@ static int32_t setTableCondForSTableQuery(SSqlCmd* pCmd, SQueryInfo* pQueryInfo,
pQueryInfo->tagCond.tbnameCond.cond = strdup(str);
taosStringBuilderDestroy(&sb1);
taosTFree(segments);
tfree(segments);
return TSDB_CODE_SUCCESS;
}

8
src/client/src/tscServer.c
View File

@ -124,7 +124,7 @@ static void tscUpdateVgroupInfo(SSqlObj *pObj, SRpcEpSet *pEpSet) {
pVgroupInfo->inUse = pEpSet->inUse;
pVgroupInfo->numOfEps = pEpSet->numOfEps;
for (int32_t i = 0; i < pVgroupInfo->numOfEps; i++) {
taosTFree(pVgroupInfo->epAddr[i].fqdn);
tfree(pVgroupInfo->epAddr[i].fqdn);
pVgroupInfo->epAddr[i].fqdn = strndup(pEpSet->fqdn[i], tListLen(pEpSet->fqdn[i]));
pVgroupInfo->epAddr[i].port = pEpSet->port[i];
}
@ -1549,7 +1549,7 @@ int tscBuildMultiMeterMetaMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
memcpy(pInfoMsg->tableIds, tmpData, pCmd->payloadLen);
}
taosTFree(tmpData);
tfree(tmpData);
pCmd->payloadLen += sizeof(SMgmtHead) + sizeof(SMultiTableInfoMsg);
pCmd->msgType = TSDB_MSG_TYPE_CM_TABLES_META;
@ -1956,7 +1956,7 @@ int tscProcessShowRsp(SSqlObj *pSql) {
pCmd->numOfCols = pQueryInfo->fieldsInfo.numOfOutput;
tscFieldInfoUpdateOffset(pQueryInfo);
taosTFree(pTableMeta);
tfree(pTableMeta);
return 0;
}
@ -1981,7 +1981,7 @@ static void createHBObj(STscObj* pObj) {
pSql->cmd.command = pQueryInfo->command;
if (TSDB_CODE_SUCCESS != tscAllocPayload(&(pSql->cmd), TSDB_DEFAULT_PAYLOAD_SIZE)) {
taosTFree(pSql);
tfree(pSql);
return;
}

6
src/client/src/tscSql.c
View File

@ -566,7 +566,7 @@ int taos_fetch_block(TAOS_RES *res, TAOS_ROW *rows) {
pRes->rspType = 0;
pSql->subState.numOfSub = 0;
taosTFree(pSql->pSubs);
tfree(pSql->pSubs);
assert(pSql->fp == NULL);
@ -894,7 +894,7 @@ int taos_validate_sql(TAOS *taos, const char *sql) {
if (sqlLen > tsMaxSQLStringLen) {
tscError("%p sql too long", pSql);
pRes->code = TSDB_CODE_TSC_INVALID_SQL;
taosTFree(pSql);
tfree(pSql);
return pRes->code;
}
@ -903,7 +903,7 @@ int taos_validate_sql(TAOS *taos, const char *sql) {
pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
tscError("%p failed to malloc sql string buffer", pSql);
tscDebug("%p Valid SQL result:%d, %s pObj:%p", pSql, pRes->code, taos_errstr(pSql), pObj);
taosTFree(pSql);
tfree(pSql);
return pRes->code;
}

4
src/client/src/tscStream.c
View File

@ -273,7 +273,7 @@ static void tscProcessStreamRetrieveResult(void *param, TAOS_RES *res, int numOf
taosCacheRelease(tscMetaCache, (void**)&(pTableMetaInfo->pTableMeta), false);
tscFreeSqlResult(pSql);
taosTFree(pSql->pSubs);
tfree(pSql->pSubs);
pSql->subState.numOfSub = 0;
pTableMetaInfo->vgroupList = tscVgroupInfoClear(pTableMetaInfo->vgroupList);
tscSetNextLaunchTimer(pStream, pSql);
@ -617,6 +617,6 @@ void taos_close_stream(TAOS_STREAM *handle) {
pStream->pSql = NULL;
taos_free_result(pSql);
taosTFree(pStream);
tfree(pStream);
}
}

28
src/client/src/tscSubquery.c
View File

@ -255,7 +255,7 @@ static void tscDestroyJoinSupporter(SJoinSupporter* pSupporter) {
pSupporter->pVgroupTables = NULL;
}
taosTFree(pSupporter->pIdTagList);
tfree(pSupporter->pIdTagList);
tscTagCondRelease(&pSupporter->tagCond);
free(pSupporter);
}
@ -308,7 +308,7 @@ static void filterVgroupTables(SQueryInfo* pQueryInfo, SArray* pVgroupTables) {
assert(taosArrayGetSize(pVgroupTables) > 0);
TSDB_QUERY_SET_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_MULTITABLE_QUERY);
taosTFree(list);
tfree(list);
}
static SArray* buildVgroupTableByResult(SQueryInfo* pQueryInfo, SArray* pVgroupTables) {
@ -335,7 +335,7 @@ static SArray* buildVgroupTableByResult(SQueryInfo* pQueryInfo, SArray* pVgroupT
taosArrayPush(pNew, &info);
}
taosTFree(list);
tfree(list);
TSDB_QUERY_SET_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_MULTITABLE_QUERY);
return pNew;
@ -1624,8 +1624,8 @@ static void doCleanupSubqueries(SSqlObj *pSql, int32_t numOfSubs) {
SRetrieveSupport* pSupport = pSub->param;
taosTFree(pSupport->localBuffer);
taosTFree(pSupport);
tfree(pSupport->localBuffer);
tfree(pSupport);
taos_free_result(pSub);
}
@ -1666,7 +1666,7 @@ int32_t tscHandleMasterSTableQuery(SSqlObj *pSql) {
if (ret != 0) {
pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
tscQueueAsyncRes(pSql);
taosTFree(pMemoryBuf);
tfree(pMemoryBuf);
return ret;
}
@ -1675,7 +1675,7 @@ int32_t tscHandleMasterSTableQuery(SSqlObj *pSql) {
tscDebug("%p retrieved query data from %d vnode(s)", pSql, pState->numOfSub);
if (pSql->pSubs == NULL) {
taosTFree(pSql->pSubs);
tfree(pSql->pSubs);
pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
tscLocalReducerEnvDestroy(pMemoryBuf, pDesc, pModel, pState->numOfSub);
@ -1700,7 +1700,7 @@ int32_t tscHandleMasterSTableQuery(SSqlObj *pSql) {
trs->localBuffer = (tFilePage *)calloc(1, nBufferSize + sizeof(tFilePage));
if (trs->localBuffer == NULL) {
tscError("%p failed to malloc buffer for local buffer, orderOfSub:%d, reason:%s", pSql, i, strerror(errno));
taosTFree(trs);
tfree(trs);
break;
}
@ -1711,8 +1711,8 @@ int32_t tscHandleMasterSTableQuery(SSqlObj *pSql) {
SSqlObj *pNew = tscCreateSTableSubquery(pSql, trs, NULL);
if (pNew == NULL) {
tscError("%p failed to malloc buffer for subObj, orderOfSub:%d, reason:%s", pSql, i, strerror(errno));
taosTFree(trs->localBuffer);
taosTFree(trs);
tfree(trs->localBuffer);
tfree(trs);
break;
}
@ -1766,8 +1766,8 @@ static void tscFreeRetrieveSup(SSqlObj *pSql) {
// SSqlObj *pParentSql = trsupport->pParentSql;
// assert(pSql == pParentSql->pSubs[index]);
taosTFree(trsupport->localBuffer);
taosTFree(trsupport);
tfree(trsupport->localBuffer);
tfree(trsupport);
}
static void tscRetrieveFromDnodeCallBack(void *param, TAOS_RES *tres, int numOfRows);
@ -2167,7 +2167,7 @@ static void multiVnodeInsertFinalize(void* param, TAOS_RES* tres, int numOfRows)
pParentObj->res.code = pSql->res.code;
}
taosTFree(pSupporter);
tfree(pSupporter);
if (atomic_sub_fetch_32(&pParentObj->subState.numOfRemain, 1) > 0) {
return;
@ -2442,7 +2442,7 @@ TAOS_ROW doSetResultRowData(SSqlObj *pSql, bool finalResult) {
assert(pRes->row >= 0 && pRes->row <= pRes->numOfRows);
if (pRes->row >= pRes->numOfRows) { // all the results has returned to invoker
taosTFree(pRes->tsrow);
tfree(pRes->tsrow);
return pRes->tsrow;
}

74
src/client/src/tscUtil.c
View File

@ -245,7 +245,7 @@ void tscClearInterpInfo(SQueryInfo* pQueryInfo) {
}
pQueryInfo->fillType = TSDB_FILL_NONE;
taosTFree(pQueryInfo->fillVal);
tfree(pQueryInfo->fillVal);
}
int32_t tscCreateResPointerInfo(SSqlRes* pRes, SQueryInfo* pQueryInfo) {
@ -259,7 +259,7 @@ int32_t tscCreateResPointerInfo(SSqlRes* pRes, SQueryInfo* pQueryInfo) {
// not enough memory
if (pRes->tsrow == NULL || (pRes->buffer == NULL && pRes->numOfCols > 0)) {
taosTFree(pRes->tsrow);
tfree(pRes->tsrow);
pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
return pRes->code;
}
@ -271,24 +271,24 @@ int32_t tscCreateResPointerInfo(SSqlRes* pRes, SQueryInfo* pQueryInfo) {
static void tscDestroyResPointerInfo(SSqlRes* pRes) {
if (pRes->buffer != NULL) { // free all buffers containing the multibyte string
for (int i = 0; i < pRes->numOfCols; i++) {
taosTFree(pRes->buffer[i]);
tfree(pRes->buffer[i]);
}
pRes->numOfCols = 0;
}
taosTFree(pRes->pRsp);
tfree(pRes->pRsp);
taosTFree(pRes->tsrow);
taosTFree(pRes->length);
taosTFree(pRes->buffer);
tfree(pRes->tsrow);
tfree(pRes->length);
tfree(pRes->buffer);
taosTFree(pRes->pGroupRec);
taosTFree(pRes->pColumnIndex);
tfree(pRes->pGroupRec);
tfree(pRes->pColumnIndex);
if (pRes->pArithSup != NULL) {
taosTFree(pRes->pArithSup->data);
taosTFree(pRes->pArithSup);
tfree(pRes->pArithSup->data);
tfree(pRes->pArithSup);
}
pRes->data = NULL; // pRes->data points to the buffer of pRsp, no need to free
@ -305,11 +305,11 @@ static void tscFreeQueryInfo(SSqlCmd* pCmd, bool removeFromCache) {
freeQueryInfoImpl(pQueryInfo);
clearAllTableMetaInfo(pQueryInfo, (const char*)addr, removeFromCache);
taosTFree(pQueryInfo);
tfree(pQueryInfo);
}
pCmd->numOfClause = 0;
taosTFree(pCmd->pQueryInfo);
tfree(pCmd->pQueryInfo);
}
void tscResetSqlCmdObj(SSqlCmd* pCmd, bool removeFromCache) {
@ -387,14 +387,14 @@ void tscFreeTableMetaHelper(void *pTableMeta) {
assert(numOfEps >= 0 && numOfEps <= TSDB_MAX_REPLICA);
for(int32_t i = 0; i < numOfEps; ++i) {
taosTFree(p->vgroupInfo.epAddr[i].fqdn);
tfree(p->vgroupInfo.epAddr[i].fqdn);
}
int32_t numOfEps1 = p->corVgroupInfo.numOfEps;
assert(numOfEps1 >= 0 && numOfEps1 <= TSDB_MAX_REPLICA);
for(int32_t i = 0; i < numOfEps1; ++i) {
taosTFree(p->corVgroupInfo.epAddr[i].fqdn);
tfree(p->corVgroupInfo.epAddr[i].fqdn);
}
}
@ -418,9 +418,9 @@ void tscFreeSqlObj(SSqlObj* pSql) {
pSql->signature = NULL;
pSql->fp = NULL;
taosTFree(pSql->sqlstr);
tfree(pSql->sqlstr);
taosTFree(pSql->pSubs);
tfree(pSql->pSubs);
pSql->subState.numOfSub = 0;
pSql->self = 0;
@ -428,7 +428,7 @@ void tscFreeSqlObj(SSqlObj* pSql) {
tscResetSqlCmdObj(pCmd, false);
memset(pCmd->payload, 0, (size_t)pCmd->allocSize);
taosTFree(pCmd->payload);
tfree(pCmd->payload);
pCmd->allocSize = 0;
tsem_destroy(&pSql->rspSem);
@ -440,15 +440,15 @@ void tscDestroyDataBlock(STableDataBlocks* pDataBlock) {
return;
}
taosTFree(pDataBlock->pData);
taosTFree(pDataBlock->params);
tfree(pDataBlock->pData);
tfree(pDataBlock->params);
// free the refcount for metermeta
if (pDataBlock->pTableMeta != NULL) {
taosCacheRelease(tscMetaCache, (void**)&(pDataBlock->pTableMeta), false);
}
taosTFree(pDataBlock);
tfree(pDataBlock);
}
SParamInfo* tscAddParamToDataBlock(STableDataBlocks* pDataBlock, char type, uint8_t timePrec, int16_t bytes,
@ -723,7 +723,7 @@ int32_t tscMergeTableDataBlocks(SSqlObj* pSql, SArray* pTableDataBlockList) {
taosHashCleanup(pVnodeDataBlockHashList);
tscDestroyBlockArrayList(pVnodeDataBlockList);
taosTFree(dataBuf->pData);
tfree(dataBuf->pData);
return TSDB_CODE_TSC_OUT_OF_MEMORY;
}
@ -783,7 +783,7 @@ void tscCloseTscObj(void *param) {
pthread_mutex_destroy(&pObj->mutex);
tscDebug("%p DB connection is closed, dnodeConn:%p", pObj, p);
taosTFree(pObj);
tfree(pObj);
}
bool tscIsInsertData(char* sqlstr) {
@ -947,12 +947,12 @@ void tscFieldInfoClear(SFieldInfo* pFieldInfo) {
if (pInfo->pArithExprInfo != NULL) {
tExprTreeDestroy(&pInfo->pArithExprInfo->pExpr, NULL);
taosTFree(pInfo->pArithExprInfo);
tfree(pInfo->pArithExprInfo);
}
}
taosArrayDestroy(pFieldInfo->internalField);
taosTFree(pFieldInfo->final);
tfree(pFieldInfo->final);
memset(pFieldInfo, 0, sizeof(SFieldInfo));
}
@ -1068,7 +1068,7 @@ void* sqlExprDestroy(SSqlExpr* pExpr) {
tVariantDestroy(&pExpr->param[i]);
}
taosTFree(pExpr);
tfree(pExpr);
return NULL;
}
@ -1168,11 +1168,11 @@ SColumn* tscColumnListInsert(SArray* pColumnList, SColumnIndex* pColIndex) {
static void destroyFilterInfo(SColumnFilterInfo* pFilterInfo, int32_t numOfFilters) {
for(int32_t i = 0; i < numOfFilters; ++i) {
if (pFilterInfo[i].filterstr) {
taosTFree(pFilterInfo[i].pz);
tfree(pFilterInfo[i].pz);
}
}
taosTFree(pFilterInfo);
tfree(pFilterInfo);
}
SColumn* tscColumnClone(const SColumn* src) {
@ -1460,7 +1460,7 @@ void tscTagCondRelease(STagCond* pTagCond) {
size_t s = taosArrayGetSize(pTagCond->pCond);
for (int32_t i = 0; i < s; ++i) {
SCond* p = taosArrayGet(pTagCond->pCond, i);
taosTFree(p->cond);
tfree(p->cond);
}
taosArrayDestroy(pTagCond->pCond);
@ -1652,7 +1652,7 @@ static void freeQueryInfoImpl(SQueryInfo* pQueryInfo) {
pQueryInfo->tsBuf = tsBufDestroy(pQueryInfo->tsBuf);
taosTFree(pQueryInfo->fillVal);
tfree(pQueryInfo->fillVal);
}
void tscClearSubqueryInfo(SSqlCmd* pCmd) {
@ -1672,7 +1672,7 @@ void tscFreeVgroupTableInfo(SArray* pVgroupTables) {
SVgroupTableInfo* pInfo = taosArrayGet(pVgroupTables, i);
for(int32_t j = 0; j < pInfo->vgInfo.numOfEps; ++j) {
taosTFree(pInfo->vgInfo.epAddr[j].fqdn);
tfree(pInfo->vgInfo.epAddr[j].fqdn);
}
taosArrayDestroy(pInfo->itemList);
@ -1689,7 +1689,7 @@ void tscRemoveVgroupTableGroup(SArray* pVgroupTable, int32_t index) {
SVgroupTableInfo* pInfo = taosArrayGet(pVgroupTable, index);
for(int32_t j = 0; j < pInfo->vgInfo.numOfEps; ++j) {
taosTFree(pInfo->vgInfo.epAddr[j].fqdn);
tfree(pInfo->vgInfo.epAddr[j].fqdn);
}
taosArrayDestroy(pInfo->itemList);
@ -1737,7 +1737,7 @@ void clearAllTableMetaInfo(SQueryInfo* pQueryInfo, const char* address, bool rem
free(pTableMetaInfo);
}
taosTFree(pQueryInfo->pTableMetaInfo);
tfree(pQueryInfo->pTableMetaInfo);
}
STableMetaInfo* tscAddTableMetaInfo(SQueryInfo* pQueryInfo, const char* name, STableMeta* pTableMeta,
@ -2336,7 +2336,7 @@ void tscTryQueryNextClause(SSqlObj* pSql, __async_cb_func_t fp) {
pRes->numOfTotal = num;
taosTFree(pSql->pSubs);
tfree(pSql->pSubs);
pSql->subState.numOfSub = 0;
pSql->fp = fp;
@ -2461,11 +2461,11 @@ void* tscVgroupInfoClear(SVgroupsInfo *vgroupList) {
SVgroupInfo* pVgroupInfo = &vgroupList->vgroups[i];
for(int32_t j = 0; j < pVgroupInfo->numOfEps; ++j) {
taosTFree(pVgroupInfo->epAddr[j].fqdn);
tfree(pVgroupInfo->epAddr[j].fqdn);
}
}
taosTFree(vgroupList);
tfree(vgroupList);
return NULL;
}
@ -2473,7 +2473,7 @@ void tscSVgroupInfoCopy(SVgroupInfo* dst, const SVgroupInfo* src) {
dst->vgId = src->vgId;
dst->numOfEps = src->numOfEps;
for(int32_t i = 0; i < dst->numOfEps; ++i) {
taosTFree(dst->epAddr[i].fqdn);
tfree(dst->epAddr[i].fqdn);
dst->epAddr[i].port = src->epAddr[i].port;
dst->epAddr[i].fqdn = strdup(src->epAddr[i].fqdn);
}

4
src/common/inc/tdataformat.h
View File

@ -80,7 +80,7 @@ typedef struct {
#define schemaFLen(s) ((s)->flen)
#define schemaVLen(s) ((s)->vlen)
#define schemaColAt(s, i) ((s)->columns + i)
#define tdFreeSchema(s) taosTFree((s))
#define tdFreeSchema(s) tfree((s))
STSchema *tdDupSchema(STSchema *pSchema);
int tdEncodeSchema(void **buf, STSchema *pSchema);
@ -308,7 +308,7 @@ typedef struct {
#define kvRowCpy(dst, r) memcpy((dst), (r), kvRowLen(r))
#define kvRowColVal(r, colIdx) POINTER_SHIFT(kvRowValues(r), (colIdx)->offset)
#define kvRowColIdxAt(r, i) (kvRowColIdx(r) + (i))
#define kvRowFree(r) taosTFree(r)
#define kvRowFree(r) tfree(r)
#define kvRowEnd(r) POINTER_SHIFT(r, kvRowLen(r))
SKVRow tdKVRowDup(SKVRow row);

10
src/common/src/tdataformat.c
View File

@ -97,7 +97,7 @@ int tdInitTSchemaBuilder(STSchemaBuilder *pBuilder, int32_t version) {
void tdDestroyTSchemaBuilder(STSchemaBuilder *pBuilder) {
if (pBuilder) {
taosTFree(pBuilder->columns);
tfree(pBuilder->columns);
}
}
@ -339,8 +339,8 @@ int tdInitDataCols(SDataCols *pCols, STSchema *pSchema) {
void tdFreeDataCols(SDataCols *pCols) {
if (pCols) {
taosTFree(pCols->buf);
taosTFree(pCols->cols);
tfree(pCols->buf);
tfree(pCols->cols);
free(pCols);
}
}
@ -669,8 +669,8 @@ int tdInitKVRowBuilder(SKVRowBuilder *pBuilder) {
}
void tdDestroyKVRowBuilder(SKVRowBuilder *pBuilder) {
taosTFree(pBuilder->pColIdx);
taosTFree(pBuilder->buf);
tfree(pBuilder->pColIdx);
tfree(pBuilder->buf);
}
void tdResetKVRowBuilder(SKVRowBuilder *pBuilder) {

2
src/common/src/tvariant.c
View File

@ -125,7 +125,7 @@ void tVariantDestroy(tVariant *pVar) {
if (pVar == NULL) return;
if (pVar->nType == TSDB_DATA_TYPE_BINARY || pVar->nType == TSDB_DATA_TYPE_NCHAR) {
taosTFree(pVar->pz);
tfree(pVar->pz);
pVar->nLen = 0;
}

2
src/cq/src/cqMain.c
View File

@ -115,7 +115,7 @@ void cqClose(void *handle) {
SCqObj *pTemp = pObj;
pObj = pObj->next;
tdFreeSchema(pTemp->pSchema);
taosTFree(pTemp->sqlStr);
tfree(pTemp->sqlStr);
free(pTemp);
}

2
src/dnode/src/dnodeMPeer.c
View File

@ -84,7 +84,7 @@ void dnodeCleanupMPeer() {
taosCloseQset(tsMPeerQset);
tsMPeerQset = NULL;
taosTFree(tsMPeerWP.worker);
tfree(tsMPeerWP.worker);
}
int32_t dnodeAllocateMPeerQueue() {

2
src/dnode/src/dnodeMWrite.c
View File

@ -86,7 +86,7 @@ void dnodeCleanupMWrite() {
taosCloseQset(tsMWriteQset);
tsMWriteQset = NULL;
taosTFree(tsMWriteWP.worker);
tfree(tsMWriteWP.worker);
}
int32_t dnodeAllocMWritequeue() {

4
src/kit/shell/src/shellDarwin.c
View File

@ -229,8 +229,8 @@ void shellReadCommand(TAOS *con, char *command) {
printf("\n");
if (isReadyGo(&cmd)) {
sprintf(command, "%s%s", cmd.buffer, cmd.command);
taosTFree(cmd.buffer);
taosTFree(cmd.command);
tfree(cmd.buffer);
tfree(cmd.command);
return;
} else {
updateBuffer(&cmd);

8
src/kit/shell/src/shellEngine.c
View File

@ -193,7 +193,7 @@ int32_t shellRunCommand(TAOS* con, char* command) {
history.hist[(history.hend + MAX_HISTORY_SIZE - 1) % MAX_HISTORY_SIZE] == NULL ||
strcmp(command, history.hist[(history.hend + MAX_HISTORY_SIZE - 1) % MAX_HISTORY_SIZE]) != 0) {
if (history.hist[history.hend] != NULL) {
taosTFree(history.hist[history.hend]);
tfree(history.hist[history.hend]);
}
history.hist[history.hend] = strdup(command);
@ -770,7 +770,7 @@ void read_history() {
return;
}
while ((read_size = taosGetline(&line, &line_size, f)) != -1) {
while ((read_size = tgetline(&line, &line_size, f)) != -1) {
line[read_size - 1] = '\0';
history.hist[history.hend] = strdup(line);
@ -800,7 +800,7 @@ void write_history() {
for (int i = history.hstart; i != history.hend;) {
if (history.hist[i] != NULL) {
fprintf(f, "%s\n", history.hist[i]);
taosTFree(history.hist[i]);
tfree(history.hist[i]);
}
i = (i + 1) % MAX_HISTORY_SIZE;
}
@ -854,7 +854,7 @@ void source_file(TAOS *con, char *fptr) {
return;
}
while ((read_len = taosGetline(&line, &line_len, f)) != -1) {
while ((read_len = tgetline(&line, &line_len, f)) != -1) {
if (read_len >= tsMaxSQLStringLen) continue;
line[--read_len] = '\0';

6
src/kit/shell/src/shellLinux.c
View File

@ -232,8 +232,8 @@ void shellReadCommand(TAOS *con, char *command) {
printf("\n");
if (isReadyGo(&cmd)) {
sprintf(command, "%s%s", cmd.buffer, cmd.command);
taosTFree(cmd.buffer);
taosTFree(cmd.command);
tfree(cmd.buffer);
tfree(cmd.command);
return;
} else {
updateBuffer(&cmd);
@ -351,7 +351,7 @@ void *shellLoopQuery(void *arg) {
reset_terminal_mode();
} while (shellRunCommand(con, command) == 0);
taosTFree(command);
tfree(command);
exitShell();
pthread_cleanup_pop(1);

2
src/kit/taosdemo/taosdemo.c
View File

@ -955,7 +955,7 @@ void querySqlFile(TAOS* taos, char* sqlFile)
double t = getCurrentTime();
while ((read_len = taosGetline(&line, &line_len, fp)) != -1) {
while ((read_len = tgetline(&line, &line_len, fp)) != -1) {
if (read_len >= MAX_SQL_SIZE) continue;
line[--read_len] = '\0';

2
src/mnode/src/mnodeAcct.c
View File

@ -34,7 +34,7 @@ static int32_t mnodeCreateRootAcct();
static int32_t mnodeAcctActionDestroy(SSdbOper *pOper) {
SAcctObj *pAcct = pOper->pObj;
pthread_mutex_destroy(&pAcct->mutex);
taosTFree(pOper->pObj);
tfree(pOper->pObj);
return TSDB_CODE_SUCCESS;
}

2
src/mnode/src/mnodeCluster.c
View File

@ -33,7 +33,7 @@ static int32_t mnodeGetClusterMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *
static int32_t mnodeRetrieveClusters(SShowObj *pShow, char *data, int32_t rows, void *pConn);
static int32_t mnodeClusterActionDestroy(SSdbOper *pOper) {
taosTFree(pOper->pObj);
tfree(pOper->pObj);
return TSDB_CODE_SUCCESS;
}

6
src/mnode/src/mnodeDb.c
View File

@ -52,8 +52,8 @@ static int32_t mnodeProcessDropDbMsg(SMnodeMsg *pMsg);
static void mnodeDestroyDb(SDbObj *pDb) {
pthread_mutex_destroy(&pDb->mutex);
taosTFree(pDb->vgList);
taosTFree(pDb);
tfree(pDb->vgList);
tfree(pDb);
}
static int32_t mnodeDbActionDestroy(SSdbOper *pOper) {
@ -405,7 +405,7 @@ static int32_t mnodeCreateDb(SAcctObj *pAcct, SCreateDbMsg *pCreate, SMnodeMsg *
code = mnodeCheckDbCfg(&pDb->cfg);
if (code != TSDB_CODE_SUCCESS) {
taosTFree(pDb);
tfree(pDb);
return code;
}

4
src/mnode/src/mnodeDnode.c
View File

@ -88,7 +88,7 @@ static char* offlineReason[] = {
};
static int32_t mnodeDnodeActionDestroy(SSdbOper *pOper) {
taosTFree(pOper->pObj);
tfree(pOper->pObj);
return TSDB_CODE_SUCCESS;
}
@ -655,7 +655,7 @@ static int32_t mnodeCreateDnode(char *ep, SMnodeMsg *pMsg) {
int32_t code = sdbInsertRow(&oper);
if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
int dnodeId = pDnode->dnodeId;
taosTFree(pDnode);
tfree(pDnode);
mError("failed to create dnode:%d, reason:%s", dnodeId, tstrerror(code));
} else {
mLInfo("dnode:%d is created", pDnode->dnodeId);

6
src/mnode/src/mnodeMnode.c
View File

@ -59,7 +59,7 @@ static int32_t mnodeRetrieveMnodes(SShowObj *pShow, char *data, int32_t rows, vo
#endif
static int32_t mnodeMnodeActionDestroy(SSdbOper *pOper) {
taosTFree(pOper->pObj);
tfree(pOper->pObj);
return TSDB_CODE_SUCCESS;
}
@ -342,14 +342,14 @@ void mnodeCreateMnode(int32_t dnodeId, char *dnodeEp, bool needConfirm) {
}
if (code != TSDB_CODE_SUCCESS) {
taosTFree(pMnode);
tfree(pMnode);
return;
}
code = sdbInsertRow(&oper);
if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
mError("dnode:%d, failed to create mnode, ep:%s reason:%s", dnodeId, dnodeEp, tstrerror(code));
taosTFree(pMnode);
tfree(pMnode);
}
}

4
src/mnode/src/mnodeProfile.c
View File

@ -131,8 +131,8 @@ SConnObj *mnodeAccquireConn(int32_t connId, char *user, uint32_t ip, uint16_t po
static void mnodeFreeConn(void *data) {
SConnObj *pConn = data;
taosTFree(pConn->pQueries);
taosTFree(pConn->pStreams);
tfree(pConn->pQueries);
tfree(pConn->pStreams);
mDebug("connId:%d, is destroyed", pConn->connId);
}

2
src/mnode/src/mnodeSdb.c
View File

@ -984,7 +984,7 @@ void sdbCleanupWriteWorker() {
}
sdbFreeWritequeue();
taosTFree(tsSdbPool.writeWorker);
tfree(tsSdbPool.writeWorker);
mInfo("sdb write is closed");
}

2
src/mnode/src/mnodeShow.c
View File

@ -415,7 +415,7 @@ static void mnodeFreeShowObj(void *data) {
sdbFreeIter(pShow->pIter);
mDebug("%p, show is destroyed, data:%p index:%d", pShow, data, pShow->index);
taosTFree(pShow);
tfree(pShow);
}
static void mnodeReleaseShowObj(SShowObj *pShow, bool forceRemove) {

14
src/mnode/src/mnodeTable.c
View File

@ -93,10 +93,10 @@ static void mnodeProcessAlterTableRsp(SRpcMsg *rpcMsg);
static int32_t mnodeFindSuperTableColumnIndex(SSTableObj *pStable, char *colName);
static void mnodeDestroyChildTable(SCTableObj *pTable) {
taosTFree(pTable->info.tableId);
taosTFree(pTable->schema);
taosTFree(pTable->sql);
taosTFree(pTable);
tfree(pTable->info.tableId);
tfree(pTable->schema);
tfree(pTable->sql);
tfree(pTable);
}
static int32_t mnodeChildTableActionDestroy(SSdbOper *pOper) {
@ -425,9 +425,9 @@ static void mnodeDestroySuperTable(SSTableObj *pStable) {
taosHashCleanup(pStable->vgHash);
pStable->vgHash = NULL;
}
taosTFree(pStable->info.tableId);
taosTFree(pStable->schema);
taosTFree(pStable);
tfree(pStable->info.tableId);
tfree(pStable->schema);
tfree(pStable);
}
static int32_t mnodeSuperTableActionDestroy(SSdbOper *pOper) {

4
src/mnode/src/mnodeUser.c
View File

@ -43,7 +43,7 @@ static int32_t mnodeProcessDropUserMsg(SMnodeMsg *pMsg);
static int32_t mnodeProcessAuthMsg(SMnodeMsg *pMsg);
static int32_t mnodeUserActionDestroy(SSdbOper *pOper) {
taosTFree(pOper->pObj);
tfree(pOper->pObj);
return TSDB_CODE_SUCCESS;
}
@ -270,7 +270,7 @@ int32_t mnodeCreateUser(SAcctObj *pAcct, char *name, char *pass, void *pMsg) {
code = sdbInsertRow(&oper);
if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
mError("user:%s, failed to create by %s, reason:%s", pUser->user, mnodeGetUserFromMsg(pMsg), tstrerror(code));
taosTFree(pUser);
tfree(pUser);
} else {
mLInfo("user:%s, is created by %s", pUser->user, mnodeGetUserFromMsg(pMsg));
}

2
src/mnode/src/mnodeVgroup.c
View File

@ -69,7 +69,7 @@ static void mnodeDestroyVgroup(SVgObj *pVgroup) {
pVgroup->idPool = NULL;
}
taosTFree(pVgroup);
tfree(pVgroup);
}
static int32_t mnodeVgroupActionDestroy(SSdbOper *pOper) {

1
src/os/inc/os.h
View File

@ -53,7 +53,6 @@ extern "C" {
#endif
#include "osDef.h"
#include "osAlloc.h"
#include "osAtomic.h"
#include "osCommon.h"
#include "osDir.h"

43
src/os/inc/osAlloc.h
View File

@ -1,43 +0,0 @@
/*
* Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
*
* This program is free software: you can use, redistribute, and/or modify
* it under the terms of the GNU Affero General Public License, version 3
* or later ("AGPL"), as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef TDENGINE_OS_ALLOC_H
#define TDENGINE_OS_ALLOC_H
#ifdef __cplusplus
extern "C" {
#endif
#ifndef TAOS_OS_FUNC_ALLOC
#define tmalloc(size) malloc(size)
#define tcalloc(nmemb, size) calloc(nmemb, size)
#define trealloc(p, size) realloc(p, size)
#define tmemalign(alignment, size) malloc(size)
#define tfree(p) free(p)
#define tmemzero(p, size) memset(p, 0, size)
#else
void *tmalloc(int32_t size);
void *tcalloc(int32_t nmemb, int32_t size);
void *trealloc(void *p, int32_t size);
void *tmemalign(int32_t alignment, int32_t size);
void tfree(void *p);
void tmemzero(void *p, int32_t size);
#endif
#ifdef __cplusplus
}
#endif
#endif

56
src/os/inc/osMemory.h
View File

@ -31,6 +31,7 @@ typedef enum {
void taosSetAllocMode(int mode, const char *path, bool autoDump);
void taosDumpMemoryLeak();
// used in tsdb module
void * taosTMalloc(size_t size);
void * taosTCalloc(size_t nmemb, size_t size);
void * taosTRealloc(void *ptr, size_t size);
@ -38,7 +39,14 @@ void taosTZfree(void *ptr);
size_t taosTSizeof(void *ptr);
void taosTMemset(void *ptr, int c);
#define taosTFree(x) \
// used in other module
#define tmalloc(size) malloc(size)
#define tcalloc(num, size) calloc(num, size)
#define trealloc(ptr, size) realloc(ptr, size)
#define tstrdup(str) taosStrdupImp(str)
#define tstrndup(str, size) taosStrndupImp(str, size)
#define tgetline(lineptr, n, stream) taosGetlineImp(lineptr, n, stream)
#define tfree(x) \
do { \
if (x) { \
free((void *)(x)); \
@ -46,37 +54,29 @@ void taosTMemset(void *ptr, int c);
} \
} while (0);
#define taosMalloc(size) malloc(size)
#define taosCalloc(num, size) calloc(num, size)
#define taosRealloc(ptr, size) realloc(ptr, size)
#define taosFree(ptr) free(ptr)
#define taosStrdup(str) taosStrdupImp(str)
#define taosStrndup(str, size) taosStrndupImp(str, size)
#define taosGetline(lineptr, n, stream) taosGetlineImp(lineptr, n, stream)
#ifdef TAOS_MEM_CHECK
#ifdef TAOS_MEM_CHECK_TEST
void * taos_malloc(size_t size, const char *file, uint32_t line);
void * taos_calloc(size_t num, size_t size, const char *file, uint32_t line);
void * taos_realloc(void *ptr, size_t size, const char *file, uint32_t line);
void taos_free(void *ptr, const char *file, uint32_t line);
char * taos_strdup(const char *str, const char *file, uint32_t line);
char * taos_strndup(const char *str, size_t size, const char *file, uint32_t line);
ssize_t taos_getline(char **lineptr, size_t *n, FILE *stream, const char *file, uint32_t line);
#undef taosMalloc
#undef taosCalloc
#undef taosRealloc
#undef taosFree
#undef taosStrdup
#undef taosStrndup
#undef taosGetline
#define taosMalloc(size) taos_malloc(size, __FILE__, __LINE__)
#define taosCalloc(num, size) taos_calloc(num, size, __FILE__, __LINE__)
#define taosRealloc(ptr, size) taos_realloc(ptr, size, __FILE__, __LINE__)
#define taosFree(ptr) taos_free(ptr, __FILE__, __LINE__)
void * taosMallocMem(size_t size, const char *file, uint32_t line);
void * taosCallocMem(size_t num, size_t size, const char *file, uint32_t line);
void * taosReallocMem(void *ptr, size_t size, const char *file, uint32_t line);
void taosFreeMem(void *ptr, const char *file, uint32_t line);
char * taosStrdupMem(const char *str, const char *file, uint32_t line);
char * taosStrndupMem(const char *str, size_t size, const char *file, uint32_t line);
ssize_t taosGetlineMem(char **lineptr, size_t *n, FILE *stream, const char *file, uint32_t line);
#undef tmalloc
#undef tcalloc
#undef trealloc
#define tmalloc(size) taosMallocMem(size, __FILE__, __LINE__)
#define tcalloc(num, size) taosCallocMem(num, size, __FILE__, __LINE__)
#define trealloc(ptr, size) taosReallocMem(ptr, size, __FILE__, __LINE__)
#define tfree(ptr) taosFreeMem(ptr, __FILE__, __LINE__)
// #undef tstrdup
// #undef tstrndup
// #undef tgetline
// #define taosStrdup(str) taos_strdup(str, __FILE__, __LINE__)
// #define taosStrndup(str, size) taos_strndup(str, size, __FILE__, __LINE__)
//#define taosGetline(lineptr, n, stream) taos_getline(lineptr, n, stream, __FILE__, __LINE__)
// #define tgetline(lineptr, n, stream) taos_getline(lineptr, n, stream, __FILE__, __LINE__)
#endif
#endif

79
src/os/src/detail/osAlloc.c
View File

@ -1,79 +0,0 @@
/*
* Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
*
* This program is free software: you can use, redistribute, and/or modify
* it under the terms of the GNU Affero General Public License, version 3
* or later ("AGPL"), as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#define _DEFAULT_SOURCE
#include "os.h"
#include "taoserror.h"
#include "tulog.h"
#include "osAlloc.h"
#define TSDB_HAVE_MEMALIGN
#ifdef TAOS_OS_FUNC_ALLOC
void *tmalloc(int32_t size) {
void *p = malloc(size);
if (p == NULL) {
terrno = TAOS_SYSTEM_ERROR(errno);
uError("failed to malloc memory, size:%d reason:%s", size, strerror(errno));
}
return p;
}
void *tcalloc(int32_t nmemb, int32_t size) {
void *p = calloc(nmemb, size);
if (p == NULL) {
terrno = TAOS_SYSTEM_ERROR(errno);
uError("failed to calloc memory, nmemb:%d size:%d reason:%s", nmemb, size, strerror(errno));
}
return p;
}
void *trealloc(void *p, int32_t size) {
p = realloc(p, size);
if (p == NULL) {
terrno = TAOS_SYSTEM_ERROR(errno);
uError("failed to realloc memory, size:%d reason:%s", size, strerror(errno));
}
return p;
}
void tfree(void *p) { free(p); }
void tmemzero(void *p, int32_t size) { memset(p, 0, size); }
#ifdef TSDB_HAVE_MEMALIGN
void *tmemalign(int32_t alignment, int32_t size) {
void *p;
int err = posix_memalign(&p, alignment, size);
if (err) {
terrno = TAOS_SYSTEM_ERROR(errno);
uError("failed to memalign memory, alignment:%d size:%d reason:%s", alignment, size, strerror(err));
p = NULL;
}
return p;
}
#else
void *tmemalign(int32_t alignment, int32_t size) { return tmalloc(size); }
#endif
#endif

124
src/os/src/detail/osMemory.c
View File

@ -28,7 +28,7 @@ static FILE* fpAllocLog = NULL;
extern int32_t taosGetTimestampSec();
static int32_t startTime = INT32_MAX;
static bool random_alloc_fail(size_t size, const char* file, uint32_t line) {
static bool taosRandomAllocFail(size_t size, const char* file, uint32_t line) {
if (taosGetTimestampSec() < startTime) {
return false;
}
@ -48,33 +48,33 @@ static bool random_alloc_fail(size_t size, const char* file, uint32_t line) {
return true;
}
static void* malloc_random(size_t size, const char* file, uint32_t line) {
return random_alloc_fail(size, file, line) ? NULL : malloc(size);
static void* taosRandmoMalloc(size_t size, const char* file, uint32_t line) {
return taosRandomAllocFail(size, file, line) ? NULL : malloc(size);
}
static void* calloc_random(size_t num, size_t size, const char* file, uint32_t line) {
return random_alloc_fail(num * size, file, line) ? NULL : calloc(num, size);
static void* taosRandomCalloc(size_t num, size_t size, const char* file, uint32_t line) {
return taosRandomAllocFail(num * size, file, line) ? NULL : calloc(num, size);
}
static void* realloc_random(void* ptr, size_t size, const char* file, uint32_t line) {
return random_alloc_fail(size, file, line) ? NULL : realloc(ptr, size);
static void* taosRandomRealloc(void* ptr, size_t size, const char* file, uint32_t line) {
return taosRandomAllocFail(size, file, line) ? NULL : realloc(ptr, size);
}
static char* strdup_random(const char* str, const char* file, uint32_t line) {
static char* taosRandomStrdup(const char* str, const char* file, uint32_t line) {
size_t len = strlen(str);
return random_alloc_fail(len + 1, file, line) ? NULL : taosStrdupImp(str);
return taosRandomAllocFail(len + 1, file, line) ? NULL : taosStrdupImp(str);
}
static char* strndup_random(const char* str, size_t size, const char* file, uint32_t line) {
static char* taosRandomStrndup(const char* str, size_t size, const char* file, uint32_t line) {
size_t len = strlen(str);
if (len > size) {
len = size;
}
return random_alloc_fail(len + 1, file, line) ? NULL : taosStrndupImp(str, len);
return taosRandomAllocFail(len + 1, file, line) ? NULL : taosStrndupImp(str, len);
}
static ssize_t getline_random(char **lineptr, size_t *n, FILE *stream, const char* file, uint32_t line) {
return random_alloc_fail(*n, file, line) ? -1 : taosGetlineImp(lineptr, n, stream);
static ssize_t taosRandomGetline(char **lineptr, size_t *n, FILE *stream, const char* file, uint32_t line) {
return taosRandomAllocFail(*n, file, line) ? -1 : taosGetlineImp(lineptr, n, stream);
}
////////////////////////////////////////////////////////////////////////////////
@ -96,7 +96,7 @@ typedef struct SMemBlock {
static SMemBlock *blocks = NULL;
static uintptr_t lock = 0;
static void add_mem_block(SMemBlock* blk) {
static void taosAddMemBlock(SMemBlock* blk) {
blk->prev = NULL;
while (atomic_val_compare_exchange_ptr(&lock, 0, 1) != 0);
blk->next = blocks;
@ -107,7 +107,7 @@ static void add_mem_block(SMemBlock* blk) {
atomic_store_ptr(&lock, 0);
}
static void remove_mem_block(SMemBlock* blk) {
static void taosRemoveMemBlock(SMemBlock* blk) {
while (atomic_val_compare_exchange_ptr(&lock, 0, 1) != 0);
if (blocks == blk) {
@ -126,7 +126,7 @@ static void remove_mem_block(SMemBlock* blk) {
blk->next = NULL;
}
static void free_detect_leak(void* ptr, const char* file, uint32_t line) {
static void taosFreeDetectLeak(void* ptr, const char* file, uint32_t line) {
if (ptr == NULL) {
return;
}
@ -140,11 +140,11 @@ static void free_detect_leak(void* ptr, const char* file, uint32_t line) {
return;
}
remove_mem_block(blk);
taosRemoveMemBlock(blk);
free(blk);
}
static void* malloc_detect_leak(size_t size, const char* file, uint32_t line) {
static void* taosMallocDetectLeak(size_t size, const char* file, uint32_t line) {
if (size == 0) {
return NULL;
}
@ -166,28 +166,28 @@ static void* malloc_detect_leak(size_t size, const char* file, uint32_t line) {
blk->line = (uint16_t)line;
blk->magic = MEMBLK_MAGIC;
blk->size = size;
add_mem_block(blk);
taosAddMemBlock(blk);
return blk->data;
}
static void* calloc_detect_leak(size_t num, size_t size, const char* file, uint32_t line) {
static void* taosCallocDetectLeak(size_t num, size_t size, const char* file, uint32_t line) {
size *= num;
void* p = malloc_detect_leak(size, file, line);
void* p = taosMallocDetectLeak(size, file, line);
if (p != NULL) {
memset(p, 0, size);
}
return p;
}
static void* realloc_detect_leak(void* ptr, size_t size, const char* file, uint32_t line) {
static void* taosReallocDetectLeak(void* ptr, size_t size, const char* file, uint32_t line) {
if (size == 0) {
free_detect_leak(ptr, file, line);
taosFreeDetectLeak(ptr, file, line);
return NULL;
}
if (ptr == NULL) {
return malloc_detect_leak(size, file, line);
return taosMallocDetectLeak(size, file, line);
}
SMemBlock* blk = (SMemBlock *)((char*)ptr) - sizeof(SMemBlock);
@ -198,11 +198,11 @@ static void* realloc_detect_leak(void* ptr, size_t size, const char* file, uint3
return realloc(ptr, size);
}
remove_mem_block(blk);
taosRemoveMemBlock(blk);
void* p = realloc(blk, size + sizeof(SMemBlock));
if (p == NULL) {
add_mem_block(blk);
taosAddMemBlock(blk);
return NULL;
}
@ -212,13 +212,13 @@ static void* realloc_detect_leak(void* ptr, size_t size, const char* file, uint3
blk = (SMemBlock*)p;
blk->size = size;
add_mem_block(blk);
taosAddMemBlock(blk);
return blk->data;
}
static char* strdup_detect_leak(const char* str, const char* file, uint32_t line) {
static char* taosStrdupDetectLeak(const char* str, const char* file, uint32_t line) {
size_t len = strlen(str);
char *p = malloc_detect_leak(len + 1, file, line);
char *p = taosMallocDetectLeak(len + 1, file, line);
if (p != NULL) {
memcpy(p, str, len);
p[len] = 0;
@ -226,12 +226,12 @@ static char* strdup_detect_leak(const char* str, const char* file, uint32_t line
return p;
}
static char* strndup_detect_leak(const char* str, size_t size, const char* file, uint32_t line) {
static char* taosStrndupDetectLeak(const char* str, size_t size, const char* file, uint32_t line) {
size_t len = strlen(str);
if (len > size) {
len = size;
}
char *p = malloc_detect_leak(len + 1, file, line);
char *p = taosMallocDetectLeak(len + 1, file, line);
if (p != NULL) {
memcpy(p, str, len);
p[len] = 0;
@ -239,13 +239,13 @@ static char* strndup_detect_leak(const char* str, size_t size, const char* file,
return p;
}
static ssize_t getline_detect_leak(char **lineptr, size_t *n, FILE *stream, const char* file, uint32_t line) {
static ssize_t taosGetlineDetectLeak(char **lineptr, size_t *n, FILE *stream, const char* file, uint32_t line) {
char* buf = NULL;
size_t bufSize = 0;
ssize_t size = taosGetlineImp(&buf, &bufSize, stream);
if (size != -1) {
if (*n < size + 1) {
void* p = realloc_detect_leak(*lineptr, size + 1, file, line);
void* p = taosReallocDetectLeak(*lineptr, size + 1, file, line);
if (p == NULL) {
free(buf);
return -1;
@ -260,7 +260,7 @@ static ssize_t getline_detect_leak(char **lineptr, size_t *n, FILE *stream, cons
return size;
}
static void dump_memory_leak() {
static void taosDumpMemoryLeakImp() {
const char* hex = "0123456789ABCDEF";
const char* fmt = ":%d: addr=%p, size=%d, content(first 16 bytes)=";
size_t numOfBlk = 0, totalSize = 0;
@ -299,7 +299,7 @@ static void dump_memory_leak() {
fflush(fpAllocLog);
}
static void dump_memory_leak_on_sig(int sig) {
static void taosDumpMemoryLeakOnSig(int sig) {
fprintf(fpAllocLog, "signal %d received.\n", sig);
// restore default signal handler
@ -307,55 +307,55 @@ static void dump_memory_leak_on_sig(int sig) {
act.sa_handler = SIG_DFL;
sigaction(sig, &act, NULL);
dump_memory_leak();
taosDumpMemoryLeakImp();
}
////////////////////////////////////////////////////////////////////////////////
// interface functions
void* taos_malloc(size_t size, const char* file, uint32_t line) {
void* taosMallocMem(size_t size, const char* file, uint32_t line) {
switch (allocMode) {
case TAOS_ALLOC_MODE_DEFAULT:
return malloc(size);
case TAOS_ALLOC_MODE_RANDOM_FAIL:
return malloc_random(size, file, line);
return taosRandmoMalloc(size, file, line);
case TAOS_ALLOC_MODE_DETECT_LEAK:
return malloc_detect_leak(size, file, line);
return taosMallocDetectLeak(size, file, line);
}
return malloc(size);
}
void* taos_calloc(size_t num, size_t size, const char* file, uint32_t line) {
void* taosCallocMem(size_t num, size_t size, const char* file, uint32_t line) {
switch (allocMode) {
case TAOS_ALLOC_MODE_DEFAULT:
return calloc(num, size);
case TAOS_ALLOC_MODE_RANDOM_FAIL:
return calloc_random(num, size, file, line);
return taosRandomCalloc(num, size, file, line);
case TAOS_ALLOC_MODE_DETECT_LEAK:
return calloc_detect_leak(num, size, file, line);
return taosCallocDetectLeak(num, size, file, line);
}
return calloc(num, size);
}
void* taos_realloc(void* ptr, size_t size, const char* file, uint32_t line) {
void* taosReallocMem(void* ptr, size_t size, const char* file, uint32_t line) {
switch (allocMode) {
case TAOS_ALLOC_MODE_DEFAULT:
return realloc(ptr, size);
case TAOS_ALLOC_MODE_RANDOM_FAIL:
return realloc_random(ptr, size, file, line);
return taosRandomRealloc(ptr, size, file, line);
case TAOS_ALLOC_MODE_DETECT_LEAK:
return realloc_detect_leak(ptr, size, file, line);
return taosReallocDetectLeak(ptr, size, file, line);
}
return realloc(ptr, size);
}
void taos_free(void* ptr, const char* file, uint32_t line) {
void taosFreeMem(void* ptr, const char* file, uint32_t line) {
switch (allocMode) {
case TAOS_ALLOC_MODE_DEFAULT:
return free(ptr);
@ -364,54 +364,54 @@ void taos_free(void* ptr, const char* file, uint32_t line) {
return free(ptr);
case TAOS_ALLOC_MODE_DETECT_LEAK:
return free_detect_leak(ptr, file, line);
return taosFreeDetectLeak(ptr, file, line);
}
return free(ptr);
}
char* taos_strdup(const char* str, const char* file, uint32_t line) {
char* taosStrdupMem(const char* str, const char* file, uint32_t line) {
switch (allocMode) {
case TAOS_ALLOC_MODE_DEFAULT:
return taosStrdupImp(str);
case TAOS_ALLOC_MODE_RANDOM_FAIL:
return strdup_random(str, file, line);
return taosRandomStrdup(str, file, line);
case TAOS_ALLOC_MODE_DETECT_LEAK:
return strdup_detect_leak(str, file, line);
return taosStrdupDetectLeak(str, file, line);
}
return taosStrdupImp(str);
}
char* taos_strndup(const char* str, size_t size, const char* file, uint32_t line) {
char* taosStrndupMem(const char* str, size_t size, const char* file, uint32_t line) {
switch (allocMode) {
case TAOS_ALLOC_MODE_DEFAULT:
return taosStrndupImp(str, size);
case TAOS_ALLOC_MODE_RANDOM_FAIL:
return strndup_random(str, size, file, line);
return taosRandomStrndup(str, size, file, line);
case TAOS_ALLOC_MODE_DETECT_LEAK:
return strndup_detect_leak(str, size, file, line);
return taosStrndupDetectLeak(str, size, file, line);
}
return taosStrndupImp(str, size);
}
ssize_t taos_getline(char **lineptr, size_t *n, FILE *stream, const char* file, uint32_t line) {
ssize_t taosGetlineMem(char **lineptr, size_t *n, FILE *stream, const char* file, uint32_t line) {
switch (allocMode) {
case TAOS_ALLOC_MODE_DEFAULT:
return taosGetlineImp(lineptr, n, stream);
case TAOS_ALLOC_MODE_RANDOM_FAIL:
return getline_random(lineptr, n, stream, file, line);
return taosRandomGetline(lineptr, n, stream, file, line);
case TAOS_ALLOC_MODE_DETECT_LEAK:
return getline_detect_leak(lineptr, n, stream, file, line);
return taosGetlineDetectLeak(lineptr, n, stream, file, line);
}
return taosGetlineImp(lineptr, n, stream);
}
static void close_alloc_log() {
static void taosCloseAllocLog() {
if (fpAllocLog != NULL) {
if (fpAllocLog != stdout) {
fclose(fpAllocLog);
@ -432,7 +432,7 @@ void taosSetAllocMode(int mode, const char* path, bool autoDump) {
if (path == NULL || path[0] == 0) {
fpAllocLog = stdout;
} else if ((fpAllocLog = fopen(path, "w")) != NULL) {
atexit(close_alloc_log);
atexit(taosCloseAllocLog);
} else {
printf("failed to open memory allocation log file '%s', errno=%d\n", path, errno);
return;
@ -446,10 +446,10 @@ void taosSetAllocMode(int mode, const char* path, bool autoDump) {
}
if (autoDump && mode == TAOS_ALLOC_MODE_DETECT_LEAK) {
atexit(dump_memory_leak);
atexit(taosDumpMemoryLeakImp);
struct sigaction act = {0};
act.sa_handler = dump_memory_leak_on_sig;
act.sa_handler = taosDumpMemoryLeakOnSig;
sigaction(SIGFPE, &act, NULL);
sigaction(SIGSEGV, &act, NULL);
sigaction(SIGILL, &act, NULL);
@ -457,8 +457,8 @@ void taosSetAllocMode(int mode, const char* path, bool autoDump) {
}
void taosDumpMemoryLeak() {
dump_memory_leak();
close_alloc_log();
taosDumpMemoryLeakImp();
taosCloseAllocLog();
}
#else // 'TAOS_MEM_CHECK' not defined

14
src/os/src/detail/osSysinfo.c
View File

@ -61,7 +61,7 @@ bool taosGetProcMemory(float *memoryUsedMB) {
size_t len;
char * line = NULL;
while (!feof(fp)) {
taosTFree(line);
tfree(line);
len = 0;
getline(&line, &len, fp);
if (line == NULL) {
@ -83,7 +83,7 @@ bool taosGetProcMemory(float *memoryUsedMB) {
sscanf(line, "%s %" PRId64, tmp, &memKB);
*memoryUsedMB = (float)((double)memKB / 1024);
taosTFree(line);
tfree(line);
fclose(fp);
return true;
}
@ -107,7 +107,7 @@ static bool taosGetSysCpuInfo(SysCpuInfo *cpuInfo) {
char cpu[10] = {0};
sscanf(line, "%s %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64, cpu, &cpuInfo->user, &cpuInfo->nice, &cpuInfo->system, &cpuInfo->idle);
taosTFree(line);
tfree(line);
fclose(fp);
return true;
}
@ -136,7 +136,7 @@ static bool taosGetProcCpuInfo(ProcCpuInfo *cpuInfo) {
}
}
taosTFree(line);
tfree(line);
fclose(fp);
return true;
}
@ -377,7 +377,7 @@ static bool taosGetCardInfo(int64_t *bytes) {
*bytes += (rbytes + tbytes);
}
taosTFree(line);
tfree(line);
fclose(fp);
return true;
@ -432,7 +432,7 @@ static bool taosReadProcIO(int64_t *readbyte, int64_t *writebyte) {
int readIndex = 0;
while (!feof(fp)) {
taosTFree(line);
tfree(line);
len = 0;
getline(&line, &len, fp);
if (line == NULL) {
@ -450,7 +450,7 @@ static bool taosReadProcIO(int64_t *readbyte, int64_t *writebyte) {
if (readIndex >= 2) break;
}
taosTFree(line);
tfree(line);
fclose(fp);
if (readIndex < 2) {

2
src/plugins/http/src/httpContext.c
View File

@ -63,7 +63,7 @@ static void httpDestroyContext(void *data) {
pContext->parser = NULL;
}
taosTFree(pContext);
tfree(pContext);
}
bool httpInitContexts() {

2
src/plugins/http/src/httpSystem.c
View File

@ -107,7 +107,7 @@ void httpCleanUpSystem() {
httpCleanupResultQueue();
pthread_mutex_destroy(&tsHttpServer.serverMutex);
taosTFree(tsHttpServer.pThreads);
tfree(tsHttpServer.pThreads);
tsHttpServer.pThreads = NULL;
tsHttpServer.status = HTTP_SERVER_CLOSED;

98
src/query/src/qExecutor.c
View File

@ -1019,7 +1019,7 @@ static void blockwiseApplyFunctions(SQueryRuntimeEnv *pRuntimeEnv, SDataStatis *
bool hasTimeWindow = false;
STimeWindow win = getActiveTimeWindow(pWindowResInfo, ts, pQuery);
if (setWindowOutputBufByKey(pRuntimeEnv, pWindowResInfo, pDataBlockInfo, &win, masterScan, &hasTimeWindow) != TSDB_CODE_SUCCESS) {
taosTFree(sasArray);
tfree(sasArray);
return;
}
@ -1081,10 +1081,10 @@ static void blockwiseApplyFunctions(SQueryRuntimeEnv *pRuntimeEnv, SDataStatis *
continue;
}
taosTFree(sasArray[i].data);
tfree(sasArray[i].data);
}
taosTFree(sasArray);
tfree(sasArray);
}
static int32_t setGroupResultOutputBuf(SQueryRuntimeEnv *pRuntimeEnv, char *pData, int16_t type, int16_t bytes, int32_t groupIndex) {
@ -1410,7 +1410,7 @@ static void rowwiseApplyFunctions(SQueryRuntimeEnv *pRuntimeEnv, SDataStatis *pS
continue;
}
taosTFree(sasArray[i].data);
tfree(sasArray[i].data);
}
free(sasArray);
@ -1596,7 +1596,7 @@ static int32_t setCtxTagColumnInfo(SQueryRuntimeEnv *pRuntimeEnv, SQLFunctionCtx
p->tagInfo.numOfTagCols = num;
p->tagInfo.tagsLen = tagLen;
} else {
taosTFree(pTagCtx);
tfree(pTagCtx);
}
}
@ -1706,7 +1706,7 @@ static int32_t setupQueryRuntimeEnv(SQueryRuntimeEnv *pRuntimeEnv, int16_t order
return TSDB_CODE_SUCCESS;
_clean:
taosTFree(pRuntimeEnv->pCtx);
tfree(pRuntimeEnv->pCtx);
return TSDB_CODE_QRY_OUT_OF_MEMORY;
}
@ -1744,10 +1744,10 @@ static void teardownQueryRuntimeEnv(SQueryRuntimeEnv *pRuntimeEnv) {
}
tVariantDestroy(&pCtx->tag);
taosTFree(pCtx->tagInfo.pTagCtxList);
tfree(pCtx->tagInfo.pTagCtxList);
}
taosTFree(pRuntimeEnv->pCtx);
tfree(pRuntimeEnv->pCtx);
}
pRuntimeEnv->pFillInfo = taosDestroyFillInfo(pRuntimeEnv->pFillInfo);
@ -1756,8 +1756,8 @@ static void teardownQueryRuntimeEnv(SQueryRuntimeEnv *pRuntimeEnv) {
doFreeQueryHandle(pQInfo);
pRuntimeEnv->pTSBuf = tsBufDestroy(pRuntimeEnv->pTSBuf);
taosTFree(pRuntimeEnv->keyBuf);
taosTFree(pRuntimeEnv->rowCellInfoOffset);
tfree(pRuntimeEnv->keyBuf);
tfree(pRuntimeEnv->rowCellInfoOffset);
taosHashCleanup(pRuntimeEnv->pResultRowHashTable);
pRuntimeEnv->pResultRowHashTable = NULL;
@ -2985,8 +2985,8 @@ int32_t mergeIntoGroupResultImpl(SQInfo *pQInfo, SArray *pGroup) {
STableQueryInfo **pTableList = malloc(POINTER_BYTES * size);
if (pTableList == NULL || posList == NULL) {
taosTFree(posList);
taosTFree(pTableList);
tfree(posList);
tfree(pTableList);
qError("QInfo:%p failed alloc memory", pQInfo);
longjmp(pRuntimeEnv->env, TSDB_CODE_QRY_OUT_OF_MEMORY);
@ -3010,12 +3010,12 @@ int32_t mergeIntoGroupResultImpl(SQInfo *pQInfo, SArray *pGroup) {
// there is no data in current group
if (numOfTables == 0) {
taosTFree(posList);
taosTFree(pTableList);
tfree(posList);
tfree(pTableList);
return 0;
} else if (numOfTables == 1) { // no need to merge results since only one table in each group
taosTFree(posList);
taosTFree(pTableList);
tfree(posList);
tfree(pTableList);
SGroupResInfo* pGroupResInfo = &pQInfo->groupResInfo;
@ -3045,9 +3045,9 @@ int32_t mergeIntoGroupResultImpl(SQInfo *pQInfo, SArray *pGroup) {
if (IS_QUERY_KILLED(pQInfo)) {
qDebug("QInfo:%p it is already killed, abort", pQInfo);
taosTFree(pTableList);
taosTFree(posList);
taosTFree(pTree);
tfree(pTableList);
tfree(posList);
tfree(pTree);
longjmp(pRuntimeEnv->env, TSDB_CODE_TSC_QUERY_CANCELLED);
}
@ -3118,9 +3118,9 @@ int32_t mergeIntoGroupResultImpl(SQInfo *pQInfo, SArray *pGroup) {
if (flushFromResultBuf(pRuntimeEnv, &pQInfo->groupResInfo) != TSDB_CODE_SUCCESS) {
qError("QInfo:%p failed to flush data into temp file, abort query", pQInfo);
taosTFree(pTree);
taosTFree(pTableList);
taosTFree(posList);
tfree(pTree);
tfree(pTableList);
tfree(posList);
return -1;
}
}
@ -3133,12 +3133,12 @@ int32_t mergeIntoGroupResultImpl(SQInfo *pQInfo, SArray *pGroup) {
qDebug("QInfo:%p result merge completed for group:%d, elapsed time:%" PRId64 " ms", pQInfo, pQInfo->groupIndex, endt - startt);
taosTFree(pTableList);
taosTFree(posList);
taosTFree(pTree);
tfree(pTableList);
tfree(posList);
tfree(pTree);
// taosTFree(pResultInfo);
// taosTFree(buf);
// tfree(pResultInfo);
// tfree(buf);
return pQInfo->groupResInfo.numOfDataPages;
}
@ -5880,13 +5880,13 @@ static int32_t convertQueryMsg(SQueryTableMsg *pQueryMsg, SArray **pTableIdList,
return TSDB_CODE_SUCCESS;
_cleanup:
taosTFree(*pExpr);
tfree(*pExpr);
taosArrayDestroy(*pTableIdList);
*pTableIdList = NULL;
taosTFree(*tbnameCond);
taosTFree(*groupbyCols);
taosTFree(*tagCols);
taosTFree(*tagCond);
tfree(*tbnameCond);
tfree(*groupbyCols);
tfree(*tagCols);
tfree(*tagCond);
return code;
}
@ -5937,7 +5937,7 @@ static int32_t createQFunctionExprFromMsg(SQueryTableMsg *pQueryMsg, SExprInfo *
code = buildAirthmeticExprFromMsg(&pExprs[i], pQueryMsg);
if (code != TSDB_CODE_SUCCESS) {
taosTFree(pExprs);
tfree(pExprs);
return code;
}
@ -5976,7 +5976,7 @@ static int32_t createQFunctionExprFromMsg(SQueryTableMsg *pQueryMsg, SExprInfo *
int32_t param = (int32_t)pExprs[i].base.arg[0].argValue.i64;
if (getResultDataInfo(type, bytes, pExprs[i].base.functionId, param, &pExprs[i].type, &pExprs[i].bytes,
&pExprs[i].interBytes, 0, isSuperTable) != TSDB_CODE_SUCCESS) {
taosTFree(pExprs);
tfree(pExprs);
return TSDB_CODE_QRY_INVALID_MSG;
}
@ -6352,7 +6352,7 @@ _cleanup_query:
free(pGroupbyExpr);
}
taosTFree(pTagCols);
tfree(pTagCols);
for (int32_t i = 0; i < numOfOutput; ++i) {
SExprInfo* pExprInfo = &pExprs[i];
if (pExprInfo->pExpr != NULL) {
@ -6360,7 +6360,7 @@ _cleanup_query:
}
}
taosTFree(pExprs);
tfree(pExprs);
_cleanup:
freeQInfo(pQInfo);
@ -6479,19 +6479,19 @@ static void freeQInfo(SQInfo *pQInfo) {
if (pQuery != NULL) {
if (pQuery->sdata != NULL) {
for (int32_t col = 0; col < pQuery->numOfOutput; ++col) {
taosTFree(pQuery->sdata[col]);
tfree(pQuery->sdata[col]);
}
taosTFree(pQuery->sdata);
tfree(pQuery->sdata);
}
if (pQuery->fillVal != NULL) {
taosTFree(pQuery->fillVal);
tfree(pQuery->fillVal);
}
for (int32_t i = 0; i < pQuery->numOfFilterCols; ++i) {
SSingleColumnFilterInfo *pColFilter = &pQuery->pFilterInfo[i];
if (pColFilter->numOfFilters > 0) {
taosTFree(pColFilter->pFilters);
tfree(pColFilter->pFilters);
}
}
@ -6504,31 +6504,31 @@ static void freeQInfo(SQInfo *pQInfo) {
}
}
taosTFree(pQuery->pSelectExpr);
tfree(pQuery->pSelectExpr);
}
if (pQuery->pGroupbyExpr != NULL) {
taosArrayDestroy(pQuery->pGroupbyExpr->columnInfo);
taosTFree(pQuery->pGroupbyExpr);
tfree(pQuery->pGroupbyExpr);
}
taosTFree(pQuery->tagColList);
taosTFree(pQuery->pFilterInfo);
tfree(pQuery->tagColList);
tfree(pQuery->pFilterInfo);
if (pQuery->colList != NULL) {
for (int32_t i = 0; i < pQuery->numOfCols; i++) {
SColumnInfo *column = pQuery->colList + i;
freeColumnFilterInfo(column->filters, column->numOfFilters);
}
taosTFree(pQuery->colList);
tfree(pQuery->colList);
}
taosTFree(pQuery);
tfree(pQuery);
}
doDestroyTableQueryInfo(&pQInfo->tableqinfoGroupInfo);
taosTFree(pQInfo->pBuf);
tfree(pQInfo->pBuf);
tsdbDestroyTableGroup(&pQInfo->tableGroupInfo);
taosArrayDestroy(pQInfo->arrTableIdInfo);
@ -6536,7 +6536,7 @@ static void freeQInfo(SQInfo *pQInfo) {
qDebug("QInfo:%p QInfo is freed", pQInfo);
taosTFree(pQInfo);
tfree(pQInfo);
}
static size_t getResultSize(SQInfo *pQInfo, int64_t *numOfRows) {
@ -7231,7 +7231,7 @@ void qCleanupQueryMgmt(void* pQMgmt) {
taosCacheCleanup(pqinfoPool);
pthread_mutex_destroy(&pQueryMgmt->lock);
taosTFree(pQueryMgmt);
tfree(pQueryMgmt);
qDebug("vgId:%d queryMgmt cleanup completed", vgId);
}

16
src/query/src/qExtbuffer.c
View File

@ -64,7 +64,7 @@ void* destoryExtMemBuffer(tExtMemBuffer *pMemBuffer) {
// release flush out info link
SExtFileInfo *pFileMeta = &pMemBuffer->fileMeta;
if (pFileMeta->flushoutData.nAllocSize != 0 && pFileMeta->flushoutData.pFlushoutInfo != NULL) {
taosTFree(pFileMeta->flushoutData.pFlushoutInfo);
tfree(pFileMeta->flushoutData.pFlushoutInfo);
}
// release all in-memory buffer pages
@ -72,7 +72,7 @@ void* destoryExtMemBuffer(tExtMemBuffer *pMemBuffer) {
while (pFilePages != NULL) {
tFilePagesItem *pTmp = pFilePages;
pFilePages = pFilePages->pNext;
taosTFree(pTmp);
tfree(pTmp);
}
// close temp file
@ -87,8 +87,8 @@ void* destoryExtMemBuffer(tExtMemBuffer *pMemBuffer) {
destroyColumnModel(pMemBuffer->pColumnModel);
taosTFree(pMemBuffer->path);
taosTFree(pMemBuffer);
tfree(pMemBuffer->path);
tfree(pMemBuffer);
return NULL;
}
@ -275,7 +275,7 @@ int32_t tExtMemBufferFlush(tExtMemBuffer *pMemBuffer) {
tFilePagesItem *ptmp = first;
first = first->pNext;
taosTFree(ptmp); // release all data in memory buffer
tfree(ptmp); // release all data in memory buffer
}
fflush(pMemBuffer->file); // flush to disk
@ -300,7 +300,7 @@ void tExtMemBufferClear(tExtMemBuffer *pMemBuffer) {
while (first != NULL) {
tFilePagesItem *ptmp = first;
first = first->pNext;
taosTFree(ptmp);
tfree(ptmp);
}
pMemBuffer->fileMeta.numOfElemsInFile = 0;
@ -802,7 +802,7 @@ void destroyColumnModel(SColumnModel *pModel) {
return;
}
taosTFree(pModel);
tfree(pModel);
}
static void printBinaryData(char *data, int32_t len) {
@ -1087,5 +1087,5 @@ void tOrderDescDestroy(tOrderDescriptor *pDesc) {
}
destroyColumnModel(pDesc->pColumnModel);
taosTFree(pDesc);
tfree(pDesc);
}

16
src/query/src/qFill.c
View File

@ -96,18 +96,18 @@ void* taosDestroyFillInfo(SFillInfo* pFillInfo) {
return NULL;
}
taosTFree(pFillInfo->prevValues);
taosTFree(pFillInfo->nextValues);
taosTFree(pFillInfo->pTags);
tfree(pFillInfo->prevValues);
tfree(pFillInfo->nextValues);
tfree(pFillInfo->pTags);
for(int32_t i = 0; i < pFillInfo->numOfCols; ++i) {
taosTFree(pFillInfo->pData[i]);
tfree(pFillInfo->pData[i]);
}
taosTFree(pFillInfo->pData);
taosTFree(pFillInfo->pFillCol);
tfree(pFillInfo->pData);
tfree(pFillInfo->pFillCol);
taosTFree(pFillInfo);
tfree(pFillInfo);
return NULL;
}
@ -496,7 +496,7 @@ int32_t generateDataBlockImpl(SFillInfo* pFillInfo, tFilePage** data, int32_t nu
pFillInfo->numOfRows = 0;
/* the raw data block is exhausted, next value does not exists */
taosTFree(*nextValues);
tfree(*nextValues);
}
pFillInfo->numOfTotal += pFillInfo->numOfCurrent;

8
src/query/src/qParserImpl.c
View File

@ -571,7 +571,7 @@ void destroyAllSelectClause(SSubclauseInfo *pClause) {
doDestroyQuerySql(pQuerySql);
}
taosTFree(pClause->pClause);
tfree(pClause->pClause);
}
SCreateTableSQL *tSetCreateSQLElems(tFieldList *pCols, tFieldList *pTags, SStrToken *pStableName,
@ -641,12 +641,12 @@ void SQLInfoDestroy(SSqlInfo *pInfo) {
tFieldListDestroy(pCreateTableInfo->colInfo.pTagColumns);
tVariantListDestroy(pCreateTableInfo->usingInfo.pTagVals);
taosTFree(pInfo->pCreateTableInfo);
tfree(pInfo->pCreateTableInfo);
} else if (pInfo->type == TSDB_SQL_ALTER_TABLE) {
tVariantListDestroy(pInfo->pAlterInfo->varList);
tFieldListDestroy(pInfo->pAlterInfo->pAddColumns);
taosTFree(pInfo->pAlterInfo);
tfree(pInfo->pAlterInfo);
} else {
if (pInfo->pDCLInfo != NULL && pInfo->pDCLInfo->nAlloc > 0) {
free(pInfo->pDCLInfo->a);
@ -656,7 +656,7 @@ void SQLInfoDestroy(SSqlInfo *pInfo) {
tVariantListDestroy(pInfo->pDCLInfo->dbOpt.keep);
}
taosTFree(pInfo->pDCLInfo);
tfree(pInfo->pDCLInfo);
}
}

6
src/query/src/qPercentile.c
View File

@ -361,8 +361,8 @@ void tMemBucketDestroy(tMemBucket *pBucket) {
}
destroyResultBuf(pBucket->pBuffer);
taosTFree(pBucket->pSlots);
taosTFree(pBucket);
tfree(pBucket->pSlots);
tfree(pBucket);
}
void tMemBucketUpdateBoundingBox(MinMaxEntry *r, const char *data, int32_t dataType) {
@ -680,7 +680,7 @@ double getPercentileImpl(tMemBucket *pMemBucket, int32_t count, double fraction)
}
double val = (1 - fraction) * td + fraction * nd;
taosTFree(buffer);
tfree(buffer);
return val;
} else { // incur a second round bucket split

12
src/query/src/qResultbuf.c
View File

@ -267,7 +267,7 @@ static char* evicOneDataPage(SDiskbasedResultBuf* pResultBuf) {
assert(d->pn == pn);
d->pn = NULL;
taosTFree(pn);
tfree(pn);
bufPage = flushPageToDisk(pResultBuf, d);
}
@ -418,7 +418,7 @@ void destroyResultBuf(SDiskbasedResultBuf* pResultBuf) {
}
unlink(pResultBuf->path);
taosTFree(pResultBuf->path);
tfree(pResultBuf->path);
SHashMutableIterator* iter = taosHashCreateIter(pResultBuf->groupSet);
while(taosHashIterNext(iter)) {
@ -426,8 +426,8 @@ void destroyResultBuf(SDiskbasedResultBuf* pResultBuf) {
size_t n = taosArrayGetSize(*p);
for(int32_t i = 0; i < n; ++i) {
SPageInfo* pi = taosArrayGetP(*p, i);
taosTFree(pi->pData);
taosTFree(pi);
tfree(pi->pData);
tfree(pi);
}
taosArrayDestroy(*p);
@ -440,8 +440,8 @@ void destroyResultBuf(SDiskbasedResultBuf* pResultBuf) {
taosHashCleanup(pResultBuf->groupSet);
taosHashCleanup(pResultBuf->all);
taosTFree(pResultBuf->assistBuf);
taosTFree(pResultBuf);
tfree(pResultBuf->assistBuf);
tfree(pResultBuf);
}
SPageInfo* getLastPageInfo(SIDList pList) {

8
src/query/src/qTsbuf.c
View File

@ -142,11 +142,11 @@ void* tsBufDestroy(STSBuf* pTSBuf) {
return NULL;
}
taosTFree(pTSBuf->assistBuf);
taosTFree(pTSBuf->tsData.rawBuf);
tfree(pTSBuf->assistBuf);
tfree(pTSBuf->tsData.rawBuf);
taosTFree(pTSBuf->pData);
taosTFree(pTSBuf->block.payload);
tfree(pTSBuf->pData);
tfree(pTSBuf->block.payload);
fclose(pTSBuf->f);

6
src/query/src/qUtil.c
View File

@ -57,7 +57,7 @@ void cleanupTimeWindowInfo(SWindowResInfo *pWindowResInfo) {
return;
}
taosTFree(pWindowResInfo->pResult);
tfree(pWindowResInfo->pResult);
}
void resetTimeWindowInfo(SQueryRuntimeEnv *pRuntimeEnv, SWindowResInfo *pWindowResInfo) {
@ -358,11 +358,11 @@ void* destroyResultRowPool(SResultRowPool* p) {
size_t size = taosArrayGetSize(p->pData);
for(int32_t i = 0; i < size; ++i) {
void** ptr = taosArrayGet(p->pData, i);
taosTFree(*ptr);
tfree(*ptr);
}
taosArrayDestroy(p->pData);
taosTFree(p);
tfree(p);
return NULL;
}

6
src/rpc/src/rpcCache.c
View File

@ -101,9 +101,9 @@ void rpcCloseConnCache(void *handle) {
if (pCache->connHashMemPool) taosMemPoolCleanUp(pCache->connHashMemPool);
taosTFree(pCache->connHashList);
taosTFree(pCache->count);
taosTFree(pCache->lockedBy);
tfree(pCache->connHashList);
tfree(pCache->count);
tfree(pCache->lockedBy);
pthread_mutex_unlock(&pCache->mutex);

4
src/rpc/src/rpcMain.c
View File

@ -1620,10 +1620,10 @@ static void rpcDecRef(SRpcInfo *pRpc)
taosTmrCleanUp(pRpc->tmrCtrl);
taosIdPoolCleanUp(pRpc->idPool);
taosTFree(pRpc->connList);
tfree(pRpc->connList);
pthread_mutex_destroy(&pRpc->mutex);
tDebug("%s rpc resources are released", pRpc->label);
taosTFree(pRpc);
tfree(pRpc);
atomic_sub_fetch_32(&tsRpcNum, 1);
}

10
src/rpc/src/rpcTcp.c
View File

@ -236,8 +236,8 @@ void taosCleanUpTcpServer(void *handle) {
tDebug("%s TCP server is cleaned up", pServerObj->label);
taosTFree(pServerObj->pThreadObj);
taosTFree(pServerObj);
tfree(pServerObj->pThreadObj);
tfree(pServerObj);
}
static void *taosAcceptTcpConnection(void *arg) {
@ -535,7 +535,7 @@ static void *taosProcessTcpData(void *param) {
pthread_mutex_destroy(&(pThreadObj->mutex));
tDebug("%s TCP thread exits ...", pThreadObj->label);
taosTFree(pThreadObj);
tfree(pThreadObj);
return NULL;
}
@ -556,7 +556,7 @@ static SFdObj *taosMallocFdObj(SThreadObj *pThreadObj, SOCKET fd) {
event.events = EPOLLIN | EPOLLRDHUP;
event.data.ptr = pFdObj;
if (epoll_ctl(pThreadObj->pollFd, EPOLL_CTL_ADD, fd, &event) < 0) {
taosTFree(pFdObj);
tfree(pFdObj);
terrno = TAOS_SYSTEM_ERROR(errno);
return NULL;
}
@ -609,5 +609,5 @@ static void taosFreeFdObj(SFdObj *pFdObj) {
tDebug("%s %p TCP connection is closed, FD:%p numOfFds:%d",
pThreadObj->label, pFdObj->thandle, pFdObj, pThreadObj->numOfFds);
taosTFree(pFdObj);
tfree(pFdObj);
}

4
src/rpc/src/rpcUdp.c
View File

@ -147,7 +147,7 @@ void taosStopUdpConnection(void *handle) {
if (taosCheckPthreadValid(pConn->thread)) {
pthread_join(pConn->thread, NULL);
}
taosTFree(pConn->buffer);
tfree(pConn->buffer);
// tTrace("%s UDP thread is closed, index:%d", pConn->label, i);
}
@ -166,7 +166,7 @@ void taosCleanUpUdpConnection(void *handle) {
}
tDebug("%s UDP is cleaned up", pSet->label);
taosTFree(pSet);
tfree(pSet);
}
void *taosOpenUdpConnection(void *shandle, void *thandle, uint32_t ip, uint16_t port) {

10
src/sync/inc/taosTcpPool.h
View File

@ -24,18 +24,18 @@ typedef void* ttpool_h;
typedef void *tthread_h;
typedef struct {
int numOfThreads;
int32_t numOfThreads;
uint32_t serverIp;
int16_t port;
int bufferSize;
int32_t bufferSize;
void (*processBrokenLink)(void *ahandle);
int (*processIncomingMsg)(void *ahandle, void *buffer);
void (*processIncomingConn)(int fd, uint32_t ip);
int32_t (*processIncomingMsg)(void *ahandle, void *buffer);
void (*processIncomingConn)(int32_t fd, uint32_t ip);
} SPoolInfo;
ttpool_h taosOpenTcpThreadPool(SPoolInfo *pInfo);
void taosCloseTcpThreadPool(ttpool_h);
void *taosAllocateTcpConn(void *, void *ahandle, int connFd);
void * taosAllocateTcpConn(void *, void *ahandle, int32_t connFd);
void taosFreeTcpConn(void *);
#ifdef __cplusplus

10
src/sync/src/syncMain.c
View File

@ -437,9 +437,9 @@ static void syncFreeNode(void *param) {
SSyncNode *pNode = param;
pthread_mutex_destroy(&pNode->mutex);
taosTFree(pNode->pRecv);
taosTFree(pNode->pSyncFwds);
taosTFree(pNode);
tfree(pNode->pRecv);
tfree(pNode->pSyncFwds);
tfree(pNode);
}
void syncAddPeerRef(SSyncPeer *pPeer) { atomic_add_fetch_8(&pPeer->refCount, 1); }
@ -449,8 +449,8 @@ int syncDecPeerRef(SSyncPeer *pPeer) {
taosReleaseRef(tsSyncRefId, pPeer->pSyncNode->rid);
sDebug("%s, resource is freed", pPeer->id);
taosTFree(pPeer->watchFd);
taosTFree(pPeer);
tfree(pPeer->watchFd);
tfree(pPeer);
return 0;
}

4
src/sync/src/syncRestore.c
View File

@ -225,10 +225,10 @@ int syncSaveIntoBuffer(SSyncPeer *pPeer, SWalHead *pHead) {
static void syncCloseRecvBuffer(SSyncNode *pNode) {
if (pNode->pRecv) {
taosTFree(pNode->pRecv->buffer);
tfree(pNode->pRecv->buffer);
}
taosTFree(pNode->pRecv);
tfree(pNode->pRecv);
}
static int syncOpenRecvBuffer(SSyncNode *pNode) {

2
src/sync/src/taosTcpPool.c
View File

@ -108,7 +108,7 @@ void taosCloseTcpThreadPool(void *param) {
sDebug("%p TCP pool is closed", pPool);
taosTFree(pPool->pThread);
tfree(pPool->pThread);
tfree(pPool);
}

4
src/sync/src/tarbitrator.c
View File

@ -131,7 +131,7 @@ static void arbProcessIncommingConnection(int connFd, uint32_t sourceIp) {
snprintf(pNode->id, sizeof(pNode->id), "vgId:%d peer:%s:%d", firstPkt.sourceId, firstPkt.fqdn, firstPkt.port);
if (firstPkt.syncHead.vgId) {
sDebug("%s, vgId in head is not zero, close the connection", pNode->id);
taosTFree(pNode);
tfree(pNode);
taosCloseSocket(connFd);
return;
}
@ -147,7 +147,7 @@ static void arbProcessBrokenLink(void *param) {
SNodeConn *pNode = param;
sDebug("%s, TCP link is broken(%s), close connection", pNode->id, strerror(errno));
taosTFree(pNode);
tfree(pNode);
}
static int arbProcessPeerMsg(void *param, void *buffer) {

2
src/tsdb/src/tsdbBuffer.c
View File

@ -157,4 +157,4 @@ _err:
return NULL;
}
static void tsdbFreeBufBlock(STsdbBufBlock *pBufBlock) { taosTFree(pBufBlock); }
static void tsdbFreeBufBlock(STsdbBufBlock *pBufBlock) { tfree(pBufBlock); }

6
src/tsdb/src/tsdbFile.c
View File

@ -65,7 +65,7 @@ _err:
void tsdbFreeFileH(STsdbFileH *pFileH) {
if (pFileH) {
pthread_rwlock_destroy(&pFileH->fhlock);
taosTFree(pFileH->pFGroup);
tfree(pFileH->pFGroup);
free(pFileH);
}
}
@ -199,7 +199,7 @@ int tsdbOpenFileH(STsdbRepo *pRepo) {
regfree(&regex1);
regfree(&regex2);
taosTFree(tDataDir);
tfree(tDataDir);
closedir(dir);
return 0;
@ -209,7 +209,7 @@ _err:
regfree(&regex1);
regfree(&regex2);
taosTFree(tDataDir);
tfree(tDataDir);
if (dir != NULL) closedir(dir);
tsdbCloseFileH(pRepo);
return -1;

22
src/tsdb/src/tsdbMain.c
View File

@ -228,7 +228,7 @@ uint32_t tsdbGetFileInfo(TSDB_REPO_T *repo, char *name, uint32_t *index, uint32_
int prefixLen = (int)strlen(prefix);
if (name[0] == 0) { // get the file from index or after, but not larger than eindex
taosTFree(sdup);
tfree(sdup);
int fid = (*index) / TSDB_FILE_TYPE_MAX;
if (pFileH->nFGroups == 0 || fid > pFileH->pFGroup[pFileH->nFGroups - 1].fileId) {
@ -260,8 +260,8 @@ uint32_t tsdbGetFileInfo(TSDB_REPO_T *repo, char *name, uint32_t *index, uint32_
fname = malloc(prefixLen + strlen(name) + 2);
sprintf(fname, "%s/%s", prefix, name);
if (access(fname, F_OK) != 0) {
taosFree(fname);
taosFree(sdup);
tfree(fname);
tfree(sdup);
return 0;
}
if (*index == TSDB_META_FILE_INDEX) { // get meta file
@ -269,20 +269,20 @@ uint32_t tsdbGetFileInfo(TSDB_REPO_T *repo, char *name, uint32_t *index, uint32_
} else {
tsdbGetFileInfoImpl(fname, &magic, size);
}
taosFree(fname);
taosFree(sdup);
tfree(fname);
tfree(sdup);
return magic;
}
if (stat(fname, &fState) < 0) {
taosTFree(fname);
tfree(fname);
return 0;
}
*size = fState.st_size;
// magic = *size;
taosTFree(fname);
tfree(fname);
return magic;
}
@ -600,7 +600,7 @@ static int32_t tsdbSaveConfig(char *rootDir, STsdbCfg *pCfg) {
return 0;
_err:
taosTFree(fname);
tfree(fname);
if (fd >= 0) close(fd);
return -1;
}
@ -637,13 +637,13 @@ static int tsdbLoadConfig(char *rootDir, STsdbCfg *pCfg) {
tsdbDecodeCfg(buf, pCfg);
taosTFree(fname);
tfree(fname);
close(fd);
return 0;
_err:
taosTFree(fname);
tfree(fname);
if (fd >= 0) close(fd);
return -1;
}
@ -718,7 +718,7 @@ static void tsdbFreeRepo(STsdbRepo *pRepo) {
tsdbFreeMeta(pRepo->tsdbMeta);
// tsdbFreeMemTable(pRepo->mem);
// tsdbFreeMemTable(pRepo->imem);
taosTFree(pRepo->rootDir);
tfree(pRepo->rootDir);
pthread_mutex_destroy(&pRepo->mutex);
free(pRepo);
}

8
src/tsdb/src/tsdbMemTable.c
View File

@ -488,7 +488,7 @@ static void tsdbFreeMemTable(SMemTable* pMemTable) {
tdListFree(pMemTable->extraBuffList);
tdListFree(pMemTable->bufBlockList);
tdListFree(pMemTable->actList);
taosTFree(pMemTable->tData);
tfree(pMemTable->tData);
free(pMemTable);
}
}
@ -746,7 +746,7 @@ static int tsdbCommitToFile(STsdbRepo *pRepo, int fid, SCommitIter *iters, SRWHe
goto _err;
}
taosTFree(dataDir);
tfree(dataDir);
tsdbCloseHelperFile(pHelper, 0, pGroup);
pthread_rwlock_wrlock(&(pFileH->fhlock));
@ -768,7 +768,7 @@ static int tsdbCommitToFile(STsdbRepo *pRepo, int fid, SCommitIter *iters, SRWHe
return 0;
_err:
taosTFree(dataDir);
tfree(dataDir);
tsdbCloseHelperFile(pHelper, 1, NULL);
return -1;
}
@ -843,7 +843,7 @@ static int tsdbAdjustMemMaxTables(SMemTable *pMemTable, int maxTables) {
pMemTable->tData = pTableData;
taosWUnLockLatch(&(pMemTable->latch));
taosTFree(tData);
tfree(tData);
return 0;
}

20
src/tsdb/src/tsdbMeta.c
View File

@ -192,7 +192,7 @@ int tsdbDropTable(TSDB_REPO_T *repo, STableId tableId) {
return 0;
_err:
taosTFree(tbname);
tfree(tbname);
return -1;
}
@ -462,7 +462,7 @@ void tsdbFreeMeta(STsdbMeta *pMeta) {
if (pMeta) {
taosHashCleanup(pMeta->uidMap);
tdListFree(pMeta->superList);
taosTFree(pMeta->tables);
tfree(pMeta->tables);
pthread_rwlock_destroy(&pMeta->rwLock);
free(pMeta);
}
@ -486,11 +486,11 @@ int tsdbOpenMeta(STsdbRepo *pRepo) {
}
tsdbDebug("vgId:%d open TSDB meta succeed", REPO_ID(pRepo));
taosTFree(fname);
tfree(fname);
return 0;
_err:
taosTFree(fname);
tfree(fname);
return -1;
}
@ -761,7 +761,7 @@ static void tsdbFreeTable(STable *pTable) {
if (pTable->name != NULL)
tsdbTrace("table %s tid %d uid %" PRIu64 " is freed", TABLE_CHAR_NAME(pTable), TABLE_TID(pTable),
TABLE_UID(pTable));
taosTFree(TABLE_NAME(pTable));
tfree(TABLE_NAME(pTable));
if (TABLE_TYPE(pTable) != TSDB_CHILD_TABLE) {
for (int i = 0; i < TSDB_MAX_TABLE_SCHEMAS; i++) {
tdFreeSchema(pTable->schema[i]);
@ -775,7 +775,7 @@ static void tsdbFreeTable(STable *pTable) {
kvRowFree(pTable->tagVal);
tSkipListDestroy(pTable->pIndex);
taosTFree(pTable->sql);
tfree(pTable->sql);
free(pTable);
}
}
@ -1066,9 +1066,9 @@ void tsdbClearTableCfg(STableCfg *config) {
if (config->schema) tdFreeSchema(config->schema);
if (config->tagSchema) tdFreeSchema(config->tagSchema);
if (config->tagValues) kvRowFree(config->tagValues);
taosTFree(config->name);
taosTFree(config->sname);
taosTFree(config->sql);
tfree(config->name);
tfree(config->sname);
tfree(config->sql);
free(config);
}
}
@ -1290,7 +1290,7 @@ static int tsdbAdjustMetaTables(STsdbRepo *pRepo, int tid) {
STable **tTables = pMeta->tables;
pMeta->tables = tables;
taosTFree(tTables);
tfree(tTables);
tsdbDebug("vgId:%d tsdb meta maxTables is adjusted as %d", REPO_ID(pRepo), maxTables);
return 0;

22
src/tsdb/src/tsdbRead.c
View File

@ -1544,15 +1544,15 @@ int32_t binarySearchForKey(char* pValue, int num, TSKEY key, int order) {
}
static void cleanBlockOrderSupporter(SBlockOrderSupporter* pSupporter, int32_t numOfTables) {
taosTFree(pSupporter->numOfBlocksPerTable);
taosTFree(pSupporter->blockIndexArray);
tfree(pSupporter->numOfBlocksPerTable);
tfree(pSupporter->blockIndexArray);
for (int32_t i = 0; i < numOfTables; ++i) {
STableBlockInfo* pBlockInfo = pSupporter->pDataBlockInfo[i];
taosTFree(pBlockInfo);
tfree(pBlockInfo);
}
taosTFree(pSupporter->pDataBlockInfo);
tfree(pSupporter->pDataBlockInfo);
}
static int32_t dataBlockOrderCompar(const void* pLeft, const void* pRight, void* param) {
@ -1970,7 +1970,7 @@ static void destroyHelper(void* param) {
tQueryInfo* pInfo = (tQueryInfo*)param;
if (pInfo->optr != TSDB_RELATION_IN) {
taosTFree(pInfo->q);
tfree(pInfo->q);
}
free(param);
@ -2035,7 +2035,7 @@ bool tsdbNextDataBlock(TsdbQueryHandleT* pHandle) {
STsdbQueryHandle* pSecQueryHandle = tsdbQueryTablesImpl(pQueryHandle->pTsdb, &cond, pQueryHandle->qinfo, pQueryHandle->pMemRef);
taosTFree(cond.colList);
tfree(cond.colList);
pSecQueryHandle->pTableCheckInfo = createCheckInfoFromCheckInfo(pQueryHandle->pTableCheckInfo, pSecQueryHandle->window.skey);
if (pSecQueryHandle->pTableCheckInfo == NULL) {
@ -2750,7 +2750,7 @@ void tsdbCleanupQueryHandle(TsdbQueryHandleT queryHandle) {
STableCheckInfo* pTableCheckInfo = taosArrayGet(pQueryHandle->pTableCheckInfo, i);
destroyTableMemIterator(pTableCheckInfo);
taosTFree(pTableCheckInfo->pCompInfo);
tfree(pTableCheckInfo->pCompInfo);
}
taosArrayDestroy(pQueryHandle->pTableCheckInfo);
}
@ -2759,14 +2759,14 @@ void tsdbCleanupQueryHandle(TsdbQueryHandleT queryHandle) {
size_t cols = taosArrayGetSize(pQueryHandle->pColumns);
for (int32_t i = 0; i < cols; ++i) {
SColumnInfoData* pColInfo = taosArrayGet(pQueryHandle->pColumns, i);
taosTFree(pColInfo->pData);
tfree(pColInfo->pData);
}
taosArrayDestroy(pQueryHandle->pColumns);
}
taosArrayDestroy(pQueryHandle->defaultLoadColumn);
taosTFree(pQueryHandle->pDataBlockInfo);
taosTFree(pQueryHandle->statis);
tfree(pQueryHandle->pDataBlockInfo);
tfree(pQueryHandle->statis);
// todo check error
tsdbMayUnTakeMemSnapshot(pQueryHandle);
@ -2780,7 +2780,7 @@ void tsdbCleanupQueryHandle(TsdbQueryHandleT queryHandle) {
tsdbDebug("%p :io-cost summary: statis-info:%"PRId64" us, datablock:%" PRId64" us, check data:%"PRId64" us, %p",
pQueryHandle, pCost->statisInfoLoadTime, pCost->blockLoadTime, pCost->checkForNextTime, pQueryHandle->qinfo);
taosTFree(pQueryHandle);
tfree(pQueryHandle);
}
void tsdbDestroyTableGroup(STableGroupInfo *pGroupList) {

4
src/tsdb/tests/tsdbTests.cpp
View File

@ -80,7 +80,7 @@ static int insertData(SInsertInfo *pInfo) {
pMsg->numOfBlocks = htonl(pMsg->numOfBlocks);
if (tsdbInsertData(pInfo->pRepo, pMsg, NULL) < 0) {
taosTFree(pMsg);
tfree(pMsg);
return -1;
}
}
@ -88,7 +88,7 @@ static int insertData(SInsertInfo *pInfo) {
double etime = getCurTime();
printf("Spent %f seconds to write %d records\n", etime - stime, pInfo->totalRows);
taosTFree(pMsg);
tfree(pMsg);
return 0;
}

4
src/util/src/hash.c
View File

@ -22,7 +22,7 @@
#define DO_FREE_HASH_NODE(_n) \
do { \
taosTFree(_n); \
tfree(_n); \
} while (0)
#define FREE_HASH_NODE(_h, _n) \
@ -522,7 +522,7 @@ void taosHashCleanup(SHashObj *pHashObj) {
size_t memBlock = taosArrayGetSize(pHashObj->pMemBlock);
for (int32_t i = 0; i < memBlock; ++i) {
void *p = taosArrayGetP(pHashObj->pMemBlock, i);
taosTFree(p);
tfree(p);
}
taosArrayDestroy(pHashObj->pMemBlock);

2
src/util/src/talgo.c
View File

@ -153,7 +153,7 @@ static void tqsortImpl(void *src, int32_t start, int32_t end, size_t size, const
void taosqsort(void *src, size_t numOfElem, size_t size, const void* param, __ext_compar_fn_t comparFn) {
char *buf = calloc(1, size); // prepare the swap buffer
tqsortImpl(src, 0, (int32_t)numOfElem - 1, (int32_t)size, param, comparFn, buf);
taosTFree(buf);
tfree(buf);
}
void * taosbsearch(const void *key, const void *base, size_t nmemb, size_t size, __compar_fn_t compar, int flags) {

4
src/util/src/tcache.c
View File

@ -228,7 +228,7 @@ void *taosCachePut(SCacheObj *pCacheObj, const void *key, size_t keyLen, const v
pCacheObj->freeFp(p->data);
}
taosTFree(p);
tfree(p);
} else {
taosAddToTrashcan(pCacheObj, p);
uDebug("cache:%s, key:%p, %p exist in cache, updated old:%p", pCacheObj->name, key, pNode1->data, p->data);
@ -614,7 +614,7 @@ void doCleanupDataCache(SCacheObj *pCacheObj) {
__cache_lock_destroy(pCacheObj);
taosTFree(pCacheObj->name);
tfree(pCacheObj->name);
memset(pCacheObj, 0, sizeof(SCacheObj));
free(pCacheObj);
}

8
src/util/src/tconfig.c
View File

@ -288,7 +288,7 @@ void taosReadGlobalLogCfg() {
option = value = NULL;
olen = vlen = 0;
taosGetline(&line, &len, fp);
tgetline(&line, &len, fp);
line[len - 1] = 0;
paGetToken(line, &option, &olen);
@ -302,7 +302,7 @@ void taosReadGlobalLogCfg() {
taosReadLogOption(option, value);
}
taosTFree(line);
tfree(line);
fclose(fp);
}
@ -334,7 +334,7 @@ bool taosReadGlobalCfg() {
option = value = NULL;
olen = vlen = 0;
taosGetline(&line, &len, fp);
tgetline(&line, &len, fp);
line[len - 1] = 0;
paGetToken(line, &option, &olen);
@ -354,7 +354,7 @@ bool taosReadGlobalCfg() {
fclose(fp);
taosTFree(line);
tfree(line);
if (debugFlag & DEBUG_TRACE || debugFlag & DEBUG_DEBUG || debugFlag & DEBUG_DUMP) {
taosSetAllDebugFlag();

10
src/util/src/tkvstore.c
View File

@ -475,9 +475,9 @@ _err:
static void tdFreeKVStore(SKVStore *pStore) {
if (pStore) {
taosTFree(pStore->fname);
taosTFree(pStore->fsnap);
taosTFree(pStore->fnew);
tfree(pStore->fname);
tfree(pStore->fsnap);
tfree(pStore->fnew);
taosHashCleanup(pStore->map);
free(pStore);
}
@ -616,11 +616,11 @@ static int tdRestoreKVStore(SKVStore *pStore) {
if (pStore->aFunc) (*pStore->aFunc)(pStore->appH);
taosHashDestroyIter(pIter);
taosTFree(buf);
tfree(buf);
return 0;
_err:
taosHashDestroyIter(pIter);
taosTFree(buf);
tfree(buf);
return -1;
}

6
src/util/src/tlog.c
View File

@ -512,8 +512,8 @@ static SLogBuff *taosLogBuffNew(int32_t bufSize) {
return tLogBuff;
_err:
taosTFree(LOG_BUF_BUFFER(tLogBuff));
taosTFree(tLogBuff);
tfree(LOG_BUF_BUFFER(tLogBuff));
tfree(tLogBuff);
return NULL;
}
@ -522,7 +522,7 @@ static void taosLogBuffDestroy(SLogBuff *tLogBuff) {
tsem_destroy(&(tLogBuff->buffNotEmpty));
pthread_mutex_destroy(&(tLogBuff->buffMutex));
free(tLogBuff->buffer);
taosTFree(tLogBuff);
tfree(tLogBuff);
}
#endif

6
src/util/src/tmempool.c
View File

@ -52,9 +52,9 @@ mpool_h taosMemPoolInit(int numOfBlock, int blockSize) {
if (pool_p->pool == NULL || pool_p->freeList == NULL) {
uError("failed to allocate memory\n");
taosTFree(pool_p->freeList);
taosTFree(pool_p->pool);
taosTFree(pool_p);
tfree(pool_p->freeList);
tfree(pool_p->pool);
tfree(pool_p);
return NULL;
}

4
src/util/src/tref.c
View File

@ -484,8 +484,8 @@ static void taosDecRsetCount(SRefSet *pSet) {
pSet->max = 0;
pSet->fp = NULL;
taosTFree(pSet->nodeList);
taosTFree(pSet->lockedBy);
tfree(pSet->nodeList);
tfree(pSet->lockedBy);
tsRefSetNum--;
uTrace("rsetId:%d is cleaned, refSetNum:%d count:%d", pSet->rsetId, tsRefSetNum, pSet->count);

8
src/util/src/tskiplist.c
View File

@ -27,7 +27,7 @@ static SSkipListIterator *doCreateSkipListIterator(SSkipList *pSkipList, int32_t
static void tSkipListDoInsert(SSkipList *pSkipList, SSkipListNode **forward, SSkipListNode *pNode);
static bool tSkipListGetPosToPut(SSkipList *pSkipList, SSkipListNode **forward, void *pData);
static SSkipListNode * tSkipListNewNode(uint8_t level);
#define tSkipListFreeNode(n) taosTFree((n))
#define tSkipListFreeNode(n) tfree((n))
static FORCE_INLINE int tSkipListWLock(SSkipList *pSkipList);
static FORCE_INLINE int tSkipListRLock(SSkipList *pSkipList);
@ -97,12 +97,12 @@ void tSkipListDestroy(SSkipList *pSkipList) {
tSkipListUnlock(pSkipList);
if (pSkipList->lock != NULL) {
pthread_rwlock_destroy(pSkipList->lock);
taosTFree(pSkipList->lock);
tfree(pSkipList->lock);
}
tSkipListFreeNode(pSkipList->pHead);
tSkipListFreeNode(pSkipList->pTail);
taosTFree(pSkipList);
tfree(pSkipList);
}
SSkipListNode *tSkipListPut(SSkipList *pSkipList, void *pData) {
@ -265,7 +265,7 @@ void *tSkipListDestroyIter(SSkipListIterator *iter) {
return NULL;
}
taosTFree(iter);
tfree(iter);
return NULL;
}

10
src/util/tests/skiplistTest.cpp
View File

@ -59,7 +59,7 @@ void doubleSkipListTest() {
}
if (size > 0) {
taosTFree(pNodes);
tfree(pNodes);
}
}
@ -196,7 +196,7 @@ void stringKeySkiplistTest() {
tSkipListRemoveNode(pSkipList, pres[0]);
if (num > 0) {
taosTFree(pres);
tfree(pres);
}
}
@ -276,7 +276,7 @@ void skiplistPerformanceTest() {
assert(SL_GET_SIZE(pSkipList) == size);
tSkipListDestroy(pSkipList);
taosTFree(total);
tfree(total);
}
// todo not support duplicated key yet
@ -357,7 +357,7 @@ TEST(testCase, skiplist_test) {
printf("-----%lf\n", pNodes[i]->key.dKey);
}
printf("the range query result size is: %d\n", size);
taosTFree(pNodes);
tfree(pNodes);
SSkipListKey *pKeys = malloc(sizeof(SSkipListKey) * 20);
for (int32_t i = 0; i < 8; i += 2) {
@ -371,7 +371,7 @@ TEST(testCase, skiplist_test) {
for (int32_t i = 0; i < r; ++i) {
// printf("%lf ", pNodes[i]->key.dKey);
}
taosTFree(pNodes);
tfree(pNodes);
free(pKeys);*/
}

2
src/vnode/src/vnodeMain.c
View File

@ -416,7 +416,7 @@ void vnodeRelease(void *pVnodeRaw) {
pVnode->rqueue = NULL;
}
taosTFree(pVnode->rootDir);
tfree(pVnode->rootDir);
if (pVnode->dropped) {
char rootDir[TSDB_FILENAME_LEN] = {0};

3
src/wal/src/walMgmt.c
View File

@ -28,14 +28,13 @@ typedef struct {
pthread_mutex_t mutex;
} SWalMgmt;
static SWalMgmt tsWal;
static SWalMgmt tsWal = {0};
static int32_t walCreateThread();
static void walStopThread();
static int32_t walInitObj(SWal *pWal);
static void walFreeObj(void *pWal);
int32_t walInit() {
tmemzero(&tsWal, sizeof(SWalMgmt));
tsWal.refId = taosOpenRef(TSDB_MIN_VNODES, walFreeObj);
int32_t code = walCreateThread();

6
tests/tsim/src/simSystem.c
View File

@ -103,9 +103,9 @@ void simFreeScript(SScript *script) {
simDebug("script:%s, is freed", script->fileName);
taos_close(script->taos);
taosTFree(script->lines);
taosTFree(script->optionBuffer);
taosTFree(script);
tfree(script->lines);
tfree(script->optionBuffer);
tfree(script);
}
SScript *simProcessCallOver(SScript *script) {