From 3c4b2c6bac1b916b9db91388decb6a5622012d8f Mon Sep 17 00:00:00 2001 From: Hongze Cheng Date: Mon, 29 Jul 2024 10:33:29 +0800 Subject: [PATCH 01/28] refactor error code --- source/dnode/vnode/src/tsdb/tsdbCommit2.c | 38 ++++----- source/dnode/vnode/src/tsdb/tsdbDataFileRAW.c | 6 +- source/dnode/vnode/src/tsdb/tsdbFS2.c | 79 ++++++++++--------- source/dnode/vnode/src/tsdb/tsdbFSetRW.c | 2 +- source/dnode/vnode/src/tsdb/tsdbFile.c | 2 +- source/dnode/vnode/src/tsdb/tsdbIter.c | 2 +- source/dnode/vnode/src/tsdb/tsdbMerge.c | 12 +-- source/dnode/vnode/src/tsdb/tsdbOpen.c | 16 ++-- .../dnode/vnode/src/tsdb/tsdbReaderWriter.c | 12 +-- source/dnode/vnode/src/tsdb/tsdbSnapInfo.c | 2 +- source/dnode/vnode/src/tsdb/tsdbSnapshot.c | 48 +++++------ source/dnode/vnode/src/tsdb/tsdbUpgrade.c | 4 +- 12 files changed, 112 insertions(+), 111 deletions(-) diff --git a/source/dnode/vnode/src/tsdb/tsdbCommit2.c b/source/dnode/vnode/src/tsdb/tsdbCommit2.c index 0c3fc95d6c..4467102d6f 100644 --- a/source/dnode/vnode/src/tsdb/tsdbCommit2.c +++ b/source/dnode/vnode/src/tsdb/tsdbCommit2.c @@ -251,7 +251,7 @@ static int32_t tsdbCommitOpenReader(SCommitter2 *committer) { _exit: if (code) { - tsdbCommitCloseReader(committer); + TAOS_UNUSED(tsdbCommitCloseReader(committer)); tsdbError("vgId:%d %s failed at %s:%d since %s", TD_VID(committer->tsdb->pVnode), __func__, __FILE__, lino, tstrerror(code)); } @@ -259,8 +259,8 @@ _exit: } static int32_t tsdbCommitCloseIter(SCommitter2 *committer) { - tsdbIterMergerClose(&committer->tombIterMerger); - tsdbIterMergerClose(&committer->dataIterMerger); + TAOS_UNUSED(tsdbIterMergerClose(&committer->tombIterMerger)); + TAOS_UNUSED(tsdbIterMergerClose(&committer->dataIterMerger)); TARRAY2_CLEAR(committer->tombIterArray, tsdbIterClose); TARRAY2_CLEAR(committer->dataIterArray, tsdbIterClose); return 0; @@ -322,7 +322,7 @@ static int32_t tsdbCommitOpenIter(SCommitter2 *committer) { _exit: if (code) { - tsdbCommitCloseIter(committer); + TAOS_UNUSED(tsdbCommitCloseIter(committer)); tsdbError("vgId:%d %s failed at %s:%d since %s", TD_VID(committer->tsdb->pVnode), __func__, __FILE__, lino, tstrerror(code)); } @@ -335,7 +335,7 @@ static int32_t tsdbCommitFileSetBegin(SCommitter2 *committer) { STsdb *tsdb = committer->tsdb; // check if can commit - tsdbFSCheckCommit(tsdb, committer->ctx->info->fid); + TAOS_UNUSED(tsdbFSCheckCommit(tsdb, committer->ctx->info->fid)); committer->ctx->expLevel = tsdbFidLevel(committer->ctx->info->fid, &tsdb->keepCfg, committer->now); tsdbFidKeyRange(committer->ctx->info->fid, committer->minutes, committer->precision, &committer->ctx->minKey, @@ -344,7 +344,7 @@ static int32_t tsdbCommitFileSetBegin(SCommitter2 *committer) { TAOS_CHECK_GOTO(tfsAllocDisk(committer->tsdb->pVnode->pTfs, committer->ctx->expLevel, &committer->ctx->did), &lino, _exit); - tfsMkdirRecurAt(committer->tsdb->pVnode->pTfs, committer->tsdb->path, committer->ctx->did); + TAOS_UNUSED(tfsMkdirRecurAt(committer->tsdb->pVnode->pTfs, committer->tsdb->path, committer->ctx->did)); committer->ctx->tbid->suid = 0; committer->ctx->tbid->uid = 0; @@ -430,12 +430,12 @@ static int32_t tsdbCommitInfoDestroy(STsdb *pTsdb) { if (pTsdb->commitInfo) { for (int32_t i = 0; i < taosArrayGetSize(pTsdb->commitInfo->arr); i++) { SFileSetCommitInfo *info = *(SFileSetCommitInfo **)taosArrayGet(pTsdb->commitInfo->arr, i); - vHashDrop(pTsdb->commitInfo->ht, info); + TAOS_UNUSED(vHashDrop(pTsdb->commitInfo->ht, info)); tsdbTFileSetClear(&info->fset); taosMemoryFree(info); } - vHashDestroy(&pTsdb->commitInfo->ht); + TAOS_UNUSED(vHashDestroy(&pTsdb->commitInfo->ht)); taosArrayDestroy(pTsdb->commitInfo->arr); pTsdb->commitInfo->arr = NULL; taosMemoryFreeClear(pTsdb->commitInfo); @@ -461,7 +461,7 @@ static int32_t tsdbCommitInfoInit(STsdb *pTsdb) { _exit: if (code) { - tsdbCommitInfoDestroy(pTsdb); + TAOS_UNUSED(tsdbCommitInfoDestroy(pTsdb)); tsdbError("vgId:%d %s failed at %s:%d since %s", TD_VID(pTsdb->pVnode), __func__, __FILE__, lino, tstrerror(code)); } return code; @@ -531,7 +531,7 @@ static int32_t tsdbCommitInfoBuild(STsdb *tsdb) { SFileSetCommitInfo tinfo = { .fid = fid, }; - vHashGet(tsdb->commitInfo->ht, &tinfo, (void **)&info); + TAOS_UNUSED(vHashGet(tsdb->commitInfo->ht, &tinfo, (void **)&info)); if (info == NULL) { TAOS_CHECK_GOTO(tsdbCommitInfoAdd(tsdb, fid), &lino, _exit); } @@ -555,7 +555,7 @@ static int32_t tsdbCommitInfoBuild(STsdb *tsdb) { }; // check if the file set already on the commit list - vHashGet(tsdb->commitInfo->ht, &tinfo, (void **)&info); + TAOS_UNUSED(vHashGet(tsdb->commitInfo->ht, &tinfo, (void **)&info)); if (info != NULL) { continue; } @@ -589,7 +589,7 @@ static int32_t tsdbCommitInfoBuild(STsdb *tsdb) { // begin tasks on file set for (int i = 0; i < taosArrayGetSize(tsdb->commitInfo->arr); i++) { SFileSetCommitInfo *info = *(SFileSetCommitInfo **)taosArrayGet(tsdb->commitInfo->arr, i); - tsdbBeginTaskOnFileSet(tsdb, info->fid, &fset); + TAOS_UNUSED(tsdbBeginTaskOnFileSet(tsdb, info->fid, &fset)); if (fset) { code = tsdbTFileSetInitCopy(tsdb, fset, &info->fset); if (code) { @@ -603,7 +603,7 @@ static int32_t tsdbCommitInfoBuild(STsdb *tsdb) { _exit: if (code) { - tsdbCommitInfoDestroy(tsdb); + TAOS_UNUSED(tsdbCommitInfoDestroy(tsdb)); tsdbError("vgId:%d %s failed at %s:%d since %s", TD_VID(tsdb->pVnode), __func__, __FILE__, lino, tstrerror(code)); } return code; @@ -689,7 +689,7 @@ int32_t tsdbCommitBegin(STsdb *tsdb, SCommitInfo *info) { (void)taosThreadMutexLock(&tsdb->mutex); tsdb->imem = NULL; (void)taosThreadMutexUnlock(&tsdb->mutex); - tsdbUnrefMemTable(imem, NULL, true); + TAOS_UNUSED(tsdbUnrefMemTable(imem, NULL, true)); } else { SCommitter2 committer = {0}; @@ -730,14 +730,14 @@ int32_t tsdbCommitCommit(STsdb *tsdb) { for (int32_t i = 0; i < taosArrayGetSize(tsdb->commitInfo->arr); i++) { SFileSetCommitInfo *info = *(SFileSetCommitInfo **)taosArrayGet(tsdb->commitInfo->arr, i); if (info->fset) { - tsdbFinishTaskOnFileSet(tsdb, info->fid); + TAOS_UNUSED(tsdbFinishTaskOnFileSet(tsdb, info->fid)); } } (void)taosThreadMutexUnlock(&tsdb->mutex); - tsdbCommitInfoDestroy(tsdb); - tsdbUnrefMemTable(pMemTable, NULL, true); + TAOS_UNUSED(tsdbCommitInfoDestroy(tsdb)); + TAOS_UNUSED(tsdbUnrefMemTable(pMemTable, NULL, true)); } _exit: @@ -761,11 +761,11 @@ int32_t tsdbCommitAbort(STsdb *pTsdb) { for (int32_t i = 0; i < taosArrayGetSize(pTsdb->commitInfo->arr); i++) { SFileSetCommitInfo *info = *(SFileSetCommitInfo **)taosArrayGet(pTsdb->commitInfo->arr, i); if (info->fset) { - tsdbFinishTaskOnFileSet(pTsdb, info->fid); + TAOS_UNUSED(tsdbFinishTaskOnFileSet(pTsdb, info->fid)); } } (void)taosThreadMutexUnlock(&pTsdb->mutex); - tsdbCommitInfoDestroy(pTsdb); + TAOS_UNUSED(tsdbCommitInfoDestroy(pTsdb)); _exit: if (code) { diff --git a/source/dnode/vnode/src/tsdb/tsdbDataFileRAW.c b/source/dnode/vnode/src/tsdb/tsdbDataFileRAW.c index e358b8f87e..6469160536 100644 --- a/source/dnode/vnode/src/tsdb/tsdbDataFileRAW.c +++ b/source/dnode/vnode/src/tsdb/tsdbDataFileRAW.c @@ -35,7 +35,7 @@ int32_t tsdbDataFileRAWReaderOpen(const char *fname, const SDataFileRAWReaderCon } } else { char fname1[TSDB_FILENAME_LEN]; - tsdbTFileName(config->tsdb, &config->file, fname1); + (void)tsdbTFileName(config->tsdb, &config->file, fname1); TAOS_CHECK_GOTO(tsdbOpenFile(fname1, config->tsdb, TD_FILE_READ, &reader[0]->fd, lcn), &lino, _exit); } @@ -159,7 +159,7 @@ static int32_t tsdbDataFileRAWWriterOpenDataFD(SDataFileRAWWriter *writer) { flag |= (TD_FILE_CREATE | TD_FILE_TRUNC); } - tsdbTFileName(writer->config->tsdb, &writer->file, fname); + (void)tsdbTFileName(writer->config->tsdb, &writer->file, fname); TAOS_CHECK_GOTO(tsdbOpenFile(fname, writer->config->tsdb, flag, &writer->fd, writer->file.lcn), &lino, _exit); _exit: @@ -202,7 +202,7 @@ int32_t tsdbDataFileRAWWriterClose(SDataFileRAWWriter **writer, bool abort, TFil } else { TAOS_CHECK_GOTO(tsdbDataFileRAWWriterCloseCommit(writer[0], opArr), &lino, _exit); } - tsdbDataFileRAWWriterDoClose(writer[0]); + (void)tsdbDataFileRAWWriterDoClose(writer[0]); } taosMemoryFree(writer[0]); writer[0] = NULL; diff --git a/source/dnode/vnode/src/tsdb/tsdbFS2.c b/source/dnode/vnode/src/tsdb/tsdbFS2.c index ff97274097..99dd0edf9d 100644 --- a/source/dnode/vnode/src/tsdb/tsdbFS2.c +++ b/source/dnode/vnode/src/tsdb/tsdbFS2.c @@ -46,7 +46,7 @@ static int32_t create_fs(STsdb *pTsdb, STFileSystem **fs) { } fs[0]->tsdb = pTsdb; - tsem_init(&fs[0]->canEdit, 0, 1); + (void)tsem_init(&fs[0]->canEdit, 0, 1); fs[0]->fsstate = TSDB_FS_STATE_NORMAL; fs[0]->neid = 0; TARRAY2_INIT(fs[0]->fSetArr); @@ -60,7 +60,7 @@ static int32_t destroy_fs(STFileSystem **fs) { TARRAY2_DESTROY(fs[0]->fSetArr, NULL); TARRAY2_DESTROY(fs[0]->fSetArrTmp, NULL); - tsem_destroy(&fs[0]->canEdit); + (void)tsem_destroy(&fs[0]->canEdit); taosMemoryFree(fs[0]); fs[0] = NULL; return 0; @@ -69,7 +69,7 @@ static int32_t destroy_fs(STFileSystem **fs) { int32_t current_fname(STsdb *pTsdb, char *fname, EFCurrentT ftype) { int32_t offset = 0; - vnodeGetPrimaryDir(pTsdb->path, pTsdb->pVnode->diskPrimary, pTsdb->pVnode->pTfs, fname, TSDB_FILENAME_LEN); + (void)vnodeGetPrimaryDir(pTsdb->path, pTsdb->pVnode->diskPrimary, pTsdb->pVnode->pTfs, fname, TSDB_FILENAME_LEN); offset = strlen(fname); snprintf(fname + offset, TSDB_FILENAME_LEN - offset - 1, "%s%s", TD_DIRSEP, gCurrentFname[ftype]); @@ -105,7 +105,7 @@ _exit: tsdbError("%s failed at %s:%d since %s", __func__, fname, __LINE__, tstrerror(code)); } taosMemoryFree(data); - taosCloseFile(&fp); + (void)taosCloseFile(&fp); return code; } @@ -144,7 +144,7 @@ _exit: tsdbError("%s failed at %s:%d since %s", __func__, fname, __LINE__, tstrerror(code)); json[0] = NULL; } - taosCloseFile(&fp); + (void)taosCloseFile(&fp); taosMemoryFree(data); return code; } @@ -174,7 +174,8 @@ int32_t save_fs(const TFileSetArray *arr, const char *fname) { if (!item) { TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit); } - cJSON_AddItemToArray(ajson, item); + code = cJSON_AddItemToArray(ajson, item); + TSDB_CHECK_CODE(code, lino, _exit); code = tsdbTFileSetToJson(fset, item); TSDB_CHECK_CODE(code, lino, _exit); @@ -255,7 +256,7 @@ static int32_t apply_commit(STFileSystem *fs) { if (fset1 && fset2) { if (fset1->fid < fset2->fid) { // delete fset1 - tsdbTFileSetRemove(fset1); + (void)tsdbTFileSetRemove(fset1); i1++; } else if (fset1->fid > fset2->fid) { // create new file set with fid of fset2->fid @@ -274,7 +275,7 @@ static int32_t apply_commit(STFileSystem *fs) { } } else if (fset1) { // delete fset1 - tsdbTFileSetRemove(fset1); + (void)tsdbTFileSetRemove(fset1); i1++; } else { // create new file set with fid of fset2->fid @@ -298,11 +299,11 @@ static int32_t commit_edit(STFileSystem *fs) { char current[TSDB_FILENAME_LEN]; char current_t[TSDB_FILENAME_LEN]; - current_fname(fs->tsdb, current, TSDB_FCURRENT); + (void)current_fname(fs->tsdb, current, TSDB_FCURRENT); if (fs->etype == TSDB_FEDIT_COMMIT) { - current_fname(fs->tsdb, current_t, TSDB_FCURRENT_C); + (void)current_fname(fs->tsdb, current_t, TSDB_FCURRENT_C); } else { - current_fname(fs->tsdb, current_t, TSDB_FCURRENT_M); + (void)current_fname(fs->tsdb, current_t, TSDB_FCURRENT_M); } int32_t code; @@ -333,9 +334,9 @@ static int32_t abort_edit(STFileSystem *fs) { char fname[TSDB_FILENAME_LEN]; if (fs->etype == TSDB_FEDIT_COMMIT) { - current_fname(fs->tsdb, fname, TSDB_FCURRENT_C); + (void)current_fname(fs->tsdb, fname, TSDB_FCURRENT_C); } else { - current_fname(fs->tsdb, fname, TSDB_FCURRENT_M); + (void)current_fname(fs->tsdb, fname, TSDB_FCURRENT_M); } int32_t code; @@ -368,7 +369,7 @@ static int32_t tsdbFSDoScanAndFixFile(STFileSystem *fs, const STFileObj *fobj) { if (tsS3Enabled && fobj->f->lcn > 1) { char fname1[TSDB_FILENAME_LEN]; - tsdbTFileLastChunkName(fs->tsdb, fobj->f, fname1); + (void)tsdbTFileLastChunkName(fs->tsdb, fobj->f, fname1); if (!taosCheckExistFile(fname1)) { code = TSDB_CODE_FILE_CORRUPTED; tsdbError("vgId:%d %s failed since file:%s does not exist", TD_VID(fs->tsdb->pVnode), __func__, fname1); @@ -419,7 +420,7 @@ static int32_t tsdbFSCreateFileObjHash(STFileSystem *fs, STFileHash *hash) { } // vnode.json - current_fname(fs->tsdb, fname, TSDB_FCURRENT); + (void)current_fname(fs->tsdb, fname, TSDB_FCURRENT); code = tsdbFSAddEntryToFileObjHash(hash, fname); TSDB_CHECK_CODE(code, lino, _exit); @@ -603,9 +604,9 @@ static int32_t open_fs(STFileSystem *fs, int8_t rollback) { char cCurrent[TSDB_FILENAME_LEN]; char mCurrent[TSDB_FILENAME_LEN]; - current_fname(pTsdb, fCurrent, TSDB_FCURRENT); - current_fname(pTsdb, cCurrent, TSDB_FCURRENT_C); - current_fname(pTsdb, mCurrent, TSDB_FCURRENT_M); + (void)current_fname(pTsdb, fCurrent, TSDB_FCURRENT); + (void)current_fname(pTsdb, cCurrent, TSDB_FCURRENT_C); + (void)current_fname(pTsdb, mCurrent, TSDB_FCURRENT_M); if (taosCheckExistFile(fCurrent)) { // current.json exists code = load_fs(pTsdb, fCurrent, fs->fSetArr); @@ -744,7 +745,7 @@ int32_t tsdbOpenFS(STsdb *pTsdb, STFileSystem **fs, int8_t rollback) { _exit: if (code) { tsdbError("vgId:%d %s failed at line %d since %s", TD_VID(pTsdb->pVnode), __func__, lino, tstrerror(code)); - destroy_fs(fs); + (void)destroy_fs(fs); } else { tsdbInfo("vgId:%d %s success", TD_VID(pTsdb->pVnode), __func__); } @@ -787,12 +788,12 @@ int32_t tsdbDisableAndCancelAllBgTask(STsdb *pTsdb) { // destroy all channels for (int32_t i = 0; i < taosArrayGetSize(channelArray); i++) { SVAChannelID *channel = taosArrayGet(channelArray, i); - vnodeAChannelDestroy(channel, true); + (void)vnodeAChannelDestroy(channel, true); } taosArrayDestroy(channelArray); #ifdef TD_ENTERPRISE - tsdbStopAllCompTask(pTsdb); + (void)tsdbStopAllCompTask(pTsdb); #endif return 0; } @@ -807,9 +808,9 @@ int32_t tsdbEnableBgTask(STsdb *pTsdb) { int32_t tsdbCloseFS(STFileSystem **fs) { if (fs[0] == NULL) return 0; - tsdbDisableAndCancelAllBgTask((*fs)->tsdb); - close_file_system(fs[0]); - destroy_fs(fs); + (void)tsdbDisableAndCancelAllBgTask((*fs)->tsdb); + (void)close_file_system(fs[0]); + (void)destroy_fs(fs); return 0; } @@ -832,12 +833,12 @@ int32_t tsdbFSEditBegin(STFileSystem *fs, const TFileOpArray *opArray, EFEditT e char current_t[TSDB_FILENAME_LEN]; if (etype == TSDB_FEDIT_COMMIT) { - current_fname(fs->tsdb, current_t, TSDB_FCURRENT_C); + (void)current_fname(fs->tsdb, current_t, TSDB_FCURRENT_C); } else { - current_fname(fs->tsdb, current_t, TSDB_FCURRENT_M); + (void)current_fname(fs->tsdb, current_t, TSDB_FCURRENT_M); } - tsem_wait(&fs->canEdit); + (void)tsem_wait(&fs->canEdit); fs->etype = etype; // edit @@ -864,7 +865,7 @@ static int32_t tsdbFSSetBlockCommit(STFileSet *fset, bool block) { } else { fset->blockCommit = false; if (fset->numWaitCommit > 0) { - taosThreadCondSignal(&fset->canCommit); + (void)taosThreadCondSignal(&fset->canCommit); } } return 0; @@ -873,7 +874,7 @@ static int32_t tsdbFSSetBlockCommit(STFileSet *fset, bool block) { int32_t tsdbFSCheckCommit(STsdb *tsdb, int32_t fid) { (void)taosThreadMutexLock(&tsdb->mutex); STFileSet *fset; - tsdbFSGetFSet(tsdb->pFS, fid, &fset); + (void)tsdbFSGetFSet(tsdb->pFS, fid, &fset); if (fset) { while (fset->blockCommit) { fset->numWaitCommit++; @@ -901,13 +902,13 @@ int32_t tsdbFSEditCommit(STFileSystem *fs) { STFileSet *fset; TARRAY2_FOREACH_REVERSE(fs->fSetArr, fset) { if (TARRAY2_SIZE(fset->lvlArr) == 0) { - tsdbFSSetBlockCommit(fset, false); + (void)tsdbFSSetBlockCommit(fset, false); continue; } SSttLvl *lvl = TARRAY2_FIRST(fset->lvlArr); if (lvl->level != 0) { - tsdbFSSetBlockCommit(fset, false); + (void)tsdbFSSetBlockCommit(fset, false); continue; } @@ -932,9 +933,9 @@ int32_t tsdbFSEditCommit(STFileSystem *fs) { } if (numFile >= sttTrigger * BLOCK_COMMIT_FACTOR) { - tsdbFSSetBlockCommit(fset, true); + (void)tsdbFSSetBlockCommit(fset, true); } else { - tsdbFSSetBlockCommit(fset, false); + (void)tsdbFSSetBlockCommit(fset, false); } } } @@ -945,13 +946,13 @@ _exit: } else { tsdbInfo("vgId:%d %s done, etype:%d", TD_VID(fs->tsdb->pVnode), __func__, fs->etype); } - tsem_post(&fs->canEdit); + (void)tsem_post(&fs->canEdit); return code; } int32_t tsdbFSEditAbort(STFileSystem *fs) { int32_t code = abort_edit(fs); - tsem_post(&fs->canEdit); + (void)tsem_post(&fs->canEdit); return code; } @@ -1181,7 +1182,7 @@ int32_t tsdbFSDestroyRefRangedSnapshot(TFileSetRangeArray **fsrArr) { return tsd int32_t tsdbBeginTaskOnFileSet(STsdb *tsdb, int32_t fid, STFileSet **fset) { int16_t sttTrigger = tsdb->pVnode->config.sttTrigger; - tsdbFSGetFSet(tsdb->pFS, fid, fset); + (void)tsdbFSGetFSet(tsdb->pFS, fid, fset); if (sttTrigger == 1 && (*fset)) { for (;;) { if ((*fset)->taskRunning) { @@ -1189,7 +1190,7 @@ int32_t tsdbBeginTaskOnFileSet(STsdb *tsdb, int32_t fid, STFileSet **fset) { taosThreadCondWait(&(*fset)->beginTask, &tsdb->mutex); - tsdbFSGetFSet(tsdb->pFS, fid, fset); + (void)tsdbFSGetFSet(tsdb->pFS, fid, fset); ASSERT(fset != NULL); (*fset)->numWaitTask--; @@ -1209,11 +1210,11 @@ int32_t tsdbFinishTaskOnFileSet(STsdb *tsdb, int32_t fid) { int16_t sttTrigger = tsdb->pVnode->config.sttTrigger; if (sttTrigger == 1) { STFileSet *fset = NULL; - tsdbFSGetFSet(tsdb->pFS, fid, &fset); + (void)tsdbFSGetFSet(tsdb->pFS, fid, &fset); if (fset != NULL && fset->taskRunning) { fset->taskRunning = false; if (fset->numWaitTask > 0) { - taosThreadCondSignal(&fset->beginTask); + (void)taosThreadCondSignal(&fset->beginTask); } tsdbInfo("vgId:%d finish task on file set:%d", TD_VID(tsdb->pVnode), fid); } diff --git a/source/dnode/vnode/src/tsdb/tsdbFSetRW.c b/source/dnode/vnode/src/tsdb/tsdbFSetRW.c index 77d8998aa7..3ccf833ddd 100644 --- a/source/dnode/vnode/src/tsdb/tsdbFSetRW.c +++ b/source/dnode/vnode/src/tsdb/tsdbFSetRW.c @@ -44,7 +44,7 @@ static int32_t tsdbFSetWriteTableDataBegin(SFSetWriter *writer, const TABLEID *t writer->ctx->tbid->uid = tbid->uid; code = tsdbUpdateSkmTb(writer->config->tsdb, writer->ctx->tbid, writer->skmTb); - TSDB_CHECK_CODE(code , lino, _exit); + TSDB_CHECK_CODE(code, lino, _exit); code = metaGetColCmpr(writer->config->tsdb->pVnode->pMeta, tbid->suid ? tbid->suid : tbid->uid, &writer->pColCmprObj); // TODO: TSDB_CHECK_CODE(code, lino, _exit); diff --git a/source/dnode/vnode/src/tsdb/tsdbFile.c b/source/dnode/vnode/src/tsdb/tsdbFile.c index 243ff662f7..cf88f9a066 100644 --- a/source/dnode/vnode/src/tsdb/tsdbFile.c +++ b/source/dnode/vnode/src/tsdb/tsdbFile.c @@ -221,7 +221,7 @@ void tsdbDelFileName(STsdb *pTsdb, SDelFile *pFile, char fname[]) { int32_t offset = 0; SVnode *pVnode = pTsdb->pVnode; - vnodeGetPrimaryDir(pTsdb->path, pVnode->diskPrimary, pVnode->pTfs, fname, TSDB_FILENAME_LEN); + (void)vnodeGetPrimaryDir(pTsdb->path, pVnode->diskPrimary, pVnode->pTfs, fname, TSDB_FILENAME_LEN); offset = strlen(fname); snprintf((char *)fname + offset, TSDB_FILENAME_LEN - offset - 1, "%sv%dver%" PRId64 ".del", TD_DIRSEP, TD_VID(pTsdb->pVnode), pFile->commitID); diff --git a/source/dnode/vnode/src/tsdb/tsdbIter.c b/source/dnode/vnode/src/tsdb/tsdbIter.c index 3b5bd6d02f..0de9ba9822 100644 --- a/source/dnode/vnode/src/tsdb/tsdbIter.c +++ b/source/dnode/vnode/src/tsdb/tsdbIter.c @@ -224,7 +224,7 @@ static int32_t tsdbMemTableIterNext(STsdbIter *iter, const TABLEID *tbid) { iter->row->row = row[0]; - tsdbTbDataIterNext(iter->memtData->tbIter); + (void)tsdbTbDataIterNext(iter->memtData->tbIter); goto _exit; } diff --git a/source/dnode/vnode/src/tsdb/tsdbMerge.c b/source/dnode/vnode/src/tsdb/tsdbMerge.c index 7b40290c05..1bbda8a249 100644 --- a/source/dnode/vnode/src/tsdb/tsdbMerge.c +++ b/source/dnode/vnode/src/tsdb/tsdbMerge.c @@ -215,7 +215,7 @@ static int32_t tsdbMergeFileSetBeginOpenReader(SMerger *merger) { TAOS_CHECK_GOTO(tsdbSttFileReaderOpen(fobj->fname, &config, &reader), &lino, _exit); if ((code = TARRAY2_APPEND(merger->sttReaderArr, reader))) { - tsdbSttFileReaderClose(&reader); + (void)tsdbSttFileReaderClose(&reader); TSDB_CHECK_CODE(code, lino, _exit); } } @@ -230,7 +230,7 @@ _exit: if (code) { tsdbError("vgId:%d %s failed at %s:%d since %s", TD_VID(merger->tsdb->pVnode), __func__, __FILE__, lino, tstrerror(code)); - tsdbMergeFileSetEndCloseReader(merger); + (void)tsdbMergeFileSetEndCloseReader(merger); } return code; } @@ -282,7 +282,7 @@ static int32_t tsdbMergeFileSetBeginOpenWriter(SMerger *merger) { TAOS_CHECK_GOTO(tfsAllocDisk(merger->tsdb->pVnode->pTfs, level, &did), &lino, _exit); - tfsMkdirRecurAt(merger->tsdb->pVnode->pTfs, merger->tsdb->path, did); + (void)tfsMkdirRecurAt(merger->tsdb->pVnode->pTfs, merger->tsdb->path, did); SFSetWriterConfig config = { .tsdb = merger->tsdb, .toSttOnly = true, @@ -355,9 +355,9 @@ static int32_t tsdbMergeFileSetEndCloseWriter(SMerger *merger) { } static int32_t tsdbMergeFileSetEndCloseIter(SMerger *merger) { - tsdbIterMergerClose(&merger->tombIterMerger); + (void)tsdbIterMergerClose(&merger->tombIterMerger); TARRAY2_CLEAR(merger->tombIterArr, tsdbIterClose); - tsdbIterMergerClose(&merger->dataIterMerger); + (void)tsdbIterMergerClose(&merger->dataIterMerger); TARRAY2_CLEAR(merger->dataIterArr, tsdbIterClose); return 0; } @@ -479,7 +479,7 @@ static int32_t tsdbMergeGetFSet(SMerger *merger) { STFileSet *fset; (void)taosThreadMutexLock(&merger->tsdb->mutex); - tsdbFSGetFSet(merger->tsdb->pFS, merger->fid, &fset); + (void)tsdbFSGetFSet(merger->tsdb->pFS, merger->fid, &fset); if (fset == NULL) { (void)taosThreadMutexUnlock(&merger->tsdb->mutex); return 0; diff --git a/source/dnode/vnode/src/tsdb/tsdbOpen.c b/source/dnode/vnode/src/tsdb/tsdbOpen.c index 370d847a33..7f83bcdb0c 100644 --- a/source/dnode/vnode/src/tsdb/tsdbOpen.c +++ b/source/dnode/vnode/src/tsdb/tsdbOpen.c @@ -59,16 +59,16 @@ int32_t tsdbOpen(SVnode *pVnode, STsdb **ppTsdb, const char *dir, STsdbKeepCfg * pTsdb->pVnode = pVnode; taosThreadMutexInit(&pTsdb->mutex, NULL); if (!pKeepCfg) { - tsdbSetKeepCfg(pTsdb, &pVnode->config.tsdbCfg); + (void)tsdbSetKeepCfg(pTsdb, &pVnode->config.tsdbCfg); } else { memcpy(&pTsdb->keepCfg, pKeepCfg, sizeof(STsdbKeepCfg)); } // create dir if (pVnode->pTfs) { - tfsMkdir(pVnode->pTfs, pTsdb->path); + (void)tfsMkdir(pVnode->pTfs, pTsdb->path); } else { - taosMkDir(pTsdb->path); + (void)taosMkDir(pTsdb->path); } // open tsdb @@ -87,8 +87,8 @@ int32_t tsdbOpen(SVnode *pVnode, STsdb **ppTsdb, const char *dir, STsdbKeepCfg * _exit: if (code) { tsdbError("vgId:%d %s failed at %s:%d since %s", TD_VID(pVnode), __func__, __FILE__, lino, tstrerror(code)); - tsdbCloseFS(&pTsdb->pFS); - taosThreadMutexDestroy(&pTsdb->mutex); + (void)tsdbCloseFS(&pTsdb->pFS); + (void)taosThreadMutexDestroy(&pTsdb->mutex); taosMemoryFree(pTsdb); } else { tsdbDebug("vgId:%d, tsdb is opened at %s, days:%d, keep:%d,%d,%d, keepTimeoffset:%d", TD_VID(pVnode), pTsdb->path, @@ -110,12 +110,12 @@ int32_t tsdbClose(STsdb **pTsdb) { (*pTsdb)->mem = NULL; (void)taosThreadMutexUnlock(&(*pTsdb)->mutex); - tsdbCloseFS(&(*pTsdb)->pFS); + (void)tsdbCloseFS(&(*pTsdb)->pFS); tsdbCloseCache(*pTsdb); #ifdef TD_ENTERPRISE - tsdbCloseCompMonitor(*pTsdb); + (void)tsdbCloseCompMonitor(*pTsdb); #endif - taosThreadMutexDestroy(&(*pTsdb)->mutex); + (void)taosThreadMutexDestroy(&(*pTsdb)->mutex); taosMemoryFreeClear(*pTsdb); } return 0; diff --git a/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c b/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c index 28abed1ce7..8e52074807 100644 --- a/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c +++ b/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c @@ -35,7 +35,7 @@ static int32_t tsdbOpenFileImpl(STsdbFD *pFD) { int32_t vid = 0; const char *object_name = taosDirEntryBaseName((char *)path); - sscanf(object_name, "v%df%dver%" PRId64 ".data", &vid, &pFD->fid, &pFD->cid); + (void)sscanf(object_name, "v%df%dver%" PRId64 ".data", &vid, &pFD->fid, &pFD->cid); char *dot = strrchr(lc_path, '.'); if (!dot) { @@ -124,7 +124,7 @@ void tsdbCloseFile(STsdbFD **ppFD) { if (pFD) { taosMemoryFree(pFD->pBuf); // if (!pFD->s3File) { - taosCloseFile(&pFD->pFD); + (void)taosCloseFile(&pFD->pFD); //} taosMemoryFree(pFD); *ppFD = NULL; @@ -156,7 +156,7 @@ static int32_t tsdbWriteFilePage(STsdbFD *pFD, int32_t encryptAlgorithm, char *e TSDB_CHECK_CODE(code = TAOS_SYSTEM_ERROR(errno), lino, _exit); } - taosCalcChecksumAppend(0, pFD->pBuf, pFD->szPage); + (void)taosCalcChecksumAppend(0, pFD->pBuf, pFD->szPage); if (encryptAlgorithm == DND_CA_SM4) { // if(tsiEncryptAlgorithm == DND_CA_SM4 && (tsiEncryptScope & DND_CS_TSDB) == DND_CS_TSDB){ @@ -430,7 +430,7 @@ static int32_t tsdbReadFileS3(STsdbFD *pFD, int64_t offset, uint8_t *pBuf, int64 code = tsdbCacheGetPageS3(pFD->pTsdb->pgCache, pFD, pgno, &handle); if (code != TSDB_CODE_SUCCESS) { if (handle) { - tsdbCacheRelease(pFD->pTsdb->pgCache, handle); + (void)tsdbCacheRelease(pFD->pTsdb->pgCache, handle); } TSDB_CHECK_CODE(code, lino, _exit); } @@ -441,7 +441,7 @@ static int32_t tsdbReadFileS3(STsdbFD *pFD, int64_t offset, uint8_t *pBuf, int64 uint8_t *pPage = (uint8_t *)taosLRUCacheValue(pFD->pTsdb->pgCache, handle); memcpy(pFD->pBuf, pPage, pFD->szPage); - tsdbCacheRelease(pFD->pTsdb->pgCache, handle); + (void)tsdbCacheRelease(pFD->pTsdb->pgCache, handle); // check if (pgno > 1 && !taosCheckChecksumWhole(pFD->pBuf, pFD->szPage)) { @@ -477,7 +477,7 @@ static int32_t tsdbReadFileS3(STsdbFD *pFD, int64_t offset, uint8_t *pBuf, int64 int nPage = pgnoEnd - pgno + 1; for (int i = 0; i < nPage; ++i) { if (pFD->szFile != pgno) { // DONOT cache last volatile page - tsdbCacheSetPageS3(pFD->pTsdb->pgCache, pFD, pgno, pBlock + i * pFD->szPage); + (void)tsdbCacheSetPageS3(pFD->pTsdb->pgCache, pFD, pgno, pBlock + i * pFD->szPage); } if (szHint > 0 && n >= size) { diff --git a/source/dnode/vnode/src/tsdb/tsdbSnapInfo.c b/source/dnode/vnode/src/tsdb/tsdbSnapInfo.c index c9e02c5130..decf276bc6 100644 --- a/source/dnode/vnode/src/tsdb/tsdbSnapInfo.c +++ b/source/dnode/vnode/src/tsdb/tsdbSnapInfo.c @@ -196,7 +196,7 @@ int32_t tsdbFSetPartListToRangeDiff(STsdbFSetPartList* pList, TFileSetRangeArray _err: if (pDiff) { - tsdbTFileSetRangeArrayDestroy(&pDiff); + (void)tsdbTFileSetRangeArrayDestroy(&pDiff); } return code; } diff --git a/source/dnode/vnode/src/tsdb/tsdbSnapshot.c b/source/dnode/vnode/src/tsdb/tsdbSnapshot.c index 3edff5ebcb..2b63d5b6e6 100644 --- a/source/dnode/vnode/src/tsdb/tsdbSnapshot.c +++ b/source/dnode/vnode/src/tsdb/tsdbSnapshot.c @@ -59,7 +59,7 @@ struct STsdbSnapReader { static int32_t tsdbSnapReadFileSetCloseReader(STsdbSnapReader* reader) { TARRAY2_CLEAR(reader->sttReaderArr, tsdbSttFileReaderClose); - tsdbDataFileReaderClose(&reader->dataReader); + TAOS_UNUSED(tsdbDataFileReaderClose(&reader->dataReader)); return 0; } @@ -107,7 +107,7 @@ static int32_t tsdbSnapReadFileSetOpenReader(STsdbSnapReader* reader) { TSDB_CHECK_CODE(code, lino, _exit); if ((code = TARRAY2_APPEND(reader->sttReaderArr, sttReader))) { - tsdbSttFileReaderClose(&sttReader); + TAOS_UNUSED(tsdbSttFileReaderClose(&sttReader)); TSDB_CHECK_CODE(code, lino, _exit); } } @@ -115,7 +115,7 @@ static int32_t tsdbSnapReadFileSetOpenReader(STsdbSnapReader* reader) { _exit: if (code) { - tsdbSnapReadFileSetCloseReader(reader); + TAOS_UNUSED(tsdbSnapReadFileSetCloseReader(reader)); TSDB_ERROR_LOG(TD_VID(reader->tsdb->pVnode), code, lino); } return code; @@ -199,8 +199,8 @@ _exit: } static int32_t tsdbSnapReadFileSetCloseIter(STsdbSnapReader* reader) { - tsdbIterMergerClose(&reader->dataIterMerger); - tsdbIterMergerClose(&reader->tombIterMerger); + TAOS_UNUSED(tsdbIterMergerClose(&reader->dataIterMerger)); + TAOS_UNUSED(tsdbIterMergerClose(&reader->tombIterMerger)); TARRAY2_CLEAR(reader->dataIterArr, tsdbIterClose); TARRAY2_CLEAR(reader->tombIterArr, tsdbIterClose); return 0; @@ -232,8 +232,8 @@ _exit: } static int32_t tsdbSnapReadRangeEnd(STsdbSnapReader* reader) { - tsdbSnapReadFileSetCloseIter(reader); - tsdbSnapReadFileSetCloseReader(reader); + TAOS_UNUSED(tsdbSnapReadFileSetCloseIter(reader)); + TAOS_UNUSED(tsdbSnapReadFileSetCloseReader(reader)); reader->ctx->fsr = NULL; return 0; } @@ -384,7 +384,7 @@ static int32_t tsdbSnapReadTombData(STsdbSnapReader* reader, uint8_t** data) { int32_t lino = 0; SMetaInfo info; - tTombBlockClear(reader->tombBlock); + TAOS_UNUSED(tTombBlockClear(reader->tombBlock)); TABLEID tbid[1] = {0}; for (STombRecord* record; (record = tsdbIterMergerGetTombRecord(reader->tombIterMerger)) != NULL;) { @@ -441,7 +441,7 @@ _exit: if (code) { tsdbError("vgId:%d %s failed at %s:%d since %s, sver:%" PRId64 " ever:%" PRId64 " type:%d", TD_VID(tsdb->pVnode), __func__, __FILE__, lino, tstrerror(code), sver, ever, type); - tsdbTFileSetRangeArrayDestroy(&reader[0]->fsrArr); + TAOS_UNUSED(tsdbTFileSetRangeArrayDestroy(&reader[0]->fsrArr)); taosMemoryFree(reader[0]); reader[0] = NULL; } else { @@ -460,21 +460,21 @@ int32_t tsdbSnapReaderClose(STsdbSnapReader** reader) { STsdb* tsdb = reader[0]->tsdb; - tTombBlockDestroy(reader[0]->tombBlock); + TAOS_UNUSED(tTombBlockDestroy(reader[0]->tombBlock)); tBlockDataDestroy(reader[0]->blockData); - tsdbIterMergerClose(&reader[0]->dataIterMerger); - tsdbIterMergerClose(&reader[0]->tombIterMerger); + TAOS_UNUSED(tsdbIterMergerClose(&reader[0]->dataIterMerger)); + TAOS_UNUSED(tsdbIterMergerClose(&reader[0]->tombIterMerger)); TARRAY2_DESTROY(reader[0]->dataIterArr, tsdbIterClose); TARRAY2_DESTROY(reader[0]->tombIterArr, tsdbIterClose); TARRAY2_DESTROY(reader[0]->sttReaderArr, tsdbSttFileReaderClose); - tsdbDataFileReaderClose(&reader[0]->dataReader); + TAOS_UNUSED(tsdbDataFileReaderClose(&reader[0]->dataReader)); - tsdbFSDestroyRefRangedSnapshot(&reader[0]->fsrArr); + TAOS_UNUSED(tsdbFSDestroyRefRangedSnapshot(&reader[0]->fsrArr)); tDestroyTSchema(reader[0]->skmTb->pTSchema); for (int32_t i = 0; i < ARRAY_SIZE(reader[0]->buffers); ++i) { - tBufferDestroy(reader[0]->buffers + i); + TAOS_UNUSED(tBufferDestroy(reader[0]->buffers + i)); } taosMemoryFree(reader[0]); @@ -706,7 +706,7 @@ _exit: static int32_t tsdbSnapWriteFileSetCloseReader(STsdbSnapWriter* writer) { TARRAY2_CLEAR(writer->ctx->sttReaderArr, tsdbSttFileReaderClose); - tsdbDataFileReaderClose(&writer->ctx->dataReader); + TAOS_UNUSED(tsdbDataFileReaderClose(&writer->ctx->dataReader)); return 0; } @@ -782,8 +782,8 @@ _exit: } static int32_t tsdbSnapWriteFileSetCloseIter(STsdbSnapWriter* writer) { - tsdbIterMergerClose(&writer->ctx->dataIterMerger); - tsdbIterMergerClose(&writer->ctx->tombIterMerger); + TAOS_UNUSED(tsdbIterMergerClose(&writer->ctx->dataIterMerger)); + TAOS_UNUSED(tsdbIterMergerClose(&writer->ctx->tombIterMerger)); TARRAY2_CLEAR(writer->ctx->dataIterArr, tsdbIterClose); TARRAY2_CLEAR(writer->ctx->tombIterArr, tsdbIterClose); return 0; @@ -838,7 +838,7 @@ static int32_t tsdbSnapWriteFileSetBegin(STsdbSnapWriter* writer, int32_t fid) { code = TSDB_CODE_NO_AVAIL_DISK; TSDB_CHECK_CODE(code, lino, _exit); } - tfsMkdirRecurAt(writer->tsdb->pVnode->pTfs, writer->tsdb->path, writer->ctx->did); + TAOS_UNUSED(tfsMkdirRecurAt(writer->tsdb->pVnode->pTfs, writer->tsdb->path, writer->ctx->did)); writer->ctx->hasData = true; writer->ctx->hasTomb = true; @@ -993,7 +993,7 @@ static int32_t tsdbSnapWriteDecmprTombBlock(SSnapDataHdr* hdr, STombBlock* tombB int32_t code = 0; int32_t lino = 0; - tTombBlockClear(tombBlock); + TAOS_UNUSED(tTombBlockClear(tombBlock)); int64_t size = hdr->size; ASSERT(size % TOMB_RECORD_ELEM_NUM == 0); @@ -1140,15 +1140,15 @@ int32_t tsdbSnapWriterClose(STsdbSnapWriter** writer, int8_t rollback) { (void)taosThreadMutexUnlock(&writer[0]->tsdb->mutex); } - tsdbIterMergerClose(&writer[0]->ctx->tombIterMerger); - tsdbIterMergerClose(&writer[0]->ctx->dataIterMerger); + TAOS_UNUSED(tsdbIterMergerClose(&writer[0]->ctx->tombIterMerger)); + TAOS_UNUSED(tsdbIterMergerClose(&writer[0]->ctx->dataIterMerger)); TARRAY2_DESTROY(writer[0]->ctx->tombIterArr, tsdbIterClose); TARRAY2_DESTROY(writer[0]->ctx->dataIterArr, tsdbIterClose); TARRAY2_DESTROY(writer[0]->ctx->sttReaderArr, tsdbSttFileReaderClose); - tsdbDataFileReaderClose(&writer[0]->ctx->dataReader); + TAOS_UNUSED(tsdbDataFileReaderClose(&writer[0]->ctx->dataReader)); TARRAY2_DESTROY(writer[0]->fopArr, NULL); - tsdbFSDestroyCopyRangedSnapshot(&writer[0]->fsetArr); + TAOS_UNUSED(tsdbFSDestroyCopyRangedSnapshot(&writer[0]->fsetArr)); for (int32_t i = 0; i < ARRAY_SIZE(writer[0]->buffers); ++i) { tBufferDestroy(writer[0]->buffers + i); diff --git a/source/dnode/vnode/src/tsdb/tsdbUpgrade.c b/source/dnode/vnode/src/tsdb/tsdbUpgrade.c index 6d2006eaa1..8b55b2bab2 100644 --- a/source/dnode/vnode/src/tsdb/tsdbUpgrade.c +++ b/source/dnode/vnode/src/tsdb/tsdbUpgrade.c @@ -79,7 +79,7 @@ static int32_t tsdbUpgradeHead(STsdb *tsdb, SDFileSet *pDFileSet, SDataFReader * // open fd char fname[TSDB_FILENAME_LEN]; - tsdbTFileName(tsdb, &file, fname); + (void)tsdbTFileName(tsdb, &file, fname); TAOS_CHECK_GOTO(tsdbOpenFile(fname, tsdb, TD_FILE_READ | TD_FILE_WRITE, &ctx->fd, 0), &lino, _exit); @@ -321,7 +321,7 @@ static int32_t tsdbUpgradeStt(STsdb *tsdb, SDFileSet *pDFileSet, SDataFReader *r if (TARRAY2_SIZE(lvl->fobjArr) > 0) { TAOS_CHECK_GOTO(TARRAY2_APPEND(fset->lvlArr, lvl), &lino, _exit); } else { - tsdbSttLvlClear(&lvl); + (void)tsdbSttLvlClear(&lvl); } _exit: From 9f0ec7be291eba2cfea202aa5c664a0307f6a8cf Mon Sep 17 00:00:00 2001 From: dmchen Date: Mon, 29 Jul 2024 03:22:19 +0000 Subject: [PATCH 02/28] fix/TD-30989 --- source/dnode/mnode/impl/src/mndSnode.c | 12 +- source/dnode/mnode/impl/src/mndStb.c | 205 +++++++++++++-------- source/dnode/mnode/impl/src/mndSubscribe.c | 2 +- 3 files changed, 135 insertions(+), 84 deletions(-) diff --git a/source/dnode/mnode/impl/src/mndSnode.c b/source/dnode/mnode/impl/src/mndSnode.c index cca1e71f6a..cd5584022f 100644 --- a/source/dnode/mnode/impl/src/mndSnode.c +++ b/source/dnode/mnode/impl/src/mndSnode.c @@ -223,7 +223,7 @@ static int32_t mndSetCreateSnodeRedoActions(STrans *pTrans, SDnodeObj *pDnode, S code = TSDB_CODE_OUT_OF_MEMORY; TAOS_RETURN(code); } - tSerializeSCreateDropMQSNodeReq(pReq, contLen, &createReq); + (void)tSerializeSCreateDropMQSNodeReq(pReq, contLen, &createReq); STransAction action = {0}; action.epSet = mndGetDnodeEpset(pDnode); @@ -251,7 +251,7 @@ static int32_t mndSetCreateSnodeUndoActions(STrans *pTrans, SDnodeObj *pDnode, S code = TSDB_CODE_OUT_OF_MEMORY; TAOS_RETURN(code); } - tSerializeSCreateDropMQSNodeReq(pReq, contLen, &dropReq); + (void)tSerializeSCreateDropMQSNodeReq(pReq, contLen, &dropReq); STransAction action = {0}; action.epSet = mndGetDnodeEpset(pDnode); @@ -383,7 +383,7 @@ static int32_t mndSetDropSnodeRedoActions(STrans *pTrans, SDnodeObj *pDnode, SSn code = TSDB_CODE_OUT_OF_MEMORY; TAOS_RETURN(code); } - tSerializeSCreateDropMQSNodeReq(pReq, contLen, &dropReq); + (void)tSerializeSCreateDropMQSNodeReq(pReq, contLen, &dropReq); STransAction action = {0}; action.epSet = mndGetDnodeEpset(pDnode); @@ -482,16 +482,16 @@ static int32_t mndRetrieveSnodes(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pB cols = 0; SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)&pObj->id, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pObj->id, false); char ep[TSDB_EP_LEN + VARSTR_HEADER_SIZE] = {0}; STR_WITH_MAXSIZE_TO_VARSTR(ep, pObj->pDnode->ep, pShow->pMeta->pSchemas[cols].bytes); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)ep, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)ep, false); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)&pObj->createdTime, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pObj->createdTime, false); numOfRows++; sdbRelease(pSdb, pObj); diff --git a/source/dnode/mnode/impl/src/mndStb.c b/source/dnode/mnode/impl/src/mndStb.c index 1616d5fac7..960331fc2f 100644 --- a/source/dnode/mnode/impl/src/mndStb.c +++ b/source/dnode/mnode/impl/src/mndStb.c @@ -278,7 +278,7 @@ static SSdbRow *mndStbActionDecode(SSdbRaw *pRaw) { for (int32_t i = 0; i < pStb->numOfFuncs; ++i) { char funcName[TSDB_FUNC_NAME_LEN] = {0}; SDB_GET_BINARY(pRaw, dataPos, funcName, TSDB_FUNC_NAME_LEN, _OVER) - taosArrayPush(pStb->pFuncs, funcName); + (void)taosArrayPush(pStb->pFuncs, funcName); } if (pStb->commentLen > 0) { @@ -479,10 +479,10 @@ void mndReleaseStb(SMnode *pMnode, SStbObj *pStb) { SDbObj *mndAcquireDbByStb(SMnode *pMnode, const char *stbName) { SName name = {0}; - tNameFromString(&name, stbName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); + if ((terrno = tNameFromString(&name, stbName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE)) != 0) return NULL; char db[TSDB_TABLE_FNAME_LEN] = {0}; - tNameGetFullDbName(&name, db); + if ((terrno = tNameGetFullDbName(&name, db)) != 0) return NULL; return mndAcquireDb(pMnode, db); } @@ -503,9 +503,13 @@ void *mndBuildVCreateStbReq(SMnode *pMnode, SVgObj *pVgroup, SStbObj *pStb, int3 SName name = {0}; SVCreateStbReq req = {0}; - tNameFromString(&name, pStb->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); + if ((terrno = tNameFromString(&name, pStb->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE)) != 0) { + goto _err; + } char dbFName[TSDB_DB_FNAME_LEN] = {0}; - tNameGetFullDbName(&name, dbFName); + if ((terrno = tNameGetFullDbName(&name, dbFName)) != 0) { + goto _err; + } req.name = (char *)tNameGetTableName(&name); req.suid = pStb->uid; @@ -600,7 +604,9 @@ static void *mndBuildVDropStbReq(SMnode *pMnode, SVgObj *pVgroup, SStbObj *pStb, SMsgHead *pHead = NULL; SEncoder encoder = {0}; - tNameFromString(&name, pStb->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); + if ((terrno = tNameFromString(&name, pStb->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE)) != 0) { + return NULL; + } req.name = (char *)tNameGetTableName(&name); req.suid = pStb->uid; @@ -621,7 +627,7 @@ static void *mndBuildVDropStbReq(SMnode *pMnode, SVgObj *pVgroup, SStbObj *pStb, void *pBuf = POINTER_SHIFT(pHead, sizeof(SMsgHead)); tEncoderInit(&encoder, pBuf, contLen - sizeof(SMsgHead)); - tEncodeSVDropStbReq(&encoder, &req); + (void)tEncodeSVDropStbReq(&encoder, &req); tEncoderClear(&encoder); *pContLen = contLen; @@ -948,7 +954,9 @@ int32_t mndBuildStbFromReq(SMnode *pMnode, SStbObj *pDst, SMCreateStbReq *pCreat } static int32_t mndGenIdxNameForFirstTag(char *fullname, char *dbname, char *stbname, char *tagname) { SName name = {0}; - tNameFromString(&name, stbname, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); + if ((terrno = tNameFromString(&name, stbname, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE)) != 0) { + return -1; + } return snprintf(fullname, TSDB_INDEX_FNAME_LEN, "%s.%s_%s", dbname, tagname, tNameGetTableName(&name)); } @@ -969,7 +977,9 @@ static int32_t mndCreateStb(SMnode *pMnode, SRpcMsg *pReq, SMCreateStbReq *pCrea TAOS_CHECK_GOTO(mndBuildStbFromReq(pMnode, &stbObj, pCreate, pDb), NULL, _OVER); SSchema *pSchema = &(stbObj.pTags[0]); - mndGenIdxNameForFirstTag(fullIdxName, pDb->name, stbObj.name, pSchema->name); + if (mndGenIdxNameForFirstTag(fullIdxName, pDb->name, stbObj.name, pSchema->name) < 0) { + goto _OVER; + } SSIdx idx = {0}; if (mndAcquireGlobalIdx(pMnode, fullIdxName, SDB_IDX, &idx) == 0 && idx.pIdx != NULL) { code = TSDB_CODE_MND_TAG_INDEX_ALREADY_EXIST; @@ -995,7 +1005,7 @@ static int32_t mndCreateStb(SMnode *pMnode, SRpcMsg *pReq, SMCreateStbReq *pCrea _OVER: mndTransDrop(pTrans); - mndStbActionDelete(pMnode->pSdb, &stbObj); + (void)mndStbActionDelete(pMnode->pSdb, &stbObj); TAOS_RETURN(code); } @@ -1031,7 +1041,7 @@ static int32_t mndProcessTtlTimer(SRpcMsg *pReq) { } pHead->contLen = htonl(contLen); pHead->vgId = htonl(pVgroup->vgId); - tSerializeSVDropTtlTableReq((char *)pHead + sizeof(SMsgHead), reqLen, &ttlReq); + (void)tSerializeSVDropTtlTableReq((char *)pHead + sizeof(SMsgHead), reqLen, &ttlReq); SRpcMsg rpcMsg = { .msgType = TDMT_VND_FETCH_TTL_EXPIRED_TBS, .pCont = pHead, .contLen = contLen, .info = pReq->info}; @@ -1069,7 +1079,7 @@ static int32_t mndProcessTrimDbTimer(SRpcMsg *pReq) { } pHead->contLen = htonl(contLen); pHead->vgId = htonl(pVgroup->vgId); - tSerializeSVTrimDbReq((char *)pHead + sizeof(SMsgHead), reqLen, &trimReq); + (void)tSerializeSVTrimDbReq((char *)pHead + sizeof(SMsgHead), reqLen, &trimReq); SRpcMsg rpcMsg = {.msgType = TDMT_VND_TRIM, .pCont = pHead, .contLen = contLen}; SEpSet epSet = mndGetVgroupEpset(pMnode, pVgroup); @@ -1106,7 +1116,7 @@ static int32_t mndProcessS3MigrateDbTimer(SRpcMsg *pReq) { } pHead->contLen = htonl(contLen); pHead->vgId = htonl(pVgroup->vgId); - tSerializeSVS3MigrateDbReq((char *)pHead + sizeof(SMsgHead), reqLen, &s3migrateReq); + (void)tSerializeSVS3MigrateDbReq((char *)pHead + sizeof(SMsgHead), reqLen, &s3migrateReq); SRpcMsg rpcMsg = {.msgType = TDMT_VND_S3MIGRATE, .pCont = pHead, .contLen = contLen}; SEpSet epSet = mndGetVgroupEpset(pMnode, pVgroup); @@ -1335,7 +1345,7 @@ static int32_t mndProcessCreateStbReq(SRpcMsg *pReq) { if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS; SName name = {0}; - tNameFromString(&name, createReq.name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); + TAOS_CHECK_RETURN(tNameFromString(&name, createReq.name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE)); if (createReq.sql == NULL && createReq.sqlLen == 0) { char detail[1000] = {0}; @@ -1499,7 +1509,12 @@ static int32_t mndCheckAlterColForTopic(SMnode *pMnode, const char *stbFullName, } SNodeList *pNodeList = NULL; - nodesCollectColumns((SSelectStmt *)pAst, SQL_CLAUSE_FROM, NULL, COLLECT_COL_TYPE_ALL, &pNodeList); + if ((code = nodesCollectColumns((SSelectStmt *)pAst, SQL_CLAUSE_FROM, NULL, COLLECT_COL_TYPE_ALL, &pNodeList)) != + 0) { + sdbRelease(pSdb, pTopic); + sdbCancelFetch(pSdb, pIter); + TAOS_RETURN(code); + } SNode *pNode = NULL; FOREACH(pNode, pNodeList) { SColumnNode *pCol = (SColumnNode *)pNode; @@ -1549,7 +1564,13 @@ static int32_t mndCheckAlterColForStream(SMnode *pMnode, const char *stbFullName } SNodeList *pNodeList = NULL; - nodesCollectColumns((SSelectStmt *)pAst, SQL_CLAUSE_FROM, NULL, COLLECT_COL_TYPE_ALL, &pNodeList); + if ((code = nodesCollectColumns((SSelectStmt *)pAst, SQL_CLAUSE_FROM, NULL, COLLECT_COL_TYPE_ALL, &pNodeList)) != + 0) { + sdbRelease(pSdb, pStream); + sdbCancelFetch(pSdb, pIter); + TAOS_RETURN(code); + } + SNode *pNode = NULL; FOREACH(pNode, pNodeList) { SColumnNode *pCol = (SColumnNode *)pNode; @@ -1600,7 +1621,11 @@ static int32_t mndCheckAlterColForTSma(SMnode *pMnode, const char *stbFullName, } SNodeList *pNodeList = NULL; - nodesCollectColumns((SSelectStmt *)pAst, SQL_CLAUSE_FROM, NULL, COLLECT_COL_TYPE_ALL, &pNodeList); + if ((code = nodesCollectColumns((SSelectStmt *)pAst, SQL_CLAUSE_FROM, NULL, COLLECT_COL_TYPE_ALL, &pNodeList)) != + 0) { + sdbCancelFetch(pSdb, pIter); + TAOS_RETURN(code); + } SNode *pNode = NULL; FOREACH(pNode, pNodeList) { SColumnNode *pCol = (SColumnNode *)pNode; @@ -2291,7 +2316,7 @@ static int32_t mndBuildSMAlterStbRsp(SDbObj *pDb, SStbObj *pObj, void **pCont, i uint32_t contLen = 0; SMAlterStbRsp alterRsp = {0}; SName name = {0}; - tNameFromString(&name, pObj->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); + TAOS_CHECK_RETURN(tNameFromString(&name, pObj->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE)); alterRsp.pMeta = taosMemoryCalloc(1, sizeof(STableMetaRsp)); if (NULL == alterRsp.pMeta) { @@ -2313,7 +2338,7 @@ static int32_t mndBuildSMAlterStbRsp(SDbObj *pDb, SStbObj *pObj, void **pCont, i void *cont = taosMemoryMalloc(contLen); tEncoderInit(&ec, cont, contLen); - tEncodeSMAlterStbRsp(&ec, &alterRsp); + (void)tEncodeSMAlterStbRsp(&ec, &alterRsp); tEncoderClear(&ec); tFreeSMAlterStbRsp(&alterRsp); @@ -2344,7 +2369,7 @@ int32_t mndBuildSMCreateStbRsp(SMnode *pMnode, char *dbFName, char *stbFName, vo uint32_t contLen = 0; SMCreateStbRsp stbRsp = {0}; SName name = {0}; - tNameFromString(&name, pObj->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); + TAOS_CHECK_GOTO(tNameFromString(&name, pObj->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE), NULL, _OVER); stbRsp.pMeta = taosMemoryCalloc(1, sizeof(STableMetaRsp)); if (NULL == stbRsp.pMeta) { @@ -2366,7 +2391,7 @@ int32_t mndBuildSMCreateStbRsp(SMnode *pMnode, char *dbFName, char *stbFName, vo void *cont = taosMemoryMalloc(contLen); tEncoderInit(&ec, cont, contLen); - tEncodeSMCreateStbRsp(&ec, &stbRsp); + (void)tEncodeSMCreateStbRsp(&ec, &stbRsp); tEncoderClear(&ec); tFreeSMCreateStbRsp(&stbRsp); @@ -2605,7 +2630,7 @@ static int32_t mndProcessAlterStbReq(SRpcMsg *pReq) { if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS; SName name = {0}; - tNameFromString(&name, alterReq.name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); + TAOS_CHECK_GOTO(tNameFromString(&name, alterReq.name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE), NULL, _OVER); auditRecord(pReq, pMnode->clusterId, "alterStb", name.dbname, name.tname, alterReq.sql, alterReq.sqlLen); @@ -2755,7 +2780,12 @@ static int32_t mndCheckDropStbForTopic(SMnode *pMnode, const char *stbFullName, } SNodeList *pNodeList = NULL; - nodesCollectColumns((SSelectStmt *)pAst, SQL_CLAUSE_FROM, NULL, COLLECT_COL_TYPE_ALL, &pNodeList); + if ((code = nodesCollectColumns((SSelectStmt *)pAst, SQL_CLAUSE_FROM, NULL, COLLECT_COL_TYPE_ALL, &pNodeList)) != + 0) { + sdbRelease(pSdb, pTopic); + sdbCancelFetch(pSdb, pIter); + TAOS_RETURN(code); + } SNode *pNode = NULL; FOREACH(pNode, pNodeList) { SColumnNode *pCol = (SColumnNode *)pNode; @@ -2803,7 +2833,12 @@ static int32_t mndCheckDropStbForStream(SMnode *pMnode, const char *stbFullName, } SNodeList *pNodeList = NULL; - nodesCollectColumns((SSelectStmt *)pAst, SQL_CLAUSE_FROM, NULL, COLLECT_COL_TYPE_ALL, &pNodeList); + if ((code = nodesCollectColumns((SSelectStmt *)pAst, SQL_CLAUSE_FROM, NULL, COLLECT_COL_TYPE_ALL, &pNodeList)) != + 0) { + sdbCancelFetch(pSdb, pIter); + sdbRelease(pSdb, pStream); + TAOS_RETURN(code); + } SNode *pNode = NULL; FOREACH(pNode, pNodeList) { SColumnNode *pCol = (SColumnNode *)pNode; @@ -2882,7 +2917,7 @@ static int32_t mndProcessDropStbReq(SRpcMsg *pReq) { if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS; SName name = {0}; - tNameFromString(&name, dropReq.name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); + TAOS_CHECK_GOTO(tNameFromString(&name, dropReq.name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE), NULL, _OVER); auditRecord(pReq, pMnode->clusterId, "dropStb", name.dbname, name.tname, dropReq.sql, dropReq.sqlLen); @@ -2933,7 +2968,7 @@ static int32_t mndProcessTableMetaReq(SRpcMsg *pReq) { goto _OVER; } - tSerializeSTableMetaRsp(pRsp, rspLen, &metaRsp); + (void)tSerializeSTableMetaRsp(pRsp, rspLen, &metaRsp); pReq->info.rsp = pRsp; pReq->info.rspLen = rspLen; code = 0; @@ -2984,7 +3019,7 @@ static int32_t mndProcessTableCfgReq(SRpcMsg *pReq) { goto _OVER; } - tSerializeSTableCfgRsp(pRsp, rspLen, &cfgRsp); + (void)tSerializeSTableCfgRsp(pRsp, rspLen, &cfgRsp); pReq->info.rsp = pRsp; pReq->info.rspLen = rspLen; code = 0; @@ -3034,7 +3069,7 @@ int32_t mndValidateStbInfo(SMnode *pMnode, SSTableVersion *pStbVersions, int32_t tstrncpy(metaRsp.dbFName, pStbVersion->dbFName, sizeof(metaRsp.dbFName)); tstrncpy(metaRsp.tbName, pStbVersion->stbName, sizeof(metaRsp.tbName)); tstrncpy(metaRsp.stbName, pStbVersion->stbName, sizeof(metaRsp.stbName)); - taosArrayPush(hbRsp.pMetaRsp, &metaRsp); + (void)taosArrayPush(hbRsp.pMetaRsp, &metaRsp); continue; } @@ -3047,11 +3082,11 @@ int32_t mndValidateStbInfo(SMnode *pMnode, SSTableVersion *pStbVersions, int32_t tstrncpy(metaRsp.dbFName, pStbVersion->dbFName, sizeof(metaRsp.dbFName)); tstrncpy(metaRsp.tbName, pStbVersion->stbName, sizeof(metaRsp.tbName)); tstrncpy(metaRsp.stbName, pStbVersion->stbName, sizeof(metaRsp.stbName)); - taosArrayPush(hbRsp.pMetaRsp, &metaRsp); + (void)taosArrayPush(hbRsp.pMetaRsp, &metaRsp); continue; } - taosArrayPush(hbRsp.pMetaRsp, &metaRsp); + (void)taosArrayPush(hbRsp.pMetaRsp, &metaRsp); } if (sma) { @@ -3075,7 +3110,7 @@ int32_t mndValidateStbInfo(SMnode *pMnode, SSTableVersion *pStbVersions, int32_t strcpy(indexRsp.dbFName, pStbVersion->dbFName); strcpy(indexRsp.tbName, pStbVersion->stbName); - taosArrayPush(hbRsp.pIndexRsp, &indexRsp); + (void)taosArrayPush(hbRsp.pIndexRsp, &indexRsp); } } @@ -3093,7 +3128,7 @@ int32_t mndValidateStbInfo(SMnode *pMnode, SSTableVersion *pStbVersions, int32_t TAOS_RETURN(code); } - tSerializeSSTbHbRsp(pRsp, rspLen, &hbRsp); + (void)tSerializeSSTbHbRsp(pRsp, rspLen, &hbRsp); tFreeSSTbHbRsp(&hbRsp); *ppRsp = pRsp; *pRspLen = rspLen; @@ -3130,23 +3165,23 @@ int32_t mndGetNumOfStbs(SMnode *pMnode, char *dbName, int32_t *pNumOfStbs) { void mndExtractDbNameFromStbFullName(const char *stbFullName, char *dst) { SName name = {0}; - tNameFromString(&name, stbFullName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); + (void)tNameFromString(&name, stbFullName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); - tNameGetFullDbName(&name, dst); + (void)tNameGetFullDbName(&name, dst); } void mndExtractShortDbNameFromStbFullName(const char *stbFullName, char *dst) { SName name = {0}; - tNameFromString(&name, stbFullName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); + (void)tNameFromString(&name, stbFullName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); - tNameGetDbName(&name, dst); + (void)tNameGetDbName(&name, dst); } void mndExtractShortDbNameFromDbFullName(const char *stbFullName, char *dst) { SName name = {0}; - tNameFromString(&name, stbFullName, T_NAME_ACCT | T_NAME_DB); + (void)tNameFromString(&name, stbFullName, T_NAME_ACCT | T_NAME_DB); - tNameGetDbName(&name, dst); + (void)tNameGetDbName(&name, dst); } void mndExtractTbNameFromStbFullName(const char *stbFullName, char *dst, int32_t dstSize) { @@ -3473,37 +3508,37 @@ static int32_t mndRetrieveStb(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBloc varDataSetLen(stbName, strlen(&stbName[VARSTR_HEADER_SIZE])); SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)stbName, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)stbName, false); char db[TSDB_DB_NAME_LEN + VARSTR_HEADER_SIZE] = {0}; - tNameFromString(&name, pStb->db, T_NAME_ACCT | T_NAME_DB); - tNameGetDbName(&name, varDataVal(db)); + (void)tNameFromString(&name, pStb->db, T_NAME_ACCT | T_NAME_DB); + (void)tNameGetDbName(&name, varDataVal(db)); varDataSetLen(db, strlen(varDataVal(db))); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)db, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)db, false); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)&pStb->createdTime, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pStb->createdTime, false); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)&pStb->numOfColumns, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pStb->numOfColumns, false); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)&pStb->numOfTags, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pStb->numOfTags, false); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)&pStb->updateTime, false); // number of tables + (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pStb->updateTime, false); // number of tables pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); if (pStb->commentLen > 0) { char comment[TSDB_TB_COMMENT_LEN + VARSTR_HEADER_SIZE] = {0}; STR_TO_VARSTR(comment, pStb->comment); - colDataSetVal(pColInfo, numOfRows, comment, false); + (void)colDataSetVal(pColInfo, numOfRows, comment, false); } else if (pStb->commentLen == 0) { char comment[VARSTR_HEADER_SIZE + VARSTR_HEADER_SIZE] = {0}; STR_TO_VARSTR(comment, ""); - colDataSetVal(pColInfo, numOfRows, comment, false); + (void)colDataSetVal(pColInfo, numOfRows, comment, false); } else { colDataSetNULL(pColInfo, numOfRows); } @@ -3513,14 +3548,14 @@ static int32_t mndRetrieveStb(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBloc varDataSetLen(watermark, strlen(varDataVal(watermark))); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)watermark, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)watermark, false); char maxDelay[64 + VARSTR_HEADER_SIZE] = {0}; sprintf(varDataVal(maxDelay), "%" PRId64 "a,%" PRId64 "a", pStb->maxdelay[0], pStb->maxdelay[1]); varDataSetLen(maxDelay, strlen(varDataVal(maxDelay))); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)maxDelay, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)maxDelay, false); char rollup[160 + VARSTR_HEADER_SIZE] = {0}; int32_t rollupNum = (int32_t)taosArrayGetSize(pStb->pFuncs); @@ -3530,16 +3565,16 @@ static int32_t mndRetrieveStb(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBloc for (int32_t i = 0; i < rollupNum; ++i) { char *funcName = taosArrayGet(pStb->pFuncs, i); if (i) { - strncat(varDataVal(rollup), sep, rollupLen); + (void)strncat(varDataVal(rollup), sep, rollupLen); rollupLen -= sepLen; } - strncat(varDataVal(rollup), funcName, rollupLen); + (void)strncat(varDataVal(rollup), funcName, rollupLen); rollupLen -= strlen(funcName); } varDataSetLen(rollup, strlen(varDataVal(rollup))); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)rollup, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)rollup, false); numOfRows++; sdbRelease(pSdb, pStb); @@ -3577,20 +3612,20 @@ static int32_t buildDbColsInfoBlock(const SSDataBlock *p, const SSysTableMeta *p for (int32_t j = 0; j < pm->colNum; j++) { // table name SColumnInfoData *pColInfoData = taosArrayGet(p->pDataBlock, 0); - colDataSetVal(pColInfoData, numOfRows, tName, false); + (void)colDataSetVal(pColInfoData, numOfRows, tName, false); // database name pColInfoData = taosArrayGet(p->pDataBlock, 1); - colDataSetVal(pColInfoData, numOfRows, dName, false); + (void)colDataSetVal(pColInfoData, numOfRows, dName, false); pColInfoData = taosArrayGet(p->pDataBlock, 2); - colDataSetVal(pColInfoData, numOfRows, typeName, false); + (void)colDataSetVal(pColInfoData, numOfRows, typeName, false); // col name char colName[TSDB_COL_NAME_LEN + VARSTR_HEADER_SIZE] = {0}; STR_TO_VARSTR(colName, pm->schema[j].name); pColInfoData = taosArrayGet(p->pDataBlock, 3); - colDataSetVal(pColInfoData, numOfRows, colName, false); + (void)colDataSetVal(pColInfoData, numOfRows, colName, false); // col type int8_t colType = pm->schema[j].type; @@ -3605,10 +3640,10 @@ static int32_t buildDbColsInfoBlock(const SSDataBlock *p, const SSysTableMeta *p (int32_t)((pm->schema[j].bytes - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE)); } varDataSetLen(colTypeStr, colTypeLen); - colDataSetVal(pColInfoData, numOfRows, (char *)colTypeStr, false); + (void)colDataSetVal(pColInfoData, numOfRows, (char *)colTypeStr, false); pColInfoData = taosArrayGet(p->pDataBlock, 5); - colDataSetVal(pColInfoData, numOfRows, (const char *)&pm->schema[j].bytes, false); + (void)colDataSetVal(pColInfoData, numOfRows, (const char *)&pm->schema[j].bytes, false); for (int32_t k = 6; k <= 8; ++k) { pColInfoData = taosArrayGet(p->pDataBlock, k); colDataSetNULL(pColInfoData, numOfRows); @@ -3724,26 +3759,26 @@ static int32_t mndRetrieveStbCol(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pB mDebug("mndRetrieveStbCol get stable cols, stable name:%s, db:%s", pStb->name, pStb->db); char db[TSDB_DB_NAME_LEN + VARSTR_HEADER_SIZE] = {0}; - tNameFromString(&name, pStb->db, T_NAME_ACCT | T_NAME_DB); - tNameGetDbName(&name, varDataVal(db)); + (void)tNameFromString(&name, pStb->db, T_NAME_ACCT | T_NAME_DB); + (void)tNameGetDbName(&name, varDataVal(db)); varDataSetLen(db, strlen(varDataVal(db))); for (int i = 0; i < pStb->numOfColumns; i++) { int32_t cols = 0; SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)stbName, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)stbName, false); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)db, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)db, false); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, typeName, false); + (void)colDataSetVal(pColInfo, numOfRows, typeName, false); // col name char colName[TSDB_COL_NAME_LEN + VARSTR_HEADER_SIZE] = {0}; STR_TO_VARSTR(colName, pStb->pColumns[i].name); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, colName, false); + (void)colDataSetVal(pColInfo, numOfRows, colName, false); // col type int8_t colType = pStb->pColumns[i].type; @@ -3758,10 +3793,10 @@ static int32_t mndRetrieveStbCol(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pB (int32_t)((pStb->pColumns[i].bytes - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE)); } varDataSetLen(colTypeStr, colTypeLen); - colDataSetVal(pColInfo, numOfRows, (char *)colTypeStr, false); + (void)colDataSetVal(pColInfo, numOfRows, (char *)colTypeStr, false); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)&pStb->pColumns[i].bytes, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pStb->pColumns[i].bytes, false); while (cols < pShow->numOfColumns) { pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); colDataSetNULL(pColInfo, numOfRows); @@ -4064,7 +4099,7 @@ static void *mndBuildVDropTbsReq(SMnode *pMnode, const SVgroupInfo *pVgInfo, con void *pBuf = POINTER_SHIFT(pHead, sizeof(SMsgHead)); tEncoderInit(&encoder, pBuf, contLen - sizeof(SMsgHead)); - tEncodeSVDropTbBatchReq(&encoder, pReq); + (void)tEncodeSVDropTbBatchReq(&encoder, pReq); tEncoderClear(&encoder); *len = contLen; @@ -4155,10 +4190,19 @@ static int32_t mndDropTbAdd(SMnode *pMnode, SHashObj *pVgHashMap, const SVgroupI if (pReqs == NULL) { reqs.info = *pVgInfo; reqs.req.pArray = taosArrayInit(TARRAY_MIN_SIZE, sizeof(SVDropTbReq)); - taosArrayPush(reqs.req.pArray, &req); - taosHashPut(pVgHashMap, &pVgInfo->vgId, sizeof(pVgInfo->vgId), &reqs, sizeof(reqs)); + if (reqs.req.pArray == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } + if (taosArrayPush(reqs.req.pArray, &req) == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } + if (taosHashPut(pVgHashMap, &pVgInfo->vgId, sizeof(pVgInfo->vgId), &reqs, sizeof(reqs)) != 0) { + return TSDB_CODE_OUT_OF_MEMORY; + } } else { - taosArrayPush(pReqs->req.pArray, &req); + if (taosArrayPush(pReqs->req.pArray, &req) == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } } return 0; } @@ -4231,7 +4275,10 @@ static int32_t mndDropTbAddTsmaResTbsForSingleVg(SMnode *pMnode, SMndDropTbsWith code = TSDB_CODE_OUT_OF_MEMORY; goto _end; } - taosHashPut(pCtx->pTsmaMap, &pTb->suid, sizeof(pTb->suid), &infos, sizeof(infos)); + if (taosHashPut(pCtx->pTsmaMap, &pTb->suid, sizeof(pTb->suid), &infos, sizeof(infos)) != 0) { + code = TSDB_CODE_OUT_OF_MEMORY; + goto _end; + } } } @@ -4258,11 +4305,15 @@ static int32_t mndDropTbAddTsmaResTbsForSingleVg(SMnode *pMnode, SMndDropTbsWith sdbRelease(pMnode->pSdb, pSma); goto _end; } - taosHashPut(pCtx->pDbMap, pSma->db, TSDB_DB_FNAME_LEN, &info.dbInfo, sizeof(SMDropTbDbInfo)); + if (taosHashPut(pCtx->pDbMap, pSma->db, TSDB_DB_FNAME_LEN, &info.dbInfo, sizeof(SMDropTbDbInfo)) != 0) { + sdbCancelFetch(pMnode->pSdb, pIter); + sdbRelease(pMnode->pSdb, pSma); + goto _end; + } } else { info.dbInfo = *pDbInfo; } - taosArrayPush(pInfos->pTsmaInfos, &info); + (void)taosArrayPush(pInfos->pTsmaInfos, &info); } sdbRelease(pMnode->pSdb, pSma); } @@ -4270,7 +4321,7 @@ static int32_t mndDropTbAddTsmaResTbsForSingleVg(SMnode *pMnode, SMndDropTbsWith // generate vg req map for (int32_t i = 0; i < pTbs->size; ++i) { SVDropTbReq *pTb = taosArrayGet(pTbs, i); - mndDropTbAdd(pMnode, pCtx->pVgMap, &vgInfo, pTb->name, pTb->suid, pTb->igNotExists); + TAOS_CHECK_GOTO(mndDropTbAdd(pMnode, pCtx->pVgMap, &vgInfo, pTb->name, pTb->suid, pTb->igNotExists), NULL, _end); SMDropTbTsmaInfos *pInfos = taosHashGet(pCtx->pTsmaMap, &pTb->suid, sizeof(pTb->suid)); SArray *pVgInfos = NULL; @@ -4282,8 +4333,8 @@ static int32_t mndDropTbAddTsmaResTbsForSingleVg(SMnode *pMnode, SMndDropTbsWith taosGetTbHashVal(buf, len, pInfo->dbInfo.hashMethod, pInfo->dbInfo.hashPrefix, pInfo->dbInfo.hashSuffix); const SVgroupInfo *pVgInfo = taosArraySearch(pInfo->dbInfo.dbVgInfos, &hashVal, vgHashValCmp, TD_EQ); void *p = taosStrdup(buf + strlen(pInfo->tsmaResTbDbFName) + TSDB_NAME_DELIMITER_LEN); - taosArrayPush(pCtx->pResTbNames, &p); - mndDropTbAdd(pMnode, pCtx->pVgMap, pVgInfo, p, pInfo->suid, true); + (void)taosArrayPush(pCtx->pResTbNames, &p); + TAOS_CHECK_GOTO(mndDropTbAdd(pMnode, pCtx->pVgMap, pVgInfo, p, pInfo->suid, true), NULL, _end); } } _end: diff --git a/source/dnode/mnode/impl/src/mndSubscribe.c b/source/dnode/mnode/impl/src/mndSubscribe.c index bb59af2808..d45346516b 100644 --- a/source/dnode/mnode/impl/src/mndSubscribe.c +++ b/source/dnode/mnode/impl/src/mndSubscribe.c @@ -1375,7 +1375,7 @@ static int32_t buildResult(SSDataBlock *pBlock, int32_t *numOfRows, int64_t cons if (data) { // vg id char buf[TSDB_OFFSET_LEN * 2 + VARSTR_HEADER_SIZE] = {0}; - tFormatOffset(varDataVal(buf), TSDB_OFFSET_LEN, &data->offset); + (void)tFormatOffset(varDataVal(buf), TSDB_OFFSET_LEN, &data->offset); (void)sprintf(varDataVal(buf) + strlen(varDataVal(buf)), "/%" PRId64, data->ever); varDataSetLen(buf, strlen(varDataVal(buf))); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); From de557c92f0adb9a86b0a22d955e7423ae5753c2b Mon Sep 17 00:00:00 2001 From: dmchen Date: Mon, 29 Jul 2024 05:16:21 +0000 Subject: [PATCH 03/28] fix/TD-30989 --- source/libs/sync/src/syncEnv.c | 12 +-- source/libs/sync/src/syncMain.c | 143 ++++++++++++++++---------------- 2 files changed, 79 insertions(+), 76 deletions(-) diff --git a/source/libs/sync/src/syncEnv.c b/source/libs/sync/src/syncEnv.c index cce8149037..8d1e2cfebd 100644 --- a/source/libs/sync/src/syncEnv.c +++ b/source/libs/sync/src/syncEnv.c @@ -69,13 +69,13 @@ void syncCleanUp() { if (gNodeRefId != -1) { sDebug("sync rsetId:%d is closed", gNodeRefId); - taosCloseRef(gNodeRefId); + (void)taosCloseRef(gNodeRefId); gNodeRefId = -1; } if (gHbDataRefId != -1) { sDebug("sync rsetId:%d is closed", gHbDataRefId); - taosCloseRef(gHbDataRefId); + (void)taosCloseRef(gHbDataRefId); gHbDataRefId = -1; } } @@ -88,7 +88,7 @@ int64_t syncNodeAdd(SSyncNode *pNode) { return pNode->rid; } -void syncNodeRemove(int64_t rid) { taosRemoveRef(gNodeRefId, rid); } +void syncNodeRemove(int64_t rid) { (void)taosRemoveRef(gNodeRefId, rid); } SSyncNode *syncNodeAcquire(int64_t rid) { SSyncNode *pNode = taosAcquireRef(gNodeRefId, rid); @@ -101,7 +101,7 @@ SSyncNode *syncNodeAcquire(int64_t rid) { } void syncNodeRelease(SSyncNode *pNode) { - if (pNode) taosReleaseRef(gNodeRefId, pNode->rid); + if (pNode) (void)taosReleaseRef(gNodeRefId, pNode->rid); } int64_t syncHbTimerDataAdd(SSyncHbTimerData *pData) { @@ -110,7 +110,7 @@ int64_t syncHbTimerDataAdd(SSyncHbTimerData *pData) { return pData->rid; } -void syncHbTimerDataRemove(int64_t rid) { taosRemoveRef(gHbDataRefId, rid); } +void syncHbTimerDataRemove(int64_t rid) { (void)taosRemoveRef(gHbDataRefId, rid); } SSyncHbTimerData *syncHbTimerDataAcquire(int64_t rid) { SSyncHbTimerData *pData = taosAcquireRef(gHbDataRefId, rid); @@ -122,7 +122,7 @@ SSyncHbTimerData *syncHbTimerDataAcquire(int64_t rid) { return pData; } -void syncHbTimerDataRelease(SSyncHbTimerData *pData) { taosReleaseRef(gHbDataRefId, pData->rid); } +void syncHbTimerDataRelease(SSyncHbTimerData *pData) { (void)taosReleaseRef(gHbDataRefId, pData->rid); } #if 0 void syncEnvStartTimer() { diff --git a/source/libs/sync/src/syncMain.c b/source/libs/sync/src/syncMain.c index f93b52dd2a..db1b4ff486 100644 --- a/source/libs/sync/src/syncMain.c +++ b/source/libs/sync/src/syncMain.c @@ -181,17 +181,17 @@ int32_t syncReconfig(int64_t rid, SSyncCfg* pNewCfg) { TAOS_RETURN(code); } - syncNodeUpdateNewConfigIndex(pSyncNode, pNewCfg); + TAOS_CHECK_RETURN(syncNodeUpdateNewConfigIndex(pSyncNode, pNewCfg)); syncNodeDoConfigChange(pSyncNode, pNewCfg, pNewCfg->lastIndex); if (pSyncNode->state == TAOS_SYNC_STATE_LEADER || pSyncNode->state == TAOS_SYNC_STATE_ASSIGNED_LEADER) { - syncNodeStopHeartbeatTimer(pSyncNode); + TAOS_CHECK_RETURN(syncNodeStopHeartbeatTimer(pSyncNode)); for (int32_t i = 0; i < TSDB_MAX_REPLICA + TSDB_MAX_LEARNER_REPLICA; ++i) { - syncHbTimerInit(pSyncNode, &pSyncNode->peerHeartbeatTimerArr[i], pSyncNode->replicasId[i]); + TAOS_CHECK_RETURN(syncHbTimerInit(pSyncNode, &pSyncNode->peerHeartbeatTimerArr[i], pSyncNode->replicasId[i])); } - syncNodeStartHeartbeatTimer(pSyncNode); + TAOS_CHECK_RETURN(syncNodeStartHeartbeatTimer(pSyncNode)); // syncNodeReplicate(pSyncNode); } @@ -394,8 +394,7 @@ int32_t syncSendTimeoutRsp(int64_t rid, int64_t seq) { syncNodeRelease(pNode); if (ret == 1) { sInfo("send timeout response, seq:%" PRId64 " handle:%p ahandle:%p", seq, rpcMsg.info.handle, rpcMsg.info.ahandle); - rpcSendResponse(&rpcMsg); - return 0; + return rpcSendResponse(&rpcMsg); } else { sError("no message handle to send timeout response, seq:%" PRId64, seq); return TSDB_CODE_SYN_INTERNAL_ERROR; @@ -674,9 +673,9 @@ int32_t syncGetArbToken(int64_t rid, char* outToken) { } memset(outToken, 0, TSDB_ARB_TOKEN_SIZE); - taosThreadMutexLock(&pSyncNode->arbTokenMutex); + (void)taosThreadMutexLock(&pSyncNode->arbTokenMutex); strncpy(outToken, pSyncNode->arbToken, TSDB_ARB_TOKEN_SIZE); - taosThreadMutexUnlock(&pSyncNode->arbTokenMutex); + (void)taosThreadMutexUnlock(&pSyncNode->arbTokenMutex); syncNodeRelease(pSyncNode); TAOS_RETURN(code); @@ -956,8 +955,9 @@ static int32_t syncHbTimerStart(SSyncNode* pSyncNode, SSyncTimer* pSyncTimer) { sTrace("vgId:%d, start hb timer, rid:%" PRId64 " addr:%" PRId64, pSyncNode->vgId, pData->rid, pData->destId.addr); - taosTmrReset(pSyncTimer->timerCb, pSyncTimer->timerMS / HEARTBEAT_TICK_NUM, (void*)(pData->rid), - syncEnv()->pTimerManager, &pSyncTimer->pTimer); + if (!taosTmrReset(pSyncTimer->timerCb, pSyncTimer->timerMS / HEARTBEAT_TICK_NUM, (void*)(pData->rid), + syncEnv()->pTimerManager, &pSyncTimer->pTimer)) + return TSDB_CODE_SYN_INTERNAL_ERROR; } else { ret = TSDB_CODE_SYN_INTERNAL_ERROR; sError("vgId:%d, start ctrl hb timer error, sync env is stop", pSyncNode->vgId); @@ -967,7 +967,7 @@ static int32_t syncHbTimerStart(SSyncNode* pSyncNode, SSyncTimer* pSyncTimer) { static int32_t syncHbTimerStop(SSyncNode* pSyncNode, SSyncTimer* pSyncTimer) { int32_t ret = 0; - atomic_add_fetch_64(&pSyncTimer->logicClock, 1); + (void)atomic_add_fetch_64(&pSyncTimer->logicClock, 1); if (!taosTmrStop(pSyncTimer->pTimer)) { return TSDB_CODE_SYN_INTERNAL_ERROR; } @@ -983,7 +983,7 @@ int32_t syncNodeLogStoreRestoreOnNeed(SSyncNode* pNode) { ASSERTS(pNode->pFsm != NULL, "pFsm not registered"); ASSERTS(pNode->pFsm->FpGetSnapshotInfo != NULL, "FpGetSnapshotInfo not registered"); SSnapshot snapshot = {0}; - pNode->pFsm->FpGetSnapshotInfo(pNode->pFsm, &snapshot); + TAOS_CHECK_RETURN(pNode->pFsm->FpGetSnapshotInfo(pNode->pFsm, &snapshot)); SyncIndex commitIndex = snapshot.lastApplyIndex; SyncIndex firstVer = pNode->pLogStore->syncLogBeginIndex(pNode->pLogStore); @@ -1112,7 +1112,7 @@ SSyncNode* syncNodeOpen(SSyncInfo* pSyncInfo, int32_t vnodeVersion) { } pSyncNode->arbTerm = -1; - taosThreadMutexInit(&pSyncNode->arbTokenMutex, NULL); + (void)taosThreadMutexInit(&pSyncNode->arbTokenMutex, NULL); syncUtilGenerateArbToken(pSyncNode->myNodeInfo.nodeId, pSyncInfo->vgId, pSyncNode->arbToken); sInfo("vgId:%d, arb token:%s", pSyncNode->vgId, pSyncNode->arbToken); @@ -1220,7 +1220,7 @@ SSyncNode* syncNodeOpen(SSyncInfo* pSyncInfo, int32_t vnodeVersion) { SyncIndex commitIndex = SYNC_INDEX_INVALID; if (pSyncNode->pFsm != NULL && pSyncNode->pFsm->FpGetSnapshotInfo != NULL) { SSnapshot snapshot = {0}; - pSyncNode->pFsm->FpGetSnapshotInfo(pSyncNode->pFsm, &snapshot); + TAOS_CHECK_GOTO(pSyncNode->pFsm->FpGetSnapshotInfo(pSyncNode->pFsm, &snapshot), NULL, _error); if (snapshot.lastApplyIndex > commitIndex) { commitIndex = snapshot.lastApplyIndex; sNTrace(pSyncNode, "reset commit index by snapshot"); @@ -1373,7 +1373,7 @@ _error: void syncNodeMaybeUpdateCommitBySnapshot(SSyncNode* pSyncNode) { if (pSyncNode->pFsm != NULL && pSyncNode->pFsm->FpGetSnapshotInfo != NULL) { SSnapshot snapshot = {0}; - pSyncNode->pFsm->FpGetSnapshotInfo(pSyncNode->pFsm, &snapshot); + (void)pSyncNode->pFsm->FpGetSnapshotInfo(pSyncNode->pFsm, &snapshot); if (snapshot.lastApplyIndex > pSyncNode->commitIndex) { pSyncNode->commitIndex = snapshot.lastApplyIndex; } @@ -1386,11 +1386,11 @@ int32_t syncNodeRestore(SSyncNode* pSyncNode) { ASSERTS(pSyncNode->pLogStore != NULL, "log store not created"); ASSERTS(pSyncNode->pLogBuf != NULL, "ring log buffer not created"); - taosThreadMutexLock(&pSyncNode->pLogBuf->mutex); + (void)taosThreadMutexLock(&pSyncNode->pLogBuf->mutex); SyncIndex lastVer = pSyncNode->pLogStore->syncLogLastIndex(pSyncNode->pLogStore); SyncIndex commitIndex = pSyncNode->pLogStore->syncLogCommitIndex(pSyncNode->pLogStore); SyncIndex endIndex = pSyncNode->pLogBuf->endIndex; - taosThreadMutexUnlock(&pSyncNode->pLogBuf->mutex); + (void)taosThreadMutexUnlock(&pSyncNode->pLogBuf->mutex); if (lastVer != -1 && endIndex != lastVer + 1) { code = TSDB_CODE_WAL_LOG_INCOMPLETE; @@ -1439,7 +1439,7 @@ int32_t syncNodeStartStandBy(SSyncNode* pSyncNode) { // state change pSyncNode->state = TAOS_SYNC_STATE_FOLLOWER; pSyncNode->roleTimeMs = taosGetTimestampMs(); - syncNodeStopHeartbeatTimer(pSyncNode); + TAOS_CHECK_RETURN(syncNodeStopHeartbeatTimer(pSyncNode)); // reset elect timer, long enough int32_t electMS = TIMER_MAX_MS; @@ -1464,13 +1464,13 @@ void syncNodePreClose(SSyncNode* pSyncNode) { ASSERT(pSyncNode->pFsm->FpApplyQueueItems != NULL); // stop elect timer - syncNodeStopElectTimer(pSyncNode); + (void)syncNodeStopElectTimer(pSyncNode); // stop heartbeat timer - syncNodeStopHeartbeatTimer(pSyncNode); + (void)syncNodeStopHeartbeatTimer(pSyncNode); // stop ping timer - syncNodeStopPingTimer(pSyncNode); + (void)syncNodeStopPingTimer(pSyncNode); // clean rsp syncRespCleanRsp(pSyncNode->pSyncRespMgr); @@ -1497,9 +1497,9 @@ void syncNodeClose(SSyncNode* pSyncNode) { syncRespCleanRsp(pSyncNode->pSyncRespMgr); - syncNodeStopPingTimer(pSyncNode); - syncNodeStopElectTimer(pSyncNode); - syncNodeStopHeartbeatTimer(pSyncNode); + (void)syncNodeStopPingTimer(pSyncNode); + (void)syncNodeStopElectTimer(pSyncNode); + (void)syncNodeStopHeartbeatTimer(pSyncNode); syncNodeLogReplDestroy(pSyncNode); syncRespMgrDestroy(pSyncNode->pSyncRespMgr); @@ -1517,7 +1517,7 @@ void syncNodeClose(SSyncNode* pSyncNode) { syncLogBufferDestroy(pSyncNode->pLogBuf); pSyncNode->pLogBuf = NULL; - taosThreadMutexDestroy(&pSyncNode->arbTokenMutex); + (void)taosThreadMutexDestroy(&pSyncNode->arbTokenMutex); for (int32_t i = 0; i < TSDB_MAX_REPLICA + TSDB_MAX_LEARNER_REPLICA; ++i) { if (pSyncNode->senders[i] != NULL) { @@ -1557,8 +1557,10 @@ ESyncStrategy syncNodeStrategy(SSyncNode* pSyncNode) { return pSyncNode->raftCfg int32_t syncNodeStartPingTimer(SSyncNode* pSyncNode) { int32_t ret = 0; if (syncIsInit()) { - taosTmrReset(pSyncNode->FpPingTimerCB, pSyncNode->pingTimerMS, (void*)pSyncNode->rid, syncEnv()->pTimerManager, - &pSyncNode->pPingTimer); + if (!taosTmrReset(pSyncNode->FpPingTimerCB, pSyncNode->pingTimerMS, (void*)pSyncNode->rid, syncEnv()->pTimerManager, + &pSyncNode->pPingTimer)) { + return TSDB_CODE_SYN_INTERNAL_ERROR; + }; atomic_store_64(&pSyncNode->pingTimerLogicClock, pSyncNode->pingTimerLogicClockUser); } else { sError("vgId:%d, start ping timer error, sync env is stop", pSyncNode->vgId); @@ -1568,8 +1570,8 @@ int32_t syncNodeStartPingTimer(SSyncNode* pSyncNode) { int32_t syncNodeStopPingTimer(SSyncNode* pSyncNode) { int32_t ret = 0; - atomic_add_fetch_64(&pSyncNode->pingTimerLogicClockUser, 1); - taosTmrStop(pSyncNode->pPingTimer); + (void)atomic_add_fetch_64(&pSyncNode->pingTimerLogicClockUser, 1); + TAOS_CHECK_RETURN(taosTmrStop(pSyncNode->pPingTimer)); pSyncNode->pPingTimer = NULL; return ret; } @@ -1598,8 +1600,8 @@ int32_t syncNodeStartElectTimer(SSyncNode* pSyncNode, int32_t ms) { int32_t syncNodeStopElectTimer(SSyncNode* pSyncNode) { int32_t ret = 0; - atomic_add_fetch_64(&pSyncNode->electTimerLogicClock, 1); - taosTmrStop(pSyncNode->pElectTimer); + (void)atomic_add_fetch_64(&pSyncNode->electTimerLogicClock, 1); + TAOS_CHECK_RETURN(taosTmrStop(pSyncNode->pElectTimer)); pSyncNode->pElectTimer = NULL; return ret; @@ -1634,8 +1636,9 @@ void syncNodeResetElectTimer(SSyncNode* pSyncNode) { static int32_t syncNodeDoStartHeartbeatTimer(SSyncNode* pSyncNode) { int32_t ret = 0; if (syncIsInit()) { - taosTmrReset(pSyncNode->FpHeartbeatTimerCB, pSyncNode->heartbeatTimerMS, (void*)pSyncNode->rid, - syncEnv()->pTimerManager, &pSyncNode->pHeartbeatTimer); + if (!taosTmrReset(pSyncNode->FpHeartbeatTimerCB, pSyncNode->heartbeatTimerMS, (void*)pSyncNode->rid, + syncEnv()->pTimerManager, &pSyncNode->pHeartbeatTimer)) + return TSDB_CODE_SYN_INTERNAL_ERROR; atomic_store_64(&pSyncNode->heartbeatTimerLogicClock, pSyncNode->heartbeatTimerLogicClockUser); } else { sError("vgId:%d, start heartbeat timer error, sync env is stop", pSyncNode->vgId); @@ -1668,8 +1671,8 @@ int32_t syncNodeStopHeartbeatTimer(SSyncNode* pSyncNode) { int32_t ret = 0; #if 0 - atomic_add_fetch_64(&pSyncNode->heartbeatTimerLogicClockUser, 1); - taosTmrStop(pSyncNode->pHeartbeatTimer); + (void)atomic_add_fetch_64(&pSyncNode->heartbeatTimerLogicClockUser, 1); + TAOS_CHECK_RETURN(taosTmrStop(pSyncNode->pHeartbeatTimer)); pSyncNode->pHeartbeatTimer = NULL; #endif @@ -1685,8 +1688,8 @@ int32_t syncNodeStopHeartbeatTimer(SSyncNode* pSyncNode) { #ifdef BUILD_NO_CALL int32_t syncNodeRestartHeartbeatTimer(SSyncNode* pSyncNode) { - syncNodeStopHeartbeatTimer(pSyncNode); - syncNodeStartHeartbeatTimer(pSyncNode); + TAOS_CHECK_RETURN(syncNodeStopHeartbeatTimer(pSyncNode)); + TAOS_CHECK_RETURN(syncNodeStartHeartbeatTimer(pSyncNode)); return 0; } #endif @@ -1801,7 +1804,7 @@ void syncNodeDoConfigChange(SSyncNode* pSyncNode, SSyncCfg* pNewConfig, SyncInde } // add last config index - syncAddCfgIndex(pSyncNode, lastConfigChangeIndex); + (void)syncAddCfgIndex(pSyncNode, lastConfigChangeIndex); if (IamInNew) { //----------------------------------------- @@ -1818,7 +1821,7 @@ void syncNodeDoConfigChange(SSyncNode* pSyncNode, SSyncCfg* pNewConfig, SyncInde // init internal pSyncNode->myNodeInfo = pSyncNode->raftCfg.cfg.nodeInfo[pSyncNode->raftCfg.cfg.myIndex]; - syncUtilNodeInfo2RaftId(&pSyncNode->myNodeInfo, pSyncNode->vgId, &pSyncNode->myRaftId); + (void)syncUtilNodeInfo2RaftId(&pSyncNode->myNodeInfo, pSyncNode->vgId, &pSyncNode->myRaftId); // init peersNum, peers, peersId pSyncNode->peersNum = pSyncNode->raftCfg.cfg.totalReplicaNum - 1; @@ -1831,14 +1834,14 @@ void syncNodeDoConfigChange(SSyncNode* pSyncNode, SSyncCfg* pNewConfig, SyncInde } } for (int32_t i = 0; i < pSyncNode->peersNum; ++i) { - syncUtilNodeInfo2RaftId(&pSyncNode->peersNodeInfo[i], pSyncNode->vgId, &pSyncNode->peersId[i]); + (void)syncUtilNodeInfo2RaftId(&pSyncNode->peersNodeInfo[i], pSyncNode->vgId, &pSyncNode->peersId[i]); } // init replicaNum, replicasId pSyncNode->replicaNum = pSyncNode->raftCfg.cfg.replicaNum; pSyncNode->totalReplicaNum = pSyncNode->raftCfg.cfg.totalReplicaNum; for (int32_t i = 0; i < pSyncNode->raftCfg.cfg.totalReplicaNum; ++i) { - syncUtilNodeInfo2RaftId(&pSyncNode->raftCfg.cfg.nodeInfo[i], pSyncNode->vgId, &pSyncNode->replicasId[i]); + (void)syncUtilNodeInfo2RaftId(&pSyncNode->raftCfg.cfg.nodeInfo[i], pSyncNode->vgId, &pSyncNode->replicasId[i]); } // update quorum first @@ -1884,7 +1887,7 @@ void syncNodeDoConfigChange(SSyncNode* pSyncNode, SSyncCfg* pNewConfig, SyncInde // create new for (int32_t i = 0; i < TSDB_MAX_REPLICA + TSDB_MAX_LEARNER_REPLICA; ++i) { if (pSyncNode->senders[i] == NULL) { - snapshotSenderCreate(pSyncNode, i, &pSyncNode->senders[i]); + (void)snapshotSenderCreate(pSyncNode, i, &pSyncNode->senders[i]); if (pSyncNode->senders[i] == NULL) { // will be created later while send snapshot sSError(pSyncNode->senders[i], "snapshot sender create failed while reconfig"); @@ -1906,10 +1909,10 @@ void syncNodeDoConfigChange(SSyncNode* pSyncNode, SSyncCfg* pNewConfig, SyncInde } // persist cfg - syncWriteCfgFile(pSyncNode); + (void)syncWriteCfgFile(pSyncNode); } else { // persist cfg - syncWriteCfgFile(pSyncNode); + (void)syncWriteCfgFile(pSyncNode); sNInfo(pSyncNode, "do not config change from %d to %d", oldConfig.totalReplicaNum, pNewConfig->totalReplicaNum); } @@ -1937,10 +1940,10 @@ void syncNodeStepDown(SSyncNode* pSyncNode, SyncTerm newTerm) { } while (0); if (pSyncNode->state == TAOS_SYNC_STATE_ASSIGNED_LEADER) { - taosThreadMutexLock(&pSyncNode->arbTokenMutex); + (void)taosThreadMutexLock(&pSyncNode->arbTokenMutex); syncUtilGenerateArbToken(pSyncNode->myNodeInfo.nodeId, pSyncNode->vgId, pSyncNode->arbToken); sInfo("vgId:%d, step down as assigned leader, new arbToken:%s", pSyncNode->vgId, pSyncNode->arbToken); - taosThreadMutexUnlock(&pSyncNode->arbTokenMutex); + (void)taosThreadMutexUnlock(&pSyncNode->arbTokenMutex); } if (currentTerm < newTerm) { @@ -1969,7 +1972,7 @@ void syncNodeBecomeFollower(SSyncNode* pSyncNode, const char* debugStr) { // state change pSyncNode->state = TAOS_SYNC_STATE_FOLLOWER; pSyncNode->roleTimeMs = taosGetTimestampMs(); - syncNodeStopHeartbeatTimer(pSyncNode); + (void)syncNodeStopHeartbeatTimer(pSyncNode); // trace log sNTrace(pSyncNode, "become follower %s", debugStr); @@ -1986,7 +1989,7 @@ void syncNodeBecomeFollower(SSyncNode* pSyncNode, const char* debugStr) { pSyncNode->minMatchIndex = SYNC_INDEX_INVALID; // reset log buffer - syncLogBufferReset(pSyncNode->pLogBuf, pSyncNode); + (void)syncLogBufferReset(pSyncNode->pLogBuf, pSyncNode); // reset elect timer syncNodeResetElectTimer(pSyncNode); @@ -2011,7 +2014,7 @@ void syncNodeBecomeLearner(SSyncNode* pSyncNode, const char* debugStr) { pSyncNode->minMatchIndex = SYNC_INDEX_INVALID; // reset log buffer - syncLogBufferReset(pSyncNode->pLogBuf, pSyncNode); + (void)syncLogBufferReset(pSyncNode->pLogBuf, pSyncNode); } // TLA+ Spec @@ -2061,7 +2064,7 @@ void syncNodeBecomeLeader(SSyncNode* pSyncNode, const char* debugStr) { } // init peer mgr - syncNodePeerStateInit(pSyncNode); + (void)syncNodePeerStateInit(pSyncNode); #if 0 // update sender private term @@ -2082,13 +2085,13 @@ void syncNodeBecomeLeader(SSyncNode* pSyncNode, const char* debugStr) { } // stop elect timer - syncNodeStopElectTimer(pSyncNode); + (void)syncNodeStopElectTimer(pSyncNode); // start heartbeat timer - syncNodeStartHeartbeatTimer(pSyncNode); + (void)syncNodeStartHeartbeatTimer(pSyncNode); // send heartbeat right now - syncNodeHeartbeatPeers(pSyncNode); + (void)syncNodeHeartbeatPeers(pSyncNode); // call back if (pSyncNode->pFsm != NULL && pSyncNode->pFsm->FpBecomeLeaderCb != NULL) { @@ -2099,7 +2102,7 @@ void syncNodeBecomeLeader(SSyncNode* pSyncNode, const char* debugStr) { pSyncNode->minMatchIndex = SYNC_INDEX_INVALID; // reset log buffer - syncLogBufferReset(pSyncNode->pLogBuf, pSyncNode); + (void)syncLogBufferReset(pSyncNode->pLogBuf, pSyncNode); // trace log sNInfo(pSyncNode, "become leader %s", debugStr); @@ -2134,7 +2137,7 @@ void syncNodeBecomeAssignedLeader(SSyncNode* pSyncNode) { } // init peer mgr - syncNodePeerStateInit(pSyncNode); + (void)syncNodePeerStateInit(pSyncNode); // close receiver if (snapshotReceiverIsStart(pSyncNode->pNewNodeReceiver)) { @@ -2142,13 +2145,13 @@ void syncNodeBecomeAssignedLeader(SSyncNode* pSyncNode) { } // stop elect timer - syncNodeStopElectTimer(pSyncNode); + (void)syncNodeStopElectTimer(pSyncNode); // start heartbeat timer - syncNodeStartHeartbeatTimer(pSyncNode); + (void)syncNodeStartHeartbeatTimer(pSyncNode); // send heartbeat right now - syncNodeHeartbeatPeers(pSyncNode); + (void)syncNodeHeartbeatPeers(pSyncNode); // call back if (pSyncNode->pFsm != NULL && pSyncNode->pFsm->FpBecomeAssignedLeaderCb != NULL) { @@ -2159,7 +2162,7 @@ void syncNodeBecomeAssignedLeader(SSyncNode* pSyncNode) { pSyncNode->minMatchIndex = SYNC_INDEX_INVALID; // reset log buffer - syncLogBufferReset(pSyncNode->pLogBuf, pSyncNode); + (void)syncLogBufferReset(pSyncNode->pLogBuf, pSyncNode); // trace log sNInfo(pSyncNode, "become assigned leader"); @@ -2262,7 +2265,7 @@ bool syncNodeHasSnapshot(SSyncNode* pSyncNode) { bool ret = false; SSnapshot snapshot = {.data = NULL, .lastApplyIndex = -1, .lastApplyTerm = 0, .lastConfigIndex = -1}; if (pSyncNode->pFsm->FpGetSnapshotInfo != NULL) { - pSyncNode->pFsm->FpGetSnapshotInfo(pSyncNode->pFsm, &snapshot); + if ((terrno = pSyncNode->pFsm->FpGetSnapshotInfo(pSyncNode->pFsm, &snapshot)) != 0) return false; if (snapshot.lastApplyIndex >= SYNC_INDEX_BEGIN) { ret = true; } @@ -2275,7 +2278,7 @@ bool syncNodeHasSnapshot(SSyncNode* pSyncNode) { SyncIndex syncNodeGetLastIndex(const SSyncNode* pSyncNode) { SSnapshot snapshot = {.data = NULL, .lastApplyIndex = -1, .lastApplyTerm = 0, .lastConfigIndex = -1}; if (pSyncNode->pFsm->FpGetSnapshotInfo != NULL) { - pSyncNode->pFsm->FpGetSnapshotInfo(pSyncNode->pFsm, &snapshot); + if ((terrno = pSyncNode->pFsm->FpGetSnapshotInfo(pSyncNode->pFsm, &snapshot)) != 0) return -1; } SyncIndex logLastIndex = pSyncNode->pLogStore->syncLogLastIndex(pSyncNode->pLogStore); @@ -2291,7 +2294,7 @@ SyncTerm syncNodeGetLastTerm(SSyncNode* pSyncNode) { // has snapshot SSnapshot snapshot = {.data = NULL, .lastApplyIndex = -1, .lastApplyTerm = 0, .lastConfigIndex = -1}; if (pSyncNode->pFsm->FpGetSnapshotInfo != NULL) { - pSyncNode->pFsm->FpGetSnapshotInfo(pSyncNode->pFsm, &snapshot); + if ((terrno = pSyncNode->pFsm->FpGetSnapshotInfo(pSyncNode->pFsm, &snapshot)) != 0) return lastTerm; } SyncIndex logLastIndex = pSyncNode->pLogStore->syncLogLastIndex(pSyncNode->pLogStore); @@ -2386,7 +2389,7 @@ SyncTerm syncNodeGetPreTerm(SSyncNode* pSyncNode, SyncIndex index) { return preTerm; } else { if (pSyncNode->pFsm->FpGetSnapshotInfo != NULL) { - pSyncNode->pFsm->FpGetSnapshotInfo(pSyncNode->pFsm, &snapshot); + if ((terrno = pSyncNode->pFsm->FpGetSnapshotInfo(pSyncNode->pFsm, &snapshot)) != 0) return SYNC_TERM_INVALID; if (snapshot.lastApplyIndex == preIndex) { return snapshot.lastApplyTerm; } @@ -2433,8 +2436,8 @@ static void syncNodeEqPingTimer(void* param, void* tmrId) { } _out: - taosTmrReset(syncNodeEqPingTimer, pNode->pingTimerMS, (void*)pNode->rid, syncEnv()->pTimerManager, - &pNode->pPingTimer); + (void)taosTmrReset(syncNodeEqPingTimer, pNode->pingTimerMS, (void*)pNode->rid, syncEnv()->pTimerManager, + &pNode->pPingTimer); } } @@ -2510,8 +2513,8 @@ static void syncNodeEqHeartbeatTimer(void* param, void* tmrId) { } _out: - taosTmrReset(syncNodeEqHeartbeatTimer, pNode->heartbeatTimerMS, (void*)pNode->rid, syncEnv()->pTimerManager, - &pNode->pHeartbeatTimer); + (void)taosTmrReset(syncNodeEqHeartbeatTimer, pNode->heartbeatTimerMS, (void*)pNode->rid, syncEnv()->pTimerManager, + &pNode->pHeartbeatTimer); } else { sTrace("==syncNodeEqHeartbeatTimer== heartbeatTimerLogicClock:%" PRId64 ", heartbeatTimerLogicClockUser:%" PRId64, @@ -2585,14 +2588,14 @@ static void syncNodeEqPeerHeartbeatTimer(void* param, void* tmrId) { // send msg sTrace("vgId:%d, send heartbeat to dnode:%d", pSyncNode->vgId, DID(&(pSyncMsg->destId))); syncLogSendHeartbeat(pSyncNode, pSyncMsg, false, timerElapsed, pData->execTime); - syncNodeSendHeartbeat(pSyncNode, &pSyncMsg->destId, &rpcMsg); + (void)syncNodeSendHeartbeat(pSyncNode, &pSyncMsg->destId, &rpcMsg); } else { } if (syncIsInit()) { // sTrace("vgId:%d, reset peer hb timer", pSyncNode->vgId); - taosTmrReset(syncNodeEqPeerHeartbeatTimer, pSyncTimer->timerMS / HEARTBEAT_TICK_NUM, (void*)hbDataRid, - syncEnv()->pTimerManager, &pSyncTimer->pTimer); + (void)taosTmrReset(syncNodeEqPeerHeartbeatTimer, pSyncTimer->timerMS / HEARTBEAT_TICK_NUM, (void*)hbDataRid, + syncEnv()->pTimerManager, &pSyncTimer->pTimer); } else { sError("sync env is stop, reset peer hb timer error"); } From 7f801388debcfd18b7f0214372642c153040f4a5 Mon Sep 17 00:00:00 2001 From: dmchen Date: Mon, 29 Jul 2024 05:42:57 +0000 Subject: [PATCH 04/28] fix/TD-30989 --- source/libs/monitorfw/src/taos_collector.c | 8 ++--- .../monitorfw/src/taos_collector_registry.c | 18 +++++------ source/libs/monitorfw/src/taos_map.c | 21 ++++++------ source/libs/monitorfw/src/taos_metric.c | 10 +++--- .../monitorfw/src/taos_metric_formatter.c | 4 +-- .../src/taos_metric_formatter_custom.c | 32 +++++++++---------- .../libs/monitorfw/src/taos_metric_sample.c | 2 +- source/libs/monitorfw/src/taos_monitor_util.c | 4 +-- .../libs/monitorfw/src/taos_string_builder.c | 2 +- 9 files changed, 51 insertions(+), 50 deletions(-) diff --git a/source/libs/monitorfw/src/taos_collector.c b/source/libs/monitorfw/src/taos_collector.c index 8be4edaef9..01e37b6d76 100644 --- a/source/libs/monitorfw/src/taos_collector.c +++ b/source/libs/monitorfw/src/taos_collector.c @@ -39,18 +39,18 @@ taos_collector_t *taos_collector_new(const char *name) { self->name = taos_strdup(name); self->metrics = taos_map_new(); if (self->metrics == NULL) { - taos_collector_destroy(self); + (void)taos_collector_destroy(self); return NULL; } r = taos_map_set_free_value_fn(self->metrics, &taos_metric_free_generic); if (r) { - taos_collector_destroy(self); + (void)taos_collector_destroy(self); return NULL; } self->collect_fn = &taos_collector_default_collect; self->string_builder = taos_string_builder_new(); if (self->string_builder == NULL) { - taos_collector_destroy(self); + (void)taos_collector_destroy(self); return NULL; } self->proc_limits_file_path = NULL; @@ -93,7 +93,7 @@ int taos_collector_destroy_generic(void *gen) { void taos_collector_free_generic(void *gen) { taos_collector_t *self = (taos_collector_t *)gen; - taos_collector_destroy(self); + (void)taos_collector_destroy(self); } int taos_collector_set_collect_fn(taos_collector_t *self, taos_collect_fn *fn) { diff --git a/source/libs/monitorfw/src/taos_collector_registry.c b/source/libs/monitorfw/src/taos_collector_registry.c index 0c8385791d..88f56549e5 100644 --- a/source/libs/monitorfw/src/taos_collector_registry.c +++ b/source/libs/monitorfw/src/taos_collector_registry.c @@ -50,8 +50,8 @@ taos_collector_registry_t *taos_collector_registry_new(const char *name) { self->name = taos_strdup(name); self->collectors = taos_map_new(); - taos_map_set_free_value_fn(self->collectors, &taos_collector_free_generic); - taos_map_set(self->collectors, "default", taos_collector_new("default")); + (void)taos_map_set_free_value_fn(self->collectors, &taos_collector_free_generic); + if (taos_map_set(self->collectors, "default", taos_collector_new("default")) != 0) return NULL; self->metric_formatter = taos_metric_formatter_new(); self->string_builder = taos_string_builder_new(); @@ -237,15 +237,15 @@ int taos_collector_registry_clear_batch(taos_collector_registry_t *self){ } const char *taos_collector_registry_bridge_new(taos_collector_registry_t *self, char *ts, char *format, char** prom_str) { - taos_metric_formatter_clear(self->metric_formatter); - + if (taos_metric_formatter_clear(self->metric_formatter) != 0) return NULL; + SJson* pJson = tjsonCreateArray(); SJson* item = tjsonCreateObject(); - tjsonAddItemToArray(pJson, item); - tjsonAddStringToObject(item, "ts", ts); - tjsonAddDoubleToObject(item, "protocol", 2); + (void)tjsonAddItemToArray(pJson, item); + (void)tjsonAddStringToObject(item, "ts", ts); + (void)tjsonAddDoubleToObject(item, "protocol", 2); SJson* array = tjsonCreateArray(); - tjsonAddItemToObject(item, "tables", array); + (void)tjsonAddItemToObject(item, "tables", array); if(taos_metric_formatter_load_metrics_new(self->metric_formatter, self->collectors, ts, format, array) != 0){ TAOS_LOG("failed to load metrics"); @@ -304,7 +304,7 @@ const char *taos_collector_registry_bridge_new(taos_collector_registry_t *self, _OVER: tjsonDelete(pJson); if(tmp_builder != NULL){ - taos_string_builder_destroy(tmp_builder); + (void)taos_string_builder_destroy(tmp_builder); } return NULL; diff --git a/source/libs/monitorfw/src/taos_map.c b/source/libs/monitorfw/src/taos_map.c index 55aaabf1a7..64d5475af2 100644 --- a/source/libs/monitorfw/src/taos_map.c +++ b/source/libs/monitorfw/src/taos_map.c @@ -59,7 +59,7 @@ int taos_map_node_destroy(taos_map_node_t *self) { void taos_map_node_free(void *item) { taos_map_node_t *map_node = (taos_map_node_t *)item; - taos_map_node_destroy(map_node); + (void)taos_map_node_destroy(map_node); } taos_linked_list_compare_t taos_map_node_compare(void *item_a, void *item_b) { @@ -87,7 +87,7 @@ taos_map_t *taos_map_new() { // we will only have to deallocate each key once. That will happen on taos_map_node_destroy. r = taos_linked_list_set_free_fn(self->keys, taos_linked_list_no_op_free); if (r) { - taos_map_destroy(self); + (void)taos_map_destroy(self); return NULL; } @@ -98,12 +98,12 @@ taos_map_t *taos_map_new() { self->addrs[i] = taos_linked_list_new(); r = taos_linked_list_set_free_fn(self->addrs[i], taos_map_node_free); if (r) { - taos_map_destroy(self); + (void)taos_map_destroy(self); return NULL; } r = taos_linked_list_set_compare_fn(self->addrs[i], taos_map_node_compare); if (r) { - taos_map_destroy(self); + (void)taos_map_destroy(self); return NULL; } } @@ -112,7 +112,7 @@ taos_map_t *taos_map_new() { r = pthread_rwlock_init(self->rwlock, NULL); if (r) { TAOS_LOG(TAOS_PTHREAD_RWLOCK_INIT_ERROR); - taos_map_destroy(self); + (void)taos_map_destroy(self); return NULL; } @@ -188,12 +188,12 @@ static void *taos_map_get_internal(const char *key, size_t *size, size_t *max_si taos_map_node_t *current_map_node = (taos_map_node_t *)current_node->item; taos_linked_list_compare_t result = taos_linked_list_compare(list, current_map_node, temp_map_node); if (result == TAOS_EQUAL) { - taos_map_node_destroy(temp_map_node); + (void)taos_map_node_destroy(temp_map_node); temp_map_node = NULL; return current_map_node->value; } } - taos_map_node_destroy(temp_map_node); + (void)taos_map_node_destroy(temp_map_node); temp_map_node = NULL; return NULL; } @@ -248,8 +248,8 @@ static int taos_map_set_internal(const char *key, void *value, size_t *size, siz return 0; } } - taos_linked_list_append(list, map_node); - taos_linked_list_append(keys, (char *)map_node->key); + if (taos_linked_list_append(list, map_node) != 0) return 1; + if (taos_linked_list_append(keys, (char *)map_node->key) != 0) return 1; (*size)++; return 0; } @@ -311,7 +311,8 @@ int taos_map_ensure_space(taos_map_t *self) { self->addrs[i] = NULL; } // Destroy the collection of keys in the map - taos_linked_list_destroy(self->keys); + r = taos_linked_list_destroy(self->keys); + if (r) return r; self->keys = NULL; // Deallocate the backbone of the map diff --git a/source/libs/monitorfw/src/taos_metric.c b/source/libs/monitorfw/src/taos_metric.c index 056bf131f2..f31cef79b0 100644 --- a/source/libs/monitorfw/src/taos_metric.c +++ b/source/libs/monitorfw/src/taos_metric.c @@ -49,12 +49,12 @@ taos_metric_t *taos_metric_new(taos_metric_type_t metric_type, const char *name, for (int i = 0; i < label_key_count; i++) { if (strcmp(label_keys[i], "le") == 0) { TAOS_LOG(TAOS_METRIC_INVALID_LABEL_NAME); - taos_metric_destroy(self); + (void)taos_metric_destroy(self); return NULL; } if (strcmp(label_keys[i], "quantile") == 0) { TAOS_LOG(TAOS_METRIC_INVALID_LABEL_NAME); - taos_metric_destroy(self); + (void)taos_metric_destroy(self); return NULL; } k[i] = taos_strdup(label_keys[i]); @@ -68,14 +68,14 @@ taos_metric_t *taos_metric_new(taos_metric_type_t metric_type, const char *name, } else { r = taos_map_set_free_value_fn(self->samples, &taos_metric_sample_free_generic); if (r) { - taos_metric_destroy(self); + (void)taos_metric_destroy(self); return NULL; } } self->formatter = taos_metric_formatter_new(); if (self->formatter == NULL) { - taos_metric_destroy(self); + (void)taos_metric_destroy(self); return NULL; } self->rwlock = (pthread_rwlock_t *)taos_malloc(sizeof(pthread_rwlock_t)); @@ -140,7 +140,7 @@ int taos_metric_destroy_generic(void *item) { void taos_metric_free_generic(void *item) { taos_metric_t *self = (taos_metric_t *)item; - taos_metric_destroy(self); + (void)taos_metric_destroy(self); } taos_metric_sample_t *taos_metric_sample_from_labels(taos_metric_t *self, const char **label_values) { diff --git a/source/libs/monitorfw/src/taos_metric_formatter.c b/source/libs/monitorfw/src/taos_metric_formatter.c index 5f34edf3e6..e57c809815 100644 --- a/source/libs/monitorfw/src/taos_metric_formatter.c +++ b/source/libs/monitorfw/src/taos_metric_formatter.c @@ -34,12 +34,12 @@ taos_metric_formatter_t *taos_metric_formatter_new() { taos_metric_formatter_t *self = (taos_metric_formatter_t *)taos_malloc(sizeof(taos_metric_formatter_t)); self->string_builder = taos_string_builder_new(); if (self->string_builder == NULL) { - taos_metric_formatter_destroy(self); + (void)taos_metric_formatter_destroy(self); return NULL; } self->err_builder = taos_string_builder_new(); if (self->err_builder == NULL) { - taos_metric_formatter_destroy(self); + (void)taos_metric_formatter_destroy(self); return NULL; } return self; diff --git a/source/libs/monitorfw/src/taos_metric_formatter_custom.c b/source/libs/monitorfw/src/taos_metric_formatter_custom.c index 553227c801..0287641311 100644 --- a/source/libs/monitorfw/src/taos_metric_formatter_custom.c +++ b/source/libs/monitorfw/src/taos_metric_formatter_custom.c @@ -88,17 +88,17 @@ int taos_metric_formatter_load_sample_new(taos_metric_formatter_t *self, taos_me char* value = *(pair + 1); SJson* tag = tjsonCreateObject(); - tjsonAddStringToObject(tag, "name", key); - tjsonAddStringToObject(tag, "value", value); + (void)tjsonAddStringToObject(tag, "name", key); + (void)tjsonAddStringToObject(tag, "value", value); - tjsonAddItemToArray(arrayTag, tag); + (void)tjsonAddItemToArray(arrayTag, tag); } - tjsonAddItemToObject(item, "tags", arrayTag); + (void)tjsonAddItemToObject(item, "tags", arrayTag); metrics = tjsonCreateArray(); - tjsonAddItemToObject(item, "metrics", metrics); + (void)tjsonAddItemToObject(item, "metrics", metrics); - tjsonAddItemToArray(arrayMetricGroups, item); + (void)tjsonAddItemToArray(arrayMetricGroups, item); } else{ metrics = tjsonGetObjectItem(item, "metrics"); @@ -109,20 +109,20 @@ int taos_metric_formatter_load_sample_new(taos_metric_formatter_t *self, taos_me taosMemoryFreeClear(keyvalues); SJson* metric = tjsonCreateObject(); - tjsonAddStringToObject(metric, "name", metricName); - + (void)tjsonAddStringToObject(metric, "name", metricName); + double old_value = 0; #define USE_EXCHANGE #ifdef USE_EXCHANGE - taos_metric_sample_exchange(sample, 0, &old_value); + (void)taos_metric_sample_exchange(sample, 0, &old_value); #else old_value = sample->r_value; taos_metric_sample_set(sample, 0); #endif - tjsonAddDoubleToObject(metric, "value", old_value); - tjsonAddDoubleToObject(metric, "type", metric_type); - tjsonAddItemToArray(metrics, metric); + (void)tjsonAddDoubleToObject(metric, "value", old_value); + (void)tjsonAddDoubleToObject(metric, "type", metric_type); + (void)tjsonAddItemToArray(metrics, metric); return 0; } @@ -150,7 +150,7 @@ int taos_metric_formatter_load_metric_new(taos_metric_formatter_t *self, taos_me SJson* table = tjsonGetArrayItem(tableArray, i); char tableName[MONITOR_TABLENAME_LEN] = {0}; - tjsonGetStringValue(table, "name", tableName); + (void)tjsonGetStringValue(table, "name", tableName); if(strcmp(tableName, arr[0]) == 0){ isFound = true; arrayMetricGroups = tjsonGetObjectItem(table, "metric_groups"); @@ -161,10 +161,10 @@ int taos_metric_formatter_load_metric_new(taos_metric_formatter_t *self, taos_me if(!isFound){ table = tjsonCreateObject(); - tjsonAddStringToObject(table, "name", arr[0]); + (void)tjsonAddStringToObject(table, "name", arr[0]); arrayMetricGroups = tjsonCreateArray(); - tjsonAddItemToObject(table, "metric_groups", arrayMetricGroups); + (void)tjsonAddItemToObject(table, "metric_groups", arrayMetricGroups); } int32_t sample_count = 0; @@ -183,7 +183,7 @@ int taos_metric_formatter_load_metric_new(taos_metric_formatter_t *self, taos_me } if(!isFound && sample_count > 0){ - tjsonAddItemToArray(tableArray, table); + (void)tjsonAddItemToArray(tableArray, table); } else{ if(table != NULL) tjsonDelete(table); diff --git a/source/libs/monitorfw/src/taos_metric_sample.c b/source/libs/monitorfw/src/taos_metric_sample.c index 4688672835..ccddefa17e 100644 --- a/source/libs/monitorfw/src/taos_metric_sample.c +++ b/source/libs/monitorfw/src/taos_metric_sample.c @@ -63,7 +63,7 @@ int taos_metric_sample_destroy_generic(void *gen) { void taos_metric_sample_free_generic(void *gen) { taos_metric_sample_t *self = (taos_metric_sample_t *)gen; - taos_metric_sample_destroy(self); + (void)taos_metric_sample_destroy(self); } int taos_metric_sample_add(taos_metric_sample_t *self, double r_value) { diff --git a/source/libs/monitorfw/src/taos_monitor_util.c b/source/libs/monitorfw/src/taos_monitor_util.c index d338215426..2285ed9e71 100644 --- a/source/libs/monitorfw/src/taos_monitor_util.c +++ b/source/libs/monitorfw/src/taos_monitor_util.c @@ -84,10 +84,10 @@ bool taos_monitor_is_match(const SJson* tags, char** pairs, int32_t count) { SJson* item = tjsonGetArrayItem(tags, i); char item_name[MONITOR_TAG_NAME_LEN] = {0}; - tjsonGetStringValue(item, "name", item_name); + (void)tjsonGetStringValue(item, "name", item_name); char item_value[MONITOR_TAG_VALUE_LEN] = {0}; - tjsonGetStringValue(item, "value", item_value); + (void)tjsonGetStringValue(item, "value", item_value); bool isfound = false; for(int32_t j = 0; j < count; j++){ diff --git a/source/libs/monitorfw/src/taos_string_builder.c b/source/libs/monitorfw/src/taos_string_builder.c index e1bfa4142c..208f3f6d51 100644 --- a/source/libs/monitorfw/src/taos_string_builder.c +++ b/source/libs/monitorfw/src/taos_string_builder.c @@ -44,7 +44,7 @@ taos_string_builder_t *taos_string_builder_new(void) { self->init_size = TAOS_STRING_BUILDER_INIT_SIZE; r = taos_string_builder_init(self); if (r) { - taos_string_builder_destroy(self); + (void)taos_string_builder_destroy(self); return NULL; } From c75d281a49f8787e910e0851ce3627e1a463a233 Mon Sep 17 00:00:00 2001 From: Hongze Cheng Date: Mon, 29 Jul 2024 14:22:57 +0800 Subject: [PATCH 05/28] more change --- source/dnode/vnode/src/tsdb/tsdbRetention.c | 42 ++++++++++----------- 1 file changed, 21 insertions(+), 21 deletions(-) diff --git a/source/dnode/vnode/src/tsdb/tsdbRetention.c b/source/dnode/vnode/src/tsdb/tsdbRetention.c index a454f09e22..bdd174a8f8 100644 --- a/source/dnode/vnode/src/tsdb/tsdbRetention.c +++ b/source/dnode/vnode/src/tsdb/tsdbRetention.c @@ -71,8 +71,8 @@ static int32_t tsdbDoCopyFileLC(SRTNer *rtner, const STFileObj *from, const STFi char fname_from[TSDB_FILENAME_LEN]; char fname_to[TSDB_FILENAME_LEN]; - tsdbTFileLastChunkName(rtner->tsdb, from->f, fname_from); - tsdbTFileLastChunkName(rtner->tsdb, to, fname_to); + (void)tsdbTFileLastChunkName(rtner->tsdb, from->f, fname_from); + (void)tsdbTFileLastChunkName(rtner->tsdb, to, fname_to); fdFrom = taosOpenFile(fname_from, TD_FILE_READ); if (fdFrom == NULL) { @@ -99,8 +99,8 @@ _exit: tsdbError("vgId:%d, %s failed at %s:%d since %s", TD_VID(rtner->tsdb->pVnode), __func__, __FILE__, lino, tstrerror(code)); } - taosCloseFile(&fdFrom); - taosCloseFile(&fdTo); + (void)taosCloseFile(&fdFrom); + (void)taosCloseFile(&fdTo); return code; } @@ -112,7 +112,7 @@ static int32_t tsdbDoCopyFile(SRTNer *rtner, const STFileObj *from, const STFile TdFilePtr fdFrom = NULL; TdFilePtr fdTo = NULL; - tsdbTFileName(rtner->tsdb, to, fname); + (void)tsdbTFileName(rtner->tsdb, to, fname); fdFrom = taosOpenFile(from->fname, TD_FILE_READ); if (fdFrom == NULL) { @@ -136,8 +136,8 @@ _exit: tsdbError("vgId:%d, %s failed at %s:%d since %s", TD_VID(rtner->tsdb->pVnode), __func__, __FILE__, lino, tstrerror(code)); } - taosCloseFile(&fdFrom); - taosCloseFile(&fdTo); + (void)taosCloseFile(&fdFrom); + (void)taosCloseFile(&fdTo); return code; } @@ -255,7 +255,7 @@ static int32_t tsdbDoRetention(SRTNer *rtner) { SDiskID did; TAOS_CHECK_GOTO(tfsAllocDisk(rtner->tsdb->pVnode->pTfs, expLevel, &did), &lino, _exit); - tfsMkdirRecurAt(rtner->tsdb->pVnode->pTfs, rtner->tsdb->path, did); + (void)tfsMkdirRecurAt(rtner->tsdb->pVnode->pTfs, rtner->tsdb->path, did); // data for (int32_t ftype = 0; ftype < TSDB_FTYPE_MAX && (fobj = fset->farr[ftype], 1); ++ftype) { @@ -316,7 +316,7 @@ static int32_t tsdbRetention(void *arg) { // begin task (void)taosThreadMutexLock(&pTsdb->mutex); - tsdbBeginTaskOnFileSet(pTsdb, rtnArg->fid, &fset); + (void)tsdbBeginTaskOnFileSet(pTsdb, rtnArg->fid, &fset); if (fset && (code = tsdbTFileSetInitCopy(pTsdb, fset, &rtner.fset))) { (void)taosThreadMutexUnlock(&pTsdb->mutex); TSDB_CHECK_CODE(code, lino, _exit); @@ -337,7 +337,7 @@ static int32_t tsdbRetention(void *arg) { _exit: if (rtner.fset) { (void)taosThreadMutexLock(&pTsdb->mutex); - tsdbFinishTaskOnFileSet(pTsdb, rtnArg->fid); + (void)tsdbFinishTaskOnFileSet(pTsdb, rtnArg->fid); (void)taosThreadMutexUnlock(&pTsdb->mutex); } @@ -427,7 +427,7 @@ static int32_t tsdbCopyFileS3(SRTNer *rtner, const STFileObj *from, const STFile TdFilePtr fdFrom = NULL; // TdFilePtr fdTo = NULL; - tsdbTFileName(rtner->tsdb, to, fname); + (void)tsdbTFileName(rtner->tsdb, to, fname); fdFrom = taosOpenFile(from->fname, TD_FILE_READ); if (fdFrom == NULL) { @@ -442,7 +442,7 @@ _exit: tsdbError("vgId:%d %s failed at line %s:%d since %s", TD_VID(rtner->tsdb->pVnode), __func__, __FILE__, lino, tstrerror(code)); } - taosCloseFile(&fdFrom); + (void)taosCloseFile(&fdFrom); return code; } @@ -486,7 +486,7 @@ static int32_t tsdbMigrateDataFileLCS3(SRTNer *rtner, const STFileObj *fobj, int TAOS_CHECK_GOTO(TARRAY2_APPEND(&rtner->fopArr, op), &lino, _exit); char fname[TSDB_FILENAME_LEN]; - tsdbTFileName(rtner->tsdb, &op.nf, fname); + (void)tsdbTFileName(rtner->tsdb, &op.nf, fname); char *object_name = taosDirEntryBaseName(fname); char object_name_prefix[TSDB_FILENAME_LEN]; int32_t node_id = vnodeNodeId(rtner->tsdb->pVnode); @@ -542,8 +542,8 @@ _exit: tsdbError("vgId:%d %s failed at line %s:%d since %s", TD_VID(rtner->tsdb->pVnode), __func__, __FILE__, lino, tstrerror(code)); } - taosCloseFile(&fdFrom); - taosCloseFile(&fdTo); + (void)taosCloseFile(&fdFrom); + (void)taosCloseFile(&fdTo); return code; } @@ -587,7 +587,7 @@ static int32_t tsdbMigrateDataFileS3(SRTNer *rtner, const STFileObj *fobj, int64 TAOS_CHECK_GOTO(TARRAY2_APPEND(&rtner->fopArr, op), &lino, _exit); char fname[TSDB_FILENAME_LEN]; - tsdbTFileName(rtner->tsdb, &op.nf, fname); + (void)tsdbTFileName(rtner->tsdb, &op.nf, fname); char *object_name = taosDirEntryBaseName(fname); char object_name_prefix[TSDB_FILENAME_LEN]; int32_t node_id = vnodeNodeId(rtner->tsdb->pVnode); @@ -640,8 +640,8 @@ _exit: tsdbError("vgId:%d %s failed at line %s:%d since %s", TD_VID(rtner->tsdb->pVnode), __func__, __FILE__, lino, tstrerror(code)); } - taosCloseFile(&fdFrom); - taosCloseFile(&fdTo); + (void)taosCloseFile(&fdFrom); + (void)taosCloseFile(&fdTo); return code; } @@ -673,7 +673,7 @@ static int32_t tsdbDoS3Migrate(SRTNer *rtner) { if (/*lcn < 1 && */ taosCheckExistFile(fobj->fname)) { int32_t mtime = 0; int64_t size = 0; - taosStatFile(fobj->fname, &size, &mtime, NULL); + (void)taosStatFile(fobj->fname, &size, &mtime, NULL); if (size > chunksize && mtime < rtner->now - tsS3UploadDelaySec) { if (pCfg->s3Compact && lcn < 0) { extern int32_t tsdbAsyncCompact(STsdb * tsdb, const STimeWindow *tw, bool sync); @@ -695,12 +695,12 @@ static int32_t tsdbDoS3Migrate(SRTNer *rtner) { TAOS_CHECK_GOTO(TSDB_CODE_INVALID_PARA, &lino, _exit); } char fname1[TSDB_FILENAME_LEN]; - tsdbTFileLastChunkName(rtner->tsdb, fobj->f, fname1); + (void)tsdbTFileLastChunkName(rtner->tsdb, fobj->f, fname1); if (taosCheckExistFile(fname1)) { int32_t mtime = 0; int64_t size = 0; - taosStatFile(fname1, &size, &mtime, NULL); + (void)taosStatFile(fname1, &size, &mtime, NULL); if (size > chunksize && mtime < rtner->now - tsS3UploadDelaySec) { TAOS_CHECK_GOTO(tsdbMigrateDataFileLCS3(rtner, fobj, size, chunksize), &lino, _exit); } From 0fb6d366df42ffbaa9b0f8d17d28e2c131ebf02f Mon Sep 17 00:00:00 2001 From: dmchen Date: Mon, 29 Jul 2024 06:25:21 +0000 Subject: [PATCH 06/28] fix case --- source/dnode/mnode/impl/src/mndStb.c | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/source/dnode/mnode/impl/src/mndStb.c b/source/dnode/mnode/impl/src/mndStb.c index 960331fc2f..c1ebc535a6 100644 --- a/source/dnode/mnode/impl/src/mndStb.c +++ b/source/dnode/mnode/impl/src/mndStb.c @@ -482,7 +482,7 @@ SDbObj *mndAcquireDbByStb(SMnode *pMnode, const char *stbName) { if ((terrno = tNameFromString(&name, stbName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE)) != 0) return NULL; char db[TSDB_TABLE_FNAME_LEN] = {0}; - if ((terrno = tNameGetFullDbName(&name, db)) != 0) return NULL; + (void)tNameGetFullDbName(&name, db); return mndAcquireDb(pMnode, db); } @@ -507,9 +507,7 @@ void *mndBuildVCreateStbReq(SMnode *pMnode, SVgObj *pVgroup, SStbObj *pStb, int3 goto _err; } char dbFName[TSDB_DB_FNAME_LEN] = {0}; - if ((terrno = tNameGetFullDbName(&name, dbFName)) != 0) { - goto _err; - } + (void)tNameGetFullDbName(&name, dbFName); req.name = (char *)tNameGetTableName(&name); req.suid = pStb->uid; From a7c54f19a03d500e49984df802b16c07833ed056 Mon Sep 17 00:00:00 2001 From: kailixu Date: Mon, 29 Jul 2024 15:53:15 +0800 Subject: [PATCH 07/28] fix: load config from apollo url --- source/common/src/tglobal.c | 49 +++++++++++++++++++------------------ source/util/src/tconfig.c | 2 +- 2 files changed, 26 insertions(+), 25 deletions(-) diff --git a/source/common/src/tglobal.c b/source/common/src/tglobal.c index 04e3316bed..3b6daecdc6 100644 --- a/source/common/src/tglobal.c +++ b/source/common/src/tglobal.c @@ -396,8 +396,9 @@ struct SConfig *taosGetCfg() { return tsCfg; } static int32_t taosLoadCfg(SConfig *pCfg, const char **envCmd, const char *inputCfgDir, const char *envFile, char *apolloUrl) { - char cfgDir[PATH_MAX] = {0}; - char cfgFile[PATH_MAX + 100] = {0}; + char cfgDir[PATH_MAX] = {0}; + char cfgFile[PATH_MAX + 100] = {0}; + int32_t code = 0; TAOS_CHECK_RETURN(taosExpandDir(inputCfgDir, cfgDir, PATH_MAX)); char lastC = cfgDir[strlen(cfgDir) - 1]; @@ -424,32 +425,32 @@ static int32_t taosLoadCfg(SConfig *pCfg, const char **envCmd, const char *input } if (apolloUrl != NULL && apolloUrl[0] == '\0') { - TAOS_CHECK_RETURN(cfgGetApollUrl(envCmd, envFile, apolloUrl)); + (void)(cfgGetApollUrl(envCmd, envFile, apolloUrl)); } - if (cfgLoad(pCfg, CFG_STYPE_APOLLO_URL, apolloUrl) != 0) { - uError("failed to load from apollo url:%s since %s", apolloUrl, terrstr()); - TAOS_RETURN(TSDB_CODE_INVALID_CFG); + if ((code = cfgLoad(pCfg, CFG_STYPE_APOLLO_URL, apolloUrl)) != 0) { + uError("failed to load from apollo url:%s since %s", apolloUrl, tstrerror(code)); + TAOS_RETURN(code); } - if (cfgLoad(pCfg, CFG_STYPE_CFG_FILE, cfgFile) != 0) { - uError("failed to load from cfg file:%s since %s", cfgFile, terrstr()); - TAOS_RETURN(TSDB_CODE_INVALID_CFG); + if ((code = cfgLoad(pCfg, CFG_STYPE_CFG_FILE, cfgFile)) != 0) { + uError("failed to load from cfg file:%s since %s", cfgFile, tstrerror(code)); + TAOS_RETURN(code); } - if (cfgLoad(pCfg, CFG_STYPE_ENV_FILE, envFile) != 0) { - uError("failed to load from env file:%s since %s", envFile, terrstr()); - TAOS_RETURN(TSDB_CODE_INVALID_CFG); + if ((code = cfgLoad(pCfg, CFG_STYPE_ENV_FILE, envFile)) != 0) { + uError("failed to load from env file:%s since %s", envFile, tstrerror(code)); + TAOS_RETURN(code); } - if (cfgLoad(pCfg, CFG_STYPE_ENV_VAR, NULL) != 0) { - uError("failed to load from global env variables since %s", terrstr()); - TAOS_RETURN(TSDB_CODE_INVALID_CFG); + if ((code = cfgLoad(pCfg, CFG_STYPE_ENV_VAR, NULL)) != 0) { + uError("failed to load from global env variables since %s", tstrerror(code)); + TAOS_RETURN(code); } - if (cfgLoad(pCfg, CFG_STYPE_ENV_CMD, envCmd) != 0) { - uError("failed to load from cmd env variables since %s", terrstr()); - TAOS_RETURN(TSDB_CODE_INVALID_CFG); + if ((code = cfgLoad(pCfg, CFG_STYPE_ENV_CMD, envCmd)) != 0) { + uError("failed to load from cmd env variables since %s", tstrerror(code)); + TAOS_RETURN(code); } TAOS_RETURN(TSDB_CODE_SUCCESS); @@ -1280,12 +1281,12 @@ int32_t taosCreateLog(const char *logname, int32_t logFileNum, const char *cfgDi } if ((code = taosLoadCfg(pCfg, envCmd, cfgDir, envFile, apolloUrl)) != TSDB_CODE_SUCCESS) { - printf("failed to load cfg since %s", tstrerror(code)); + printf("failed to load cfg since %s\n", tstrerror(code)); goto _exit; } if ((code = cfgLoadFromArray(pCfg, pArgs)) != TSDB_CODE_SUCCESS) { - printf("failed to load cfg from array since %s", tstrerror(code)); + printf("failed to load cfg from array since %s\n", tstrerror(code)); goto _exit; } @@ -1302,12 +1303,12 @@ int32_t taosCreateLog(const char *logname, int32_t logFileNum, const char *cfgDi TAOS_CHECK_RETURN(taosSetAllDebugFlag(pCfg, pDebugItem->i32)); if ((code = taosMulModeMkDir(tsLogDir, 0777, true)) != TSDB_CODE_SUCCESS) { - printf("failed to create dir:%s since %s", tsLogDir, tstrerror(code)); + printf("failed to create dir:%s since %s\n", tsLogDir, tstrerror(code)); goto _exit; } if ((code = taosInitLog(logname, logFileNum)) != 0) { - printf("failed to init log file since %s", terrstr()); + printf("failed to init log file since %s\n", tstrerror(code)); goto _exit; } @@ -1329,12 +1330,12 @@ int32_t taosReadDataFolder(const char *cfgDir, const char **envCmd, const char * if (cfgAddInt32(pCfg, "dDebugFlag", dDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER) != 0) return -1; if ((code = taosLoadCfg(pCfg, envCmd, cfgDir, envFile, apolloUrl)) != 0) { - printf("failed to load cfg since %s", terrstr()); + printf("failed to load cfg since %s\n", tstrerror(code)); goto _exit; } if ((code = cfgLoadFromArray(pCfg, pArgs)) != 0) { - printf("failed to load cfg from array since %s", terrstr()); + printf("failed to load cfg from array since %s\n", tstrerror(code)); goto _exit; } diff --git a/source/util/src/tconfig.c b/source/util/src/tconfig.c index e68d86e232..fa172392e6 100644 --- a/source/util/src/tconfig.c +++ b/source/util/src/tconfig.c @@ -1420,7 +1420,7 @@ int32_t cfgGetApollUrl(const char **envCmd, const char *envFile, char *apolloUrl } uInfo("fail get apollo url from cmd env file"); - TAOS_RETURN(TSDB_CODE_INVALID_PARA); + TAOS_RETURN(TSDB_CODE_NOT_FOUND); } struct SConfigIter { From feec3f9d35e509ab2732aaff65e155d2337903d6 Mon Sep 17 00:00:00 2001 From: Hongze Cheng Date: Mon, 29 Jul 2024 16:03:35 +0800 Subject: [PATCH 08/28] make CI pass --- source/dnode/vnode/src/tsdb/tsdbFS2.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/source/dnode/vnode/src/tsdb/tsdbFS2.c b/source/dnode/vnode/src/tsdb/tsdbFS2.c index 99dd0edf9d..8985e07b0c 100644 --- a/source/dnode/vnode/src/tsdb/tsdbFS2.c +++ b/source/dnode/vnode/src/tsdb/tsdbFS2.c @@ -174,8 +174,7 @@ int32_t save_fs(const TFileSetArray *arr, const char *fname) { if (!item) { TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit); } - code = cJSON_AddItemToArray(ajson, item); - TSDB_CHECK_CODE(code, lino, _exit); + (void)cJSON_AddItemToArray(ajson, item); code = tsdbTFileSetToJson(fset, item); TSDB_CHECK_CODE(code, lino, _exit); From 3fe2bb2effa6f52b957a563f39d23ccd098c19b4 Mon Sep 17 00:00:00 2001 From: dmchen Date: Mon, 29 Jul 2024 08:14:24 +0000 Subject: [PATCH 09/28] fix case --- source/libs/sync/src/syncMain.c | 23 ++++++++--------------- 1 file changed, 8 insertions(+), 15 deletions(-) diff --git a/source/libs/sync/src/syncMain.c b/source/libs/sync/src/syncMain.c index db1b4ff486..b35211a76e 100644 --- a/source/libs/sync/src/syncMain.c +++ b/source/libs/sync/src/syncMain.c @@ -955,9 +955,8 @@ static int32_t syncHbTimerStart(SSyncNode* pSyncNode, SSyncTimer* pSyncTimer) { sTrace("vgId:%d, start hb timer, rid:%" PRId64 " addr:%" PRId64, pSyncNode->vgId, pData->rid, pData->destId.addr); - if (!taosTmrReset(pSyncTimer->timerCb, pSyncTimer->timerMS / HEARTBEAT_TICK_NUM, (void*)(pData->rid), - syncEnv()->pTimerManager, &pSyncTimer->pTimer)) - return TSDB_CODE_SYN_INTERNAL_ERROR; + (void)taosTmrReset(pSyncTimer->timerCb, pSyncTimer->timerMS / HEARTBEAT_TICK_NUM, (void*)(pData->rid), + syncEnv()->pTimerManager, &pSyncTimer->pTimer); } else { ret = TSDB_CODE_SYN_INTERNAL_ERROR; sError("vgId:%d, start ctrl hb timer error, sync env is stop", pSyncNode->vgId); @@ -1557,10 +1556,8 @@ ESyncStrategy syncNodeStrategy(SSyncNode* pSyncNode) { return pSyncNode->raftCfg int32_t syncNodeStartPingTimer(SSyncNode* pSyncNode) { int32_t ret = 0; if (syncIsInit()) { - if (!taosTmrReset(pSyncNode->FpPingTimerCB, pSyncNode->pingTimerMS, (void*)pSyncNode->rid, syncEnv()->pTimerManager, - &pSyncNode->pPingTimer)) { - return TSDB_CODE_SYN_INTERNAL_ERROR; - }; + (void)taosTmrReset(pSyncNode->FpPingTimerCB, pSyncNode->pingTimerMS, (void*)pSyncNode->rid, + syncEnv()->pTimerManager, &pSyncNode->pPingTimer); atomic_store_64(&pSyncNode->pingTimerLogicClock, pSyncNode->pingTimerLogicClockUser); } else { sError("vgId:%d, start ping timer error, sync env is stop", pSyncNode->vgId); @@ -1587,11 +1584,8 @@ int32_t syncNodeStartElectTimer(SSyncNode* pSyncNode, int32_t ms) { pSyncNode->electTimerParam.pSyncNode = pSyncNode; pSyncNode->electTimerParam.pData = NULL; - if (!taosTmrReset(pSyncNode->FpElectTimerCB, pSyncNode->electTimerMS, (void*)(pSyncNode->rid), - syncEnv()->pTimerManager, &pSyncNode->pElectTimer)) { - ret = TSDB_CODE_SYN_INTERNAL_ERROR; - } - + (void)taosTmrReset(pSyncNode->FpElectTimerCB, pSyncNode->electTimerMS, (void*)(pSyncNode->rid), + syncEnv()->pTimerManager, &pSyncNode->pElectTimer); } else { sError("vgId:%d, start elect timer error, sync env is stop", pSyncNode->vgId); } @@ -1636,9 +1630,8 @@ void syncNodeResetElectTimer(SSyncNode* pSyncNode) { static int32_t syncNodeDoStartHeartbeatTimer(SSyncNode* pSyncNode) { int32_t ret = 0; if (syncIsInit()) { - if (!taosTmrReset(pSyncNode->FpHeartbeatTimerCB, pSyncNode->heartbeatTimerMS, (void*)pSyncNode->rid, - syncEnv()->pTimerManager, &pSyncNode->pHeartbeatTimer)) - return TSDB_CODE_SYN_INTERNAL_ERROR; + (void)taosTmrReset(pSyncNode->FpHeartbeatTimerCB, pSyncNode->heartbeatTimerMS, (void*)pSyncNode->rid, + syncEnv()->pTimerManager, &pSyncNode->pHeartbeatTimer); atomic_store_64(&pSyncNode->heartbeatTimerLogicClock, pSyncNode->heartbeatTimerLogicClockUser); } else { sError("vgId:%d, start heartbeat timer error, sync env is stop", pSyncNode->vgId); From 2239a924f04ed617133b08b9eace2fbb0dc4136c Mon Sep 17 00:00:00 2001 From: kailixu Date: Mon, 29 Jul 2024 16:14:52 +0800 Subject: [PATCH 10/28] enh: return code of get ip from fqdn --- source/os/src/osSocket.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/source/os/src/osSocket.c b/source/os/src/osSocket.c index 1b0deb1819..f9ae6c2157 100644 --- a/source/os/src/osSocket.c +++ b/source/os/src/osSocket.c @@ -941,7 +941,7 @@ int32_t taosBlockSIGPIPE() { #endif } -int32_t taosGetIpv4FromFqdn(const char *fqdn, uint32_t* ip) { +int32_t taosGetIpv4FromFqdn(const char *fqdn, uint32_t *ip) { #ifdef WINDOWS // Initialize Winsock WSADATA wsaData; @@ -959,8 +959,8 @@ int32_t taosGetIpv4FromFqdn(const char *fqdn, uint32_t* ip) { hints.ai_socktype = SOCK_STREAM; struct addrinfo *result = NULL; - bool inRetry = false; - + bool inRetry = false; + while (true) { int32_t ret = getaddrinfo(fqdn, NULL, &hints, &result); if (ret) { @@ -972,7 +972,7 @@ int32_t taosGetIpv4FromFqdn(const char *fqdn, uint32_t* ip) { return terrno; } - terrno = TAOS_SYSTEM_ERROR(ret); + terrno = TAOS_SYSTEM_ERROR(errno); return terrno; } @@ -1011,7 +1011,7 @@ int32_t taosGetIpv4FromFqdn(const char *fqdn, uint32_t* ip) { #else // printf("failed to get the ip address, fqdn:%s, ret:%d, since:%s", fqdn, ret, gai_strerror(ret)); #endif - + *ip = 0xFFFFFFFF; return 0xFFFFFFFF; } From 81a44ee6b794b9f4ccff5752fbd9b26742d28ced Mon Sep 17 00:00:00 2001 From: dmchen Date: Mon, 29 Jul 2024 08:34:01 +0000 Subject: [PATCH 11/28] fix log output --- source/libs/sync/src/syncCommit.c | 18 ++++++------------ 1 file changed, 6 insertions(+), 12 deletions(-) diff --git a/source/libs/sync/src/syncCommit.c b/source/libs/sync/src/syncCommit.c index b55267a0e7..3e2b98c35b 100644 --- a/source/libs/sync/src/syncCommit.c +++ b/source/libs/sync/src/syncCommit.c @@ -76,10 +76,8 @@ int64_t syncNodeUpdateCommitIndex(SSyncNode* ths, SyncIndex commitIndex) { SyncIndex lastVer = ths->pLogStore->syncLogLastIndex(ths->pLogStore); commitIndex = TMAX(commitIndex, ths->commitIndex); ths->commitIndex = TMIN(commitIndex, lastVer); - if ((code = ths->pLogStore->syncLogUpdateCommitIndex(ths->pLogStore, ths->commitIndex)) != 0) { - // TODO add return when error - sError("failed to update commit index since %s", tstrerror(code)); - } + // TODO add return when error + (void)ths->pLogStore->syncLogUpdateCommitIndex(ths->pLogStore, ths->commitIndex); return ths->commitIndex; } @@ -87,10 +85,8 @@ int64_t syncNodeCheckCommitIndex(SSyncNode* ths, SyncIndex indexLikely) { int32_t code = 0; if (indexLikely > ths->commitIndex && syncNodeAgreedUpon(ths, indexLikely)) { SyncIndex commitIndex = indexLikely; - if ((code = syncNodeUpdateCommitIndex(ths, commitIndex)) != 0) { - // TODO add return when error - sError("failed to update commit index since %s", tstrerror(code)); - } + // TODO add return when error + (void)syncNodeUpdateCommitIndex(ths, commitIndex); sTrace("vgId:%d, agreed upon. role:%d, term:%" PRId64 ", index:%" PRId64 "", ths->vgId, ths->state, raftStoreGetTerm(ths), commitIndex); } @@ -102,9 +98,7 @@ int64_t syncNodeUpdateAssignedCommitIndex(SSyncNode* ths, SyncIndex assignedComm SyncIndex lastVer = ths->pLogStore->syncLogLastIndex(ths->pLogStore); assignedCommitIndex = TMAX(assignedCommitIndex, ths->assignedCommitIndex); ths->assignedCommitIndex = TMIN(assignedCommitIndex, lastVer); - if ((code = ths->pLogStore->syncLogUpdateCommitIndex(ths->pLogStore, ths->assignedCommitIndex)) != 0) { - // TODO add return when error - sError("failed to update commit index since %s", tstrerror(code)); - } + // TODO add return when error + (void)ths->pLogStore->syncLogUpdateCommitIndex(ths->pLogStore, ths->assignedCommitIndex); return ths->commitIndex; } From b1300b5a6aa7945301352eb4541eb6adb58101e9 Mon Sep 17 00:00:00 2001 From: dmchen Date: Mon, 29 Jul 2024 09:02:30 +0000 Subject: [PATCH 12/28] fix case --- source/dnode/mnode/impl/src/mndStb.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/source/dnode/mnode/impl/src/mndStb.c b/source/dnode/mnode/impl/src/mndStb.c index c1ebc535a6..89fd0268f8 100644 --- a/source/dnode/mnode/impl/src/mndStb.c +++ b/source/dnode/mnode/impl/src/mndStb.c @@ -2628,7 +2628,8 @@ static int32_t mndProcessAlterStbReq(SRpcMsg *pReq) { if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS; SName name = {0}; - TAOS_CHECK_GOTO(tNameFromString(&name, alterReq.name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE), NULL, _OVER); + // TODO check return value + tNameFromString(&name, alterReq.name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); auditRecord(pReq, pMnode->clusterId, "alterStb", name.dbname, name.tname, alterReq.sql, alterReq.sqlLen); From 155c693326c17934637be881012807209d7d8d2e Mon Sep 17 00:00:00 2001 From: kailixu Date: Mon, 29 Jul 2024 17:40:10 +0800 Subject: [PATCH 13/28] fix: memory leak when parse apollo failed --- source/util/src/tconfig.c | 30 +++++++++++++++++++----------- 1 file changed, 19 insertions(+), 11 deletions(-) diff --git a/source/util/src/tconfig.c b/source/util/src/tconfig.c index fa172392e6..87551e28e0 100644 --- a/source/util/src/tconfig.c +++ b/source/util/src/tconfig.c @@ -18,12 +18,12 @@ #include "cJSON.h" #include "taoserror.h" #include "tenv.h" +#include "tglobal.h" #include "tgrant.h" #include "tjson.h" #include "tlog.h" #include "tunit.h" #include "tutil.h" -#include "tglobal.h" #define CFG_NAME_PRINT_LEN 24 #define CFG_SRC_PRINT_LEN 12 @@ -1214,8 +1214,9 @@ int32_t cfgLoadFromCfgFile(SConfig *pConfig, const char *filepath) { int32_t cfgLoadFromApollUrl(SConfig *pConfig, const char *url) { char *cfgLineBuf = NULL, *name, *value, *value2, *value3, *value4; + SJson *pJson = NULL; int32_t olen, vlen, vlen2, vlen3, vlen4; - int32_t code = 0; + int32_t code = 0, lino = 0; if (url == NULL || strlen(url) == 0) { uInfo("apoll url not load"); TAOS_RETURN(TSDB_CODE_SUCCESS); @@ -1228,7 +1229,6 @@ int32_t cfgLoadFromApollUrl(SConfig *pConfig, const char *url) { } p++; - SJson *pJson = NULL; if (strncmp(url, "jsonFile", 8) == 0) { char *filepath = p; if (!taosCheckExistFile(filepath)) { @@ -1238,7 +1238,7 @@ int32_t cfgLoadFromApollUrl(SConfig *pConfig, const char *url) { TdFilePtr pFile = taosOpenFile(filepath, TD_FILE_READ); if (pFile == NULL) { - TAOS_RETURN(TAOS_SYSTEM_ERROR(errno)); + TAOS_CHECK_EXIT(TAOS_SYSTEM_ERROR(errno)); } size_t fileSize = taosLSeekFile(pFile, 0, SEEK_END); char *buf = taosMemoryMalloc(fileSize + 1); @@ -1264,7 +1264,7 @@ int32_t cfgLoadFromApollUrl(SConfig *pConfig, const char *url) { uError("load json file parse error: %s", jsonParseError); } taosMemoryFreeClear(buf); - TAOS_RETURN(TSDB_CODE_INVALID_DATA_FMT); + TAOS_CHECK_EXIT(TSDB_CODE_INVALID_DATA_FMT); } taosMemoryFreeClear(buf); @@ -1273,16 +1273,19 @@ int32_t cfgLoadFromApollUrl(SConfig *pConfig, const char *url) { cJSON *item = tjsonGetArrayItem(pJson, i); if (item == NULL) break; char *itemName = NULL, *itemValueString = NULL; - TAOS_CHECK_GOTO(tjsonGetObjectName(item, &itemName), NULL, _err_json); - TAOS_CHECK_GOTO(tjsonGetObjectValueString(item, &itemValueString), NULL, _err_json); + if (tjsonGetObjectName(item, &itemName) != 0) { + TAOS_CHECK_EXIT(TSDB_CODE_INVALID_DATA_FMT); + } + if (tjsonGetObjectValueString(item, &itemValueString) != 0) { + TAOS_CHECK_EXIT(TSDB_CODE_INVALID_DATA_FMT); + } if (itemValueString != NULL && itemName != NULL) { size_t itemNameLen = strlen(itemName); size_t itemValueStringLen = strlen(itemValueString); - void* px = taosMemoryRealloc(cfgLineBuf, itemNameLen + itemValueStringLen + 3); + void *px = taosMemoryRealloc(cfgLineBuf, itemNameLen + itemValueStringLen + 3); if (NULL == px) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _err_json; + TAOS_CHECK_EXIT(TSDB_CODE_OUT_OF_MEMORY); } cfgLineBuf = px; @@ -1321,6 +1324,7 @@ int32_t cfgLoadFromApollUrl(SConfig *pConfig, const char *url) { } } tjsonDelete(pJson); + pJson = NULL; // } else if (strncmp(url, "jsonUrl", 7) == 0) { // } else if (strncmp(url, "etcdUrl", 7) == 0) { @@ -1333,8 +1337,12 @@ int32_t cfgLoadFromApollUrl(SConfig *pConfig, const char *url) { uInfo("load from apoll url not implemented yet"); TAOS_RETURN(TSDB_CODE_SUCCESS); -_err_json: +_exit: + taosMemoryFree(cfgLineBuf); tjsonDelete(pJson); + if (code != 0) { + uError("failed to load from apollo url:%s at line %d since %s", url, lino, tstrerror(code)); + } TAOS_RETURN(code); } From 61994e7b5eca0c1c7569e6355d12f3db94e61aad Mon Sep 17 00:00:00 2001 From: Hongze Cheng Date: Mon, 29 Jul 2024 18:12:57 +0800 Subject: [PATCH 14/28] merge conflict --- include/common/tmsg.h | 2 +- source/common/src/tmsg.c | 5 +++-- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/include/common/tmsg.h b/include/common/tmsg.h index 4eb64785df..782b9a072d 100644 --- a/include/common/tmsg.h +++ b/include/common/tmsg.h @@ -3641,7 +3641,7 @@ int32_t tEncodeSTqOffsetVal(SEncoder* pEncoder, const STqOffsetVal* pOffsetVal); int32_t tDecodeSTqOffsetVal(SDecoder* pDecoder, STqOffsetVal* pOffsetVal); void tFormatOffset(char* buf, int32_t maxLen, const STqOffsetVal* pVal); bool tOffsetEqual(const STqOffsetVal* pLeft, const STqOffsetVal* pRight); -void tOffsetCopy(STqOffsetVal* pLeft, const STqOffsetVal* pRight); +int32_t tOffsetCopy(STqOffsetVal* pLeft, const STqOffsetVal* pRight); void tOffsetDestroy(void* pVal); typedef struct { diff --git a/source/common/src/tmsg.c b/source/common/src/tmsg.c index c5c0553abe..2fe6deaf14 100644 --- a/source/common/src/tmsg.c +++ b/source/common/src/tmsg.c @@ -9238,17 +9238,18 @@ bool tOffsetEqual(const STqOffsetVal *pLeft, const STqOffsetVal *pRight) { return false; } -void tOffsetCopy(STqOffsetVal *pLeft, const STqOffsetVal *pRight) { +int32_t tOffsetCopy(STqOffsetVal *pLeft, const STqOffsetVal *pRight) { tOffsetDestroy(pLeft); *pLeft = *pRight; if (IS_VAR_DATA_TYPE(pRight->primaryKey.type)) { pLeft->primaryKey.pData = taosMemoryMalloc(pRight->primaryKey.nData); if (pLeft->primaryKey.pData == NULL) { uError("failed to allocate memory for offset"); - return; + return terrno; } (void)memcpy(pLeft->primaryKey.pData, pRight->primaryKey.pData, pRight->primaryKey.nData); } + return 0; } void tOffsetDestroy(void *param) { From 598ed867c3e64a38cecdacda44157ce8bdd1efa4 Mon Sep 17 00:00:00 2001 From: dmchen Date: Mon, 29 Jul 2024 11:17:15 +0000 Subject: [PATCH 15/28] fix case --- source/libs/sync/src/syncMain.c | 53 ++++++++++++++++++++------------- 1 file changed, 33 insertions(+), 20 deletions(-) diff --git a/source/libs/sync/src/syncMain.c b/source/libs/sync/src/syncMain.c index b35211a76e..67eb09418c 100644 --- a/source/libs/sync/src/syncMain.c +++ b/source/libs/sync/src/syncMain.c @@ -181,17 +181,18 @@ int32_t syncReconfig(int64_t rid, SSyncCfg* pNewCfg) { TAOS_RETURN(code); } - TAOS_CHECK_RETURN(syncNodeUpdateNewConfigIndex(pSyncNode, pNewCfg)); + syncNodeUpdateNewConfigIndex(pSyncNode, pNewCfg); syncNodeDoConfigChange(pSyncNode, pNewCfg, pNewCfg->lastIndex); if (pSyncNode->state == TAOS_SYNC_STATE_LEADER || pSyncNode->state == TAOS_SYNC_STATE_ASSIGNED_LEADER) { - TAOS_CHECK_RETURN(syncNodeStopHeartbeatTimer(pSyncNode)); + // TODO check return value + (void)syncNodeStopHeartbeatTimer(pSyncNode); for (int32_t i = 0; i < TSDB_MAX_REPLICA + TSDB_MAX_LEARNER_REPLICA; ++i) { - TAOS_CHECK_RETURN(syncHbTimerInit(pSyncNode, &pSyncNode->peerHeartbeatTimerArr[i], pSyncNode->replicasId[i])); + (void)syncHbTimerInit(pSyncNode, &pSyncNode->peerHeartbeatTimerArr[i], pSyncNode->replicasId[i]); } - TAOS_CHECK_RETURN(syncNodeStartHeartbeatTimer(pSyncNode)); + (void)syncNodeStartHeartbeatTimer(pSyncNode); // syncNodeReplicate(pSyncNode); } @@ -394,7 +395,9 @@ int32_t syncSendTimeoutRsp(int64_t rid, int64_t seq) { syncNodeRelease(pNode); if (ret == 1) { sInfo("send timeout response, seq:%" PRId64 " handle:%p ahandle:%p", seq, rpcMsg.info.handle, rpcMsg.info.ahandle); - return rpcSendResponse(&rpcMsg); + // TODO check return value + (void)rpcSendResponse(&rpcMsg); + return 0; } else { sError("no message handle to send timeout response, seq:%" PRId64, seq); return TSDB_CODE_SYN_INTERNAL_ERROR; @@ -982,7 +985,8 @@ int32_t syncNodeLogStoreRestoreOnNeed(SSyncNode* pNode) { ASSERTS(pNode->pFsm != NULL, "pFsm not registered"); ASSERTS(pNode->pFsm->FpGetSnapshotInfo != NULL, "FpGetSnapshotInfo not registered"); SSnapshot snapshot = {0}; - TAOS_CHECK_RETURN(pNode->pFsm->FpGetSnapshotInfo(pNode->pFsm, &snapshot)); + // TODO check return value + (void)pNode->pFsm->FpGetSnapshotInfo(pNode->pFsm, &snapshot); SyncIndex commitIndex = snapshot.lastApplyIndex; SyncIndex firstVer = pNode->pLogStore->syncLogBeginIndex(pNode->pLogStore); @@ -1219,7 +1223,8 @@ SSyncNode* syncNodeOpen(SSyncInfo* pSyncInfo, int32_t vnodeVersion) { SyncIndex commitIndex = SYNC_INDEX_INVALID; if (pSyncNode->pFsm != NULL && pSyncNode->pFsm->FpGetSnapshotInfo != NULL) { SSnapshot snapshot = {0}; - TAOS_CHECK_GOTO(pSyncNode->pFsm->FpGetSnapshotInfo(pSyncNode->pFsm, &snapshot), NULL, _error); + // TODO check return value + (void)pSyncNode->pFsm->FpGetSnapshotInfo(pSyncNode->pFsm, &snapshot); if (snapshot.lastApplyIndex > commitIndex) { commitIndex = snapshot.lastApplyIndex; sNTrace(pSyncNode, "reset commit index by snapshot"); @@ -1438,7 +1443,8 @@ int32_t syncNodeStartStandBy(SSyncNode* pSyncNode) { // state change pSyncNode->state = TAOS_SYNC_STATE_FOLLOWER; pSyncNode->roleTimeMs = taosGetTimestampMs(); - TAOS_CHECK_RETURN(syncNodeStopHeartbeatTimer(pSyncNode)); + // TODO check return value + (void)syncNodeStopHeartbeatTimer(pSyncNode); // reset elect timer, long enough int32_t electMS = TIMER_MAX_MS; @@ -1568,7 +1574,8 @@ int32_t syncNodeStartPingTimer(SSyncNode* pSyncNode) { int32_t syncNodeStopPingTimer(SSyncNode* pSyncNode) { int32_t ret = 0; (void)atomic_add_fetch_64(&pSyncNode->pingTimerLogicClockUser, 1); - TAOS_CHECK_RETURN(taosTmrStop(pSyncNode->pPingTimer)); + // TODO check return value + (void)taosTmrStop(pSyncNode->pPingTimer); pSyncNode->pPingTimer = NULL; return ret; } @@ -1595,7 +1602,8 @@ int32_t syncNodeStartElectTimer(SSyncNode* pSyncNode, int32_t ms) { int32_t syncNodeStopElectTimer(SSyncNode* pSyncNode) { int32_t ret = 0; (void)atomic_add_fetch_64(&pSyncNode->electTimerLogicClock, 1); - TAOS_CHECK_RETURN(taosTmrStop(pSyncNode->pElectTimer)); + // TODO check return value + (void)taosTmrStop(pSyncNode->pElectTimer); pSyncNode->pElectTimer = NULL; return ret; @@ -1618,9 +1626,8 @@ void syncNodeResetElectTimer(SSyncNode* pSyncNode) { electMS = syncUtilElectRandomMS(pSyncNode->electBaseLine, 2 * pSyncNode->electBaseLine); } - if ((code = syncNodeRestartElectTimer(pSyncNode, electMS)) != 0) { - sError("failed to restart elect timer since %s", tstrerror(code)); - } + // TODO check return value + (void)syncNodeRestartElectTimer(pSyncNode, electMS); sNTrace(pSyncNode, "reset elect timer, min:%d, max:%d, ms:%d", pSyncNode->electBaseLine, 2 * pSyncNode->electBaseLine, electMS); @@ -1664,8 +1671,9 @@ int32_t syncNodeStopHeartbeatTimer(SSyncNode* pSyncNode) { int32_t ret = 0; #if 0 + //TODO check return value (void)atomic_add_fetch_64(&pSyncNode->heartbeatTimerLogicClockUser, 1); - TAOS_CHECK_RETURN(taosTmrStop(pSyncNode->pHeartbeatTimer)); + (void)taosTmrStop(pSyncNode->pHeartbeatTimer); pSyncNode->pHeartbeatTimer = NULL; #endif @@ -1681,8 +1689,9 @@ int32_t syncNodeStopHeartbeatTimer(SSyncNode* pSyncNode) { #ifdef BUILD_NO_CALL int32_t syncNodeRestartHeartbeatTimer(SSyncNode* pSyncNode) { - TAOS_CHECK_RETURN(syncNodeStopHeartbeatTimer(pSyncNode)); - TAOS_CHECK_RETURN(syncNodeStartHeartbeatTimer(pSyncNode)); + // TODO check return value + (void)syncNodeStopHeartbeatTimer(pSyncNode); + (void)syncNodeStartHeartbeatTimer(pSyncNode); return 0; } #endif @@ -2258,7 +2267,8 @@ bool syncNodeHasSnapshot(SSyncNode* pSyncNode) { bool ret = false; SSnapshot snapshot = {.data = NULL, .lastApplyIndex = -1, .lastApplyTerm = 0, .lastConfigIndex = -1}; if (pSyncNode->pFsm->FpGetSnapshotInfo != NULL) { - if ((terrno = pSyncNode->pFsm->FpGetSnapshotInfo(pSyncNode->pFsm, &snapshot)) != 0) return false; + // TODO check return value + (void)pSyncNode->pFsm->FpGetSnapshotInfo(pSyncNode->pFsm, &snapshot); if (snapshot.lastApplyIndex >= SYNC_INDEX_BEGIN) { ret = true; } @@ -2271,7 +2281,8 @@ bool syncNodeHasSnapshot(SSyncNode* pSyncNode) { SyncIndex syncNodeGetLastIndex(const SSyncNode* pSyncNode) { SSnapshot snapshot = {.data = NULL, .lastApplyIndex = -1, .lastApplyTerm = 0, .lastConfigIndex = -1}; if (pSyncNode->pFsm->FpGetSnapshotInfo != NULL) { - if ((terrno = pSyncNode->pFsm->FpGetSnapshotInfo(pSyncNode->pFsm, &snapshot)) != 0) return -1; + // TODO check return value + (void)pSyncNode->pFsm->FpGetSnapshotInfo(pSyncNode->pFsm, &snapshot); } SyncIndex logLastIndex = pSyncNode->pLogStore->syncLogLastIndex(pSyncNode->pLogStore); @@ -2287,7 +2298,8 @@ SyncTerm syncNodeGetLastTerm(SSyncNode* pSyncNode) { // has snapshot SSnapshot snapshot = {.data = NULL, .lastApplyIndex = -1, .lastApplyTerm = 0, .lastConfigIndex = -1}; if (pSyncNode->pFsm->FpGetSnapshotInfo != NULL) { - if ((terrno = pSyncNode->pFsm->FpGetSnapshotInfo(pSyncNode->pFsm, &snapshot)) != 0) return lastTerm; + // TODO check return value + (void)pSyncNode->pFsm->FpGetSnapshotInfo(pSyncNode->pFsm, &snapshot); } SyncIndex logLastIndex = pSyncNode->pLogStore->syncLogLastIndex(pSyncNode->pLogStore); @@ -2382,7 +2394,8 @@ SyncTerm syncNodeGetPreTerm(SSyncNode* pSyncNode, SyncIndex index) { return preTerm; } else { if (pSyncNode->pFsm->FpGetSnapshotInfo != NULL) { - if ((terrno = pSyncNode->pFsm->FpGetSnapshotInfo(pSyncNode->pFsm, &snapshot)) != 0) return SYNC_TERM_INVALID; + // TODO check return value + (void)pSyncNode->pFsm->FpGetSnapshotInfo(pSyncNode->pFsm, &snapshot); if (snapshot.lastApplyIndex == preIndex) { return snapshot.lastApplyTerm; } From 487fcf231e5031b3d4d167d6afb831c882d09b25 Mon Sep 17 00:00:00 2001 From: xsren <285808407@qq.com> Date: Mon, 29 Jul 2024 18:20:50 +0800 Subject: [PATCH 16/28] fix: regex cache destroy --- source/client/src/clientMain.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/source/client/src/clientMain.c b/source/client/src/clientMain.c index 01a4fd5640..0a5fb1a7b4 100644 --- a/source/client/src/clientMain.c +++ b/source/client/src/clientMain.c @@ -85,7 +85,6 @@ void taos_cleanup(void) { tscWarn("failed to close clientReqRefPool"); } - DestroyRegexCache(); rpcCleanup(); tscDebug("rpc cleanup"); @@ -93,6 +92,8 @@ void taos_cleanup(void) { tmqMgmtClose(); + DestroyRegexCache(); + tscInfo("all local resources released"); taosCleanupCfg(); taosCloseLog(); From 6164e39433d514048d63b90186fc0200de167102 Mon Sep 17 00:00:00 2001 From: dmchen Date: Mon, 29 Jul 2024 11:38:04 +0000 Subject: [PATCH 17/28] fix/TD-30989 --- source/dnode/mnode/impl/src/mndDnode.c | 12 +++++++----- source/dnode/mnode/impl/src/mndDump.c | 18 +++++++++--------- source/dnode/mnode/impl/src/mndFunc.c | 2 +- source/dnode/mnode/impl/src/mndIndex.c | 24 ++++++++++++------------ source/dnode/mnode/impl/src/mndMnode.c | 22 +++++++++++----------- 5 files changed, 40 insertions(+), 38 deletions(-) diff --git a/source/dnode/mnode/impl/src/mndDnode.c b/source/dnode/mnode/impl/src/mndDnode.c index b02f754943..3e70bb20cd 100644 --- a/source/dnode/mnode/impl/src/mndDnode.c +++ b/source/dnode/mnode/impl/src/mndDnode.c @@ -185,8 +185,8 @@ static int32_t mndCreateDefaultDnode(SMnode *pMnode) { TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _OVER); code = 0; - mndUpdateIpWhiteForAllUser(pMnode, TSDB_DEFAULT_USER, dnodeObj.fqdn, IP_WHITE_ADD, - 1); // TODO: check the return value + (void)mndUpdateIpWhiteForAllUser(pMnode, TSDB_DEFAULT_USER, dnodeObj.fqdn, IP_WHITE_ADD, + 1); // TODO: check the return value _OVER: mndTransDrop(pTrans); @@ -916,7 +916,8 @@ static int32_t mndCreateDnode(SMnode *pMnode, SRpcMsg *pReq, SCreateDnodeReq *pC TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _OVER); code = 0; - mndUpdateIpWhiteForAllUser(pMnode, TSDB_DEFAULT_USER, dnodeObj.fqdn, IP_WHITE_ADD, 1); // TODO: check the return value + (void)mndUpdateIpWhiteForAllUser(pMnode, TSDB_DEFAULT_USER, dnodeObj.fqdn, IP_WHITE_ADD, + 1); // TODO: check the return value _OVER: mndTransDrop(pTrans); sdbFreeRaw(pRaw); @@ -1231,7 +1232,8 @@ static int32_t mndDropDnode(SMnode *pMnode, SRpcMsg *pReq, SDnodeObj *pDnode, SM TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _OVER); - mndUpdateIpWhiteForAllUser(pMnode, TSDB_DEFAULT_USER, pDnode->fqdn, IP_WHITE_DROP, 1); // TODO: check the return value + (void)mndUpdateIpWhiteForAllUser(pMnode, TSDB_DEFAULT_USER, pDnode->fqdn, IP_WHITE_DROP, + 1); // TODO: check the return value code = 0; _OVER: @@ -1749,7 +1751,7 @@ static int32_t mndRetrieveDnodes(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pB #ifdef TD_ENTERPRISE STR_TO_VARSTR(buf, pDnode->machineId); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, buf, false); + (void)colDataSetVal(pColInfo, numOfRows, buf, false); #endif numOfRows++; diff --git a/source/dnode/mnode/impl/src/mndDump.c b/source/dnode/mnode/impl/src/mndDump.c index ca7b5bbac6..31e092f1a4 100644 --- a/source/dnode/mnode/impl/src/mndDump.c +++ b/source/dnode/mnode/impl/src/mndDump.c @@ -74,7 +74,7 @@ void dumpFunc(SSdb *pSdb, SJson *json) { void dumpDb(SSdb *pSdb, SJson *json) { void *pIter = NULL; SJson *items = tjsonCreateObject(); - tjsonAddItemToObject(json, "dbs", items); + (void)tjsonAddItemToObject(json, "dbs", items); while (1) { SDbObj *pObj = NULL; @@ -82,7 +82,7 @@ void dumpDb(SSdb *pSdb, SJson *json) { if (pIter == NULL) break; SJson *item = tjsonCreateObject(); - tjsonAddItemToObject(items, "db", item); + (void)tjsonAddItemToObject(items, "db", item); (void)tjsonAddStringToObject(item, "name", mndGetDbStr(pObj->name)); (void)tjsonAddStringToObject(item, "acct", pObj->acct); @@ -546,7 +546,7 @@ void dumpHeader(SSdb *pSdb, SJson *json) { (void)tjsonAddStringToObject(json, "applyConfig", i642str(pSdb->applyConfig)); SJson *maxIdsJson = tjsonCreateObject(); - tjsonAddItemToObject(json, "maxIds", maxIdsJson); + (void)tjsonAddItemToObject(json, "maxIds", maxIdsJson); for (int32_t i = 0; i < SDB_MAX; ++i) { if(i == 5) continue; int64_t maxId = 0; @@ -557,7 +557,7 @@ void dumpHeader(SSdb *pSdb, SJson *json) { } SJson *tableVersJson = tjsonCreateObject(); - tjsonAddItemToObject(json, "tableVers", tableVersJson); + (void)tjsonAddItemToObject(json, "tableVers", tableVersJson); for (int32_t i = 0; i < SDB_MAX; ++i) { int64_t tableVer = 0; if (i < SDB_MAX) { @@ -581,8 +581,8 @@ void mndDumpSdb() { msgCb.mgmt = (SMgmtWrapper *)(&msgCb); // hack tmsgSetDefault(&msgCb); - walInit(); - syncInit(); + (void)walInit(); + (void)syncInit(); SMnodeOpt opt = {.msgCb = msgCb}; SMnode *pMnode = mndOpen(path, &opt); @@ -620,10 +620,10 @@ void mndDumpSdb() { mError("failed to write %s since %s", file, terrstr()); return; } - taosWriteFile(pFile, pCont, contLen); - taosWriteFile(pFile, "\n", 1); + (void)taosWriteFile(pFile, pCont, contLen); + (void)taosWriteFile(pFile, "\n", 1); UNUSED(taosFsyncFile(pFile)); - taosCloseFile(&pFile); + (void)taosCloseFile(&pFile); tjsonDelete(json); taosMemoryFree(pCont); diff --git a/source/dnode/mnode/impl/src/mndFunc.c b/source/dnode/mnode/impl/src/mndFunc.c index 442da63b31..f89394ee22 100644 --- a/source/dnode/mnode/impl/src/mndFunc.c +++ b/source/dnode/mnode/impl/src/mndFunc.c @@ -598,7 +598,7 @@ static int32_t mndProcessRetrieveFuncReq(SRpcMsg *pReq) { goto RETRIEVE_FUNC_OVER; } - tSerializeSRetrieveFuncRsp(pRsp, contLen, &retrieveRsp); + (void)tSerializeSRetrieveFuncRsp(pRsp, contLen, &retrieveRsp); pReq->info.rsp = pRsp; pReq->info.rspLen = contLen; diff --git a/source/dnode/mnode/impl/src/mndIndex.c b/source/dnode/mnode/impl/src/mndIndex.c index 6fc9194249..c4cad8e5a8 100644 --- a/source/dnode/mnode/impl/src/mndIndex.c +++ b/source/dnode/mnode/impl/src/mndIndex.c @@ -159,7 +159,7 @@ static void *mndBuildDropIdxReq(SMnode *pMnode, SVgObj *pVgroup, SStbObj *pStbOb pHead->vgId = htonl(pVgroup->vgId); void *pBuf = POINTER_SHIFT(pHead, sizeof(SMsgHead)); - tSerializeSDropIdxReq(pBuf, len - sizeof(SMsgHead), &req); + (void)tSerializeSDropIdxReq(pBuf, len - sizeof(SMsgHead), &req); *contLen = len; return pHead; _err: @@ -333,10 +333,10 @@ void mndReleaseIdx(SMnode *pMnode, SIdxObj *pIdx) { SDbObj *mndAcquireDbByIdx(SMnode *pMnode, const char *idxName) { SName name = {0}; - tNameFromString(&name, idxName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); + TAOS_CHECK_RETURN(tNameFromString(&name, idxName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE)); char db[TSDB_TABLE_FNAME_LEN] = {0}; - tNameGetFullDbName(&name, db); + (void)tNameGetFullDbName(&name, db); return mndAcquireDb(pMnode, db); } @@ -578,7 +578,7 @@ int32_t mndRetrieveTagIdx(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, i cols = 0; SName idxName = {0}; - tNameFromString(&idxName, pIdx->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); + (void)tNameFromString(&idxName, pIdx->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); char n1[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0}; STR_TO_VARSTR(n1, (char *)tNameGetTableName(&idxName)); @@ -587,37 +587,37 @@ int32_t mndRetrieveTagIdx(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, i STR_TO_VARSTR(n2, (char *)mndGetDbStr(pIdx->db)); SName stbName = {0}; - tNameFromString(&stbName, pIdx->stb, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); + (void)tNameFromString(&stbName, pIdx->stb, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); char n3[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0}; STR_TO_VARSTR(n3, (char *)tNameGetTableName(&stbName)); SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)n1, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)n1, false); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)n2, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)n2, false); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)n3, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)n3, false); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, NULL, true); + (void)colDataSetVal(pColInfo, numOfRows, NULL, true); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)&pIdx->createdTime, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pIdx->createdTime, false); char col[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0}; STR_TO_VARSTR(col, (char *)pIdx->colName); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)col, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)col, false); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); char tag[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0}; STR_TO_VARSTR(tag, (char *)"tag_index"); - colDataSetVal(pColInfo, numOfRows, (const char *)tag, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)tag, false); numOfRows++; sdbRelease(pSdb, pIdx); diff --git a/source/dnode/mnode/impl/src/mndMnode.c b/source/dnode/mnode/impl/src/mndMnode.c index 014d6468ff..67fdcc2466 100644 --- a/source/dnode/mnode/impl/src/mndMnode.c +++ b/source/dnode/mnode/impl/src/mndMnode.c @@ -270,7 +270,7 @@ void mndGetMnodeEpSet(SMnode *pMnode, SEpSet *pEpSet) { } } if (pObj->pDnode != NULL) { - addEpIntoEpSet(pEpSet, pObj->pDnode->fqdn, pObj->pDnode->port); + (void)addEpIntoEpSet(pEpSet, pObj->pDnode->fqdn, pObj->pDnode->port); } sdbRelease(pSdb, pObj); } @@ -341,7 +341,7 @@ static int32_t mndBuildCreateMnodeRedoAction(STrans *pTrans, SDCreateMnodeReq *p int32_t code = 0; int32_t contLen = tSerializeSDCreateMnodeReq(NULL, 0, pCreateReq); void *pReq = taosMemoryMalloc(contLen); - tSerializeSDCreateMnodeReq(pReq, contLen, pCreateReq); + (void)tSerializeSDCreateMnodeReq(pReq, contLen, pCreateReq); STransAction action = { .epSet = *pCreateEpSet, @@ -363,7 +363,7 @@ static int32_t mndBuildAlterMnodeTypeRedoAction(STrans *pTrans, SDAlterMnodeType int32_t code = 0; int32_t contLen = tSerializeSDCreateMnodeReq(NULL, 0, pAlterMnodeTypeReq); void *pReq = taosMemoryMalloc(contLen); - tSerializeSDCreateMnodeReq(pReq, contLen, pAlterMnodeTypeReq); + (void)tSerializeSDCreateMnodeReq(pReq, contLen, pAlterMnodeTypeReq); STransAction action = { .epSet = *pAlterMnodeTypeEpSet, @@ -385,7 +385,7 @@ static int32_t mndBuildAlterMnodeRedoAction(STrans *pTrans, SDCreateMnodeReq *pA int32_t code = 0; int32_t contLen = tSerializeSDCreateMnodeReq(NULL, 0, pAlterReq); void *pReq = taosMemoryMalloc(contLen); - tSerializeSDCreateMnodeReq(pReq, contLen, pAlterReq); + (void)tSerializeSDCreateMnodeReq(pReq, contLen, pAlterReq); STransAction action = { .epSet = *pAlterEpSet, @@ -407,7 +407,7 @@ static int32_t mndBuildDropMnodeRedoAction(STrans *pTrans, SDDropMnodeReq *pDrop int32_t code = 0; int32_t contLen = tSerializeSCreateDropMQSNodeReq(NULL, 0, pDropReq); void *pReq = taosMemoryMalloc(contLen); - tSerializeSCreateDropMQSNodeReq(pReq, contLen, pDropReq); + (void)tSerializeSCreateDropMQSNodeReq(pReq, contLen, pDropReq); STransAction action = { .epSet = *pDroprEpSet, @@ -881,13 +881,13 @@ static int32_t mndRetrieveMnodes(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pB cols = 0; SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)&pObj->id, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pObj->id, false); char b1[TSDB_EP_LEN + VARSTR_HEADER_SIZE] = {0}; STR_WITH_MAXSIZE_TO_VARSTR(b1, pObj->pDnode->ep, TSDB_EP_LEN + VARSTR_HEADER_SIZE); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, b1, false); + (void)colDataSetVal(pColInfo, numOfRows, b1, false); char role[20] = "offline"; if (pObj->id == pMnode->selfDnodeId) { @@ -904,7 +904,7 @@ static int32_t mndRetrieveMnodes(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pB char b2[12 + VARSTR_HEADER_SIZE] = {0}; STR_WITH_MAXSIZE_TO_VARSTR(b2, role, pShow->pMeta->pSchemas[cols].bytes); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)b2, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)b2, false); const char *status = "ready"; if (objStatus == SDB_STATUS_CREATING) status = "creating"; @@ -913,14 +913,14 @@ static int32_t mndRetrieveMnodes(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pB char b3[9 + VARSTR_HEADER_SIZE] = {0}; STR_WITH_MAXSIZE_TO_VARSTR(b3, status, pShow->pMeta->pSchemas[cols].bytes); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)b3, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)b3, false); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)&pObj->createdTime, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pObj->createdTime, false); int64_t roleTimeMs = (isDnodeOnline) ? pObj->roleTimeMs : 0; pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)&roleTimeMs, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)&roleTimeMs, false); numOfRows++; sdbRelease(pSdb, pObj); From 00cc66eb15cd5d8cc773042413e3ebc58d7fc900 Mon Sep 17 00:00:00 2001 From: yihaoDeng Date: Mon, 29 Jul 2024 19:41:44 +0800 Subject: [PATCH 18/28] refactor mgt --- include/util/tlockfree.h | 8 +- source/common/src/rsync.c | 8 +- source/dnode/mgmt/exe/dmMain.c | 42 +++++----- source/dnode/mgmt/mgmt_dnode/src/dmHandle.c | 63 +++++++++++---- source/dnode/mgmt/mgmt_dnode/src/dmWorker.c | 66 ++++++++-------- source/dnode/mgmt/mgmt_mnode/src/mmHandle.c | 4 +- source/dnode/mgmt/mgmt_mnode/src/mmInt.c | 8 +- source/dnode/mgmt/mgmt_mnode/src/mmWorker.c | 24 +++--- source/dnode/mgmt/mgmt_qnode/src/qmHandle.c | 4 +- source/dnode/mgmt/mgmt_qnode/src/qmWorker.c | 15 ++-- source/dnode/mgmt/mgmt_snode/src/smWorker.c | 4 +- source/dnode/mgmt/mgmt_vnode/src/vmFile.c | 6 +- source/dnode/mgmt/mgmt_vnode/src/vmHandle.c | 47 ++++++------ source/dnode/mgmt/mgmt_vnode/src/vmInt.c | 76 +++++++++---------- source/dnode/mgmt/mgmt_vnode/src/vmWorker.c | 4 +- source/dnode/mgmt/node_mgmt/src/dmEnv.c | 8 +- source/dnode/mgmt/node_mgmt/src/dmMgmt.c | 39 +++++----- source/dnode/mgmt/node_mgmt/src/dmNodes.c | 4 +- source/dnode/mgmt/node_mgmt/src/dmTransport.c | 40 +++++----- source/dnode/mgmt/node_util/src/dmEps.c | 60 +++++++-------- 20 files changed, 287 insertions(+), 243 deletions(-) diff --git a/include/util/tlockfree.h b/include/util/tlockfree.h index 82dd5a0e8b..1a575f8ea1 100644 --- a/include/util/tlockfree.h +++ b/include/util/tlockfree.h @@ -84,7 +84,7 @@ int32_t taosWTryLockLatch(SRWLatch *pLatch); int32_t old_ = atomic_add_fetch_32((x), 0); \ if (old_ & 0x00000001) { \ if (i_ % 1000 == 0) { \ - sched_yield(); \ + (void)sched_yield(); \ } \ continue; \ } @@ -98,9 +98,9 @@ int32_t taosWTryLockLatch(SRWLatch *pLatch); #define taosCorBeginWrite(x) \ taosCorBeginRead(x) if (atomic_val_compare_exchange_32((x), old_, old_ + 1) != old_) { continue; } -#define taosCorEndWrite(x) \ - atomic_add_fetch_32((x), 1); \ - break; \ +#define taosCorEndWrite(x) \ + (void)atomic_add_fetch_32((x), 1); \ + break; \ } #ifdef __cplusplus diff --git a/source/common/src/rsync.c b/source/common/src/rsync.c index 5e51f62a1f..c7044864ae 100644 --- a/source/common/src/rsync.c +++ b/source/common/src/rsync.c @@ -32,10 +32,10 @@ static void removeEmptyDir() { empty = false; } if (empty) taosRemoveDir(filename); - taosCloseDir(&pDirTmp); + (void)taosCloseDir(&pDirTmp); } - taosCloseDir(&pDir); + (void)taosCloseDir(&pDir); } #ifdef WINDOWS @@ -92,12 +92,12 @@ static int32_t generateConfigFile(char* confDir) { uDebug("[rsync] conf:%s", confContent); if (taosWriteFile(pFile, confContent, strlen(confContent)) <= 0) { uError("[rsync] write conf file error," ERRNO_ERR_FORMAT, ERRNO_ERR_DATA); - taosCloseFile(&pFile); + (void)taosCloseFile(&pFile); code = TAOS_SYSTEM_ERROR(errno); return code; } - taosCloseFile(&pFile); + (void)taosCloseFile(&pFile); return 0; } diff --git a/source/dnode/mgmt/exe/dmMain.c b/source/dnode/mgmt/exe/dmMain.c index 2d748706b5..b3e5015706 100644 --- a/source/dnode/mgmt/exe/dmMain.c +++ b/source/dnode/mgmt/exe/dmMain.c @@ -80,11 +80,11 @@ static void dmSetAssert(int32_t signum, void *sigInfo, void *context) { tsAssert static void dmStopDnode(int signum, void *sigInfo, void *context) { // taosIgnSignal(SIGUSR1); // taosIgnSignal(SIGUSR2); - taosIgnSignal(SIGTERM); - taosIgnSignal(SIGHUP); - taosIgnSignal(SIGINT); - taosIgnSignal(SIGABRT); - taosIgnSignal(SIGBREAK); + (void)taosIgnSignal(SIGTERM); + (void)taosIgnSignal(SIGHUP); + (void)taosIgnSignal(SIGINT); + (void)taosIgnSignal(SIGABRT); + (void)taosIgnSignal(SIGBREAK); dInfo("shut down signal is %d", signum); #ifndef WINDOWS @@ -102,11 +102,11 @@ void dmLogCrash(int signum, void *sigInfo, void *context) { // taosIgnSignal(SIGBREAK); #ifndef WINDOWS - taosIgnSignal(SIGBUS); + (void)taosIgnSignal(SIGBUS); #endif - taosIgnSignal(SIGABRT); - taosIgnSignal(SIGFPE); - taosIgnSignal(SIGSEGV); + (void)taosIgnSignal(SIGABRT); + (void)taosIgnSignal(SIGFPE); + (void)taosIgnSignal(SIGSEGV); char *pMsg = NULL; const char *flags = "UTL FATAL "; @@ -135,23 +135,23 @@ _return: } static void dmSetSignalHandle() { - taosSetSignal(SIGUSR1, dmSetDebugFlag); - taosSetSignal(SIGUSR2, dmSetAssert); - taosSetSignal(SIGTERM, dmStopDnode); - taosSetSignal(SIGHUP, dmStopDnode); - taosSetSignal(SIGINT, dmStopDnode); - taosSetSignal(SIGBREAK, dmStopDnode); + (void)taosSetSignal(SIGUSR1, dmSetDebugFlag); + (void)taosSetSignal(SIGUSR2, dmSetAssert); + (void)taosSetSignal(SIGTERM, dmStopDnode); + (void)taosSetSignal(SIGHUP, dmStopDnode); + (void)taosSetSignal(SIGINT, dmStopDnode); + (void)taosSetSignal(SIGBREAK, dmStopDnode); #ifndef WINDOWS - taosSetSignal(SIGTSTP, dmStopDnode); - taosSetSignal(SIGQUIT, dmStopDnode); + (void)taosSetSignal(SIGTSTP, dmStopDnode); + (void)taosSetSignal(SIGQUIT, dmStopDnode); #endif #ifndef WINDOWS - taosSetSignal(SIGBUS, dmLogCrash); + (void)taosSetSignal(SIGBUS, dmLogCrash); #endif - taosSetSignal(SIGABRT, dmLogCrash); - taosSetSignal(SIGFPE, dmLogCrash); - taosSetSignal(SIGSEGV, dmLogCrash); + (void)taosSetSignal(SIGABRT, dmLogCrash); + (void)taosSetSignal(SIGFPE, dmLogCrash); + (void)taosSetSignal(SIGSEGV, dmLogCrash); } static int32_t dmParseArgs(int32_t argc, char const *argv[]) { diff --git a/source/dnode/mgmt/mgmt_dnode/src/dmHandle.c b/source/dnode/mgmt/mgmt_dnode/src/dmHandle.c index f50754992c..d3c325c262 100644 --- a/source/dnode/mgmt/mgmt_dnode/src/dmHandle.c +++ b/source/dnode/mgmt/mgmt_dnode/src/dmHandle.c @@ -21,32 +21,45 @@ extern SConfig *tsCfg; static void dmUpdateDnodeCfg(SDnodeMgmt *pMgmt, SDnodeCfg *pCfg) { + int32_t code = 0; if (pMgmt->pData->dnodeId == 0 || pMgmt->pData->clusterId == 0) { dInfo("set local info, dnodeId:%d clusterId:%" PRId64, pCfg->dnodeId, pCfg->clusterId); - taosThreadRwlockWrlock(&pMgmt->pData->lock); + (void)taosThreadRwlockWrlock(&pMgmt->pData->lock); pMgmt->pData->dnodeId = pCfg->dnodeId; pMgmt->pData->clusterId = pCfg->clusterId; - dmWriteEps(pMgmt->pData); - taosThreadRwlockUnlock(&pMgmt->pData->lock); + code = dmWriteEps(pMgmt->pData); + if (code != 0) { + dInfo("failed to set local info, dnodeId:%d clusterId:%" PRId64 " reason:%s", pCfg->dnodeId, pCfg->clusterId, + tstrerror(code)); + } + (void)taosThreadRwlockUnlock(&pMgmt->pData->lock); } } static void dmMayShouldUpdateIpWhiteList(SDnodeMgmt *pMgmt, int64_t ver) { + int32_t code = 0; dDebug("ip-white-list on dnode ver: %" PRId64 ", status ver: %" PRId64 "", pMgmt->pData->ipWhiteVer, ver); if (pMgmt->pData->ipWhiteVer == ver) { if (ver == 0) { dDebug("disable ip-white-list on dnode ver: %" PRId64 ", status ver: %" PRId64 "", pMgmt->pData->ipWhiteVer, ver); rpcSetIpWhite(pMgmt->msgCb.serverRpc, NULL); - // pMgmt->ipWhiteVer = ver; } return; } int64_t oldVer = pMgmt->pData->ipWhiteVer; - // pMgmt->ipWhiteVer = ver; SRetrieveIpWhiteReq req = {.ipWhiteVer = oldVer}; int32_t contLen = tSerializeRetrieveIpWhite(NULL, 0, &req); - void *pHead = rpcMallocCont(contLen); - tSerializeRetrieveIpWhite(pHead, contLen, &req); + if (contLen < 0) { + dError("failed to serialize ip white list request since: %s", tstrerror(contLen)); + return; + } + void *pHead = rpcMallocCont(contLen); + contLen = tSerializeRetrieveIpWhite(pHead, contLen, &req); + if (contLen < 0) { + rpcFreeCont(pHead); + dError("failed to serialize ip white list request since:%s", tstrerror(contLen)); + return; + } SRpcMsg rpcMsg = {.pCont = pHead, .contLen = contLen, @@ -57,9 +70,12 @@ static void dmMayShouldUpdateIpWhiteList(SDnodeMgmt *pMgmt, int64_t ver) { .info.handle = 0}; SEpSet epset = {0}; - dmGetMnodeEpSet(pMgmt->pData, &epset); + (void)dmGetMnodeEpSet(pMgmt->pData, &epset); - rpcSendRequest(pMgmt->msgCb.clientRpc, &epset, &rpcMsg, NULL); + code = rpcSendRequest(pMgmt->msgCb.clientRpc, &epset, &rpcMsg, NULL); + if (code != 0) { + dError("failed to send retrieve ip white list request since:%s", tstrerror(code)); + } } static void dmProcessStatusRsp(SDnodeMgmt *pMgmt, SRpcMsg *pRsp) { const STraceId *trace = &pRsp->info.traceId; @@ -72,7 +88,7 @@ static void dmProcessStatusRsp(SDnodeMgmt *pMgmt, SRpcMsg *pRsp) { pMgmt->pData->dropped = 1; dmWriteEps(pMgmt->pData); dInfo("dnode will exit since it is in the dropped state"); - raise(SIGINT); + (void)raise(SIGINT); } } else { SStatusRsp statusRsp = {0}; @@ -93,9 +109,10 @@ static void dmProcessStatusRsp(SDnodeMgmt *pMgmt, SRpcMsg *pRsp) { } void dmSendStatusReq(SDnodeMgmt *pMgmt) { + int32_t code = 0; SStatusReq req = {0}; - taosThreadRwlockRdlock(&pMgmt->pData->lock); + (void)taosThreadRwlockRdlock(&pMgmt->pData->lock); req.sver = tsVersion; req.dnodeVer = pMgmt->pData->dnodeVer; req.dnodeId = pMgmt->pData->dnodeId; @@ -129,7 +146,7 @@ void dmSendStatusReq(SDnodeMgmt *pMgmt) { memcpy(req.clusterCfg.timezone, tsTimezoneStr, TD_TIMEZONE_LEN); memcpy(req.clusterCfg.locale, tsLocale, TD_LOCALE_LEN); memcpy(req.clusterCfg.charset, tsCharset, TD_LOCALE_LEN); - taosThreadRwlockUnlock(&pMgmt->pData->lock); + (void)taosThreadRwlockUnlock(&pMgmt->pData->lock); SMonVloadInfo vinfo = {0}; (*pMgmt->getVnodeLoadsFp)(&vinfo); @@ -146,8 +163,17 @@ void dmSendStatusReq(SDnodeMgmt *pMgmt) { req.ipWhiteVer = pMgmt->pData->ipWhiteVer; int32_t contLen = tSerializeSStatusReq(NULL, 0, &req); - void *pHead = rpcMallocCont(contLen); + if (contLen < 0) { + dError("failed to serialize status req since %s", tstrerror(contLen)); + return; + } + void *pHead = rpcMallocCont(contLen); tSerializeSStatusReq(pHead, contLen, &req); + if (contLen < 0) { + rpcFreeCont(pHead); + dError("failed to serialize status req since %s", tstrerror(contLen)); + return; + } tFreeSStatusReq(&req); SRpcMsg rpcMsg = {.pCont = pHead, @@ -163,8 +189,15 @@ void dmSendStatusReq(SDnodeMgmt *pMgmt) { SEpSet epSet = {0}; int8_t epUpdated = 0; - dmGetMnodeEpSet(pMgmt->pData, &epSet); - rpcSendRecvWithTimeout(pMgmt->msgCb.statusRpc, &epSet, &rpcMsg, &rpcRsp, &epUpdated, tsStatusInterval * 5 * 1000); + (void)dmGetMnodeEpSet(pMgmt->pData, &epSet); + + code = + rpcSendRecvWithTimeout(pMgmt->msgCb.statusRpc, &epSet, &rpcMsg, &rpcRsp, &epUpdated, tsStatusInterval * 5 * 1000); + if (code != 0) { + dError("failed to send status req since %s", tstrerror(code)); + return; + } + if (rpcRsp.code != 0) { dmRotateMnodeEpSet(pMgmt->pData); char tbuf[512]; diff --git a/source/dnode/mgmt/mgmt_dnode/src/dmWorker.c b/source/dnode/mgmt/mgmt_dnode/src/dmWorker.c index add62d1edc..a3e1a64012 100644 --- a/source/dnode/mgmt/mgmt_dnode/src/dmWorker.c +++ b/source/dnode/mgmt/mgmt_dnode/src/dmWorker.c @@ -266,22 +266,22 @@ static void *dmCrashReportThreadFp(void *param) { int32_t dmStartStatusThread(SDnodeMgmt *pMgmt) { int32_t code = 0; TdThreadAttr thAttr; - taosThreadAttrInit(&thAttr); - taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE); + (void)taosThreadAttrInit(&thAttr); + (void)taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE); if (taosThreadCreate(&pMgmt->statusThread, &thAttr, dmStatusThreadFp, pMgmt) != 0) { code = TAOS_SYSTEM_ERROR(errno); dError("failed to create status thread since %s", tstrerror(code)); return code; } - taosThreadAttrDestroy(&thAttr); + (void)taosThreadAttrDestroy(&thAttr); tmsgReportStartup("dnode-status", "initialized"); return 0; } void dmStopStatusThread(SDnodeMgmt *pMgmt) { if (taosCheckPthreadValid(pMgmt->statusThread)) { - taosThreadJoin(pMgmt->statusThread, NULL); + (void)taosThreadJoin(pMgmt->statusThread, NULL); taosThreadClear(&pMgmt->statusThread); } } @@ -289,40 +289,40 @@ void dmStopStatusThread(SDnodeMgmt *pMgmt) { int32_t dmStartNotifyThread(SDnodeMgmt *pMgmt) { int32_t code = 0; TdThreadAttr thAttr; - taosThreadAttrInit(&thAttr); - taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE); + (void)taosThreadAttrInit(&thAttr); + (void)taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE); if (taosThreadCreate(&pMgmt->notifyThread, &thAttr, dmNotifyThreadFp, pMgmt) != 0) { code = TAOS_SYSTEM_ERROR(errno); dError("failed to create notify thread since %s", strerror(code)); return code; } - taosThreadAttrDestroy(&thAttr); + (void)taosThreadAttrDestroy(&thAttr); tmsgReportStartup("dnode-notify", "initialized"); return 0; } void dmStopNotifyThread(SDnodeMgmt *pMgmt) { if (taosCheckPthreadValid(pMgmt->notifyThread)) { - tsem_post(&dmNotifyHdl.sem); - taosThreadJoin(pMgmt->notifyThread, NULL); + (void)tsem_post(&dmNotifyHdl.sem); + (void)taosThreadJoin(pMgmt->notifyThread, NULL); taosThreadClear(&pMgmt->notifyThread); } - tsem_destroy(&dmNotifyHdl.sem); + (void)tsem_destroy(&dmNotifyHdl.sem); } int32_t dmStartMonitorThread(SDnodeMgmt *pMgmt) { int32_t code = 0; TdThreadAttr thAttr; - taosThreadAttrInit(&thAttr); - taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE); + (void)taosThreadAttrInit(&thAttr); + (void)taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE); if (taosThreadCreate(&pMgmt->monitorThread, &thAttr, dmMonitorThreadFp, pMgmt) != 0) { code = TAOS_SYSTEM_ERROR(errno); dError("failed to create monitor thread since %s", tstrerror(code)); return code; } - taosThreadAttrDestroy(&thAttr); + (void)taosThreadAttrDestroy(&thAttr); tmsgReportStartup("dnode-monitor", "initialized"); return 0; } @@ -330,30 +330,30 @@ int32_t dmStartMonitorThread(SDnodeMgmt *pMgmt) { int32_t dmStartAuditThread(SDnodeMgmt *pMgmt) { int32_t code = 0; TdThreadAttr thAttr; - taosThreadAttrInit(&thAttr); - taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE); + (void)taosThreadAttrInit(&thAttr); + (void)taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE); if (taosThreadCreate(&pMgmt->auditThread, &thAttr, dmAuditThreadFp, pMgmt) != 0) { code = TAOS_SYSTEM_ERROR(errno); dError("failed to create audit thread since %s", tstrerror(code)); return code; } - taosThreadAttrDestroy(&thAttr); + (void)taosThreadAttrDestroy(&thAttr); tmsgReportStartup("dnode-audit", "initialized"); return 0; } void dmStopMonitorThread(SDnodeMgmt *pMgmt) { if (taosCheckPthreadValid(pMgmt->monitorThread)) { - taosThreadJoin(pMgmt->monitorThread, NULL); - taosThreadClear(&pMgmt->monitorThread); + (void)taosThreadJoin(pMgmt->monitorThread, NULL); + (void)taosThreadClear(&pMgmt->monitorThread); } } void dmStopAuditThread(SDnodeMgmt *pMgmt) { if (taosCheckPthreadValid(pMgmt->auditThread)) { - taosThreadJoin(pMgmt->auditThread, NULL); - taosThreadClear(&pMgmt->auditThread); + (void)taosThreadJoin(pMgmt->auditThread, NULL); + (void)taosThreadClear(&pMgmt->auditThread); } } @@ -364,15 +364,15 @@ int32_t dmStartCrashReportThread(SDnodeMgmt *pMgmt) { } TdThreadAttr thAttr; - taosThreadAttrInit(&thAttr); - taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE); + (void)taosThreadAttrInit(&thAttr); + (void)taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE); if (taosThreadCreate(&pMgmt->crashReportThread, &thAttr, dmCrashReportThreadFp, pMgmt) != 0) { code = TAOS_SYSTEM_ERROR(errno); dError("failed to create crashReport thread since %s", tstrerror(code)); return code; } - taosThreadAttrDestroy(&thAttr); + (void)taosThreadAttrDestroy(&thAttr); tmsgReportStartup("dnode-crashReport", "initialized"); return 0; } @@ -383,8 +383,8 @@ void dmStopCrashReportThread(SDnodeMgmt *pMgmt) { } if (taosCheckPthreadValid(pMgmt->crashReportThread)) { - taosThreadJoin(pMgmt->crashReportThread, NULL); - taosThreadClear(&pMgmt->crashReportThread); + (void)taosThreadJoin(pMgmt->crashReportThread, NULL); + (void)taosThreadClear(&pMgmt->crashReportThread); } } @@ -454,7 +454,11 @@ static void dmProcessMgmtQueue(SQueueInfo *pInfo, SRpcMsg *pMsg) { .contLen = pMsg->info.rspLen, .info = pMsg->info, }; - rpcSendResponse(&rsp); + + code = rpcSendResponse(&rsp); + if (code != 0) { + dError("failed to send response since %s", tstrerror(code)); + } } dTrace("msg:%p, is freed, code:0x%x", pMsg, code); @@ -463,6 +467,7 @@ static void dmProcessMgmtQueue(SQueueInfo *pInfo, SRpcMsg *pMsg) { } int32_t dmStartWorker(SDnodeMgmt *pMgmt) { + int32_t code = 0; SSingleWorkerCfg cfg = { .min = 1, .max = 1, @@ -470,9 +475,9 @@ int32_t dmStartWorker(SDnodeMgmt *pMgmt) { .fp = (FItem)dmProcessMgmtQueue, .param = pMgmt, }; - if (tSingleWorkerInit(&pMgmt->mgmtWorker, &cfg) != 0) { - dError("failed to start dnode-mgmt worker since %s", terrstr()); - return -1; + if ((code = tSingleWorkerInit(&pMgmt->mgmtWorker, &cfg)) != 0) { + dError("failed to start dnode-mgmt worker since %s", tstrerror(code)); + return code; } dDebug("dnode workers are initialized"); @@ -487,6 +492,5 @@ void dmStopWorker(SDnodeMgmt *pMgmt) { int32_t dmPutNodeMsgToMgmtQueue(SDnodeMgmt *pMgmt, SRpcMsg *pMsg) { SSingleWorker *pWorker = &pMgmt->mgmtWorker; dTrace("msg:%p, put into worker %s", pMsg, pWorker->name); - taosWriteQitem(pWorker->queue, pMsg); - return 0; + return taosWriteQitem(pWorker->queue, pMsg); } diff --git a/source/dnode/mgmt/mgmt_mnode/src/mmHandle.c b/source/dnode/mgmt/mgmt_mnode/src/mmHandle.c index 067ce528d5..7605df8e7c 100644 --- a/source/dnode/mgmt/mgmt_mnode/src/mmHandle.c +++ b/source/dnode/mgmt/mgmt_mnode/src/mmHandle.c @@ -17,12 +17,12 @@ #include "mmInt.h" void mmGetMonitorInfo(SMnodeMgmt *pMgmt, SMonMmInfo *pInfo) { - mndGetMonitorInfo(pMgmt->pMnode, &pInfo->cluster, &pInfo->vgroup, &pInfo->stb, &pInfo->grant); + (void)mndGetMonitorInfo(pMgmt->pMnode, &pInfo->cluster, &pInfo->vgroup, &pInfo->stb, &pInfo->grant); } void mmGetMnodeLoads(SMnodeMgmt *pMgmt, SMonMloadInfo *pInfo) { pInfo->isMnode = 1; - mndGetLoad(pMgmt->pMnode, &pInfo->load); + (void)mndGetLoad(pMgmt->pMnode, &pInfo->load); } int32_t mmProcessCreateReq(const SMgmtInputOpt *pInput, SRpcMsg *pMsg) { diff --git a/source/dnode/mgmt/mgmt_mnode/src/mmInt.c b/source/dnode/mgmt/mgmt_mnode/src/mmInt.c index 57436adcd0..20802e33d9 100644 --- a/source/dnode/mgmt/mgmt_mnode/src/mmInt.c +++ b/source/dnode/mgmt/mgmt_mnode/src/mmInt.c @@ -68,7 +68,7 @@ static void mmClose(SMnodeMgmt *pMgmt) { if (pMgmt->pMnode != NULL) { mmStopWorker(pMgmt); mndClose(pMgmt->pMnode); - taosThreadRwlockDestroy(&pMgmt->lock); + (void)taosThreadRwlockDestroy(&pMgmt->lock); pMgmt->pMnode = NULL; } @@ -107,7 +107,7 @@ static int32_t mmOpen(SMgmtInputOpt *pInput, SMgmtOutputOpt *pOutput) { pMgmt->msgCb = pInput->msgCb; pMgmt->msgCb.putToQueueFp = (PutToQueueFp)mmPutMsgToQueue; pMgmt->msgCb.mgmt = pMgmt; - taosThreadRwlockInit(&pMgmt->lock, NULL); + (void)taosThreadRwlockInit(&pMgmt->lock, NULL); SMnodeOpt option = {0}; if ((code = mmReadFile(pMgmt->path, &option)) != 0) { @@ -163,9 +163,9 @@ static int32_t mmStart(SMnodeMgmt *pMgmt) { static void mmStop(SMnodeMgmt *pMgmt) { dDebug("mnode-mgmt start to stop"); mndPreClose(pMgmt->pMnode); - taosThreadRwlockWrlock(&pMgmt->lock); + (void)taosThreadRwlockWrlock(&pMgmt->lock); pMgmt->stopped = 1; - taosThreadRwlockUnlock(&pMgmt->lock); + (void)taosThreadRwlockUnlock(&pMgmt->lock); mndStop(pMgmt->pMnode); } diff --git a/source/dnode/mgmt/mgmt_mnode/src/mmWorker.c b/source/dnode/mgmt/mgmt_mnode/src/mmWorker.c index 26e99f4798..fc070d0d05 100644 --- a/source/dnode/mgmt/mgmt_mnode/src/mmWorker.c +++ b/source/dnode/mgmt/mgmt_mnode/src/mmWorker.c @@ -20,20 +20,20 @@ static inline int32_t mmAcquire(SMnodeMgmt *pMgmt) { int32_t code = 0; - taosThreadRwlockRdlock(&pMgmt->lock); + (void)taosThreadRwlockRdlock(&pMgmt->lock); if (pMgmt->stopped) { code = -1; } else { - atomic_add_fetch_32(&pMgmt->refCount, 1); + (void)atomic_add_fetch_32(&pMgmt->refCount, 1); } - taosThreadRwlockUnlock(&pMgmt->lock); + (void)taosThreadRwlockUnlock(&pMgmt->lock); return code; } static inline void mmRelease(SMnodeMgmt *pMgmt) { - taosThreadRwlockRdlock(&pMgmt->lock); - atomic_sub_fetch_32(&pMgmt->refCount, 1); - taosThreadRwlockUnlock(&pMgmt->lock); + (void)taosThreadRwlockRdlock(&pMgmt->lock); + (void)atomic_sub_fetch_32(&pMgmt->refCount, 1); + (void)taosThreadRwlockUnlock(&pMgmt->lock); } static inline void mmSendRsp(SRpcMsg *pMsg, int32_t code) { @@ -100,16 +100,16 @@ static void mmProcessSyncMsg(SQueueInfo *pInfo, SRpcMsg *pMsg) { static inline int32_t mmPutMsgToWorker(SMnodeMgmt *pMgmt, SSingleWorker *pWorker, SRpcMsg *pMsg) { const STraceId *trace = &pMsg->info.traceId; - - if (mmAcquire(pMgmt) == 0) { + int32_t code = 0; + if ((code = mmAcquire(pMgmt)) == 0) { dGTrace("msg:%p, put into %s queue, type:%s", pMsg, pWorker->name, TMSG_INFO(pMsg->msgType)); - taosWriteQitem(pWorker->queue, pMsg); + code = taosWriteQitem(pWorker->queue, pMsg); mmRelease(pMgmt); - return 0; + return code; } else { - dGTrace("msg:%p, failed to put into %s queue since %s, type:%s", pMsg, pWorker->name, terrstr(), + dGTrace("msg:%p, failed to put into %s queue since %s, type:%s", pMsg, pWorker->name, tstrerror(code), TMSG_INFO(pMsg->msgType)); - return -1; + return code; } } diff --git a/source/dnode/mgmt/mgmt_qnode/src/qmHandle.c b/source/dnode/mgmt/mgmt_qnode/src/qmHandle.c index ae7125811e..a8ad26f006 100644 --- a/source/dnode/mgmt/mgmt_qnode/src/qmHandle.c +++ b/source/dnode/mgmt/mgmt_qnode/src/qmHandle.c @@ -18,13 +18,13 @@ void qmGetMonitorInfo(SQnodeMgmt *pMgmt, SMonQmInfo *qmInfo) { SQnodeLoad qload = {0}; - qndGetLoad(pMgmt->pQnode, &qload); + (void)qndGetLoad(pMgmt->pQnode, &qload); qload.dnodeId = pMgmt->pData->dnodeId; } void qmGetQnodeLoads(SQnodeMgmt *pMgmt, SQnodeLoad *pInfo) { - qndGetLoad(pMgmt->pQnode, pInfo); + (void)qndGetLoad(pMgmt->pQnode, pInfo); pInfo->dnodeId = pMgmt->pData->dnodeId; } diff --git a/source/dnode/mgmt/mgmt_qnode/src/qmWorker.c b/source/dnode/mgmt/mgmt_qnode/src/qmWorker.c index 5b380c2a0b..9ae16f7581 100644 --- a/source/dnode/mgmt/mgmt_qnode/src/qmWorker.c +++ b/source/dnode/mgmt/mgmt_qnode/src/qmWorker.c @@ -23,7 +23,7 @@ static inline void qmSendRsp(SRpcMsg *pMsg, int32_t code) { .contLen = pMsg->info.rspLen, .info = pMsg->info, }; - tmsgSendRsp(&rsp); + (void)tmsgSendRsp(&rsp); } static void qmProcessQueue(SQueueInfo *pInfo, SRpcMsg *pMsg) { @@ -43,8 +43,7 @@ static void qmProcessQueue(SQueueInfo *pInfo, SRpcMsg *pMsg) { static int32_t qmPutNodeMsgToWorker(SSingleWorker *pWorker, SRpcMsg *pMsg) { dTrace("msg:%p, put into worker %s, type:%s", pMsg, pWorker->name, TMSG_INFO(pMsg->msgType)); - taosWriteQitem(pWorker->queue, pMsg); - return 0; + return taosWriteQitem(pWorker->queue, pMsg); } int32_t qmPutNodeMsgToQueryQueue(SQnodeMgmt *pMgmt, SRpcMsg *pMsg) { @@ -69,18 +68,18 @@ int32_t qmPutRpcMsgToQueue(SQnodeMgmt *pMgmt, EQueueType qtype, SRpcMsg *pRpc) { switch (qtype) { case QUERY_QUEUE: dTrace("msg:%p, is created and will put into qnode-query queue, len:%d", pMsg, pRpc->contLen); - taosWriteQitem(pMgmt->queryWorker.queue, pMsg); - return 0; + code = taosWriteQitem(pMgmt->queryWorker.queue, pMsg); + return code; case READ_QUEUE: case FETCH_QUEUE: dTrace("msg:%p, is created and will put into qnode-fetch queue, len:%d", pMsg, pRpc->contLen); - taosWriteQitem(pMgmt->fetchWorker.queue, pMsg); - return 0; + code = taosWriteQitem(pMgmt->fetchWorker.queue, pMsg); + return code; default: terrno = TSDB_CODE_INVALID_PARA; rpcFreeCont(pMsg->pCont); taosFreeQitem(pMsg); - return -1; + return terrno; } } diff --git a/source/dnode/mgmt/mgmt_snode/src/smWorker.c b/source/dnode/mgmt/mgmt_snode/src/smWorker.c index 6d20e076dd..ad602313e0 100644 --- a/source/dnode/mgmt/mgmt_snode/src/smWorker.c +++ b/source/dnode/mgmt/mgmt_snode/src/smWorker.c @@ -23,7 +23,7 @@ static inline void smSendRsp(SRpcMsg *pMsg, int32_t code) { .contLen = pMsg->info.rspLen, .info = pMsg->info, }; - tmsgSendRsp(&rsp); + (void)tmsgSendRsp(&rsp); } static void smProcessWriteQueue(SQueueInfo *pInfo, STaosQall *qall, int32_t numOfMsgs) { @@ -31,7 +31,7 @@ static void smProcessWriteQueue(SQueueInfo *pInfo, STaosQall *qall, int32_t numO for (int32_t i = 0; i < numOfMsgs; i++) { SRpcMsg *pMsg = NULL; - taosGetQitem(qall, (void **)&pMsg); + (void)taosGetQitem(qall, (void **)&pMsg); const STraceId *trace = &pMsg->info.traceId; dTrace("msg:%p, get from snode-write queue", pMsg); diff --git a/source/dnode/mgmt/mgmt_vnode/src/vmFile.c b/source/dnode/mgmt/mgmt_vnode/src/vmFile.c index 47ae2a1395..4f2c04c6a5 100644 --- a/source/dnode/mgmt/mgmt_vnode/src/vmFile.c +++ b/source/dnode/mgmt/mgmt_vnode/src/vmFile.c @@ -20,13 +20,13 @@ #define MAX_CONTENT_LEN 2 * 1024 * 1024 int32_t vmGetVnodeListFromHash(SVnodeMgmt *pMgmt, int32_t *numOfVnodes, SVnodeObj ***ppVnodes) { - taosThreadRwlockRdlock(&pMgmt->lock); + (void)taosThreadRwlockRdlock(&pMgmt->lock); int32_t num = 0; int32_t size = taosHashGetSize(pMgmt->hash); SVnodeObj **pVnodes = taosMemoryCalloc(size, sizeof(SVnodeObj *)); if (pVnodes == NULL) { - taosThreadRwlockUnlock(&pMgmt->lock); + (void)taosThreadRwlockUnlock(&pMgmt->lock); return TSDB_CODE_OUT_OF_MEMORY; } @@ -44,7 +44,7 @@ int32_t vmGetVnodeListFromHash(SVnodeMgmt *pMgmt, int32_t *numOfVnodes, SVnodeOb } } - taosThreadRwlockUnlock(&pMgmt->lock); + (void)taosThreadRwlockUnlock(&pMgmt->lock); *numOfVnodes = num; *ppVnodes = pVnodes; diff --git a/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c b/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c index b193206e5e..d626ff449c 100644 --- a/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c +++ b/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c @@ -22,7 +22,7 @@ void vmGetVnodeLoads(SVnodeMgmt *pMgmt, SMonVloadInfo *pInfo, bool isReset) { tfsUpdateSize(pMgmt->pTfs); - taosThreadRwlockRdlock(&pMgmt->lock); + (void)taosThreadRwlockRdlock(&pMgmt->lock); void *pIter = taosHashIterate(pMgmt->hash, NULL); while (pIter) { @@ -32,21 +32,21 @@ void vmGetVnodeLoads(SVnodeMgmt *pMgmt, SMonVloadInfo *pInfo, bool isReset) { SVnodeObj *pVnode = *ppVnode; SVnodeLoad vload = {.vgId = pVnode->vgId}; if (!pVnode->failed) { - vnodeGetLoad(pVnode->pImpl, &vload); + (void)vnodeGetLoad(pVnode->pImpl, &vload); if (isReset) vnodeResetLoad(pVnode->pImpl, &vload); } - taosArrayPush(pInfo->pVloads, &vload); + (void)taosArrayPush(pInfo->pVloads, &vload); pIter = taosHashIterate(pMgmt->hash, pIter); } - taosThreadRwlockUnlock(&pMgmt->lock); + (void)taosThreadRwlockUnlock(&pMgmt->lock); } void vmGetVnodeLoadsLite(SVnodeMgmt *pMgmt, SMonVloadInfo *pInfo) { pInfo->pVloads = taosArrayInit(pMgmt->state.totalVnodes, sizeof(SVnodeLoadLite)); if (!pInfo->pVloads) return; - taosThreadRwlockRdlock(&pMgmt->lock); + (void)taosThreadRwlockRdlock(&pMgmt->lock); void *pIter = taosHashIterate(pMgmt->hash, NULL); while (pIter) { @@ -57,13 +57,13 @@ void vmGetVnodeLoadsLite(SVnodeMgmt *pMgmt, SMonVloadInfo *pInfo) { if (!pVnode->failed) { SVnodeLoadLite vload = {0}; if (vnodeGetLoadLite(pVnode->pImpl, &vload) == 0) { - taosArrayPush(pInfo->pVloads, &vload); + (void)taosArrayPush(pInfo->pVloads, &vload); } } pIter = taosHashIterate(pMgmt->hash, pIter); } - taosThreadRwlockUnlock(&pMgmt->lock); + (void)taosThreadRwlockUnlock(&pMgmt->lock); } void vmGetMonitorInfo(SVnodeMgmt *pMgmt, SMonVmInfo *pInfo) { @@ -109,7 +109,7 @@ void vmGetMonitorInfo(SVnodeMgmt *pMgmt, SMonVmInfo *pInfo) { pMgmt->state.numOfBatchInsertReqs = numOfBatchInsertReqs; pMgmt->state.numOfBatchInsertSuccessReqs = numOfBatchInsertSuccessReqs; - tfsGetMonitorInfo(pMgmt->pTfs, &pInfo->tfs); + (void)tfsGetMonitorInfo(pMgmt->pTfs, &pInfo->tfs); taosArrayDestroy(pVloads); } @@ -200,7 +200,7 @@ static void vmGenerateVnodeCfg(SCreateVnodeReq *pCreate, SVnodeCfg *pCfg) { pNode->nodePort = pCreate->replicas[pCfg->syncCfg.replicaNum].port; pNode->nodeRole = TAOS_SYNC_ROLE_VOTER; tstrncpy(pNode->nodeFqdn, pCreate->replicas[pCfg->syncCfg.replicaNum].fqdn, TSDB_FQDN_LEN); - tmsgUpdateDnodeInfo(&pNode->nodeId, &pNode->clusterId, pNode->nodeFqdn, &pNode->nodePort); + (void)tmsgUpdateDnodeInfo(&pNode->nodeId, &pNode->clusterId, pNode->nodeFqdn, &pNode->nodePort); pCfg->syncCfg.replicaNum++; } if (pCreate->selfIndex != -1) { @@ -212,7 +212,7 @@ static void vmGenerateVnodeCfg(SCreateVnodeReq *pCreate, SVnodeCfg *pCfg) { pNode->nodePort = pCreate->learnerReplicas[pCfg->syncCfg.totalReplicaNum].port; pNode->nodeRole = TAOS_SYNC_ROLE_LEARNER; tstrncpy(pNode->nodeFqdn, pCreate->learnerReplicas[pCfg->syncCfg.totalReplicaNum].fqdn, TSDB_FQDN_LEN); - tmsgUpdateDnodeInfo(&pNode->nodeId, &pNode->clusterId, pNode->nodeFqdn, &pNode->nodePort); + (void)tmsgUpdateDnodeInfo(&pNode->nodeId, &pNode->clusterId, pNode->nodeFqdn, &pNode->nodePort); pCfg->syncCfg.totalReplicaNum++; } pCfg->syncCfg.totalReplicaNum += pCfg->syncCfg.replicaNum; @@ -323,7 +323,7 @@ int32_t vmProcessCreateVnodeReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) { SVnodeObj *pVnode = vmAcquireVnodeImpl(pMgmt, req.vgId, false); if (pVnode != NULL && (req.replica == 1 || !pVnode->failed)) { dError("vgId:%d, already exist", req.vgId); - tFreeSCreateVnodeReq(&req); + (void)tFreeSCreateVnodeReq(&req); vmReleaseVnode(pMgmt, pVnode); code = TSDB_CODE_VND_ALREADY_EXIST; return 0; @@ -374,14 +374,14 @@ int32_t vmProcessCreateVnodeReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) { goto _OVER; } - //taosThreadMutexLock(&pMgmt->createLock); + // taosThreadMutexLock(&pMgmt->createLock); code = vmWriteVnodeListToFile(pMgmt); if (code != 0) { code = terrno != 0 ? terrno : code; - //taosThreadMutexUnlock(&pMgmt->createLock); + // taosThreadMutexUnlock(&pMgmt->createLock); goto _OVER; } - //taosThreadMutexUnlock(&pMgmt->createLock); + // taosThreadMutexUnlock(&pMgmt->createLock); _OVER: if (code != 0) { @@ -392,7 +392,7 @@ _OVER: TMSG_INFO(pMsg->msgType)); } - tFreeSCreateVnodeReq(&req); + (void)tFreeSCreateVnodeReq(&req); terrno = code; return code; } @@ -779,10 +779,11 @@ int32_t vmProcessAlterVnodeReplicaReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) { } int32_t vmProcessDropVnodeReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) { + int32_t code = 0; SDropVnodeReq dropReq = {0}; if (tDeserializeSDropVnodeReq(pMsg->pCont, pMsg->contLen, &dropReq) != 0) { terrno = TSDB_CODE_INVALID_MSG; - return -1; + return terrno; } int32_t vgId = dropReq.vgId; @@ -791,25 +792,25 @@ int32_t vmProcessDropVnodeReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) { if (dropReq.dnodeId != pMgmt->pData->dnodeId) { terrno = TSDB_CODE_INVALID_MSG; dError("vgId:%d, dnodeId:%d not matched with local dnode", dropReq.vgId, dropReq.dnodeId); - return -1; + return terrno; } SVnodeObj *pVnode = vmAcquireVnodeImpl(pMgmt, vgId, false); if (pVnode == NULL) { dInfo("vgId:%d, failed to drop since %s", vgId, terrstr()); terrno = TSDB_CODE_VND_NOT_EXIST; - return -1; + return terrno; } pVnode->dropped = 1; - if (vmWriteVnodeListToFile(pMgmt) != 0) { + if ((code = vmWriteVnodeListToFile(pMgmt)) != 0) { pVnode->dropped = 0; vmReleaseVnode(pMgmt, pVnode); - return -1; + return code; } vmCloseVnode(pMgmt, pVnode, false); - vmWriteVnodeListToFile(pMgmt); + (void)vmWriteVnodeListToFile(pMgmt); dInfo("vgId:%d, is dropped", vgId); return 0; @@ -864,7 +865,7 @@ int32_t vmProcessArbHeartBeatReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) { continue; } - taosArrayPush(arbHbRsp.hbMembers, &rspMember); + (void)taosArrayPush(arbHbRsp.hbMembers, &rspMember); vmReleaseVnode(pMgmt, pVnode); } @@ -895,7 +896,7 @@ int32_t vmProcessArbHeartBeatReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) { _OVER: tFreeSVArbHeartBeatReq(&arbHbReq); tFreeSVArbHeartBeatRsp(&arbHbRsp); - return terrno == TSDB_CODE_SUCCESS ? 0 : -1; + return terrno; } SArray *vmGetMsgHandles() { diff --git a/source/dnode/mgmt/mgmt_vnode/src/vmInt.c b/source/dnode/mgmt/mgmt_vnode/src/vmInt.c index 41ee392b4d..6bc0b5fe93 100644 --- a/source/dnode/mgmt/mgmt_vnode/src/vmInt.c +++ b/source/dnode/mgmt/mgmt_vnode/src/vmInt.c @@ -23,12 +23,12 @@ int32_t vmGetPrimaryDisk(SVnodeMgmt *pMgmt, int32_t vgId) { int32_t diskId = -1; SVnodeObj *pVnode = NULL; - taosThreadRwlockRdlock(&pMgmt->lock); - taosHashGetDup(pMgmt->hash, &vgId, sizeof(int32_t), (void *)&pVnode); + (void)taosThreadRwlockRdlock(&pMgmt->lock); + (void)taosHashGetDup(pMgmt->hash, &vgId, sizeof(int32_t), (void *)&pVnode); if (pVnode != NULL) { diskId = pVnode->diskPrimary; } - taosThreadRwlockUnlock(&pMgmt->lock); + (void)taosThreadRwlockUnlock(&pMgmt->lock); return diskId; } @@ -96,8 +96,8 @@ int32_t vmAllocPrimaryDisk(SVnodeMgmt *pMgmt, int32_t vgId) { SVnodeObj *vmAcquireVnodeImpl(SVnodeMgmt *pMgmt, int32_t vgId, bool strict) { SVnodeObj *pVnode = NULL; - taosThreadRwlockRdlock(&pMgmt->lock); - taosHashGetDup(pMgmt->hash, &vgId, sizeof(int32_t), (void *)&pVnode); + (void)taosThreadRwlockRdlock(&pMgmt->lock); + (void)taosHashGetDup(pMgmt->hash, &vgId, sizeof(int32_t), (void *)&pVnode); if (pVnode == NULL || strict && (pVnode->dropped || pVnode->failed)) { terrno = TSDB_CODE_VND_INVALID_VGROUP_ID; pVnode = NULL; @@ -105,7 +105,7 @@ SVnodeObj *vmAcquireVnodeImpl(SVnodeMgmt *pMgmt, int32_t vgId, bool strict) { int32_t refCount = atomic_add_fetch_32(&pVnode->refCount, 1); // dTrace("vgId:%d, acquire vnode, ref:%d", pVnode->vgId, refCount); } - taosThreadRwlockUnlock(&pMgmt->lock); + (void)taosThreadRwlockUnlock(&pMgmt->lock); return pVnode; } @@ -115,10 +115,10 @@ SVnodeObj *vmAcquireVnode(SVnodeMgmt *pMgmt, int32_t vgId) { return vmAcquireVno void vmReleaseVnode(SVnodeMgmt *pMgmt, SVnodeObj *pVnode) { if (pVnode == NULL) return; - taosThreadRwlockRdlock(&pMgmt->lock); + (void)taosThreadRwlockRdlock(&pMgmt->lock); int32_t refCount = atomic_sub_fetch_32(&pVnode->refCount, 1); // dTrace("vgId:%d, release vnode, ref:%d", pVnode->vgId, refCount); - taosThreadRwlockUnlock(&pMgmt->lock); + (void)taosThreadRwlockUnlock(&pMgmt->lock); } static void vmFreeVnodeObj(SVnodeObj **ppVnode) { @@ -163,15 +163,15 @@ int32_t vmOpenVnode(SVnodeMgmt *pMgmt, SWrapperCfg *pCfg, SVnode *pImpl) { pVnode->failed = 1; } - taosThreadRwlockWrlock(&pMgmt->lock); + (void)taosThreadRwlockWrlock(&pMgmt->lock); SVnodeObj *pOld = NULL; - taosHashGetDup(pMgmt->hash, &pVnode->vgId, sizeof(int32_t), (void *)&pOld); + (void)taosHashGetDup(pMgmt->hash, &pVnode->vgId, sizeof(int32_t), (void *)&pOld); if (pOld) { ASSERT(pOld->failed); vmFreeVnodeObj(&pOld); } int32_t code = taosHashPut(pMgmt->hash, &pVnode->vgId, sizeof(int32_t), &pVnode, sizeof(SVnodeObj *)); - taosThreadRwlockUnlock(&pMgmt->lock); + (void)taosThreadRwlockUnlock(&pMgmt->lock); return code; } @@ -184,9 +184,9 @@ void vmCloseVnode(SVnodeMgmt *pMgmt, SVnodeObj *pVnode, bool commitAndRemoveWal) vnodeProposeCommitOnNeed(pVnode->pImpl, atExit); } - taosThreadRwlockWrlock(&pMgmt->lock); - taosHashRemove(pMgmt->hash, &pVnode->vgId, sizeof(int32_t)); - taosThreadRwlockUnlock(&pMgmt->lock); + (void)taosThreadRwlockWrlock(&pMgmt->lock); + (void)taosHashRemove(pMgmt->hash, &pVnode->vgId, sizeof(int32_t)); + (void)taosThreadRwlockUnlock(&pMgmt->lock); vmReleaseVnode(pMgmt, pVnode); if (pVnode->failed) { @@ -235,8 +235,8 @@ void vmCloseVnode(SVnodeMgmt *pMgmt, SVnodeObj *pVnode, bool commitAndRemoveWal) if (commitAndRemoveWal) { dInfo("vgId:%d, commit data for vnode split", pVnode->vgId); - vnodeSyncCommit(pVnode->pImpl); - vnodeBegin(pVnode->pImpl); + (void)vnodeSyncCommit(pVnode->pImpl); + (void)vnodeBegin(pVnode->pImpl); dInfo("vgId:%d, commit data finished", pVnode->vgId); } @@ -250,8 +250,8 @@ _closed: if (commitAndRemoveWal) { snprintf(path, TSDB_FILENAME_LEN, "vnode%svnode%d%swal", TD_DIRSEP, pVnode->vgId, TD_DIRSEP); dInfo("vgId:%d, remove all wals, path:%s", pVnode->vgId, path); - tfsRmdir(pMgmt->pTfs, path); - tfsMkdir(pMgmt->pTfs, path); + (void)tfsRmdir(pMgmt->pTfs, path); + (void)tfsMkdir(pMgmt->pTfs, path); } if (pVnode->dropped) { @@ -332,7 +332,7 @@ static void *vmOpenVnodeInThread(void *param) { dInfo("vgId:%d, is opened by thread:%d", pCfg->vgId, pThread->threadIndex); pThread->opened++; - atomic_add_fetch_32(&pMgmt->state.openVnodes, 1); + (void)atomic_add_fetch_32(&pMgmt->state.openVnodes, 1); } dInfo("thread:%d, numOfVnodes:%d, opened:%d failed:%d", pThread->threadIndex, pThread->vnodeNum, pThread->opened, @@ -381,13 +381,13 @@ static int32_t vmOpenVnodes(SVnodeMgmt *pMgmt) { if (pThread->vnodeNum == 0) continue; TdThreadAttr thAttr; - taosThreadAttrInit(&thAttr); - taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE); + (void)taosThreadAttrInit(&thAttr); + (void)taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE); if (taosThreadCreate(&pThread->thread, &thAttr, vmOpenVnodeInThread, pThread) != 0) { dError("thread:%d, failed to create thread to open vnode, reason:%s", pThread->threadIndex, strerror(errno)); } - taosThreadAttrDestroy(&thAttr); + (void)taosThreadAttrDestroy(&thAttr); } bool updateVnodesList = false; @@ -395,7 +395,7 @@ static int32_t vmOpenVnodes(SVnodeMgmt *pMgmt) { for (int32_t t = 0; t < threadNum; ++t) { SVnodeThread *pThread = &threads[t]; if (pThread->vnodeNum > 0 && taosCheckPthreadValid(pThread->thread)) { - taosThreadJoin(pThread->thread, NULL); + (void)taosThreadJoin(pThread->thread, NULL); taosThreadClear(&pThread->thread); } taosMemoryFree(pThread->pCfgs); @@ -484,19 +484,19 @@ static void vmCloseVnodes(SVnodeMgmt *pMgmt) { if (pThread->vnodeNum == 0) continue; TdThreadAttr thAttr; - taosThreadAttrInit(&thAttr); - taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE); + (void)taosThreadAttrInit(&thAttr); + (void)taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE); if (taosThreadCreate(&pThread->thread, &thAttr, vmCloseVnodeInThread, pThread) != 0) { dError("thread:%d, failed to create thread to close vnode since %s", pThread->threadIndex, strerror(errno)); } - taosThreadAttrDestroy(&thAttr); + (void)taosThreadAttrDestroy(&thAttr); } for (int32_t t = 0; t < threadNum; ++t) { SVnodeThread *pThread = &threads[t]; if (pThread->vnodeNum > 0 && taosCheckPthreadValid(pThread->thread)) { - taosThreadJoin(pThread->thread, NULL); + (void)taosThreadJoin(pThread->thread, NULL); taosThreadClear(&pThread->thread); } taosMemoryFree(pThread->ppVnodes); @@ -519,8 +519,8 @@ static void vmCleanup(SVnodeMgmt *pMgmt) { vmCloseVnodes(pMgmt); vmStopWorker(pMgmt); vnodeCleanup(); - taosThreadRwlockDestroy(&pMgmt->lock); - taosThreadMutexDestroy(&pMgmt->createLock); + (void)taosThreadRwlockDestroy(&pMgmt->lock); + (void)taosThreadMutexDestroy(&pMgmt->createLock); taosMemoryFree(pMgmt); } @@ -569,22 +569,22 @@ static void *vmThreadFp(void *param) { static int32_t vmInitTimer(SVnodeMgmt *pMgmt) { int32_t code = 0; TdThreadAttr thAttr; - taosThreadAttrInit(&thAttr); - taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE); + (void)taosThreadAttrInit(&thAttr); + (void)taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE); if (taosThreadCreate(&pMgmt->thread, &thAttr, vmThreadFp, pMgmt) != 0) { code = TAOS_SYSTEM_ERROR(errno); dError("failed to create vnode timer thread since %s", tstrerror(code)); return code; } - taosThreadAttrDestroy(&thAttr); + (void)taosThreadAttrDestroy(&thAttr); return 0; } static void vmCleanupTimer(SVnodeMgmt *pMgmt) { pMgmt->stop = true; if (taosCheckPthreadValid(pMgmt->thread)) { - taosThreadJoin(pMgmt->thread, NULL); + (void)taosThreadJoin(pMgmt->thread, NULL); taosThreadClear(&pMgmt->thread); } } @@ -707,7 +707,7 @@ static void *vmRestoreVnodeInThread(void *param) { } else { dInfo("vgId:%d, is restored by thread:%d", pVnode->vgId, pThread->threadIndex); pThread->opened++; - atomic_add_fetch_32(&pMgmt->state.openVnodes, 1); + (void)atomic_add_fetch_32(&pMgmt->state.openVnodes, 1); } } @@ -761,20 +761,20 @@ static int32_t vmStartVnodes(SVnodeMgmt *pMgmt) { if (pThread->vnodeNum == 0) continue; TdThreadAttr thAttr; - taosThreadAttrInit(&thAttr); - taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE); + (void)taosThreadAttrInit(&thAttr); + (void)taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE); if (taosThreadCreate(&pThread->thread, &thAttr, vmRestoreVnodeInThread, pThread) != 0) { dError("thread:%d, failed to create thread to restore vnode since %s", pThread->threadIndex, strerror(errno)); ASSERT(errno == 0); } - taosThreadAttrDestroy(&thAttr); + (void)taosThreadAttrDestroy(&thAttr); } for (int32_t t = 0; t < threadNum; ++t) { SVnodeThread *pThread = &threads[t]; if (pThread->vnodeNum > 0 && taosCheckPthreadValid(pThread->thread)) { - taosThreadJoin(pThread->thread, NULL); + (void)taosThreadJoin(pThread->thread, NULL); taosThreadClear(&pThread->thread); } taosMemoryFree(pThread->ppVnodes); diff --git a/source/dnode/mgmt/mgmt_vnode/src/vmWorker.c b/source/dnode/mgmt/mgmt_vnode/src/vmWorker.c index 4eaaf02573..2ad5464c31 100644 --- a/source/dnode/mgmt/mgmt_vnode/src/vmWorker.c +++ b/source/dnode/mgmt/mgmt_vnode/src/vmWorker.c @@ -187,7 +187,7 @@ static void vmProcessSyncQueue(SQueueInfo *pInfo, STaosQall *qall, int32_t numOf static void vmSendResponse(SRpcMsg *pMsg) { if (pMsg->info.handle) { SRpcMsg rsp = {.info = pMsg->info, .code = terrno}; - rpcSendResponse(&rsp); + (void)rpcSendResponse(&rsp); } } @@ -236,7 +236,7 @@ static int32_t vmPutMsgToQueue(SVnodeMgmt *pMgmt, SRpcMsg *pMsg, EQueueType qtyp dError("vgId:%d, msg:%p preprocess query msg failed since %s", pVnode->vgId, pMsg, tstrerror(code)); } else { dGTrace("vgId:%d, msg:%p put into vnode-query queue", pVnode->vgId, pMsg); - taosWriteQitem(pVnode->pQueryQ, pMsg); + code = taosWriteQitem(pVnode->pQueryQ, pMsg); } break; case STREAM_QUEUE: diff --git a/source/dnode/mgmt/node_mgmt/src/dmEnv.c b/source/dnode/mgmt/node_mgmt/src/dmEnv.c index e6e065756f..9819c4f64e 100644 --- a/source/dnode/mgmt/node_mgmt/src/dmEnv.c +++ b/source/dnode/mgmt/node_mgmt/src/dmEnv.c @@ -47,8 +47,8 @@ static int32_t dmCheckRepeatInit(SDnode *pDnode) { } static int32_t dmInitSystem() { - taosIgnSIGPIPE(); - taosBlockSIGPIPE(); + (void)taosIgnSIGPIPE(); + (void)taosBlockSIGPIPE(); taosResolveCRC(); return 0; } @@ -200,10 +200,10 @@ void dmCleanup() { auditCleanup(); syncCleanUp(); walCleanUp(); - udfcClose(); + (void)udfcClose(); udfStopUdfd(); taosStopCacheRefreshWorker(); - dmDiskClose(); + (void)dmDiskClose(); DestroyRegexCache(); #if defined(USE_S3) diff --git a/source/dnode/mgmt/node_mgmt/src/dmMgmt.c b/source/dnode/mgmt/node_mgmt/src/dmMgmt.c index ccbfeb5aa5..197a1fd129 100644 --- a/source/dnode/mgmt/node_mgmt/src/dmMgmt.c +++ b/source/dnode/mgmt/node_mgmt/src/dmMgmt.c @@ -47,7 +47,8 @@ int32_t dmInitDnode(SDnode *pDnode) { } // compress module init - tsCompressInit(tsLossyColumns, tsFPrecision, tsDPrecision, tsMaxRange, tsCurRange, (int)tsIfAdtFse, tsCompressor); + (void)tsCompressInit(tsLossyColumns, tsFPrecision, tsDPrecision, tsMaxRange, tsCurRange, (int)tsIfAdtFse, + tsCompressor); pDnode->wrappers[DNODE].func = dmGetMgmtFunc(); pDnode->wrappers[MNODE].func = mmGetMgmtFunc(); @@ -60,7 +61,7 @@ int32_t dmInitDnode(SDnode *pDnode) { pWrapper->pDnode = pDnode; pWrapper->name = dmNodeName(ntype); pWrapper->ntype = ntype; - taosThreadRwlockInit(&pWrapper->lock, NULL); + (void)taosThreadRwlockInit(&pWrapper->lock, NULL); snprintf(path, sizeof(path), "%s%s%s", tsDataDir, TD_DIRSEP, pWrapper->name); pWrapper->path = taosStrdup(path); @@ -214,8 +215,8 @@ int32_t dmInitVars(SDnode *pDnode) { return -1; } - taosThreadRwlockInit(&pData->lock, NULL); - taosThreadMutexInit(&pDnode->mutex, NULL); + (void)taosThreadRwlockInit(&pData->lock, NULL); + (void)taosThreadMutexInit(&pDnode->mutex, NULL); return 0; } @@ -223,16 +224,16 @@ void dmClearVars(SDnode *pDnode) { for (EDndNodeType ntype = DNODE; ntype < NODE_END; ++ntype) { SMgmtWrapper *pWrapper = &pDnode->wrappers[ntype]; taosMemoryFreeClear(pWrapper->path); - taosThreadRwlockDestroy(&pWrapper->lock); + (void)taosThreadRwlockDestroy(&pWrapper->lock); } if (pDnode->lockfile != NULL) { - taosUnLockFile(pDnode->lockfile); - taosCloseFile(&pDnode->lockfile); + (void)taosUnLockFile(pDnode->lockfile); + (void)taosCloseFile(&pDnode->lockfile); pDnode->lockfile = NULL; } SDnodeData *pData = &pDnode->data; - taosThreadRwlockWrlock(&pData->lock); + (void)taosThreadRwlockWrlock(&pData->lock); if (pData->oldDnodeEps != NULL) { if (dmWriteEps(pData) == 0) { dmRemoveDnodePairs(pData); @@ -248,10 +249,10 @@ void dmClearVars(SDnode *pDnode) { taosHashCleanup(pData->dnodeHash); pData->dnodeHash = NULL; } - taosThreadRwlockUnlock(&pData->lock); + (void)taosThreadRwlockUnlock(&pData->lock); - taosThreadRwlockDestroy(&pData->lock); - taosThreadMutexDestroy(&pDnode->mutex); + (void)taosThreadRwlockDestroy(&pData->lock); + (void)taosThreadMutexDestroy(&pDnode->mutex); memset(&pDnode->mutex, 0, sizeof(pDnode->mutex)); } @@ -266,14 +267,14 @@ SMgmtWrapper *dmAcquireWrapper(SDnode *pDnode, EDndNodeType ntype) { SMgmtWrapper *pWrapper = &pDnode->wrappers[ntype]; SMgmtWrapper *pRetWrapper = pWrapper; - taosThreadRwlockRdlock(&pWrapper->lock); + (void)taosThreadRwlockRdlock(&pWrapper->lock); if (pWrapper->deployed) { int32_t refCount = atomic_add_fetch_32(&pWrapper->refCount, 1); // dTrace("node:%s, is acquired, ref:%d", pWrapper->name, refCount); } else { pRetWrapper = NULL; } - taosThreadRwlockUnlock(&pWrapper->lock); + (void)taosThreadRwlockUnlock(&pWrapper->lock); return pRetWrapper; } @@ -281,7 +282,7 @@ SMgmtWrapper *dmAcquireWrapper(SDnode *pDnode, EDndNodeType ntype) { int32_t dmMarkWrapper(SMgmtWrapper *pWrapper) { int32_t code = 0; - taosThreadRwlockRdlock(&pWrapper->lock); + (void)taosThreadRwlockRdlock(&pWrapper->lock); if (pWrapper->deployed) { int32_t refCount = atomic_add_fetch_32(&pWrapper->refCount, 1); // dTrace("node:%s, is marked, ref:%d", pWrapper->name, refCount); @@ -304,7 +305,7 @@ int32_t dmMarkWrapper(SMgmtWrapper *pWrapper) { break; } } - taosThreadRwlockUnlock(&pWrapper->lock); + (void)taosThreadRwlockUnlock(&pWrapper->lock); return code; } @@ -312,9 +313,9 @@ int32_t dmMarkWrapper(SMgmtWrapper *pWrapper) { void dmReleaseWrapper(SMgmtWrapper *pWrapper) { if (pWrapper == NULL) return; - taosThreadRwlockRdlock(&pWrapper->lock); + (void)taosThreadRwlockRdlock(&pWrapper->lock); int32_t refCount = atomic_sub_fetch_32(&pWrapper->refCount, 1); - taosThreadRwlockUnlock(&pWrapper->lock); + (void)taosThreadRwlockUnlock(&pWrapper->lock); // dTrace("node:%s, is released, ref:%d", pWrapper->name, refCount); } @@ -343,7 +344,7 @@ void dmProcessNetTestReq(SDnode *pDnode, SRpcMsg *pMsg) { rsp.contLen = pMsg->contLen; } - rpcSendResponse(&rsp); + (void)rpcSendResponse(&rsp); rpcFreeCont(pMsg->pCont); } @@ -365,6 +366,6 @@ void dmProcessServerStartupStatus(SDnode *pDnode, SRpcMsg *pMsg) { } } - rpcSendResponse(&rsp); + (void)rpcSendResponse(&rsp); rpcFreeCont(pMsg->pCont); } diff --git a/source/dnode/mgmt/node_mgmt/src/dmNodes.c b/source/dnode/mgmt/node_mgmt/src/dmNodes.c index 175e470b4a..38bd9f6b92 100644 --- a/source/dnode/mgmt/node_mgmt/src/dmNodes.c +++ b/source/dnode/mgmt/node_mgmt/src/dmNodes.c @@ -77,12 +77,12 @@ void dmCloseNode(SMgmtWrapper *pWrapper) { taosMsleep(10); } - taosThreadRwlockWrlock(&pWrapper->lock); + (void)taosThreadRwlockWrlock(&pWrapper->lock); if (pWrapper->pMgmt != NULL) { (*pWrapper->func.closeFp)(pWrapper->pMgmt); pWrapper->pMgmt = NULL; } - taosThreadRwlockUnlock(&pWrapper->lock); + (void)taosThreadRwlockUnlock(&pWrapper->lock); dInfo("node:%s, has been closed", pWrapper->name); } diff --git a/source/dnode/mgmt/node_mgmt/src/dmTransport.c b/source/dnode/mgmt/node_mgmt/src/dmTransport.c index 0c04d50927..cd608d7a74 100644 --- a/source/dnode/mgmt/node_mgmt/src/dmTransport.c +++ b/source/dnode/mgmt/node_mgmt/src/dmTransport.c @@ -18,7 +18,7 @@ #include "qworker.h" #include "tversion.h" -static inline void dmSendRsp(SRpcMsg *pMsg) { rpcSendResponse(pMsg); } +static inline void dmSendRsp(SRpcMsg *pMsg) { (void)rpcSendResponse(pMsg); } static inline void dmBuildMnodeRedirectRsp(SDnode *pDnode, SRpcMsg *pMsg) { SEpSet epSet = {0}; @@ -29,7 +29,11 @@ static inline void dmBuildMnodeRedirectRsp(SDnode *pDnode, SRpcMsg *pMsg) { if (pMsg->pCont == NULL) { pMsg->code = TSDB_CODE_OUT_OF_MEMORY; } else { - tSerializeSEpSet(pMsg->pCont, contLen, &epSet); + contLen = tSerializeSEpSet(pMsg->pCont, contLen, &epSet); + if (contLen < 0) { + pMsg->code = contLen; + return; + } pMsg->contLen = contLen; } } @@ -65,14 +69,17 @@ static int32_t dmConvertErrCode(tmsg_t msgType, int32_t code) { return code; } static void dmUpdateRpcIpWhite(SDnodeData *pData, void *pTrans, SRpcMsg *pRpc) { - int32_t code = 0; + int32_t code = 0; SUpdateIpWhite ipWhite = {0}; // aosMemoryCalloc(1, sizeof(SUpdateIpWhite)); - tDeserializeSUpdateIpWhite(pRpc->pCont, pRpc->contLen, &ipWhite); - + code = tDeserializeSUpdateIpWhite(pRpc->pCont, pRpc->contLen, &ipWhite); + if (code < 0) { + dError("failed to update rpc ip-white since: %s", tstrerror(code)); + return; + } code = rpcSetIpWhite(pTrans, &ipWhite); pData->ipWhiteVer = ipWhite.ver; - tFreeSUpdateIpWhiteReq(&ipWhite); + (void)tFreeSUpdateIpWhiteReq(&ipWhite); rpcFreeCont(pRpc->pCont); } @@ -81,7 +88,7 @@ static bool dmIsForbiddenIp(int8_t forbidden, char *user, uint32_t clientIp) { SIpV4Range range = {.ip = clientIp, .mask = 32}; char buf[36] = {0}; - rpcUtilSIpRangeToStr(&range, buf); + (void)rpcUtilSIpRangeToStr(&range, buf); dError("User:%s host:%s not in ip white list", user, buf); return true; } else { @@ -100,7 +107,7 @@ static void dmProcessRpcMsg(SDnode *pDnode, SRpcMsg *pRpc, SEpSet *pEpSet) { pRpc->info.handle, pRpc->contLen, pRpc->code, pRpc->info.ahandle, pRpc->info.refId); int32_t svrVer = 0; - taosVersionStrToInt(version, &svrVer); + (void)taosVersionStrToInt(version, &svrVer); if ((code = taosCheckVersionCompatible(pRpc->info.cliVer, svrVer, 3)) != 0) { dError("Version not compatible, cli ver: %d, svr ver: %d", pRpc->info.cliVer, svrVer); goto _OVER; @@ -296,7 +303,7 @@ static inline int32_t dmSendReq(const SEpSet *pEpSet, SRpcMsg *pMsg) { return code; } else { pMsg->info.handle = 0; - rpcSendRequest(pDnode->trans.clientRpc, pEpSet, pMsg, NULL); + (void)rpcSendRequest(pDnode->trans.clientRpc, pEpSet, pMsg, NULL); return 0; } } @@ -315,14 +322,13 @@ static inline int32_t dmSendSyncReq(const SEpSet *pEpSet, SRpcMsg *pMsg) { pMsg->info.handle); return code; } else { - rpcSendRequest(pDnode->trans.syncRpc, pEpSet, pMsg, NULL); - return 0; + return rpcSendRequest(pDnode->trans.syncRpc, pEpSet, pMsg, NULL); } } -static inline void dmRegisterBrokenLinkArg(SRpcMsg *pMsg) { rpcRegisterBrokenLinkArg(pMsg); } +static inline void dmRegisterBrokenLinkArg(SRpcMsg *pMsg) { (void)rpcRegisterBrokenLinkArg(pMsg); } -static inline void dmReleaseHandle(SRpcHandleInfo *pHandle, int8_t type) { rpcReleaseHandle(pHandle, type); } +static inline void dmReleaseHandle(SRpcHandleInfo *pHandle, int8_t type) { (void)rpcReleaseHandle(pHandle, type); } static bool rpcRfp(int32_t code, tmsg_t msgType) { if (code == TSDB_CODE_RPC_NETWORK_UNAVAIL || code == TSDB_CODE_RPC_BROKEN_LINK || code == TSDB_CODE_MNODE_NOT_FOUND || @@ -382,7 +388,7 @@ int32_t dmInitClient(SDnode *pDnode) { rpcInit.batchSize = 8 * 1024; rpcInit.timeToGetConn = tsTimeToGetAvailableConn; - taosVersionStrToInt(version, &(rpcInit.compatibilityVer)); + (void)taosVersionStrToInt(version, &(rpcInit.compatibilityVer)); pTrans->clientRpc = rpcOpen(&rpcInit); if (pTrans->clientRpc == NULL) { @@ -426,7 +432,7 @@ int32_t dmInitStatusClient(SDnode *pDnode) { rpcInit.supportBatch = 1; rpcInit.batchSize = 8 * 1024; rpcInit.timeToGetConn = tsTimeToGetAvailableConn; - taosVersionStrToInt(version, &(rpcInit.compatibilityVer)); + (void)taosVersionStrToInt(version, &(rpcInit.compatibilityVer)); pTrans->statusRpc = rpcOpen(&rpcInit); if (pTrans->statusRpc == NULL) { @@ -471,7 +477,7 @@ int32_t dmInitSyncClient(SDnode *pDnode) { rpcInit.supportBatch = 1; rpcInit.batchSize = 8 * 1024; rpcInit.timeToGetConn = tsTimeToGetAvailableConn; - taosVersionStrToInt(version, &(rpcInit.compatibilityVer)); + (void)taosVersionStrToInt(version, &(rpcInit.compatibilityVer)); pTrans->syncRpc = rpcOpen(&rpcInit); if (pTrans->syncRpc == NULL) { @@ -522,7 +528,7 @@ int32_t dmInitServer(SDnode *pDnode) { rpcInit.idleTime = tsShellActivityTimer * 1000; rpcInit.parent = pDnode; rpcInit.compressSize = tsCompressMsgSize; - taosVersionStrToInt(version, &(rpcInit.compatibilityVer)); + (void)taosVersionStrToInt(version, &(rpcInit.compatibilityVer)); pTrans->serverRpc = rpcOpen(&rpcInit); if (pTrans->serverRpc == NULL) { dError("failed to init dnode rpc server"); diff --git a/source/dnode/mgmt/node_util/src/dmEps.c b/source/dnode/mgmt/node_util/src/dmEps.c index 866dce1b87..af5530215b 100644 --- a/source/dnode/mgmt/node_util/src/dmEps.c +++ b/source/dnode/mgmt/node_util/src/dmEps.c @@ -33,7 +33,7 @@ static int32_t dmReadDnodePairs(SDnodeData *pData); void dmGetDnodeEp(void *data, int32_t dnodeId, char *pEp, char *pFqdn, uint16_t *pPort) { SDnodeData *pData = data; - taosThreadRwlockRdlock(&pData->lock); + (void)taosThreadRwlockRdlock(&pData->lock); SDnodeEp *pDnodeEp = taosHashGet(pData->dnodeHash, &dnodeId, sizeof(int32_t)); if (pDnodeEp != NULL) { @@ -48,7 +48,7 @@ void dmGetDnodeEp(void *data, int32_t dnodeId, char *pEp, char *pFqdn, uint16_t } } - taosThreadRwlockUnlock(&pData->lock); + (void)taosThreadRwlockUnlock(&pData->lock); } static int32_t dmDecodeEps(SJson *pJson, SDnodeData *pData) { @@ -255,8 +255,8 @@ _OVER: if (taosArrayGetSize(pData->dnodeEps) == 0) { SDnodeEp dnodeEp = {0}; dnodeEp.isMnode = 1; - taosGetFqdnPortFromEp(tsFirst, &dnodeEp.ep); - taosArrayPush(pData->dnodeEps, &dnodeEp); + (void)taosGetFqdnPortFromEp(tsFirst, &dnodeEp.ep); + (void)taosArrayPush(pData->dnodeEps, &dnodeEp); } if ((code = dmReadDnodePairs(pData)) != 0) { @@ -337,7 +337,7 @@ int32_t dmWriteEps(SDnodeData *pData) { if (taosWriteFile(pFile, buffer, len) <= 0) TAOS_CHECK_GOTO(TAOS_SYSTEM_ERROR(errno), NULL, _OVER); if (taosFsyncFile(pFile) < 0) TAOS_CHECK_GOTO(TAOS_SYSTEM_ERROR(errno), NULL, _OVER); - taosCloseFile(&pFile); + (void)taosCloseFile(&pFile); if (taosRenameFile(file, realfile) != 0) TAOS_CHECK_GOTO(TAOS_SYSTEM_ERROR(errno), NULL, _OVER); code = 0; @@ -348,7 +348,7 @@ int32_t dmWriteEps(SDnodeData *pData) { _OVER: if (pJson != NULL) tjsonDelete(pJson); if (buffer != NULL) taosMemoryFree(buffer); - if (pFile != NULL) taosCloseFile(&pFile); + if (pFile != NULL) (void)taosCloseFile(&pFile); if (code != 0) { dError("failed to write dnode file:%s since %s, dnodeVer:%" PRId64, realfile, tstrerror(code), pData->dnodeVer); @@ -358,18 +358,18 @@ _OVER: int32_t dmGetDnodeSize(SDnodeData *pData) { int32_t size = 0; - taosThreadRwlockRdlock(&pData->lock); + (void)taosThreadRwlockRdlock(&pData->lock); size = taosArrayGetSize(pData->dnodeEps); - taosThreadRwlockUnlock(&pData->lock); + (void)taosThreadRwlockUnlock(&pData->lock); return size; } void dmUpdateEps(SDnodeData *pData, SArray *eps) { - taosThreadRwlockWrlock(&pData->lock); + (void)taosThreadRwlockWrlock(&pData->lock); dDebug("new dnode list get from mnode, dnodeVer:%" PRId64, pData->dnodeVer); dmResetEps(pData, eps); - dmWriteEps(pData); - taosThreadRwlockUnlock(&pData->lock); + (void)dmWriteEps(pData); + (void)taosThreadRwlockUnlock(&pData->lock); } static void dmResetEps(SDnodeData *pData, SArray *dnodeEps) { @@ -398,7 +398,7 @@ static void dmResetEps(SDnodeData *pData, SArray *dnodeEps) { for (int32_t i = 0; i < numOfEps; i++) { SDnodeEp *pDnodeEp = taosArrayGet(dnodeEps, i); - taosHashPut(pData->dnodeHash, &pDnodeEp->id, sizeof(int32_t), pDnodeEp, sizeof(SDnodeEp)); + (void)taosHashPut(pData->dnodeHash, &pDnodeEp->id, sizeof(int32_t), pDnodeEp, sizeof(SDnodeEp)); } pData->validMnodeEps = true; @@ -418,7 +418,7 @@ static void dmPrintEps(SDnodeData *pData) { static bool dmIsEpChanged(SDnodeData *pData, int32_t dnodeId, const char *ep) { bool changed = false; if (dnodeId == 0) return changed; - taosThreadRwlockRdlock(&pData->lock); + (void)taosThreadRwlockRdlock(&pData->lock); SDnodeEp *pDnodeEp = taosHashGet(pData->dnodeHash, &dnodeId, sizeof(int32_t)); if (pDnodeEp != NULL) { @@ -430,14 +430,14 @@ static bool dmIsEpChanged(SDnodeData *pData, int32_t dnodeId, const char *ep) { } } - taosThreadRwlockUnlock(&pData->lock); + (void)taosThreadRwlockUnlock(&pData->lock); return changed; } void dmGetMnodeEpSet(SDnodeData *pData, SEpSet *pEpSet) { - taosThreadRwlockRdlock(&pData->lock); + (void)taosThreadRwlockRdlock(&pData->lock); *pEpSet = pData->mnodeEps; - taosThreadRwlockUnlock(&pData->lock); + (void)taosThreadRwlockUnlock(&pData->lock); } void dmEpSetToStr(char *buf, int32_t len, SEpSet *epSet) { @@ -464,12 +464,12 @@ static FORCE_INLINE void dmSwapEps(SEp *epLhs, SEp *epRhs) { } void dmRotateMnodeEpSet(SDnodeData *pData) { - taosThreadRwlockRdlock(&pData->lock); + (void)taosThreadRwlockRdlock(&pData->lock); SEpSet *pEpSet = &pData->mnodeEps; for (int i = 1; i < pEpSet->numOfEps; i++) { dmSwapEps(&pEpSet->eps[i - 1], &pEpSet->eps[i]); } - taosThreadRwlockUnlock(&pData->lock); + (void)taosThreadRwlockUnlock(&pData->lock); } void dmGetMnodeEpSetForRedirect(SDnodeData *pData, SRpcMsg *pMsg, SEpSet *pEpSet) { @@ -486,9 +486,9 @@ void dmGetMnodeEpSetForRedirect(SDnodeData *pData, SRpcMsg *pMsg, SEpSet *pEpSet void dmSetMnodeEpSet(SDnodeData *pData, SEpSet *pEpSet) { if (memcmp(pEpSet, &pData->mnodeEps, sizeof(SEpSet)) == 0) return; - taosThreadRwlockWrlock(&pData->lock); + (void)taosThreadRwlockWrlock(&pData->lock); pData->mnodeEps = *pEpSet; - taosThreadRwlockUnlock(&pData->lock); + (void)taosThreadRwlockUnlock(&pData->lock); dInfo("mnode is changed, num:%d use:%d", pEpSet->numOfEps, pEpSet->inUse); for (int32_t i = 0; i < pEpSet->numOfEps; ++i) { @@ -502,7 +502,7 @@ bool dmUpdateDnodeInfo(void *data, int32_t *did, int64_t *clusterId, char *fqdn, int32_t dnodeId = -1; if (did != NULL) dnodeId = *did; - taosThreadRwlockRdlock(&pData->lock); + (void)taosThreadRwlockRdlock(&pData->lock); if (pData->oldDnodeEps != NULL) { int32_t size = (int32_t)taosArrayGetSize(pData->oldDnodeEps); @@ -542,7 +542,7 @@ bool dmUpdateDnodeInfo(void *data, int32_t *did, int64_t *clusterId, char *fqdn, } } - taosThreadRwlockUnlock(&pData->lock); + (void)taosThreadRwlockUnlock(&pData->lock); return updated; } @@ -550,26 +550,26 @@ static int32_t dmDecodeEpPairs(SJson *pJson, SDnodeData *pData) { int32_t code = 0; SJson *dnodes = tjsonGetObjectItem(pJson, "dnodes"); - if (dnodes == NULL) return -1; + if (dnodes == NULL) return TSDB_CODE_INVALID_CFG_VALUE; int32_t numOfDnodes = tjsonGetArraySize(dnodes); for (int32_t i = 0; i < numOfDnodes; ++i) { SJson *dnode = tjsonGetArrayItem(dnodes, i); - if (dnode == NULL) return -1; + if (dnode == NULL) return TSDB_CODE_INVALID_CFG_VALUE; SDnodeEpPair pair = {0}; tjsonGetInt32ValueFromDouble(dnode, "id", pair.id, code); - if (code < 0) return -1; + if (code < 0) return TSDB_CODE_INVALID_CFG_VALUE; code = tjsonGetStringValue(dnode, "fqdn", pair.oldFqdn); - if (code < 0) return -1; + if (code < 0) return TSDB_CODE_INVALID_CFG_VALUE; tjsonGetUInt16ValueFromDouble(dnode, "port", pair.oldPort, code); - if (code < 0) return -1; + if (code < 0) return TSDB_CODE_INVALID_CFG_VALUE; code = tjsonGetStringValue(dnode, "new_fqdn", pair.newFqdn); - if (code < 0) return -1; + if (code < 0) return TSDB_CODE_INVALID_CFG_VALUE; tjsonGetUInt16ValueFromDouble(dnode, "new_port", pair.newPort, code); - if (code < 0) return -1; + if (code < 0) return TSDB_CODE_INVALID_CFG_VALUE; - if (taosArrayPush(pData->oldDnodeEps, &pair) == NULL) return -1; + if (taosArrayPush(pData->oldDnodeEps, &pair) == NULL) return TSDB_CODE_OUT_OF_MEMORY; } return code; From 422cd2f2057840ebb89939cef028c506d79a1b85 Mon Sep 17 00:00:00 2001 From: dmchen Date: Mon, 29 Jul 2024 11:43:20 +0000 Subject: [PATCH 19/28] fix/TD-30989 --- source/dnode/mnode/impl/src/mndProfile.c | 138 ++++++++++++----------- 1 file changed, 70 insertions(+), 68 deletions(-) diff --git a/source/dnode/mnode/impl/src/mndProfile.c b/source/dnode/mnode/impl/src/mndProfile.c index f7b509b1cc..ad3ed2e62f 100644 --- a/source/dnode/mnode/impl/src/mndProfile.c +++ b/source/dnode/mnode/impl/src/mndProfile.c @@ -263,7 +263,7 @@ static int32_t mndProcessConnectReq(SRpcMsg *pReq) { if (connReq.db[0]) { char db[TSDB_DB_FNAME_LEN] = {0}; - snprintf(db, TSDB_DB_FNAME_LEN, "%d%s%s", pUser->acctId, TS_PATH_DELIMITER, connReq.db); + (void)snprintf(db, TSDB_DB_FNAME_LEN, "%d%s%s", pUser->acctId, TS_PATH_DELIMITER, connReq.db); pDb = mndAcquireDb(pMnode, db); if (pDb == NULL) { if (0 != strcmp(connReq.db, TSDB_INFORMATION_SCHEMA_DB) && @@ -307,9 +307,9 @@ static int32_t mndProcessConnectReq(SRpcMsg *pReq) { tstrncpy(connectRsp.monitorParas.tsSlowLogExceptDb, tsSlowLogExceptDb, TSDB_DB_NAME_LEN); connectRsp.whiteListVer = pUser->ipWhiteListVer; - strcpy(connectRsp.sVer, version); - snprintf(connectRsp.sDetailVer, sizeof(connectRsp.sDetailVer), "ver:%s\nbuild:%s\ngitinfo:%s", version, buildinfo, - gitinfo); + (void)strcpy(connectRsp.sVer, version); + (void)snprintf(connectRsp.sDetailVer, sizeof(connectRsp.sDetailVer), "ver:%s\nbuild:%s\ngitinfo:%s", version, + buildinfo, gitinfo); mndGetMnodeEpSet(pMnode, &connectRsp.epSet); int32_t contLen = tSerializeSConnectRsp(NULL, 0, &connectRsp); @@ -335,7 +335,7 @@ static int32_t mndProcessConnectReq(SRpcMsg *pReq) { code = 0; char detail[1000] = {0}; - sprintf(detail, "app:%s", connReq.app); + (void)sprintf(detail, "app:%s", connReq.app); auditRecord(pReq, pMnode->clusterId, "login", "", "", detail, strlen(detail)); @@ -371,9 +371,9 @@ static SAppObj *mndCreateApp(SMnode *pMnode, uint32_t clientIp, SAppHbReq *pReq) app.appId = pReq->appId; app.ip = clientIp; app.pid = pReq->pid; - strcpy(app.name, pReq->name); + (void)strcpy(app.name, pReq->name); app.startTime = pReq->startTime; - memcpy(&app.summary, &pReq->summary, sizeof(pReq->summary)); + (void)memcpy(&app.summary, &pReq->summary, sizeof(pReq->summary)); app.lastAccessTimeMs = taosGetTimestampMs(); const int32_t keepTime = tsShellActivityTimer * 3; @@ -456,7 +456,7 @@ static int32_t mndUpdateAppInfo(SMnode *pMnode, SClientHbReq *pHbReq, SRpcConnIn } } - memcpy(&pApp->summary, &pReq->summary, sizeof(pReq->summary)); + (void)memcpy(&pApp->summary, &pReq->summary, sizeof(pReq->summary)); mndReleaseApp(pMnode, pApp); @@ -492,7 +492,7 @@ static int32_t mndProcessQueryHeartBeat(SMnode *pMnode, SRpcMsg *pMsg, SClientHb SRpcConnInfo connInfo = pMsg->info.conn; if (0 != pHbReq->app.appId) { - mndUpdateAppInfo(pMnode, pHbReq, &connInfo); + TAOS_CHECK_RETURN(mndUpdateAppInfo(pMnode, pHbReq, &connInfo)); } if (pHbReq->query) { @@ -520,7 +520,7 @@ static int32_t mndProcessQueryHeartBeat(SMnode *pMnode, SRpcMsg *pMsg, SClientHb TAOS_RETURN(code); } - mndSaveQueryList(pConn, pBasic); + TAOS_CHECK_RETURN(mndSaveQueryList(pConn, pBasic)); if (pConn->killed != 0) { rspBasic->killConnection = 1; } @@ -546,7 +546,8 @@ static int32_t mndProcessQueryHeartBeat(SMnode *pMnode, SRpcMsg *pMsg, SClientHb int32_t kvNum = taosHashGetSize(pHbReq->info); if (NULL == pHbReq->info || kvNum <= 0) { - taosArrayPush(pBatchRsp->rsps, &hbRsp); + // TODO return value + (void)taosArrayPush(pBatchRsp->rsps, &hbRsp); return TSDB_CODE_SUCCESS; } @@ -589,31 +590,31 @@ static int32_t mndProcessQueryHeartBeat(SMnode *pMnode, SRpcMsg *pMsg, SClientHb case HEARTBEAT_KEY_USER_AUTHINFO: { void *rspMsg = NULL; int32_t rspLen = 0; - mndValidateUserAuthInfo(pMnode, kv->value, kv->valueLen / sizeof(SUserAuthVersion), &rspMsg, &rspLen, - pObj->ipWhiteListVer); + (void)mndValidateUserAuthInfo(pMnode, kv->value, kv->valueLen / sizeof(SUserAuthVersion), &rspMsg, &rspLen, + pObj->ipWhiteListVer); if (rspMsg && rspLen > 0) { SKv kv1 = {.key = HEARTBEAT_KEY_USER_AUTHINFO, .valueLen = rspLen, .value = rspMsg}; - taosArrayPush(hbRsp.info, &kv1); + (void)taosArrayPush(hbRsp.info, &kv1); } break; } case HEARTBEAT_KEY_DBINFO: { void *rspMsg = NULL; int32_t rspLen = 0; - mndValidateDbInfo(pMnode, kv->value, kv->valueLen / sizeof(SDbCacheInfo), &rspMsg, &rspLen); + (void)mndValidateDbInfo(pMnode, kv->value, kv->valueLen / sizeof(SDbCacheInfo), &rspMsg, &rspLen); if (rspMsg && rspLen > 0) { SKv kv1 = {.key = HEARTBEAT_KEY_DBINFO, .valueLen = rspLen, .value = rspMsg}; - taosArrayPush(hbRsp.info, &kv1); + (void)taosArrayPush(hbRsp.info, &kv1); } break; } case HEARTBEAT_KEY_STBINFO: { void *rspMsg = NULL; int32_t rspLen = 0; - mndValidateStbInfo(pMnode, kv->value, kv->valueLen / sizeof(SSTableVersion), &rspMsg, &rspLen); + (void)mndValidateStbInfo(pMnode, kv->value, kv->valueLen / sizeof(SSTableVersion), &rspMsg, &rspLen); if (rspMsg && rspLen > 0) { SKv kv1 = {.key = HEARTBEAT_KEY_STBINFO, .valueLen = rspLen, .value = rspMsg}; - taosArrayPush(hbRsp.info, &kv1); + (void)taosArrayPush(hbRsp.info, &kv1); } break; } @@ -628,10 +629,10 @@ static int32_t mndProcessQueryHeartBeat(SMnode *pMnode, SRpcMsg *pMsg, SClientHb void *rspMsg = NULL; int32_t rspLen = 0; - mndValidateViewInfo(pMnode, kv->value, kv->valueLen / sizeof(SViewVersion), &rspMsg, &rspLen); + (void)mndValidateViewInfo(pMnode, kv->value, kv->valueLen / sizeof(SViewVersion), &rspMsg, &rspLen); if (rspMsg && rspLen > 0) { SKv kv1 = {.key = HEARTBEAT_KEY_VIEWINFO, .valueLen = rspLen, .value = rspMsg}; - taosArrayPush(hbRsp.info, &kv1); + (void)taosArrayPush(hbRsp.info, &kv1); } break; } @@ -639,10 +640,10 @@ static int32_t mndProcessQueryHeartBeat(SMnode *pMnode, SRpcMsg *pMsg, SClientHb case HEARTBEAT_KEY_TSMA: { void *rspMsg = NULL; int32_t rspLen = 0; - mndValidateTSMAInfo(pMnode, kv->value, kv->valueLen / sizeof(STSMAVersion), &rspMsg, &rspLen); + (void)mndValidateTSMAInfo(pMnode, kv->value, kv->valueLen / sizeof(STSMAVersion), &rspMsg, &rspLen); if (rspMsg && rspLen > 0) { SKv kv = {.key = HEARTBEAT_KEY_TSMA, .valueLen = rspLen, .value = rspMsg}; - taosArrayPush(hbRsp.info, &kv); + (void)taosArrayPush(hbRsp.info, &kv); } break; } @@ -655,9 +656,10 @@ static int32_t mndProcessQueryHeartBeat(SMnode *pMnode, SRpcMsg *pMsg, SClientHb pIter = taosHashIterate(pHbReq->info, pIter); } - taosArrayPush(pBatchRsp->rsps, &hbRsp); - - return TSDB_CODE_SUCCESS; + if (taosArrayPush(pBatchRsp->rsps, &hbRsp) == NULL) { + if (terrno != 0) code = terrno; + } + TAOS_RETURN(code); } static int32_t mndProcessHeartBeatReq(SRpcMsg *pReq) { @@ -675,9 +677,9 @@ static int32_t mndProcessHeartBeatReq(SRpcMsg *pReq) { SConnPreparedObj obj = {0}; obj.totalDnodes = mndGetDnodeSize(pMnode); obj.ipWhiteListVer = batchReq.ipWhiteList; - mndGetOnlineDnodeNum(pMnode, &obj.onlineDnodes); + TAOS_CHECK_RETURN(mndGetOnlineDnodeNum(pMnode, &obj.onlineDnodes)); mndGetMnodeEpSet(pMnode, &obj.epSet); - mndCreateQnodeList(pMnode, &obj.pQnodeList, -1); + TAOS_CHECK_RETURN(mndCreateQnodeList(pMnode, &obj.pQnodeList, -1)); SClientHbBatchRsp batchRsp = {0}; batchRsp.svrTimestamp = taosGetTimestampSec(); @@ -845,32 +847,32 @@ static int32_t mndRetrieveConns(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBl cols = 0; SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)&pConn->id, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pConn->id, false); char user[TSDB_USER_LEN + VARSTR_HEADER_SIZE] = {0}; STR_TO_VARSTR(user, pConn->user); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)user, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)user, false); char app[TSDB_APP_NAME_LEN + VARSTR_HEADER_SIZE]; STR_TO_VARSTR(app, pConn->app); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)app, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)app, false); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)&pConn->pid, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pConn->pid, false); char endpoint[TSDB_IPv4ADDR_LEN + 6 + VARSTR_HEADER_SIZE] = {0}; - sprintf(&endpoint[VARSTR_HEADER_SIZE], "%s:%d", taosIpStr(pConn->ip), pConn->port); + (void)sprintf(&endpoint[VARSTR_HEADER_SIZE], "%s:%d", taosIpStr(pConn->ip), pConn->port); varDataLen(endpoint) = strlen(&endpoint[VARSTR_HEADER_SIZE]); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)endpoint, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)endpoint, false); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)&pConn->loginTimeMs, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pConn->loginTimeMs, false); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)&pConn->lastAccessTimeMs, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pConn->lastAccessTimeMs, false); numOfRows++; } @@ -903,50 +905,50 @@ static int32_t packQueriesIntoBlock(SShowObj *pShow, SConnObj *pConn, SSDataBloc cols = 0; char queryId[26 + VARSTR_HEADER_SIZE] = {0}; - sprintf(&queryId[VARSTR_HEADER_SIZE], "%x:%" PRIx64, pConn->id, pQuery->reqRid); + (void)sprintf(&queryId[VARSTR_HEADER_SIZE], "%x:%" PRIx64, pConn->id, pQuery->reqRid); varDataLen(queryId) = strlen(&queryId[VARSTR_HEADER_SIZE]); SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, curRowIndex, (const char *)queryId, false); + (void)colDataSetVal(pColInfo, curRowIndex, (const char *)queryId, false); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, curRowIndex, (const char *)&pQuery->queryId, false); + (void)colDataSetVal(pColInfo, curRowIndex, (const char *)&pQuery->queryId, false); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, curRowIndex, (const char *)&pConn->id, false); + (void)colDataSetVal(pColInfo, curRowIndex, (const char *)&pConn->id, false); char app[TSDB_APP_NAME_LEN + VARSTR_HEADER_SIZE]; STR_TO_VARSTR(app, pConn->app); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, curRowIndex, (const char *)app, false); + (void)colDataSetVal(pColInfo, curRowIndex, (const char *)app, false); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, curRowIndex, (const char *)&pConn->pid, false); + (void)colDataSetVal(pColInfo, curRowIndex, (const char *)&pConn->pid, false); char user[TSDB_USER_LEN + VARSTR_HEADER_SIZE] = {0}; STR_TO_VARSTR(user, pConn->user); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, curRowIndex, (const char *)user, false); + (void)colDataSetVal(pColInfo, curRowIndex, (const char *)user, false); char endpoint[TSDB_IPv4ADDR_LEN + 6 + VARSTR_HEADER_SIZE] = {0}; - sprintf(&endpoint[VARSTR_HEADER_SIZE], "%s:%d", taosIpStr(pConn->ip), pConn->port); + (void)sprintf(&endpoint[VARSTR_HEADER_SIZE], "%s:%d", taosIpStr(pConn->ip), pConn->port); varDataLen(endpoint) = strlen(&endpoint[VARSTR_HEADER_SIZE]); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, curRowIndex, (const char *)endpoint, false); + (void)colDataSetVal(pColInfo, curRowIndex, (const char *)endpoint, false); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, curRowIndex, (const char *)&pQuery->stime, false); + (void)colDataSetVal(pColInfo, curRowIndex, (const char *)&pQuery->stime, false); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, curRowIndex, (const char *)&pQuery->useconds, false); + (void)colDataSetVal(pColInfo, curRowIndex, (const char *)&pQuery->useconds, false); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, curRowIndex, (const char *)&pQuery->stableQuery, false); + (void)colDataSetVal(pColInfo, curRowIndex, (const char *)&pQuery->stableQuery, false); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, curRowIndex, (const char *)&pQuery->isSubQuery, false); + (void)colDataSetVal(pColInfo, curRowIndex, (const char *)&pQuery->isSubQuery, false); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, curRowIndex, (const char *)&pQuery->subPlanNum, false); + (void)colDataSetVal(pColInfo, curRowIndex, (const char *)&pQuery->subPlanNum, false); char subStatus[TSDB_SHOW_SUBQUERY_LEN + VARSTR_HEADER_SIZE] = {0}; int64_t reserve = 64; @@ -965,12 +967,12 @@ static int32_t packQueriesIntoBlock(SShowObj *pShow, SConnObj *pConn, SSDataBloc } varDataLen(subStatus) = strlen(&subStatus[VARSTR_HEADER_SIZE]); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, curRowIndex, subStatus, (varDataLen(subStatus) == 0) ? true : false); + (void)colDataSetVal(pColInfo, curRowIndex, subStatus, (varDataLen(subStatus) == 0) ? true : false); char sql[TSDB_SHOW_SQL_LEN + VARSTR_HEADER_SIZE] = {0}; STR_TO_VARSTR(sql, pQuery->sql); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, curRowIndex, (const char *)sql, false); + (void)colDataSetVal(pColInfo, curRowIndex, (const char *)sql, false); pBlock->info.rows++; } @@ -1037,55 +1039,55 @@ static int32_t mndRetrieveApps(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlo cols = 0; SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->appId, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->appId, false); char ip[TSDB_IPv4ADDR_LEN + 6 + VARSTR_HEADER_SIZE] = {0}; - sprintf(&ip[VARSTR_HEADER_SIZE], "%s", taosIpStr(pApp->ip)); + (void)sprintf(&ip[VARSTR_HEADER_SIZE], "%s", taosIpStr(pApp->ip)); varDataLen(ip) = strlen(&ip[VARSTR_HEADER_SIZE]); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)ip, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)ip, false); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->pid, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->pid, false); char name[TSDB_APP_NAME_LEN + 6 + VARSTR_HEADER_SIZE] = {0}; - sprintf(&name[VARSTR_HEADER_SIZE], "%s", pApp->name); + (void)sprintf(&name[VARSTR_HEADER_SIZE], "%s", pApp->name); varDataLen(name) = strlen(&name[VARSTR_HEADER_SIZE]); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)name, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)name, false); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->startTime, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->startTime, false); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->summary.numOfInsertsReq, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->summary.numOfInsertsReq, false); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->summary.numOfInsertRows, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->summary.numOfInsertRows, false); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->summary.insertElapsedTime, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->summary.insertElapsedTime, false); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->summary.insertBytes, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->summary.insertBytes, false); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->summary.fetchBytes, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->summary.fetchBytes, false); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->summary.queryElapsedTime, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->summary.queryElapsedTime, false); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->summary.numOfSlowQueries, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->summary.numOfSlowQueries, false); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->summary.totalRequests, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->summary.totalRequests, false); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->summary.currentRequests, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->summary.currentRequests, false); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->lastAccessTimeMs, false); + (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->lastAccessTimeMs, false); numOfRows++; } From ef89905560a5a9752625733070bf986be41b9396 Mon Sep 17 00:00:00 2001 From: dmchen Date: Mon, 29 Jul 2024 11:47:13 +0000 Subject: [PATCH 20/28] fix/TD-30989 --- source/dnode/mnode/impl/src/mndMain.c | 151 ++++++++++++++++---------- 1 file changed, 96 insertions(+), 55 deletions(-) diff --git a/source/dnode/mnode/impl/src/mndMain.c b/source/dnode/mnode/impl/src/mndMain.c index 906d6aba28..9b6c2ab201 100644 --- a/source/dnode/mnode/impl/src/mndMain.c +++ b/source/dnode/mnode/impl/src/mndMain.c @@ -48,32 +48,32 @@ static inline int32_t mndAcquireRpc(SMnode *pMnode) { int32_t code = 0; - taosThreadRwlockRdlock(&pMnode->lock); + TAOS_CHECK_RETURN(taosThreadRwlockRdlock(&pMnode->lock)); if (pMnode->stopped) { code = TSDB_CODE_APP_IS_STOPPING; } else if (!mndIsLeader(pMnode)) { code = -1; } else { #if 1 - atomic_add_fetch_32(&pMnode->rpcRef, 1); + (void)atomic_add_fetch_32(&pMnode->rpcRef, 1); #else int32_t ref = atomic_add_fetch_32(&pMnode->rpcRef, 1); mTrace("mnode rpc is acquired, ref:%d", ref); #endif } - taosThreadRwlockUnlock(&pMnode->lock); + TAOS_CHECK_RETURN(taosThreadRwlockUnlock(&pMnode->lock)); TAOS_RETURN(code); } static inline void mndReleaseRpc(SMnode *pMnode) { - taosThreadRwlockRdlock(&pMnode->lock); + (void)taosThreadRwlockRdlock(&pMnode->lock); #if 1 - atomic_sub_fetch_32(&pMnode->rpcRef, 1); + (void)atomic_sub_fetch_32(&pMnode->rpcRef, 1); #else int32_t ref = atomic_sub_fetch_32(&pMnode->rpcRef, 1); mTrace("mnode rpc is released, ref:%d", ref); #endif - taosThreadRwlockUnlock(&pMnode->lock); + (void)taosThreadRwlockUnlock(&pMnode->lock); } static void *mndBuildTimerMsg(int32_t *pContLen) { @@ -85,53 +85,68 @@ static void *mndBuildTimerMsg(int32_t *pContLen) { void *pReq = rpcMallocCont(contLen); if (pReq == NULL) return NULL; - tSerializeSMTimerMsg(pReq, contLen, &timerReq); + (void)tSerializeSMTimerMsg(pReq, contLen, &timerReq); *pContLen = contLen; return pReq; } static void mndPullupTrans(SMnode *pMnode) { + int32_t code = 0; mTrace("pullup trans msg"); int32_t contLen = 0; void *pReq = mndBuildTimerMsg(&contLen); if (pReq != NULL) { SRpcMsg rpcMsg = {.msgType = TDMT_MND_TRANS_TIMER, .pCont = pReq, .contLen = contLen}; - tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg); + if ((code = tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg)) != 0) { + mError("failed to put to queue since %s", tstrerror(code)); + } } } static void mndPullupCompacts(SMnode *pMnode) { + int32_t code = 0; mTrace("pullup compact timer msg"); int32_t contLen = 0; void *pReq = mndBuildTimerMsg(&contLen); if (pReq != NULL) { SRpcMsg rpcMsg = {.msgType = TDMT_MND_COMPACT_TIMER, .pCont = pReq, .contLen = contLen}; - tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg); + if ((code = tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg)) != 0) { + mError("failed to put to queue since %s", tstrerror(code)); + } } } static void mndPullupTtl(SMnode *pMnode) { + int32_t code = 0; mTrace("pullup ttl"); int32_t contLen = 0; void *pReq = mndBuildTimerMsg(&contLen); SRpcMsg rpcMsg = {.msgType = TDMT_MND_TTL_TIMER, .pCont = pReq, .contLen = contLen}; - tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg); + if ((code = tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg)) != 0) { + mError("failed to put to queue since %s", tstrerror(code)); + } } static void mndPullupTrimDb(SMnode *pMnode) { + int32_t code = 0; mTrace("pullup s3migrate"); int32_t contLen = 0; void *pReq = mndBuildTimerMsg(&contLen); SRpcMsg rpcMsg = {.msgType = TDMT_MND_S3MIGRATE_DB_TIMER, .pCont = pReq, .contLen = contLen}; - tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg); + if ((code = tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg)) != 0) { + mError("failed to put to queue since %s", tstrerror(code)); + } } static void mndPullupS3MigrateDb(SMnode *pMnode) { + int32_t code = 0; mTrace("pullup trim"); int32_t contLen = 0; void *pReq = mndBuildTimerMsg(&contLen); SRpcMsg rpcMsg = {.msgType = TDMT_MND_TRIM_DB_TIMER, .pCont = pReq, .contLen = contLen}; - tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg); + if ((code = tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg)) != 0) { + mError("failed to put to queue since %s", tstrerror(code)); + } } static int32_t mndPullupArbHeartbeat(SMnode *pMnode) { @@ -151,70 +166,91 @@ static int32_t mndPullupArbCheckSync(SMnode *pMnode) { } static void mndCalMqRebalance(SMnode *pMnode) { + int32_t code = 0; int32_t contLen = 0; void *pReq = mndBuildTimerMsg(&contLen); if (pReq != NULL) { SRpcMsg rpcMsg = {.msgType = TDMT_MND_TMQ_TIMER, .pCont = pReq, .contLen = contLen}; - tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg); + if ((code = tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg)) != 0) { + mError("failed to put to queue since %s", tstrerror(code)); + } } } static void mndStreamCheckpointTimer(SMnode *pMnode) { + int32_t code = 0; SMStreamDoCheckpointMsg *pMsg = rpcMallocCont(sizeof(SMStreamDoCheckpointMsg)); if (pMsg != NULL) { int32_t size = sizeof(SMStreamDoCheckpointMsg); SRpcMsg rpcMsg = {.msgType = TDMT_MND_STREAM_BEGIN_CHECKPOINT, .pCont = pMsg, .contLen = size}; - tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg); + if ((code = tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg)) != 0) { + mError("failed to put to queue since %s", tstrerror(code)); + } } } static void mndStreamCheckNode(SMnode *pMnode) { + int32_t code = 0; int32_t contLen = 0; void *pReq = mndBuildTimerMsg(&contLen); if (pReq != NULL) { SRpcMsg rpcMsg = {.msgType = TDMT_MND_NODECHECK_TIMER, .pCont = pReq, .contLen = contLen}; - tmsgPutToQueue(&pMnode->msgCb, READ_QUEUE, &rpcMsg); + if ((code = tmsgPutToQueue(&pMnode->msgCb, READ_QUEUE, &rpcMsg)) != 0) { + mError("failed to put to queue since %s", tstrerror(code)); + } } } static void mndStreamConsensusChkpt(SMnode *pMnode) { + int32_t code = 0; int32_t contLen = 0; void *pReq = mndBuildTimerMsg(&contLen); if (pReq != NULL) { SRpcMsg rpcMsg = {.msgType = TDMT_MND_STREAM_CONSEN_TIMER, .pCont = pReq, .contLen = contLen}; - tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg); + if ((code = tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg)) != 0) { + mError("failed to put to queue since %s", tstrerror(code)); + } } } static void mndPullupTelem(SMnode *pMnode) { + int32_t code = 0; mTrace("pullup telem msg"); int32_t contLen = 0; void *pReq = mndBuildTimerMsg(&contLen); if (pReq != NULL) { SRpcMsg rpcMsg = {.msgType = TDMT_MND_TELEM_TIMER, .pCont = pReq, .contLen = contLen}; - tmsgPutToQueue(&pMnode->msgCb, READ_QUEUE, &rpcMsg); + if ((code = tmsgPutToQueue(&pMnode->msgCb, READ_QUEUE, &rpcMsg)) != 0) { + mError("failed to put to queue since %s", tstrerror(code)); + } } } static void mndPullupGrant(SMnode *pMnode) { + int32_t code = 0; mTrace("pullup grant msg"); int32_t contLen = 0; void *pReq = mndBuildTimerMsg(&contLen); if (pReq != NULL) { SRpcMsg rpcMsg = { .msgType = TDMT_MND_GRANT_HB_TIMER, .pCont = pReq, .contLen = contLen, .info.ahandle = (void *)0x9527}; - tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg); + if ((code = tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg)) != 0) { + mError("failed to put to queue since %s", tstrerror(code)); + } } } static void mndIncreaseUpTime(SMnode *pMnode) { + int32_t code = 0; mTrace("increate uptime"); int32_t contLen = 0; void *pReq = mndBuildTimerMsg(&contLen); if (pReq != NULL) { SRpcMsg rpcMsg = { .msgType = TDMT_MND_UPTIME_TIMER, .pCont = pReq, .contLen = contLen, .info.ahandle = (void *)0x9528}; - tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg); + if ((code = tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg)) != 0) { + mError("failed to put to queue since %s", tstrerror(code)); + } } } @@ -287,24 +323,24 @@ static void mndCheckDnodeOffline(SMnode *pMnode) { static bool mnodeIsNotLeader(SMnode *pMnode) { terrno = 0; - taosThreadRwlockRdlock(&pMnode->lock); + (void)taosThreadRwlockRdlock(&pMnode->lock); SSyncState state = syncGetState(pMnode->syncMgmt.sync); if (terrno != 0) { - taosThreadRwlockUnlock(&pMnode->lock); + (void)taosThreadRwlockUnlock(&pMnode->lock); return true; } if (state.state != TAOS_SYNC_STATE_LEADER) { - taosThreadRwlockUnlock(&pMnode->lock); + (void)taosThreadRwlockUnlock(&pMnode->lock); terrno = TSDB_CODE_SYN_NOT_LEADER; return true; } if (!state.restored || !pMnode->restored) { - taosThreadRwlockUnlock(&pMnode->lock); + (void)taosThreadRwlockUnlock(&pMnode->lock); terrno = TSDB_CODE_SYN_RESTORING; return true; } - taosThreadRwlockUnlock(&pMnode->lock); + (void)taosThreadRwlockUnlock(&pMnode->lock); return false; } @@ -429,21 +465,21 @@ static void *mndThreadFp(void *param) { static int32_t mndInitTimer(SMnode *pMnode) { int32_t code = 0; TdThreadAttr thAttr; - taosThreadAttrInit(&thAttr); - taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE); + TAOS_CHECK_RETURN(taosThreadAttrInit(&thAttr)); + TAOS_CHECK_RETURN(taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE)); if ((code = taosThreadCreate(&pMnode->thread, &thAttr, mndThreadFp, pMnode)) != 0) { mError("failed to create timer thread since %s", strerror(errno)); TAOS_RETURN(code); } - taosThreadAttrDestroy(&thAttr); + TAOS_CHECK_RETURN(taosThreadAttrDestroy(&thAttr)); tmsgReportStartup("mnode-timer", "initialized"); TAOS_RETURN(code); } static void mndCleanupTimer(SMnode *pMnode) { if (taosCheckPthreadValid(pMnode->thread)) { - taosThreadJoin(pMnode->thread, NULL); + (void)taosThreadJoin(pMnode->thread, NULL); taosThreadClear(&pMnode->thread); } } @@ -467,7 +503,7 @@ static int32_t mndCreateDir(SMnode *pMnode, const char *path) { static int32_t mndInitWal(SMnode *pMnode) { int32_t code = 0; char path[PATH_MAX + 20] = {0}; - snprintf(path, sizeof(path), "%s%swal", pMnode->path, TD_DIRSEP); + (void)snprintf(path, sizeof(path), "%s%swal", pMnode->path, TD_DIRSEP); SWalCfg cfg = {.vgId = 1, .fsyncPeriod = 0, .rollPeriod = -1, @@ -486,7 +522,7 @@ static int32_t mndInitWal(SMnode *pMnode) { TAOS_RETURN(code); } else{ - strncpy(cfg.encryptKey, tsEncryptKey, ENCRYPT_KEY_LEN); + (void)strncpy(cfg.encryptKey, tsEncryptKey, ENCRYPT_KEY_LEN); } } #endif @@ -642,8 +678,8 @@ static void mndSetOptions(SMnode *pMnode, const SMnodeOpt *pOption) { pMnode->syncMgmt.numOfReplicas = pOption->numOfReplicas; pMnode->syncMgmt.numOfTotalReplicas = pOption->numOfTotalReplicas; pMnode->syncMgmt.lastIndex = pOption->lastIndex; - memcpy(pMnode->syncMgmt.replicas, pOption->replicas, sizeof(pOption->replicas)); - memcpy(pMnode->syncMgmt.nodeRoles, pOption->nodeRoles, sizeof(pOption->nodeRoles)); + (void)memcpy(pMnode->syncMgmt.replicas, pOption->replicas, sizeof(pOption->replicas)); + (void)memcpy(pMnode->syncMgmt.nodeRoles, pOption->nodeRoles, sizeof(pOption->nodeRoles)); } SMnode *mndOpen(const char *path, const SMnodeOpt *pOption) { @@ -656,7 +692,7 @@ SMnode *mndOpen(const char *path, const SMnodeOpt *pOption) { mError("failed to open mnode since %s", terrstr()); return NULL; } - memset(pMnode, 0, sizeof(SMnode)); + (void)memset(pMnode, 0, sizeof(SMnode)); char timestr[24] = "1970-01-01 00:00:00.00"; (void)taosParseTime(timestr, &pMnode->checkTime, (int32_t)strlen(timestr), TSDB_TIME_PRECISION_MILLI, 0); @@ -703,10 +739,15 @@ SMnode *mndOpen(const char *path, const SMnodeOpt *pOption) { } void mndPreClose(SMnode *pMnode) { + int32_t code = 0; if (pMnode != NULL) { - syncLeaderTransfer(pMnode->syncMgmt.sync); + if ((code = syncLeaderTransfer(pMnode->syncMgmt.sync)) != 0) { + mError("failed to pre close since %s", tstrerror(code)); + } syncPreStop(pMnode->syncMgmt.sync); - sdbWriteFile(pMnode->pSdb, 0); + if ((code = sdbWriteFile(pMnode->pSdb, 0)) != 0) { + mError("failed to pre close since %s", tstrerror(code)); + } } } @@ -785,9 +826,9 @@ static int32_t mndCheckMnodeState(SRpcMsg *pMsg) { } SMnode *pMnode = pMsg->info.node; - taosThreadRwlockRdlock(&pMnode->lock); + TAOS_CHECK_RETURN(taosThreadRwlockRdlock(&pMnode->lock)); if (pMnode->stopped) { - taosThreadRwlockUnlock(&pMnode->lock); + (void)taosThreadRwlockUnlock(&pMnode->lock); code = TSDB_CODE_APP_IS_STOPPING; TAOS_RETURN(code); } @@ -795,31 +836,31 @@ static int32_t mndCheckMnodeState(SRpcMsg *pMsg) { terrno = 0; SSyncState state = syncGetState(pMnode->syncMgmt.sync); if (terrno != 0) { - taosThreadRwlockUnlock(&pMnode->lock); + (void)taosThreadRwlockUnlock(&pMnode->lock); code = terrno; TAOS_RETURN(code); } if (state.state != TAOS_SYNC_STATE_LEADER) { - taosThreadRwlockUnlock(&pMnode->lock); + (void)taosThreadRwlockUnlock(&pMnode->lock); code = TSDB_CODE_SYN_NOT_LEADER; goto _OVER; } if (!state.restored || !pMnode->restored) { - taosThreadRwlockUnlock(&pMnode->lock); + (void)taosThreadRwlockUnlock(&pMnode->lock); code = TSDB_CODE_SYN_RESTORING; goto _OVER; } #if 1 - atomic_add_fetch_32(&pMnode->rpcRef, 1); + (void)atomic_add_fetch_32(&pMnode->rpcRef, 1); #else int32_t ref = atomic_add_fetch_32(&pMnode->rpcRef, 1); mTrace("mnode rpc is acquired, ref:%d", ref); #endif - taosThreadRwlockUnlock(&pMnode->lock); + (void)taosThreadRwlockUnlock(&pMnode->lock); TAOS_RETURN(code); _OVER: @@ -854,7 +895,7 @@ _OVER: int32_t contLen = tSerializeSEpSet(NULL, 0, &epSet); pMsg->info.rsp = rpcMallocCont(contLen); if (pMsg->info.rsp != NULL) { - tSerializeSEpSet(pMsg->info.rsp, contLen, &epSet); + (void)tSerializeSEpSet(pMsg->info.rsp, contLen, &epSet); pMsg->info.hasEpSet = 1; pMsg->info.rspLen = contLen; } @@ -973,7 +1014,7 @@ int32_t mndGetMonitorInfo(SMnode *pMnode, SMonClusterInfo *pClusterInfo, SMonVgr } else { tstrncpy(desc.status, "offline", sizeof(desc.status)); } - taosArrayPush(pClusterInfo->dnodes, &desc); + (void)taosArrayPush(pClusterInfo->dnodes, &desc); sdbRelease(pSdb, pObj); } @@ -999,7 +1040,7 @@ int32_t mndGetMonitorInfo(SMnode *pMnode, SMonClusterInfo *pClusterInfo, SMonVgr tstrncpy(desc.role, syncStr(pObj->syncState), sizeof(desc.role)); desc.syncState = pObj->syncState; } - taosArrayPush(pClusterInfo->mnodes, &desc); + (void)taosArrayPush(pClusterInfo->mnodes, &desc); sdbRelease(pSdb, pObj); } @@ -1017,8 +1058,8 @@ int32_t mndGetMonitorInfo(SMnode *pMnode, SMonClusterInfo *pClusterInfo, SMonVgr desc.vgroup_id = pVgroup->vgId; SName name = {0}; - tNameFromString(&name, pVgroup->dbName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); - tNameGetDbName(&name, desc.database_name); + (void)tNameFromString(&name, pVgroup->dbName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); + (void)tNameGetDbName(&name, desc.database_name); desc.tables_num = pVgroup->numOfTables; pGrantInfo->timeseries_used += pVgroup->numOfTimeSeries; @@ -1039,7 +1080,7 @@ int32_t mndGetMonitorInfo(SMnode *pMnode, SMonClusterInfo *pClusterInfo, SMonVgr pClusterInfo->vnodes_total++; } - taosArrayPush(pVgroupInfo->vgroups, &desc); + (void)taosArrayPush(pVgroupInfo->vgroups, &desc); sdbRelease(pSdb, pVgroup); } @@ -1053,14 +1094,14 @@ int32_t mndGetMonitorInfo(SMnode *pMnode, SMonClusterInfo *pClusterInfo, SMonVgr SMonStbDesc desc = {0}; SName name1 = {0}; - tNameFromString(&name1, pStb->db, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); - tNameGetDbName(&name1, desc.database_name); + (void)tNameFromString(&name1, pStb->db, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); + (void)tNameGetDbName(&name1, desc.database_name); SName name2 = {0}; - tNameFromString(&name2, pStb->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); + (void)tNameFromString(&name2, pStb->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); tstrncpy(desc.stb_name, tNameGetTableName(&name2), TSDB_TABLE_NAME_LEN); - taosArrayPush(pStbInfo->stbs, &desc); + (void)taosArrayPush(pStbInfo->stbs, &desc); sdbRelease(pSdb, pStb); } @@ -1096,12 +1137,12 @@ void mndSetRestored(SMnode *pMnode, bool restored) { if (restored) { taosThreadRwlockWrlock(&pMnode->lock); pMnode->restored = true; - taosThreadRwlockUnlock(&pMnode->lock); + (void)taosThreadRwlockUnlock(&pMnode->lock); mInfo("mnode set restored:%d", restored); } else { taosThreadRwlockWrlock(&pMnode->lock); pMnode->restored = false; - taosThreadRwlockUnlock(&pMnode->lock); + (void)taosThreadRwlockUnlock(&pMnode->lock); mInfo("mnode set restored:%d", restored); while (1) { if (pMnode->rpcRef <= 0) break; @@ -1115,7 +1156,7 @@ bool mndGetRestored(SMnode *pMnode) { return pMnode->restored; } void mndSetStop(SMnode *pMnode) { taosThreadRwlockWrlock(&pMnode->lock); pMnode->stopped = true; - taosThreadRwlockUnlock(&pMnode->lock); + (void)taosThreadRwlockUnlock(&pMnode->lock); mInfo("mnode set stopped"); } From 4258de4d17499b8df00e9abbad260cf1c7f400ae Mon Sep 17 00:00:00 2001 From: dmchen Date: Mon, 29 Jul 2024 11:52:54 +0000 Subject: [PATCH 21/28] fix compile --- source/dnode/mnode/impl/src/mndIndex.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/dnode/mnode/impl/src/mndIndex.c b/source/dnode/mnode/impl/src/mndIndex.c index c4cad8e5a8..8786c3a934 100644 --- a/source/dnode/mnode/impl/src/mndIndex.c +++ b/source/dnode/mnode/impl/src/mndIndex.c @@ -333,7 +333,7 @@ void mndReleaseIdx(SMnode *pMnode, SIdxObj *pIdx) { SDbObj *mndAcquireDbByIdx(SMnode *pMnode, const char *idxName) { SName name = {0}; - TAOS_CHECK_RETURN(tNameFromString(&name, idxName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE)); + (void)tNameFromString(&name, idxName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); char db[TSDB_TABLE_FNAME_LEN] = {0}; (void)tNameGetFullDbName(&name, db); From f4c8b6d081a4fcbfbb6a0d55723037fa4af19543 Mon Sep 17 00:00:00 2001 From: dmchen Date: Mon, 29 Jul 2024 12:06:41 +0000 Subject: [PATCH 22/28] fix case --- source/dnode/mnode/impl/src/mndMain.c | 93 +++++++++------------------ 1 file changed, 32 insertions(+), 61 deletions(-) diff --git a/source/dnode/mnode/impl/src/mndMain.c b/source/dnode/mnode/impl/src/mndMain.c index 9b6c2ab201..4f195227a2 100644 --- a/source/dnode/mnode/impl/src/mndMain.c +++ b/source/dnode/mnode/impl/src/mndMain.c @@ -48,7 +48,7 @@ static inline int32_t mndAcquireRpc(SMnode *pMnode) { int32_t code = 0; - TAOS_CHECK_RETURN(taosThreadRwlockRdlock(&pMnode->lock)); + (void)taosThreadRwlockRdlock(&pMnode->lock); if (pMnode->stopped) { code = TSDB_CODE_APP_IS_STOPPING; } else if (!mndIsLeader(pMnode)) { @@ -61,7 +61,7 @@ static inline int32_t mndAcquireRpc(SMnode *pMnode) { mTrace("mnode rpc is acquired, ref:%d", ref); #endif } - TAOS_CHECK_RETURN(taosThreadRwlockUnlock(&pMnode->lock)); + (void)taosThreadRwlockUnlock(&pMnode->lock); TAOS_RETURN(code); } @@ -91,62 +91,52 @@ static void *mndBuildTimerMsg(int32_t *pContLen) { } static void mndPullupTrans(SMnode *pMnode) { - int32_t code = 0; mTrace("pullup trans msg"); int32_t contLen = 0; void *pReq = mndBuildTimerMsg(&contLen); if (pReq != NULL) { SRpcMsg rpcMsg = {.msgType = TDMT_MND_TRANS_TIMER, .pCont = pReq, .contLen = contLen}; - if ((code = tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg)) != 0) { - mError("failed to put to queue since %s", tstrerror(code)); - } + //TODO check return value + (void)tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg); } } static void mndPullupCompacts(SMnode *pMnode) { - int32_t code = 0; mTrace("pullup compact timer msg"); int32_t contLen = 0; void *pReq = mndBuildTimerMsg(&contLen); if (pReq != NULL) { SRpcMsg rpcMsg = {.msgType = TDMT_MND_COMPACT_TIMER, .pCont = pReq, .contLen = contLen}; - if ((code = tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg)) != 0) { - mError("failed to put to queue since %s", tstrerror(code)); - } + //TODO check return value + (void)tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg); } } static void mndPullupTtl(SMnode *pMnode) { - int32_t code = 0; mTrace("pullup ttl"); int32_t contLen = 0; void *pReq = mndBuildTimerMsg(&contLen); SRpcMsg rpcMsg = {.msgType = TDMT_MND_TTL_TIMER, .pCont = pReq, .contLen = contLen}; - if ((code = tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg)) != 0) { - mError("failed to put to queue since %s", tstrerror(code)); - } + //TODO check return value + (void)tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg); } static void mndPullupTrimDb(SMnode *pMnode) { - int32_t code = 0; mTrace("pullup s3migrate"); int32_t contLen = 0; void *pReq = mndBuildTimerMsg(&contLen); SRpcMsg rpcMsg = {.msgType = TDMT_MND_S3MIGRATE_DB_TIMER, .pCont = pReq, .contLen = contLen}; - if ((code = tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg)) != 0) { - mError("failed to put to queue since %s", tstrerror(code)); - } + // TODO check return value + (void)tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg); } static void mndPullupS3MigrateDb(SMnode *pMnode) { - int32_t code = 0; mTrace("pullup trim"); int32_t contLen = 0; void *pReq = mndBuildTimerMsg(&contLen); SRpcMsg rpcMsg = {.msgType = TDMT_MND_TRIM_DB_TIMER, .pCont = pReq, .contLen = contLen}; - if ((code = tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg)) != 0) { - mError("failed to put to queue since %s", tstrerror(code)); - } + // TODO check return value + (void)tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg); } static int32_t mndPullupArbHeartbeat(SMnode *pMnode) { @@ -166,91 +156,76 @@ static int32_t mndPullupArbCheckSync(SMnode *pMnode) { } static void mndCalMqRebalance(SMnode *pMnode) { - int32_t code = 0; int32_t contLen = 0; void *pReq = mndBuildTimerMsg(&contLen); if (pReq != NULL) { SRpcMsg rpcMsg = {.msgType = TDMT_MND_TMQ_TIMER, .pCont = pReq, .contLen = contLen}; - if ((code = tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg)) != 0) { - mError("failed to put to queue since %s", tstrerror(code)); - } + (void)tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg); } } static void mndStreamCheckpointTimer(SMnode *pMnode) { - int32_t code = 0; SMStreamDoCheckpointMsg *pMsg = rpcMallocCont(sizeof(SMStreamDoCheckpointMsg)); if (pMsg != NULL) { int32_t size = sizeof(SMStreamDoCheckpointMsg); SRpcMsg rpcMsg = {.msgType = TDMT_MND_STREAM_BEGIN_CHECKPOINT, .pCont = pMsg, .contLen = size}; - if ((code = tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg)) != 0) { - mError("failed to put to queue since %s", tstrerror(code)); - } + // TODO check return value + (void)tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg); } } static void mndStreamCheckNode(SMnode *pMnode) { - int32_t code = 0; int32_t contLen = 0; void *pReq = mndBuildTimerMsg(&contLen); if (pReq != NULL) { SRpcMsg rpcMsg = {.msgType = TDMT_MND_NODECHECK_TIMER, .pCont = pReq, .contLen = contLen}; - if ((code = tmsgPutToQueue(&pMnode->msgCb, READ_QUEUE, &rpcMsg)) != 0) { - mError("failed to put to queue since %s", tstrerror(code)); - } + // TODO check return value + (void)tmsgPutToQueue(&pMnode->msgCb, READ_QUEUE, &rpcMsg); } } static void mndStreamConsensusChkpt(SMnode *pMnode) { - int32_t code = 0; int32_t contLen = 0; void *pReq = mndBuildTimerMsg(&contLen); if (pReq != NULL) { SRpcMsg rpcMsg = {.msgType = TDMT_MND_STREAM_CONSEN_TIMER, .pCont = pReq, .contLen = contLen}; - if ((code = tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg)) != 0) { - mError("failed to put to queue since %s", tstrerror(code)); - } + // TODO check return value + (void)tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg); } } static void mndPullupTelem(SMnode *pMnode) { - int32_t code = 0; mTrace("pullup telem msg"); int32_t contLen = 0; void *pReq = mndBuildTimerMsg(&contLen); if (pReq != NULL) { SRpcMsg rpcMsg = {.msgType = TDMT_MND_TELEM_TIMER, .pCont = pReq, .contLen = contLen}; - if ((code = tmsgPutToQueue(&pMnode->msgCb, READ_QUEUE, &rpcMsg)) != 0) { - mError("failed to put to queue since %s", tstrerror(code)); - } + // TODO check return value + (void)tmsgPutToQueue(&pMnode->msgCb, READ_QUEUE, &rpcMsg); } } static void mndPullupGrant(SMnode *pMnode) { - int32_t code = 0; mTrace("pullup grant msg"); int32_t contLen = 0; void *pReq = mndBuildTimerMsg(&contLen); if (pReq != NULL) { SRpcMsg rpcMsg = { .msgType = TDMT_MND_GRANT_HB_TIMER, .pCont = pReq, .contLen = contLen, .info.ahandle = (void *)0x9527}; - if ((code = tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg)) != 0) { - mError("failed to put to queue since %s", tstrerror(code)); - } + // TODO check return value + (void)tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg); } } static void mndIncreaseUpTime(SMnode *pMnode) { - int32_t code = 0; mTrace("increate uptime"); int32_t contLen = 0; void *pReq = mndBuildTimerMsg(&contLen); if (pReq != NULL) { SRpcMsg rpcMsg = { .msgType = TDMT_MND_UPTIME_TIMER, .pCont = pReq, .contLen = contLen, .info.ahandle = (void *)0x9528}; - if ((code = tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg)) != 0) { - mError("failed to put to queue since %s", tstrerror(code)); - } + // TODO check return value + (void)tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg); } } @@ -465,14 +440,14 @@ static void *mndThreadFp(void *param) { static int32_t mndInitTimer(SMnode *pMnode) { int32_t code = 0; TdThreadAttr thAttr; - TAOS_CHECK_RETURN(taosThreadAttrInit(&thAttr)); - TAOS_CHECK_RETURN(taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE)); + (void)taosThreadAttrInit(&thAttr); + (void)taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE); if ((code = taosThreadCreate(&pMnode->thread, &thAttr, mndThreadFp, pMnode)) != 0) { mError("failed to create timer thread since %s", strerror(errno)); TAOS_RETURN(code); } - TAOS_CHECK_RETURN(taosThreadAttrDestroy(&thAttr)); + (void)taosThreadAttrDestroy(&thAttr); tmsgReportStartup("mnode-timer", "initialized"); TAOS_RETURN(code); } @@ -739,15 +714,11 @@ SMnode *mndOpen(const char *path, const SMnodeOpt *pOption) { } void mndPreClose(SMnode *pMnode) { - int32_t code = 0; if (pMnode != NULL) { - if ((code = syncLeaderTransfer(pMnode->syncMgmt.sync)) != 0) { - mError("failed to pre close since %s", tstrerror(code)); - } + // TODO check return value + syncLeaderTransfer(pMnode->syncMgmt.sync); syncPreStop(pMnode->syncMgmt.sync); - if ((code = sdbWriteFile(pMnode->pSdb, 0)) != 0) { - mError("failed to pre close since %s", tstrerror(code)); - } + sdbWriteFile(pMnode->pSdb, 0); } } @@ -826,7 +797,7 @@ static int32_t mndCheckMnodeState(SRpcMsg *pMsg) { } SMnode *pMnode = pMsg->info.node; - TAOS_CHECK_RETURN(taosThreadRwlockRdlock(&pMnode->lock)); + (void)taosThreadRwlockRdlock(&pMnode->lock); if (pMnode->stopped) { (void)taosThreadRwlockUnlock(&pMnode->lock); code = TSDB_CODE_APP_IS_STOPPING; From 8ef31bc18662fbe8995c897bbcc4cb4242659da6 Mon Sep 17 00:00:00 2001 From: Hongze Cheng Date: Mon, 29 Jul 2024 20:14:15 +0800 Subject: [PATCH 23/28] enh: refactor return code --- include/util/tlockfree.h | 8 +- source/common/src/tdataformat.c | 37 +-- source/common/src/tmsg.c | 36 +-- source/dnode/vnode/src/inc/meta.h | 6 +- source/dnode/vnode/src/meta/metaCache.c | 32 +-- source/dnode/vnode/src/meta/metaOpen.c | 42 ++-- source/dnode/vnode/src/meta/metaQuery.c | 34 +-- source/dnode/vnode/src/meta/metaSnapshot.c | 90 +++---- source/dnode/vnode/src/meta/metaTable.c | 245 ++++++++++--------- source/dnode/vnode/src/tsdb/tsdbCache.c | 2 +- source/dnode/vnode/src/tsdb/tsdbDataFileRW.c | 32 +-- source/dnode/vnode/src/tsdb/tsdbFS2.c | 8 +- source/dnode/vnode/src/tsdb/tsdbFSet2.c | 7 +- source/dnode/vnode/src/tsdb/tsdbOpen.c | 2 +- source/dnode/vnode/src/tsdb/tsdbSttFileRW.c | 2 +- source/dnode/vnode/src/tsdb/tsdbUpgrade.c | 6 +- source/dnode/vnode/src/tsdb/tsdbUtil.c | 4 +- source/dnode/vnode/src/vnd/vnodeAsync.c | 4 +- source/dnode/vnode/src/vnd/vnodeCommit.c | 2 +- source/dnode/vnode/src/vnd/vnodeOpen.c | 6 +- source/dnode/vnode/src/vnd/vnodeSnapshot.c | 4 +- source/dnode/vnode/src/vnd/vnodeSvr.c | 8 +- source/dnode/vnode/src/vnd/vnodeSync.c | 2 +- source/libs/tdb/src/db/tdbBtree.c | 14 +- source/libs/tdb/src/db/tdbPager.c | 2 +- source/util/src/tarray.c | 2 +- source/util/src/tcache.c | 46 ++-- source/util/src/tdigest.c | 2 +- source/util/src/terror.c | 2 +- source/util/src/texception.c | 4 +- source/util/src/thash.c | 20 +- source/util/src/theap.c | 12 +- source/util/src/tidpool.c | 4 +- source/util/src/tlockfree.c | 8 +- source/util/src/tlog.c | 96 ++++---- source/util/src/tqueue.c | 34 +-- source/util/src/trbtree.c | 2 +- source/util/src/tref.c | 8 +- source/util/src/tskiplist.c | 20 +- source/util/src/tthread.c | 10 +- source/util/src/ttimer.c | 18 +- source/util/src/tworker.c | 116 ++++----- 42 files changed, 519 insertions(+), 520 deletions(-) diff --git a/include/util/tlockfree.h b/include/util/tlockfree.h index 82dd5a0e8b..1a575f8ea1 100644 --- a/include/util/tlockfree.h +++ b/include/util/tlockfree.h @@ -84,7 +84,7 @@ int32_t taosWTryLockLatch(SRWLatch *pLatch); int32_t old_ = atomic_add_fetch_32((x), 0); \ if (old_ & 0x00000001) { \ if (i_ % 1000 == 0) { \ - sched_yield(); \ + (void)sched_yield(); \ } \ continue; \ } @@ -98,9 +98,9 @@ int32_t taosWTryLockLatch(SRWLatch *pLatch); #define taosCorBeginWrite(x) \ taosCorBeginRead(x) if (atomic_val_compare_exchange_32((x), old_, old_ + 1) != old_) { continue; } -#define taosCorEndWrite(x) \ - atomic_add_fetch_32((x), 1); \ - break; \ +#define taosCorEndWrite(x) \ + (void)atomic_add_fetch_32((x), 1); \ + break; \ } #ifdef __cplusplus diff --git a/source/common/src/tdataformat.c b/source/common/src/tdataformat.c index 371fc130f0..5caf93de65 100644 --- a/source/common/src/tdataformat.c +++ b/source/common/src/tdataformat.c @@ -706,7 +706,10 @@ static int32_t tRowMergeImpl(SArray *aRowP, STSchema *pTSchema, int32_t iStart, if (code) goto _exit; taosArrayRemoveBatch(aRowP, iStart, nRow, (FDelete)tRowPDestroy); - taosArrayInsert(aRowP, iStart, &pRow); + if (taosArrayInsert(aRowP, iStart, &pRow) == NULL) { + code = terrno; + goto _exit; + } _exit: if (aIter) { @@ -1708,7 +1711,7 @@ bool tTagGet(const STag *pTag, STagVal *pTagVal) { offset = pTag->idx[midx]; } - tGetTagVal(p + offset, &tv, isJson); + (void)tGetTagVal(p + offset, &tv, isJson); if (isJson) { c = tTagValJsonCmprFn(pTagVal, &tv); } else { @@ -1758,7 +1761,7 @@ int32_t tTagToValArray(const STag *pTag, SArray **ppArray) { } else { offset = pTag->idx[iTag]; } - tGetTagVal(p + offset, &tv, pTag->flags & TD_TAG_JSON); + (void)tGetTagVal(p + offset, &tv, pTag->flags & TD_TAG_JSON); if (taosArrayPush(*ppArray, &tv) == NULL) { code = TSDB_CODE_OUT_OF_MEMORY; goto _err; @@ -1788,7 +1791,7 @@ void tTagSetCid(const STag *pTag, int16_t iTag, int16_t cid) { offset = pTag->idx[iTag]; } - tPutI16v(p + offset, cid); + (void)tPutI16v(p + offset, cid); } // STSchema ======================================== @@ -3152,16 +3155,16 @@ static int32_t tColDataCopyRowSingleCol(SColData *pFromColData, int32_t iFromRow SET_BIT1(pToColData->pBitMap, iToRow, GET_BIT1(pFromColData->pBitMap, iFromRow)); } break; case HAS_VALUE: { - tColDataCopyRowCell(pFromColData, iFromRow, pToColData, iToRow); + (void)tColDataCopyRowCell(pFromColData, iFromRow, pToColData, iToRow); } break; case (HAS_VALUE | HAS_NONE): case (HAS_VALUE | HAS_NULL): { SET_BIT1(pToColData->pBitMap, iToRow, GET_BIT1(pFromColData->pBitMap, iFromRow)); - tColDataCopyRowCell(pFromColData, iFromRow, pToColData, iToRow); + (void)tColDataCopyRowCell(pFromColData, iFromRow, pToColData, iToRow); } break; case (HAS_VALUE | HAS_NULL | HAS_NONE): { SET_BIT2(pToColData->pBitMap, iToRow, GET_BIT2(pFromColData->pBitMap, iFromRow)); - tColDataCopyRowCell(pFromColData, iFromRow, pToColData, iToRow); + (void)tColDataCopyRowCell(pFromColData, iFromRow, pToColData, iToRow); } break; default: return -1; @@ -3235,24 +3238,24 @@ static int32_t tColDataMergeSortMerge(SColData *aColData, int32_t start, int32_t tColDataArrGetRowKey(aColData, nColData, j, &keyj); while (i <= mid && j <= end) { if (tRowKeyCompare(&keyi, &keyj) <= 0) { - tColDataCopyRowAppend(aColData, i++, aDstColData, nColData); + (void)tColDataCopyRowAppend(aColData, i++, aDstColData, nColData); tColDataArrGetRowKey(aColData, nColData, i, &keyi); } else { - tColDataCopyRowAppend(aColData, j++, aDstColData, nColData); + (void)tColDataCopyRowAppend(aColData, j++, aDstColData, nColData); tColDataArrGetRowKey(aColData, nColData, j, &keyj); } } while (i <= mid) { - tColDataCopyRowAppend(aColData, i++, aDstColData, nColData); + (void)tColDataCopyRowAppend(aColData, i++, aDstColData, nColData); } while (j <= end) { - tColDataCopyRowAppend(aColData, j++, aDstColData, nColData); + (void)tColDataCopyRowAppend(aColData, j++, aDstColData, nColData); } for (i = start, k = 0; i <= end; ++i, ++k) { - tColDataCopyRow(aDstColData, k, aColData, i, nColData); + (void)tColDataCopyRow(aDstColData, k, aColData, i, nColData); } if (aDstColData) { @@ -3551,7 +3554,7 @@ void tColDataSortMerge(SArray *colDataArr) { // sort ------- if (doSort) { - tColDataSort(aColData, nColData); + (void)tColDataSort(aColData, nColData); } if (doMerge != 1) { @@ -4209,17 +4212,17 @@ int32_t tValueColumnGet(SValueColumn *valCol, int32_t idx, SValue *value) { int32_t offset, nextOffset; SBufferReader reader = BUFFER_READER_INITIALIZER(idx * sizeof(offset), &valCol->offsets); - tBufferGetI32(&reader, &offset); + (void)tBufferGetI32(&reader, &offset); if (idx == valCol->numOfValues - 1) { nextOffset = tBufferGetSize(&valCol->data); } else { - tBufferGetI32(&reader, &nextOffset); + (void)tBufferGetI32(&reader, &nextOffset); } value->nData = nextOffset - offset; value->pData = (uint8_t *)tBufferGetDataAt(&valCol->data, offset); } else { SBufferReader reader = BUFFER_READER_INITIALIZER(idx * tDataTypes[value->type].bytes, &valCol->data); - tBufferGet(&reader, tDataTypes[value->type].bytes, &value->val); + (void)tBufferGet(&reader, tDataTypes[value->type].bytes, &value->val); } return 0; } @@ -4269,7 +4272,7 @@ int32_t tValueColumnDecompress(void *input, const SValueColumnCompressInfo *info SBuffer *assist) { int32_t code; - tValueColumnClear(valCol); + (void)tValueColumnClear(valCol); valCol->type = info->type; // offset if (IS_VAR_DATA_TYPE(valCol->type)) { diff --git a/source/common/src/tmsg.c b/source/common/src/tmsg.c index 2fe6deaf14..1db6fd2ff6 100644 --- a/source/common/src/tmsg.c +++ b/source/common/src/tmsg.c @@ -522,7 +522,7 @@ int32_t tDeserializeSClientHbBatchReq(void *buf, int32_t bufLen, SClientHbBatchR } if (!tDecodeIsEnd(&decoder)) { - tDecodeI64(&decoder, &pBatchReq->ipWhiteList); + if (tDecodeI64(&decoder, &pBatchReq->ipWhiteList) < 0) return -1; } tEndDecode(&decoder); @@ -2163,21 +2163,21 @@ int32_t tDeserializeSGetUserAuthRspImpl(SDecoder *pDecoder, SGetUserAuthRsp *pRs char db[TSDB_DB_FNAME_LEN] = {0}; if (tDecodeCStrTo(pDecoder, db) < 0) goto _err; int32_t len = strlen(db); - taosHashPut(pRsp->createdDbs, db, len + 1, db, len + 1); + if (taosHashPut(pRsp->createdDbs, db, len + 1, db, len + 1) < 0) goto _err; } for (int32_t i = 0; i < numOfReadDbs; ++i) { char db[TSDB_DB_FNAME_LEN] = {0}; if (tDecodeCStrTo(pDecoder, db) < 0) goto _err; int32_t len = strlen(db); - taosHashPut(pRsp->readDbs, db, len + 1, db, len + 1); + if (taosHashPut(pRsp->readDbs, db, len + 1, db, len + 1) < 0) goto _err; } for (int32_t i = 0; i < numOfWriteDbs; ++i) { char db[TSDB_DB_FNAME_LEN] = {0}; if (tDecodeCStrTo(pDecoder, db) < 0) goto _err; int32_t len = strlen(db); - taosHashPut(pRsp->writeDbs, db, len + 1, db, len + 1); + if (taosHashPut(pRsp->writeDbs, db, len + 1, db, len + 1) < 0) goto _err; } if (!tDecodeIsEnd(pDecoder)) { @@ -2209,7 +2209,7 @@ int32_t tDeserializeSGetUserAuthRspImpl(SDecoder *pDecoder, SGetUserAuthRsp *pRs if ((value = taosMemoryCalloc(valuelen + 1, sizeof(char))) == NULL) goto _err; if (tDecodeCStrTo(pDecoder, value) < 0) goto _err; - taosHashPut(pRsp->readTbs, key, keyLen, value, valuelen + 1); + if (taosHashPut(pRsp->readTbs, key, keyLen, value, valuelen + 1) < 0) goto _err; taosMemoryFreeClear(key); taosMemoryFreeClear(value); @@ -2247,7 +2247,7 @@ int32_t tDeserializeSGetUserAuthRspImpl(SDecoder *pDecoder, SGetUserAuthRsp *pRs if ((value = taosMemoryCalloc(valuelen + 1, sizeof(char))) == NULL) goto _err; if (tDecodeCStrTo(pDecoder, value) < 0) goto _err; - taosHashPut(pRsp->alterTbs, key, keyLen, value, valuelen + 1); + if (taosHashPut(pRsp->alterTbs, key, keyLen, value, valuelen + 1) < 0) goto _err; taosMemoryFreeClear(key); taosMemoryFreeClear(value); @@ -2266,7 +2266,7 @@ int32_t tDeserializeSGetUserAuthRspImpl(SDecoder *pDecoder, SGetUserAuthRsp *pRs if ((value = taosMemoryCalloc(valuelen + 1, sizeof(char))) == NULL) goto _err; if (tDecodeCStrTo(pDecoder, value) < 0) goto _err; - taosHashPut(pRsp->readViews, key, keyLen, value, valuelen + 1); + if (taosHashPut(pRsp->readViews, key, keyLen, value, valuelen + 1) < 0) goto _err; taosMemoryFreeClear(key); taosMemoryFreeClear(value); @@ -2304,7 +2304,7 @@ int32_t tDeserializeSGetUserAuthRspImpl(SDecoder *pDecoder, SGetUserAuthRsp *pRs if ((value = taosMemoryCalloc(valuelen + 1, sizeof(char))) == NULL) goto _err; if (tDecodeCStrTo(pDecoder, value) < 0) goto _err; - taosHashPut(pRsp->alterViews, key, keyLen, value, valuelen + 1); + if (taosHashPut(pRsp->alterViews, key, keyLen, value, valuelen + 1) < 0) goto _err; taosMemoryFreeClear(key); taosMemoryFreeClear(value); @@ -2320,7 +2320,7 @@ int32_t tDeserializeSGetUserAuthRspImpl(SDecoder *pDecoder, SGetUserAuthRsp *pRs int32_t ref = 0; if (tDecodeI32(pDecoder, &ref) < 0) goto _err; - taosHashPut(pRsp->useDbs, key, keyLen, &ref, sizeof(ref)); + if (taosHashPut(pRsp->useDbs, key, keyLen, &ref, sizeof(ref)) < 0) goto _err; taosMemoryFreeClear(key); } // since 3.0.7.0 @@ -4240,7 +4240,7 @@ int32_t tSerializeSDbCfgRsp(void *buf, int32_t bufLen, const SDbCfgRsp *pRsp) { tEncoderInit(&encoder, buf, bufLen); if (tStartEncode(&encoder) < 0) return -1; - tSerializeSDbCfgRspImpl(&encoder, pRsp); + if (tSerializeSDbCfgRspImpl(&encoder, pRsp) < 0) return -1; tEndEncode(&encoder); int32_t tlen = encoder.pos; tEncoderClear(&encoder); @@ -7815,8 +7815,8 @@ int32_t tEncodeTSma(SEncoder *pCoder, const STSma *pSma) { if (tEncodeCStr(pCoder, pSma->tagsFilter) < 0) return -1; } - tEncodeSSchemaWrapper(pCoder, &pSma->schemaRow); - tEncodeSSchemaWrapper(pCoder, &pSma->schemaTag); + if (tEncodeSSchemaWrapper(pCoder, &pSma->schemaRow) < 0) return -1; + if (tEncodeSSchemaWrapper(pCoder, &pSma->schemaTag) < 0) return -1; return 0; } @@ -7861,8 +7861,8 @@ int32_t tDecodeTSma(SDecoder *pCoder, STSma *pSma, bool deepCopy) { pSma->tagsFilter = NULL; } // only needed in dstVgroup - tDecodeSSchemaWrapperEx(pCoder, &pSma->schemaRow); - tDecodeSSchemaWrapperEx(pCoder, &pSma->schemaTag); + if (tDecodeSSchemaWrapperEx(pCoder, &pSma->schemaRow) < 0) return -1; + if (tDecodeSSchemaWrapperEx(pCoder, &pSma->schemaTag) < 0) return -1; return 0; } @@ -7870,7 +7870,7 @@ int32_t tDecodeTSma(SDecoder *pCoder, STSma *pSma, bool deepCopy) { int32_t tEncodeSVCreateTSmaReq(SEncoder *pCoder, const SVCreateTSmaReq *pReq) { if (tStartEncode(pCoder) < 0) return -1; - tEncodeTSma(pCoder, pReq); + if (tEncodeTSma(pCoder, pReq) < 0) return -1; tEndEncode(pCoder); return 0; @@ -7879,7 +7879,7 @@ int32_t tEncodeSVCreateTSmaReq(SEncoder *pCoder, const SVCreateTSmaReq *pReq) { int32_t tDecodeSVCreateTSmaReq(SDecoder *pCoder, SVCreateTSmaReq *pReq) { if (tStartDecode(pCoder) < 0) return -1; - tDecodeTSma(pCoder, pReq, false); + if (tDecodeTSma(pCoder, pReq, false) < 0) return -1; tEndDecode(pCoder); return 0; @@ -10741,7 +10741,7 @@ void tFreeSMDropTbReqOnSingleVg(void *p) { int32_t tSerializeSMDropTbsReq(void *buf, int32_t bufLen, const SMDropTbsReq *pReq) { SEncoder encoder = {0}; tEncoderInit(&encoder, buf, bufLen); - tStartEncode(&encoder); + if (tStartEncode(&encoder) < 0) return -1; int32_t size = pReq->pVgReqs ? pReq->pVgReqs->size : 0; if (tEncodeI32(&encoder, size) < 0) return -1; for (int32_t i = 0; i < size; ++i) { @@ -10757,7 +10757,7 @@ int32_t tSerializeSMDropTbsReq(void *buf, int32_t bufLen, const SMDropTbsReq *pR int32_t tDeserializeSMDropTbsReq(void *buf, int32_t bufLen, SMDropTbsReq *pReq) { SDecoder decoder = {0}; tDecoderInit(&decoder, buf, bufLen); - tStartDecode(&decoder); + if (tStartDecode(&decoder) < 0) return -1; int32_t size = 0; if (tDecodeI32(&decoder, &size) < 0) return -1; pReq->pVgReqs = taosArrayInit(size, sizeof(SMDropTbReqsOnSingleVg)); diff --git a/source/dnode/vnode/src/inc/meta.h b/source/dnode/vnode/src/inc/meta.h index d986d63ac7..87d7d2150e 100644 --- a/source/dnode/vnode/src/inc/meta.h +++ b/source/dnode/vnode/src/inc/meta.h @@ -39,9 +39,9 @@ typedef struct SMetaCache SMetaCache; // clang-format on // metaOpen ================== -int32_t metaRLock(SMeta* pMeta); -int32_t metaWLock(SMeta* pMeta); -int32_t metaULock(SMeta* pMeta); +void metaRLock(SMeta* pMeta); +void metaWLock(SMeta* pMeta); +void metaULock(SMeta* pMeta); // metaEntry ================== int metaEncodeEntry(SEncoder* pCoder, const SMetaEntry* pME); diff --git a/source/dnode/vnode/src/meta/metaCache.c b/source/dnode/vnode/src/meta/metaCache.c index 8af902538d..3d4067ba99 100644 --- a/source/dnode/vnode/src/meta/metaCache.c +++ b/source/dnode/vnode/src/meta/metaCache.c @@ -156,7 +156,7 @@ int32_t metaCacheOpen(SMeta* pMeta) { } taosHashSetFreeFp(pMeta->pCache->sTagFilterResCache.pTableEntry, freeCacheEntryFp); - taosThreadMutexInit(&pMeta->pCache->sTagFilterResCache.lock, NULL); + (void)taosThreadMutexInit(&pMeta->pCache->sTagFilterResCache.lock, NULL); pMeta->pCache->STbGroupResCache.pResCache = taosLRUCacheInit(5 * 1024 * 1024, -1, 0.5); if (pMeta->pCache->STbGroupResCache.pResCache == NULL) { @@ -171,7 +171,7 @@ int32_t metaCacheOpen(SMeta* pMeta) { } taosHashSetFreeFp(pMeta->pCache->STbGroupResCache.pTableEntry, freeCacheEntryFp); - taosThreadMutexInit(&pMeta->pCache->STbGroupResCache.lock, NULL); + (void)taosThreadMutexInit(&pMeta->pCache->STbGroupResCache.lock, NULL); pMeta->pCache->STbFilterCache.pStb = taosHashInit(0, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK); @@ -201,11 +201,11 @@ void metaCacheClose(SMeta* pMeta) { statsCacheClose(pMeta); taosLRUCacheCleanup(pMeta->pCache->sTagFilterResCache.pUidResCache); - taosThreadMutexDestroy(&pMeta->pCache->sTagFilterResCache.lock); + (void)taosThreadMutexDestroy(&pMeta->pCache->sTagFilterResCache.lock); taosHashCleanup(pMeta->pCache->sTagFilterResCache.pTableEntry); taosLRUCacheCleanup(pMeta->pCache->STbGroupResCache.pResCache); - taosThreadMutexDestroy(&pMeta->pCache->STbGroupResCache.lock); + (void)taosThreadMutexDestroy(&pMeta->pCache->STbGroupResCache.lock); taosHashCleanup(pMeta->pCache->STbGroupResCache.pTableEntry); taosHashCleanup(pMeta->pCache->STbFilterCache.pStb); @@ -495,7 +495,7 @@ static int checkAllEntriesInCache(const STagFilterResEntry* pEntry, SArray* pInv return TSDB_CODE_OUT_OF_MEMORY; } } else { - taosLRUCacheRelease(pCache, pRes, false); + (void)taosLRUCacheRelease(pCache, pRes, false); } } @@ -552,7 +552,9 @@ int32_t metaGetCachedTableUidList(void* pVnode, tb_uid_t suid, const uint8_t* pK int32_t size = *(int32_t*)p; // set the result into the buffer - taosArrayAddBatch(pList1, p + sizeof(int32_t), size); + if (taosArrayAddBatch(pList1, p + sizeof(int32_t), size) == NULL) { + return terrno; + } (*pEntry)->hitTimes += 1; @@ -562,7 +564,7 @@ int32_t metaGetCachedTableUidList(void* pVnode, tb_uid_t suid, const uint8_t* pK ((double)(*pEntry)->hitTimes) / acc); } - taosLRUCacheRelease(pCache, pHandle, false); + (void)taosLRUCacheRelease(pCache, pHandle, false); // unlock meta (void)taosThreadMutexUnlock(pLock); @@ -618,7 +620,7 @@ static int32_t addNewEntry(SHashObj* pTableEntry, const void* pKey, int32_t keyL p->hitTimes = 0; tdListInit(&p->list, keyLen); TAOS_CHECK_RETURN(taosHashPut(pTableEntry, &suid, sizeof(uint64_t), &p, POINTER_BYTES)); - tdListAppend(&p->list, pKey); + (void)tdListAppend(&p->list, pKey); return 0; } @@ -662,7 +664,7 @@ int32_t metaUidFilterCachePut(void* pVnode, uint64_t suid, const void* pKey, int } else { // check if it exists or not size_t size = listNEles(&(*pEntry)->list); if (size == 0) { - tdListAppend(&(*pEntry)->list, pKey); + (void)tdListAppend(&(*pEntry)->list, pKey); } else { SListNode* pNode = listHead(&(*pEntry)->list); uint64_t* p = (uint64_t*)pNode->data; @@ -671,7 +673,7 @@ int32_t metaUidFilterCachePut(void* pVnode, uint64_t suid, const void* pKey, int (void)taosThreadMutexUnlock(pLock); return TSDB_CODE_SUCCESS; } else { // not equal, append it - tdListAppend(&(*pEntry)->list, pKey); + (void)tdListAppend(&(*pEntry)->list, pKey); } } } @@ -761,7 +763,7 @@ int32_t metaGetCachedTbGroup(void* pVnode, tb_uid_t suid, const uint8_t* pKey, i ((double)(*pEntry)->hitTimes) / acc); } - taosLRUCacheRelease(pCache, pHandle, false); + (void)taosLRUCacheRelease(pCache, pHandle, false); // unlock meta (void)taosThreadMutexUnlock(pLock); @@ -839,7 +841,7 @@ int32_t metaPutTbGroupToCache(void* pVnode, uint64_t suid, const void* pKey, int } else { // check if it exists or not size_t size = listNEles(&(*pEntry)->list); if (size == 0) { - tdListAppend(&(*pEntry)->list, pKey); + (void)tdListAppend(&(*pEntry)->list, pKey); } else { SListNode* pNode = listHead(&(*pEntry)->list); uint64_t* p = (uint64_t*)pNode->data; @@ -848,14 +850,14 @@ int32_t metaPutTbGroupToCache(void* pVnode, uint64_t suid, const void* pKey, int (void)taosThreadMutexUnlock(pLock); return TSDB_CODE_SUCCESS; } else { // not equal, append it - tdListAppend(&(*pEntry)->list, pKey); + (void)tdListAppend(&(*pEntry)->list, pKey); } } } // add to cache. - taosLRUCacheInsert(pCache, key, TAG_FILTER_RES_KEY_LEN, pPayload, payloadLen, freeTbGroupCachePayload, NULL, - TAOS_LRU_PRIORITY_LOW, NULL); + (void)taosLRUCacheInsert(pCache, key, TAG_FILTER_RES_KEY_LEN, pPayload, payloadLen, freeTbGroupCachePayload, NULL, + TAOS_LRU_PRIORITY_LOW, NULL); _end: (void)taosThreadMutexUnlock(pLock); metaDebug("vgId:%d, suid:%" PRIu64 " tb group added into cache, total:%d, tables:%d", vgId, suid, diff --git a/source/dnode/vnode/src/meta/metaOpen.c b/source/dnode/vnode/src/meta/metaOpen.c index ec26e94c5a..13163aef05 100644 --- a/source/dnode/vnode/src/meta/metaOpen.c +++ b/source/dnode/vnode/src/meta/metaOpen.c @@ -29,10 +29,10 @@ static int ncolIdxCmpr(const void *pKey1, int kLen1, const void *pKey2, int kLen static int32_t metaInitLock(SMeta *pMeta) { TdThreadRwlockAttr attr; - taosThreadRwlockAttrInit(&attr); - taosThreadRwlockAttrSetKindNP(&attr, PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP); - taosThreadRwlockInit(&pMeta->lock, &attr); - taosThreadRwlockAttrDestroy(&attr); + (void)taosThreadRwlockAttrInit(&attr); + (void)taosThreadRwlockAttrSetKindNP(&attr, PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP); + (void)taosThreadRwlockInit(&pMeta->lock, &attr); + (void)taosThreadRwlockAttrDestroy(&attr); return 0; } static int32_t metaDestroyLock(SMeta *pMeta) { return taosThreadRwlockDestroy(&pMeta->lock); } @@ -48,7 +48,7 @@ int32_t metaOpen(SVnode *pVnode, SMeta **ppMeta, int8_t rollback) { char indexFullPath[128] = {0}; // create handle - vnodeGetPrimaryDir(pVnode->path, pVnode->diskPrimary, pVnode->pTfs, path, TSDB_FILENAME_LEN); + (void)vnodeGetPrimaryDir(pVnode->path, pVnode->diskPrimary, pVnode->pTfs, path, TSDB_FILENAME_LEN); offset = strlen(path); snprintf(path + offset, TSDB_FILENAME_LEN - offset - 1, "%s%s", TD_DIRSEP, VNODE_META_DIR); @@ -56,16 +56,16 @@ int32_t metaOpen(SVnode *pVnode, SMeta **ppMeta, int8_t rollback) { TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit); } - metaInitLock(pMeta); + (void)metaInitLock(pMeta); pMeta->path = (char *)&pMeta[1]; strcpy(pMeta->path, path); - taosRealPath(pMeta->path, NULL, strlen(path) + 1); + (void)taosRealPath(pMeta->path, NULL, strlen(path) + 1); pMeta->pVnode = pVnode; // create path if not created yet - taosMkDir(pMeta->path); + (void)taosMkDir(pMeta->path); // open env code = tdbOpen(pMeta->path, pVnode->config.szPage, pVnode->config.szCache, &pMeta->pEnv, rollback, @@ -186,31 +186,19 @@ int metaAlterCache(SMeta *pMeta, int32_t nPage) { return code; } -int32_t metaRLock(SMeta *pMeta) { +void metaRLock(SMeta *pMeta) { metaTrace("meta rlock %p", &pMeta->lock); - int32_t code = taosThreadRwlockRdlock(&pMeta->lock); - if (code) { - return TAOS_SYSTEM_ERROR(code); - } - return 0; + (void)taosThreadRwlockRdlock(&pMeta->lock); } -int32_t metaWLock(SMeta *pMeta) { +void metaWLock(SMeta *pMeta) { metaTrace("meta wlock %p", &pMeta->lock); - int32_t code = taosThreadRwlockWrlock(&pMeta->lock); - if (code) { - return TAOS_SYSTEM_ERROR(code); - } - return 0; + (void)taosThreadRwlockWrlock(&pMeta->lock); } -int32_t metaULock(SMeta *pMeta) { +void metaULock(SMeta *pMeta) { metaTrace("meta ulock %p", &pMeta->lock); - int32_t code = taosThreadRwlockUnlock(&pMeta->lock); - if (code) { - return TAOS_SYSTEM_ERROR(code); - } - return 0; + (void)taosThreadRwlockUnlock(&pMeta->lock); } static void metaCleanup(SMeta **ppMeta) { @@ -235,7 +223,7 @@ static void metaCleanup(SMeta **ppMeta) { if (pMeta->pSkmDb) tdbTbClose(pMeta->pSkmDb); if (pMeta->pTbDb) tdbTbClose(pMeta->pTbDb); if (pMeta->pEnv) tdbClose(pMeta->pEnv); - metaDestroyLock(pMeta); + (void)metaDestroyLock(pMeta); taosMemoryFreeClear(*ppMeta); } diff --git a/source/dnode/vnode/src/meta/metaQuery.c b/source/dnode/vnode/src/meta/metaQuery.c index ee616d7a0d..5daa7817f6 100644 --- a/source/dnode/vnode/src/meta/metaQuery.c +++ b/source/dnode/vnode/src/meta/metaQuery.c @@ -252,7 +252,7 @@ void metaCloseTbCursor(SMTbCursor *pTbCur) { if (!pTbCur->paused) { metaReaderClear(&pTbCur->mr); if (pTbCur->pDbc) { - tdbTbcClose((TBC *)pTbCur->pDbc); + (void)tdbTbcClose((TBC *)pTbCur->pDbc); } } taosMemoryFree(pTbCur); @@ -262,7 +262,7 @@ void metaCloseTbCursor(SMTbCursor *pTbCur) { void metaPauseTbCursor(SMTbCursor *pTbCur) { if (!pTbCur->paused) { metaReaderClear(&pTbCur->mr); - tdbTbcClose((TBC *)pTbCur->pDbc); + (void)tdbTbcClose((TBC *)pTbCur->pDbc); pTbCur->paused = 1; } } @@ -270,10 +270,10 @@ void metaResumeTbCursor(SMTbCursor *pTbCur, int8_t first, int8_t move) { if (pTbCur->paused) { metaReaderDoInit(&pTbCur->mr, pTbCur->pMeta, META_READER_LOCK); - tdbTbcOpen(((SMeta *)pTbCur->pMeta)->pUidIdx, (TBC **)&pTbCur->pDbc, NULL); + (void)tdbTbcOpen(((SMeta *)pTbCur->pMeta)->pUidIdx, (TBC **)&pTbCur->pDbc, NULL); if (first) { - tdbTbcMoveToFirst((TBC *)pTbCur->pDbc); + (void)tdbTbcMoveToFirst((TBC *)pTbCur->pDbc); } else { int c = 1; tdbTbcMoveTo(pTbCur->pDbc, pTbCur->pKey, pTbCur->kLen, &c); @@ -433,7 +433,7 @@ void metaCloseCtbCursor(SMCtbCursor *pCtbCur) { if (!pCtbCur->paused) { if (pCtbCur->pMeta && pCtbCur->lock) metaULock(pCtbCur->pMeta); if (pCtbCur->pCur) { - tdbTbcClose(pCtbCur->pCur); + (void)tdbTbcClose(pCtbCur->pCur); } } tdbFree(pCtbCur->pKey); @@ -444,7 +444,7 @@ void metaCloseCtbCursor(SMCtbCursor *pCtbCur) { void metaPauseCtbCursor(SMCtbCursor *pCtbCur) { if (!pCtbCur->paused) { - tdbTbcClose((TBC *)pCtbCur->pCur); + (void)tdbTbcClose((TBC *)pCtbCur->pCur); if (pCtbCur->lock) { metaULock(pCtbCur->pMeta); } @@ -552,7 +552,7 @@ void metaCloseStbCursor(SMStbCursor *pStbCur) { if (pStbCur) { if (pStbCur->pMeta) metaULock(pStbCur->pMeta); if (pStbCur->pCur) { - tdbTbcClose(pStbCur->pCur); + (void)tdbTbcClose(pStbCur->pCur); tdbFree(pStbCur->pKey); tdbFree(pStbCur->pVal); @@ -603,19 +603,19 @@ int32_t metaGetTbTSchemaEx(SMeta *pMeta, tb_uid_t suid, tb_uid_t uid, int32_t sv skmDbKey.uid = suid ? suid : uid; skmDbKey.sver = INT32_MAX; - tdbTbcOpen(pMeta->pSkmDb, &pSkmDbC, NULL); + (void)tdbTbcOpen(pMeta->pSkmDb, &pSkmDbC, NULL); metaRLock(pMeta); if (tdbTbcMoveTo(pSkmDbC, &skmDbKey, sizeof(skmDbKey), &c) < 0) { metaULock(pMeta); - tdbTbcClose(pSkmDbC); + (void)tdbTbcClose(pSkmDbC); code = TSDB_CODE_NOT_FOUND; goto _exit; } if (c == 0) { metaULock(pMeta); - tdbTbcClose(pSkmDbC); + (void)tdbTbcClose(pSkmDbC); code = TSDB_CODE_FAILED; metaError("meta/query: incorrect c: %" PRId32 ".", c); goto _exit; @@ -631,7 +631,7 @@ int32_t metaGetTbTSchemaEx(SMeta *pMeta, tb_uid_t suid, tb_uid_t uid, int32_t sv if (((SSkmDbKey *)pKey)->uid != skmDbKey.uid) { metaULock(pMeta); - tdbTbcClose(pSkmDbC); + (void)tdbTbcClose(pSkmDbC); code = TSDB_CODE_NOT_FOUND; goto _exit; } @@ -639,7 +639,7 @@ int32_t metaGetTbTSchemaEx(SMeta *pMeta, tb_uid_t suid, tb_uid_t uid, int32_t sv sver = ((SSkmDbKey *)pKey)->sver; metaULock(pMeta); - tdbTbcClose(pSkmDbC); + (void)tdbTbcClose(pSkmDbC); } } @@ -765,7 +765,7 @@ void metaCloseSmaCursor(SMSmaCursor *pSmaCur) { if (pSmaCur) { if (pSmaCur->pMeta) metaULock(pSmaCur->pMeta); if (pSmaCur->pCur) { - tdbTbcClose(pSmaCur->pCur); + (void)tdbTbcClose(pSmaCur->pCur); tdbFree(pSmaCur->pKey); tdbFree(pSmaCur->pVal); @@ -1086,7 +1086,7 @@ int32_t metaFilterCreateTime(void *pVnode, SMetaFltParam *arg, SArray *pUids) { END: if (pCursor->pMeta) metaULock(pCursor->pMeta); - if (pCursor->pCur) tdbTbcClose(pCursor->pCur); + if (pCursor->pCur) (void)tdbTbcClose(pCursor->pCur); taosMemoryFree(pCursor); return ret; } @@ -1153,7 +1153,7 @@ int32_t metaFilterTableName(void *pVnode, SMetaFltParam *arg, SArray *pUids) { END: if (pCursor->pMeta) metaULock(pCursor->pMeta); - if (pCursor->pCur) tdbTbcClose(pCursor->pCur); + if (pCursor->pCur) (void)tdbTbcClose(pCursor->pCur); taosMemoryFree(buf); taosMemoryFree(pKey); @@ -1182,7 +1182,7 @@ int32_t metaFilterTtl(void *pVnode, SMetaFltParam *arg, SArray *pUids) { END: if (pCursor->pMeta) metaULock(pCursor->pMeta); - if (pCursor->pCur) tdbTbcClose(pCursor->pCur); + if (pCursor->pCur) (void)tdbTbcClose(pCursor->pCur); taosMemoryFree(buf); taosMemoryFree(pKey); @@ -1353,7 +1353,7 @@ int32_t metaFilterTableIds(void *pVnode, SMetaFltParam *arg, SArray *pUids) { END: if (pCursor->pMeta) metaULock(pCursor->pMeta); - if (pCursor->pCur) tdbTbcClose(pCursor->pCur); + if (pCursor->pCur) (void)tdbTbcClose(pCursor->pCur); if (oStbEntry.pBuf) taosMemoryFree(oStbEntry.pBuf); tDecoderClear(&dc); tdbFree(pData); diff --git a/source/dnode/vnode/src/meta/metaSnapshot.c b/source/dnode/vnode/src/meta/metaSnapshot.c index b8043c00de..3f99bcb5b2 100644 --- a/source/dnode/vnode/src/meta/metaSnapshot.c +++ b/source/dnode/vnode/src/meta/metaSnapshot.c @@ -59,7 +59,7 @@ _exit: void metaSnapReaderClose(SMetaSnapReader** ppReader) { if (ppReader && *ppReader) { - tdbTbcClose((*ppReader)->pTbc); + (void)tdbTbcClose((*ppReader)->pTbc); taosMemoryFree(*ppReader); *ppReader = NULL; } @@ -87,7 +87,7 @@ int32_t metaSnapRead(SMetaSnapReader* pReader, uint8_t** ppData) { if (key.version < pReader->sver // || metaGetInfo(pReader->pMeta, key.uid, &info, NULL) == TSDB_CODE_NOT_FOUND) { - tdbTbcMoveToNext(pReader->pTbc); + (void)tdbTbcMoveToNext(pReader->pTbc); continue; } @@ -110,7 +110,7 @@ int32_t metaSnapRead(SMetaSnapReader* pReader, uint8_t** ppData) { metaDebug("vgId:%d, vnode snapshot meta read data, version:%" PRId64 " uid:%" PRId64 " blockLen:%d", TD_VID(pReader->pMeta->pVnode), key.version, key.uid, nData); - tdbTbcMoveToNext(pReader->pTbc); + (void)tdbTbcMoveToNext(pReader->pTbc); break; } @@ -223,17 +223,17 @@ static int32_t MoveToSnapShotVersion(SSnapContext* ctx) { int32_t code = 0; (void)tdbTbcClose((TBC*)ctx->pCur); code = tdbTbcOpen(ctx->pMeta->pTbDb, (TBC**)&ctx->pCur, NULL); - if (code != 0){ + if (code != 0) { return TAOS_GET_TERRNO(code); } STbDbKey key = {.version = ctx->snapVersion, .uid = INT64_MAX}; int c = 0; code = tdbTbcMoveTo((TBC*)ctx->pCur, &key, sizeof(key), &c); - if (code != 0){ + if (code != 0) { return TAOS_GET_TERRNO(code); } if (c < 0) { - tdbTbcMoveToPrev((TBC*)ctx->pCur); + (void)tdbTbcMoveToPrev((TBC*)ctx->pCur); } return 0; } @@ -241,13 +241,13 @@ static int32_t MoveToSnapShotVersion(SSnapContext* ctx) { static int32_t MoveToPosition(SSnapContext* ctx, int64_t ver, int64_t uid) { (void)tdbTbcClose((TBC*)ctx->pCur); int32_t code = tdbTbcOpen(ctx->pMeta->pTbDb, (TBC**)&ctx->pCur, NULL); - if (code != 0){ + if (code != 0) { return TAOS_GET_TERRNO(code); } STbDbKey key = {.version = ver, .uid = uid}; int c = 0; code = tdbTbcMoveTo((TBC*)ctx->pCur, &key, sizeof(key), &c); - if (code != 0){ + if (code != 0) { return TAOS_GET_TERRNO(code); } return c; @@ -256,11 +256,11 @@ static int32_t MoveToPosition(SSnapContext* ctx, int64_t ver, int64_t uid) { static int32_t MoveToFirst(SSnapContext* ctx) { (void)tdbTbcClose((TBC*)ctx->pCur); int32_t code = tdbTbcOpen(ctx->pMeta->pTbDb, (TBC**)&ctx->pCur, NULL); - if (code != 0){ + if (code != 0) { return TAOS_GET_TERRNO(code); } code = tdbTbcMoveToFirst((TBC*)ctx->pCur); - if (code != 0){ + if (code != 0) { return TAOS_GET_TERRNO(code); } return 0; @@ -271,38 +271,39 @@ static int32_t saveSuperTableInfoForChildTable(SMetaEntry* me, SHashObj* suidInf if (data) { return 0; } - int32_t code = 0; + int32_t code = 0; STableInfoForChildTable dataTmp = {0}; dataTmp.tableName = taosStrdup(me->name); - if (dataTmp.tableName == NULL){ + if (dataTmp.tableName == NULL) { code = TSDB_CODE_OUT_OF_MEMORY; goto END; } dataTmp.schemaRow = tCloneSSchemaWrapper(&me->stbEntry.schemaRow); - if (dataTmp.schemaRow == NULL){ + if (dataTmp.schemaRow == NULL) { code = TSDB_CODE_OUT_OF_MEMORY; goto END; } dataTmp.tagRow = tCloneSSchemaWrapper(&me->stbEntry.schemaTag); - if (dataTmp.tagRow == NULL){ + if (dataTmp.tagRow == NULL) { code = TSDB_CODE_OUT_OF_MEMORY; goto END; } code = taosHashPut(suidInfo, &me->uid, sizeof(tb_uid_t), &dataTmp, sizeof(STableInfoForChildTable)); - if (code != 0){ + if (code != 0) { goto END; } return 0; END: destroySTableInfoForChildTable(&dataTmp); - return TAOS_GET_TERRNO(code);; + return TAOS_GET_TERRNO(code); + ; } int32_t buildSnapContext(SVnode* pVnode, int64_t snapVersion, int64_t suid, int8_t subType, int8_t withMeta, SSnapContext** ctxRet) { SSnapContext* ctx = taosMemoryCalloc(1, sizeof(SSnapContext)); - if (ctx == NULL){ + if (ctx == NULL) { return TAOS_GET_TERRNO(TSDB_CODE_OUT_OF_MEMORY); } *ctxRet = ctx; @@ -319,14 +320,16 @@ int32_t buildSnapContext(SVnode* pVnode, int64_t snapVersion, int64_t suid, int8 ctx->suidInfo = taosHashInit(100, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, HASH_NO_LOCK); if (ctx->suidInfo == NULL) { - return TAOS_GET_TERRNO(TSDB_CODE_OUT_OF_MEMORY);; + return TAOS_GET_TERRNO(TSDB_CODE_OUT_OF_MEMORY); + ; } taosHashSetFreeFp(ctx->suidInfo, destroySTableInfoForChildTable); ctx->index = 0; ctx->idList = taosArrayInit(100, sizeof(int64_t)); - if (ctx->idList == NULL){ - return TAOS_GET_TERRNO(TSDB_CODE_OUT_OF_MEMORY);; + if (ctx->idList == NULL) { + return TAOS_GET_TERRNO(TSDB_CODE_OUT_OF_MEMORY); + ; } void* pKey = NULL; void* pVal = NULL; @@ -334,7 +337,7 @@ int32_t buildSnapContext(SVnode* pVnode, int64_t snapVersion, int64_t suid, int8 metaDebug("tmqsnap init snapVersion:%" PRIi64, ctx->snapVersion); int32_t code = MoveToFirst(ctx); - if (code != 0){ + if (code != 0) { return code; } while (1) { @@ -348,7 +351,8 @@ int32_t buildSnapContext(SVnode* pVnode, int64_t snapVersion, int64_t suid, int8 continue; } - if (tdbTbGet(ctx->pMeta->pUidIdx, &tmp->uid, sizeof(tb_uid_t), NULL, NULL) < 0) { // check if table exist for now, need optimize later + if (tdbTbGet(ctx->pMeta->pUidIdx, &tmp->uid, sizeof(tb_uid_t), NULL, NULL) < + 0) { // check if table exist for now, need optimize later continue; } @@ -356,7 +360,7 @@ int32_t buildSnapContext(SVnode* pVnode, int64_t snapVersion, int64_t suid, int8 SMetaEntry me = {0}; tDecoderInit(&dc, pVal, vLen); ret = metaDecodeEntry(&dc, &me); - if (ret < 0){ + if (ret < 0) { tDecoderClear(&dc); return TAOS_GET_TERRNO(ret); } @@ -368,7 +372,7 @@ int32_t buildSnapContext(SVnode* pVnode, int64_t snapVersion, int64_t suid, int8 } } - if (taosArrayPush(ctx->idList, &tmp->uid) == NULL){ + if (taosArrayPush(ctx->idList, &tmp->uid) == NULL) { tDecoderClear(&dc); return TAOS_GET_TERRNO(TSDB_CODE_OUT_OF_MEMORY); } @@ -383,7 +387,7 @@ int32_t buildSnapContext(SVnode* pVnode, int64_t snapVersion, int64_t suid, int8 taosHashClear(ctx->idVersion); code = MoveToSnapShotVersion(ctx); - if (code != 0){ + if (code != 0) { return code; } while (1) { @@ -405,7 +409,7 @@ int32_t buildSnapContext(SVnode* pVnode, int64_t snapVersion, int64_t suid, int8 SMetaEntry me = {0}; tDecoderInit(&dc, pVal, vLen); ret = metaDecodeEntry(&dc, &me); - if (ret < 0){ + if (ret < 0) { tDecoderClear(&dc); return TAOS_GET_TERRNO(ret); } @@ -421,7 +425,7 @@ int32_t buildSnapContext(SVnode* pVnode, int64_t snapVersion, int64_t suid, int8 if ((ctx->subType == TOPIC_SUB_TYPE__DB && me.type == TSDB_SUPER_TABLE) || (ctx->subType == TOPIC_SUB_TYPE__TABLE && me.uid == ctx->suid)) { ret = saveSuperTableInfoForChildTable(&me, ctx->suidInfo); - if (ret != 0){ + if (ret != 0) { tDecoderClear(&dc); return ret; } @@ -431,7 +435,7 @@ int32_t buildSnapContext(SVnode* pVnode, int64_t snapVersion, int64_t suid, int8 for (int i = 0; i < taosArrayGetSize(ctx->idList); i++) { int64_t* uid = taosArrayGet(ctx->idList, i); - if (uid == NULL){ + if (uid == NULL) { return TAOS_GET_TERRNO(TSDB_CODE_OUT_OF_MEMORY); } SIdInfo* idData = (SIdInfo*)taosHashGet(ctx->idVersion, uid, sizeof(int64_t)); @@ -467,7 +471,7 @@ static int32_t buildNormalChildTableInfo(SVCreateTbReq* req, void** pBuf, int32_ ret = TAOS_GET_TERRNO(TSDB_CODE_OUT_OF_MEMORY); goto end; } - if (taosArrayPush(reqs.pArray, req) == NULL){ + if (taosArrayPush(reqs.pArray, req) == NULL) { ret = TAOS_GET_TERRNO(TSDB_CODE_OUT_OF_MEMORY); goto end; } @@ -540,10 +544,10 @@ int32_t setForSnapShot(SSnapContext* ctx, int64_t uid) { return 0; } -void taosXSetTablePrimaryKey(SSnapContext* ctx, int64_t uid){ - bool ret = false; - SSchemaWrapper *schema = metaGetTableSchema(ctx->pMeta, uid, -1, 1); - if (schema && schema->nCols >= 2 && schema->pSchema[1].flags & COL_IS_KEY){ +void taosXSetTablePrimaryKey(SSnapContext* ctx, int64_t uid) { + bool ret = false; + SSchemaWrapper* schema = metaGetTableSchema(ctx->pMeta, uid, -1, 1); + if (schema && schema->nCols >= 2 && schema->pSchema[1].flags & COL_IS_KEY) { ret = true; } tDeleteSchemaWrapper(schema); @@ -639,7 +643,7 @@ int32_t getTableInfoFromSnapshot(SSnapContext* ctx, void** pBuf, int32_t* contLe ret = TAOS_GET_TERRNO(TSDB_CODE_OUT_OF_MEMORY); goto END; } - STag* p = (STag*)me.ctbEntry.pTags; + STag* p = (STag*)me.ctbEntry.pTags; if (tTagIsJson(p)) { if (p->nTag != 0) { SSchema* schema = &data->tagRow->pSchema[0]; @@ -651,7 +655,7 @@ int32_t getTableInfoFromSnapshot(SSnapContext* ctx, void** pBuf, int32_t* contLe } } else { SArray* pTagVals = NULL; - ret = tTagToValArray((const STag*)p, &pTagVals); + ret = tTagToValArray((const STag*)p, &pTagVals); if (ret != 0) { metaError("meta/snap: tag to val array failed."); taosArrayDestroy(pTagVals); @@ -701,9 +705,9 @@ END: } int32_t getMetaTableInfoFromSnapshot(SSnapContext* ctx, SMetaTableInfo* result) { - void* pKey = NULL; - void* pVal = NULL; - int vLen, kLen; + void* pKey = NULL; + void* pVal = NULL; + int vLen, kLen; while (1) { if (ctx->index >= taosArrayGetSize(ctx->idList)) { @@ -711,7 +715,7 @@ int32_t getMetaTableInfoFromSnapshot(SSnapContext* ctx, SMetaTableInfo* result) return 0; } int64_t* uidTmp = taosArrayGet(ctx->idList, ctx->index); - if (uidTmp == NULL){ + if (uidTmp == NULL) { return TAOS_GET_TERRNO(TSDB_CODE_OUT_OF_MEMORY); } ctx->index++; @@ -728,21 +732,21 @@ int32_t getMetaTableInfoFromSnapshot(SSnapContext* ctx, SMetaTableInfo* result) continue; } ret = tdbTbcGet((TBC*)ctx->pCur, (const void**)&pKey, &kLen, (const void**)&pVal, &vLen); - if (ret != 0){ + if (ret != 0) { return TAOS_GET_TERRNO(ret); } SDecoder dc = {0}; SMetaEntry me = {0}; tDecoderInit(&dc, pVal, vLen); ret = metaDecodeEntry(&dc, &me); - if (ret != 0){ + if (ret != 0) { tDecoderClear(&dc); return TAOS_GET_TERRNO(ret); } metaDebug("tmqsnap get uid info uid:%" PRIi64 " name:%s index:%d", me.uid, me.name, ctx->index - 1); if ((ctx->subType == TOPIC_SUB_TYPE__DB && me.type == TSDB_CHILD_TABLE) || - (ctx->subType == TOPIC_SUB_TYPE__TABLE && me.type == TSDB_CHILD_TABLE && me.ctbEntry.suid == ctx->suid)){ + (ctx->subType == TOPIC_SUB_TYPE__TABLE && me.type == TSDB_CHILD_TABLE && me.ctbEntry.suid == ctx->suid)) { STableInfoForChildTable* data = (STableInfoForChildTable*)taosHashGet(ctx->suidInfo, &me.ctbEntry.suid, sizeof(tb_uid_t)); if (data == NULL) { @@ -763,7 +767,7 @@ int32_t getMetaTableInfoFromSnapshot(SSnapContext* ctx, SMetaTableInfo* result) result->uid = me.uid; tstrncpy(result->tbName, me.name, TSDB_TABLE_NAME_LEN); tDecoderClear(&dc); - if(result->schema == NULL){ + if (result->schema == NULL) { return TAOS_GET_TERRNO(TSDB_CODE_OUT_OF_MEMORY); } break; diff --git a/source/dnode/vnode/src/meta/metaTable.c b/source/dnode/vnode/src/meta/metaTable.c index 04447fd3ce..d6bba3486a 100644 --- a/source/dnode/vnode/src/meta/metaTable.c +++ b/source/dnode/vnode/src/meta/metaTable.c @@ -161,10 +161,10 @@ static int metaSaveJsonVarToIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry, const term = indexTermCreate(suid, ADD_VALUE, TSDB_DATA_TYPE_BOOL, key, nKey, (const char *)&val, len); } if (term != NULL) { - indexMultiTermAdd(terms, term); + (void)indexMultiTermAdd(terms, term); } } - indexJsonPut(pMeta->pTagIvtIdx, terms, tuid); + (void)indexJsonPut(pMeta->pTagIvtIdx, terms, tuid); indexMultiTermDestroy(terms); taosArrayDestroy(pTagVals); @@ -223,7 +223,7 @@ int metaDelJsonVarFromIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry, const SSche term = indexTermCreate(suid, DEL_VALUE, TSDB_DATA_TYPE_BOOL, key, nKey, (const char *)&val, len); } if (term != NULL) { - indexMultiTermAdd(terms, term); + (void)indexMultiTermAdd(terms, term); } } indexJsonPut(pMeta->pTagIvtIdx, terms, tuid); @@ -239,7 +239,7 @@ static inline void metaTimeSeriesNotifyCheck(SMeta *pMeta) { int64_t deltaTS = nTimeSeries - pMeta->pVnode->config.vndStats.numOfReportedTimeSeries; if (deltaTS > tsTimeSeriesThreshold) { if (0 == atomic_val_compare_exchange_8(&dmNotifyHdl.state, 1, 2)) { - tsem_post(&dmNotifyHdl.sem); + (void)tsem_post(&dmNotifyHdl.sem); } } #endif @@ -323,10 +323,10 @@ int metaDropSTable(SMeta *pMeta, int64_t verison, SVDropStbReq *pReq, SArray *tb // drop all child tables TBC *pCtbIdxc = NULL; - tdbTbcOpen(pMeta->pCtbIdx, &pCtbIdxc, NULL); + (void)(void)tdbTbcOpen(pMeta->pCtbIdx, &pCtbIdxc, NULL); rc = tdbTbcMoveTo(pCtbIdxc, &(SCtbIdxKey){.suid = pReq->suid, .uid = INT64_MIN}, sizeof(SCtbIdxKey), &c); if (rc < 0) { - tdbTbcClose(pCtbIdxc); + (void)tdbTbcClose(pCtbIdxc); metaWLock(pMeta); goto _drop_super_table; } @@ -344,7 +344,7 @@ int metaDropSTable(SMeta *pMeta, int64_t verison, SVDropStbReq *pReq, SArray *tb (void)taosArrayPush(tbUidList, &(((SCtbIdxKey *)pKey)->uid)); } - tdbTbcClose(pCtbIdxc); + (void)tdbTbcClose(pCtbIdxc); (void)tsdbCacheDropSubTables(pMeta->pVnode->pTsdb, tbUidList, pReq->suid); @@ -352,19 +352,19 @@ int metaDropSTable(SMeta *pMeta, int64_t verison, SVDropStbReq *pReq, SArray *tb for (int32_t iChild = 0; iChild < taosArrayGetSize(tbUidList); iChild++) { tb_uid_t uid = *(tb_uid_t *)taosArrayGet(tbUidList, iChild); - metaDropTableByUid(pMeta, uid, NULL, NULL, NULL); + (void)metaDropTableByUid(pMeta, uid, NULL, NULL, NULL); } // drop super table _drop_super_table: tdbTbGet(pMeta->pUidIdx, &pReq->suid, sizeof(tb_uid_t), &pData, &nData); - tdbTbDelete(pMeta->pTbDb, &(STbDbKey){.version = ((SUidIdxVal *)pData)[0].version, .uid = pReq->suid}, - sizeof(STbDbKey), pMeta->txn); - tdbTbDelete(pMeta->pNameIdx, pReq->name, strlen(pReq->name) + 1, pMeta->txn); - tdbTbDelete(pMeta->pUidIdx, &pReq->suid, sizeof(tb_uid_t), pMeta->txn); - tdbTbDelete(pMeta->pSuidIdx, &pReq->suid, sizeof(tb_uid_t), pMeta->txn); + (void)tdbTbDelete(pMeta->pTbDb, &(STbDbKey){.version = ((SUidIdxVal *)pData)[0].version, .uid = pReq->suid}, + sizeof(STbDbKey), pMeta->txn); + (void)tdbTbDelete(pMeta->pNameIdx, pReq->name, strlen(pReq->name) + 1, pMeta->txn); + (void)tdbTbDelete(pMeta->pUidIdx, &pReq->suid, sizeof(tb_uid_t), pMeta->txn); + (void)tdbTbDelete(pMeta->pSuidIdx, &pReq->suid, sizeof(tb_uid_t), pMeta->txn); - metaStatsCacheDrop(pMeta, pReq->suid); + (void)metaStatsCacheDrop(pMeta, pReq->suid); metaULock(pMeta); @@ -387,10 +387,10 @@ static void metaGetSubtables(SMeta *pMeta, int64_t suid, SArray *uids) { int nKey = 0; TBC *pCtbIdxc = NULL; - tdbTbcOpen(pMeta->pCtbIdx, &pCtbIdxc, NULL); + (void)tdbTbcOpen(pMeta->pCtbIdx, &pCtbIdxc, NULL); int rc = tdbTbcMoveTo(pCtbIdxc, &(SCtbIdxKey){.suid = suid, .uid = INT64_MIN}, sizeof(SCtbIdxKey), &c); if (rc < 0) { - tdbTbcClose(pCtbIdxc); + (void)tdbTbcClose(pCtbIdxc); metaWLock(pMeta); return; } @@ -410,7 +410,7 @@ static void metaGetSubtables(SMeta *pMeta, int64_t suid, SArray *uids) { tdbFree(pKey); - tdbTbcClose(pCtbIdxc); + (void)tdbTbcClose(pCtbIdxc); } int metaAlterSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) { @@ -425,28 +425,28 @@ int metaAlterSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) { int32_t ret; int32_t c = -2; - tdbTbcOpen(pMeta->pUidIdx, &pUidIdxc, NULL); + (void)tdbTbcOpen(pMeta->pUidIdx, &pUidIdxc, NULL); ret = tdbTbcMoveTo(pUidIdxc, &pReq->suid, sizeof(tb_uid_t), &c); if (ret < 0 || c) { - tdbTbcClose(pUidIdxc); + (void)tdbTbcClose(pUidIdxc); return terrno = TSDB_CODE_TDB_STB_NOT_EXIST; } ret = tdbTbcGet(pUidIdxc, NULL, NULL, &pData, &nData); if (ret < 0) { - tdbTbcClose(pUidIdxc); + (void)tdbTbcClose(pUidIdxc); return terrno = TSDB_CODE_TDB_STB_NOT_EXIST; } oversion = ((SUidIdxVal *)pData)[0].version; - tdbTbcOpen(pMeta->pTbDb, &pTbDbc, NULL); + (void)tdbTbcOpen(pMeta->pTbDb, &pTbDbc, NULL); ret = tdbTbcMoveTo(pTbDbc, &((STbDbKey){.uid = pReq->suid, .version = oversion}), sizeof(STbDbKey), &c); if (!(ret == 0 && c == 0)) { - tdbTbcClose(pUidIdxc); - tdbTbcClose(pTbDbc); + (void)tdbTbcClose(pUidIdxc); + (void)tdbTbcClose(pTbDbc); metaError("meta/table: invalide ret: %" PRId32 " or c: %" PRId32 "alter stb failed.", ret, c); return terrno = TSDB_CODE_TDB_STB_NOT_EXIST; @@ -454,8 +454,8 @@ int metaAlterSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) { ret = tdbTbcGet(pTbDbc, NULL, NULL, &pData, &nData); if (ret < 0) { - tdbTbcClose(pUidIdxc); - tdbTbcClose(pTbDbc); + (void)tdbTbcClose(pUidIdxc); + (void)tdbTbcClose(pTbDbc); return terrno = TSDB_CODE_TDB_STB_NOT_EXIST; } @@ -512,19 +512,19 @@ int metaAlterSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) { metaWLock(pMeta); // compare two entry if (oStbEntry.stbEntry.schemaRow.version != pReq->schemaRow.version) { - metaSaveToSkmDb(pMeta, &nStbEntry); + (void)metaSaveToSkmDb(pMeta, &nStbEntry); } // update table.db - metaSaveToTbDb(pMeta, &nStbEntry); + (void)metaSaveToTbDb(pMeta, &nStbEntry); // update uid index - metaUpdateUidIdx(pMeta, &nStbEntry); + (void)metaUpdateUidIdx(pMeta, &nStbEntry); // metaStatsCacheDrop(pMeta, nStbEntry.uid); if (updStat) { - metaUpdateStbStats(pMeta, pReq->suid, 0, deltaCol); + (void)metaUpdateStbStats(pMeta, pReq->suid, 0, deltaCol); } metaULock(pMeta); @@ -540,8 +540,8 @@ int metaAlterSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) { _exit: if (oStbEntry.pBuf) taosMemoryFree(oStbEntry.pBuf); tDecoderClear(&dc); - tdbTbcClose(pTbDbc); - tdbTbcClose(pUidIdxc); + (void)tdbTbcClose(pTbDbc); + (void)tdbTbcClose(pUidIdxc); return 0; } int metaAddIndexToSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) { @@ -619,10 +619,10 @@ int metaAddIndexToSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) { * iterator all pTdDbc by uid and version */ TBC *pCtbIdxc = NULL; - tdbTbcOpen(pMeta->pCtbIdx, &pCtbIdxc, NULL); + (void)tdbTbcOpen(pMeta->pCtbIdx, &pCtbIdxc, NULL); int rc = tdbTbcMoveTo(pCtbIdxc, &(SCtbIdxKey){.suid = suid, .uid = INT64_MIN}, sizeof(SCtbIdxKey), &c); if (rc < 0) { - tdbTbcClose(pCtbIdxc); + (void)tdbTbcClose(pCtbIdxc); goto _err; } for (;;) { @@ -632,7 +632,7 @@ int metaAddIndexToSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) { if (rc < 0) { tdbFree(pKey); tdbFree(pVal); - tdbTbcClose(pCtbIdxc); + (void)tdbTbcClose(pCtbIdxc); pCtbIdxc = NULL; break; } @@ -667,7 +667,7 @@ int metaAddIndexToSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) { tdbFree(pVal); if (rc < 0) { metaDestroyTagIdxKey(pTagIdxKey); - tdbTbcClose(pCtbIdxc); + (void)tdbTbcClose(pCtbIdxc); goto _err; } @@ -688,16 +688,16 @@ int metaAddIndexToSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) { metaWLock(pMeta); // update table.db - metaSaveToTbDb(pMeta, &nStbEntry); + (void)metaSaveToTbDb(pMeta, &nStbEntry); // update uid index - metaUpdateUidIdx(pMeta, &nStbEntry); + (void)metaUpdateUidIdx(pMeta, &nStbEntry); metaULock(pMeta); if (oStbEntry.pBuf) taosMemoryFree(oStbEntry.pBuf); tDecoderClear(&dc); tdbFree(pData); - tdbTbcClose(pCtbIdxc); + (void)tdbTbcClose(pCtbIdxc); return TSDB_CODE_SUCCESS; _err: if (oStbEntry.pBuf) taosMemoryFree(oStbEntry.pBuf); @@ -756,10 +756,10 @@ int metaDropIndexFromSTable(SMeta *pMeta, int64_t version, SDropIndexReq *pReq) * iterator all pTdDbc by uid and version */ TBC *pCtbIdxc = NULL; - tdbTbcOpen(pMeta->pCtbIdx, &pCtbIdxc, NULL); + (void)tdbTbcOpen(pMeta->pCtbIdx, &pCtbIdxc, NULL); int rc = tdbTbcMoveTo(pCtbIdxc, &(SCtbIdxKey){.suid = suid, .uid = INT64_MIN}, sizeof(SCtbIdxKey), &c); if (rc < 0) { - tdbTbcClose(pCtbIdxc); + (void)tdbTbcClose(pCtbIdxc); goto _err; } for (;;) { @@ -769,7 +769,7 @@ int metaDropIndexFromSTable(SMeta *pMeta, int64_t version, SDropIndexReq *pReq) if (rc < 0) { tdbFree(pKey); tdbFree(pVal); - tdbTbcClose(pCtbIdxc); + (void)tdbTbcClose(pCtbIdxc); pCtbIdxc = NULL; break; } @@ -804,12 +804,12 @@ int metaDropIndexFromSTable(SMeta *pMeta, int64_t version, SDropIndexReq *pReq) tdbFree(pVal); if (rc < 0) { metaDestroyTagIdxKey(pTagIdxKey); - tdbTbcClose(pCtbIdxc); + (void)tdbTbcClose(pCtbIdxc); goto _err; } metaWLock(pMeta); - tdbTbDelete(pMeta->pTagIdx, pTagIdxKey, nTagIdxKey, pMeta->txn); + (void)tdbTbDelete(pMeta->pTagIdx, pTagIdxKey, nTagIdxKey, pMeta->txn); metaULock(pMeta); metaDestroyTagIdxKey(pTagIdxKey); pTagIdxKey = NULL; @@ -836,9 +836,9 @@ int metaDropIndexFromSTable(SMeta *pMeta, int64_t version, SDropIndexReq *pReq) metaWLock(pMeta); // update table.db - metaSaveToTbDb(pMeta, &nStbEntry); + (void)metaSaveToTbDb(pMeta, &nStbEntry); // update uid index - metaUpdateUidIdx(pMeta, &nStbEntry); + (void)metaUpdateUidIdx(pMeta, &nStbEntry); metaULock(pMeta); tDeleteSchemaWrapper(tag); @@ -849,7 +849,7 @@ int metaDropIndexFromSTable(SMeta *pMeta, int64_t version, SDropIndexReq *pReq) tDecoderClear(&dc); tdbFree(pData); - tdbTbcClose(pCtbIdxc); + (void)tdbTbcClose(pCtbIdxc); return TSDB_CODE_SUCCESS; _err: if (oStbEntry.pBuf) taosMemoryFree(oStbEntry.pBuf); @@ -942,9 +942,9 @@ int metaCreateTable(SMeta *pMeta, int64_t ver, SVCreateTbReq *pReq, STableMetaRs } metaWLock(pMeta); - metaUpdateStbStats(pMeta, me.ctbEntry.suid, 1, 0); - metaUidCacheClear(pMeta, me.ctbEntry.suid); - metaTbGroupCacheClear(pMeta, me.ctbEntry.suid); + (void)metaUpdateStbStats(pMeta, me.ctbEntry.suid, 1, 0); + (void)metaUidCacheClear(pMeta, me.ctbEntry.suid); + (void)metaTbGroupCacheClear(pMeta, me.ctbEntry.suid); metaULock(pMeta); if (!TSDB_CACHE_NO(pMeta->pVnode->config)) { @@ -982,7 +982,7 @@ int metaCreateTable(SMeta *pMeta, int64_t ver, SVCreateTbReq *pReq, STableMetaRs (*pMetaRsp)->suid = pReq->ctb.suid; strcpy((*pMetaRsp)->tbName, pReq->name); } else { - metaUpdateMetaRsp(pReq->uid, pReq->name, &pReq->ntb.schemaRow, *pMetaRsp); + (void)metaUpdateMetaRsp(pReq->uid, pReq->name, &pReq->ntb.schemaRow, *pMetaRsp); for (int32_t i = 0; i < pReq->colCmpr.nCols; i++) { SColCmpr *p = &pReq->colCmpr.pColCmpr[i]; (*pMetaRsp)->pSchemaExt[i].colId = p->id; @@ -1062,7 +1062,7 @@ void metaDropTables(SMeta *pMeta, SArray *tbUids) { tb_uid_t suid = 0; int8_t sysTbl = 0; int type; - metaDropTableByUid(pMeta, uid, &type, &suid, &sysTbl); + (void)metaDropTableByUid(pMeta, uid, &type, &suid, &sysTbl); if (!sysTbl && type == TSDB_CHILD_TABLE && suid != 0 && suidHash) { int64_t *pVal = tSimpleHashGet(suidHash, &suid, sizeof(tb_uid_t)); if (pVal) { @@ -1111,7 +1111,7 @@ static int32_t metaFilterTableByHash(SMeta *pMeta, SArray *uidList) { code = tdbTbcMoveToFirst(pCur); if (code) { - tdbTbcClose(pCur); + (void)tdbTbcClose(pCur); return code; } @@ -1142,7 +1142,7 @@ static int32_t metaFilterTableByHash(SMeta *pMeta, SArray *uidList) { } tdbFree(pData); tdbFree(pKey); - tdbTbcClose(pCur); + (void)tdbTbcClose(pCur); return 0; } @@ -1296,7 +1296,7 @@ static int metaDropTableByUid(SMeta *pMeta, tb_uid_t uid, int *type, tb_uid_t *p if (metaCreateTagIdxKey(e.ctbEntry.suid, pTagColumn->colId, pTagData, nTagData, pTagColumn->type, uid, &pTagIdxKey, &nTagIdxKey) == 0) { - tdbTbDelete(pMeta->pTagIdx, pTagIdxKey, nTagIdxKey, pMeta->txn); + (void)tdbTbDelete(pMeta->pTagIdx, pTagIdxKey, nTagIdxKey, pMeta->txn); } metaDestroyTagIdxKey(pTagIdxKey); pTagIdxKey = NULL; @@ -1308,9 +1308,9 @@ static int metaDropTableByUid(SMeta *pMeta, tb_uid_t uid, int *type, tb_uid_t *p } } - tdbTbDelete(pMeta->pTbDb, &(STbDbKey){.version = version, .uid = uid}, sizeof(STbDbKey), pMeta->txn); - tdbTbDelete(pMeta->pNameIdx, e.name, strlen(e.name) + 1, pMeta->txn); - tdbTbDelete(pMeta->pUidIdx, &uid, sizeof(uid), pMeta->txn); + (void)tdbTbDelete(pMeta->pTbDb, &(STbDbKey){.version = version, .uid = uid}, sizeof(STbDbKey), pMeta->txn); + (void)tdbTbDelete(pMeta->pNameIdx, e.name, strlen(e.name) + 1, pMeta->txn); + (void)tdbTbDelete(pMeta->pUidIdx, &uid, sizeof(uid), pMeta->txn); if (e.type == TSDB_CHILD_TABLE || e.type == TSDB_NORMAL_TABLE) metaDeleteBtimeIdx(pMeta, &e); if (e.type == TSDB_NORMAL_TABLE) metaDeleteNcolIdx(pMeta, &e); @@ -1318,12 +1318,13 @@ static int metaDropTableByUid(SMeta *pMeta, tb_uid_t uid, int *type, tb_uid_t *p if (e.type != TSDB_SUPER_TABLE) metaDeleteTtl(pMeta, &e); if (e.type == TSDB_CHILD_TABLE) { - tdbTbDelete(pMeta->pCtbIdx, &(SCtbIdxKey){.suid = e.ctbEntry.suid, .uid = uid}, sizeof(SCtbIdxKey), pMeta->txn); + (void)tdbTbDelete(pMeta->pCtbIdx, &(SCtbIdxKey){.suid = e.ctbEntry.suid, .uid = uid}, sizeof(SCtbIdxKey), + pMeta->txn); --pMeta->pVnode->config.vndStats.numOfCTables; - metaUpdateStbStats(pMeta, e.ctbEntry.suid, -1, 0); - metaUidCacheClear(pMeta, e.ctbEntry.suid); - metaTbGroupCacheClear(pMeta, e.ctbEntry.suid); + (void)metaUpdateStbStats(pMeta, e.ctbEntry.suid, -1, 0); + (void)metaUidCacheClear(pMeta, e.ctbEntry.suid); + (void)metaTbGroupCacheClear(pMeta, e.ctbEntry.suid); /* if (!TSDB_CACHE_NO(pMeta->pVnode->config)) { tsdbCacheDropTable(pMeta->pVnode->pTsdb, e.uid, e.ctbEntry.suid, NULL); @@ -1341,10 +1342,10 @@ static int metaDropTableByUid(SMeta *pMeta, tb_uid_t uid, int *type, tb_uid_t *p } */ } else if (e.type == TSDB_SUPER_TABLE) { - tdbTbDelete(pMeta->pSuidIdx, &e.uid, sizeof(tb_uid_t), pMeta->txn); + (void)tdbTbDelete(pMeta->pSuidIdx, &e.uid, sizeof(tb_uid_t), pMeta->txn); // drop schema.db (todo) - metaStatsCacheDrop(pMeta, uid); + (void)metaStatsCacheDrop(pMeta, uid); metaUidCacheClear(pMeta, uid); metaTbGroupCacheClear(pMeta, uid); --pMeta->pVnode->config.vndStats.numOfSTables; @@ -1423,10 +1424,10 @@ static int metaAlterTableColumn(SMeta *pMeta, int64_t version, SVAlterTbReq *pAl // search uid index TBC *pUidIdxc = NULL; - tdbTbcOpen(pMeta->pUidIdx, &pUidIdxc, NULL); + (void)tdbTbcOpen(pMeta->pUidIdx, &pUidIdxc, NULL); tdbTbcMoveTo(pUidIdxc, &uid, sizeof(uid), &c); if (c != 0) { - tdbTbcClose(pUidIdxc); + (void)tdbTbcClose(pUidIdxc); metaError("meta/table: invalide c: %" PRId32 " alt tb column failed.", c); return TSDB_CODE_FAILED; } @@ -1437,11 +1438,11 @@ static int metaAlterTableColumn(SMeta *pMeta, int64_t version, SVAlterTbReq *pAl // search table.db TBC *pTbDbc = NULL; - tdbTbcOpen(pMeta->pTbDb, &pTbDbc, NULL); + (void)tdbTbcOpen(pMeta->pTbDb, &pTbDbc, NULL); tdbTbcMoveTo(pTbDbc, &((STbDbKey){.uid = uid, .version = oversion}), sizeof(STbDbKey), &c); if (c != 0) { - tdbTbcClose(pUidIdxc); - tdbTbcClose(pTbDbc); + (void)tdbTbcClose(pUidIdxc); + (void)tdbTbcClose(pTbDbc); metaError("meta/table: invalide c: %" PRId32 " alt tb column failed.", c); return TSDB_CODE_FAILED; } @@ -1455,8 +1456,8 @@ static int metaAlterTableColumn(SMeta *pMeta, int64_t version, SVAlterTbReq *pAl tDecoderInit(&dc, entry.pBuf, nData); ret = metaDecodeEntry(&dc, &entry); if (ret != 0) { - tdbTbcClose(pUidIdxc); - tdbTbcClose(pTbDbc); + (void)tdbTbcClose(pUidIdxc); + (void)tdbTbcClose(pTbDbc); tDecoderClear(&dc); metaError("meta/table: invalide ret: %" PRId32 " alt tb column failed.", ret); return ret; @@ -1620,20 +1621,20 @@ static int metaAlterTableColumn(SMeta *pMeta, int64_t version, SVAlterTbReq *pAl // do actual write metaWLock(pMeta); - metaDeleteNcolIdx(pMeta, &oldEntry); - metaUpdateNcolIdx(pMeta, &entry); + (void)metaDeleteNcolIdx(pMeta, &oldEntry); + (void)metaUpdateNcolIdx(pMeta, &entry); // save to table db - metaSaveToTbDb(pMeta, &entry); + (void)metaSaveToTbDb(pMeta, &entry); - metaUpdateUidIdx(pMeta, &entry); + (void)metaUpdateUidIdx(pMeta, &entry); - metaSaveToSkmDb(pMeta, &entry); + (void)metaSaveToSkmDb(pMeta, &entry); - metaUpdateChangeTime(pMeta, entry.uid, pAlterTbReq->ctimeMs); + (void)metaUpdateChangeTime(pMeta, entry.uid, pAlterTbReq->ctimeMs); metaULock(pMeta); - metaUpdateMetaRsp(uid, pAlterTbReq->tbName, pSchema, pMetaRsp); + (void)metaUpdateMetaRsp(uid, pAlterTbReq->tbName, pSchema, pMetaRsp); for (int32_t i = 0; i < entry.colCmpr.nCols; i++) { SColCmpr *p = &entry.colCmpr.pColCmpr[i]; pMetaRsp->pSchemaExt[i].colId = p->id; @@ -1644,16 +1645,16 @@ static int metaAlterTableColumn(SMeta *pMeta, int64_t version, SVAlterTbReq *pAl if (pNewSchema) taosMemoryFree(pNewSchema); if (freeColCmpr) taosMemoryFree(entry.colCmpr.pColCmpr); - tdbTbcClose(pTbDbc); - tdbTbcClose(pUidIdxc); + (void)tdbTbcClose(pTbDbc); + (void)tdbTbcClose(pUidIdxc); tDecoderClear(&dc); return 0; _err: if (entry.pBuf) taosMemoryFree(entry.pBuf); - tdbTbcClose(pTbDbc); - tdbTbcClose(pUidIdxc); + (void)tdbTbcClose(pTbDbc); + (void)tdbTbcClose(pUidIdxc); tDecoderClear(&dc); return TSDB_CODE_FAILED; @@ -1688,10 +1689,10 @@ static int metaUpdateTableTagVal(SMeta *pMeta, int64_t version, SVAlterTbReq *pA // search uid index TBC *pUidIdxc = NULL; - tdbTbcOpen(pMeta->pUidIdx, &pUidIdxc, NULL); + (void)tdbTbcOpen(pMeta->pUidIdx, &pUidIdxc, NULL); tdbTbcMoveTo(pUidIdxc, &uid, sizeof(uid), &c); if (c != 0) { - tdbTbcClose(pUidIdxc); + (void)tdbTbcClose(pUidIdxc); metaError("meta/table: invalide c: %" PRId32 " update tb tag val failed.", c); return terrno = TSDB_CODE_TDB_TABLE_NOT_EXIST; } @@ -1705,11 +1706,11 @@ static int metaUpdateTableTagVal(SMeta *pMeta, int64_t version, SVAlterTbReq *pA SDecoder dc2 = {0}; /* get ctbEntry */ - tdbTbcOpen(pMeta->pTbDb, &pTbDbc, NULL); + (void)tdbTbcOpen(pMeta->pTbDb, &pTbDbc, NULL); tdbTbcMoveTo(pTbDbc, &((STbDbKey){.uid = uid, .version = oversion}), sizeof(STbDbKey), &c); if (c != 0) { - tdbTbcClose(pUidIdxc); - tdbTbcClose(pTbDbc); + (void)tdbTbcClose(pUidIdxc); + (void)tdbTbcClose(pTbDbc); metaError("meta/table: invalide c: %" PRId32 " update tb tag val failed.", c); return terrno = TSDB_CODE_TDB_TABLE_NOT_EXIST; } @@ -1802,12 +1803,12 @@ static int metaUpdateTableTagVal(SMeta *pMeta, int64_t version, SVAlterTbReq *pA metaWLock(pMeta); // save to table.db - metaSaveToTbDb(pMeta, &ctbEntry); + (void)metaSaveToTbDb(pMeta, &ctbEntry); // save to uid.idx - metaUpdateUidIdx(pMeta, &ctbEntry); + (void)metaUpdateUidIdx(pMeta, &ctbEntry); - metaUpdateTagIdx(pMeta, &ctbEntry); + (void)metaUpdateTagIdx(pMeta, &ctbEntry); if (NULL == ctbEntry.ctbEntry.pTags) { metaError("meta/table: null tags, update tag val failed."); @@ -1818,10 +1819,10 @@ static int metaUpdateTableTagVal(SMeta *pMeta, int64_t version, SVAlterTbReq *pA tdbTbUpsert(pMeta->pCtbIdx, &ctbIdxKey, sizeof(ctbIdxKey), ctbEntry.ctbEntry.pTags, ((STag *)(ctbEntry.ctbEntry.pTags))->len, pMeta->txn); - metaUidCacheClear(pMeta, ctbEntry.ctbEntry.suid); - metaTbGroupCacheClear(pMeta, ctbEntry.ctbEntry.suid); + (void)metaUidCacheClear(pMeta, ctbEntry.ctbEntry.suid); + (void)metaTbGroupCacheClear(pMeta, ctbEntry.ctbEntry.suid); - metaUpdateChangeTime(pMeta, ctbEntry.uid, pAlterTbReq->ctimeMs); + (void)metaUpdateChangeTime(pMeta, ctbEntry.uid, pAlterTbReq->ctimeMs); metaULock(pMeta); @@ -1830,8 +1831,8 @@ static int metaUpdateTableTagVal(SMeta *pMeta, int64_t version, SVAlterTbReq *pA taosMemoryFree((void *)ctbEntry.ctbEntry.pTags); if (ctbEntry.pBuf) taosMemoryFree(ctbEntry.pBuf); if (stbEntry.pBuf) tdbFree(stbEntry.pBuf); - tdbTbcClose(pTbDbc); - tdbTbcClose(pUidIdxc); + (void)tdbTbcClose(pTbDbc); + (void)tdbTbcClose(pUidIdxc); return 0; _err: @@ -1839,8 +1840,8 @@ _err: tDecoderClear(&dc2); if (ctbEntry.pBuf) taosMemoryFree(ctbEntry.pBuf); if (stbEntry.pBuf) tdbFree(stbEntry.pBuf); - tdbTbcClose(pTbDbc); - tdbTbcClose(pUidIdxc); + (void)tdbTbcClose(pTbDbc); + (void)tdbTbcClose(pUidIdxc); return -1; } @@ -1868,10 +1869,10 @@ static int metaUpdateTableOptions(SMeta *pMeta, int64_t version, SVAlterTbReq *p // search uid index TBC *pUidIdxc = NULL; - tdbTbcOpen(pMeta->pUidIdx, &pUidIdxc, NULL); + (void)tdbTbcOpen(pMeta->pUidIdx, &pUidIdxc, NULL); tdbTbcMoveTo(pUidIdxc, &uid, sizeof(uid), &c); if (c != 0) { - tdbTbcClose(pUidIdxc); + (void)tdbTbcClose(pUidIdxc); metaError("meta/table: invalide c: %" PRId32 " update tb options failed.", c); return TSDB_CODE_FAILED; } @@ -1882,11 +1883,11 @@ static int metaUpdateTableOptions(SMeta *pMeta, int64_t version, SVAlterTbReq *p // search table.db TBC *pTbDbc = NULL; - tdbTbcOpen(pMeta->pTbDb, &pTbDbc, NULL); + (void)tdbTbcOpen(pMeta->pTbDb, &pTbDbc, NULL); tdbTbcMoveTo(pTbDbc, &((STbDbKey){.uid = uid, .version = oversion}), sizeof(STbDbKey), &c); if (c != 0) { - tdbTbcClose(pUidIdxc); - tdbTbcClose(pTbDbc); + (void)tdbTbcClose(pUidIdxc); + (void)tdbTbcClose(pTbDbc); metaError("meta/table: invalide c: %" PRId32 " update tb options failed.", c); return TSDB_CODE_FAILED; } @@ -1901,8 +1902,8 @@ static int metaUpdateTableOptions(SMeta *pMeta, int64_t version, SVAlterTbReq *p ret = metaDecodeEntry(&dc, &entry); if (ret != 0) { tDecoderClear(&dc); - tdbTbcClose(pUidIdxc); - tdbTbcClose(pTbDbc); + (void)tdbTbcClose(pUidIdxc); + (void)tdbTbcClose(pTbDbc); metaError("meta/table: invalide ret: %" PRId32 " alt tb options failed.", ret); return TSDB_CODE_FAILED; } @@ -1912,9 +1913,9 @@ static int metaUpdateTableOptions(SMeta *pMeta, int64_t version, SVAlterTbReq *p // build SMetaEntry if (entry.type == TSDB_CHILD_TABLE) { if (pAlterTbReq->updateTTL) { - metaDeleteTtl(pMeta, &entry); + (void)metaDeleteTtl(pMeta, &entry); entry.ctbEntry.ttlDays = pAlterTbReq->newTTL; - metaUpdateTtl(pMeta, &entry); + (void)metaUpdateTtl(pMeta, &entry); } if (pAlterTbReq->newCommentLen >= 0) { entry.ctbEntry.commentLen = pAlterTbReq->newCommentLen; @@ -1922,9 +1923,9 @@ static int metaUpdateTableOptions(SMeta *pMeta, int64_t version, SVAlterTbReq *p } } else { if (pAlterTbReq->updateTTL) { - metaDeleteTtl(pMeta, &entry); + (void)metaDeleteTtl(pMeta, &entry); entry.ntbEntry.ttlDays = pAlterTbReq->newTTL; - metaUpdateTtl(pMeta, &entry); + (void)metaUpdateTtl(pMeta, &entry); } if (pAlterTbReq->newCommentLen >= 0) { entry.ntbEntry.commentLen = pAlterTbReq->newCommentLen; @@ -1933,14 +1934,14 @@ static int metaUpdateTableOptions(SMeta *pMeta, int64_t version, SVAlterTbReq *p } // save to table db - metaSaveToTbDb(pMeta, &entry); - metaUpdateUidIdx(pMeta, &entry); - metaUpdateChangeTime(pMeta, entry.uid, pAlterTbReq->ctimeMs); + (void)metaSaveToTbDb(pMeta, &entry); + (void)metaUpdateUidIdx(pMeta, &entry); + (void)metaUpdateChangeTime(pMeta, entry.uid, pAlterTbReq->ctimeMs); metaULock(pMeta); - tdbTbcClose(pTbDbc); - tdbTbcClose(pUidIdxc); + (void)tdbTbcClose(pTbDbc); + (void)tdbTbcClose(pUidIdxc); tDecoderClear(&dc); if (entry.pBuf) taosMemoryFree(entry.pBuf); return 0; @@ -2017,10 +2018,10 @@ static int metaAddTagIndex(SMeta *pMeta, int64_t version, SVAlterTbReq *pAlterTb * iterator all pTdDbc by uid and version */ TBC *pCtbIdxc = NULL; - tdbTbcOpen(pMeta->pCtbIdx, &pCtbIdxc, NULL); + (void)tdbTbcOpen(pMeta->pCtbIdx, &pCtbIdxc, NULL); int rc = tdbTbcMoveTo(pCtbIdxc, &(SCtbIdxKey){.suid = suid, .uid = INT64_MIN}, sizeof(SCtbIdxKey), &c); if (rc < 0) { - tdbTbcClose(pCtbIdxc); + (void)tdbTbcClose(pCtbIdxc); goto _err; } for (;;) { @@ -2057,14 +2058,14 @@ static int metaAddTagIndex(SMeta *pMeta, int64_t version, SVAlterTbReq *pAlterTb tdbFree(pKey); tdbFree(pVal); metaDestroyTagIdxKey(pTagIdxKey); - tdbTbcClose(pCtbIdxc); + (void)tdbTbcClose(pCtbIdxc); goto _err; } tdbTbUpsert(pMeta->pTagIdx, pTagIdxKey, nTagIdxKey, NULL, 0, pMeta->txn); metaDestroyTagIdxKey(pTagIdxKey); pTagIdxKey = NULL; } - tdbTbcClose(pCtbIdxc); + (void)tdbTbcClose(pCtbIdxc); return 0; _err: @@ -2156,7 +2157,7 @@ static int metaDropTagIndex(SMeta *pMeta, int64_t version, SVAlterTbReq *pAlterT SArray *tagIdxList = taosArrayInit(512, sizeof(SMetaPair)); TBC *pTagIdxc = NULL; - tdbTbcOpen(pMeta->pTagIdx, &pTagIdxc, NULL); + (void)tdbTbcOpen(pMeta->pTagIdx, &pTagIdxc, NULL); int rc = tdbTbcMoveTo(pTagIdxc, &(STagIdxKey){.suid = suid, .cid = INT32_MIN, .type = pCol->type}, sizeof(STagIdxKey), &c); for (;;) { @@ -2173,12 +2174,12 @@ static int metaDropTagIndex(SMeta *pMeta, int64_t version, SVAlterTbReq *pAlterT SMetaPair pair = {.key = pKey, nKey = nKey}; (void)taosArrayPush(tagIdxList, &pair); } - tdbTbcClose(pTagIdxc); + (void)tdbTbcClose(pTagIdxc); metaWLock(pMeta); for (int i = 0; i < taosArrayGetSize(tagIdxList); i++) { SMetaPair *pair = taosArrayGet(tagIdxList, i); - tdbTbDelete(pMeta->pTagIdx, pair->key, pair->nkey, pMeta->txn); + (void)tdbTbDelete(pMeta->pTagIdx, pair->key, pair->nkey, pMeta->txn); } metaULock(pMeta); @@ -2265,9 +2266,9 @@ int32_t metaUpdateTableColCompress(SMeta *pMeta, int64_t version, SVAlterTbReq * tbEntry.version = version; metaWLock(pMeta); - metaSaveToTbDb(pMeta, &tbEntry); - metaUpdateUidIdx(pMeta, &tbEntry); - metaUpdateChangeTime(pMeta, suid, pReq->ctimeMs); + (void)metaSaveToTbDb(pMeta, &tbEntry); + (void)metaUpdateUidIdx(pMeta, &tbEntry); + (void)metaUpdateChangeTime(pMeta, suid, pReq->ctimeMs); metaULock(pMeta); diff --git a/source/dnode/vnode/src/tsdb/tsdbCache.c b/source/dnode/vnode/src/tsdb/tsdbCache.c index 51de400305..8d5fa8b0b3 100644 --- a/source/dnode/vnode/src/tsdb/tsdbCache.c +++ b/source/dnode/vnode/src/tsdb/tsdbCache.c @@ -3274,7 +3274,7 @@ _err: TAOS_RETURN(code); } -void tsdbCacheRelease(SLRUCache *pCache, LRUHandle *h) { taosLRUCacheRelease(pCache, h, false); } +void tsdbCacheRelease(SLRUCache *pCache, LRUHandle *h) { (void)taosLRUCacheRelease(pCache, h, false); } void tsdbCacheSetCapacity(SVnode *pVnode, size_t capacity) { taosLRUCacheSetCapacity(pVnode->pTsdb->lruCache, capacity); diff --git a/source/dnode/vnode/src/tsdb/tsdbDataFileRW.c b/source/dnode/vnode/src/tsdb/tsdbDataFileRW.c index 28598f23f7..2665cc1aaf 100644 --- a/source/dnode/vnode/src/tsdb/tsdbDataFileRW.c +++ b/source/dnode/vnode/src/tsdb/tsdbDataFileRW.c @@ -135,7 +135,7 @@ int32_t tsdbDataFileReaderOpen(const char *fname[], const SDataFileReaderConfig for (int32_t i = 0; i < TSDB_FTYPE_MAX; ++i) { if (config->files[i].exist) { char fname1[TSDB_FILENAME_LEN]; - tsdbTFileName(config->tsdb, &config->files[i].file, fname1); + (void)tsdbTFileName(config->tsdb, &config->files[i].file, fname1); int32_t lcn = config->files[i].file.lcn; TAOS_CHECK_GOTO(tsdbOpenFile(fname1, config->tsdb, TD_FILE_READ, &reader[0]->fd[i], lcn), &lino, _exit); } @@ -667,7 +667,7 @@ static int32_t tsdbDataFileWriterCloseAbort(SDataFileWriter *writer) { static int32_t tsdbDataFileWriterDoClose(SDataFileWriter *writer) { if (writer->ctx->reader) { - tsdbDataFileReaderClose(&writer->ctx->reader); + (void)tsdbDataFileReaderClose(&writer->ctx->reader); } tTombBlockDestroy(writer->tombBlock); @@ -857,7 +857,7 @@ int32_t tsdbFileWriteBrinBlock(STsdbFD *fd, SBrinBlock *brinBlock, uint32_t cmpr } } - tsdbWriterUpdVerRange(range, brinBlk.minVer, brinBlk.maxVer); + (void)tsdbWriterUpdVerRange(range, brinBlk.minVer, brinBlk.maxVer); // write to file for (int32_t i = 0; i < 10; ++i) { @@ -1018,7 +1018,7 @@ static int32_t tsdbDataFileDoWriteBlockData(SDataFileWriter *writer, SBlockData } } - tsdbWriterUpdVerRange(&writer->ctx->range, record->minVer, record->maxVer); + (void)tsdbWriterUpdVerRange(&writer->ctx->range, record->minVer, record->maxVer); code = metaGetColCmpr(writer->config->tsdb->pVnode->pMeta, bData->suid != 0 ? bData->suid : bData->uid, &cmprInfo.pColCmpr); @@ -1371,7 +1371,7 @@ int32_t tsdbFileWriteTombBlock(STsdbFD *fd, STombBlock *tombBlock, int8_t cmprAl } } - tsdbWriterUpdVerRange(range, tombBlk.minVer, tombBlk.maxVer); + (void)tsdbWriterUpdVerRange(range, tombBlk.minVer, tombBlk.maxVer); for (int32_t i = 0; i < ARRAY_SIZE(tombBlock->buffers); i++) { tBufferClear(buffer0); @@ -1640,8 +1640,8 @@ static int32_t tsdbDataFileWriterCloseCommit(SDataFileWriter *writer, TFileOpArr .fid = writer->config->fid, .nf = writer->files[ftype], }; - tsdbTFileUpdVerRange(&op.nf, ofRange); - tsdbTFileUpdVerRange(&op.nf, writer->ctx->range); + (void)tsdbTFileUpdVerRange(&op.nf, ofRange); + (void)tsdbTFileUpdVerRange(&op.nf, writer->ctx->range); TAOS_CHECK_GOTO(TARRAY2_APPEND(opArr, op), &lino, _exit); // .data @@ -1652,7 +1652,7 @@ static int32_t tsdbDataFileWriterCloseCommit(SDataFileWriter *writer, TFileOpArr .fid = writer->config->fid, .nf = writer->files[ftype], }; - tsdbTFileUpdVerRange(&op.nf, writer->ctx->range); + (void)tsdbTFileUpdVerRange(&op.nf, writer->ctx->range); TAOS_CHECK_GOTO(TARRAY2_APPEND(opArr, op), &lino, _exit); } else if (writer->config->files[ftype].file.size != writer->files[ftype].size) { op = (STFileOp){ @@ -1661,7 +1661,7 @@ static int32_t tsdbDataFileWriterCloseCommit(SDataFileWriter *writer, TFileOpArr .of = writer->config->files[ftype].file, .nf = writer->files[ftype], }; - tsdbTFileUpdVerRange(&op.nf, writer->ctx->range); + (void)tsdbTFileUpdVerRange(&op.nf, writer->ctx->range); TAOS_CHECK_GOTO(TARRAY2_APPEND(opArr, op), &lino, _exit); } @@ -1673,7 +1673,7 @@ static int32_t tsdbDataFileWriterCloseCommit(SDataFileWriter *writer, TFileOpArr .fid = writer->config->fid, .nf = writer->files[ftype], }; - tsdbTFileUpdVerRange(&op.nf, writer->ctx->range); + (void)tsdbTFileUpdVerRange(&op.nf, writer->ctx->range); TAOS_CHECK_GOTO(TARRAY2_APPEND(opArr, op), &lino, _exit); } else if (writer->config->files[ftype].file.size != writer->files[ftype].size) { op = (STFileOp){ @@ -1682,7 +1682,7 @@ static int32_t tsdbDataFileWriterCloseCommit(SDataFileWriter *writer, TFileOpArr .of = writer->config->files[ftype].file, .nf = writer->files[ftype], }; - tsdbTFileUpdVerRange(&op.nf, writer->ctx->range); + (void)tsdbTFileUpdVerRange(&op.nf, writer->ctx->range); TAOS_CHECK_GOTO(TARRAY2_APPEND(opArr, op), &lino, _exit); } } @@ -1716,8 +1716,8 @@ static int32_t tsdbDataFileWriterCloseCommit(SDataFileWriter *writer, TFileOpArr .fid = writer->config->fid, .nf = writer->files[ftype], }; - tsdbTFileUpdVerRange(&op.nf, ofRange); - tsdbTFileUpdVerRange(&op.nf, writer->ctx->tombRange); + (void)tsdbTFileUpdVerRange(&op.nf, ofRange); + (void)tsdbTFileUpdVerRange(&op.nf, writer->ctx->tombRange); TAOS_CHECK_GOTO(TARRAY2_APPEND(opArr, op), &lino, _exit); } int32_t encryptAlgorithm = writer->config->tsdb->pVnode->config.tsdbCfg.encryptAlgorithm; @@ -1754,7 +1754,7 @@ static int32_t tsdbDataFileWriterOpenDataFD(SDataFileWriter *writer) { } int32_t lcn = writer->files[ftype].lcn; - tsdbTFileName(writer->config->tsdb, &writer->files[ftype], fname); + (void)tsdbTFileName(writer->config->tsdb, &writer->files[ftype], fname); TAOS_CHECK_GOTO(tsdbOpenFile(fname, writer->config->tsdb, flag, &writer->fd[ftype], lcn), &lino, _exit); if (writer->files[ftype].size == 0) { @@ -1804,7 +1804,7 @@ int32_t tsdbDataFileWriterClose(SDataFileWriter **writer, bool abort, TFileOpArr } else { TAOS_CHECK_GOTO(tsdbDataFileWriterCloseCommit(writer[0], opArr), &lino, _exit); } - tsdbDataFileWriterDoClose(writer[0]); + (void)tsdbDataFileWriterDoClose(writer[0]); } taosMemoryFree(writer[0]); writer[0] = NULL; @@ -1915,7 +1915,7 @@ static int32_t tsdbDataFileWriterOpenTombFD(SDataFileWriter *writer) { int32_t flag = (TD_FILE_READ | TD_FILE_WRITE | TD_FILE_CREATE | TD_FILE_TRUNC); int32_t lcn = writer->files[ftype].lcn; - tsdbTFileName(writer->config->tsdb, writer->files + ftype, fname); + (void)tsdbTFileName(writer->config->tsdb, writer->files + ftype, fname); TAOS_CHECK_GOTO(tsdbOpenFile(fname, writer->config->tsdb, flag, &writer->fd[ftype], lcn), &lino, _exit); diff --git a/source/dnode/vnode/src/tsdb/tsdbFS2.c b/source/dnode/vnode/src/tsdb/tsdbFS2.c index 8985e07b0c..c3b612b227 100644 --- a/source/dnode/vnode/src/tsdb/tsdbFS2.c +++ b/source/dnode/vnode/src/tsdb/tsdbFS2.c @@ -777,7 +777,7 @@ int32_t tsdbDisableAndCancelAllBgTask(STsdb *pTsdb) { } fset->channel = (SVAChannelID){0}; fset->mergeScheduled = false; - tsdbFSSetBlockCommit(fset, false); + (void)tsdbFSSetBlockCommit(fset, false); fset->channelOpened = false; } } @@ -877,7 +877,7 @@ int32_t tsdbFSCheckCommit(STsdb *tsdb, int32_t fid) { if (fset) { while (fset->blockCommit) { fset->numWaitCommit++; - taosThreadCondWait(&fset->canCommit, &tsdb->mutex); + (void)taosThreadCondWait(&fset->canCommit, &tsdb->mutex); fset->numWaitCommit--; } } @@ -1163,7 +1163,7 @@ int32_t tsdbFSCreateRefRangedSnapshot(STFileSystem *fs, int64_t sver, int64_t ev (void)taosThreadMutexUnlock(&fs->tsdb->mutex); if (code) { - tsdbTFileSetRangeClear(&fsr1); + (void)tsdbTFileSetRangeClear(&fsr1); TARRAY2_DESTROY(fsrArr[0], tsdbTFileSetRangeClear); fsrArr[0] = NULL; } @@ -1187,7 +1187,7 @@ int32_t tsdbBeginTaskOnFileSet(STsdb *tsdb, int32_t fid, STFileSet **fset) { if ((*fset)->taskRunning) { (*fset)->numWaitTask++; - taosThreadCondWait(&(*fset)->beginTask, &tsdb->mutex); + (void)taosThreadCondWait(&(*fset)->beginTask, &tsdb->mutex); (void)tsdbFSGetFSet(tsdb->pFS, fid, fset); ASSERT(fset != NULL); diff --git a/source/dnode/vnode/src/tsdb/tsdbFSet2.c b/source/dnode/vnode/src/tsdb/tsdbFSet2.c index 5ad7807f02..78e1a6a13d 100644 --- a/source/dnode/vnode/src/tsdb/tsdbFSet2.c +++ b/source/dnode/vnode/src/tsdb/tsdbFSet2.c @@ -45,7 +45,7 @@ static int32_t tsdbSttLvlInitEx(STsdb *pTsdb, const SSttLvl *lvl1, SSttLvl **lvl STFileObj *fobj; code = tsdbTFileObjInit(pTsdb, fobj1->f, &fobj); if (code) { - tsdbSttLvlClear(lvl); + (void)tsdbSttLvlClear(lvl); return code; } @@ -79,7 +79,7 @@ static int32_t tsdbSttLvlFilteredInitEx(STsdb *pTsdb, const SSttLvl *lvl1, int64 STFileObj *fobj; code = tsdbTFileObjInit(pTsdb, fobj1->f, &fobj); if (code) { - tsdbSttLvlClear(lvl); + (void)tsdbSttLvlClear(lvl); return code; } @@ -522,7 +522,8 @@ int32_t tsdbTFileSetFilteredInitDup(STsdb *pTsdb, const STFileSet *fset1, int64_ .fid = fobj->f->fid, .of = fobj->f[0], }; - TARRAY2_APPEND(fopArr, op); + code = TARRAY2_APPEND(fopArr, op); + if (code) return code; } } diff --git a/source/dnode/vnode/src/tsdb/tsdbOpen.c b/source/dnode/vnode/src/tsdb/tsdbOpen.c index 7f83bcdb0c..996b1a6425 100644 --- a/source/dnode/vnode/src/tsdb/tsdbOpen.c +++ b/source/dnode/vnode/src/tsdb/tsdbOpen.c @@ -57,7 +57,7 @@ int32_t tsdbOpen(SVnode *pVnode, STsdb **ppTsdb, const char *dir, STsdbKeepCfg * snprintf(pTsdb->path, TD_PATH_MAX, "%s%s%s", pVnode->path, TD_DIRSEP, dir); // taosRealPath(pTsdb->path, NULL, slen); pTsdb->pVnode = pVnode; - taosThreadMutexInit(&pTsdb->mutex, NULL); + (void)taosThreadMutexInit(&pTsdb->mutex, NULL); if (!pKeepCfg) { (void)tsdbSetKeepCfg(pTsdb, &pVnode->config.tsdbCfg); } else { diff --git a/source/dnode/vnode/src/tsdb/tsdbSttFileRW.c b/source/dnode/vnode/src/tsdb/tsdbSttFileRW.c index 779e6146e8..6e24311017 100644 --- a/source/dnode/vnode/src/tsdb/tsdbSttFileRW.c +++ b/source/dnode/vnode/src/tsdb/tsdbSttFileRW.c @@ -507,7 +507,7 @@ static int32_t tsdbFileDoWriteSttBlockData(STsdbFD *fd, SBlockData *blockData, S if (sttBlk->maxVer < blockData->aVersion[iRow]) sttBlk->maxVer = blockData->aVersion[iRow]; } - tsdbWriterUpdVerRange(range, sttBlk->minVer, sttBlk->maxVer); + (void)tsdbWriterUpdVerRange(range, sttBlk->minVer, sttBlk->maxVer); TAOS_CHECK_RETURN(tBlockDataCompress(blockData, info, buffers, buffers + 4)); sttBlk->bInfo.offset = *fileSize; diff --git a/source/dnode/vnode/src/tsdb/tsdbUpgrade.c b/source/dnode/vnode/src/tsdb/tsdbUpgrade.c index 8b55b2bab2..9336231420 100644 --- a/source/dnode/vnode/src/tsdb/tsdbUpgrade.c +++ b/source/dnode/vnode/src/tsdb/tsdbUpgrade.c @@ -358,7 +358,7 @@ static int32_t tsdbUpgradeFileSet(STsdb *tsdb, SDFileSet *pDFileSet, TFileSetArr TAOS_CHECK_GOTO(tsdbUpgradeStt(tsdb, pDFileSet, reader, fset), &lino, _exit); } - tsdbDataFReaderClose(&reader); + (void)tsdbDataFReaderClose(&reader); TAOS_CHECK_GOTO(TARRAY2_APPEND(fileSetArray, fset), &lino, _exit); @@ -570,7 +570,7 @@ _exit: if (code) { tsdbError("vgId:%d %s failed at %s:%d since %s", TD_VID(tsdb->pVnode), __func__, __FILE__, lino, tstrerror(code)); } - tsdbDelFReaderClose(&reader); + (void)tsdbDelFReaderClose(&reader); taosArrayDestroy(aDelIdx); return code; } @@ -612,7 +612,7 @@ static int32_t tsdbUpgradeFileSystem(STsdb *tsdb, int8_t rollback) { // save new file system char fname[TSDB_FILENAME_LEN]; - current_fname(tsdb, fname, TSDB_FCURRENT); + (void)current_fname(tsdb, fname, TSDB_FCURRENT); TAOS_CHECK_GOTO(save_fs(fileSetArray, fname), &lino, _exit); _exit: diff --git a/source/dnode/vnode/src/tsdb/tsdbUtil.c b/source/dnode/vnode/src/tsdb/tsdbUtil.c index a1ca8ccda2..667d7ffb7c 100644 --- a/source/dnode/vnode/src/tsdb/tsdbUtil.c +++ b/source/dnode/vnode/src/tsdb/tsdbUtil.c @@ -107,7 +107,7 @@ _exit: void tMapDataGetItemByIdx(SMapData *pMapData, int32_t idx, void *pItem, int32_t (*tGetItemFn)(uint8_t *, void *)) { ASSERT(idx >= 0 && idx < pMapData->nItem); - tGetItemFn(pMapData->pData + pMapData->aOffset[idx], pItem); + (void)tGetItemFn(pMapData->pData + pMapData->aOffset[idx], pItem); } #ifdef BUILD_NO_CALL @@ -613,7 +613,7 @@ void tsdbRowGetColVal(TSDBROW *pRow, STSchema *pTSchema, int32_t iCol, SColVal * SValue value; if (pRow->type == TSDBROW_ROW_FMT) { - tRowGet(pRow->pTSRow, pTSchema, iCol, pColVal); + (void)tRowGet(pRow->pTSRow, pTSchema, iCol, pColVal); } else if (pRow->type == TSDBROW_COL_FMT) { if (iCol == 0) { *pColVal = diff --git a/source/dnode/vnode/src/vnd/vnodeAsync.c b/source/dnode/vnode/src/vnd/vnodeAsync.c index cd4450cd7b..2ddd3c9d3e 100644 --- a/source/dnode/vnode/src/vnd/vnodeAsync.c +++ b/source/dnode/vnode/src/vnd/vnodeAsync.c @@ -389,7 +389,7 @@ static int32_t vnodeAsyncDestroy(SVAsync **async) { // set stop and broadcast (void)taosThreadMutexLock(&(*async)->mutex); (*async)->stop = true; - taosThreadCondBroadcast(&(*async)->hasTask); + (void)taosThreadCondBroadcast(&(*async)->hasTask); (void)taosThreadMutexUnlock(&(*async)->mutex); // join all workers @@ -666,7 +666,7 @@ int32_t vnodeAsyncSetWorkers(int64_t asyncID, int32_t numWorkers) { (void)taosThreadMutexLock(&async->mutex); async->numWorkers = numWorkers; if (async->numIdleWorkers > 0) { - taosThreadCondBroadcast(&async->hasTask); + (void)taosThreadCondBroadcast(&async->hasTask); } (void)taosThreadMutexUnlock(&async->mutex); diff --git a/source/dnode/vnode/src/vnd/vnodeCommit.c b/source/dnode/vnode/src/vnd/vnodeCommit.c index f7174d9a5f..88b13310d8 100644 --- a/source/dnode/vnode/src/vnd/vnodeCommit.c +++ b/source/dnode/vnode/src/vnd/vnodeCommit.c @@ -291,7 +291,7 @@ static int32_t vnodePrepareCommit(SVnode *pVnode, SCommitInfo *pInfo) { code = vnodeSaveInfo(dir, &pInfo->info); TSDB_CHECK_CODE(code, lino, _exit); - tsdbPreCommit(pVnode->pTsdb); + (void)tsdbPreCommit(pVnode->pTsdb); code = metaPrepareAsyncCommit(pVnode->pMeta); TSDB_CHECK_CODE(code, lino, _exit); diff --git a/source/dnode/vnode/src/vnd/vnodeOpen.c b/source/dnode/vnode/src/vnd/vnodeOpen.c index dacb565ee5..8a2b10d2ef 100644 --- a/source/dnode/vnode/src/vnd/vnodeOpen.c +++ b/source/dnode/vnode/src/vnd/vnodeOpen.c @@ -404,7 +404,7 @@ SVnode *vnodeOpen(const char *path, int32_t diskPrimary, STfs *pTfs, SMsgCb msgC (void)taosThreadMutexInit(&pVnode->lock, NULL); pVnode->blocked = false; - tsem_init(&pVnode->syncSem, 0, 0); + (void)tsem_init(&pVnode->syncSem, 0, 0); (void)taosThreadMutexInit(&pVnode->mutex, NULL); (void)taosThreadCondInit(&pVnode->poolNotEmpty, NULL); @@ -546,8 +546,8 @@ void vnodeClose(SVnode *pVnode) { (void)vnodeCloseBufPool(pVnode); // destroy handle - tsem_destroy(&pVnode->syncSem); - taosThreadCondDestroy(&pVnode->poolNotEmpty); + (void)tsem_destroy(&pVnode->syncSem); + (void)taosThreadCondDestroy(&pVnode->poolNotEmpty); (void)taosThreadMutexDestroy(&pVnode->mutex); (void)taosThreadMutexDestroy(&pVnode->lock); taosMemoryFree(pVnode); diff --git a/source/dnode/vnode/src/vnd/vnodeSnapshot.c b/source/dnode/vnode/src/vnd/vnodeSnapshot.c index d4f987c259..92e2ffeb7f 100644 --- a/source/dnode/vnode/src/vnd/vnodeSnapshot.c +++ b/source/dnode/vnode/src/vnd/vnodeSnapshot.c @@ -610,7 +610,7 @@ int32_t vnodeSnapWriterOpen(SVnode *pVnode, SSnapshotParam *pParam, SVSnapWriter int64_t ever = pParam->end; // cancel and disable all bg task - vnodeCancelAndDisableAllBgTask(pVnode); + (void)vnodeCancelAndDisableAllBgTask(pVnode); // alloc pWriter = (SVSnapWriter *)taosMemoryCalloc(1, sizeof(*pWriter)); @@ -749,7 +749,7 @@ _exit: vInfo("vgId:%d, vnode snapshot writer closed, rollback:%d", TD_VID(pVnode), rollback); taosMemoryFree(pWriter); } - vnodeEnableBgTask(pVnode); + (void)vnodeEnableBgTask(pVnode); return code; } diff --git a/source/dnode/vnode/src/vnd/vnodeSvr.c b/source/dnode/vnode/src/vnd/vnodeSvr.c index 6a73baecae..feaad0f46d 100644 --- a/source/dnode/vnode/src/vnd/vnodeSvr.c +++ b/source/dnode/vnode/src/vnd/vnodeSvr.c @@ -699,7 +699,7 @@ int32_t vnodeProcessWriteMsg(SVnode *pVnode, SRpcMsg *pMsg, int64_t ver, SRpcMsg vTrace("vgId:%d, process %s request, code:0x%x index:%" PRId64, TD_VID(pVnode), TMSG_INFO(pMsg->msgType), pRsp->code, ver); - walApplyVer(pVnode->pWal, ver); + (void)walApplyVer(pVnode->pWal, ver); code = tqPushMsg(pVnode->pTq, pMsg->msgType); if (code) { @@ -1405,7 +1405,7 @@ static int32_t vnodeProcessDropTbReq(SVnode *pVnode, int64_t ver, void *pReq, in } (void)tqUpdateTbUidList(pVnode->pTq, tbUids, false); - tdUpdateTbUidList(pVnode->pSma, pStore, false); + (void)tdUpdateTbUidList(pVnode->pSma, pStore, false); if (tsEnableAuditCreateTable) { int64_t clusterId = pVnode->config.syncCfg.nodeInfo[0].clusterId; @@ -1440,7 +1440,7 @@ _exit: tEncodeSize(tEncodeSVDropTbBatchRsp, &rsp, pRsp->contLen, ret); pRsp->pCont = rpcMallocCont(pRsp->contLen); tEncoderInit(&encoder, pRsp->pCont, pRsp->contLen); - tEncodeSVDropTbBatchRsp(&encoder, &rsp); + (void)tEncodeSVDropTbBatchRsp(&encoder, &rsp); tEncoderClear(&encoder); taosArrayDestroy(rsp.pArray); taosArrayDestroy(tbNames); @@ -2158,7 +2158,7 @@ static int32_t vnodeProcessBatchDeleteReq(SVnode *pVnode, int64_t ver, void *pRe SBatchDeleteReq deleteReq; SDecoder decoder; tDecoderInit(&decoder, pReq, len); - tDecodeSBatchDeleteReq(&decoder, &deleteReq); + (void)tDecodeSBatchDeleteReq(&decoder, &deleteReq); SMetaReader mr = {0}; metaReaderDoInit(&mr, pVnode->pMeta, META_READER_NOLOCK); diff --git a/source/dnode/vnode/src/vnd/vnodeSync.c b/source/dnode/vnode/src/vnd/vnodeSync.c index 9fcb765c50..d9630b56fd 100644 --- a/source/dnode/vnode/src/vnd/vnodeSync.c +++ b/source/dnode/vnode/src/vnd/vnodeSync.c @@ -583,7 +583,7 @@ static void vnodeRestoreFinish(const SSyncFSM *pFsm, const SyncIndex commitIdx) streamMetaWUnLock(pMeta); tqInfo("vgId:%d stream task already loaded, start them", vgId); - streamTaskSchedTask(&pVnode->msgCb, TD_VID(pVnode), 0, 0, STREAM_EXEC_T_START_ALL_TASKS); + (void)streamTaskSchedTask(&pVnode->msgCb, TD_VID(pVnode), 0, 0, STREAM_EXEC_T_START_ALL_TASKS); return; } } diff --git a/source/libs/tdb/src/db/tdbBtree.c b/source/libs/tdb/src/db/tdbBtree.c index 487ec1dac5..c07f442c4a 100644 --- a/source/libs/tdb/src/db/tdbBtree.c +++ b/source/libs/tdb/src/db/tdbBtree.c @@ -235,7 +235,7 @@ int tdbBtreeDelete(SBTree *pBt, const void *pKey, int kLen, TXN *pTxn) { int c; int ret; - tdbBtcOpen(&btc, pBt, pTxn); + (void)tdbBtcOpen(&btc, pBt, pTxn); /* btc.coder.ofps = taosArrayInit(8, sizeof(SPage *)); // btc.coder.ofps = taosArrayInit(8, sizeof(SPgno)); @@ -337,7 +337,7 @@ int tdbBtreePGet(SBTree *pBt, const void *pKey, int kLen, void **ppKey, int *pkL void *pTVal = NULL; SCellDecoder cd = {0}; - tdbBtcOpen(&btc, pBt, NULL); + (void)tdbBtcOpen(&btc, pBt, NULL); tdbTrace("tdb pget, btc: %p", &btc); @@ -799,7 +799,7 @@ static int tdbBtreeBalanceNonRoot(SBTree *pBt, SPage *pParent, int idx, TXN *pTx iNew = 0; nNewCells = 0; - tdbBtreeInitPage(pNews[iNew], &iarg, 0); + (void)tdbBtreeInitPage(pNews[iNew], &iarg, 0); for (int iOld = 0; iOld < nOlds; iOld++) { SPage *pPage; @@ -828,7 +828,7 @@ static int tdbBtreeBalanceNonRoot(SBTree *pBt, SPage *pParent, int idx, TXN *pTx if (iNew == nNews - 1 && pIntHdr->pgno == 0) { pIntHdr->pgno = TDB_PAGE_PGNO(pNews[iNew]); } else { - tdbBtreeDecodeCell(pPage, pCell, &cd, pTxn, pBt); + (void)tdbBtreeDecodeCell(pPage, pCell, &cd, pTxn, pBt); // TODO: pCell here may be inserted as an overflow cell, handle it SCell *pNewCell = tdbOsMalloc(cd.kLen + 9); @@ -850,7 +850,7 @@ static int tdbBtreeBalanceNonRoot(SBTree *pBt, SPage *pParent, int idx, TXN *pTx iNew++; nNewCells = 0; if (iNew < nNews) { - tdbBtreeInitPage(pNews[iNew], &iarg, 0); + (void)tdbBtreeInitPage(pNews[iNew], &iarg, 0); } } } else { @@ -875,7 +875,7 @@ static int tdbBtreeBalanceNonRoot(SBTree *pBt, SPage *pParent, int idx, TXN *pTx iNew++; nNewCells = 0; if (iNew < nNews) { - tdbBtreeInitPage(pNews[iNew], &iarg, 0); + (void)tdbBtreeInitPage(pNews[iNew], &iarg, 0); } } } @@ -904,7 +904,7 @@ static int tdbBtreeBalanceNonRoot(SBTree *pBt, SPage *pParent, int idx, TXN *pTx if (TDB_BTREE_PAGE_IS_ROOT(pParent) && TDB_PAGE_TOTAL_CELLS(pParent) == 0) { i8 flags = TDB_BTREE_ROOT | TDB_BTREE_PAGE_IS_LEAF(pNews[0]); // copy content to the parent page - tdbBtreeInitPage(pParent, &(SBtreeInitPageArg){.flags = flags, .pBt = pBt}, 0); + (void)tdbBtreeInitPage(pParent, &(SBtreeInitPageArg){.flags = flags, .pBt = pBt}, 0); (void)tdbPageCopy(pNews[0], pParent, 1); if (!TDB_BTREE_PAGE_IS_LEAF(pNews[0])) { diff --git a/source/libs/tdb/src/db/tdbPager.c b/source/libs/tdb/src/db/tdbPager.c index 01c9132b54..01dd0ac766 100644 --- a/source/libs/tdb/src/db/tdbPager.c +++ b/source/libs/tdb/src/db/tdbPager.c @@ -968,7 +968,7 @@ static int tdbPagerInitPage(SPager *pPager, SPage *pPage, int (*initPage)(SPage if (TDB_PAGE_INITIALIZED(pPage)) break; nLoops++; if (nLoops > 1000) { - sched_yield(); + (void)sched_yield(); nLoops = 0; } } diff --git a/source/util/src/tarray.c b/source/util/src/tarray.c index 660b757bb2..e0d38df5c8 100644 --- a/source/util/src/tarray.c +++ b/source/util/src/tarray.c @@ -293,7 +293,7 @@ void taosArrayRemove(SArray* pArray, size_t index) { ASSERT(index < pArray->size); if (index == pArray->size - 1) { - taosArrayPop(pArray); + (void)taosArrayPop(pArray); return; } diff --git a/source/util/src/tcache.c b/source/util/src/tcache.c index 0d9352190b..d66128e2d1 100644 --- a/source/util/src/tcache.c +++ b/source/util/src/tcache.c @@ -110,7 +110,7 @@ typedef struct SCacheObjTravSup { static FORCE_INLINE void __trashcan_wr_lock(SCacheObj *pCacheObj) { #if defined(LINUX) - taosThreadRwlockWrlock(&pCacheObj->lock); + (void)taosThreadRwlockWrlock(&pCacheObj->lock); #else (void)taosThreadMutexLock(&pCacheObj->lock); #endif @@ -118,7 +118,7 @@ static FORCE_INLINE void __trashcan_wr_lock(SCacheObj *pCacheObj) { static FORCE_INLINE void __trashcan_unlock(SCacheObj *pCacheObj) { #if defined(LINUX) - taosThreadRwlockUnlock(&pCacheObj->lock); + (void)taosThreadRwlockUnlock(&pCacheObj->lock); #else (void)taosThreadMutexUnlock(&pCacheObj->lock); #endif @@ -134,9 +134,9 @@ static FORCE_INLINE int32_t __trashcan_lock_init(SCacheObj *pCacheObj) { static FORCE_INLINE void __trashcan_lock_destroy(SCacheObj *pCacheObj) { #if defined(LINUX) - taosThreadRwlockDestroy(&pCacheObj->lock); + (void)taosThreadRwlockDestroy(&pCacheObj->lock); #else - taosThreadMutexDestroy(&pCacheObj->lock); + (void)taosThreadMutexDestroy(&pCacheObj->lock); #endif } @@ -155,18 +155,18 @@ static void *taosCacheTimedRefresh(void *handle); static void doInitRefreshThread(void) { pCacheArrayList = taosArrayInit(4, POINTER_BYTES); - taosThreadMutexInit(&guard, NULL); + (void)taosThreadMutexInit(&guard, NULL); TdThreadAttr thattr; - taosThreadAttrInit(&thattr); - taosThreadAttrSetDetachState(&thattr, PTHREAD_CREATE_JOINABLE); + (void)taosThreadAttrInit(&thattr); + (void)taosThreadAttrSetDetachState(&thattr, PTHREAD_CREATE_JOINABLE); - taosThreadCreate(&cacheRefreshWorker, &thattr, taosCacheTimedRefresh, NULL); - taosThreadAttrDestroy(&thattr); + (void)taosThreadCreate(&cacheRefreshWorker, &thattr, taosCacheTimedRefresh, NULL); + (void)taosThreadAttrDestroy(&thattr); } TdThread doRegisterCacheObj(SCacheObj *pCacheObj) { - taosThreadOnce(&cacheThreadInit, doInitRefreshThread); + (void)taosThreadOnce(&cacheThreadInit, doInitRefreshThread); (void)taosThreadMutexLock(&guard); (void)taosArrayPush(pCacheArrayList, &pCacheObj); @@ -215,7 +215,7 @@ static FORCE_INLINE void taosCacheReleaseNode(SCacheObj *pCacheObj, SCacheNode * return; } - atomic_sub_fetch_64(&pCacheObj->sizeInBytes, pNode->size); + (void)atomic_sub_fetch_64(&pCacheObj->sizeInBytes, pNode->size); uDebug("cache:%s, key:%p, %p is destroyed from cache, size:%dbytes, total num:%d size:%" PRId64 "bytes", pCacheObj->name, pNode->key, pNode->data, pNode->size, (int)pCacheObj->numOfElems - 1, pCacheObj->sizeInBytes); @@ -416,8 +416,8 @@ void *taosCachePut(SCacheObj *pCacheObj, const void *key, size_t keyLen, const v if (pNode == NULL) { pushfrontNodeInEntryList(pe, pNode1); - atomic_add_fetch_ptr(&pCacheObj->numOfElems, 1); - atomic_add_fetch_ptr(&pCacheObj->sizeInBytes, pNode1->size); + (void)atomic_add_fetch_ptr(&pCacheObj->numOfElems, 1); + (void)atomic_add_fetch_ptr(&pCacheObj->sizeInBytes, pNode1->size); uDebug("cache:%s, key:%p, %p added into cache, added:%" PRIu64 ", expire:%" PRIu64 ", totalNum:%d sizeInBytes:%" PRId64 "bytes size:%" PRId64 "bytes", pCacheObj->name, key, pNode1->data, pNode1->addedTime, pNode1->expireTime, (int32_t)pCacheObj->numOfElems, @@ -431,7 +431,7 @@ void *taosCachePut(SCacheObj *pCacheObj, const void *key, size_t keyLen, const v pCacheObj->freeFp(pNode->data); } - atomic_sub_fetch_64(&pCacheObj->sizeInBytes, pNode->size); + (void)atomic_sub_fetch_64(&pCacheObj->sizeInBytes, pNode->size); taosMemoryFreeClear(pNode); } else { taosAddToTrashcan(pCacheObj, pNode); @@ -439,7 +439,7 @@ void *taosCachePut(SCacheObj *pCacheObj, const void *key, size_t keyLen, const v } pushfrontNodeInEntryList(pe, pNode1); - atomic_add_fetch_64(&pCacheObj->sizeInBytes, pNode1->size); + (void)atomic_add_fetch_64(&pCacheObj->sizeInBytes, pNode1->size); uDebug("cache:%s, key:%p, %p added into cache, added:%" PRIu64 ", expire:%" PRIu64 ", totalNum:%d sizeInBytes:%" PRId64 "bytes size:%" PRId64 "bytes", pCacheObj->name, key, pNode1->data, pNode1->addedTime, pNode1->expireTime, (int32_t)pCacheObj->numOfElems, @@ -456,7 +456,7 @@ void *taosCacheAcquireByKey(SCacheObj *pCacheObj, const void *key, size_t keyLen } if (pCacheObj->numOfElems == 0) { - atomic_add_fetch_64(&pCacheObj->statistics.missCount, 1); + (void)atomic_add_fetch_64(&pCacheObj->statistics.missCount, 1); return NULL; } @@ -474,15 +474,15 @@ void *taosCacheAcquireByKey(SCacheObj *pCacheObj, const void *key, size_t keyLen void *pData = (pNode != NULL) ? pNode->data : NULL; if (pData != NULL) { - atomic_add_fetch_64(&pCacheObj->statistics.hitCount, 1); + (void)atomic_add_fetch_64(&pCacheObj->statistics.hitCount, 1); uDebug("cache:%s, key:%p, %p is retrieved from cache, refcnt:%d", pCacheObj->name, key, pData, T_REF_VAL_GET(pNode)); } else { - atomic_add_fetch_64(&pCacheObj->statistics.missCount, 1); + (void)atomic_add_fetch_64(&pCacheObj->statistics.missCount, 1); uDebug("cache:%s, key:%p, not in cache, retrieved failed", pCacheObj->name, key); } - atomic_add_fetch_64(&pCacheObj->statistics.totalAccess, 1); + (void)atomic_add_fetch_64(&pCacheObj->statistics.totalAccess, 1); return pData; } @@ -577,7 +577,7 @@ void taosCacheRelease(SCacheObj *pCacheObj, void **data, bool _remove) { ASSERT(pNode->pTNodeHeader->pData == pNode); __trashcan_wr_lock(pCacheObj); - doRemoveElemInTrashcan(pCacheObj, pNode->pTNodeHeader); + (void)doRemoveElemInTrashcan(pCacheObj, pNode->pTNodeHeader); __trashcan_unlock(pCacheObj); ref = T_REF_DEC(pNode); @@ -786,7 +786,7 @@ void taosTrashcanEmpty(SCacheObj *pCacheObj, bool force) { uDebug("cache:%s, key:%p, %p removed from trashcan. numOfElem in trashcan:%d", pCacheObj->name, pElem->pData->key, pElem->pData->data, pCacheObj->numOfElemsInTrash - 1); - doRemoveElemInTrashcan(pCacheObj, pElem); + (void)doRemoveElemInTrashcan(pCacheObj, pElem); doDestroyTrashcanElem(pCacheObj, pElem); pElem = pCacheObj->pTrash; } else { @@ -896,7 +896,7 @@ _end: taosArrayDestroy(pCacheArrayList); pCacheArrayList = NULL; - taosThreadMutexDestroy(&guard); + (void)taosThreadMutexDestroy(&guard); refreshWorkerNormalStopped = true; uDebug("cache refresh thread quits"); @@ -915,7 +915,7 @@ void taosCacheRefresh(SCacheObj *pCacheObj, __cache_trav_fn_t fp, void *param1) void taosStopCacheRefreshWorker(void) { stopRefreshWorker = true; TdThreadOnce tmp = PTHREAD_ONCE_INIT; - if (memcmp(&cacheThreadInit, &tmp, sizeof(TdThreadOnce)) != 0) taosThreadJoin(cacheRefreshWorker, NULL); + if (memcmp(&cacheThreadInit, &tmp, sizeof(TdThreadOnce)) != 0) (void)taosThreadJoin(cacheRefreshWorker, NULL); taosArrayDestroy(pCacheArrayList); } diff --git a/source/util/src/tdigest.c b/source/util/src/tdigest.c index 588c53537a..51b68f8f6b 100644 --- a/source/util/src/tdigest.c +++ b/source/util/src/tdigest.c @@ -256,7 +256,7 @@ double tdigestQuantile(TDigest *t, double q) { int64_t weight_so_far; SCentroid *a, *b, tmp; - tdigestCompress(t); + (void)tdigestCompress(t); if (t->num_centroids == 0) return NAN; if (t->num_centroids == 1) return t->centroids[0].mean; if (FLOAT_EQ(q, 0.0)) return t->min; diff --git a/source/util/src/terror.c b/source/util/src/terror.c index 565a27f86a..8400675ec6 100644 --- a/source/util/src/terror.c +++ b/source/util/src/terror.c @@ -834,7 +834,7 @@ static void tsSortError(void) { } const char* tstrerror(int32_t err) { - taosThreadOnce(&tsErrorInit, tsSortError); + (void)taosThreadOnce(&tsErrorInit, tsSortError); // this is a system errno if ((err & 0x00ff0000) == 0x00ff0000) { diff --git a/source/util/src/texception.c b/source/util/src/texception.c index 4723e34990..2c8ddf6a5f 100644 --- a/source/util/src/texception.c +++ b/source/util/src/texception.c @@ -52,7 +52,7 @@ static void cleanupWrapper_void_ptr(SCleanupAction* ca) { static void cleanupWrapper_int_int(SCleanupAction* ca) { int32_t (*func)(int32_t) = ca->func; - func(ca->arg1.Int); + (void)func(ca->arg1.Int); } static void cleanupWrapper_void(SCleanupAction* ca) { @@ -62,7 +62,7 @@ static void cleanupWrapper_void(SCleanupAction* ca) { static void cleanupWrapper_int_ptr(SCleanupAction* ca) { int32_t (*func)(void*) = ca->func; - func(ca->arg1.Ptr); + (void)func(ca->arg1.Ptr); } typedef void (*wrapper)(SCleanupAction*); diff --git a/source/util/src/thash.c b/source/util/src/thash.c index 62a73cb38c..6e2d1baf84 100644 --- a/source/util/src/thash.c +++ b/source/util/src/thash.c @@ -188,7 +188,7 @@ static SHashNode *doCreateHashNode(const void *key, size_t keyLen, const void *p */ static FORCE_INLINE void doUpdateHashNode(SHashObj *pHashObj, SHashEntry *pe, SHashNode *prev, SHashNode *pNode, SHashNode *pNewNode) { - atomic_sub_fetch_16(&pNode->refCount, 1); + (void)atomic_sub_fetch_16(&pNode->refCount, 1); if (prev != NULL) { prev->next = pNewNode; ASSERT(prev->next != prev); @@ -204,7 +204,7 @@ static FORCE_INLINE void doUpdateHashNode(SHashObj *pHashObj, SHashEntry *pe, SH } else { pNewNode->next = pNode; pe->num++; - atomic_add_fetch_64(&pHashObj->size, 1); + (void)atomic_add_fetch_64(&pHashObj->size, 1); } } @@ -359,7 +359,7 @@ int32_t taosHashPut(SHashObj *pHashObj, const void *key, size_t keyLen, const vo } pushfrontNodeInEntryList(pe, pNewNode); - atomic_add_fetch_64(&pHashObj->size, 1); + (void)atomic_add_fetch_64(&pHashObj->size, 1); } else { // not support the update operation, return error if (pHashObj->enableUpdate) { @@ -392,7 +392,7 @@ void *taosHashGet(SHashObj *pHashObj, const void *key, size_t keyLen) { int32_t taosHashGetDup(SHashObj *pHashObj, const void *key, size_t keyLen, void *destBuf) { terrno = 0; - /*char* p = */ taosHashGetImpl(pHashObj, key, keyLen, &destBuf, 0, false); + (void)taosHashGetImpl(pHashObj, key, keyLen, &destBuf, 0, false); return terrno; } @@ -454,7 +454,7 @@ void *taosHashGetImpl(SHashObj *pHashObj, const void *key, size_t keyLen, void * } if (addRef) { - atomic_add_fetch_16(&pNode->refCount, 1); + (void)atomic_add_fetch_16(&pNode->refCount, 1); } if (*d != NULL) { @@ -501,7 +501,7 @@ int32_t taosHashRemove(SHashObj *pHashObj, const void *key, size_t keyLen) { pNode->removed == 0) { code = 0; // it is found - atomic_sub_fetch_16(&pNode->refCount, 1); + (void)atomic_sub_fetch_16(&pNode->refCount, 1); pNode->removed = 1; if (pNode->refCount <= 0) { if (prevNode == NULL) { @@ -512,7 +512,7 @@ int32_t taosHashRemove(SHashObj *pHashObj, const void *key, size_t keyLen) { } pe->num--; - atomic_sub_fetch_64(&pHashObj->size, 1); + (void)atomic_sub_fetch_64(&pHashObj->size, 1); FREE_HASH_NODE(pHashObj->freeFp, pNode); } } else { @@ -752,7 +752,7 @@ static void *taosHashReleaseNode(SHashObj *pHashObj, void *p, int *slot) { pNode = pNode->next; } - atomic_sub_fetch_16(&pOld->refCount, 1); + (void)atomic_sub_fetch_16(&pOld->refCount, 1); if (pOld->refCount <= 0) { if (prevNode) { prevNode->next = pOld->next; @@ -766,7 +766,7 @@ static void *taosHashReleaseNode(SHashObj *pHashObj, void *p, int *slot) { } pe->num--; - atomic_sub_fetch_64(&pHashObj->size, 1); + (void)atomic_sub_fetch_64(&pHashObj->size, 1); FREE_HASH_NODE(pHashObj->freeFp, pOld); } } else { @@ -840,7 +840,7 @@ void taosHashCancelIterate(SHashObj *pHashObj, void *p) { taosHashRLock(pHashObj); int slot; - taosHashReleaseNode(pHashObj, p, &slot); + (void)taosHashReleaseNode(pHashObj, p, &slot); SHashEntry *pe = pHashObj->hashList[slot]; diff --git a/source/util/src/theap.c b/source/util/src/theap.c index 40fe63b004..7ee49ff56d 100644 --- a/source/util/src/theap.c +++ b/source/util/src/theap.c @@ -258,9 +258,9 @@ static PriorityQueueNode* pqHeapify(PriorityQueue* pq, size_t from, size_t last) static void pqBuildHeap(PriorityQueue* pq) { if (pqContainerSize(pq) > 1) { for (size_t i = pqContainerSize(pq) - 1; i > 0; --i) { - pqHeapify(pq, i, pqContainerSize(pq)); + (void)pqHeapify(pq, i, pqContainerSize(pq)); } - pqHeapify(pq, 0, pqContainerSize(pq)); + (void)pqHeapify(pq, 0, pqContainerSize(pq)); } } @@ -276,21 +276,21 @@ static PriorityQueueNode* pqReverseHeapify(PriorityQueue* pq, size_t i) { static void pqUpdate(PriorityQueue* pq, size_t i) { if (i == 0 || pq->fn(pqContainerGetEle(pq, i)->data, pqContainerGetEle(pq, pqParent(i))->data, pq->param)) { // if value in pos i is smaller than parent, heapify down from i to the end - pqHeapify(pq, i, pqContainerSize(pq)); + (void)pqHeapify(pq, i, pqContainerSize(pq)); } else { // if value in pos i is big than parent, heapify up from i - pqReverseHeapify(pq, i); + (void)pqReverseHeapify(pq, i); } } static void pqRemove(PriorityQueue* pq, size_t i) { if (i == pqContainerSize(pq) - 1) { - taosArrayPop(pq->container); + (void)taosArrayPop(pq->container); return; } taosArraySet(pq->container, i, taosArrayGet(pq->container, pqContainerSize(pq) - 1)); - taosArrayPop(pq->container); + (void)taosArrayPop(pq->container); pqUpdate(pq, i); } diff --git a/source/util/src/tidpool.c b/source/util/src/tidpool.c index 46e68c0818..456078c4b5 100644 --- a/source/util/src/tidpool.c +++ b/source/util/src/tidpool.c @@ -33,7 +33,7 @@ void *taosInitIdPool(int32_t maxId) { pIdPool->numOfFree = maxId; pIdPool->freeSlot = 0; - taosThreadMutexInit(&pIdPool->mutex, NULL); + (void)taosThreadMutexInit(&pIdPool->mutex, NULL); uDebug("pool:%p is setup, maxId:%d", pIdPool, pIdPool->maxId); @@ -83,7 +83,7 @@ void taosIdPoolCleanUp(id_pool_t *pIdPool) { if (pIdPool->freeList) taosMemoryFree(pIdPool->freeList); - taosThreadMutexDestroy(&pIdPool->mutex); + (void)taosThreadMutexDestroy(&pIdPool->mutex); memset(pIdPool, 0, sizeof(id_pool_t)); diff --git a/source/util/src/tlockfree.c b/source/util/src/tlockfree.c index 6f7b6f6901..1961b404b5 100644 --- a/source/util/src/tlockfree.c +++ b/source/util/src/tlockfree.c @@ -30,7 +30,7 @@ void taosWLockLatch(SRWLatch *pLatch) { if (oLatch & TD_RWLATCH_WRITE_FLAG) { nLoops++; if (nLoops > 1000) { - sched_yield(); + (void)sched_yield(); nLoops = 0; } continue; @@ -47,7 +47,7 @@ void taosWLockLatch(SRWLatch *pLatch) { if (oLatch == TD_RWLATCH_WRITE_FLAG) break; nLoops++; if (nLoops > 1000) { - sched_yield(); + (void)sched_yield(); nLoops = 0; } } @@ -80,7 +80,7 @@ void taosRLockLatch(SRWLatch *pLatch) { if (oLatch & TD_RWLATCH_WRITE_FLAG) { nLoops++; if (nLoops > 1000) { - sched_yield(); + (void)sched_yield(); nLoops = 0; } continue; @@ -91,4 +91,4 @@ void taosRLockLatch(SRWLatch *pLatch) { } } -void taosRUnLockLatch(SRWLatch *pLatch) { atomic_fetch_sub_32(pLatch, 1); } +void taosRUnLockLatch(SRWLatch *pLatch) { (void)atomic_fetch_sub_32(pLatch, 1); } diff --git a/source/util/src/tlog.c b/source/util/src/tlog.c index fa2c2cc3ed..6f070a1d13 100644 --- a/source/util/src/tlog.c +++ b/source/util/src/tlog.c @@ -136,7 +136,7 @@ static int32_t taosOpenLogFile(char *fn, int32_t maxFileNum); static FORCE_INLINE void taosUpdateDaylight() { struct tm Tm, *ptm; struct timeval timeSecs; - taosGetTimeOfDay(&timeSecs); + (void)taosGetTimeOfDay(&timeSecs); time_t curTime = timeSecs.tv_sec; ptm = taosLocalTime(&curTime, &Tm, NULL); tsDaylightActive = ptm->tm_isdst; @@ -145,11 +145,11 @@ static FORCE_INLINE int32_t taosGetDaylight() { return tsDaylightActive; } static int32_t taosStartLog() { TdThreadAttr threadAttr; - taosThreadAttrInit(&threadAttr); + (void)taosThreadAttrInit(&threadAttr); if (taosThreadCreate(&(tsLogObj.logHandle->asyncThread), &threadAttr, taosAsyncOutputLog, tsLogObj.logHandle) != 0) { return terrno; } - taosThreadAttrDestroy(&threadAttr); + (void)taosThreadAttrDestroy(&threadAttr); return 0; } @@ -179,7 +179,7 @@ int32_t taosInitSlowLog() { tsLogObj.slowHandle = taosLogBuffNew(LOG_SLOW_BUF_SIZE); if (tsLogObj.slowHandle == NULL) return terrno; - taosUmaskFile(0); + (void)taosUmaskFile(0); tsLogObj.slowHandle->pFile = taosOpenFile(fullName, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_APPEND); if (tsLogObj.slowHandle->pFile == NULL) { printf("\nfailed to open slow log file:%s, reason:%s\n", fullName, strerror(errno)); @@ -231,13 +231,13 @@ void taosCloseLog() { taosStopLog(); if (tsLogObj.logHandle != NULL && taosCheckPthreadValid(tsLogObj.logHandle->asyncThread)) { - taosThreadJoin(tsLogObj.logHandle->asyncThread, NULL); + (void)taosThreadJoin(tsLogObj.logHandle->asyncThread, NULL); taosThreadClear(&tsLogObj.logHandle->asyncThread); } if (tsLogObj.slowHandle != NULL) { - taosThreadMutexDestroy(&tsLogObj.slowHandle->buffMutex); - taosCloseFile(&tsLogObj.slowHandle->pFile); + (void)taosThreadMutexDestroy(&tsLogObj.slowHandle->buffMutex); + (void)taosCloseFile(&tsLogObj.slowHandle->pFile); taosMemoryFreeClear(tsLogObj.slowHandle->buffer); taosMemoryFreeClear(tsLogObj.slowHandle); } @@ -245,10 +245,10 @@ void taosCloseLog() { if (tsLogObj.logHandle != NULL) { tsLogInited = 0; - taosThreadMutexDestroy(&tsLogObj.logHandle->buffMutex); - taosCloseFile(&tsLogObj.logHandle->pFile); + (void)taosThreadMutexDestroy(&tsLogObj.logHandle->buffMutex); + (void)taosCloseFile(&tsLogObj.logHandle->pFile); taosMemoryFreeClear(tsLogObj.logHandle->buffer); - taosThreadMutexDestroy(&tsLogObj.logMutex); + (void)taosThreadMutexDestroy(&tsLogObj.logMutex); taosMemoryFreeClear(tsLogObj.logHandle); tsLogObj.logHandle = NULL; } @@ -321,7 +321,7 @@ static OldFileKeeper *taosOpenNewFile() { char name[LOG_FILE_NAME_LEN + 20]; sprintf(name, "%s.%d", tsLogObj.logName, tsLogObj.flag); - taosUmaskFile(0); + (void)taosUmaskFile(0); TdFilePtr pFile = taosOpenFile(name, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_TRUNC); if (pFile == NULL) { @@ -331,7 +331,7 @@ static OldFileKeeper *taosOpenNewFile() { return NULL; } - taosLockLogFile(pFile); + (void)taosLockLogFile(pFile); (void)taosLSeekFile(pFile, 0, SEEK_SET); TdFilePtr pOldFile = tsLogObj.logHandle->pFile; @@ -370,12 +370,12 @@ static int32_t taosOpenNewLogFile() { uInfo("open new log file ......"); TdThread thread; TdThreadAttr attr; - taosThreadAttrInit(&attr); - taosThreadAttrSetDetachState(&attr, PTHREAD_CREATE_DETACHED); + (void)taosThreadAttrInit(&attr); + (void)taosThreadAttrSetDetachState(&attr, PTHREAD_CREATE_DETACHED); OldFileKeeper *oldFileKeeper = taosOpenNewFile(); - taosThreadCreate(&thread, &attr, taosThreadToCloseOldFile, oldFileKeeper); - taosThreadAttrDestroy(&attr); + (void)taosThreadCreate(&thread, &attr, taosThreadToCloseOldFile, oldFileKeeper); + (void)taosThreadAttrDestroy(&attr); } (void)taosThreadMutexUnlock(&tsLogObj.logMutex); @@ -388,7 +388,7 @@ void taosResetLog() { tsLogObj.lines = tsNumOfLogLines + 10; if (tsLogObj.logHandle) { - taosOpenNewLogFile(); + (void)taosOpenNewLogFile(); uInfo("=================================="); uInfo(" reset log file "); } @@ -407,10 +407,10 @@ static bool taosCheckFileIsOpen(char *logFileName) { if (taosLockLogFile(pFile)) { taosUnLockLogFile(pFile); - taosCloseFile(&pFile); + (void)taosCloseFile(&pFile); return false; } else { - taosCloseFile(&pFile); + (void)taosCloseFile(&pFile); return true; } } @@ -480,14 +480,14 @@ static int32_t taosOpenLogFile(char *fn, int32_t maxFileNum) { sprintf(fileName, "%s.%d", tsLogObj.logName, tsLogObj.flag); taosThreadMutexInit(&tsLogObj.logMutex, NULL); - taosUmaskFile(0); + (void)taosUmaskFile(0); tsLogObj.logHandle->pFile = taosOpenFile(fileName, TD_FILE_CREATE | TD_FILE_WRITE); if (tsLogObj.logHandle->pFile == NULL) { printf("\nfailed to open log file:%s, reason:%s\n", fileName, strerror(errno)); return TAOS_SYSTEM_ERROR(errno); } - taosLockLogFile(tsLogObj.logHandle->pFile); + (void)taosLockLogFile(tsLogObj.logHandle->pFile); // only an estimate for number of lines int64_t filesize = 0; @@ -497,14 +497,14 @@ static int32_t taosOpenLogFile(char *fn, int32_t maxFileNum) { } tsLogObj.lines = (int32_t)(filesize / 60); - taosLSeekFile(tsLogObj.logHandle->pFile, 0, SEEK_END); + (void)taosLSeekFile(tsLogObj.logHandle->pFile, 0, SEEK_END); sprintf(name, "==================================================\n"); - taosWriteFile(tsLogObj.logHandle->pFile, name, (uint32_t)strlen(name)); + (void)taosWriteFile(tsLogObj.logHandle->pFile, name, (uint32_t)strlen(name)); sprintf(name, " new log file \n"); - taosWriteFile(tsLogObj.logHandle->pFile, name, (uint32_t)strlen(name)); + (void)taosWriteFile(tsLogObj.logHandle->pFile, name, (uint32_t)strlen(name)); sprintf(name, "==================================================\n"); - taosWriteFile(tsLogObj.logHandle->pFile, name, (uint32_t)strlen(name)); + (void)taosWriteFile(tsLogObj.logHandle->pFile, name, (uint32_t)strlen(name)); return 0; } @@ -512,17 +512,17 @@ static int32_t taosOpenLogFile(char *fn, int32_t maxFileNum) { static void taosUpdateLogNums(ELogLevel level) { switch (level) { case DEBUG_ERROR: - atomic_add_fetch_64(&tsNumOfErrorLogs, 1); + (void)atomic_add_fetch_64(&tsNumOfErrorLogs, 1); break; case DEBUG_INFO: - atomic_add_fetch_64(&tsNumOfInfoLogs, 1); + (void)atomic_add_fetch_64(&tsNumOfInfoLogs, 1); break; case DEBUG_DEBUG: - atomic_add_fetch_64(&tsNumOfDebugLogs, 1); + (void)atomic_add_fetch_64(&tsNumOfDebugLogs, 1); break; case DEBUG_DUMP: case DEBUG_TRACE: - atomic_add_fetch_64(&tsNumOfTraceLogs, 1); + (void)atomic_add_fetch_64(&tsNumOfTraceLogs, 1); break; default: break; @@ -533,7 +533,7 @@ static inline int32_t taosBuildLogHead(char *buffer, const char *flags) { struct tm Tm, *ptm; struct timeval timeSecs; - taosGetTimeOfDay(&timeSecs); + (void)taosGetTimeOfDay(&timeSecs); time_t curTime = timeSecs.tv_sec; ptm = taosLocalTime(&curTime, &Tm, NULL); @@ -546,15 +546,15 @@ static inline void taosPrintLogImp(ELogLevel level, int32_t dflag, const char *b if ((dflag & DEBUG_FILE) && tsLogObj.logHandle && tsLogObj.logHandle->pFile != NULL && osLogSpaceAvailable()) { taosUpdateLogNums(level); if (tsAsyncLog) { - taosPushLogBuffer(tsLogObj.logHandle, buffer, len); + (void)taosPushLogBuffer(tsLogObj.logHandle, buffer, len); } else { - taosWriteFile(tsLogObj.logHandle->pFile, buffer, len); + (void)taosWriteFile(tsLogObj.logHandle->pFile, buffer, len); } if (tsNumOfLogLines > 0) { - atomic_add_fetch_32(&tsLogObj.lines, 1); + (void)atomic_add_fetch_32(&tsLogObj.lines, 1); if ((tsLogObj.lines > tsNumOfLogLines) && (tsLogObj.openInProgress == 0)) { - taosOpenNewLogFile(); + (void)taosOpenNewLogFile(); } } } @@ -627,12 +627,12 @@ void taosPrintSlowLog(const char *format, ...) { buffer[len++] = '\n'; buffer[len] = 0; - atomic_add_fetch_64(&tsNumOfSlowLogs, 1); + (void)atomic_add_fetch_64(&tsNumOfSlowLogs, 1); if (tsAsyncLog) { - taosPushLogBuffer(tsLogObj.slowHandle, buffer, len); + (void)taosPushLogBuffer(tsLogObj.slowHandle, buffer, len); } else { - taosWriteFile(tsLogObj.slowHandle->pFile, buffer, len); + (void)taosWriteFile(tsLogObj.slowHandle->pFile, buffer, len); } taosMemoryFree(buffer); @@ -651,7 +651,7 @@ void taosDumpData(unsigned char *msg, int32_t len) { pos += 3; if (c >= 16) { temp[pos++] = '\n'; - taosWriteFile(tsLogObj.logHandle->pFile, temp, (uint32_t)pos); + (void)taosWriteFile(tsLogObj.logHandle->pFile, temp, (uint32_t)pos); c = 0; pos = 0; } @@ -659,13 +659,13 @@ void taosDumpData(unsigned char *msg, int32_t len) { temp[pos++] = '\n'; - taosWriteFile(tsLogObj.logHandle->pFile, temp, (uint32_t)pos); + (void)taosWriteFile(tsLogObj.logHandle->pFile, temp, (uint32_t)pos); } static void taosCloseLogByFd(TdFilePtr pFile) { if (pFile != NULL) { taosUnLockLogFile(pFile); - taosCloseFile(&pFile); + (void)taosCloseFile(&pFile); } } @@ -786,12 +786,12 @@ static void taosWriteLog(SLogBuff *pLogBuf) { pLogBuf->lastDuration = 0; if (start < end) { - taosWriteFile(pLogBuf->pFile, LOG_BUF_BUFFER(pLogBuf) + start, pollSize); + (void)taosWriteFile(pLogBuf->pFile, LOG_BUF_BUFFER(pLogBuf) + start, pollSize); } else { int32_t tsize = LOG_BUF_SIZE(pLogBuf) - start; - taosWriteFile(pLogBuf->pFile, LOG_BUF_BUFFER(pLogBuf) + start, tsize); + (void)taosWriteFile(pLogBuf->pFile, LOG_BUF_BUFFER(pLogBuf) + start, tsize); - taosWriteFile(pLogBuf->pFile, LOG_BUF_BUFFER(pLogBuf), end); + (void)taosWriteFile(pLogBuf->pFile, LOG_BUF_BUFFER(pLogBuf), end); } dbgWN++; @@ -937,7 +937,7 @@ void taosLogCrashInfo(char *nodeType, char *pMsg, int64_t msgLen, int signum, vo _return: - if (pFile) taosCloseFile(&pFile); + if (pFile) (void)taosCloseFile(&pFile); terrno = TAOS_SYSTEM_ERROR(errno); taosPrintLog(flags, level, dflag, "crash signal is %d", signum); @@ -1029,10 +1029,10 @@ void taosReadCrashInfo(char *filepath, char **pMsg, int64_t *pMsgLen, TdFilePtr _return: if (truncateFile) { - taosFtruncateFile(pFile, 0); + (void)taosFtruncateFile(pFile, 0); } taosUnLockFile(pFile); - taosCloseFile(&pFile); + (void)taosCloseFile(&pFile); taosMemoryFree(buf); *pMsg = NULL; @@ -1042,11 +1042,11 @@ _return: void taosReleaseCrashLogFile(TdFilePtr pFile, bool truncateFile) { if (truncateFile) { - taosFtruncateFile(pFile, 0); + (void)taosFtruncateFile(pFile, 0); } taosUnLockFile(pFile); - taosCloseFile(&pFile); + (void)taosCloseFile(&pFile); } #ifdef NDEBUG diff --git a/source/util/src/tqueue.c b/source/util/src/tqueue.c index c6b029ea01..d25e0b33de 100644 --- a/source/util/src/tqueue.c +++ b/source/util/src/tqueue.c @@ -102,7 +102,7 @@ void taosCloseQueue(STaosQueue *queue) { taosMemoryFree(pTemp); } - taosThreadMutexDestroy(&queue->mutex); + (void)taosThreadMutexDestroy(&queue->mutex); taosMemoryFree(queue); uDebug("queue:%p is closed", queue); @@ -165,7 +165,7 @@ int32_t taosAllocateQitem(int32_t size, EQItype itype, int64_t dataSize, void ** if (alloced > tsRpcQueueMemoryAllowed) { uError("failed to alloc qitem, size:%" PRId64 " alloc:%" PRId64 " allowed:%" PRId64, size + dataSize, alloced, tsRpcQueueMemoryAllowed); - atomic_sub_fetch_64(&tsRpcQueueMemoryUsed, size + dataSize); + (void)atomic_sub_fetch_64(&tsRpcQueueMemoryUsed, size + dataSize); taosMemoryFree(pNode); return (terrno = TSDB_CODE_OUT_OF_RPC_MEMORY_QUEUE); } @@ -224,7 +224,7 @@ int32_t taosWriteQitem(STaosQueue *queue, void *pItem) { queue->numOfItems++; queue->memOfItems += (pNode->size + pNode->dataSize); if (queue->qset) { - atomic_add_fetch_32(&queue->qset->numOfItems, 1); + (void)atomic_add_fetch_32(&queue->qset->numOfItems, 1); } uTrace("item:%p is put into queue:%p, items:%d mem:%" PRId64, pItem, queue, queue->numOfItems, queue->memOfItems); @@ -253,7 +253,7 @@ int32_t taosReadQitem(STaosQueue *queue, void **ppItem) { queue->numOfItems--; queue->memOfItems -= (pNode->size + pNode->dataSize); if (queue->qset) { - atomic_sub_fetch_32(&queue->qset->numOfItems, 1); + (void)atomic_sub_fetch_32(&queue->qset->numOfItems, 1); } code = 1; uTrace("item:%p is read out from queue:%p, items:%d mem:%" PRId64, *ppItem, queue, queue->numOfItems, @@ -301,7 +301,7 @@ int32_t taosReadAllQitems(STaosQueue *queue, STaosQall *qall) { uTrace("read %d items from queue:%p, items:%d mem:%" PRId64, numOfItems, queue, queue->numOfItems, queue->memOfItems); if (queue->qset) { - atomic_sub_fetch_32(&queue->qset->numOfItems, qall->numOfItems); + (void)atomic_sub_fetch_32(&queue->qset->numOfItems, qall->numOfItems); } } @@ -344,8 +344,8 @@ int32_t taosOpenQset(STaosQset **qset) { return terrno = TSDB_CODE_OUT_OF_MEMORY; } - taosThreadMutexInit(&(*qset)->mutex, NULL); - tsem_init(&(*qset)->sem, 0, 0); + (void)taosThreadMutexInit(&(*qset)->mutex, NULL); + (void)tsem_init(&(*qset)->sem, 0, 0); uDebug("qset:%p is opened", qset); return 0; @@ -365,8 +365,8 @@ void taosCloseQset(STaosQset *qset) { } (void)taosThreadMutexUnlock(&qset->mutex); - taosThreadMutexDestroy(&qset->mutex); - tsem_destroy(&qset->sem); + (void)taosThreadMutexDestroy(&qset->mutex); + (void)tsem_destroy(&qset->sem); taosMemoryFree(qset); uDebug("qset:%p is closed", qset); } @@ -376,7 +376,7 @@ void taosCloseQset(STaosQset *qset) { // thread to exit. void taosQsetThreadResume(STaosQset *qset) { uDebug("qset:%p, it will exit", qset); - tsem_post(&qset->sem); + (void)tsem_post(&qset->sem); } int32_t taosAddIntoQset(STaosQset *qset, STaosQueue *queue, void *ahandle) { @@ -390,7 +390,7 @@ int32_t taosAddIntoQset(STaosQset *qset, STaosQueue *queue, void *ahandle) { qset->numOfQueues++; (void)taosThreadMutexLock(&queue->mutex); - atomic_add_fetch_32(&qset->numOfItems, queue->numOfItems); + (void)atomic_add_fetch_32(&qset->numOfItems, queue->numOfItems); queue->qset = qset; (void)taosThreadMutexUnlock(&queue->mutex); @@ -428,7 +428,7 @@ void taosRemoveFromQset(STaosQset *qset, STaosQueue *queue) { qset->numOfQueues--; (void)taosThreadMutexLock(&queue->mutex); - atomic_sub_fetch_32(&qset->numOfItems, queue->numOfItems); + (void)atomic_sub_fetch_32(&qset->numOfItems, queue->numOfItems); queue->qset = NULL; queue->next = NULL; (void)taosThreadMutexUnlock(&queue->mutex); @@ -444,7 +444,7 @@ int32_t taosReadQitemFromQset(STaosQset *qset, void **ppItem, SQueueInfo *qinfo) STaosQnode *pNode = NULL; int32_t code = 0; - tsem_wait(&qset->sem); + (void)tsem_wait(&qset->sem); (void)taosThreadMutexLock(&qset->mutex); @@ -469,7 +469,7 @@ int32_t taosReadQitemFromQset(STaosQset *qset, void **ppItem, SQueueInfo *qinfo) if (queue->head == NULL) queue->tail = NULL; // queue->numOfItems--; queue->memOfItems -= (pNode->size + pNode->dataSize); - atomic_sub_fetch_32(&qset->numOfItems, 1); + (void)atomic_sub_fetch_32(&qset->numOfItems, 1); code = 1; uTrace("item:%p is read out from queue:%p, items:%d mem:%" PRId64, *ppItem, queue, queue->numOfItems - 1, queue->memOfItems); @@ -488,7 +488,7 @@ int32_t taosReadAllQitemsFromQset(STaosQset *qset, STaosQall *qall, SQueueInfo * STaosQueue *queue; int32_t code = 0; - tsem_wait(&qset->sem); + (void)tsem_wait(&qset->sem); (void)taosThreadMutexLock(&qset->mutex); for (int32_t i = 0; i < qset->numOfQueues; ++i) { @@ -520,9 +520,9 @@ int32_t taosReadAllQitemsFromQset(STaosQset *qset, STaosQall *qall, SQueueInfo * queue->memOfItems = 0; uTrace("read %d items from queue:%p, items:0 mem:%" PRId64, code, queue, queue->memOfItems); - atomic_sub_fetch_32(&qset->numOfItems, qall->numOfItems); + (void)atomic_sub_fetch_32(&qset->numOfItems, qall->numOfItems); for (int32_t j = 1; j < qall->numOfItems; ++j) { - tsem_wait(&qset->sem); + (void)tsem_wait(&qset->sem); } } diff --git a/source/util/src/trbtree.c b/source/util/src/trbtree.c index e1000f7bc1..dddc2aea4b 100644 --- a/source/util/src/trbtree.c +++ b/source/util/src/trbtree.c @@ -412,7 +412,7 @@ void tRBTreeDrop(SRBTree *pTree, SRBTreeNode *z) { pTree->max = tRBTreePredecessor(pTree, pTree->max); } - rbtree_delete(pTree, z); + (void)rbtree_delete(pTree, z); pTree->n--; } diff --git a/source/util/src/tref.c b/source/util/src/tref.c index fe55335fce..f1d9a24757 100644 --- a/source/util/src/tref.c +++ b/source/util/src/tref.c @@ -63,7 +63,7 @@ int32_t taosOpenRef(int32_t max, RefFp fp) { int64_t *lockedBy; int32_t i, rsetId; - taosThreadOnce(&tsRefModuleInit, taosInitRefModule); + (void)taosThreadOnce(&tsRefModuleInit, taosInitRefModule); nodeList = taosMemoryCalloc(sizeof(SRefNode *), (size_t)max); if (nodeList == NULL) { @@ -450,7 +450,7 @@ static void taosLockList(int64_t *lockedBy) { int32_t i = 0; while (atomic_val_compare_exchange_64(lockedBy, 0, tid) != 0) { if (++i % 100 == 0) { - sched_yield(); + (void)sched_yield(); } } } @@ -462,10 +462,10 @@ static void taosUnlockList(int64_t *lockedBy) { } } -static void taosInitRefModule(void) { taosThreadMutexInit(&tsRefMutex, NULL); } +static void taosInitRefModule(void) { (void)taosThreadMutexInit(&tsRefMutex, NULL); } static void taosIncRsetCount(SRefSet *pSet) { - atomic_add_fetch_32(&pSet->count, 1); + (void)atomic_add_fetch_32(&pSet->count, 1); // uTrace("rsetId:%d inc count:%d", pSet->rsetId, count); } diff --git a/source/util/src/tskiplist.c b/source/util/src/tskiplist.c index 27e6fd6224..7fd09510bd 100644 --- a/source/util/src/tskiplist.c +++ b/source/util/src/tskiplist.c @@ -103,7 +103,7 @@ SSkipList *tSkipListCreate(uint8_t maxLevel, uint8_t keyType, uint16_t keyLen, _ void tSkipListDestroy(SSkipList *pSkipList) { if (pSkipList == NULL) return; - tSkipListWLock(pSkipList); + (void)tSkipListWLock(pSkipList); SSkipListNode *pNode = SL_NODE_GET_FORWARD_POINTER(pSkipList->pHead, 0); @@ -113,7 +113,7 @@ void tSkipListDestroy(SSkipList *pSkipList) { tSkipListFreeNode(pTemp); } - tSkipListUnlock(pSkipList); + (void)tSkipListUnlock(pSkipList); if (pSkipList->lock != NULL) { taosThreadRwlockDestroy(pSkipList->lock); taosMemoryFreeClear(pSkipList->lock); @@ -130,12 +130,12 @@ SSkipListNode *tSkipListPut(SSkipList *pSkipList, void *pData) { SSkipListNode *backward[MAX_SKIP_LIST_LEVEL] = {0}; SSkipListNode *pNode = NULL; - tSkipListWLock(pSkipList); + (void)tSkipListWLock(pSkipList); bool hasDup = tSkipListGetPosToPut(pSkipList, backward, pData); pNode = tSkipListPutImpl(pSkipList, pData, backward, false, hasDup); - tSkipListUnlock(pSkipList); + (void)tSkipListUnlock(pSkipList); return pNode; } @@ -293,11 +293,11 @@ SSkipListIterator *tSkipListCreateIterFromVal(SSkipList *pSkipList, const char * return iter; } - tSkipListRLock(pSkipList); + (void)tSkipListRLock(pSkipList); iter->cur = getPriorNode(pSkipList, val, order, &(iter->next)); - tSkipListUnlock(pSkipList); + (void)tSkipListUnlock(pSkipList); return iter; } @@ -307,13 +307,13 @@ bool tSkipListIterNext(SSkipListIterator *iter) { SSkipList *pSkipList = iter->pSkipList; - tSkipListRLock(pSkipList); + (void)tSkipListRLock(pSkipList); if (iter->order == TSDB_ORDER_ASC) { // no data in the skip list if (iter->cur == pSkipList->pTail || iter->next == NULL) { iter->cur = pSkipList->pTail; - tSkipListUnlock(pSkipList); + (void)tSkipListUnlock(pSkipList); return false; } @@ -329,7 +329,7 @@ bool tSkipListIterNext(SSkipListIterator *iter) { } else { if (iter->cur == pSkipList->pHead) { iter->cur = pSkipList->pHead; - tSkipListUnlock(pSkipList); + (void)tSkipListUnlock(pSkipList); return false; } @@ -344,7 +344,7 @@ bool tSkipListIterNext(SSkipListIterator *iter) { iter->step++; } - tSkipListUnlock(pSkipList); + (void)tSkipListUnlock(pSkipList); return (iter->order == TSDB_ORDER_ASC) ? (iter->cur != pSkipList->pTail) : (iter->cur != pSkipList->pHead); } diff --git a/source/util/src/tthread.c b/source/util/src/tthread.c index 17f49ea0a8..ee038f18f4 100644 --- a/source/util/src/tthread.c +++ b/source/util/src/tthread.c @@ -24,10 +24,10 @@ TdThread* taosCreateThread(void* (*__start_routine)(void*), void* param) { } TdThreadAttr thattr; - taosThreadAttrInit(&thattr); - taosThreadAttrSetDetachState(&thattr, PTHREAD_CREATE_JOINABLE); + (void)taosThreadAttrInit(&thattr); + (void)taosThreadAttrSetDetachState(&thattr, PTHREAD_CREATE_JOINABLE); int32_t ret = taosThreadCreate(pthread, &thattr, __start_routine, param); - taosThreadAttrDestroy(&thattr); + (void)taosThreadAttrDestroy(&thattr); if (ret != 0) { taosMemoryFree(pthread); @@ -40,8 +40,8 @@ TdThread* taosCreateThread(void* (*__start_routine)(void*), void* param) { bool taosDestroyThread(TdThread* pthread) { if (pthread == NULL) return false; if (taosThreadRunning(pthread)) { - taosThreadCancel(*pthread); - taosThreadJoin(*pthread, NULL); + (void)taosThreadCancel(*pthread); + (void)taosThreadJoin(*pthread, NULL); } taosMemoryFree(pthread); diff --git a/source/util/src/ttimer.c b/source/util/src/ttimer.c index 777eb23caa..6ade226cd8 100644 --- a/source/util/src/ttimer.c +++ b/source/util/src/ttimer.c @@ -138,7 +138,7 @@ static uintptr_t getNextTimerId() { return id; } -static void timerAddRef(tmr_obj_t* timer) { atomic_add_fetch_8(&timer->refCount, 1); } +static void timerAddRef(tmr_obj_t* timer) { (void)atomic_add_fetch_8(&timer->refCount, 1); } static void timerDecRef(tmr_obj_t* timer) { if (atomic_sub_fetch_8(&timer->refCount, 1) == 0) { @@ -151,7 +151,7 @@ static void lockTimerList(timer_list_t* list) { int32_t i = 0; while (atomic_val_compare_exchange_64(&(list->lockedBy), 0, tid) != 0) { if (++i % 1000 == 0) { - sched_yield(); + (void)sched_yield(); } } } @@ -314,7 +314,7 @@ static void addToExpired(tmr_obj_t* head) { schedMsg.msg = NULL; schedMsg.ahandle = head; schedMsg.thandle = NULL; - taosScheduleTask(tmrQhandle, &schedMsg); + (void)taosScheduleTask(tmrQhandle, &schedMsg); tmrDebug("timer[id=%" PRIuPTR "] has been added to queue.", id); head = next; @@ -458,7 +458,7 @@ bool taosTmrStop(tmr_h timerId) { } uint8_t state = atomic_val_compare_exchange_8(&timer->state, TIMER_STATE_WAITING, TIMER_STATE_CANCELED); - doStopTimer(timer, state); + (void)doStopTimer(timer, state); timerDecRef(timer); return state == TIMER_STATE_WAITING; @@ -501,7 +501,7 @@ bool taosTmrReset(TAOS_TMR_CALLBACK fp, int32_t mseconds, void* param, void* han // so that we can reuse this timer safely. for (int32_t i = 1; atomic_load_8(&timer->refCount) > 1; ++i) { if (i % 1000 == 0) { - sched_yield(); + (void)sched_yield(); } } @@ -528,7 +528,7 @@ static int32_t taosTmrModuleInit(void) { (tmrCtrls + tsMaxTmrCtrl - 1)->next = NULL; unusedTmrCtrl = tmrCtrls; - taosThreadMutexInit(&tmrCtrlMutex, NULL); + (void)taosThreadMutexInit(&tmrCtrlMutex, NULL); int64_t now = taosGetMonotonicMs(); for (int32_t i = 0; i < tListLen(wheels); i++) { @@ -555,7 +555,7 @@ static int32_t taosTmrModuleInit(void) { } tmrQhandle = taosInitScheduler(10000, taosTmrThreads, "tmr", NULL); - taosInitTimer(taosTimerLoopFunc, MSECONDS_PER_TICK); + (void)taosInitTimer(taosTimerLoopFunc, MSECONDS_PER_TICK); tmrDebug("timer module is initialized, number of threads: %d", taosTmrThreads); @@ -638,11 +638,11 @@ void taosTmrCleanUp(void* handle) { for (int32_t i = 0; i < tListLen(wheels); i++) { time_wheel_t* wheel = wheels + i; - taosThreadMutexDestroy(&wheel->mutex); + (void)taosThreadMutexDestroy(&wheel->mutex); taosMemoryFree(wheel->slots); } - taosThreadMutexDestroy(&tmrCtrlMutex); + (void)taosThreadMutexDestroy(&tmrCtrlMutex); for (size_t i = 0; i < timerMap.size; i++) { timer_list_t* list = timerMap.slots + i; diff --git a/source/util/src/tworker.c b/source/util/src/tworker.c index 885813f527..9dad69e0b4 100644 --- a/source/util/src/tworker.c +++ b/source/util/src/tworker.c @@ -58,15 +58,15 @@ void tQWorkerCleanup(SQWorkerPool *pool) { SQueueWorker *worker = pool->workers + i; if (taosCheckPthreadValid(worker->thread)) { uInfo("worker:%s:%d is stopping", pool->name, worker->id); - taosThreadJoin(worker->thread, NULL); - taosThreadClear(&worker->thread); + (void)taosThreadJoin(worker->thread, NULL); + (void)taosThreadClear(&worker->thread); uInfo("worker:%s:%d is stopped", pool->name, worker->id); } } taosMemoryFreeClear(pool->workers); taosCloseQset(pool->qset); - taosThreadMutexDestroy(&pool->mutex); + (void)taosThreadMutexDestroy(&pool->mutex); uInfo("worker:%s is closed", pool->name); } @@ -77,7 +77,7 @@ static void *tQWorkerThreadFp(SQueueWorker *worker) { void *msg = NULL; int32_t code = 0; - taosBlockSIGPIPE(); + (void)taosBlockSIGPIPE(); setThreadName(pool->name); worker->pid = taosGetSelfPthreadId(); uInfo("worker:%s:%d is running, thread:%08" PRId64, pool->name, worker->id, worker->pid); @@ -122,7 +122,7 @@ STaosQueue *tQWorkerAllocQueue(SQWorkerPool *pool, void *ahandle, FItem fp) { (void)taosThreadMutexLock(&pool->mutex); taosSetQueueFp(queue, fp, NULL); - taosAddIntoQset(pool->qset, queue, ahandle); + (void)taosAddIntoQset(pool->qset, queue, ahandle); // spawn a thread to process queue if (pool->num < pool->max) { @@ -130,8 +130,8 @@ STaosQueue *tQWorkerAllocQueue(SQWorkerPool *pool, void *ahandle, FItem fp) { SQueueWorker *worker = pool->workers + pool->num; TdThreadAttr thAttr; - taosThreadAttrInit(&thAttr); - taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE); + (void)taosThreadAttrInit(&thAttr); + (void)taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE); if (taosThreadCreate(&worker->thread, &thAttr, (ThreadFp)tQWorkerThreadFp, worker) != 0) { taosCloseQueue(queue); @@ -140,7 +140,7 @@ STaosQueue *tQWorkerAllocQueue(SQWorkerPool *pool, void *ahandle, FItem fp) { break; } - taosThreadAttrDestroy(&thAttr); + (void)taosThreadAttrDestroy(&thAttr); pool->num++; uInfo("worker:%s:%d is launched, total:%d", pool->name, worker->id, pool->num); } while (pool->num < pool->min); @@ -190,8 +190,8 @@ void tAutoQWorkerCleanup(SAutoQWorkerPool *pool) { SQueueWorker *worker = taosArrayGetP(pool->workers, i); if (taosCheckPthreadValid(worker->thread)) { uInfo("worker:%s:%d is stopping", pool->name, worker->id); - taosThreadJoin(worker->thread, NULL); - taosThreadClear(&worker->thread); + (void)taosThreadJoin(worker->thread, NULL); + (void)taosThreadClear(&worker->thread); uInfo("worker:%s:%d is stopped", pool->name, worker->id); } taosMemoryFree(worker); @@ -199,7 +199,7 @@ void tAutoQWorkerCleanup(SAutoQWorkerPool *pool) { taosArrayDestroy(pool->workers); taosCloseQset(pool->qset); - taosThreadMutexDestroy(&pool->mutex); + (void)taosThreadMutexDestroy(&pool->mutex); uInfo("worker:%s is closed", pool->name); } @@ -210,7 +210,7 @@ static void *tAutoQWorkerThreadFp(SQueueWorker *worker) { void *msg = NULL; int32_t code = 0; - taosBlockSIGPIPE(); + (void)taosBlockSIGPIPE(); setThreadName(pool->name); worker->pid = taosGetSelfPthreadId(); uInfo("worker:%s:%d is running, thread:%08" PRId64, pool->name, worker->id, worker->pid); @@ -253,7 +253,7 @@ STaosQueue *tAutoQWorkerAllocQueue(SAutoQWorkerPool *pool, void *ahandle, FItem (void)taosThreadMutexLock(&pool->mutex); taosSetQueueFp(queue, fp, NULL); - taosAddIntoQset(pool->qset, queue, ahandle); + (void)taosAddIntoQset(pool->qset, queue, ahandle); int32_t queueNum = taosGetQueueNumber(pool->qset); int32_t curWorkerNum = taosArrayGetSize(pool->workers); @@ -275,8 +275,8 @@ STaosQueue *tAutoQWorkerAllocQueue(SAutoQWorkerPool *pool, void *ahandle, FItem worker->pool = pool; TdThreadAttr thAttr; - taosThreadAttrInit(&thAttr); - taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE); + (void)taosThreadAttrInit(&thAttr); + (void)taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE); if (taosThreadCreate(&worker->thread, &thAttr, (ThreadFp)tAutoQWorkerThreadFp, worker) != 0) { uError("worker:%s:%d failed to create thread, total:%d", pool->name, worker->id, curWorkerNum); @@ -287,7 +287,7 @@ STaosQueue *tAutoQWorkerAllocQueue(SAutoQWorkerPool *pool, void *ahandle, FItem return NULL; } - taosThreadAttrDestroy(&thAttr); + (void)taosThreadAttrDestroy(&thAttr); int32_t numOfThreads = taosArrayGetSize(pool->workers); uInfo("worker:%s:%d is launched, total:%d, expect:%d", pool->name, worker->id, numOfThreads, dstWorkerNum); @@ -340,8 +340,8 @@ void tWWorkerCleanup(SWWorkerPool *pool) { SWWorker *worker = pool->workers + i; if (taosCheckPthreadValid(worker->thread)) { uInfo("worker:%s:%d is stopping", pool->name, worker->id); - taosThreadJoin(worker->thread, NULL); - taosThreadClear(&worker->thread); + (void)taosThreadJoin(worker->thread, NULL); + (void)taosThreadClear(&worker->thread); taosFreeQall(worker->qall); taosCloseQset(worker->qset); uInfo("worker:%s:%d is stopped", pool->name, worker->id); @@ -349,7 +349,7 @@ void tWWorkerCleanup(SWWorkerPool *pool) { } taosMemoryFreeClear(pool->workers); - taosThreadMutexDestroy(&pool->mutex); + (void)taosThreadMutexDestroy(&pool->mutex); uInfo("worker:%s is closed", pool->name); } @@ -361,7 +361,7 @@ static void *tWWorkerThreadFp(SWWorker *worker) { int32_t code = 0; int32_t numOfMsgs = 0; - taosBlockSIGPIPE(); + (void)taosBlockSIGPIPE(); setThreadName(pool->name); worker->pid = taosGetSelfPthreadId(); uInfo("worker:%s:%d is running, thread:%08" PRId64, pool->name, worker->id, worker->pid); @@ -406,23 +406,23 @@ STaosQueue *tWWorkerAllocQueue(SWWorkerPool *pool, void *ahandle, FItems fp) { code = taosOpenQset(&worker->qset); if (code) goto _OVER; - taosAddIntoQset(worker->qset, queue, ahandle); + (void)taosAddIntoQset(worker->qset, queue, ahandle); code = taosAllocateQall(&worker->qall); if (code) goto _OVER; TdThreadAttr thAttr; - taosThreadAttrInit(&thAttr); - taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE); + (void)taosThreadAttrInit(&thAttr); + (void)taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE); if (taosThreadCreate(&worker->thread, &thAttr, (ThreadFp)tWWorkerThreadFp, worker) != 0) goto _OVER; uInfo("worker:%s:%d is launched, max:%d", pool->name, worker->id, pool->max); pool->nextId = (pool->nextId + 1) % pool->max; - taosThreadAttrDestroy(&thAttr); + (void)taosThreadAttrDestroy(&thAttr); pool->num++; if (pool->num > pool->max) pool->num = pool->max; } else { - taosAddIntoQset(worker->qset, queue, ahandle); + (void)taosAddIntoQset(worker->qset, queue, ahandle); pool->nextId = (pool->nextId + 1) % pool->max; } @@ -628,7 +628,7 @@ static void *tQueryAutoQWorkerThreadFp(SQueryAutoQWorker *worker) { void *msg = NULL; int32_t code = 0; - taosBlockSIGPIPE(); + (void)taosBlockSIGPIPE(); setThreadName(pool->name); worker->pid = taosGetSelfPthreadId(); uDebug("worker:%s:%d is running, thread:%08" PRId64, pool->name, worker->id, worker->pid); @@ -647,7 +647,7 @@ static void *tQueryAutoQWorkerThreadFp(SQueryAutoQWorker *worker) { } } - tQueryAutoQWorkerWaitingCheck(pool); + (void)tQueryAutoQWorkerWaitingCheck(pool); if (qinfo.fp != NULL) { qinfo.workerId = worker->id; @@ -676,7 +676,7 @@ static bool tQueryAutoQWorkerTrySignalWaitingAfterBlock(void *p) { int32_t waitingNew = atomic_val_compare_exchange_32(&pPool->waitingAfterBlockN, waiting, waiting - 1); if (waitingNew == waiting) { (void)taosThreadMutexLock(&pPool->waitingAfterBlockLock); - taosThreadCondSignal(&pPool->waitingAfterBlockCond); + (void)taosThreadCondSignal(&pPool->waitingAfterBlockCond); (void)taosThreadMutexUnlock(&pPool->waitingAfterBlockLock); ret = true; break; @@ -694,7 +694,7 @@ static bool tQueryAutoQWorkerTrySignalWaitingBeforeProcess(void *p) { int32_t waitingNew = atomic_val_compare_exchange_32(&pPool->waitingBeforeProcessMsgN, waiting, waiting - 1); if (waitingNew == waiting) { (void)taosThreadMutexLock(&pPool->waitingBeforeProcessMsgLock); - taosThreadCondSignal(&pPool->waitingBeforeProcessMsgCond); + (void)taosThreadCondSignal(&pPool->waitingBeforeProcessMsgCond); (void)taosThreadMutexUnlock(&pPool->waitingBeforeProcessMsgLock); ret = true; break; @@ -733,7 +733,7 @@ static int32_t tQueryAutoQWorkerWaitingCheck(SQueryAutoQWorkerPool *pPool) { // to wait for process (void)taosThreadMutexLock(&pPool->waitingBeforeProcessMsgLock); atomic_fetch_add_32(&pPool->waitingBeforeProcessMsgN, 1); - if (!pPool->exit) taosThreadCondWait(&pPool->waitingBeforeProcessMsgCond, &pPool->waitingBeforeProcessMsgLock); + if (!pPool->exit) (void)taosThreadCondWait(&pPool->waitingBeforeProcessMsgCond, &pPool->waitingBeforeProcessMsgLock); // recovered from waiting (void)taosThreadMutexUnlock(&pPool->waitingBeforeProcessMsgLock); return TSDB_CODE_SUCCESS; @@ -751,8 +751,8 @@ bool tQueryAutoQWorkerTryRecycleWorker(SQueryAutoQWorkerPool *pPool, SQueryAutoQ SListNode *head = tdListPopHead(pPool->exitedWorkers); SQueryAutoQWorker *pWorker = (SQueryAutoQWorker *)head->data; if (pWorker && taosCheckPthreadValid(pWorker->thread)) { - taosThreadJoin(pWorker->thread, NULL); - taosThreadClear(&pWorker->thread); + (void)taosThreadJoin(pWorker->thread, NULL); + (void)taosThreadClear(&pWorker->thread); } taosMemoryFree(head); } @@ -768,7 +768,7 @@ bool tQueryAutoQWorkerTryRecycleWorker(SQueryAutoQWorkerPool *pPool, SQueryAutoQ // start to wait at backup cond (void)taosThreadMutexLock(&pPool->backupLock); atomic_fetch_add_32(&pPool->backupNum, 1); - if (!pPool->exit) taosThreadCondWait(&pPool->backupCond, &pPool->backupLock); + if (!pPool->exit) (void)taosThreadCondWait(&pPool->backupCond, &pPool->backupLock); (void)taosThreadMutexUnlock(&pPool->backupLock); // recovered from backup @@ -832,15 +832,15 @@ void tQueryAutoQWorkerCleanup(SQueryAutoQWorkerPool *pPool) { (void)taosThreadMutexUnlock(&pPool->poolLock); (void)taosThreadMutexLock(&pPool->backupLock); - taosThreadCondBroadcast(&pPool->backupCond); + (void)taosThreadCondBroadcast(&pPool->backupCond); (void)taosThreadMutexUnlock(&pPool->backupLock); (void)taosThreadMutexLock(&pPool->waitingAfterBlockLock); - taosThreadCondBroadcast(&pPool->waitingAfterBlockCond); + (void)taosThreadCondBroadcast(&pPool->waitingAfterBlockCond); (void)taosThreadMutexUnlock(&pPool->waitingAfterBlockLock); (void)taosThreadMutexLock(&pPool->waitingBeforeProcessMsgLock); - taosThreadCondBroadcast(&pPool->waitingBeforeProcessMsgCond); + (void)taosThreadCondBroadcast(&pPool->waitingBeforeProcessMsgCond); (void)taosThreadMutexUnlock(&pPool->waitingBeforeProcessMsgLock); int32_t idx = 0; @@ -855,8 +855,8 @@ void tQueryAutoQWorkerCleanup(SQueryAutoQWorkerPool *pPool) { worker = (SQueryAutoQWorker *)pNode->data; (void)taosThreadMutexUnlock(&pPool->poolLock); if (worker && taosCheckPthreadValid(worker->thread)) { - taosThreadJoin(worker->thread, NULL); - taosThreadClear(&worker->thread); + (void)taosThreadJoin(worker->thread, NULL); + (void)taosThreadClear(&worker->thread); } taosMemoryFree(pNode); } @@ -865,8 +865,8 @@ void tQueryAutoQWorkerCleanup(SQueryAutoQWorkerPool *pPool) { SListNode *pNode = tdListPopHead(pPool->backupWorkers); worker = (SQueryAutoQWorker *)pNode->data; if (worker && taosCheckPthreadValid(worker->thread)) { - taosThreadJoin(worker->thread, NULL); - taosThreadClear(&worker->thread); + (void)taosThreadJoin(worker->thread, NULL); + (void)taosThreadClear(&worker->thread); } taosMemoryFree(pNode); } @@ -875,8 +875,8 @@ void tQueryAutoQWorkerCleanup(SQueryAutoQWorkerPool *pPool) { SListNode *pNode = tdListPopHead(pPool->exitedWorkers); worker = (SQueryAutoQWorker *)pNode->data; if (worker && taosCheckPthreadValid(worker->thread)) { - taosThreadJoin(worker->thread, NULL); - taosThreadClear(&worker->thread); + (void)taosThreadJoin(worker->thread, NULL); + (void)taosThreadClear(&worker->thread); } taosMemoryFree(pNode); } @@ -886,14 +886,14 @@ void tQueryAutoQWorkerCleanup(SQueryAutoQWorkerPool *pPool) { tdListFree(pPool->exitedWorkers); taosMemoryFree(pPool->pCb); - taosThreadMutexDestroy(&pPool->poolLock); - taosThreadMutexDestroy(&pPool->backupLock); - taosThreadMutexDestroy(&pPool->waitingAfterBlockLock); - taosThreadMutexDestroy(&pPool->waitingBeforeProcessMsgLock); + (void)taosThreadMutexDestroy(&pPool->poolLock); + (void)taosThreadMutexDestroy(&pPool->backupLock); + (void)taosThreadMutexDestroy(&pPool->waitingAfterBlockLock); + (void)taosThreadMutexDestroy(&pPool->waitingBeforeProcessMsgLock); - taosThreadCondDestroy(&pPool->backupCond); - taosThreadCondDestroy(&pPool->waitingAfterBlockCond); - taosThreadCondDestroy(&pPool->waitingBeforeProcessMsgCond); + (void)taosThreadCondDestroy(&pPool->backupCond); + (void)taosThreadCondDestroy(&pPool->waitingAfterBlockCond); + (void)taosThreadCondDestroy(&pPool->waitingBeforeProcessMsgCond); taosCloseQset(pPool->qset); } @@ -907,7 +907,7 @@ STaosQueue *tQueryAutoQWorkerAllocQueue(SQueryAutoQWorkerPool *pool, void *ahand (void)taosThreadMutexLock(&pool->poolLock); taosSetQueueFp(queue, fp, NULL); - taosAddIntoQset(pool->qset, queue, ahandle); + (void)taosAddIntoQset(pool->qset, queue, ahandle); SQueryAutoQWorker worker = {0}; SQueryAutoQWorker *pWorker = NULL; @@ -927,8 +927,8 @@ STaosQueue *tQueryAutoQWorkerAllocQueue(SQueryAutoQWorkerPool *pool, void *ahand pWorker = (SQueryAutoQWorker *)pNode->data; TdThreadAttr thAttr; - taosThreadAttrInit(&thAttr); - taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE); + (void)taosThreadAttrInit(&thAttr); + (void)taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE); if (taosThreadCreate(&pWorker->thread, &thAttr, (ThreadFp)tQueryAutoQWorkerThreadFp, pWorker) != 0) { taosCloseQueue(queue); @@ -937,7 +937,7 @@ STaosQueue *tQueryAutoQWorkerAllocQueue(SQueryAutoQWorkerPool *pool, void *ahand break; } - taosThreadAttrDestroy(&thAttr); + (void)taosThreadAttrDestroy(&thAttr); pool->num++; atomicFetchAddActive(&pool->activeRunningN, 1); uInfo("worker:%s:%d is launched, total:%d", pool->name, pWorker->id, pool->num); @@ -958,7 +958,7 @@ static int32_t tQueryAutoQWorkerAddWorker(SQueryAutoQWorkerPool *pool) { while (backup > 0) { int32_t backupNew = atomic_val_compare_exchange_32(&pool->backupNum, backup, backup - 1); if (backupNew == backup) { - taosThreadCondSignal(&pool->backupCond); + (void)taosThreadCondSignal(&pool->backupCond); return TSDB_CODE_SUCCESS; } backup = backupNew; @@ -980,14 +980,14 @@ static int32_t tQueryAutoQWorkerAddWorker(SQueryAutoQWorkerPool *pool) { pWorker = (SQueryAutoQWorker *)pNode->data; TdThreadAttr thAttr; - taosThreadAttrInit(&thAttr); - taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE); + (void)taosThreadAttrInit(&thAttr); + (void)taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE); if (taosThreadCreate(&pWorker->thread, &thAttr, (ThreadFp)tQueryAutoQWorkerThreadFp, pWorker) != 0) { terrno = TSDB_CODE_OUT_OF_MEMORY; return terrno; } - taosThreadAttrDestroy(&thAttr); + (void)taosThreadAttrDestroy(&thAttr); return TSDB_CODE_SUCCESS; } @@ -1017,7 +1017,7 @@ static int32_t tQueryAutoQWorkerRecoverFromBlocking(void *p) { } (void)taosThreadMutexLock(&pPool->waitingAfterBlockLock); atomic_fetch_add_32(&pPool->waitingAfterBlockN, 1); - if (!pPool->exit) taosThreadCondWait(&pPool->waitingAfterBlockCond, &pPool->waitingAfterBlockLock); + if (!pPool->exit) (void)taosThreadCondWait(&pPool->waitingAfterBlockCond, &pPool->waitingAfterBlockLock); (void)taosThreadMutexUnlock(&pPool->waitingAfterBlockLock); if (pPool->exit) return TSDB_CODE_QRY_QWORKER_QUIT; return TSDB_CODE_SUCCESS; From a30ec9fb8285b8fc185654f7b97ecf9b59f4a5d7 Mon Sep 17 00:00:00 2001 From: dmchen Date: Mon, 29 Jul 2024 12:31:07 +0000 Subject: [PATCH 24/28] fix case --- source/dnode/mnode/impl/src/mndStb.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/source/dnode/mnode/impl/src/mndStb.c b/source/dnode/mnode/impl/src/mndStb.c index 89fd0268f8..3204c70db5 100644 --- a/source/dnode/mnode/impl/src/mndStb.c +++ b/source/dnode/mnode/impl/src/mndStb.c @@ -2916,7 +2916,8 @@ static int32_t mndProcessDropStbReq(SRpcMsg *pReq) { if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS; SName name = {0}; - TAOS_CHECK_GOTO(tNameFromString(&name, dropReq.name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE), NULL, _OVER); + // TODO check return value + (void)tNameFromString(&name, dropReq.name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); auditRecord(pReq, pMnode->clusterId, "dropStb", name.dbname, name.tname, dropReq.sql, dropReq.sqlLen); From 02d46c0550a1486dd52e080705a2079dfa3bc5e3 Mon Sep 17 00:00:00 2001 From: yihaoDeng Date: Mon, 29 Jul 2024 21:36:10 +0800 Subject: [PATCH 25/28] fix return code --- source/libs/index/inc/indexUtil.h | 2 +- source/libs/index/src/index.c | 58 +++---- source/libs/index/src/indexCache.c | 64 ++++---- source/libs/index/src/indexComm.c | 55 ++++++- source/libs/index/src/indexFilter.c | 14 +- source/libs/index/src/indexFst.c | 112 +++++++------- source/libs/index/src/indexFstDfa.c | 18 +-- source/libs/index/src/indexFstFile.c | 16 +- source/libs/index/src/indexFstNode.c | 4 +- source/libs/index/src/indexFstRegex.c | 12 +- source/libs/index/src/indexFstRegister.c | 2 +- source/libs/index/src/indexFstUtil.c | 4 +- source/libs/index/src/indexTfile.c | 46 +++--- source/libs/index/src/indexUtil.c | 12 +- source/libs/transport/src/thttp.c | 40 ++--- source/libs/transport/src/tmsgcb.c | 4 +- source/libs/transport/src/trans.c | 6 +- source/libs/transport/src/transCli.c | 186 +++++++++++------------ source/libs/transport/src/transComm.c | 30 ++-- source/libs/transport/src/transSvr.c | 94 ++++++------ 20 files changed, 416 insertions(+), 363 deletions(-) diff --git a/source/libs/index/inc/indexUtil.h b/source/libs/index/inc/indexUtil.h index 308e213ac9..6b016900c2 100644 --- a/source/libs/index/inc/indexUtil.h +++ b/source/libs/index/inc/indexUtil.h @@ -55,7 +55,7 @@ extern "C" { } \ } \ if (f == false) { \ - taosArrayPush(dst, &tgt); \ + (void)taosArrayPush(dst, &tgt); \ } \ } diff --git a/source/libs/index/src/index.c b/source/libs/index/src/index.c index fad04798a8..480a2ff59f 100644 --- a/source/libs/index/src/index.c +++ b/source/libs/index/src/index.c @@ -74,7 +74,7 @@ void indexCleanup() { // refacto later taosCleanUpScheduler(indexQhandle); taosMemoryFreeClear(indexQhandle); - taosCloseRef(indexRefMgt); + (void)taosCloseRef(indexRefMgt); } typedef struct SIdxColInfo { @@ -99,15 +99,15 @@ static void idxMergeCacheAndTFile(SArray* result, IterateValue* icache, IterateV static void idxPost(void* idx) { SIndex* pIdx = idx; - tsem_post(&pIdx->sem); + (void)tsem_post(&pIdx->sem); } static void indexWait(void* idx) { SIndex* pIdx = idx; - tsem_wait(&pIdx->sem); + (void)tsem_wait(&pIdx->sem); } int32_t indexOpen(SIndexOpts* opts, const char* path, SIndex** index) { - taosThreadOnce(&isInit, indexEnvInit); + (void)taosThreadOnce(&isInit, indexEnvInit); int code = TSDB_CODE_SUCCESS; SIndex* idx = taosMemoryCalloc(1, sizeof(SIndex)); @@ -137,8 +137,8 @@ int32_t indexOpen(SIndexOpts* opts, const char* path, SIndex** index) { TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, NULL, END); } - taosThreadMutexInit(&idx->mtx, NULL); - tsem_init(&idx->sem, 0, 0); + (void)taosThreadMutexInit(&idx->mtx, NULL); + (void)tsem_init(&idx->sem, 0, 0); idx->refId = idxAddRef(idx); idx->opts = *opts; @@ -158,8 +158,8 @@ END: void indexDestroy(void* handle) { if (handle == NULL) return; SIndex* idx = handle; - taosThreadMutexDestroy(&idx->mtx); - tsem_destroy(&idx->sem); + (void)taosThreadMutexDestroy(&idx->mtx); + (void)tsem_destroy(&idx->sem); idxTFileDestroy(idx->tindex); taosMemoryFree(idx->path); @@ -190,7 +190,7 @@ void indexClose(SIndex* sIdx) { } idxReleaseRef(sIdx->refId); - idxRemoveRef(sIdx->refId); + (void)idxRemoveRef(sIdx->refId); } int64_t idxAddRef(void* p) { // impl @@ -203,16 +203,16 @@ int32_t idxRemoveRef(int64_t ref) { void idxAcquireRef(int64_t ref) { // impl - taosAcquireRef(indexRefMgt, ref); + (void)taosAcquireRef(indexRefMgt, ref); } void idxReleaseRef(int64_t ref) { // impl - taosReleaseRef(indexRefMgt, ref); + (void)taosReleaseRef(indexRefMgt, ref); } int32_t indexPut(SIndex* index, SIndexMultiTerm* fVals, uint64_t uid) { // TODO(yihao): reduce the lock range - taosThreadMutexLock(&index->mtx); + (void)taosThreadMutexLock(&index->mtx); for (int i = 0; i < taosArrayGetSize(fVals); i++) { SIndexTerm* p = taosArrayGetP(fVals, i); @@ -223,10 +223,10 @@ int32_t indexPut(SIndex* index, SIndexMultiTerm* fVals, uint64_t uid) { IndexCache** cache = taosHashGet(index->colObj, buf, sz); if (cache == NULL) { IndexCache* pCache = idxCacheCreate(index, p->suid, p->colName, p->colType); - taosHashPut(index->colObj, buf, sz, &pCache, sizeof(void*)); + (void)taosHashPut(index->colObj, buf, sz, &pCache, sizeof(void*)); } } - taosThreadMutexUnlock(&index->mtx); + (void)taosThreadMutexUnlock(&index->mtx); for (int i = 0; i < taosArrayGetSize(fVals); i++) { SIndexTerm* p = taosArrayGetP(fVals, i); @@ -255,8 +255,8 @@ int32_t indexSearch(SIndex* index, SIndexMultiTermQuery* multiQuerys, SArray* re for (size_t i = 0; i < nQuery; i++) { SIndexTermQuery* qterm = taosArrayGet(multiQuerys->query, i); SArray* trslt = NULL; - idxTermSearch(index, qterm, &trslt); - taosArrayPush(iRslts, (void*)&trslt); + (void)idxTermSearch(index, qterm, &trslt); + (void)taosArrayPush(iRslts, (void*)&trslt); } idxMergeFinalResults(iRslts, opera, result); idxInterRsltDestroy(iRslts); @@ -295,7 +295,7 @@ void indexMultiTermQueryDestroy(SIndexMultiTermQuery* pQuery) { }; int32_t indexMultiTermQueryAdd(SIndexMultiTermQuery* pQuery, SIndexTerm* term, EIndexQueryType qType) { SIndexTermQuery q = {.qType = qType, .term = term}; - taosArrayPush(pQuery->query, &q); + (void)taosArrayPush(pQuery->query, &q); return 0; } @@ -341,7 +341,7 @@ void indexTermDestroy(SIndexTerm* p) { SIndexMultiTerm* indexMultiTermCreate() { return taosArrayInit(4, sizeof(SIndexTerm*)); } int32_t indexMultiTermAdd(SIndexMultiTerm* terms, SIndexTerm* term) { - taosArrayPush(terms, &term); + (void)taosArrayPush(terms, &term); return 0; } void indexMultiTermDestroy(SIndexMultiTerm* terms) { @@ -374,7 +374,7 @@ void indexRebuild(SIndexJson* idx, void* iter) { schedMsg.fp = idxSchedRebuildIdx; schedMsg.ahandle = idx; idxAcquireRef(idx->refId); - taosScheduleTask(indexQhandle, &schedMsg); + (void)taosScheduleTask(indexQhandle, &schedMsg); } /* @@ -415,10 +415,10 @@ static int32_t idxTermSearch(SIndex* sIdx, SIndexTermQuery* query, SArray** resu int32_t sz = idxSerialCacheKey(&key, buf); - taosThreadMutexLock(&sIdx->mtx); + (void)taosThreadMutexLock(&sIdx->mtx); IndexCache** pCache = taosHashGet(sIdx->colObj, buf, sz); cache = (pCache == NULL) ? NULL : *pCache; - taosThreadMutexUnlock(&sIdx->mtx); + (void)taosThreadMutexUnlock(&sIdx->mtx); *result = taosArrayInit(4, sizeof(uint64_t)); if (*result == NULL) { @@ -501,7 +501,7 @@ static void idxMayMergeTempToFinalRslt(SArray* result, TFileValue* tfv, SIdxTRsl idxTRsltMergeTo(tr, lv->tableId); idxTRsltClear(tr); - taosArrayPush(result, &tfv); + (void)taosArrayPush(result, &tfv); } else if (tfv == NULL) { // handle last iterator idxTRsltMergeTo(tr, lv->tableId); @@ -509,7 +509,7 @@ static void idxMayMergeTempToFinalRslt(SArray* result, TFileValue* tfv, SIdxTRsl tfileValueDestroy(tfv); } } else { - taosArrayPush(result, &tfv); + (void)taosArrayPush(result, &tfv); } } static void idxMergeCacheAndTFile(SArray* result, IterateValue* cv, IterateValue* tv, SIdxTRslt* tr) { @@ -528,7 +528,7 @@ static void idxMergeCacheAndTFile(SArray* result, IterateValue* cv, IterateValue } } if (tv != NULL) { - taosArrayAddAll(tr->total, tv->val); + (void)taosArrayAddAll(tr->total, tv->val); } } static void idxDestroyFinalRslt(SArray* result) { @@ -655,9 +655,9 @@ static int64_t idxGetAvailableVer(SIndex* sIdx, IndexCache* cache) { IndexTFile* tf = (IndexTFile*)(sIdx->tindex); - taosThreadMutexLock(&tf->mtx); + (void)taosThreadMutexLock(&tf->mtx); TFileReader* rd = tfileCacheGet(tf->cache, &key); - taosThreadMutexUnlock(&tf->mtx); + (void)taosThreadMutexUnlock(&tf->mtx); if (rd != NULL) { ver = (ver > rd->header.version ? ver : rd->header.version) + 1; @@ -698,9 +698,9 @@ static int32_t idxGenTFile(SIndex* sIdx, IndexCache* cache, SArray* batch) { TFileHeader* header = &reader->header; ICacheKey key = {.suid = cache->suid, .colName = header->colName, .nColName = strlen(header->colName)}; - taosThreadMutexLock(&tf->mtx); + (void)taosThreadMutexLock(&tf->mtx); code = tfileCachePut(tf->cache, &key, reader); - taosThreadMutexUnlock(&tf->mtx); + (void)taosThreadMutexUnlock(&tf->mtx); return code; @@ -717,7 +717,7 @@ int32_t idxSerialCacheKey(ICacheKey* key, char* buf) { char* p = buf; char tbuf[65] = {0}; - idxInt2str((int64_t)key->suid, tbuf, 0); + (void)idxInt2str((int64_t)key->suid, tbuf, 0); SERIALIZE_STR_VAR_TO_BUF(buf, tbuf, strlen(tbuf)); SERIALIZE_VAR_TO_BUF(buf, '_', char); diff --git a/source/libs/index/src/indexCache.c b/source/libs/index/src/indexCache.c index f2aefcfc41..56d2c865f3 100644 --- a/source/libs/index/src/indexCache.c +++ b/source/libs/index/src/indexCache.c @@ -104,7 +104,7 @@ static int32_t cacheSearchTerm(void* cache, SIndexTerm* term, SIdxTRslt* tr, STe } taosMemoryFree(pCt); - tSkipListDestroyIter(iter); + (void)tSkipListDestroyIter(iter); return 0; } static int32_t cacheSearchPrefix(void* cache, SIndexTerm* term, SIdxTRslt* tr, STermValueType* s) { @@ -162,7 +162,7 @@ static int32_t cacheSearchCompareFunc(void* cache, SIndexTerm* term, SIdxTRslt* } } taosMemoryFree(pCt); - tSkipListDestroyIter(iter); + (void)tSkipListDestroyIter(iter); return TSDB_CODE_SUCCESS; } static int32_t cacheSearchLessThan(void* cache, SIndexTerm* term, SIdxTRslt* tr, STermValueType* s) { @@ -222,7 +222,7 @@ static int32_t cacheSearchTerm_JSON(void* cache, SIndexTerm* term, SIdxTRslt* tr taosMemoryFree(pCt); taosMemoryFree(exBuf); - tSkipListDestroyIter(iter); + (void)tSkipListDestroyIter(iter); return 0; return TSDB_CODE_SUCCESS; @@ -329,7 +329,7 @@ static int32_t cacheSearchCompareFunc_JSON(void* cache, SIndexTerm* term, SIdxTR taosMemoryFree(pCt); taosMemoryFree(exBuf); - tSkipListDestroyIter(iter); + (void)tSkipListDestroyIter(iter); return TSDB_CODE_SUCCESS; } @@ -356,8 +356,8 @@ IndexCache* idxCacheCreate(SIndex* idx, uint64_t suid, const char* colName, int8 cache->suid = suid; cache->occupiedMem = 0; - taosThreadMutexInit(&cache->mtx, NULL); - taosThreadCondInit(&cache->finished, NULL); + (void)taosThreadMutexInit(&cache->mtx, NULL); + (void)taosThreadCondInit(&cache->finished, NULL); idxCacheRef(cache); if (idx != NULL) { @@ -368,10 +368,10 @@ IndexCache* idxCacheCreate(SIndex* idx, uint64_t suid, const char* colName, int8 void idxCacheDebug(IndexCache* cache) { MemTable* tbl = NULL; - taosThreadMutexLock(&cache->mtx); + (void)taosThreadMutexLock(&cache->mtx); tbl = cache->mem; idxMemRef(tbl); - taosThreadMutexUnlock(&cache->mtx); + (void)taosThreadMutexUnlock(&cache->mtx); { SSkipList* slt = tbl->mem; @@ -384,7 +384,7 @@ void idxCacheDebug(IndexCache* cache) { indexInfo("{colVal: %s, version: %" PRId64 "} \t", ct->colVal, ct->version); } } - tSkipListDestroyIter(iter); + (void)tSkipListDestroyIter(iter); idxMemUnRef(tbl); } @@ -405,7 +405,7 @@ void idxCacheDebug(IndexCache* cache) { indexInfo("{colVal: %s, version: %" PRId64 "} \t", ct->colVal, ct->version); } } - tSkipListDestroyIter(iter); + (void)tSkipListDestroyIter(iter); } idxMemUnRef(tbl); @@ -422,16 +422,16 @@ void idxCacheDestroySkiplist(SSkipList* slt) { taosMemoryFree(ct); } } - tSkipListDestroyIter(iter); + (void)tSkipListDestroyIter(iter); tSkipListDestroy(slt); } void idxCacheBroadcast(void* cache) { IndexCache* pCache = cache; - taosThreadCondBroadcast(&pCache->finished); + (void)taosThreadCondBroadcast(&pCache->finished); } void idxCacheWait(void* cache) { IndexCache* pCache = cache; - taosThreadCondWait(&pCache->finished, &pCache->mtx); + (void)taosThreadCondWait(&pCache->finished, &pCache->mtx); } void idxCacheDestroyImm(IndexCache* cache) { if (cache == NULL) { @@ -444,7 +444,7 @@ void idxCacheDestroyImm(IndexCache* cache) { cache->imm = NULL; // or throw int bg thread idxCacheBroadcast(cache); - taosThreadMutexUnlock(&cache->mtx); + (void)taosThreadMutexUnlock(&cache->mtx); idxMemUnRef(tbl); idxMemUnRef(tbl); @@ -459,8 +459,8 @@ void idxCacheDestroy(void* cache) { idxMemUnRef(pCache->imm); taosMemoryFree(pCache->colName); - taosThreadMutexDestroy(&pCache->mtx); - taosThreadCondDestroy(&pCache->finished); + (void)taosThreadMutexDestroy(&pCache->mtx); + (void)taosThreadCondDestroy(&pCache->finished); if (pCache->index != NULL) { idxReleaseRef(((SIndex*)pCache->index)->refId); } @@ -475,7 +475,7 @@ Iterate* idxCacheIteratorCreate(IndexCache* cache) { if (iter == NULL) { return NULL; } - taosThreadMutexLock(&cache->mtx); + (void)taosThreadMutexLock(&cache->mtx); idxMemRef(cache->imm); @@ -486,7 +486,7 @@ Iterate* idxCacheIteratorCreate(IndexCache* cache) { iter->next = idxCacheIteratorNext; iter->getValue = idxCacheIteratorGetValue; - taosThreadMutexUnlock(&cache->mtx); + (void)taosThreadMutexUnlock(&cache->mtx); return iter; } @@ -494,7 +494,7 @@ void idxCacheIteratorDestroy(Iterate* iter) { if (iter == NULL) { return; } - tSkipListDestroyIter(iter->iter); + (void)tSkipListDestroyIter(iter->iter); iterateValueDestroy(&iter->val, true); taosMemoryFree(iter); } @@ -508,7 +508,7 @@ int idxCacheSchedToMerge(IndexCache* pCache, bool notify) { } schedMsg.msg = NULL; idxAcquireRef(pCache->index->refId); - taosScheduleTask(indexQhandle, &schedMsg); + (void)taosScheduleTask(indexQhandle, &schedMsg); return 0; } @@ -548,7 +548,7 @@ int idxCachePut(void* cache, SIndexTerm* term, uint64_t uid) { // encode data CacheTerm* ct = taosMemoryCalloc(1, sizeof(CacheTerm)); if (ct == NULL) { - return -1; + return TSDB_CODE_OUT_OF_MEMORY; } // set up key ct->colType = term->colType; @@ -556,6 +556,10 @@ int idxCachePut(void* cache, SIndexTerm* term, uint64_t uid) { ct->colVal = idxPackJsonData(term); } else { ct->colVal = (char*)taosMemoryCalloc(1, sizeof(char) * (term->nColVal + 1)); + if (ct->colVal == NULL) { + taosMemoryFree(ct); + return TSDB_CODE_OUT_OF_MEMORY; + } memcpy(ct->colVal, term->colVal, term->nColVal); } ct->version = atomic_add_fetch_64(&pCache->version, 1); @@ -565,15 +569,15 @@ int idxCachePut(void* cache, SIndexTerm* term, uint64_t uid) { // ugly code, refactor later int64_t estimate = sizeof(ct) + strlen(ct->colVal); - taosThreadMutexLock(&pCache->mtx); + (void)taosThreadMutexLock(&pCache->mtx); pCache->occupiedMem += estimate; idxCacheMakeRoomForWrite(pCache); MemTable* tbl = pCache->mem; idxMemRef(tbl); - tSkipListPut(tbl->mem, (char*)ct); + (void)tSkipListPut(tbl->mem, (char*)ct); idxMemUnRef(tbl); - taosThreadMutexUnlock(&pCache->mtx); + (void)taosThreadMutexUnlock(&pCache->mtx); idxCacheUnRef(pCache); return 0; } @@ -581,13 +585,13 @@ void idxCacheForceToMerge(void* cache) { IndexCache* pCache = cache; idxCacheRef(pCache); - taosThreadMutexLock(&pCache->mtx); + (void)taosThreadMutexLock(&pCache->mtx); indexInfo("%p is forced to merge into tfile", pCache); pCache->occupiedMem += MEM_SIGNAL_QUIT; idxCacheMakeRoomForWrite(pCache); - taosThreadMutexUnlock(&pCache->mtx); + (void)taosThreadMutexUnlock(&pCache->mtx); idxCacheUnRef(pCache); return; } @@ -618,12 +622,12 @@ int idxCacheSearch(void* cache, SIndexTermQuery* query, SIdxTRslt* result, STerm IndexCache* pCache = cache; MemTable *mem = NULL, *imm = NULL; - taosThreadMutexLock(&pCache->mtx); + (void)taosThreadMutexLock(&pCache->mtx); mem = pCache->mem; imm = pCache->imm; idxMemRef(mem); idxMemRef(imm); - taosThreadMutexUnlock(&pCache->mtx); + (void)taosThreadMutexUnlock(&pCache->mtx); int64_t st = taosGetTimestampUs(); @@ -759,7 +763,7 @@ static void idxDoMergeWork(SSchedMsg* msg) { int quit = msg->thandle ? true : false; taosMemoryFree(msg->thandle); - idxFlushCacheToTFile(sidx, pCache, quit); + (void)idxFlushCacheToTFile(sidx, pCache, quit); } static bool idxCacheIteratorNext(Iterate* itera) { SSkipListIterator* iter = itera->iter; @@ -777,7 +781,7 @@ static bool idxCacheIteratorNext(Iterate* itera) { iv->type = ct->operaType; iv->ver = ct->version; iv->colVal = taosStrdup(ct->colVal); - taosArrayPush(iv->val, &ct->uid); + (void)taosArrayPush(iv->val, &ct->uid); } return next; } diff --git a/source/libs/index/src/indexComm.c b/source/libs/index/src/indexComm.c index b7b9f1cc9f..6337b2c556 100644 --- a/source/libs/index/src/indexComm.c +++ b/source/libs/index/src/indexComm.c @@ -378,6 +378,9 @@ int32_t idxConvertData(void* src, int8_t type, void** dst) { int32_t idxConvertDataToStr(void* src, int8_t type, void** dst) { if (src == NULL) { *dst = strndup(INDEX_DATA_NULL_STR, (int)strlen(INDEX_DATA_NULL_STR)); + if (*dst == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } return (int32_t)strlen(INDEX_DATA_NULL_STR); } int tlen = tDataTypes[type].bytes; @@ -385,63 +388,96 @@ int32_t idxConvertDataToStr(void* src, int8_t type, void** dst) { switch (type) { case TSDB_DATA_TYPE_TIMESTAMP: *dst = taosMemoryCalloc(1, bufSize + 1); - idxInt2str(*(int64_t*)src, *dst, -1); + if (*dst == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } + (void)idxInt2str(*(int64_t*)src, *dst, -1); tlen = strlen(*dst); break; case TSDB_DATA_TYPE_BOOL: case TSDB_DATA_TYPE_UTINYINT: *dst = taosMemoryCalloc(1, bufSize + 1); - idxInt2str(*(uint8_t*)src, *dst, 1); + if (*dst == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } + (void)idxInt2str(*(uint8_t*)src, *dst, 1); tlen = strlen(*dst); break; case TSDB_DATA_TYPE_TINYINT: *dst = taosMemoryCalloc(1, bufSize + 1); - idxInt2str(*(int8_t*)src, *dst, 1); + if (*dst == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } + (void)idxInt2str(*(int8_t*)src, *dst, 1); tlen = strlen(*dst); break; case TSDB_DATA_TYPE_SMALLINT: *dst = taosMemoryCalloc(1, bufSize + 1); - idxInt2str(*(int16_t*)src, *dst, -1); + if (*dst == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } + (void)idxInt2str(*(int16_t*)src, *dst, -1); tlen = strlen(*dst); break; case TSDB_DATA_TYPE_USMALLINT: *dst = taosMemoryCalloc(1, bufSize + 1); - idxInt2str(*(uint16_t*)src, *dst, -1); + (void)idxInt2str(*(uint16_t*)src, *dst, -1); tlen = strlen(*dst); break; case TSDB_DATA_TYPE_INT: *dst = taosMemoryCalloc(1, bufSize + 1); - idxInt2str(*(int32_t*)src, *dst, -1); + if (*dst == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } + (void)idxInt2str(*(int32_t*)src, *dst, -1); tlen = strlen(*dst); break; case TSDB_DATA_TYPE_UINT: *dst = taosMemoryCalloc(1, bufSize + 1); - idxInt2str(*(uint32_t*)src, *dst, 1); + if (*dst == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } + (void)idxInt2str(*(uint32_t*)src, *dst, 1); tlen = strlen(*dst); break; case TSDB_DATA_TYPE_BIGINT: *dst = taosMemoryCalloc(1, bufSize + 1); + if (*dst == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } sprintf(*dst, "%" PRIu64, *(uint64_t*)src); tlen = strlen(*dst); break; case TSDB_DATA_TYPE_UBIGINT: *dst = taosMemoryCalloc(1, bufSize + 1); - idxInt2str(*(uint64_t*)src, *dst, 1); + if (*dst == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } + (void)idxInt2str(*(uint64_t*)src, *dst, 1); tlen = strlen(*dst); break; case TSDB_DATA_TYPE_FLOAT: *dst = taosMemoryCalloc(1, bufSize + 1); + if (*dst == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } sprintf(*dst, "%.9lf", *(float*)src); tlen = strlen(*dst); break; case TSDB_DATA_TYPE_DOUBLE: *dst = taosMemoryCalloc(1, bufSize + 1); + if (*dst == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } sprintf(*dst, "%.9lf", *(double*)src); tlen = strlen(*dst); break; case TSDB_DATA_TYPE_NCHAR: { tlen = taosEncodeBinary(NULL, varDataVal(src), varDataLen(src)); *dst = taosMemoryCalloc(1, tlen + 1); + if (*dst == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } tlen = taosEncodeBinary(dst, varDataVal(src), varDataLen(src)); *dst = (char*)*dst - tlen; break; @@ -451,6 +487,9 @@ int32_t idxConvertDataToStr(void* src, int8_t type, void** dst) { case TSDB_DATA_TYPE_GEOMETRY: { tlen = taosEncodeBinary(NULL, varDataVal(src), varDataLen(src)); *dst = taosMemoryCalloc(1, tlen + 1); + if (*dst == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } tlen = taosEncodeBinary(dst, varDataVal(src), varDataLen(src)); *dst = (char*)*dst - tlen; break; diff --git a/source/libs/index/src/indexFilter.c b/source/libs/index/src/indexFilter.c index a7e539efc6..9563b91593 100644 --- a/source/libs/index/src/indexFilter.c +++ b/source/libs/index/src/indexFilter.c @@ -646,7 +646,7 @@ static int32_t sifDoIndex(SIFParam *left, SIFParam *right, int8_t operType, SIFP } SIndexMultiTermQuery *mtm = indexMultiTermQueryCreate(MUST); - indexMultiTermQueryAdd(mtm, tm, qtype); + (void)indexMultiTermQueryAdd(mtm, tm, qtype); ret = indexJsonSearch(arg->ivtIdx, mtm, output->result); indexMultiTermQueryDestroy(mtm); } else { @@ -882,9 +882,9 @@ static int32_t sifExecLogic(SLogicConditionNode *node, SIFCtx *ctx, SIFParam *ou if (ctx->noExec == false) { for (int32_t m = 0; m < node->pParameterList->length; m++) { if (node->condType == LOGIC_COND_TYPE_AND) { - taosArrayAddAll(output->result, params[m].result); + (void)taosArrayAddAll(output->result, params[m].result); } else if (node->condType == LOGIC_COND_TYPE_OR) { - taosArrayAddAll(output->result, params[m].result); + (void)taosArrayAddAll(output->result, params[m].result); } else if (node->condType == LOGIC_COND_TYPE_NOT) { // taosArrayAddAll(output->result, params[m].result); } @@ -1018,12 +1018,12 @@ static int32_t sifCalculate(SNode *pNode, SIFParam *pDst) { SIF_ERR_RET(TSDB_CODE_APP_ERROR); } if (res->result != NULL) { - taosArrayAddAll(pDst->result, res->result); + (void)taosArrayAddAll(pDst->result, res->result); } pDst->status = res->status; sifFreeParam(res); - taosHashRemove(ctx.pRes, (void *)&pNode, POINTER_BYTES); + (void)taosHashRemove(ctx.pRes, (void *)&pNode, POINTER_BYTES); } sifFreeRes(ctx.pRes); return code; @@ -1055,7 +1055,7 @@ static int32_t sifGetFltHint(SNode *pNode, SIdxFltStatus *status, SMetaDataFilte } *status = res->status; sifFreeParam(res); - taosHashRemove(ctx.pRes, (void *)&pNode, POINTER_BYTES); + (void)taosHashRemove(ctx.pRes, (void *)&pNode, POINTER_BYTES); void *iter = taosHashIterate(ctx.pRes, NULL); while (iter != NULL) { @@ -1090,7 +1090,7 @@ int32_t doFilterTag(SNode *pFilterNode, SIndexMetaArg *metaArg, SArray *result, *status = st; } - taosArrayAddAll(result, param.result); + (void)taosArrayAddAll(result, param.result); sifFreeParam(¶m); return TSDB_CODE_SUCCESS; } diff --git a/source/libs/index/src/indexFst.c b/source/libs/index/src/indexFst.c index f3b7b2fbae..34eac0761a 100644 --- a/source/libs/index/src/indexFst.c +++ b/source/libs/index/src/indexFst.c @@ -62,7 +62,7 @@ void fstUnFinishedNodesPushEmpty(FstUnFinishedNodes* nodes, bool isFinal) { node->trans = taosArrayInit(16, sizeof(FstTransition)); FstBuilderNodeUnfinished un = {.node = node, .last = NULL}; - taosArrayPush(nodes->stack, &un); + (void)taosArrayPush(nodes->stack, &un); } FstBuilderNode* fstUnFinishedNodesPopRoot(FstUnFinishedNodes* nodes) { FstBuilderNodeUnfinished* un = taosArrayPop(nodes->stack); @@ -120,7 +120,7 @@ void fstUnFinishedNodesAddSuffix(FstUnFinishedNodes* nodes, FstSlice bs, Output FstLastTransition* trn = fstLastTransitionCreate(data[i], 0); FstBuilderNodeUnfinished un = {.node = n, .last = trn}; - taosArrayPush(nodes->stack, &un); + (void)taosArrayPush(nodes->stack, &un); } fstUnFinishedNodesPushEmpty(nodes, true); } @@ -214,9 +214,9 @@ void fstStateCompileForOneTransNext(IdxFstFile* w, CompiledAddr addr, uint8_t in uint8_t v = fstStateCommInput(&s, &null); if (null) { // w->write_all(&[inp]) - idxFileWrite(w, &inp, 1); + (void)idxFileWrite(w, &inp, 1); } - idxFileWrite(w, &(s.val), 1); + (void)idxFileWrite(w, &(s.val), 1); // w->write_all(&[s.val]) return; } @@ -228,7 +228,7 @@ void fstStateCompileForOneTrans(IdxFstFile* w, CompiledAddr addr, FstTransition* FST_SET_OUTPUT_PACK_SIZE(packSizes, outPackSize); FST_SET_TRANSITION_PACK_SIZE(packSizes, transPackSize); - idxFileWrite(w, (char*)&packSizes, sizeof(packSizes)); + (void)idxFileWrite(w, (char*)&packSizes, sizeof(packSizes)); FstState st = fstStateCreate(OneTrans); @@ -237,9 +237,9 @@ void fstStateCompileForOneTrans(IdxFstFile* w, CompiledAddr addr, FstTransition* bool null = false; uint8_t inp = fstStateCommInput(&st, &null); if (null == true) { - idxFileWrite(w, (char*)&trn->inp, sizeof(trn->inp)); + (void)idxFileWrite(w, (char*)&trn->inp, sizeof(trn->inp)); } - idxFileWrite(w, (char*)(&(st.val)), sizeof(st.val)); + (void)idxFileWrite(w, (char*)(&(st.val)), sizeof(st.val)); return; } void fstStateCompileForAnyTrans(IdxFstFile* w, CompiledAddr addr, FstBuilderNode* node) { @@ -295,24 +295,24 @@ void fstStateCompileForAnyTrans(IdxFstFile* w, CompiledAddr addr, FstBuilderNode FstTransition* t = taosArrayGet(node->trans, i); index[t->inp] = i; } - idxFileWrite(w, (char*)index, 256); + (void)idxFileWrite(w, (char*)index, 256); taosMemoryFree(index); } - idxFileWrite(w, (char*)&packSizes, 1); + (void)idxFileWrite(w, (char*)&packSizes, 1); bool null = false; - fstStateStateNtrans(&st, &null); + (void)fstStateStateNtrans(&st, &null); if (null == true) { // 256 can't be represented in a u8, so we abuse the fact that // the # of transitions can never be 1 here, since 1 is always // encoded in the state byte. uint8_t v = 1; if (sz == 256) { - idxFileWrite(w, (char*)&v, 1); + (void)idxFileWrite(w, (char*)&v, 1); } else { - idxFileWrite(w, (char*)&sz, 1); + (void)idxFileWrite(w, (char*)&sz, 1); } } - idxFileWrite(w, (char*)(&(st.val)), 1); + (void)idxFileWrite(w, (char*)(&(st.val)), 1); return; } @@ -342,7 +342,7 @@ uint8_t fstStateCommInput(FstState* s, bool* null) { uint64_t fstStateInputLen(FstState* s) { ASSERT(s->state == OneTransNext || s->state == OneTrans); bool null = false; - fstStateCommInput(s, &null); + (void)fstStateCommInput(s, &null); return null ? 1 : 0; } @@ -499,7 +499,7 @@ uint64_t fstStateTransIndexSize(FstState* s, uint64_t version, uint64_t nTrans) uint64_t fstStateNtransLen(FstState* s) { ASSERT(s->state == AnyTrans); bool null = false; - fstStateStateNtrans(s, &null); + (void)fstStateStateNtrans(s, &null); return null == true ? 1 : 0; } uint64_t fstStateNtrans(FstState* s, FstSlice* slice) { @@ -673,12 +673,12 @@ bool fstNodeGetTransitionAddrAt(FstNode* node, uint64_t i, CompiledAddr* res) { FstState* st = &node->state; if (st->state == OneTransNext) { ASSERT(i == 0); - fstStateTransAddr(st, node); + (void)fstStateTransAddr(st, node); } else if (st->state == OneTrans) { ASSERT(i == 0); - fstStateTransAddr(st, node); + (void)fstStateTransAddr(st, node); } else if (st->state == AnyTrans) { - fstStateTransAddrForAnyTrans(st, node, i); + (void)fstStateTransAddrForAnyTrans(st, node, i); } else if (FST_STATE_EMPTY_FINAL(node)) { s = false; } else { @@ -755,13 +755,13 @@ FstBuilder* fstBuilderCreate(void* w, FstType ty) { char buf64[8] = {0}; void* pBuf64 = buf64; - taosEncodeFixedU64(&pBuf64, VERSION); - idxFileWrite(b->wrt, buf64, sizeof(buf64)); + (void)taosEncodeFixedU64(&pBuf64, VERSION); + (void)idxFileWrite(b->wrt, buf64, sizeof(buf64)); pBuf64 = buf64; memset(buf64, 0, sizeof(buf64)); - taosEncodeFixedU64(&pBuf64, ty); - idxFileWrite(b->wrt, buf64, sizeof(buf64)); + (void)taosEncodeFixedU64(&pBuf64, ty); + (void)idxFileWrite(b->wrt, buf64, sizeof(buf64)); return b; } @@ -862,7 +862,7 @@ CompiledAddr fstBuilderCompile(FstBuilder* b, FstBuilderNode* bn) { } CompiledAddr startAddr = (CompiledAddr)(FST_WRITER_COUNT(b->wrt)); - fstBuilderNodeCompileTo(bn, b->wrt, b->lastAddr, startAddr); + (void)fstBuilderNodeCompileTo(bn, b->wrt, b->lastAddr, startAddr); b->lastAddr = (CompiledAddr)(FST_WRITER_COUNT(b->wrt) - 1); if (entry->state == NOTFOUND) { FST_REGISTRY_CELL_INSERT(entry->cell, b->lastAddr); @@ -881,23 +881,23 @@ void* fstBuilderInsertInner(FstBuilder* b) { char buf64[8] = {0}; void* pBuf64 = buf64; - taosEncodeFixedU64(&pBuf64, b->len); - idxFileWrite(b->wrt, buf64, sizeof(buf64)); + (void)taosEncodeFixedU64(&pBuf64, b->len); + (void)idxFileWrite(b->wrt, buf64, sizeof(buf64)); pBuf64 = buf64; - taosEncodeFixedU64(&pBuf64, rootAddr); - idxFileWrite(b->wrt, buf64, sizeof(buf64)); + (void)taosEncodeFixedU64(&pBuf64, rootAddr); + (void)idxFileWrite(b->wrt, buf64, sizeof(buf64)); char buf32[4] = {0}; void* pBuf32 = buf32; uint32_t sum = idxFileMaskedCheckSum(b->wrt); - taosEncodeFixedU32(&pBuf32, sum); - idxFileWrite(b->wrt, buf32, sizeof(buf32)); + (void)taosEncodeFixedU32(&pBuf32, sum); + (void)idxFileWrite(b->wrt, buf32, sizeof(buf32)); - idxFileFlush(b->wrt); + (void)idxFileFlush(b->wrt); return b->wrt; } -void fstBuilderFinish(FstBuilder* b) { fstBuilderInsertInner(b); } +void fstBuilderFinish(FstBuilder* b) { (void)fstBuilderInsertInner(b); } FstSlice fstNodeAsSlice(FstNode* node) { FstSlice* slice = &node->data; @@ -924,7 +924,7 @@ void fstBuilderNodeUnfinishedLastCompiled(FstBuilderNodeUnfinished* unNode, Comp return; } FstTransition t = {.inp = trn->inp, .out = trn->out, .addr = addr}; - taosArrayPush(unNode->node->trans, &t); + (void)taosArrayPush(unNode->node->trans, &t); fstLastTransitionDestroy(trn); unNode->last = NULL; return; @@ -955,19 +955,19 @@ Fst* fstCreate(FstSlice* slice) { uint64_t skip = 0; uint64_t version; - taosDecodeFixedU64(buf, &version); + (void)taosDecodeFixedU64(buf, &version); skip += sizeof(version); if (version == 0 || version > VERSION) { return NULL; } uint64_t type; - taosDecodeFixedU64(buf + skip, &type); + (void)taosDecodeFixedU64(buf + skip, &type); skip += sizeof(type); uint32_t checkSum = 0; len -= sizeof(checkSum); - taosDecodeFixedU32(buf + len, &checkSum); + (void)taosDecodeFixedU32(buf + len, &checkSum); if (taosCheckChecksum(buf, len, checkSum)) { indexError("index file is corrupted"); // verify fst @@ -975,11 +975,11 @@ Fst* fstCreate(FstSlice* slice) { } CompiledAddr rootAddr; len -= sizeof(rootAddr); - taosDecodeFixedU64(buf + len, &rootAddr); + (void)taosDecodeFixedU64(buf + len, &rootAddr); uint64_t fstLen; len -= sizeof(fstLen); - taosDecodeFixedU64(buf + len, &fstLen); + (void)taosDecodeFixedU64(buf + len, &fstLen); // TODO(validate root addr) Fst* fst = (Fst*)taosMemoryCalloc(1, sizeof(Fst)); if (fst == NULL) { @@ -1001,7 +1001,7 @@ Fst* fstCreate(FstSlice* slice) { *s = fstSliceCopy(slice, 0, FST_SLICE_LEN(slice) - 1); fst->data = s; - taosThreadMutexInit(&fst->mtx, NULL); + (void)taosThreadMutexInit(&fst->mtx, NULL); return fst; FST_CREAT_FAILED: @@ -1029,7 +1029,7 @@ bool fstGet(Fst* fst, FstSlice* b, Output* out) { uint8_t* data = fstSliceData(b, &len); SArray* nodes = (SArray*)taosArrayInit(len, sizeof(FstNode*)); - taosArrayPush(nodes, &root); + (void)taosArrayPush(nodes, &root); for (uint32_t i = 0; i < len; i++) { uint8_t inp = data[i]; Output res = 0; @@ -1038,10 +1038,10 @@ bool fstGet(Fst* fst, FstSlice* b, Output* out) { } FstTransition trn; - fstNodeGetTransitionAt(root, res, &trn); + (void)fstNodeGetTransitionAt(root, res, &trn); tOut += trn.out; root = fstGetNode(fst, trn.addr); - taosArrayPush(nodes, &root); + (void)taosArrayPush(nodes, &root); } if (!FST_NODE_IS_FINAL(root)) { goto _return; @@ -1163,7 +1163,7 @@ FStmSt* stmStCreate(Fst* fst, FAutoCtx* automation, FstBoundWithData* min, FstBo sws->stack = (SArray*)taosArrayInit(256, sizeof(FstStreamState)); sws->endAt = max; - stmStSeekMin(sws, min); + (void)stmStSeekMin(sws, min); return sws; } @@ -1188,7 +1188,7 @@ bool stmStSeekMin(FStmSt* sws, FstBoundWithData* min) { .trans = 0, .out = {.null = false, .out = 0}, .autState = automFuncs[aut->type].start(aut)}; // auto.start callback - taosArrayPush(sws->stack, &s); + (void)taosArrayPush(sws->stack, &s); return true; } FstSlice* key = NULL; @@ -1214,15 +1214,15 @@ bool stmStSeekMin(FStmSt* sws, FstBoundWithData* min) { uint64_t res = 0; if (fstNodeFindInput(node, b, &res)) { FstTransition trn; - fstNodeGetTransitionAt(node, res, &trn); + (void)fstNodeGetTransitionAt(node, res, &trn); void* preState = autState; autState = automFuncs[aut->type].accept(aut, preState, b); - taosArrayPush(sws->inp, &b); + (void)taosArrayPush(sws->inp, &b); FstStreamState s = {.node = node, .trans = res + 1, .out = {.null = false, .out = out}, .autState = preState}; node = NULL; - taosArrayPush(sws->stack, &s); + (void)taosArrayPush(sws->stack, &s); out += trn.out; node = fstGetNode(sws->fst, trn.addr); } else { @@ -1241,7 +1241,7 @@ bool stmStSeekMin(FStmSt* sws, FstBoundWithData* min) { } FstStreamState s = {.node = node, .trans = i, .out = {.null = false, .out = out}, .autState = autState}; - taosArrayPush(sws->stack, &s); + (void)taosArrayPush(sws->stack, &s); taosMemoryFree(trans); return true; } @@ -1254,15 +1254,15 @@ bool stmStSeekMin(FStmSt* sws, FstBoundWithData* min) { FstStreamState* s = taosArrayGet(sws->stack, sz - 1); if (inclusize) { s->trans -= 1; - taosArrayPop(sws->inp); + (void)taosArrayPop(sws->inp); } else { FstNode* n = s->node; uint64_t trans = s->trans; FstTransition trn; - fstNodeGetTransitionAt(n, trans - 1, &trn); + (void)fstNodeGetTransitionAt(n, trans - 1, &trn); FstStreamState s = { .node = fstGetNode(sws->fst, trn.addr), .trans = 0, .out = {.null = false, .out = out}, .autState = autState}; - taosArrayPush(sws->stack, &s); + (void)taosArrayPush(sws->stack, &s); return true; } return false; @@ -1291,13 +1291,13 @@ FStmStRslt* stmStNextWith(FStmSt* sws, streamCallback__fn callback) { FstStreamState* p = (FstStreamState*)taosArrayPop(sws->stack); if (p->trans >= FST_NODE_LEN(p->node) || !automFuncs[aut->type].canMatch(aut, p->autState)) { if (FST_NODE_ADDR(p->node) != fstGetRootAddr(sws->fst)) { - taosArrayPop(sws->inp); + (void)taosArrayPop(sws->inp); } fstStreamStateDestroy(p); continue; } FstTransition trn; - fstNodeGetTransitionAt(p->node, p->trans, &trn); + (void)fstNodeGetTransitionAt(p->node, p->trans, &trn); Output out = p->out.out + trn.out; void* nextState = automFuncs[aut->type].accept(aut, p->autState, trn.inp); @@ -1305,8 +1305,8 @@ FStmStRslt* stmStNextWith(FStmSt* sws, streamCallback__fn callback) { bool isMatch = automFuncs[aut->type].isMatch(aut, nextState); FstNode* nextNode = fstGetNode(sws->fst, trn.addr); - taosArrayPush(nodes, &nextNode); - taosArrayPush(sws->inp, &(trn.inp)); + (void)taosArrayPush(nodes, &nextNode); + (void)taosArrayPush(sws->inp, &(trn.inp)); if (FST_NODE_IS_FINAL(nextNode)) { void* eofState = automFuncs[aut->type].acceptEof(aut, nextState); @@ -1315,10 +1315,10 @@ FStmStRslt* stmStNextWith(FStmSt* sws, streamCallback__fn callback) { } } FstStreamState s1 = {.node = p->node, .trans = p->trans + 1, .out = p->out, .autState = p->autState}; - taosArrayPush(sws->stack, &s1); + (void)taosArrayPush(sws->stack, &s1); FstStreamState s2 = {.node = nextNode, .trans = 0, .out = {.null = false, .out = out}, .autState = nextState}; - taosArrayPush(sws->stack, &s2); + (void)taosArrayPush(sws->stack, &s2); int32_t isz = taosArrayGetSize(sws->inp); uint8_t* buf = (uint8_t*)taosMemoryMalloc(isz * sizeof(uint8_t)); diff --git a/source/libs/index/src/indexFstDfa.c b/source/libs/index/src/indexFstDfa.c index a3e26d8518..f552d5feba 100644 --- a/source/libs/index/src/indexFstDfa.c +++ b/source/libs/index/src/indexFstDfa.c @@ -74,7 +74,7 @@ FstDfa *dfaBuilderBuild(FstDfaBuilder *builder) { uint32_t result; SArray *states = taosArrayInit(0, sizeof(uint32_t)); if (dfaBuilderCacheState(builder, cur, &result)) { - taosArrayPush(states, &result); + (void)taosArrayPush(states, &result); } SHashObj *seen = taosHashInit(12, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), false, HASH_NO_LOCK); while (taosArrayGetSize(states) != 0) { @@ -83,8 +83,8 @@ FstDfa *dfaBuilderBuild(FstDfaBuilder *builder) { uint32_t ns, dummpy = 0; if (dfaBuilderRunState(builder, cur, nxt, result, i, &ns)) { if (taosHashGet(seen, &ns, sizeof(ns)) == NULL) { - taosHashPut(seen, &ns, sizeof(ns), &dummpy, sizeof(dummpy)); - taosArrayPush(states, &ns); + (void)taosHashPut(seen, &ns, sizeof(ns), &dummpy, sizeof(dummpy)); + (void)taosArrayPush(states, &ns); } } if (taosArrayGetSize(builder->dfa->states) > STATE_LIMIT) { @@ -108,7 +108,7 @@ bool dfaBuilderRunState(FstDfaBuilder *builder, FstSparseSet *cur, FstSparseSet bool succ = sparSetAdd(cur, ip, NULL); if (succ == false) return false; } - dfaRun(builder->dfa, cur, next, byte); + (void)dfaRun(builder->dfa, cur, next, byte); t = taosArrayGet(builder->dfa->states, state); @@ -133,10 +133,10 @@ bool dfaBuilderCacheState(FstDfaBuilder *builder, FstSparseSet *set, uint32_t *r if (inst->ty == JUMP || inst->ty == SPLIT) { continue; } else if (inst->ty == RANGE) { - taosArrayPush(tinsts, &ip); + (void)taosArrayPush(tinsts, &ip); } else if (inst->ty == MATCH) { isMatch = true; - taosArrayPush(tinsts, &ip); + (void)taosArrayPush(tinsts, &ip); } } if (taosArrayGetSize(tinsts) == 0) { @@ -149,10 +149,10 @@ bool dfaBuilderCacheState(FstDfaBuilder *builder, FstSparseSet *set, uint32_t *r taosArrayDestroy(tinsts); } else { DfaState st = {.insts = tinsts, .isMatch = isMatch}; - taosArrayPush(builder->dfa->states, &st); + (void)taosArrayPush(builder->dfa->states, &st); int32_t sz = taosArrayGetSize(builder->dfa->states) - 1; - taosHashPut(builder->cache, &tinsts, sizeof(POINTER_BYTES), &sz, sizeof(sz)); + (void)taosHashPut(builder->cache, &tinsts, sizeof(POINTER_BYTES), &sz, sizeof(sz)); *result = sz; } return true; @@ -187,7 +187,7 @@ void dfaAdd(FstDfa *dfa, FstSparseSet *set, uint32_t ip) { if (sparSetContains(set, ip)) { return; } - bool succ = sparSetAdd(set, ip, NULL); + bool succ = sparSetAdd(set, ip, NULL); Inst *inst = taosArrayGet(dfa->insts, ip); if (inst->ty == MATCH || inst->ty == RANGE) { // do nothing diff --git a/source/libs/index/src/indexFstFile.c b/source/libs/index/src/indexFstFile.c index d86b3d476f..678f2c6086 100644 --- a/source/libs/index/src/indexFstFile.c +++ b/source/libs/index/src/indexFstFile.c @@ -38,7 +38,7 @@ static FORCE_INLINE void idxGenLRUKey(char* buf, const char* path, int32_t block char* p = buf; SERIALIZE_STR_VAR_TO_BUF(p, path, strlen(path)); SERIALIZE_VAR_TO_BUF(p, '_', char); - idxInt2str(blockId, p, 0); + (void)idxInt2str(blockId, p, 0); return; } static FORCE_INLINE int idxFileCtxDoWrite(IFileCtx* ctx, uint8_t* buf, int len) { @@ -48,7 +48,7 @@ static FORCE_INLINE int idxFileCtxDoWrite(IFileCtx* ctx, uint8_t* buf, int len) if (len + ctx->file.wBufOffset >= cap) { int32_t nw = cap - ctx->file.wBufOffset; memcpy(ctx->file.wBuf + ctx->file.wBufOffset, buf, nw); - taosWriteFile(ctx->file.pFile, ctx->file.wBuf, cap); + (void)taosWriteFile(ctx->file.pFile, ctx->file.wBuf, cap); memset(ctx->file.wBuf, 0, cap); ctx->file.wBufOffset = 0; @@ -58,7 +58,7 @@ static FORCE_INLINE int idxFileCtxDoWrite(IFileCtx* ctx, uint8_t* buf, int len) nw = (len / cap) * cap; if (nw != 0) { - taosWriteFile(ctx->file.pFile, buf, nw); + (void)taosWriteFile(ctx->file.pFile, buf, nw); } len -= nw; @@ -112,7 +112,7 @@ static int idxFileCtxDoReadFrom(IFileCtx* ctx, uint8_t* buf, int len, int32_t of SDataBlock* blk = taosLRUCacheValue(ctx->lru, h); nread = TMIN(blkLeft, len); memcpy(buf + total, blk->buf + blkOffset, nread); - taosLRUCacheRelease(ctx->lru, h, false); + (void)taosLRUCacheRelease(ctx->lru, h, false); } else { int32_t left = ctx->file.size - offset; if (left < kBlockSize) { @@ -162,7 +162,7 @@ static FORCE_INLINE int idxFileCtxGetSize(IFileCtx* ctx) { return ctx->offset; } else { int64_t file_size = 0; - taosStatFile(ctx->file.buf, &file_size, NULL, NULL); + (void)taosStatFile(ctx->file.buf, &file_size, NULL, NULL); return (int)file_size; } } @@ -250,16 +250,16 @@ void idxFileCtxDestroy(IFileCtx* ctx, bool remove) { int32_t nw = taosWriteFile(ctx->file.pFile, ctx->file.wBuf, ctx->file.wBufOffset); ctx->file.wBufOffset = 0; } - ctx->flush(ctx); + (void)(ctx->flush(ctx)); taosMemoryFreeClear(ctx->file.wBuf); - taosCloseFile(&ctx->file.pFile); + (void)taosCloseFile(&ctx->file.pFile); if (ctx->file.readOnly) { #ifdef USE_MMAP munmap(ctx->file.ptr, ctx->file.size); #endif } if (remove) { - unlink(ctx->file.buf); + (void)unlink(ctx->file.buf); } } taosMemoryFree(ctx); diff --git a/source/libs/index/src/indexFstNode.c b/source/libs/index/src/indexFstNode.c index 7185e44f46..b934cb0536 100644 --- a/source/libs/index/src/indexFstNode.c +++ b/source/libs/index/src/indexFstNode.c @@ -68,7 +68,7 @@ FstBuilderNode* fstBuilderNodeClone(FstBuilderNode* src) { for (size_t i = 0; i < sz; i++) { FstTransition* tran = taosArrayGet(src->trans, i); - taosArrayPush(trans, tran); + (void)taosArrayPush(trans, tran); } node->trans = trans; @@ -91,7 +91,7 @@ void fstBuilderNodeCloneFrom(FstBuilderNode* dst, FstBuilderNode* src) { dst->trans = taosArrayInit(sz, sizeof(FstTransition)); for (size_t i = 0; i < sz; i++) { FstTransition* trn = taosArrayGet(src->trans, i); - taosArrayPush(dst->trans, trn); + (void)taosArrayPush(dst->trans, trn); } } diff --git a/source/libs/index/src/indexFstRegex.c b/source/libs/index/src/indexFstRegex.c index 7af4b17e79..c6ceb1d965 100644 --- a/source/libs/index/src/indexFstRegex.c +++ b/source/libs/index/src/indexFstRegex.c @@ -24,12 +24,22 @@ FstRegex *regexCreate(const char *str) { } regex->orig = taosStrdup(str); + if (regex->orig == NULL) { + taosMemoryFree(regex); + return NULL; + } // construct insts based on str SArray *insts = taosArrayInit(256, sizeof(uint8_t)); + if (insts == NULL) { + taosMemoryFree(regex->orig); + taosMemoryFree(regex); + return NULL; + } + for (int i = 0; i < strlen(str); i++) { uint8_t v = str[i]; - taosArrayPush(insts, &v); + (void)taosArrayPush(insts, &v); } FstDfaBuilder *builder = dfaBuilderCreate(insts); regex->dfa = dfaBuilderBuild(builder); diff --git a/source/libs/index/src/indexFstRegister.c b/source/libs/index/src/indexFstRegister.c index adafecccb1..e27ab939b3 100644 --- a/source/libs/index/src/indexFstRegister.c +++ b/source/libs/index/src/indexFstRegister.c @@ -83,7 +83,7 @@ FstRegistry* fstRegistryCreate(uint64_t tableSize, uint64_t mruSize) { for (uint64_t i = 0; i < nCells; i++) { FstRegistryCell cell = {.addr = NONE_ADDRESS, .node = fstBuilderNodeDefault()}; - taosArrayPush(tb, &cell); + (void)taosArrayPush(tb, &cell); } registry->table = tb; diff --git a/source/libs/index/src/indexFstUtil.c b/source/libs/index/src/indexFstUtil.c index f1e8808cf5..92cece3890 100644 --- a/source/libs/index/src/indexFstUtil.c +++ b/source/libs/index/src/indexFstUtil.c @@ -81,7 +81,7 @@ FstSlice fstSliceCreate(uint8_t* data, uint64_t len) { str->len = len; str->data = taosMemoryMalloc(len * sizeof(uint8_t)); - if (data != NULL) { + if (data != NULL && str->data != NULL) { memcpy(str->data, data, len); } @@ -91,7 +91,7 @@ FstSlice fstSliceCreate(uint8_t* data, uint64_t len) { // just shallow copy FstSlice fstSliceCopy(FstSlice* s, int32_t start, int32_t end) { FstString* str = s->str; - atomic_add_fetch_32(&str->ref, 1); + (void)atomic_add_fetch_32(&str->ref, 1); FstSlice t = {.str = str, .start = start + s->start, .end = end + s->start}; return t; diff --git a/source/libs/index/src/indexTfile.c b/source/libs/index/src/indexTfile.c index d0166ae2e5..6aab70dcb0 100644 --- a/source/libs/index/src/indexTfile.c +++ b/source/libs/index/src/indexTfile.c @@ -125,7 +125,7 @@ TFileCache* tfileCacheCreate(SIndex* idx, const char* path) { char buf[128] = {0}; int32_t sz = idxSerialCacheKey(&key, buf); - taosHashPut(tcache->tableCache, buf, sz, &reader, sizeof(void*)); + (void)taosHashPut(tcache->tableCache, buf, sz, &reader, sizeof(void*)); tfileReaderRef(reader); } taosArrayDestroyEx(files, tfileDestroyFileName); @@ -172,7 +172,7 @@ int32_t tfileCachePut(TFileCache* tcache, ICacheKey* key, TFileReader* reader) { TFileReader** p = taosHashGet(tcache->tableCache, buf, sz); if (p != NULL && *p != NULL) { TFileReader* oldRdr = *p; - taosHashRemove(tcache->tableCache, buf, sz); + (void)taosHashRemove(tcache->tableCache, buf, sz); indexInfo("found %s, should remove file %s", buf, oldRdr->ctx->file.buf); oldRdr->remove = true; tfileReaderUnRef(oldRdr); @@ -265,7 +265,7 @@ static int32_t tfSearchPrefix(void* reader, SIndexTerm* tem, SIdxTRslt* tr) { FStmSt* st = stmBuilderIntoStm(sb); FStmStRslt* rt = NULL; while ((rt = stmStNextWith(st, NULL)) != NULL) { - taosArrayPush(offsets, &(rt->out.out)); + (void)taosArrayPush(offsets, &(rt->out.out)); swsResultDestroy(rt); } stmStDestroy(st); @@ -337,7 +337,7 @@ static int32_t tfSearchCompareFunc(void* reader, SIndexTerm* tem, SIdxTRslt* tr, TExeCond cond = cmpFn(ch, p, tem->colType); if (MATCH == cond) { - tfileReaderLoadTableIds((TFileReader*)reader, rt->out.out, tr->total); + (void)tfileReaderLoadTableIds((TFileReader*)reader, rt->out.out, tr->total); } else if (CONTINUE == cond) { } else if (BREAK == cond) { swsResultDestroy(rt); @@ -474,7 +474,7 @@ static int32_t tfSearchCompareFunc_JSON(void* reader, SIndexTerm* tem, SIdxTRslt taosMemoryFree(tBuf); } if (MATCH == cond) { - tfileReaderLoadTableIds((TFileReader*)reader, rt->out.out, tr->total); + (void)tfileReaderLoadTableIds((TFileReader*)reader, rt->out.out, tr->total); } else if (CONTINUE == cond) { } else if (BREAK == cond) { swsResultDestroy(rt); @@ -552,7 +552,7 @@ int32_t tfileWriterCreate(IFileCtx* ctx, TFileHeader* header, TFileWriter** pWri } tw->ctx = ctx; tw->header = *header; - tfileWriteHeader(tw); + (void)tfileWriteHeader(tw); *pWriter = tw; return code; @@ -571,7 +571,7 @@ int tfileWriterPut(TFileWriter* tw, void* data, bool order) { } else { fn = getComparFunc(colType, 0); } - taosArraySortPWithExt((SArray*)(data), tfileValueCompare, &fn); + (void)taosArraySortPWithExt((SArray*)(data), tfileValueCompare, &fn); } int32_t sz = taosArrayGetSize((SArray*)data); @@ -586,7 +586,7 @@ int tfileWriterPut(TFileWriter* tw, void* data, bool order) { if (tbsz == 0) continue; fstOffset += TF_TABLE_TATOAL_SIZE(tbsz); } - tfileWriteFstOffset(tw, fstOffset); + (void)tfileWriteFstOffset(tw, fstOffset); int32_t cap = 4 * 1024; char* buf = taosMemoryCalloc(1, cap); @@ -614,7 +614,7 @@ int tfileWriterPut(TFileWriter* tw, void* data, bool order) { char* p = buf; tfileSerialTableIdsToBuf(p, v->tableId); - tw->ctx->write(tw->ctx, buf, ttsz); + (void)(tw->ctx->write(tw->ctx, buf, ttsz)); v->offset = tw->offset; tw->offset += ttsz; memset(buf, 0, cap); @@ -642,7 +642,7 @@ int tfileWriterPut(TFileWriter* tw, void* data, bool order) { } } fstBuilderDestroy(tw->fb); - tfileWriteFooter(tw); + (void)tfileWriteFooter(tw); return 0; } void tfileWriterClose(TFileWriter* tw) { @@ -679,7 +679,7 @@ void idxTFileDestroy(IndexTFile* tfile) { if (tfile == NULL) { return; } - taosThreadMutexDestroy(&tfile->mtx); + (void)taosThreadMutexDestroy(&tfile->mtx); tfileCacheDestroy(tfile->cache); taosMemoryFree(tfile); } @@ -696,9 +696,9 @@ int idxTFileSearch(void* tfile, SIndexTermQuery* query, SIdxTRslt* result) { SIndexTerm* term = query->term; ICacheKey key = {.suid = term->suid, .colType = term->colType, .colName = term->colName, .nColName = term->nColName}; - taosThreadMutexLock(&pTfile->mtx); + (void)taosThreadMutexLock(&pTfile->mtx); TFileReader* reader = tfileCacheGet(pTfile->cache, &key); - taosThreadMutexUnlock(&pTfile->mtx); + (void)taosThreadMutexUnlock(&pTfile->mtx); if (reader == NULL) { return 0; } @@ -802,9 +802,9 @@ TFileReader* tfileGetReaderByCol(IndexTFile* tf, uint64_t suid, char* colName) { TFileReader* rd = NULL; ICacheKey key = {.suid = suid, .colType = TSDB_DATA_TYPE_BINARY, .colName = colName, .nColName = strlen(colName)}; - taosThreadMutexLock(&tf->mtx); + (void)taosThreadMutexLock(&tf->mtx); rd = tfileCacheGet(tf->cache, &key); - taosThreadMutexUnlock(&tf->mtx); + (void)taosThreadMutexUnlock(&tf->mtx); return rd; } @@ -838,7 +838,7 @@ int tfileValuePush(TFileValue* tf, uint64_t val) { if (tf == NULL) { return -1; } - taosArrayPush(tf->tableId, &val); + (void)taosArrayPush(tf->tableId, &val); return 0; } void tfileValueDestroy(TFileValue* tf) { @@ -897,7 +897,7 @@ static int tfileWriteData(TFileWriter* write, TFileValue* tval) { static int tfileWriteFooter(TFileWriter* write) { char buf[sizeof(FILE_MAGIC_NUMBER) + 1] = {0}; void* pBuf = (void*)buf; - taosEncodeFixedU64((void**)(void*)&pBuf, FILE_MAGIC_NUMBER); + (void)taosEncodeFixedU64((void**)(void*)&pBuf, FILE_MAGIC_NUMBER); int nwrite = write->ctx->write(write->ctx, buf, (int32_t)strlen(buf)); indexInfo("tfile write footer size: %d", write->ctx->size(write->ctx)); @@ -964,7 +964,7 @@ static int tfileReaderLoadTableIds(TFileReader* reader, int32_t offset, SArray* while (nid > 0) { int32_t left = block + sizeof(block) - p; if (left >= sizeof(uint64_t)) { - taosArrayPush(result, (uint64_t*)p); + (void)taosArrayPush(result, (uint64_t*)p); p += sizeof(uint64_t); } else { char buf[sizeof(uint64_t)] = {0}; @@ -975,7 +975,7 @@ static int tfileReaderLoadTableIds(TFileReader* reader, int32_t offset, SArray* nread = ctx->readFrom(ctx, block, sizeof(block), offset); memcpy(buf + left, block, sizeof(uint64_t) - left); - taosArrayPush(result, (uint64_t*)buf); + (void)taosArrayPush(result, (uint64_t*)buf); p = block + sizeof(uint64_t) - left; } nid -= 1; @@ -996,7 +996,7 @@ static int tfileReaderVerify(TFileReader* reader) { return -1; } - taosDecodeFixedU64(buf, &tMagicNumber); + (void)taosDecodeFixedU64(buf, &tMagicNumber); return tMagicNumber == FILE_MAGIC_NUMBER ? 0 : -1; } @@ -1040,12 +1040,12 @@ static SArray* tfileGetFileList(const char* path) { size_t len = strlen(path) + 1 + strlen(file) + 1; char* buf = taosMemoryCalloc(1, len); sprintf(buf, "%s/%s", path, file); - taosArrayPush(files, &buf); + (void)taosArrayPush(files, &buf); } - taosCloseDir(&pDir); + (void)taosCloseDir(&pDir); taosArraySort(files, tfileCompare); - tfileRmExpireFile(files); + (void)tfileRmExpireFile(files); return files; } diff --git a/source/libs/index/src/indexUtil.c b/source/libs/index/src/indexUtil.c index f89944204d..0776e71180 100644 --- a/source/libs/index/src/indexUtil.c +++ b/source/libs/index/src/indexUtil.c @@ -64,7 +64,7 @@ void iIntersection(SArray *in, SArray *out) { } } if (has == true) { - taosArrayPush(out, &tgt); + (void)taosArrayPush(out, &tgt); } } taosMemoryFreeClear(mi); @@ -75,7 +75,7 @@ void iUnion(SArray *in, SArray *out) { return; } if (sz == 1) { - taosArrayAddAll(out, taosArrayGetP(in, 0)); + (void)taosArrayAddAll(out, taosArrayGetP(in, 0)); return; } @@ -108,7 +108,7 @@ void iUnion(SArray *in, SArray *out) { continue; } } - taosArrayPush(out, &mVal); + (void)taosArrayPush(out, &mVal); } else { break; } @@ -198,11 +198,11 @@ void idxTRsltMergeTo(SIdxTRslt *tr, SArray *result) { if (taosArrayGetSize(tr->total) == 0 || taosArrayGetSize(tr->add) == 0) { SArray *t = taosArrayGetSize(tr->total) == 0 ? tr->add : tr->total; - taosArrayAddAll(result, t); + (void)taosArrayAddAll(result, t); } else { SArray *arrs = taosArrayInit(2, sizeof(void *)); - taosArrayPush(arrs, &tr->total); - taosArrayPush(arrs, &tr->add); + (void)taosArrayPush(arrs, &tr->total); + (void)taosArrayPush(arrs, &tr->add); iUnion(arrs, result); taosArrayDestroy(arrs); } diff --git a/source/libs/transport/src/thttp.c b/source/libs/transport/src/thttp.c index d3fe42d2ec..908468f094 100644 --- a/source/libs/transport/src/thttp.c +++ b/source/libs/transport/src/thttp.c @@ -209,7 +209,7 @@ static FORCE_INLINE int32_t taosBuildDstAddr(const char* server, uint16_t port, static void* httpThread(void* arg) { SHttpModule* http = (SHttpModule*)arg; setThreadName("http-cli-send-thread"); - uv_run(http->loop, UV_RUN_DEFAULT); + (void)uv_run(http->loop, UV_RUN_DEFAULT); return NULL; } @@ -332,7 +332,7 @@ static FORCE_INLINE void clientCloseCb(uv_handle_t* handle) { SHttpModule* http = taosAcquireRef(httpRefMgt, cli->chanId); if (http != NULL) { http->connNum -= 1; - taosReleaseRef(httpRefMgt, chanId); + (void)taosReleaseRef(httpRefMgt, chanId); } destroyHttpClient(cli); @@ -389,7 +389,7 @@ static void clientConnCb(uv_connect_t* req, int32_t status) { if (!uv_is_closing((uv_handle_t*)&cli->tcp)) { uv_close((uv_handle_t*)&cli->tcp, clientCloseCb); } - taosReleaseRef(httpRefMgt, chanId); + (void)taosReleaseRef(httpRefMgt, chanId); return; } http->connNum += 1; @@ -404,7 +404,7 @@ static void clientConnCb(uv_connect_t* req, int32_t status) { uv_close((uv_handle_t*)&cli->tcp, clientCloseCb); } } - taosReleaseRef(httpRefMgt, chanId); + (void)taosReleaseRef(httpRefMgt, chanId); } int32_t httpSendQuit(SHttpModule* http, int64_t chanId) { @@ -449,7 +449,7 @@ static void httpHandleQuit(SHttpMsg* msg) { SHttpModule* http = taosAcquireRef(httpRefMgt, chanId); if (http == NULL) return; uv_walk(http->loop, httpWalkCb, NULL); - taosReleaseRef(httpRefMgt, chanId); + (void)taosReleaseRef(httpRefMgt, chanId); } static bool httpFailFastShoudIgnoreMsg(SHashObj* pTable, char* server, int16_t port) { @@ -474,10 +474,10 @@ static void httpFailFastMayUpdate(SHashObj* pTable, char* server, int16_t port, sprintf(buf, "%s:%d", server, port); if (succ) { - taosHashRemove(pTable, buf, strlen(buf)); + (void)taosHashRemove(pTable, buf, strlen(buf)); } else { int32_t st = taosGetTimestampSec(); - taosHashPut(pTable, buf, strlen(buf), &st, sizeof(st)); + (void)taosHashPut(pTable, buf, strlen(buf), &st, sizeof(st)); } return; } @@ -559,7 +559,7 @@ static void httpHandleReq(SHttpMsg* msg) { tError("http-report failed to alloc read buf, dst:%s:%d,chanId:%" PRId64 ", reason:%s", cli->addr, cli->port, chanId, tstrerror(TSDB_CODE_OUT_OF_MEMORY)); destroyHttpClient(cli); - taosReleaseRef(httpRefMgt, chanId); + (void)taosReleaseRef(httpRefMgt, chanId); return; } @@ -568,7 +568,7 @@ static void httpHandleReq(SHttpMsg* msg) { tError("http-report failed to init socket handle, dst:%s:%d,chanId:%" PRId64 ", reason:%s", cli->addr, cli->port, chanId, uv_strerror(err)); destroyHttpClient(cli); - taosReleaseRef(httpRefMgt, chanId); + (void)taosReleaseRef(httpRefMgt, chanId); return; } @@ -578,7 +578,7 @@ static void httpHandleReq(SHttpMsg* msg) { tError("http-report failed to open socket, dst:%s:%d, chanId:%" PRId64 ", reason:%s", cli->addr, cli->port, chanId, tstrerror(TAOS_SYSTEM_ERROR(errno))); destroyHttpClient(cli); - taosReleaseRef(httpRefMgt, chanId); + (void)taosReleaseRef(httpRefMgt, chanId); return; } @@ -587,7 +587,7 @@ static void httpHandleReq(SHttpMsg* msg) { tError("http-report failed to open socket, reason:%s, dst:%s:%d, chanId:%" PRId64 ",reason:%s", uv_strerror(ret), cli->addr, cli->port, chanId, uv_strerror(ret)); destroyHttpClient(cli); - taosReleaseRef(httpRefMgt, chanId); + (void)taosReleaseRef(httpRefMgt, chanId); return; } @@ -598,7 +598,7 @@ static void httpHandleReq(SHttpMsg* msg) { httpFailFastMayUpdate(http->connStatusTable, cli->addr, cli->port, 0); destroyHttpClient(cli); } - taosReleaseRef(httpRefMgt, chanId); + (void)taosReleaseRef(httpRefMgt, chanId); return; END: @@ -608,7 +608,7 @@ END: } httpDestroyMsg(msg); taosMemoryFree(header); - taosReleaseRef(httpRefMgt, chanId); + (void)taosReleaseRef(httpRefMgt, chanId); } static void httpModuleDestroy(SHttpModule* http) { @@ -619,7 +619,7 @@ static void httpModuleDestroy(SHttpModule* http) { transAsyncPoolDestroy(http->asyncPool); } if (http->loop) { - uv_loop_close(http->loop); + (void)uv_loop_close(http->loop); taosMemoryFree(http->loop); } @@ -673,7 +673,7 @@ int32_t taosSendHttpReportByChan(const char* server, const char* uri, uint16_t p int32_t taosSendHttpReport(const char* server, const char* uri, uint16_t port, char* pCont, int32_t contLen, EHttpCompFlag flag) { - taosThreadOnce(&transHttpInit, transHttpEnvInit); + (void)taosThreadOnce(&transHttpInit, transHttpEnvInit); return taosSendHttpReportImplByChan(server, uri, port, pCont, contLen, flag, httpDefaultChanId); } @@ -743,7 +743,7 @@ _ERROR: return code; } int64_t taosInitHttpChan() { - taosThreadOnce(&transHttpInit, transHttpEnvInit); + (void)taosThreadOnce(&transHttpInit, transHttpEnvInit); return transInitHttpChanImpl(); } @@ -762,14 +762,14 @@ void taosDestroyHttpChan(int64_t chanId) { ret = httpSendQuit(load, chanId); if (ret != 0) { tDebug("http-report already destroyed, chanId %" PRId64 ",reason:%s", chanId, tstrerror(ret)); - taosReleaseRef(httpRefMgt, chanId); + (void)taosReleaseRef(httpRefMgt, chanId); return; } - taosThreadJoin(load->thread, NULL); + (void)taosThreadJoin(load->thread, NULL); httpModuleDestroy(load); - taosReleaseRef(httpRefMgt, chanId); - taosRemoveRef(httpRefMgt, chanId); + (void)taosReleaseRef(httpRefMgt, chanId); + (void)taosRemoveRef(httpRefMgt, chanId); } \ No newline at end of file diff --git a/source/libs/transport/src/tmsgcb.c b/source/libs/transport/src/tmsgcb.c index e44328c683..619592c82c 100644 --- a/source/libs/transport/src/tmsgcb.c +++ b/source/libs/transport/src/tmsgcb.c @@ -59,7 +59,7 @@ int32_t tmsgSendSyncReq(const SEpSet* epSet, SRpcMsg* pMsg) { void tmsgSendRsp(SRpcMsg* pMsg) { #if 1 - rpcSendResponse(pMsg); + (void)rpcSendResponse(pMsg); #else return (*defaultMsgCb.sendRspFp)(pMsg); #endif @@ -81,6 +81,6 @@ bool tmsgUpdateDnodeInfo(int32_t* dnodeId, int64_t* clusterId, char* fqdn, uint1 void tmsgUpdateDnodeEpSet(SEpSet* epset) { for (int32_t i = 0; i < epset->numOfEps; ++i) { - tmsgUpdateDnodeInfo(NULL, NULL, epset->eps[i].fqdn, &epset->eps[i].port); + (void)tmsgUpdateDnodeInfo(NULL, NULL, epset->eps[i].fqdn, &epset->eps[i].port); } } diff --git a/source/libs/transport/src/trans.c b/source/libs/transport/src/trans.c index f86c010828..fbcc74e8e1 100644 --- a/source/libs/transport/src/trans.c +++ b/source/libs/transport/src/trans.c @@ -111,7 +111,7 @@ void* rpcOpen(const SRpcInit* pInit) { } int64_t refId = transAddExHandle(transGetInstMgt(), pRpc); - transAcquireExHandle(transGetInstMgt(), refId); + (void)transAcquireExHandle(transGetInstMgt(), refId); pRpc->refId = refId; return (void*)refId; _end: @@ -122,8 +122,8 @@ _end: } void rpcClose(void* arg) { tInfo("start to close rpc"); - transRemoveExHandle(transGetInstMgt(), (int64_t)arg); - transReleaseExHandle(transGetInstMgt(), (int64_t)arg); + (void)transRemoveExHandle(transGetInstMgt(), (int64_t)arg); + (void)transReleaseExHandle(transGetInstMgt(), (int64_t)arg); tInfo("end to close rpc"); return; } diff --git a/source/libs/transport/src/transCli.c b/source/libs/transport/src/transCli.c index b51964083f..4669972904 100644 --- a/source/libs/transport/src/transCli.c +++ b/source/libs/transport/src/transCli.c @@ -230,11 +230,11 @@ static int32_t createThrdObj(void* trans, SCliThrd** pThrd); static void destroyThrdObj(SCliThrd* pThrd); static void cliWalkCb(uv_handle_t* handle, void* arg); -#define CLI_RELEASE_UV(loop) \ - do { \ - uv_walk(loop, cliWalkCb, NULL); \ - uv_run(loop, UV_RUN_DEFAULT); \ - uv_loop_close(loop); \ +#define CLI_RELEASE_UV(loop) \ + do { \ + (void)uv_walk(loop, cliWalkCb, NULL); \ + (void)uv_run(loop, UV_RUN_DEFAULT); \ + (void)uv_loop_close(loop); \ } while (0); // snprintf may cause performance problem @@ -244,7 +244,7 @@ static void cliWalkCb(uv_handle_t* handle, void* arg); int16_t len = strlen(ip); \ if (ip != NULL) memcpy(t, ip, len); \ t[len] = ':'; \ - titoa(port, 10, &t[len + 1]); \ + (void)titoa(port, 10, &t[len + 1]); \ } while (0) #define CONN_PERSIST_TIME(para) ((para) <= 90000 ? 90000 : (para)) @@ -357,15 +357,15 @@ bool cliConnSendSeqMsg(int64_t refId, SCliConn* conn) { taosWUnLockLatch(&exh->latch); SCliMsg* t = QUEUE_DATA(h, SCliMsg, seqq); transCtxMerge(&conn->ctx, &t->ctx->appCtx); - transQueuePush(&conn->cliMsgs, t); + (void)transQueuePush(&conn->cliMsgs, t); tDebug("pop from conn %p, refId: %" PRId64 "", conn, refId); - transReleaseExHandle(transGetRefMgt(), refId); + (void)transReleaseExHandle(transGetRefMgt(), refId); cliSend(conn); return true; } taosWUnLockLatch(&exh->latch); tDebug("empty conn %p, refId: %" PRId64 "", conn, refId); - transReleaseExHandle(transGetRefMgt(), refId); + (void)transReleaseExHandle(transGetRefMgt(), refId); return false; } @@ -376,9 +376,9 @@ void cliHandleResp(SCliConn* conn) { if (conn->timer) { if (uv_is_active((uv_handle_t*)conn->timer)) { tDebug("%s conn %p stop timer", CONN_GET_INST_LABEL(conn), conn); - uv_timer_stop(conn->timer); + (void)uv_timer_stop(conn->timer); } - taosArrayPush(pThrd->timerList, &conn->timer); + (void)taosArrayPush(pThrd->timerList, &conn->timer); conn->timer->data = NULL; conn->timer = NULL; } @@ -486,7 +486,7 @@ void cliHandleResp(SCliConn* conn) { return addConnToPool(pThrd->pool, conn); } - uv_read_start((uv_stream_t*)conn->stream, cliAllocRecvBufferCb, cliRecvCb); + (void)uv_read_start((uv_stream_t*)conn->stream, cliAllocRecvBufferCb, cliRecvCb); } static void cliDestroyMsgInExhandle(int64_t refId) { if (refId == 0) return; @@ -500,7 +500,7 @@ static void cliDestroyMsgInExhandle(int64_t refId) { destroyCmsg(t); } taosWUnLockLatch(&exh->latch); - transReleaseExHandle(transGetRefMgt(), refId); + (void)transReleaseExHandle(transGetRefMgt(), refId); } } @@ -588,9 +588,9 @@ void cliConnTimeout(uv_timer_t* handle) { tTrace("%s conn %p conn timeout, ref:%d", CONN_GET_INST_LABEL(conn), conn, T_REF_VAL_GET(conn)); - uv_timer_stop(handle); + (void)uv_timer_stop(handle); handle->data = NULL; - taosArrayPush(pThrd->timerList, &conn->timer); + (void)taosArrayPush(pThrd->timerList, &conn->timer); conn->timer = NULL; cliMayUpdateFqdnCache(pThrd->fqdn2ipCache, conn->dstAddr); @@ -600,7 +600,7 @@ void cliReadTimeoutCb(uv_timer_t* handle) { // set up timeout cb SCliConn* conn = handle->data; tTrace("%s conn %p timeout, ref:%d", CONN_GET_INST_LABEL(conn), conn, T_REF_VAL_GET(conn)); - uv_read_stop(conn->stream); + (void)uv_read_stop(conn->stream); cliHandleExceptImpl(conn, TSDB_CODE_RPC_TIMEOUT); } @@ -687,7 +687,7 @@ static SCliConn* getConnFromPool2(SCliThrd* pThrd, char* key, SCliMsg** pMsg) { SConnList* plist = taosHashGet((SHashObj*)pool, key, klen); if (plist == NULL) { SConnList list = {0}; - taosHashPut((SHashObj*)pool, key, klen, (void*)&list, sizeof(list)); + (void)taosHashPut((SHashObj*)pool, key, klen, (void*)&list, sizeof(list)); plist = taosHashGet(pool, key, klen); SMsgList* nList = taosMemoryCalloc(1, sizeof(SMsgList)); @@ -800,8 +800,8 @@ static void addConnToPool(void* pool, SCliConn* conn) { SCliThrd* thrd = conn->hostThrd; if (conn->timer != NULL) { - uv_timer_stop(conn->timer); - taosArrayPush(thrd->timerList, &conn->timer); + (void)uv_timer_stop(conn->timer); + (void)taosArrayPush(thrd->timerList, &conn->timer); conn->timer->data = NULL; conn->timer = NULL; } @@ -827,7 +827,7 @@ static void addConnToPool(void* pool, SCliConn* conn) { pMsg->ctx->task = NULL; transCtxMerge(&conn->ctx, &pMsg->ctx->appCtx); - transQueuePush(&conn->cliMsgs, pMsg); + (void)transQueuePush(&conn->cliMsgs, pMsg); conn->status = ConnNormal; cliSend(conn); @@ -851,8 +851,8 @@ static void addConnToPool(void* pool, SCliConn* conn) { } static int32_t allocConnRef(SCliConn* conn, bool update) { if (update) { - transReleaseExHandle(transGetRefMgt(), conn->refId); - transRemoveExHandle(transGetRefMgt(), conn->refId); + (void)transReleaseExHandle(transGetRefMgt(), conn->refId); + (void)transRemoveExHandle(transGetRefMgt(), conn->refId); conn->refId = -1; } @@ -887,8 +887,8 @@ static int32_t allocConnRef(SCliConn* conn, bool update) { static int32_t specifyConnRef(SCliConn* conn, bool update, int64_t handle) { if (update) { - transReleaseExHandle(transGetRefMgt(), conn->refId); - transRemoveExHandle(transGetRefMgt(), conn->refId); + (void)transReleaseExHandle(transGetRefMgt(), conn->refId); + (void)transRemoveExHandle(transGetRefMgt(), conn->refId); conn->refId = -1; } SExHandle* exh = transAcquireExHandle(transGetRefMgt(), handle); @@ -982,7 +982,7 @@ static int32_t cliCreateConn(SCliThrd* pThrd, SCliConn** pCliConn) { } tDebug("no available timer, create a timer %p", timer); - uv_timer_init(pThrd->loop, timer); + (void)uv_timer_init(pThrd->loop, timer); } timer->data = conn; @@ -1000,7 +1000,7 @@ static int32_t cliCreateConn(SCliThrd* pThrd, SCliConn** pCliConn) { conn->broken = false; transRefCliHandle(conn); - atomic_add_fetch_32(&pThrd->connCount, 1); + (void)atomic_add_fetch_32(&pThrd->connCount, 1); TAOS_CHECK_GOTO(allocConnRef(conn, false), NULL, _failed); @@ -1038,8 +1038,8 @@ static void cliDestroyConn(SCliConn* conn, bool clear) { conn->list = NULL; - transReleaseExHandle(transGetRefMgt(), conn->refId); - transRemoveExHandle(transGetRefMgt(), conn->refId); + (void)transReleaseExHandle(transGetRefMgt(), conn->refId); + (void)transRemoveExHandle(transGetRefMgt(), conn->refId); conn->refId = -1; if (conn->task != NULL) { @@ -1047,15 +1047,15 @@ static void cliDestroyConn(SCliConn* conn, bool clear) { conn->task = NULL; } if (conn->timer != NULL) { - uv_timer_stop(conn->timer); + (void)uv_timer_stop(conn->timer); conn->timer->data = NULL; - taosArrayPush(pThrd->timerList, &conn->timer); + (void)taosArrayPush(pThrd->timerList, &conn->timer); conn->timer = NULL; } if (clear) { if (!uv_is_closing((uv_handle_t*)conn->stream)) { - uv_read_stop(conn->stream); + (void)uv_read_stop(conn->stream); uv_close((uv_handle_t*)conn->stream, cliDestroy); } } @@ -1067,16 +1067,16 @@ static void cliDestroy(uv_handle_t* handle) { SCliConn* conn = handle->data; SCliThrd* pThrd = conn->hostThrd; if (conn->timer != NULL) { - uv_timer_stop(conn->timer); - taosArrayPush(pThrd->timerList, &conn->timer); + (void)uv_timer_stop(conn->timer); + (void)taosArrayPush(pThrd->timerList, &conn->timer); conn->timer->data = NULL; conn->timer = NULL; } - atomic_sub_fetch_32(&pThrd->connCount, 1); + (void)atomic_sub_fetch_32(&pThrd->connCount, 1); - transReleaseExHandle(transGetRefMgt(), conn->refId); - transRemoveExHandle(transGetRefMgt(), conn->refId); + (void)transReleaseExHandle(transGetRefMgt(), conn->refId); + (void)transRemoveExHandle(transGetRefMgt(), conn->refId); taosMemoryFree(conn->dstAddr); taosMemoryFree(conn->stream); @@ -1084,7 +1084,7 @@ static void cliDestroy(uv_handle_t* handle) { tTrace("%s conn %p destroy successfully", CONN_GET_INST_LABEL(conn), conn); transReqQueueClear(&conn->wreqQueue); - transDestroyBuffer(&conn->readBuf); + (void)transDestroyBuffer(&conn->readBuf); taosMemoryFree(conn); } @@ -1093,7 +1093,7 @@ static bool cliHandleNoResp(SCliConn* conn) { if (!transQueueEmpty(&conn->cliMsgs)) { SCliMsg* pMsg = transQueueGet(&conn->cliMsgs, 0); if (REQUEST_NO_RESP(&pMsg->msg)) { - transQueuePop(&conn->cliMsgs); + (void)transQueuePop(&conn->cliMsgs); destroyCmsg(pMsg); res = true; } @@ -1138,7 +1138,7 @@ static void cliSendCb(uv_write_t* req, int status) { tTrace("%s conn %p no resp required", CONN_GET_INST_LABEL(pConn), pConn); return; } - uv_read_start((uv_stream_t*)pConn->stream, cliAllocRecvBufferCb, cliRecvCb); + (void)uv_read_start((uv_stream_t*)pConn->stream, cliAllocRecvBufferCb, cliRecvCb); } void cliSendBatch(SCliConn* pConn) { SCliThrd* pThrd = pConn->hostThrd; @@ -1197,7 +1197,7 @@ void cliSendBatch(SCliConn* pConn) { req->data = pConn; tDebug("%s conn %p start to send batch msg, batch size:%d, msgLen:%d", CONN_GET_INST_LABEL(pConn), pConn, pBatch->wLen, pBatch->batchSize); - uv_write(req, (uv_stream_t*)pConn->stream, wb, wLen, cliSendBatchCb); + (void)uv_write(req, (uv_stream_t*)pConn->stream, wb, wLen, cliSendBatchCb); taosMemoryFree(wb); } void cliSend(SCliConn* pConn) { @@ -1252,13 +1252,13 @@ void cliSend(SCliConn* pConn) { if (timer == NULL) { timer = taosMemoryCalloc(1, sizeof(uv_timer_t)); tDebug("no available timer, create a timer %p", timer); - uv_timer_init(pThrd->loop, timer); + (void)uv_timer_init(pThrd->loop, timer); } 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)); - uv_timer_start((uv_timer_t*)pConn->timer, cliReadTimeoutCb, TRANS_READ_TIMEOUT, 0); + (void)uv_timer_start((uv_timer_t*)pConn->timer, cliReadTimeoutCb, TRANS_READ_TIMEOUT, 0); } if (pHead->comp == 0 && pMsg->info.compressed == 0 && pConn->clientIp != pConn->serverIp) { @@ -1345,9 +1345,9 @@ static void cliHandleBatchReq(SCliBatch* pBatch, SCliThrd* pThrd) { uint32_t ipaddr = 0; if ((code = cliGetIpFromFqdnCache(pThrd->fqdn2ipCache, pList->ip, &ipaddr)) != 0) { - uv_timer_stop(conn->timer); + (void)uv_timer_stop(conn->timer); conn->timer->data = NULL; - taosArrayPush(pThrd->timerList, &conn->timer); + (void)taosArrayPush(pThrd->timerList, &conn->timer); conn->timer = NULL; cliHandleFastFail(conn, code); return; @@ -1381,9 +1381,9 @@ static void cliHandleBatchReq(SCliBatch* pBatch, SCliThrd* pThrd) { ret = uv_tcp_connect(&conn->connReq, (uv_tcp_t*)(conn->stream), (const struct sockaddr*)&addr, cliConnCb); if (ret != 0) { - uv_timer_stop(conn->timer); + (void)uv_timer_stop(conn->timer); conn->timer->data = NULL; - taosArrayPush(pThrd->timerList, &conn->timer); + (void)taosArrayPush(pThrd->timerList, &conn->timer); conn->timer = NULL; cliMayUpdateFqdnCache(pThrd->fqdn2ipCache, conn->dstAddr); @@ -1461,7 +1461,7 @@ static void cliHandleFastFail(SCliConn* pConn, int status) { } } else { SFailFastItem item = {.count = 1, .timestamp = cTimestamp}; - taosHashPut(pThrd->failFastCache, pConn->dstAddr, strlen(pConn->dstAddr), &item, sizeof(SFailFastItem)); + (void)taosHashPut(pThrd->failFastCache, pConn->dstAddr, strlen(pConn->dstAddr), &item, sizeof(SFailFastItem)); } } } else { @@ -1499,12 +1499,12 @@ void cliConnCb(uv_connect_t* req, int status) { struct sockaddr peername, sockname; int addrlen = sizeof(peername); - uv_tcp_getpeername((uv_tcp_t*)pConn->stream, &peername, &addrlen); - transSockInfo2Str(&peername, pConn->dst); + (void)uv_tcp_getpeername((uv_tcp_t*)pConn->stream, &peername, &addrlen); + (void)transSockInfo2Str(&peername, pConn->dst); addrlen = sizeof(sockname); - uv_tcp_getsockname((uv_tcp_t*)pConn->stream, &sockname, &addrlen); - transSockInfo2Str(&sockname, pConn->src); + (void)uv_tcp_getsockname((uv_tcp_t*)pConn->stream, &sockname, &addrlen); + (void)transSockInfo2Str(&sockname, pConn->src); struct sockaddr_in addr = *(struct sockaddr_in*)&sockname; struct sockaddr_in saddr = *(struct sockaddr_in*)&peername; @@ -1554,8 +1554,8 @@ static void cliHandleQuit(SCliMsg* pMsg, SCliThrd* pThrd) { tDebug("cli work thread %p start to quit", pThrd); destroyCmsg(pMsg); - destroyConnPool(pThrd); - uv_walk(pThrd->loop, cliWalkCb, NULL); + (void)destroyConnPool(pThrd); + (void)uv_walk(pThrd->loop, cliWalkCb, NULL); } static void cliHandleRelease(SCliMsg* pMsg, SCliThrd* pThrd) { int64_t refId = (int64_t)(pMsg->msg.info.handle); @@ -1570,7 +1570,7 @@ static void cliHandleRelease(SCliMsg* pMsg, SCliThrd* pThrd) { SCliConn* conn = exh->handle; taosRUnLockLatch(&exh->latch); - transReleaseExHandle(transGetRefMgt(), refId); + (void)transReleaseExHandle(transGetRefMgt(), refId); tDebug("%s conn %p start to release to inst", CONN_GET_INST_LABEL(conn), conn); if (T_REF_VAL_GET(conn) == 2) { @@ -1705,7 +1705,7 @@ static void cliMayUpdateFqdnCache(SHashObj* cache, char* dst) { if (i > 0) { char fqdn[TSDB_FQDN_LEN + 1] = {0}; memcpy(fqdn, dst, i); - cliUpdateFqdnCache(cache, fqdn); + (void)cliUpdateFqdnCache(cache, fqdn); } } @@ -1742,7 +1742,7 @@ void cliHandleReq(SCliMsg* pMsg, SCliThrd* pThrd) { if (ignore == true) { // persist conn already release by server STransMsg resp = {0}; - cliBuildExceptResp(pMsg, &resp); + (void)cliBuildExceptResp(pMsg, &resp); // refactorr later resp.info.cliVer = pTransInst->compatibilityVer; @@ -1780,16 +1780,16 @@ void cliHandleReq(SCliMsg* pMsg, SCliThrd* pThrd) { if (refId != 0) specifyConnRef(conn, true, refId); transCtxMerge(&conn->ctx, &pMsg->ctx->appCtx); - transQueuePush(&conn->cliMsgs, pMsg); + (void)transQueuePush(&conn->cliMsgs, pMsg); conn->dstAddr = taosStrdup(addr); uint32_t ipaddr; int32_t code = cliGetIpFromFqdnCache(pThrd->fqdn2ipCache, fqdn, &ipaddr); if (code != 0) { - uv_timer_stop(conn->timer); + (void)uv_timer_stop(conn->timer); conn->timer->data = NULL; - taosArrayPush(pThrd->timerList, &conn->timer); + (void)taosArrayPush(pThrd->timerList, &conn->timer); conn->timer = NULL; cliHandleExcept(conn, code); @@ -1829,14 +1829,14 @@ void cliHandleReq(SCliMsg* pMsg, SCliThrd* pThrd) { if (ret != 0) { uv_timer_stop(conn->timer); conn->timer->data = NULL; - taosArrayPush(pThrd->timerList, &conn->timer); + (void)taosArrayPush(pThrd->timerList, &conn->timer); conn->timer = NULL; cliMayUpdateFqdnCache(pThrd->fqdn2ipCache, conn->dstAddr); cliHandleFastFail(conn, ret); return; } - uv_timer_start(conn->timer, cliConnTimeout, TRANS_CONN_TIMEOUT, 0); + (void)uv_timer_start(conn->timer, cliConnTimeout, TRANS_CONN_TIMEOUT, 0); } tGTrace("%s conn %p ready", pTransInst->label, conn); } @@ -1989,9 +1989,9 @@ static void cliAsyncCb(uv_async_t* handle) { // batch process to avoid to lock/unlock frequently queue wq; - taosThreadMutexLock(&item->mtx); + (void)taosThreadMutexLock(&item->mtx); QUEUE_MOVE(&item->qmsg, &wq); - taosThreadMutexUnlock(&item->mtx); + (void)taosThreadMutexUnlock(&item->mtx); int8_t supportBatch = pTransInst->supportBatch; if (supportBatch == 0) { @@ -2012,9 +2012,9 @@ static void cliPrepareCb(uv_prepare_t* handle) { SAsyncItem* item = async->data; queue wq; - taosThreadMutexLock(&item->mtx); + (void)taosThreadMutexLock(&item->mtx); QUEUE_MOVE(&item->qmsg, &wq); - taosThreadMutexUnlock(&item->mtx); + (void)taosThreadMutexUnlock(&item->mtx); int count = 0; while (!QUEUE_IS_EMPTY(&wq)) { @@ -2068,7 +2068,7 @@ bool cliRecvReleaseReq(SCliConn* conn, STransMsgHead* pHead) { tDebug("%s conn %p receive release request, refId:%" PRId64 ", may ignore", CONN_GET_INST_LABEL(conn), conn, conn->refId); - transClearBuffer(&conn->readBuf); + (void)transClearBuffer(&conn->readBuf); transFreeMsg(transContFromHead((char*)pHead)); for (int i = 0; ahandle == 0 && i < transQueueSize(&conn->cliMsgs); i++) { @@ -2243,8 +2243,8 @@ static int32_t createThrdObj(void* trans, SCliThrd** ppThrd) { if (timer == NULL) { TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, NULL, _end); } - uv_timer_init(pThrd->loop, timer); - taosArrayPush(pThrd->timerList, &timer); + (void)uv_timer_init(pThrd->loop, timer); + (void)taosArrayPush(pThrd->timerList, &timer); } pThrd->pool = createConnPool(4); @@ -2288,7 +2288,7 @@ static int32_t createThrdObj(void* trans, SCliThrd** ppThrd) { _end: if (pThrd) { - uv_loop_close(pThrd->loop); + (void)uv_loop_close(pThrd->loop); taosMemoryFree(pThrd->loop); taosMemoryFree(pThrd->prepare); taosThreadMutexDestroy(&pThrd->msgMtx); @@ -2312,9 +2312,9 @@ static void destroyThrdObj(SCliThrd* pThrd) { return; } - taosThreadJoin(pThrd->thread, NULL); + (void)taosThreadJoin(pThrd->thread, NULL); CLI_RELEASE_UV(pThrd->loop); - taosThreadMutexDestroy(&pThrd->msgMtx); + (void)taosThreadMutexDestroy(&pThrd->msgMtx); TRANS_DESTROY_ASYNC_POOL_MSG(pThrd->asyncPool, SCliMsg, destroyCmsgWrapper, (void*)pThrd); transAsyncPoolDestroy(pThrd->asyncPool); @@ -2381,9 +2381,9 @@ void cliWalkCb(uv_handle_t* handle, void* arg) { if (uv_handle_get_type(handle) == UV_TIMER) { // do nothing } else { - uv_read_stop((uv_stream_t*)handle); + (void)uv_read_stop((uv_stream_t*)handle); } - uv_close(handle, cliDestroy); + (void)uv_close(handle, cliDestroy); } } @@ -2421,7 +2421,7 @@ static void cliSchedMsgToDebug(SCliMsg* pMsg, char* label) { STransConnCtx* pCtx = pMsg->ctx; STraceId* trace = &pMsg->msg.info.traceId; char tbuf[512] = {0}; - epsetToStr(&pCtx->epSet, tbuf, tListLen(tbuf)); + (void)epsetToStr(&pCtx->epSet, tbuf, tListLen(tbuf)); tGDebug("%s retry on next node,use:%s, step: %d,timeout:%" PRId64 "", label, tbuf, pCtx->retryStep, pCtx->retryNextInterval); return; @@ -2436,7 +2436,7 @@ static void cliSchedMsgToNextNode(SCliMsg* pMsg, SCliThrd* pThrd) { arg->param1 = pMsg; arg->param2 = pThrd; - transDQSched(pThrd->delayQueue, doDelayTask, arg, pCtx->retryNextInterval); + (void)transDQSched(pThrd->delayQueue, doDelayTask, arg, pCtx->retryNextInterval); } FORCE_INLINE bool cliTryExtractEpSet(STransMsg* pResp, SEpSet* dst) { @@ -2654,7 +2654,7 @@ int cliAppCb(SCliConn* pConn, STransMsg* pResp, SCliMsg* pMsg) { if (hasEpSet) { if (rpcDebugFlag & DEBUG_TRACE) { char tbuf[512] = {0}; - epsetToStr(&pCtx->epSet, tbuf, tListLen(tbuf)); + (void)epsetToStr(&pCtx->epSet, tbuf, tListLen(tbuf)); tGTrace("%s conn %p extract epset from msg", CONN_GET_INST_LABEL(pConn), pConn); } } @@ -2666,7 +2666,7 @@ int cliAppCb(SCliConn* pConn, STransMsg* pResp, SCliMsg* pMsg) { } else { memcpy((char*)pCtx->pRsp, (char*)pResp, sizeof(*pResp)); } - tsem_post(pCtx->pSem); + (void)tsem_post(pCtx->pSem); pCtx->pRsp = NULL; } else { STransSyncMsg* pSyncMsg = taosAcquireRef(transGetSyncMsgMgt(), pCtx->syncMsgRef); @@ -2676,8 +2676,8 @@ int cliAppCb(SCliConn* pConn, STransMsg* pResp, SCliMsg* pMsg) { pSyncMsg->hasEpSet = 1; epsetAssign(&pSyncMsg->epSet, &pCtx->epSet); } - tsem2_post(pSyncMsg->pSem); - taosReleaseRef(transGetSyncMsgMgt(), pCtx->syncMsgRef); + (void)tsem2_post(pSyncMsg->pSem); + (void)taosReleaseRef(transGetSyncMsgMgt(), pCtx->syncMsgRef); } else { rpcFreeCont(pResp->pCont); } @@ -2746,7 +2746,7 @@ static FORCE_INLINE SCliThrd* transGetWorkThrdFromHandle(STrans* trans, int64_t pThrd = exh->pThrd; taosWUnLockLatch(&exh->latch); - transReleaseExHandle(transGetRefMgt(), handle); + (void)transReleaseExHandle(transGetRefMgt(), handle); return pThrd; } @@ -2839,7 +2839,7 @@ int transSendRequest(void* shandle, const SEpSet* pEpSet, STransMsg* pReq, STran SCliThrd* pThrd = transGetWorkThrd(pTransInst, handle); if (pThrd == NULL) { transFreeMsg(pReq->pCont); - transReleaseExHandle(transGetInstMgt(), (int64_t)shandle); + (void)transReleaseExHandle(transGetInstMgt(), (int64_t)shandle); return TSDB_CODE_RPC_BROKEN_LINK; } if (handle != 0) { @@ -2854,19 +2854,19 @@ int transSendRequest(void* shandle, const SEpSet* pEpSet, STransMsg* pReq, STran QUEUE_PUSH(&exh->q, &pCliMsg->seqq); taosWUnLockLatch(&exh->latch); tDebug("msg refId: %" PRId64 "", handle); - transReleaseExHandle(transGetInstMgt(), (int64_t)shandle); + (void)transReleaseExHandle(transGetInstMgt(), (int64_t)shandle); return 0; } exh->inited = 1; taosWUnLockLatch(&exh->latch); - transReleaseExHandle(transGetRefMgt(), handle); + (void)transReleaseExHandle(transGetRefMgt(), handle); } } SCliMsg* pCliMsg = NULL; code = transInitMsg(shandle, pEpSet, pReq, ctx, &pCliMsg); if (code != 0) { - transReleaseExHandle(transGetInstMgt(), (int64_t)shandle); + (void)transReleaseExHandle(transGetInstMgt(), (int64_t)shandle); return code; } @@ -2875,10 +2875,10 @@ int transSendRequest(void* shandle, const SEpSet* pEpSet, STransMsg* pReq, STran EPSET_GET_INUSE_IP(pEpSet), EPSET_GET_INUSE_PORT(pEpSet), pReq->info.ahandle); if ((code = transAsyncSend(pThrd->asyncPool, &(pCliMsg->q))) != 0) { destroyCmsg(pCliMsg); - transReleaseExHandle(transGetInstMgt(), (int64_t)shandle); + (void)transReleaseExHandle(transGetInstMgt(), (int64_t)shandle); return (code == TSDB_CODE_RPC_ASYNC_MODULE_QUIT ? TSDB_CODE_RPC_MODULE_QUIT : code); } - transReleaseExHandle(transGetInstMgt(), (int64_t)shandle); + (void)transReleaseExHandle(transGetInstMgt(), (int64_t)shandle); return 0; } @@ -2958,11 +2958,11 @@ int transSendRecv(void* shandle, const SEpSet* pEpSet, STransMsg* pReq, STransMs _RETURN: tsem_destroy(sem); taosMemoryFree(sem); - transReleaseExHandle(transGetInstMgt(), (int64_t)shandle); + (void)transReleaseExHandle(transGetInstMgt(), (int64_t)shandle); taosMemoryFree(pTransRsp); return code; _RETURN1: - transReleaseExHandle(transGetInstMgt(), (int64_t)shandle); + (void)transReleaseExHandle(transGetInstMgt(), (int64_t)shandle); taosMemoryFree(pTransRsp); taosMemoryFree(pReq->pCont); return code; @@ -2998,7 +2998,7 @@ int32_t transCreateSyncMsg(STransMsg* pTransMsg, int64_t* refId) { return 0; _EXIT: - tsem2_destroy(sem); + (void)tsem2_destroy(sem); taosMemoryFree(sem); taosMemoryFree(pSyncMsg); return code; @@ -3083,14 +3083,14 @@ int transSendRecvWithTimeout(void* shandle, SEpSet* pEpSet, STransMsg* pReq, STr code = 0; } _RETURN: - transReleaseExHandle(transGetInstMgt(), (int64_t)shandle); - taosReleaseRef(transGetSyncMsgMgt(), ref); + (void)transReleaseExHandle(transGetInstMgt(), (int64_t)shandle); + (void)taosReleaseRef(transGetSyncMsgMgt(), ref); taosRemoveRef(transGetSyncMsgMgt(), ref); return code; _RETURN2: transFreeMsg(pReq->pCont); taosMemoryFree(pTransMsg); - transReleaseExHandle(transGetInstMgt(), (int64_t)shandle); + (void)transReleaseExHandle(transGetInstMgt(), (int64_t)shandle); return code; } /* @@ -3141,7 +3141,7 @@ int transSetDefaultAddr(void* shandle, const char* ip, const char* fqdn) { } } - transReleaseExHandle(transGetInstMgt(), (int64_t)shandle); + (void)transReleaseExHandle(transGetInstMgt(), (int64_t)shandle); return code; } diff --git a/source/libs/transport/src/transComm.c b/source/libs/transport/src/transComm.c index aa6b377423..ee747b8a39 100644 --- a/source/libs/transport/src/transComm.c +++ b/source/libs/transport/src/transComm.c @@ -237,7 +237,7 @@ bool transReadComplete(SConnBuffer* connBuf) { int transSetConnOption(uv_tcp_t* stream, int keepalive) { #if defined(WINDOWS) || defined(DARWIN) #else - uv_tcp_keepalive(stream, 1, keepalive); + return uv_tcp_keepalive(stream, 1, keepalive); #endif return uv_tcp_nodelay(stream, 1); // int ret = uv_tcp_keepalive(stream, 5, 60); @@ -269,7 +269,7 @@ int32_t transAsyncPoolCreate(uv_loop_t* loop, int sz, void* arg, AsyncCB cb, SAs } item->pThrd = arg; QUEUE_INIT(&item->qmsg); - taosThreadMutexInit(&item->mtx, NULL); + (void)taosThreadMutexInit(&item->mtx, NULL); async->data = item; err = uv_async_init(loop, async, cb); @@ -298,7 +298,7 @@ void transAsyncPoolDestroy(SAsyncPool* pool) { SAsyncItem* item = async->data; if (item == NULL) continue; - taosThreadMutexDestroy(&item->mtx); + (void)taosThreadMutexDestroy(&item->mtx); taosMemoryFree(item); } taosMemoryFree(pool->asyncs); @@ -325,9 +325,9 @@ int transAsyncSend(SAsyncPool* pool, queue* q) { uv_async_t* async = &(pool->asyncs[idx]); SAsyncItem* item = async->data; - taosThreadMutexLock(&item->mtx); + (void)taosThreadMutexLock(&item->mtx); QUEUE_PUSH(&item->qmsg, q); - taosThreadMutexUnlock(&item->mtx); + (void)taosThreadMutexUnlock(&item->mtx); int ret = uv_async_send(async); if (ret != 0) { tError("failed to send async,reason:%s", uv_err_name(ret)); @@ -391,7 +391,7 @@ void* transCtxDumpVal(STransCtx* ctx, int32_t key) { return NULL; } void* ret = NULL; - (*cVal->clone)(cVal->val, &ret); + (void)(*cVal->clone)(cVal->val, &ret); return ret; } void* transCtxDumpBrokenlinkVal(STransCtx* ctx, int32_t* msgType) { @@ -399,7 +399,7 @@ void* transCtxDumpBrokenlinkVal(STransCtx* ctx, int32_t* msgType) { if (ctx->brokenVal.clone == NULL) { return ret; } - (*ctx->brokenVal.clone)(ctx->brokenVal.val, &ret); + (void)(*ctx->brokenVal.clone)(ctx->brokenVal.val, &ret); *msgType = ctx->brokenVal.msgType; @@ -451,7 +451,7 @@ bool transQueuePush(STransQueue* queue, void* arg) { if (queue->q == NULL) { return true; } - taosArrayPush(queue->q, &arg); + (void)taosArrayPush(queue->q, &arg); if (taosArrayGetSize(queue->q) > 1) { return false; } @@ -545,7 +545,7 @@ static void transDQTimeout(uv_timer_t* timer) { } } while (1); if (timeout != 0) { - uv_timer_start(queue->timer, transDQTimeout, timeout, 0); + (void)uv_timer_start(queue->timer, transDQTimeout, timeout, 0); } } int32_t transDQCreate(uv_loop_t* loop, SDelayQueue** queue) { @@ -610,7 +610,7 @@ void transDQDestroy(SDelayQueue* queue, void (*freeFunc)(void* arg)) { taosMemoryFree(queue); } void transDQCancel(SDelayQueue* queue, SDelayTask* task) { - uv_timer_stop(queue->timer); + (void)uv_timer_stop(queue->timer); if (heapSize(queue->heap) <= 0) { taosMemoryFree(task->arg); @@ -630,7 +630,7 @@ void transDQCancel(SDelayQueue* queue, SDelayTask* task) { SDelayTask* task = container_of(minNode, SDelayTask, node); uint64_t timeout = now > task->execTime ? now - task->execTime : 0; - uv_timer_start(queue->timer, transDQTimeout, timeout, 0); + (void)uv_timer_start(queue->timer, transDQTimeout, timeout, 0); } } @@ -655,7 +655,7 @@ SDelayTask* transDQSched(SDelayQueue* queue, void (*func)(void* arg), void* arg, tTrace("timer %p put task into delay queue, timeoutMs:%" PRIu64, queue->timer, timeoutMs); heapInsert(queue->heap, &task->node); - uv_timer_start(queue->timer, transDQTimeout, timeoutMs, 0); + (void)uv_timer_start(queue->timer, transDQTimeout, timeoutMs, 0); return task; } @@ -703,7 +703,7 @@ static void transInitEnv() { refMgt = transOpenRefMgt(50000, transDestroyExHandle); instMgt = taosOpenRef(50, rpcCloseImpl); transSyncMsgMgt = taosOpenRef(50, transDestroySyncMsg); - uv_os_setenv("UV_TCP_SINGLE_ACCEPT", "1"); + (void)uv_os_setenv("UV_TCP_SINGLE_ACCEPT", "1"); } static void transDestroyEnv() { transCloseRefMgt(refMgt); @@ -734,7 +734,7 @@ int32_t transOpenRefMgt(int size, void (*func)(void*)) { } void transCloseRefMgt(int32_t mgt) { // close ref - taosCloseRef(mgt); + (void)taosCloseRef(mgt); } int64_t transAddExHandle(int32_t refMgt, void* p) { // acquire extern handle @@ -769,7 +769,7 @@ void transDestroySyncMsg(void* msg) { if (msg == NULL) return; STransSyncMsg* pSyncMsg = msg; - tsem2_destroy(pSyncMsg->pSem); + (void)tsem2_destroy(pSyncMsg->pSem); taosMemoryFree(pSyncMsg->pSem); transFreeMsg(pSyncMsg->pRsp->pCont); taosMemoryFree(pSyncMsg->pRsp); diff --git a/source/libs/transport/src/transSvr.c b/source/libs/transport/src/transSvr.c index 2f6c687df2..e94e6f5355 100644 --- a/source/libs/transport/src/transSvr.c +++ b/source/libs/transport/src/transSvr.c @@ -184,11 +184,11 @@ static void* transAcceptThread(void* arg); static int32_t addHandleToWorkloop(SWorkThrd* pThrd, char* pipeName); static int32_t addHandleToAcceptloop(void* arg); -#define SRV_RELEASE_UV(loop) \ - do { \ - uv_walk(loop, uvWalkCb, NULL); \ - uv_run(loop, UV_RUN_DEFAULT); \ - uv_loop_close(loop); \ +#define SRV_RELEASE_UV(loop) \ + do { \ + (void)uv_walk(loop, uvWalkCb, NULL); \ + (void)uv_run(loop, UV_RUN_DEFAULT); \ + (void)uv_loop_close(loop); \ } while (0); #define ASYNC_ERR_JRET(thrd) \ @@ -484,7 +484,7 @@ static bool uvHandleReq(SSvrConn* pConn) { pConnInfo->clientPort = pConn->port; tstrncpy(pConnInfo->user, pConn->user, sizeof(pConnInfo->user)); - transReleaseExHandle(transGetRefMgt(), pConn->refId); + (void)transReleaseExHandle(transGetRefMgt(), pConn->refId); (*pTransInst->cfp)(pTransInst->parent, &transMsg, NULL); return true; @@ -578,7 +578,7 @@ void uvOnSendCb(uv_write_t* req, int status) { (pTransInst->cfp)(pTransInst->parent, &(conn->regArg.msg), NULL); memset(&conn->regArg, 0, sizeof(conn->regArg)); } - transQueuePop(&conn->srvMsgs); + (void)transQueuePop(&conn->srvMsgs); taosMemoryFree(msg); msg = (SSvrMsg*)transQueueGet(&conn->srvMsgs, 0); @@ -634,7 +634,7 @@ static int uvPrepareSendData(SSvrMsg* smsg, uv_buf_t* wb) { // handle invalid drop_task resp, TD-20098 if (pConn->inType == TDMT_SCH_DROP_TASK && pMsg->code == TSDB_CODE_VND_INVALID_VGROUP_ID) { - transQueuePop(&pConn->srvMsgs); + (void)transQueuePop(&pConn->srvMsgs); destroySmsg(smsg); return TSDB_CODE_INVALID_MSG; } @@ -690,7 +690,7 @@ static FORCE_INLINE void uvStartSendRespImpl(SSvrMsg* smsg) { transRefSrvHandle(pConn); uv_write_t* req = transReqQueuePush(&pConn->wreqQueue); - uv_write(req, (uv_stream_t*)pConn->pTcp, &wb, 1, uvOnSendCb); + (void)uv_write(req, (uv_stream_t*)pConn->pTcp, &wb, 1, uvOnSendCb); } static void uvStartSendResp(SSvrMsg* smsg) { // impl @@ -742,9 +742,9 @@ void uvWorkerAsyncCb(uv_async_t* handle) { queue wq; // batch process to avoid to lock/unlock frequently - taosThreadMutexLock(&item->mtx); + (void)taosThreadMutexLock(&item->mtx); QUEUE_MOVE(&item->qmsg, &wq); - taosThreadMutexUnlock(&item->mtx); + (void)taosThreadMutexUnlock(&item->mtx); while (!QUEUE_IS_EMPTY(&wq)) { queue* head = QUEUE_HEAD(&wq); @@ -767,12 +767,12 @@ void uvWorkerAsyncCb(uv_async_t* handle) { SExHandle* exh2 = transAcquireExHandle(transGetRefMgt(), refId); if (exh2 == NULL || exh1 != exh2) { tTrace("handle except msg %p, ignore it", exh1); - transReleaseExHandle(transGetRefMgt(), refId); + (void)transReleaseExHandle(transGetRefMgt(), refId); destroySmsg(msg); continue; } msg->pConn = exh1->handle; - transReleaseExHandle(transGetRefMgt(), refId); + (void)transReleaseExHandle(transGetRefMgt(), refId); (*transAsyncHandle[msg->type])(msg, pThrd); } } @@ -810,7 +810,7 @@ static bool uvRecvReleaseReq(SSvrConn* pConn, STransMsgHead* pHead) { tTrace("conn %p received release request", pConn); STraceId traceId = pHead->traceId; - transClearBuffer(&pConn->readBuf); + (void)transClearBuffer(&pConn->readBuf); transFreeMsg(transContFromHead((char*)pHead)); if (pConn->status != ConnAcquire) { return true; @@ -846,9 +846,9 @@ static void uvPrepareCb(uv_prepare_t* handle) { SAsyncItem* item = async->data; queue wq; - taosThreadMutexLock(&item->mtx); + (void)taosThreadMutexLock(&item->mtx); QUEUE_MOVE(&item->qmsg, &wq); - taosThreadMutexUnlock(&item->mtx); + (void)taosThreadMutexUnlock(&item->mtx); while (!QUEUE_IS_EMPTY(&wq)) { queue* head = QUEUE_HEAD(&wq); @@ -871,12 +871,12 @@ static void uvPrepareCb(uv_prepare_t* handle) { SExHandle* exh2 = transAcquireExHandle(transGetRefMgt(), refId); if (exh2 == NULL || exh1 != exh2) { tTrace("handle except msg %p, ignore it", exh1); - transReleaseExHandle(transGetRefMgt(), refId); + (void)transReleaseExHandle(transGetRefMgt(), refId); destroySmsg(msg); continue; } msg->pConn = exh1->handle; - transReleaseExHandle(transGetRefMgt(), refId); + (void)transReleaseExHandle(transGetRefMgt(), refId); (*transAsyncHandle[msg->type])(msg, pThrd); } } @@ -935,7 +935,7 @@ void uvOnAcceptCb(uv_stream_t* stream, int status) { tTrace("new connection accepted by main server, dispatch to %dth worker-thread", pObj->workerIdx); - uv_write2(wr, (uv_stream_t*)&(pObj->pipe[pObj->workerIdx][0]), &buf, 1, (uv_stream_t*)cli, uvOnPipeWriteCb); + (void)uv_write2(wr, (uv_stream_t*)&(pObj->pipe[pObj->workerIdx][0]), &buf, 1, (uv_stream_t*)cli, uvOnPipeWriteCb); } else { if (!uv_is_closing((uv_handle_t*)cli)) { tError("failed to accept tcp: %s", uv_err_name(err)); @@ -995,7 +995,7 @@ void uvOnConnectionCb(uv_stream_t* q, ssize_t nread, const uv_buf_t* buf) { if (uv_accept(q, (uv_stream_t*)(pConn->pTcp)) == 0) { uv_os_fd_t fd; - uv_fileno((const uv_handle_t*)pConn->pTcp, &fd); + (void)uv_fileno((const uv_handle_t*)pConn->pTcp, &fd); tTrace("conn %p created, fd:%d", pConn, fd); struct sockaddr peername, sockname; @@ -1005,7 +1005,7 @@ void uvOnConnectionCb(uv_stream_t* q, ssize_t nread, const uv_buf_t* buf) { transUnrefSrvHandle(pConn); return; } - transSockInfo2Str(&peername, pConn->dst); + (void)transSockInfo2Str(&peername, pConn->dst); addrlen = sizeof(sockname); if (0 != uv_tcp_getsockname(pConn->pTcp, (struct sockaddr*)&sockname, &addrlen)) { @@ -1013,7 +1013,7 @@ void uvOnConnectionCb(uv_stream_t* q, ssize_t nread, const uv_buf_t* buf) { transUnrefSrvHandle(pConn); return; } - transSockInfo2Str(&sockname, pConn->src); + (void)transSockInfo2Str(&sockname, pConn->src); struct sockaddr_in addr = *(struct sockaddr_in*)&peername; struct sockaddr_in saddr = *(struct sockaddr_in*)&sockname; @@ -1022,7 +1022,7 @@ void uvOnConnectionCb(uv_stream_t* q, ssize_t nread, const uv_buf_t* buf) { pConn->serverIp = saddr.sin_addr.s_addr; pConn->port = ntohs(addr.sin_port); - uv_read_start((uv_stream_t*)(pConn->pTcp), uvAllocRecvBufferCb, uvOnRecvCb); + (void)uv_read_start((uv_stream_t*)(pConn->pTcp), uvAllocRecvBufferCb, uvOnRecvCb); } else { tDebug("failed to create new connection"); @@ -1034,7 +1034,7 @@ void* transAcceptThread(void* arg) { // opt setThreadName("trans-accept"); SServerObj* srv = (SServerObj*)arg; - uv_run(srv->loop, UV_RUN_DEFAULT); + (void)uv_run(srv->loop, UV_RUN_DEFAULT); return NULL; } @@ -1043,7 +1043,7 @@ void uvOnPipeConnectionCb(uv_connect_t* connect, int status) { return; } SWorkThrd* pThrd = container_of(connect, SWorkThrd, connect_req); - uv_read_start((uv_stream_t*)pThrd->pipe, uvAllocConnBufferCb, uvOnConnectionCb); + (void)uv_read_start((uv_stream_t*)pThrd->pipe, uvAllocConnBufferCb, uvOnConnectionCb); } static int32_t addHandleToWorkloop(SWorkThrd* pThrd, char* pipeName) { int32_t code = 0; @@ -1165,7 +1165,7 @@ static int32_t addHandleToAcceptloop(void* arg) { void* transWorkerThread(void* arg) { setThreadName("trans-svr-work"); SWorkThrd* pThrd = (SWorkThrd*)arg; - uv_run(pThrd->loop, UV_RUN_DEFAULT); + (void)uv_run(pThrd->loop, UV_RUN_DEFAULT); return NULL; } @@ -1242,7 +1242,7 @@ static FORCE_INLINE SSvrConn* createConn(void* hThrd) { _end: if (pConn) { transQueueDestroy(&pConn->srvMsgs); - transDestroyBuffer(&pConn->readBuf); + (void)transDestroyBuffer(&pConn->readBuf); taosMemoryFree(pConn->pTcp); taosMemoryFree(pConn); pConn = NULL; @@ -1271,8 +1271,8 @@ static FORCE_INLINE void destroyConnRegArg(SSvrConn* conn) { } static int32_t reallocConnRef(SSvrConn* conn) { if (conn->refId > 0) { - transReleaseExHandle(transGetRefMgt(), conn->refId); - transRemoveExHandle(transGetRefMgt(), conn->refId); + (void)transReleaseExHandle(transGetRefMgt(), conn->refId); + (void)transRemoveExHandle(transGetRefMgt(), conn->refId); } // avoid app continue to send msg on invalid handle SExHandle* exh = taosMemoryMalloc(sizeof(SExHandle)); @@ -1308,8 +1308,8 @@ static void uvDestroyConn(uv_handle_t* handle) { } SWorkThrd* thrd = conn->hostThrd; - transReleaseExHandle(transGetRefMgt(), conn->refId); - transRemoveExHandle(transGetRefMgt(), conn->refId); + (void)transReleaseExHandle(transGetRefMgt(), conn->refId); + (void)transRemoveExHandle(transGetRefMgt(), conn->refId); STrans* pTransInst = thrd->pTransInst; tDebug("%s conn %p destroy", transLabel(pTransInst), conn); @@ -1324,7 +1324,7 @@ static void uvDestroyConn(uv_handle_t* handle) { QUEUE_REMOVE(&conn->queue); taosMemoryFree(conn->pTcp); destroyConnRegArg(conn); - transDestroyBuffer(&conn->readBuf); + (void)transDestroyBuffer(&conn->readBuf); taosMemoryFree(conn); if (thrd->quit && QUEUE_IS_EMPTY(&thrd->conn)) { @@ -1578,7 +1578,7 @@ void uvHandleRegister(SSvrMsg* msg, SWorkThrd* thrd) { if (!transQueuePush(&conn->srvMsgs, msg)) { return; } - transQueuePop(&conn->srvMsgs); + (void)transQueuePop(&conn->srvMsgs); if (conn->regArg.init) { transFreeMsg(conn->regArg.msg.pCont); @@ -1640,7 +1640,7 @@ void destroyWorkThrd(SWorkThrd* pThrd) { if (pThrd == NULL) { return; } - taosThreadJoin(pThrd->thread, NULL); + (void)taosThreadJoin(pThrd->thread, NULL); SRV_RELEASE_UV(pThrd->loop); TRANS_DESTROY_ASYNC_POOL_MSG(pThrd->asyncPool, SSvrMsg, destroySmsgWrapper, NULL); transAsyncPoolDestroy(pThrd->asyncPool); @@ -1655,7 +1655,7 @@ void sendQuitToWorkThrd(SWorkThrd* pThrd) { SSvrMsg* msg = taosMemoryCalloc(1, sizeof(SSvrMsg)); msg->type = Quit; tDebug("server send quit msg to work thread"); - transAsyncSend(pThrd->asyncPool, &msg->q); + (void)transAsyncSend(pThrd->asyncPool, &msg->q); } void transCloseServer(void* arg) { @@ -1664,8 +1664,8 @@ void transCloseServer(void* arg) { if (srv->inited) { tDebug("send quit msg to accept thread"); - uv_async_send(srv->pAcceptAsync); - taosThreadJoin(srv->thread, NULL); + (void)uv_async_send(srv->pAcceptAsync); + (void)taosThreadJoin(srv->thread, NULL); SRV_RELEASE_UV(srv->loop); for (int i = 0; i < srv->numOfThreads; i++) { @@ -1732,15 +1732,15 @@ int transReleaseSrvHandle(void* handle) { tDebug("%s conn %p start to release", transLabel(pThrd->pTransInst), exh->handle); if ((code = transAsyncSend(pThrd->asyncPool, &m->q)) != 0) { destroySmsg(m); - transReleaseExHandle(transGetRefMgt(), refId); + (void)transReleaseExHandle(transGetRefMgt(), refId); return code; } - transReleaseExHandle(transGetRefMgt(), refId); + (void)transReleaseExHandle(transGetRefMgt(), refId); return 0; _return1: tDebug("handle %p failed to send to release handle", exh); - transReleaseExHandle(transGetRefMgt(), refId); + (void)transReleaseExHandle(transGetRefMgt(), refId); return code; _return2: tDebug("handle %p failed to send to release handle", exh); @@ -1783,17 +1783,17 @@ int transSendResponse(const STransMsg* msg) { tGDebug("conn %p start to send resp (1/2)", exh->handle); if ((code = transAsyncSend(pThrd->asyncPool, &m->q)) != 0) { destroySmsg(m); - transReleaseExHandle(transGetRefMgt(), refId); + (void)transReleaseExHandle(transGetRefMgt(), refId); return code; } - transReleaseExHandle(transGetRefMgt(), refId); + (void)transReleaseExHandle(transGetRefMgt(), refId); return 0; _return1: tDebug("handle %p failed to send resp", exh); rpcFreeCont(msg->pCont); - transReleaseExHandle(transGetRefMgt(), refId); + (void)transReleaseExHandle(transGetRefMgt(), refId); return code; _return2: tDebug("handle %p failed to send resp", exh); @@ -1828,17 +1828,17 @@ int transRegisterMsg(const STransMsg* msg) { tDebug("%s conn %p start to register brokenlink callback", transLabel(pTransInst), exh->handle); if ((code = transAsyncSend(pThrd->asyncPool, &m->q)) != 0) { destroySmsg(m); - transReleaseExHandle(transGetRefMgt(), refId); + (void)transReleaseExHandle(transGetRefMgt(), refId); return code; } - transReleaseExHandle(transGetRefMgt(), refId); + (void)transReleaseExHandle(transGetRefMgt(), refId); return 0; _return1: tDebug("handle %p failed to register brokenlink", exh); rpcFreeCont(msg->pCont); - transReleaseExHandle(transGetRefMgt(), refId); + (void)transReleaseExHandle(transGetRefMgt(), refId); return code; _return2: tDebug("handle %p failed to register brokenlink", exh); @@ -1883,7 +1883,7 @@ int32_t transSetIpWhiteList(void* thandle, void* arg, FilteFunc* func) { break; } } - transReleaseExHandle(transGetInstMgt(), (int64_t)thandle); + (void)transReleaseExHandle(transGetInstMgt(), (int64_t)thandle); if (code != 0) { tError("ip-white-list update failed since %s", tstrerror(code)); From e42f013eaccb26053e2748514ad694390b3afea9 Mon Sep 17 00:00:00 2001 From: Cary Xu Date: Mon, 29 Jul 2024 22:03:50 +0800 Subject: [PATCH 26/28] Update tglobal.c --- source/common/src/tglobal.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/common/src/tglobal.c b/source/common/src/tglobal.c index 3b6daecdc6..ebaf1041c9 100644 --- a/source/common/src/tglobal.c +++ b/source/common/src/tglobal.c @@ -396,9 +396,9 @@ struct SConfig *taosGetCfg() { return tsCfg; } static int32_t taosLoadCfg(SConfig *pCfg, const char **envCmd, const char *inputCfgDir, const char *envFile, char *apolloUrl) { + int32_t code = 0; char cfgDir[PATH_MAX] = {0}; char cfgFile[PATH_MAX + 100] = {0}; - int32_t code = 0; TAOS_CHECK_RETURN(taosExpandDir(inputCfgDir, cfgDir, PATH_MAX)); char lastC = cfgDir[strlen(cfgDir) - 1]; From 1a2e4e178f8953b5eacbc660fa221442c56602f8 Mon Sep 17 00:00:00 2001 From: yihaoDeng Date: Tue, 30 Jul 2024 08:52:28 +0800 Subject: [PATCH 27/28] fix return code --- source/dnode/mgmt/node_mgmt/src/dmTransport.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/dnode/mgmt/node_mgmt/src/dmTransport.c b/source/dnode/mgmt/node_mgmt/src/dmTransport.c index cd608d7a74..b88feb83e2 100644 --- a/source/dnode/mgmt/node_mgmt/src/dmTransport.c +++ b/source/dnode/mgmt/node_mgmt/src/dmTransport.c @@ -24,7 +24,7 @@ static inline void dmBuildMnodeRedirectRsp(SDnode *pDnode, SRpcMsg *pMsg) { SEpSet epSet = {0}; dmGetMnodeEpSetForRedirect(&pDnode->data, pMsg, &epSet); - const int32_t contLen = tSerializeSEpSet(NULL, 0, &epSet); + int32_t contLen = tSerializeSEpSet(NULL, 0, &epSet); pMsg->pCont = rpcMallocCont(contLen); if (pMsg->pCont == NULL) { pMsg->code = TSDB_CODE_OUT_OF_MEMORY; From f090c9f96e991c11cf60fa4c93862bf9aa1703fa Mon Sep 17 00:00:00 2001 From: Hongze Cheng Date: Tue, 30 Jul 2024 09:39:50 +0800 Subject: [PATCH 28/28] enh: refactor error code --- source/common/src/tmsg.c | 6 +- source/dnode/vnode/src/meta/metaQuery.c | 48 +++++------ source/dnode/vnode/src/meta/metaTable.c | 102 ++++++++++++------------ source/util/src/tcache.c | 6 +- source/util/src/thash.c | 2 +- source/util/src/tlog.c | 18 ++--- source/util/src/tqueue.c | 2 +- source/util/src/tskiplist.c | 2 +- source/util/src/tworker.c | 20 ++--- 9 files changed, 103 insertions(+), 103 deletions(-) diff --git a/source/common/src/tmsg.c b/source/common/src/tmsg.c index 1db6fd2ff6..9e663d495c 100644 --- a/source/common/src/tmsg.c +++ b/source/common/src/tmsg.c @@ -2228,7 +2228,7 @@ int32_t tDeserializeSGetUserAuthRspImpl(SDecoder *pDecoder, SGetUserAuthRsp *pRs if ((value = taosMemoryCalloc(valuelen + 1, sizeof(char))) == NULL) goto _err; if (tDecodeCStrTo(pDecoder, value) < 0) goto _err; - taosHashPut(pRsp->writeTbs, key, keyLen, value, valuelen + 1); + if (taosHashPut(pRsp->writeTbs, key, keyLen, value, valuelen + 1) < 0) goto _err; taosMemoryFreeClear(key); taosMemoryFreeClear(value); @@ -2285,7 +2285,7 @@ int32_t tDeserializeSGetUserAuthRspImpl(SDecoder *pDecoder, SGetUserAuthRsp *pRs if ((value = taosMemoryCalloc(valuelen + 1, sizeof(char))) == NULL) goto _err; if (tDecodeCStrTo(pDecoder, value) < 0) goto _err; - taosHashPut(pRsp->writeViews, key, keyLen, value, valuelen + 1); + if (taosHashPut(pRsp->writeViews, key, keyLen, value, valuelen + 1) < 0) goto _err; taosMemoryFreeClear(key); taosMemoryFreeClear(value); @@ -7101,7 +7101,7 @@ int32_t tDeserializeSMqSeekReq(void *buf, int32_t bufLen, SMqSeekReq *pReq) { if (tStartDecode(&decoder) < 0) return -1; if (tDecodeI64(&decoder, &pReq->consumerId) < 0) return -1; - tDecodeCStrTo(&decoder, pReq->subKey); + if (tDecodeCStrTo(&decoder, pReq->subKey) < 0) return -1; tEndDecode(&decoder); diff --git a/source/dnode/vnode/src/meta/metaQuery.c b/source/dnode/vnode/src/meta/metaQuery.c index 5daa7817f6..d4ff980311 100644 --- a/source/dnode/vnode/src/meta/metaQuery.c +++ b/source/dnode/vnode/src/meta/metaQuery.c @@ -276,13 +276,13 @@ void metaResumeTbCursor(SMTbCursor *pTbCur, int8_t first, int8_t move) { (void)tdbTbcMoveToFirst((TBC *)pTbCur->pDbc); } else { int c = 1; - tdbTbcMoveTo(pTbCur->pDbc, pTbCur->pKey, pTbCur->kLen, &c); + (void)tdbTbcMoveTo(pTbCur->pDbc, pTbCur->pKey, pTbCur->kLen, &c); if (c == 0) { if (move) tdbTbcMoveToNext(pTbCur->pDbc); } else if (c < 0) { - tdbTbcMoveToPrev(pTbCur->pDbc); + (void)tdbTbcMoveToPrev(pTbCur->pDbc); } else { - tdbTbcMoveToNext(pTbCur->pDbc); + (void)tdbTbcMoveToNext(pTbCur->pDbc); } } @@ -303,7 +303,7 @@ int32_t metaTbCursorNext(SMTbCursor *pTbCur, ETableType jumpTableType) { tDecoderClear(&pTbCur->mr.coder); - metaGetTableEntryByVersion(&pTbCur->mr, ((SUidIdxVal *)pTbCur->pVal)[0].version, *(tb_uid_t *)pTbCur->pKey); + (void)metaGetTableEntryByVersion(&pTbCur->mr, ((SUidIdxVal *)pTbCur->pVal)[0].version, *(tb_uid_t *)pTbCur->pKey); if (pTbCur->mr.me.type == jumpTableType) { continue; } @@ -327,7 +327,7 @@ int32_t metaTbCursorPrev(SMTbCursor *pTbCur, ETableType jumpTableType) { tDecoderClear(&pTbCur->mr.coder); - metaGetTableEntryByVersion(&pTbCur->mr, ((SUidIdxVal *)pTbCur->pVal)[0].version, *(tb_uid_t *)pTbCur->pKey); + (void)metaGetTableEntryByVersion(&pTbCur->mr, ((SUidIdxVal *)pTbCur->pVal)[0].version, *(tb_uid_t *)pTbCur->pKey); if (pTbCur->mr.me.type == jumpTableType) { continue; } @@ -355,11 +355,11 @@ _query: version = ((SUidIdxVal *)pData)[0].version; - tdbTbGet(pMeta->pTbDb, &(STbDbKey){.uid = uid, .version = version}, sizeof(STbDbKey), &pData, &nData); + (void)tdbTbGet(pMeta->pTbDb, &(STbDbKey){.uid = uid, .version = version}, sizeof(STbDbKey), &pData, &nData); SMetaEntry me = {0}; tDecoderInit(&dc, pData, nData); - metaDecodeEntry(&dc, &me); + (void)metaDecodeEntry(&dc, &me); if (me.type == TSDB_SUPER_TABLE) { if (sver == -1 || sver == me.stbEntry.schemaRow.version) { pSchema = tCloneSSchemaWrapper(&me.stbEntry.schemaRow); @@ -385,7 +385,7 @@ _query: } tDecoderInit(&dc, pData, nData); - tDecodeSSchemaWrapperEx(&dc, &schema); + (void)tDecodeSSchemaWrapperEx(&dc, &schema); pSchema = tCloneSSchemaWrapper(&schema); tDecoderClear(&dc); @@ -472,17 +472,17 @@ int32_t metaResumeCtbCursor(SMCtbCursor *pCtbCur, int8_t first) { ctbIdxKey.suid = pCtbCur->suid; ctbIdxKey.uid = INT64_MIN; int c = 0; - tdbTbcMoveTo(pCtbCur->pCur, &ctbIdxKey, sizeof(ctbIdxKey), &c); + (void)tdbTbcMoveTo(pCtbCur->pCur, &ctbIdxKey, sizeof(ctbIdxKey), &c); if (c > 0) { - tdbTbcMoveToNext(pCtbCur->pCur); + (void)tdbTbcMoveToNext(pCtbCur->pCur); } } else { int c = 0; ret = tdbTbcMoveTo(pCtbCur->pCur, pCtbCur->pKey, pCtbCur->kLen, &c); if (c < 0) { - tdbTbcMoveToPrev(pCtbCur->pCur); + (void)tdbTbcMoveToPrev(pCtbCur->pCur); } else { - tdbTbcMoveToNext(pCtbCur->pCur); + (void)tdbTbcMoveToNext(pCtbCur->pCur); } } } @@ -540,9 +540,9 @@ SMStbCursor *metaOpenStbCursor(SMeta *pMeta, tb_uid_t suid) { } // move to the suid - tdbTbcMoveTo(pStbCur->pCur, &suid, sizeof(suid), &c); + (void)tdbTbcMoveTo(pStbCur->pCur, &suid, sizeof(suid), &c); if (c > 0) { - tdbTbcMoveToNext(pStbCur->pCur); + (void)tdbTbcMoveToNext(pStbCur->pCur); } return pStbCur; @@ -622,12 +622,12 @@ int32_t metaGetTbTSchemaEx(SMeta *pMeta, tb_uid_t suid, tb_uid_t uid, int32_t sv } if (c < 0) { - tdbTbcMoveToPrev(pSkmDbC); + (void)tdbTbcMoveToPrev(pSkmDbC); } const void *pKey = NULL; int32_t nKey = 0; - tdbTbcGet(pSkmDbC, &pKey, &nKey, NULL, NULL); + (void)tdbTbcGet(pSkmDbC, &pKey, &nKey, NULL, NULL); if (((SSkmDbKey *)pKey)->uid != skmDbKey.uid) { metaULock(pMeta); @@ -753,9 +753,9 @@ SMSmaCursor *metaOpenSmaCursor(SMeta *pMeta, tb_uid_t uid) { // move to the suid smaIdxKey.uid = uid; smaIdxKey.smaUid = INT64_MIN; - tdbTbcMoveTo(pSmaCur->pCur, &smaIdxKey, sizeof(smaIdxKey), &c); + (void)tdbTbcMoveTo(pSmaCur->pCur, &smaIdxKey, sizeof(smaIdxKey), &c); if (c > 0) { - tdbTbcMoveToNext(pSmaCur->pCur); + (void)tdbTbcMoveToNext(pSmaCur->pCur); } return pSmaCur; @@ -863,7 +863,7 @@ STSmaWrapper *metaGetSmaInfoByTable(SMeta *pMeta, tb_uid_t uid, bool deepCopy) { _err: metaReaderClear(&mr); taosArrayDestroy(pSmaIds); - tFreeTSmaWrapper(pSW, deepCopy); + (void)tFreeTSmaWrapper(pSW, deepCopy); return NULL; } @@ -1221,7 +1221,7 @@ int32_t metaFilterTableIds(void *pVnode, SMetaFltParam *arg, SArray *pUids) { } tbDbKey.uid = param->suid; tbDbKey.version = ((SUidIdxVal *)pData)[0].version; - tdbTbGet(pMeta->pTbDb, &tbDbKey, sizeof(tbDbKey), &pData, &nData); + (void)tdbTbGet(pMeta->pTbDb, &tbDbKey, sizeof(tbDbKey), &pData, &nData); tDecoderInit(&dc, pData, nData); ret = metaDecodeEntry(&dc, &oStbEntry); @@ -1427,7 +1427,7 @@ int32_t metaGetTableTags(void *pVnode, uint64_t suid, SArray *pUidTagInfo) { taosHashInit(numOfElems / 0.7, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK); for (int i = 0; i < numOfElems; i++) { STUidTagInfo *pTagInfo = taosArrayGet(pUidTagInfo, i); - taosHashPut(pSepecifiedUidMap, &pTagInfo->uid, sizeof(uint64_t), &i, sizeof(int32_t)); + (void)taosHashPut(pSepecifiedUidMap, &pTagInfo->uid, sizeof(uint64_t), &i, sizeof(int32_t)); } } @@ -1513,7 +1513,7 @@ int32_t metaGetInfo(SMeta *pMeta, int64_t uid, SMetaInfo *pInfo, SMetaReader *pR } // upsert the cache metaWLock(pMeta); - metaCacheUpsert(pMeta, pInfo); + (void)metaCacheUpsert(pMeta, pInfo); metaULock(pMeta); if (lock) { @@ -1565,7 +1565,7 @@ int32_t metaGetStbStats(void *pVnode, int64_t uid, int64_t *numOfTables, int32_t // upsert the cache metaWLock(pVnodeObj->pMeta); - metaStatsCacheUpsert(pVnodeObj->pMeta, &state); + (void)metaStatsCacheUpsert(pVnodeObj->pMeta, &state); metaULock(pVnodeObj->pMeta); _exit: @@ -1578,6 +1578,6 @@ void metaUpdateStbStats(SMeta *pMeta, int64_t uid, int64_t deltaCtb, int32_t del if (metaStatsCacheGet(pMeta, uid, &stats) == TSDB_CODE_SUCCESS) { stats.ctbNum += deltaCtb; stats.colNum += deltaCol; - metaStatsCacheUpsert(pMeta, &stats); + (void)metaStatsCacheUpsert(pMeta, &stats); } } diff --git a/source/dnode/vnode/src/meta/metaTable.c b/source/dnode/vnode/src/meta/metaTable.c index d6bba3486a..2badeec2c9 100644 --- a/source/dnode/vnode/src/meta/metaTable.c +++ b/source/dnode/vnode/src/meta/metaTable.c @@ -226,7 +226,7 @@ int metaDelJsonVarFromIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry, const SSche (void)indexMultiTermAdd(terms, term); } } - indexJsonPut(pMeta->pTagIvtIdx, terms, tuid); + (void)indexJsonPut(pMeta->pTagIvtIdx, terms, tuid); indexMultiTermDestroy(terms); taosArrayDestroy(pTagVals); #endif @@ -463,7 +463,7 @@ int metaAlterSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) { oStbEntry.pBuf = taosMemoryMalloc(nData); memcpy(oStbEntry.pBuf, pData, nData); tDecoderInit(&dc, oStbEntry.pBuf, nData); - metaDecodeEntry(&dc, &oStbEntry); + (void)metaDecodeEntry(&dc, &oStbEntry); nStbEntry.version = version; nStbEntry.type = TSDB_SUPER_TABLE; @@ -487,7 +487,7 @@ int metaAlterSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) { int8_t col_type = pReq->schemaRow.pSchema[nCols - 1].type; metaGetSubtables(pMeta, pReq->suid, uids); - tsdbCacheNewSTableColumn(pTsdb, uids, cid, col_type); + (void)tsdbCacheNewSTableColumn(pTsdb, uids, cid, col_type); } else if (deltaCol == -1) { int16_t cid = -1; bool hasPrimaryKey = false; @@ -503,7 +503,7 @@ int metaAlterSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) { if (cid != -1) { metaGetSubtables(pMeta, pReq->suid, uids); - tsdbCacheDropSTableColumn(pTsdb, uids, cid, hasPrimaryKey); + (void)tsdbCacheDropSTableColumn(pTsdb, uids, cid, hasPrimaryKey); } } if (uids) taosArrayDestroy(uids); @@ -530,7 +530,7 @@ int metaAlterSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) { if (updStat) { int64_t ctbNum; - metaGetStbStats(pMeta->pVnode, pReq->suid, &ctbNum, NULL); + (void)metaGetStbStats(pMeta->pVnode, pReq->suid, &ctbNum, NULL); pMeta->pVnode->config.vndStats.numOfTimeSeries += (ctbNum * deltaCol); metaTimeSeriesNotifyCheck(pMeta); } @@ -568,7 +568,7 @@ int metaAddIndexToSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) { tbDbKey.uid = suid; tbDbKey.version = ((SUidIdxVal *)pData)[0].version; - tdbTbGet(pMeta->pTbDb, &tbDbKey, sizeof(tbDbKey), &pData, &nData); + (void)tdbTbGet(pMeta->pTbDb, &tbDbKey, sizeof(tbDbKey), &pData, &nData); tDecoderInit(&dc, pData, nData); ret = metaDecodeEntry(&dc, &oStbEntry); @@ -672,7 +672,7 @@ int metaAddIndexToSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) { } metaWLock(pMeta); - tdbTbUpsert(pMeta->pTagIdx, pTagIdxKey, nTagIdxKey, NULL, 0, pMeta->txn); + (void)tdbTbUpsert(pMeta->pTagIdx, pTagIdxKey, nTagIdxKey, NULL, 0, pMeta->txn); metaULock(pMeta); metaDestroyTagIdxKey(pTagIdxKey); pTagIdxKey = NULL; @@ -729,7 +729,7 @@ int metaDropIndexFromSTable(SMeta *pMeta, int64_t version, SDropIndexReq *pReq) tbDbKey.uid = suid; tbDbKey.version = ((SUidIdxVal *)pData)[0].version; - tdbTbGet(pMeta->pTbDb, &tbDbKey, sizeof(tbDbKey), &pData, &nData); + (void)tdbTbGet(pMeta->pTbDb, &tbDbKey, sizeof(tbDbKey), &pData, &nData); tDecoderInit(&dc, pData, nData); ret = metaDecodeEntry(&dc, &oStbEntry); if (ret < 0) { @@ -937,7 +937,7 @@ int metaCreateTable(SMeta *pMeta, int64_t ver, SVCreateTbReq *pReq, STableMetaRs if (!sysTbl) { int32_t nCols = 0; - metaGetStbStats(pMeta->pVnode, me.ctbEntry.suid, 0, &nCols); + (void)metaGetStbStats(pMeta->pVnode, me.ctbEntry.suid, 0, &nCols); pStats->numOfTimeSeries += nCols - 1; } @@ -948,7 +948,7 @@ int metaCreateTable(SMeta *pMeta, int64_t ver, SVCreateTbReq *pReq, STableMetaRs metaULock(pMeta); if (!TSDB_CACHE_NO(pMeta->pVnode->config)) { - tsdbCacheNewTable(pMeta->pVnode->pTsdb, me.uid, me.ctbEntry.suid, NULL); + (void)tsdbCacheNewTable(pMeta->pVnode->pTsdb, me.uid, me.ctbEntry.suid, NULL); } } else { me.ntbEntry.btime = pReq->btime; @@ -964,7 +964,7 @@ int metaCreateTable(SMeta *pMeta, int64_t ver, SVCreateTbReq *pReq, STableMetaRs pStats->numOfNTimeSeries += me.ntbEntry.schemaRow.nCols - 1; if (!TSDB_CACHE_NO(pMeta->pVnode->config)) { - tsdbCacheNewTable(pMeta->pVnode->pTsdb, me.uid, -1, &me.ntbEntry.schemaRow); + (void)tsdbCacheNewTable(pMeta->pVnode->pTsdb, me.uid, -1, &me.ntbEntry.schemaRow); } } @@ -1036,7 +1036,7 @@ int metaDropTable(SMeta *pMeta, int64_t version, SVDropTbReq *pReq, SArray *tbUi (void)taosArrayPush(tbUids, &uid); if (!TSDB_CACHE_NO(pMeta->pVnode->config)) { - tsdbCacheDropTable(pMeta->pVnode->pTsdb, uid, suid, NULL); + (void)tsdbCacheDropTable(pMeta->pVnode->pTsdb, uid, suid, NULL); } } @@ -1070,7 +1070,7 @@ void metaDropTables(SMeta *pMeta, SArray *tbUids) { } else { nCtbDropped = 1; } - tSimpleHashPut(suidHash, &suid, sizeof(tb_uid_t), &nCtbDropped, sizeof(int64_t)); + (void)tSimpleHashPut(suidHash, &suid, sizeof(tb_uid_t), &nCtbDropped, sizeof(int64_t)); } /* if (!TSDB_CACHE_NO(pMeta->pVnode->config)) { @@ -1127,7 +1127,7 @@ static int32_t metaFilterTableByHash(SMeta *pMeta, SArray *uidList) { SMetaEntry me = {0}; SDecoder dc = {0}; tDecoderInit(&dc, pData, nData); - metaDecodeEntry(&dc, &me); + (void)metaDecodeEntry(&dc, &me); if (me.type != TSDB_SUPER_TABLE) { char tbFName[TSDB_TABLE_FNAME_LEN + 1]; @@ -1237,7 +1237,7 @@ static int metaDropTableByUid(SMeta *pMeta, tb_uid_t uid, int *type, tb_uid_t *p } int64_t version = ((SUidIdxVal *)pData)[0].version; - tdbTbGet(pMeta->pTbDb, &(STbDbKey){.version = version, .uid = uid}, sizeof(STbDbKey), &pData, &nData); + (void)tdbTbGet(pMeta->pTbDb, &(STbDbKey){.version = version, .uid = uid}, sizeof(STbDbKey), &pData, &nData); tDecoderInit(&dc, pData, nData); rc = metaDecodeEntry(&dc, &e); @@ -1260,7 +1260,7 @@ static int metaDropTableByUid(SMeta *pMeta, tb_uid_t uid, int *type, tb_uid_t *p SMetaEntry stbEntry = {0}; tDecoderInit(&tdc, tData, tLen); - metaDecodeEntry(&tdc, &stbEntry); + (void)metaDecodeEntry(&tdc, &stbEntry); if (pSysTbl) *pSysTbl = metaTbInFilterCache(pMeta, stbEntry.name, 1) ? 1 : 0; @@ -1268,7 +1268,7 @@ static int metaDropTableByUid(SMeta *pMeta, tb_uid_t uid, int *type, tb_uid_t *p SSchemaWrapper *pTagSchema = &stbEntry.stbEntry.schemaTag; if (pTagSchema->nCols == 1 && pTagSchema->pSchema[0].type == TSDB_DATA_TYPE_JSON) { pTagColumn = &stbEntry.stbEntry.schemaTag.pSchema[0]; - metaDelJsonVarFromIdx(pMeta, &e, pTagColumn); + (void)metaDelJsonVarFromIdx(pMeta, &e, pTagColumn); } else { for (int i = 0; i < pTagSchema->nCols; i++) { pTagColumn = &stbEntry.stbEntry.schemaTag.pSchema[i]; @@ -1346,12 +1346,12 @@ static int metaDropTableByUid(SMeta *pMeta, tb_uid_t uid, int *type, tb_uid_t *p // drop schema.db (todo) (void)metaStatsCacheDrop(pMeta, uid); - metaUidCacheClear(pMeta, uid); - metaTbGroupCacheClear(pMeta, uid); + (void)metaUidCacheClear(pMeta, uid); + (void)metaTbGroupCacheClear(pMeta, uid); --pMeta->pVnode->config.vndStats.numOfSTables; } - metaCacheDrop(pMeta, uid); + (void)metaCacheDrop(pMeta, uid); tDecoderClear(&dc); tdbFree(pData); @@ -1425,21 +1425,21 @@ static int metaAlterTableColumn(SMeta *pMeta, int64_t version, SVAlterTbReq *pAl TBC *pUidIdxc = NULL; (void)tdbTbcOpen(pMeta->pUidIdx, &pUidIdxc, NULL); - tdbTbcMoveTo(pUidIdxc, &uid, sizeof(uid), &c); + (void)tdbTbcMoveTo(pUidIdxc, &uid, sizeof(uid), &c); if (c != 0) { (void)tdbTbcClose(pUidIdxc); metaError("meta/table: invalide c: %" PRId32 " alt tb column failed.", c); return TSDB_CODE_FAILED; } - tdbTbcGet(pUidIdxc, NULL, NULL, &pData, &nData); + (void)tdbTbcGet(pUidIdxc, NULL, NULL, &pData, &nData); oversion = ((SUidIdxVal *)pData)[0].version; // search table.db TBC *pTbDbc = NULL; (void)tdbTbcOpen(pMeta->pTbDb, &pTbDbc, NULL); - tdbTbcMoveTo(pTbDbc, &((STbDbKey){.uid = uid, .version = oversion}), sizeof(STbDbKey), &c); + (void)tdbTbcMoveTo(pTbDbc, &((STbDbKey){.uid = uid, .version = oversion}), sizeof(STbDbKey), &c); if (c != 0) { (void)tdbTbcClose(pUidIdxc); (void)tdbTbcClose(pTbDbc); @@ -1447,7 +1447,7 @@ static int metaAlterTableColumn(SMeta *pMeta, int64_t version, SVAlterTbReq *pAl return TSDB_CODE_FAILED; } - tdbTbcGet(pTbDbc, NULL, NULL, &pData, &nData); + (void)tdbTbcGet(pTbDbc, NULL, NULL, &pData, &nData); // get table entry SDecoder dc = {0}; @@ -1537,7 +1537,7 @@ static int metaAlterTableColumn(SMeta *pMeta, int64_t version, SVAlterTbReq *pAl SSchema *pCol = &pSchema->pSchema[entry.ntbEntry.schemaRow.nCols - 1]; uint32_t compress = pAlterTbReq->action == TSDB_ALTER_TABLE_ADD_COLUMN ? createDefaultColCmprByType(pCol->type) : pAlterTbReq->compress; - updataTableColCmpr(&entry.colCmpr, pCol, 1, compress); + (void)updataTableColCmpr(&entry.colCmpr, pCol, 1, compress); freeColCmpr = true; ASSERT(entry.colCmpr.nCols == pSchema->nCols); break; @@ -1575,7 +1575,7 @@ static int metaAlterTableColumn(SMeta *pMeta, int64_t version, SVAlterTbReq *pAl (void)tsdbCacheDropNTableColumn(pMeta->pVnode->pTsdb, entry.uid, cid, hasPrimayKey); } - updataTableColCmpr(&entry.colCmpr, &tScheam, 0, 0); + (void)updataTableColCmpr(&entry.colCmpr, &tScheam, 0, 0); ASSERT(entry.colCmpr.nCols == pSchema->nCols); break; case TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES: @@ -1690,14 +1690,14 @@ static int metaUpdateTableTagVal(SMeta *pMeta, int64_t version, SVAlterTbReq *pA TBC *pUidIdxc = NULL; (void)tdbTbcOpen(pMeta->pUidIdx, &pUidIdxc, NULL); - tdbTbcMoveTo(pUidIdxc, &uid, sizeof(uid), &c); + (void)tdbTbcMoveTo(pUidIdxc, &uid, sizeof(uid), &c); if (c != 0) { (void)tdbTbcClose(pUidIdxc); metaError("meta/table: invalide c: %" PRId32 " update tb tag val failed.", c); return terrno = TSDB_CODE_TDB_TABLE_NOT_EXIST; } - tdbTbcGet(pUidIdxc, NULL, NULL, &pData, &nData); + (void)tdbTbcGet(pUidIdxc, NULL, NULL, &pData, &nData); oversion = ((SUidIdxVal *)pData)[0].version; // search table.db @@ -1707,7 +1707,7 @@ static int metaUpdateTableTagVal(SMeta *pMeta, int64_t version, SVAlterTbReq *pA /* get ctbEntry */ (void)tdbTbcOpen(pMeta->pTbDb, &pTbDbc, NULL); - tdbTbcMoveTo(pTbDbc, &((STbDbKey){.uid = uid, .version = oversion}), sizeof(STbDbKey), &c); + (void)tdbTbcMoveTo(pTbDbc, &((STbDbKey){.uid = uid, .version = oversion}), sizeof(STbDbKey), &c); if (c != 0) { (void)tdbTbcClose(pUidIdxc); (void)tdbTbcClose(pTbDbc); @@ -1715,25 +1715,25 @@ static int metaUpdateTableTagVal(SMeta *pMeta, int64_t version, SVAlterTbReq *pA return terrno = TSDB_CODE_TDB_TABLE_NOT_EXIST; } - tdbTbcGet(pTbDbc, NULL, NULL, &pData, &nData); + (void)tdbTbcGet(pTbDbc, NULL, NULL, &pData, &nData); ctbEntry.pBuf = taosMemoryMalloc(nData); memcpy(ctbEntry.pBuf, pData, nData); tDecoderInit(&dc1, ctbEntry.pBuf, nData); - metaDecodeEntry(&dc1, &ctbEntry); + (void)metaDecodeEntry(&dc1, &ctbEntry); /* get stbEntry*/ - tdbTbGet(pMeta->pUidIdx, &ctbEntry.ctbEntry.suid, sizeof(tb_uid_t), &pVal, &nVal); + (void)tdbTbGet(pMeta->pUidIdx, &ctbEntry.ctbEntry.suid, sizeof(tb_uid_t), &pVal, &nVal); if (!pVal) { terrno = TSDB_CODE_INVALID_MSG; goto _err; } - tdbTbGet(pMeta->pTbDb, &((STbDbKey){.uid = ctbEntry.ctbEntry.suid, .version = ((SUidIdxVal *)pVal)[0].version}), - sizeof(STbDbKey), (void **)&stbEntry.pBuf, &nVal); + (void)tdbTbGet(pMeta->pTbDb, &((STbDbKey){.uid = ctbEntry.ctbEntry.suid, .version = ((SUidIdxVal *)pVal)[0].version}), + sizeof(STbDbKey), (void **)&stbEntry.pBuf, &nVal); tdbFree(pVal); tDecoderInit(&dc2, stbEntry.pBuf, nVal); - metaDecodeEntry(&dc2, &stbEntry); + (void)metaDecodeEntry(&dc2, &stbEntry); SSchemaWrapper *pTagSchema = &stbEntry.stbEntry.schemaTag; SSchema *pColumn = NULL; @@ -1816,8 +1816,8 @@ static int metaUpdateTableTagVal(SMeta *pMeta, int64_t version, SVAlterTbReq *pA } SCtbIdxKey ctbIdxKey = {.suid = ctbEntry.ctbEntry.suid, .uid = uid}; - tdbTbUpsert(pMeta->pCtbIdx, &ctbIdxKey, sizeof(ctbIdxKey), ctbEntry.ctbEntry.pTags, - ((STag *)(ctbEntry.ctbEntry.pTags))->len, pMeta->txn); + (void)tdbTbUpsert(pMeta->pCtbIdx, &ctbIdxKey, sizeof(ctbIdxKey), ctbEntry.ctbEntry.pTags, + ((STag *)(ctbEntry.ctbEntry.pTags))->len, pMeta->txn); (void)metaUidCacheClear(pMeta, ctbEntry.ctbEntry.suid); (void)metaTbGroupCacheClear(pMeta, ctbEntry.ctbEntry.suid); @@ -1870,21 +1870,21 @@ static int metaUpdateTableOptions(SMeta *pMeta, int64_t version, SVAlterTbReq *p TBC *pUidIdxc = NULL; (void)tdbTbcOpen(pMeta->pUidIdx, &pUidIdxc, NULL); - tdbTbcMoveTo(pUidIdxc, &uid, sizeof(uid), &c); + (void)tdbTbcMoveTo(pUidIdxc, &uid, sizeof(uid), &c); if (c != 0) { (void)tdbTbcClose(pUidIdxc); metaError("meta/table: invalide c: %" PRId32 " update tb options failed.", c); return TSDB_CODE_FAILED; } - tdbTbcGet(pUidIdxc, NULL, NULL, &pData, &nData); + (void)tdbTbcGet(pUidIdxc, NULL, NULL, &pData, &nData); oversion = ((SUidIdxVal *)pData)[0].version; // search table.db TBC *pTbDbc = NULL; (void)tdbTbcOpen(pMeta->pTbDb, &pTbDbc, NULL); - tdbTbcMoveTo(pTbDbc, &((STbDbKey){.uid = uid, .version = oversion}), sizeof(STbDbKey), &c); + (void)tdbTbcMoveTo(pTbDbc, &((STbDbKey){.uid = uid, .version = oversion}), sizeof(STbDbKey), &c); if (c != 0) { (void)tdbTbcClose(pUidIdxc); (void)tdbTbcClose(pTbDbc); @@ -1892,7 +1892,7 @@ static int metaUpdateTableOptions(SMeta *pMeta, int64_t version, SVAlterTbReq *p return TSDB_CODE_FAILED; } - tdbTbcGet(pTbDbc, NULL, NULL, &pData, &nData); + (void)tdbTbcGet(pTbDbc, NULL, NULL, &pData, &nData); // get table entry SDecoder dc = {0}; @@ -1982,7 +1982,7 @@ static int metaAddTagIndex(SMeta *pMeta, int64_t version, SVAlterTbReq *pAlterTb STbDbKey tbDbKey = {0}; tbDbKey.uid = suid; tbDbKey.version = ((SUidIdxVal *)pVal)[0].version; - tdbTbGet(pMeta->pTbDb, &tbDbKey, sizeof(tbDbKey), &pVal, &nVal); + (void)tdbTbGet(pMeta->pTbDb, &tbDbKey, sizeof(tbDbKey), &pVal, &nVal); tDecoderInit(&dc, pVal, nVal); ret = metaDecodeEntry(&dc, &stbEntry); if (ret < 0) { @@ -2061,7 +2061,7 @@ static int metaAddTagIndex(SMeta *pMeta, int64_t version, SVAlterTbReq *pAlterTb (void)tdbTbcClose(pCtbIdxc); goto _err; } - tdbTbUpsert(pMeta->pTagIdx, pTagIdxKey, nTagIdxKey, NULL, 0, pMeta->txn); + (void)tdbTbUpsert(pMeta->pTagIdx, pTagIdxKey, nTagIdxKey, NULL, 0, pMeta->txn); metaDestroyTagIdxKey(pTagIdxKey); pTagIdxKey = NULL; } @@ -2116,7 +2116,7 @@ static int metaDropTagIndex(SMeta *pMeta, int64_t version, SVAlterTbReq *pAlterT STbDbKey tbDbKey = {0}; tbDbKey.uid = suid; tbDbKey.version = ((SUidIdxVal *)pVal)[0].version; - tdbTbGet(pMeta->pTbDb, &tbDbKey, sizeof(tbDbKey), &pVal, &nVal); + (void)tdbTbGet(pMeta->pTbDb, &tbDbKey, sizeof(tbDbKey), &pVal, &nVal); tDecoderInit(&dc, pVal, nVal); ret = metaDecodeEntry(&dc, &stbEntry); @@ -2363,7 +2363,7 @@ static int metaUpdateUidIdx(SMeta *pMeta, const SMetaEntry *pME) { // upsert cache SMetaInfo info; metaGetEntryInfo(pME, &info); - metaCacheUpsert(pMeta, &info); + (void)metaCacheUpsert(pMeta, &info); SUidIdxVal uidIdxVal = {.suid = info.suid, .version = info.version, .skmVer = info.skmVer}; @@ -2479,7 +2479,7 @@ static int metaUpdateTagIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry) { } tbDbKey.uid = pCtbEntry->ctbEntry.suid; tbDbKey.version = ((SUidIdxVal *)pData)[0].version; - tdbTbGet(pMeta->pTbDb, &tbDbKey, sizeof(tbDbKey), &pData, &nData); + (void)tdbTbGet(pMeta->pTbDb, &tbDbKey, sizeof(tbDbKey), &pData, &nData); tDecoderInit(&dc, pData, nData); ret = metaDecodeEntry(&dc, &stbEntry); @@ -2526,7 +2526,7 @@ static int metaUpdateTagIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry) { ret = -1; goto end; } - tdbTbUpsert(pMeta->pTagIdx, pTagIdxKey, nTagIdxKey, NULL, 0, pMeta->txn); + (void)tdbTbUpsert(pMeta->pTagIdx, pTagIdxKey, nTagIdxKey, NULL, 0, pMeta->txn); metaDestroyTagIdxKey(pTagIdxKey); pTagIdxKey = NULL; } @@ -2575,7 +2575,7 @@ static int metaSaveToSkmDb(SMeta *pMeta, const SMetaEntry *pME) { } tEncoderInit(&coder, pVal, vLen); - tEncodeSSchemaWrapper(&coder, pSW); + (void)tEncodeSSchemaWrapper(&coder, pSW); if (tdbTbInsert(pMeta->pSkmDb, &skmDbKey, sizeof(skmDbKey), pVal, vLen, pMeta->txn) < 0) { rcode = -1; @@ -2663,7 +2663,7 @@ int32_t colCompressDebug(SHashObj *pColCmprObj) { p = taosHashIterate(pColCmprObj, p); uint8_t l1, l2, lvl; - tcompressDebug(cmprAlg, &l1, &l2, &lvl); + (void)tcompressDebug(cmprAlg, &l1, &l2, &lvl); const char *l1str = columnEncodeStr(l1); const char *l2str = columnCompressStr(l2); @@ -2712,7 +2712,7 @@ int32_t metaGetColCmpr(SMeta *pMeta, tb_uid_t uid, SHashObj **ppColCmprObj) { SColCmprWrapper *p = &e.colCmpr; for (int32_t i = 0; i < p->nCols; i++) { SColCmpr *pCmpr = &p->pColCmpr[i]; - taosHashPut(pColCmprObj, &pCmpr->id, sizeof(pCmpr->id), &pCmpr->alg, sizeof(pCmpr->alg)); + (void)taosHashPut(pColCmprObj, &pCmpr->id, sizeof(pCmpr->id), &pCmpr->alg, sizeof(pCmpr->alg)); } } else { tDecoderClear(&dc); @@ -2726,7 +2726,7 @@ int32_t metaGetColCmpr(SMeta *pMeta, tb_uid_t uid, SHashObj **ppColCmprObj) { metaULock(pMeta); *ppColCmprObj = pColCmprObj; - colCompressDebug(pColCmprObj); + (void)colCompressDebug(pColCmprObj); return 0; } diff --git a/source/util/src/tcache.c b/source/util/src/tcache.c index d66128e2d1..c150ca3fbd 100644 --- a/source/util/src/tcache.c +++ b/source/util/src/tcache.c @@ -388,7 +388,7 @@ SCacheObj *taosCacheInit(int32_t keyType, int64_t refreshTimeInMs, bool extendLi } pCacheObj->name = taosStrdup(cacheName); - doRegisterCacheObj(pCacheObj); + (void)doRegisterCacheObj(pCacheObj); return pCacheObj; } @@ -616,7 +616,7 @@ void taosCacheRelease(SCacheObj *pCacheObj, void **data, bool _remove) { if (ref > 0) { taosAddToTrashcan(pCacheObj, pNode); } else { // ref == 0 - atomic_sub_fetch_64(&pCacheObj->sizeInBytes, pNode->size); + (void)atomic_sub_fetch_64(&pCacheObj->sizeInBytes, pNode->size); int32_t size = (int32_t)pCacheObj->numOfElems; uDebug("cache:%s, key:%p, %p is destroyed from cache, size:%dbytes, totalNum:%d size:%" PRId64 "bytes", @@ -670,7 +670,7 @@ void doTraverseElems(SCacheObj *pCacheObj, bool (*fp)(void *param, SCacheNode *p pEntry->num -= 1; ASSERT((pEntry->next && pEntry->num > 0) || (NULL == pEntry->next && pEntry->num == 0)); - atomic_sub_fetch_ptr(&pCacheObj->numOfElems, 1); + (void)atomic_sub_fetch_ptr(&pCacheObj->numOfElems, 1); pNode = next; } } diff --git a/source/util/src/thash.c b/source/util/src/thash.c index 6e2d1baf84..2daedfdf32 100644 --- a/source/util/src/thash.c +++ b/source/util/src/thash.c @@ -399,7 +399,7 @@ int32_t taosHashGetDup(SHashObj *pHashObj, const void *key, size_t keyLen, void int32_t taosHashGetDup_m(SHashObj *pHashObj, const void *key, size_t keyLen, void **destBuf, int32_t *size) { terrno = 0; - /*char* p = */ taosHashGetImpl(pHashObj, key, keyLen, destBuf, size, false); + (void)taosHashGetImpl(pHashObj, key, keyLen, destBuf, size, false); return terrno; } diff --git a/source/util/src/tlog.c b/source/util/src/tlog.c index 6f070a1d13..7f67c11f0a 100644 --- a/source/util/src/tlog.c +++ b/source/util/src/tlog.c @@ -271,7 +271,7 @@ static void taosUnLockLogFile(TdFilePtr pFile) { if (pFile == NULL) return; if (tsLogObj.fileNum > 1) { - taosUnLockFile(pFile); + (void)taosUnLockFile(pFile); } } @@ -478,7 +478,7 @@ static int32_t taosOpenLogFile(char *fn, int32_t maxFileNum) { char fileName[LOG_FILE_NAME_LEN + 50] = "\0"; sprintf(fileName, "%s.%d", tsLogObj.logName, tsLogObj.flag); - taosThreadMutexInit(&tsLogObj.logMutex, NULL); + (void)taosThreadMutexInit(&tsLogObj.logMutex, NULL); (void)taosUmaskFile(0); tsLogObj.logHandle->pFile = taosOpenFile(fileName, TD_FILE_CREATE | TD_FILE_WRITE); @@ -562,7 +562,7 @@ static inline void taosPrintLogImp(ELogLevel level, int32_t dflag, const char *b if (dflag & DEBUG_SCREEN) { #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-result" - write(1, buffer, (uint32_t)len); + (void)write(1, buffer, (uint32_t)len); #pragma GCC diagnostic pop } } @@ -914,11 +914,11 @@ void taosLogCrashInfo(char *nodeType, char *pMsg, int64_t msgLen, int signum, vo goto _return; } - taosLockFile(pFile); + (void)taosLockFile(pFile); int64_t writeSize = taosWriteFile(pFile, &msgLen, sizeof(msgLen)); if (sizeof(msgLen) != writeSize) { - taosUnLockFile(pFile); + (void)taosUnLockFile(pFile); taosPrintLog(flags, level, dflag, "failed to write len to file:%s,%p wlen:%" PRId64 " tlen:%lu since %s", filepath, pFile, writeSize, sizeof(msgLen), terrstr()); goto _return; @@ -926,7 +926,7 @@ void taosLogCrashInfo(char *nodeType, char *pMsg, int64_t msgLen, int signum, vo writeSize = taosWriteFile(pFile, pMsg, msgLen); if (msgLen != writeSize) { - taosUnLockFile(pFile); + (void)taosUnLockFile(pFile); taosPrintLog(flags, level, dflag, "failed to write file:%s,%p wlen:%" PRId64 " tlen:%" PRId64 " since %s", filepath, pFile, writeSize, msgLen, terrstr()); goto _return; @@ -990,7 +990,7 @@ void taosReadCrashInfo(char *filepath, char **pMsg, int64_t *pMsgLen, TdFilePtr return; } - taosLockFile(pFile); + (void)taosLockFile(pFile); } else { pFile = *pFd; } @@ -1031,7 +1031,7 @@ _return: if (truncateFile) { (void)taosFtruncateFile(pFile, 0); } - taosUnLockFile(pFile); + (void)taosUnLockFile(pFile); (void)taosCloseFile(&pFile); taosMemoryFree(buf); @@ -1045,7 +1045,7 @@ void taosReleaseCrashLogFile(TdFilePtr pFile, bool truncateFile) { (void)taosFtruncateFile(pFile, 0); } - taosUnLockFile(pFile); + (void)taosUnLockFile(pFile); (void)taosCloseFile(&pFile); } diff --git a/source/util/src/tqueue.c b/source/util/src/tqueue.c index d25e0b33de..87d5680aa0 100644 --- a/source/util/src/tqueue.c +++ b/source/util/src/tqueue.c @@ -232,7 +232,7 @@ int32_t taosWriteQitem(STaosQueue *queue, void *pItem) { (void)taosThreadMutexUnlock(&queue->mutex); if (queue->qset) { - tsem_post(&queue->qset->sem); + (void)tsem_post(&queue->qset->sem); } return code; } diff --git a/source/util/src/tskiplist.c b/source/util/src/tskiplist.c index 7fd09510bd..e5e52e44d9 100644 --- a/source/util/src/tskiplist.c +++ b/source/util/src/tskiplist.c @@ -115,7 +115,7 @@ void tSkipListDestroy(SSkipList *pSkipList) { (void)tSkipListUnlock(pSkipList); if (pSkipList->lock != NULL) { - taosThreadRwlockDestroy(pSkipList->lock); + (void)taosThreadRwlockDestroy(pSkipList->lock); taosMemoryFreeClear(pSkipList->lock); } diff --git a/source/util/src/tworker.c b/source/util/src/tworker.c index 9dad69e0b4..d66628d46d 100644 --- a/source/util/src/tworker.c +++ b/source/util/src/tworker.c @@ -713,7 +713,7 @@ static bool tQueryAutoQWorkerTryDecActive(void *p, int32_t minActive) { if (atomicCompareExchangeActiveAndRunning(&pPool->activeRunningN, &active, active - 1, &running, running - 1)) return true; } - atomicFetchSubRunning(&pPool->activeRunningN, 1); + (void)atomicFetchSubRunning(&pPool->activeRunningN, 1); return false; } @@ -732,7 +732,7 @@ static int32_t tQueryAutoQWorkerWaitingCheck(SQueryAutoQWorkerPool *pPool) { } // to wait for process (void)taosThreadMutexLock(&pPool->waitingBeforeProcessMsgLock); - atomic_fetch_add_32(&pPool->waitingBeforeProcessMsgN, 1); + (void)atomic_fetch_add_32(&pPool->waitingBeforeProcessMsgN, 1); if (!pPool->exit) (void)taosThreadCondWait(&pPool->waitingBeforeProcessMsgCond, &pPool->waitingBeforeProcessMsgLock); // recovered from waiting (void)taosThreadMutexUnlock(&pPool->waitingBeforeProcessMsgLock); @@ -744,7 +744,7 @@ bool tQueryAutoQWorkerTryRecycleWorker(SQueryAutoQWorkerPool *pPool, SQueryAutoQ tQueryAutoQWorkerTryDecActive(pPool, pPool->num)) { (void)taosThreadMutexLock(&pPool->poolLock); SListNode *pNode = listNode(pWorker); - tdListPopNode(pPool->workers, pNode); + (void)tdListPopNode(pPool->workers, pNode); // reclaim some workers if (pWorker->id >= pPool->maxInUse) { while (listNEles(pPool->exitedWorkers) > pPool->maxInUse - pPool->num) { @@ -767,7 +767,7 @@ bool tQueryAutoQWorkerTryRecycleWorker(SQueryAutoQWorkerPool *pPool, SQueryAutoQ // start to wait at backup cond (void)taosThreadMutexLock(&pPool->backupLock); - atomic_fetch_add_32(&pPool->backupNum, 1); + (void)atomic_fetch_add_32(&pPool->backupNum, 1); if (!pPool->exit) (void)taosThreadCondWait(&pPool->backupCond, &pPool->backupLock); (void)taosThreadMutexUnlock(&pPool->backupLock); @@ -777,7 +777,7 @@ bool tQueryAutoQWorkerTryRecycleWorker(SQueryAutoQWorkerPool *pPool, SQueryAutoQ (void)taosThreadMutexUnlock(&pPool->poolLock); return false; } - tdListPopNode(pPool->backupWorkers, pNode); + (void)tdListPopNode(pPool->backupWorkers, pNode); tdListAppendNode(pPool->workers, pNode); (void)taosThreadMutexUnlock(&pPool->poolLock); @@ -881,9 +881,9 @@ void tQueryAutoQWorkerCleanup(SQueryAutoQWorkerPool *pPool) { taosMemoryFree(pNode); } - tdListFree(pPool->workers); - tdListFree(pPool->backupWorkers); - tdListFree(pPool->exitedWorkers); + (void)tdListFree(pPool->workers); + (void)tdListFree(pPool->backupWorkers); + (void)tdListFree(pPool->exitedWorkers); taosMemoryFree(pPool->pCb); (void)taosThreadMutexDestroy(&pPool->poolLock); @@ -939,7 +939,7 @@ STaosQueue *tQueryAutoQWorkerAllocQueue(SQueryAutoQWorkerPool *pool, void *ahand (void)taosThreadAttrDestroy(&thAttr); pool->num++; - atomicFetchAddActive(&pool->activeRunningN, 1); + (void)atomicFetchAddActive(&pool->activeRunningN, 1); uInfo("worker:%s:%d is launched, total:%d", pool->name, pWorker->id, pool->num); } while (pool->num < pool->min); } @@ -1016,7 +1016,7 @@ static int32_t tQueryAutoQWorkerRecoverFromBlocking(void *p) { } } (void)taosThreadMutexLock(&pPool->waitingAfterBlockLock); - atomic_fetch_add_32(&pPool->waitingAfterBlockN, 1); + (void)atomic_fetch_add_32(&pPool->waitingAfterBlockN, 1); if (!pPool->exit) (void)taosThreadCondWait(&pPool->waitingAfterBlockCond, &pPool->waitingAfterBlockLock); (void)taosThreadMutexUnlock(&pPool->waitingAfterBlockLock); if (pPool->exit) return TSDB_CODE_QRY_QWORKER_QUIT;