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

Merge pull request #28126 from taosdata/fix/checkReturnCode 

check return code
This commit is contained in:
Hongze Cheng 2024-09-27 09:08:50 +08:00 committed by GitHub
parent f617d216f0 94b3a07eff
commit 0ebbd730ed
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
13 changed files with 152 additions and 116 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
source/libs/index/src/index.c
View File

@ -315,6 +315,10 @@ SIndexMultiTermQuery* indexMultiTermQueryCreate(EIndexOperatorType opera) {
}
mtq->opera = opera;
mtq->query = taosArrayInit(4, sizeof(SIndexTermQuery));
if (mtq->query == NULL) {
taosMemoryFree(mtq);
return NULL;
}
return mtq;
}
void indexMultiTermQueryDestroy(SIndexMultiTermQuery* pQuery) {
@ -359,10 +363,22 @@ SIndexTerm* indexTermCreate(int64_t suid, SIndexOperOnColumn oper, uint8_t colTy
len = idxConvertDataToStr((void*)colVal, IDX_TYPE_GET_TYPE(colType), (void**)&buf);
} else if (colVal == NULL) {
buf = strndup(INDEX_DATA_NULL_STR, (int32_t)strlen(INDEX_DATA_NULL_STR));
if (buf == NULL) {
taosMemoryFree(tm->colName);
taosMemoryFree(tm);
terrno = TSDB_CODE_OUT_OF_MEMORY;
return NULL;
}
len = (int32_t)strlen(INDEX_DATA_NULL_STR);
} else {
static const char* emptyStr = " ";
buf = strndup(emptyStr, (int32_t)strlen(emptyStr));
if (buf == NULL) {
taosMemoryFree(tm->colName);
taosMemoryFree(tm);
terrno = TSDB_CODE_OUT_OF_MEMORY;
return NULL;
}
len = (int32_t)strlen(emptyStr);
}

8
source/libs/index/src/indexCache.c
View File

@ -384,7 +384,7 @@ static IterateValue* idxCacheIteratorGetValue(Iterate* iter);
IndexCache* idxCacheCreate(SIndex* idx, uint64_t suid, const char* colName, int8_t type) {
IndexCache* cache = taosMemoryCalloc(1, sizeof(IndexCache));
if (cache == NULL) {
indexError("failed to create index cache");
indexError("failed to create index cache since %s", tstrerror(TSDB_CODE_OUT_OF_MEMORY));
return NULL;
};
@ -392,6 +392,11 @@ IndexCache* idxCacheCreate(SIndex* idx, uint64_t suid, const char* colName, int8
cache->mem->pCache = cache;
cache->colName =
IDX_TYPE_CONTAIN_EXTERN_TYPE(type, TSDB_DATA_TYPE_JSON) ? taosStrdup(JSON_COLUMN) : taosStrdup(colName);
if (cache->colName == NULL) {
taosMemoryFree(cache);
indexError("failed to create index cache since %s", tstrerror(TSDB_CODE_OUT_OF_MEMORY));
return NULL;
}
cache->type = type;
cache->index = idx;
cache->version = 0;
@ -831,6 +836,7 @@ static MemTable* idxInternalCacheCreate(int8_t type) {
IDX_TYPE_CONTAIN_EXTERN_TYPE(type, TSDB_DATA_TYPE_JSON) ? idxCacheJsonTermCompare : idxCacheTermCompare;
MemTable* tbl = taosMemoryCalloc(1, sizeof(MemTable));
if (tbl == NULL) return NULL;
idxMemRef(tbl);
// if (ttype == TSDB_DATA_TYPE_BINARY || ttype == TSDB_DATA_TYPE_NCHAR || ttype == TSDB_DATA_TYPE_GEOMETRY) {
tbl->mem = tSkipListCreate(MAX_SKIP_LIST_LEVEL, ttype, MAX_INDEX_KEY_LEN, cmpFn, SL_ALLOW_DUP_KEY, idxCacheTermGet);

3
source/libs/index/src/indexComm.c
View File

@ -389,6 +389,9 @@ int32_t idxConvertDataToStr(void* src, int8_t type, void** dst) {
break;
case TSDB_DATA_TYPE_USMALLINT:
*dst = taosMemoryCalloc(1, bufSize + 1);
if (*dst == NULL) {
return terrno;
}
TAOS_UNUSED(idxInt2str(*(uint16_t*)src, *dst, -1));
tlen = strlen(*dst);
break;

19
source/libs/index/src/indexFst.c
View File

@ -111,9 +111,6 @@ void fstUnFinishedNodesAddSuffix(FstUnFinishedNodes* nodes, FstSlice bs, Output
if (un->last != NULL) return;
// FstLastTransition *trn = taosMemoryMalloc(sizeof(FstLastTransition));
// trn->inp = s->data[s->start];
// trn->out = out;
int32_t len = 0;
uint8_t* data = fstSliceData(s, &len);
un->last = fstLastTransitionCreate(data[0], out);
@ -126,10 +123,11 @@ void fstUnFinishedNodesAddSuffix(FstUnFinishedNodes* nodes, FstSlice bs, Output
n->isFinal = false;
n->finalOutput = 0;
n->trans = taosArrayInit(16, sizeof(FstTransition));
if (n->trans == NULL) {
taosMemoryFree(n);
return;
}
// FstLastTransition *trn = taosMemoryMalloc(sizeof(FstLastTransition));
// trn->inp = s->data[i];
// trn->out = out;
FstLastTransition* trn = fstLastTransitionCreate(data[i], 0);
FstBuilderNodeUnfinished un = {.node = n, .last = trn};
@ -1159,11 +1157,20 @@ FStmSt* stmStCreate(Fst* fst, FAutoCtx* automation, FstBoundWithData* min, FstBo
sws->fst = fst;
sws->aut = automation;
sws->inp = (SArray*)taosArrayInit(256, sizeof(uint8_t));
if (sws->inp == NULL) {
taosMemoryFree(sws);
return NULL;
}
sws->emptyOutput.null = true;
sws->emptyOutput.out = 0;
sws->stack = (SArray*)taosArrayInit(256, sizeof(FstStreamState));
if (sws->stack == NULL) {
taosArrayDestroy(sws->inp);
taosMemoryFree(sws);
return NULL;
}
sws->endAt = max;
TAOS_UNUSED(stmStSeekMin(sws, min));

13
source/libs/index/src/indexFstAutomation.c
View File

@ -174,7 +174,18 @@ FAutoCtx* automCtxCreate(void* data, AutomationType atype) {
// add more search type
}
ctx->data = (data != NULL ? taosStrdup((char*)data) : NULL);
// ctx->data = (data != NULL ? taosStrdup((char*)data) : NULL);
if (data != NULL) {
ctx->data = taosStrdup((char*)data);
if (ctx->data == NULL) {
startWithStateValueDestroy(sv);
taosMemoryFree(ctx);
return NULL;
}
} else {
ctx->data = NULL;
}
ctx->type = atype;
ctx->stdata = (void*)sv;
return ctx;

2
source/libs/index/src/indexFstRegister.c
View File

@ -120,6 +120,8 @@ FstRegistryEntry* fstRegistryGetEntry(FstRegistry* registry, FstBuilderNode* bNo
uint64_t end = start + registry->mruSize;
FstRegistryEntry* entry = taosMemoryMalloc(sizeof(FstRegistryEntry));
if (entry == NULL) return NULL;
if (end - start == 1) {
FstRegistryCell* cell = taosArrayGet(registry->table, start);
// cell->isNode &&

6
source/libs/index/src/indexFstSparse.c
View File

@ -28,6 +28,12 @@ FstSparseSet *sparSetCreate(int32_t sz) {
ss->dense = (int32_t *)taosMemoryMalloc(sz * sizeof(int32_t));
ss->sparse = (int32_t *)taosMemoryMalloc(sz * sizeof(int32_t));
if (ss->dense == NULL || ss->sparse == NULL) {
taosMemoryFree(ss->dense);
taosMemoryFree(ss->sparse);
taosMemoryFree(ss);
return NULL;
}
sparSetInitBuf(ss->dense, sz);
sparSetInitBuf(ss->sparse, sz);

12
source/libs/index/src/indexFstUtil.c
View File

@ -77,10 +77,13 @@ CompiledAddr unpackDelta(char* data, uint64_t len, uint64_t nodeAddr) {
FstSlice fstSliceCreate(uint8_t* data, uint64_t len) {
FstString* str = (FstString*)taosMemoryMalloc(sizeof(FstString));
if (str == NULL) {
return (FstSlice){.str = NULL, .start = 0, .end = 0};
}
str->ref = 1;
str->len = len;
str->data = taosMemoryMalloc(len * sizeof(uint8_t));
if (str == NULL || str->data == NULL) {
if (str->data == NULL) {
taosMemoryFree(str);
return (FstSlice){.str = NULL, .start = 0, .end = 0};
}
@ -107,9 +110,16 @@ FstSlice fstSliceDeepCopy(FstSlice* s, int32_t start, int32_t end) {
uint8_t* data = fstSliceData(s, &slen);
uint8_t* buf = taosMemoryMalloc(sizeof(uint8_t) * tlen);
if (buf == NULL) {
return (FstSlice){.str = NULL, .start = 0, .end = 0};
}
memcpy(buf, data + start, tlen);
FstString* str = taosMemoryMalloc(sizeof(FstString));
if (str == NULL) {
taosMemoryFree(buf);
return (FstSlice){.str = NULL, .start = 0, .end = 0};
}
str->data = buf;
str->len = tlen;
str->ref = 1;

119
source/libs/stream/src/streamBackendRocksdb.c
View File

@ -1178,106 +1178,6 @@ _exception:
return code;
}
#ifdef BUILD_NO_CALL
static int32_t chkpIdComp(const void* a, const void* b) {
int64_t x = *(int64_t*)a;
int64_t y = *(int64_t*)b;
return x < y ? -1 : 1;
}
int32_t streamBackendLoadCheckpointInfo(void* arg) {
SStreamMeta* pMeta = arg;
int32_t code = 0;
SArray* suffix = NULL;
int32_t len = strlen(pMeta->path) + 30;
char* chkpPath = taosMemoryCalloc(1, len);
sprintf(chkpPath, "%s%s%s", pMeta->path, TD_DIRSEP, "checkpoints");
if (!taosDirExist(chkpPath)) {
// no checkpoint, nothing to load
taosMemoryFree(chkpPath);
return 0;
}
TdDirPtr pDir = taosOpenDir(chkpPath);
if (pDir == NULL) {
taosMemoryFree(chkpPath);
return 0;
}
TdDirEntryPtr de = NULL;
suffix = taosArrayInit(4, sizeof(int64_t));
while ((de = taosReadDir(pDir)) != NULL) {
if (strcmp(taosGetDirEntryName(de), ".") == 0 || strcmp(taosGetDirEntryName(de), "..") == 0) continue;
if (taosDirEntryIsDir(de)) {
char checkpointPrefix[32] = {0};
int64_t checkpointId = 0;
int ret = sscanf(taosGetDirEntryName(de), "checkpoint%" PRId64 "", &checkpointId);
if (ret == 1) {
taosArrayPush(suffix, &checkpointId);
}
} else {
continue;
}
}
taosArraySort(suffix, chkpIdComp);
// free previous chkpSaved
taosArrayClear(pMeta->chkpSaved);
for (int i = 0; i < taosArrayGetSize(suffix); i++) {
int64_t id = *(int64_t*)taosArrayGet(suffix, i);
taosArrayPush(pMeta->chkpSaved, &id);
}
taosArrayDestroy(suffix);
taosCloseDir(&pDir);
taosMemoryFree(chkpPath);
return 0;
}
#endif
#ifdef BUILD_NO_CALL
int32_t chkpGetAllDbCfHandle(SStreamMeta* pMeta, rocksdb_column_family_handle_t*** ppHandle, SArray* refs) {
return 0;
// SArray* pHandle = taosArrayInit(16, POINTER_BYTES);
// void* pIter = taosHashIterate(pMeta->pTaskDbUnique, NULL);
// while (pIter) {
// int64_t id = *(int64_t*)pIter;
// SBackendCfWrapper* wrapper = taosAcquireRef(streamBackendCfWrapperId, id);
// if (wrapper == NULL) {
// pIter = taosHashIterate(pMeta->pTaskDbUnique, pIter);
// continue;
// }
// taosThreadRwlockRdlock(&wrapper->rwLock);
// for (int i = 0; i < sizeof(ginitDict) / sizeof(ginitDict[0]); i++) {
// if (wrapper->pHandle[i]) {
// rocksdb_column_family_handle_t* p = wrapper->pHandle[i];
// taosArrayPush(pHandle, &p);
// }
// }
// taosThreadRwlockUnlock(&wrapper->rwLock);
// taosArrayPush(refs, &id);
// }
// int32_t nCf = taosArrayGetSize(pHandle);
// rocksdb_column_family_handle_t** ppCf = taosMemoryCalloc(nCf, sizeof(rocksdb_column_family_handle_t*));
// for (int i = 0; i < nCf; i++) {
// ppCf[i] = taosArrayGetP(pHandle, i);
// }
// taosArrayDestroy(pHandle);
// *ppHandle = ppCf;
// return nCf;
}
#endif
int chkpIdComp(const void* a, const void* b) {
int64_t x = *(int64_t*)a;
int64_t y = *(int64_t*)b;
@ -1288,6 +1188,9 @@ int chkpIdComp(const void* a, const void* b) {
int32_t taskDbLoadChkpInfo(STaskDbWrapper* pBackend) {
int32_t code = 0;
char* pChkpDir = taosMemoryCalloc(1, 256);
if (pChkpDir == NULL) {
return terrno;
}
sprintf(pChkpDir, "%s%s%s", pBackend->path, TD_DIRSEP, "checkpoints");
if (!taosIsDir(pChkpDir)) {
@ -2376,8 +2279,14 @@ int32_t taskDbOpenCfs(STaskDbWrapper* pTask, char* path, char** pCfNames, int32_
int32_t code = -1;
char* err = NULL;
rocksdb_options_t** cfOpts = taosMemoryCalloc(nCf, sizeof(rocksdb_options_t*));
rocksdb_options_t** cfOpts = taosMemoryCalloc(nCf, sizeof(rocksdb_options_t*));
if (cfOpts == NULL) {
return terrno;
}
rocksdb_column_family_handle_t** cfHandle = taosMemoryCalloc(nCf, sizeof(rocksdb_column_family_handle_t*));
if (cfHandle == NULL) {
return terrno;
}
for (int i = 0; i < nCf; i++) {
int32_t idx = getCfIdx(pCfNames[i]);
@ -2461,6 +2370,14 @@ void taskDbInitOpt(STaskDbWrapper* pTaskDb) {
pTaskDb->pCfParams = taosMemoryCalloc(nCf, sizeof(RocksdbCfParam));
pTaskDb->pCfOpts = taosMemoryCalloc(nCf, sizeof(rocksdb_options_t*));
pTaskDb->pCompares = taosMemoryCalloc(nCf, sizeof(rocksdb_comparator_t*));
if (pTaskDb->pCf == NULL || pTaskDb->pCfParams == NULL || pTaskDb->pCfOpts == NULL || pTaskDb->pCompares == NULL) {
stError("failed to alloc memory for cf");
taosMemoryFreeClear(pTaskDb->pCf);
taosMemoryFreeClear(pTaskDb->pCfParams);
taosMemoryFreeClear(pTaskDb->pCfOpts);
taosMemoryFreeClear(pTaskDb->pCompares);
return;
}
for (int i = 0; i < nCf; i++) {
rocksdb_options_t* opt = rocksdb_options_create_copy(pTaskDb->dbOpt);

15
source/libs/transport/src/thttp.c
View File

@ -266,16 +266,23 @@ static int32_t httpCreateMsg(const char* server, const char* uri, uint16_t port,
msg->server = taosStrdup(server);
msg->uri = taosStrdup(uri);
msg->cont = taosMemoryMalloc(contLen);
if (qid != NULL)
msg->qid = taosStrdup(qid);
else
msg->qid = NULL;
if (msg->server == NULL || msg->uri == NULL || msg->cont == NULL) {
httpDestroyMsg(msg);
*httpMsg = NULL;
return terrno;
}
if (qid != NULL) {
msg->qid = taosStrdup(qid);
if (msg->qid == NULL) {
httpDestroyMsg(msg);
*httpMsg = NULL;
return terrno;
}
} else {
msg->qid = NULL;
}
memcpy(msg->cont, pCont, contLen);
msg->len = contLen;
msg->flag = flag;

31
source/libs/transport/src/transCli.c
View File

@ -673,6 +673,10 @@ static SCliConn* getConnFromPool(SCliThrd* pThrd, char* key, bool* exceed) {
plist = taosHashGet(pool, key, klen);
SMsgList* nList = taosMemoryCalloc(1, sizeof(SMsgList));
if (nList == NULL) {
tError("failed to alloc memory for msg list, reason:%s", tstrerror(terrno));
return NULL;
}
QUEUE_INIT(&nList->msgQ);
nList->numOfConn++;
@ -720,6 +724,11 @@ static SCliConn* getConnFromPool2(SCliThrd* pThrd, char* key, SCliMsg** pMsg) {
plist = taosHashGet(pool, key, klen);
SMsgList* nList = taosMemoryCalloc(1, sizeof(SMsgList));
if (nList == NULL) {
tError("failed to alloc memory for msg list, reason:%s", tstrerror(terrno));
return NULL;
}
QUEUE_INIT(&nList->msgQ);
nList->numOfConn++;
@ -1303,11 +1312,16 @@ void cliSend(SCliConn* pConn) {
uv_timer_t* timer = taosArrayGetSize(pThrd->timerList) > 0 ? *(uv_timer_t**)taosArrayPop(pThrd->timerList) : NULL;
if (timer == NULL) {
timer = taosMemoryCalloc(1, sizeof(uv_timer_t));
if (timer == NULL) {
tError("failed to alloc timer since %s", tstrerror(terrno));
}
tDebug("no available timer, create a timer %p", timer);
TAOS_UNUSED(uv_timer_init(pThrd->loop, timer));
}
timer->data = pConn;
pConn->timer = timer;
if (timer != NULL) {
timer->data = pConn;
pConn->timer = timer;
}
tGTrace("%s conn %p start timer for msg:%s", CONN_GET_INST_LABEL(pConn), pConn, TMSG_INFO(pMsg->msgType));
TAOS_UNUSED(uv_timer_start((uv_timer_t*)pConn->timer, cliReadTimeoutCb, TRANS_READ_TIMEOUT, 0));
@ -1327,6 +1341,11 @@ void cliSend(SCliConn* pConn) {
uv_buf_t wb = uv_buf_init((char*)pHead, msgLen);
uv_write_t* req = transReqQueuePush(&pConn->wreqQueue);
if (req == NULL) {
tGError("%s conn %p failed to send msg:%s, errmsg:%s", CONN_GET_INST_LABEL(pConn), pConn, TMSG_INFO(pMsg->msgType),
tstrerror(TSDB_CODE_OUT_OF_MEMORY));
cliHandleExcept(pConn, -1);
}
int status = uv_write(req, (uv_stream_t*)pConn->stream, &wb, 1, cliSendCb);
if (status != 0) {
@ -1871,6 +1890,10 @@ void cliHandleReq(SCliMsg* pMsg, SCliThrd* pThrd) {
TAOS_UNUSED(transQueuePush(&conn->cliMsgs, pMsg));
conn->dstAddr = taosStrdup(addr);
if (conn->dstAddr == NULL) {
tGError("%s conn %p failed to create socket, reason:%s", transLabel(pTransInst), conn, tstrerror(terrno));
cliHandleExcept(conn, -1);
}
uint32_t ipaddr;
int32_t code = cliGetIpFromFqdnCache(pThrd->fqdn2ipCache, fqdn, &ipaddr);
@ -2546,6 +2569,10 @@ static void cliSchedMsgToNextNode(SCliMsg* pMsg, SCliThrd* pThrd) {
cliSchedMsgToDebug(pMsg, transLabel(pThrd->pTransInst));
STaskArg* arg = taosMemoryMalloc(sizeof(STaskArg));
if (arg == NULL) {
tError("failed to malloc memory, reason:%s", tstrerror(TSDB_CODE_OUT_OF_MEMORY));
return;
}
arg->param1 = pMsg;
arg->param2 = pThrd;

3
source/libs/transport/src/transComm.c
View File

@ -421,6 +421,9 @@ void transReqQueueInit(queue* q) {
}
void* transReqQueuePush(queue* q) {
STransReq* req = taosMemoryCalloc(1, sizeof(STransReq));
if (req == NULL) {
return NULL;
}
req->wreq.data = req;
QUEUE_PUSH(q, &req->q);
return &req->wreq;

21
source/libs/transport/src/transSvr.c
View File

@ -707,6 +707,10 @@ static FORCE_INLINE void uvStartSendRespImpl(SSvrMsg* smsg) {
transRefSrvHandle(pConn);
uv_write_t* req = transReqQueuePush(&pConn->wreqQueue);
if (req == NULL) {
tError("failed to send resp since %s", tstrerror(TSDB_CODE_OUT_OF_MEMORY));
return;
}
TAOS_UNUSED(uv_write(req, (uv_stream_t*)pConn->pTcp, &wb, 1, uvOnSendCb));
}
static void uvStartSendResp(SSvrMsg* smsg) {
@ -842,6 +846,10 @@ static bool uvRecvReleaseReq(SSvrConn* pConn, STransMsgHead* pHead) {
STransMsg tmsg = {.code = 0, .info.handle = (void*)pConn, .info.traceId = traceId, .info.ahandle = (void*)0x9527};
SSvrMsg* srvMsg = taosMemoryCalloc(1, sizeof(SSvrMsg));
if (srvMsg == NULL) {
tError("failed to alloc buf to send release resp since %s", tstrerror(terrno));
return true;
}
srvMsg->msg = tmsg;
srvMsg->type = Release;
srvMsg->pConn = pConn;
@ -905,6 +913,11 @@ void uvOnAcceptCb(uv_stream_t* stream, int status) {
#endif
uv_write_t* wr = (uv_write_t*)taosMemoryMalloc(sizeof(uv_write_t));
if (wr == NULL) {
tError("failed to accept since %s", tstrerror(TSDB_CODE_OUT_OF_MEMORY));
return;
}
wr->data = cli;
uv_buf_t buf = uv_buf_init((char*)notify, strlen(notify));
@ -1401,6 +1414,10 @@ void* transInitServer(uint32_t ip, uint32_t port, char* label, int numOfThreads,
for (int i = 0; i < srv->numOfThreads; i++) {
SWorkThrd* thrd = (SWorkThrd*)taosMemoryCalloc(1, sizeof(SWorkThrd));
if (thrd == NULL) {
code = terrno;
goto End;
}
thrd->pTransInst = shandle;
thrd->quit = false;
thrd->pTransInst = shandle;
@ -1654,6 +1671,10 @@ void destroyWorkThrd(SWorkThrd* pThrd) {
}
void sendQuitToWorkThrd(SWorkThrd* pThrd) {
SSvrMsg* msg = taosMemoryCalloc(1, sizeof(SSvrMsg));
if (msg == NULL) {
tError("failed to send quit msg to work thread since %s", tstrerror(terrno));
return;
}
msg->type = Quit;
tDebug("server send quit msg to work thread");
TAOS_UNUSED(transAsyncSend(pThrd->asyncPool, &msg->q));