diff --git a/include/libs/executor/executor.h b/include/libs/executor/executor.h index 324804aa7c..09143dde29 100644 --- a/include/libs/executor/executor.h +++ b/include/libs/executor/executor.h @@ -201,7 +201,7 @@ void qStreamSetOpen(qTaskInfo_t tinfo); void qStreamSetSourceExcluded(qTaskInfo_t tinfo, int8_t sourceExcluded); -void qStreamExtractOffset(qTaskInfo_t tinfo, STqOffsetVal* pOffset); +int32_t qStreamExtractOffset(qTaskInfo_t tinfo, STqOffsetVal* pOffset); SMqBatchMetaRsp* qStreamExtractMetaMsg(qTaskInfo_t tinfo); diff --git a/include/libs/stream/tstream.h b/include/libs/stream/tstream.h index 5f322be99b..0d1e62cdbe 100644 --- a/include/libs/stream/tstream.h +++ b/include/libs/stream/tstream.h @@ -682,13 +682,13 @@ void streamTaskCleanupCheckInfo(STaskCheckInfo* pInfo); // fill-history task int32_t streamLaunchFillHistoryTask(SStreamTask* pTask); int32_t streamStartScanHistoryAsync(SStreamTask* pTask, int8_t igUntreated); -int32_t streamExecScanHistoryInFuture(SStreamTask* pTask, int32_t idleDuration); +void streamExecScanHistoryInFuture(SStreamTask* pTask, int32_t idleDuration); bool streamHistoryTaskSetVerRangeStep2(SStreamTask* pTask, int64_t latestVer); // checkpoint related void streamTaskGetActiveCheckpointInfo(const SStreamTask* pTask, int32_t* pTransId, int64_t* pCheckpointId); int32_t streamTaskSetActiveCheckpointInfo(SStreamTask* pTask, int64_t activeCheckpointId); -int32_t streamTaskSetFailedChkptInfo(SStreamTask* pTask, int32_t transId, int64_t checkpointId); +void streamTaskSetFailedChkptInfo(SStreamTask* pTask, int32_t transId, int64_t checkpointId); bool streamTaskAlreadySendTrigger(SStreamTask* pTask, int32_t downstreamNodeId); void streamTaskGetTriggerRecvStatus(SStreamTask* pTask, int32_t* pRecved, int32_t* pTotal); void streamTaskInitTriggerDispatchInfo(SStreamTask* pTask); 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 808c917431..5e716ac866 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); @@ -7819,8 +7819,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; } @@ -7865,8 +7865,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; } @@ -7874,7 +7874,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; @@ -7883,7 +7883,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; @@ -10745,7 +10745,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) { @@ -10761,7 +10761,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/tq/tq.c b/source/dnode/vnode/src/tq/tq.c index 0ab420ce63..8a4571a4af 100644 --- a/source/dnode/vnode/src/tq/tq.c +++ b/source/dnode/vnode/src/tq/tq.c @@ -169,7 +169,7 @@ void tqPushEmptyDataRsp(STqHandle* pHandle, int32_t vgId) { } dataRsp.common.blockNum = 0; char buf[TSDB_OFFSET_LEN] = {0}; - tFormatOffset(buf, TSDB_OFFSET_LEN, &dataRsp.common.reqOffset); + (void) tFormatOffset(buf, TSDB_OFFSET_LEN, &dataRsp.common.reqOffset); tqInfo("tqPushEmptyDataRsp to consumer:0x%" PRIx64 " vgId:%d, offset:%s, reqId:0x%" PRIx64, req.consumerId, vgId, buf, req.reqId); @@ -187,8 +187,8 @@ int32_t tqSendDataRsp(STqHandle* pHandle, const SRpcMsg* pMsg, const SMqPollReq* char buf1[TSDB_OFFSET_LEN] = {0}; char buf2[TSDB_OFFSET_LEN] = {0}; - tFormatOffset(buf1, TSDB_OFFSET_LEN, &((SMqDataRspCommon*)pRsp)->reqOffset); - tFormatOffset(buf2, TSDB_OFFSET_LEN, &((SMqDataRspCommon*)pRsp)->rspOffset); + (void) tFormatOffset(buf1, TSDB_OFFSET_LEN, &((SMqDataRspCommon*)pRsp)->reqOffset); + (void) tFormatOffset(buf2, TSDB_OFFSET_LEN, &((SMqDataRspCommon*)pRsp)->rspOffset); tqDebug("tmq poll vgId:%d consumer:0x%" PRIx64 " (epoch %d) send rsp, block num:%d, req:%s, rsp:%s, reqId:0x%" PRIx64, vgId, pReq->consumerId, pReq->epoch, ((SMqDataRspCommon*)pRsp)->blockNum, buf1, buf2, pReq->reqId); @@ -412,7 +412,7 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg) { } char buf[TSDB_OFFSET_LEN] = {0}; - tFormatOffset(buf, TSDB_OFFSET_LEN, &reqOffset); + (void) tFormatOffset(buf, TSDB_OFFSET_LEN, &reqOffset); tqDebug("tmq poll: consumer:0x%" PRIx64 " (epoch %d), subkey %s, recv poll req vgId:%d, req:%s, reqId:0x%" PRIx64, consumerId, req.epoch, pHandle->subKey, vgId, buf, req.reqId); @@ -745,7 +745,7 @@ int32_t tqBuildStreamTask(void* pTqObj, SStreamTask* pTask, int64_t nextProcessV } streamTaskResetUpstreamStageInfo(pTask); - streamSetupScheduleTrigger(pTask); + (void) streamSetupScheduleTrigger(pTask); SCheckpointInfo* pChkInfo = &pTask->chkInfo; tqSetRestoreVersionInfo(pTask); @@ -801,8 +801,11 @@ static void doStartFillhistoryStep2(SStreamTask* pTask, SStreamTask* pStreamTask if (done) { qDebug("s-task:%s scan wal(step 2) verRange:%" PRId64 "-%" PRId64 " ended, elapsed time:%.2fs", id, pStep2Range->minVer, pStep2Range->maxVer, 0.0); - streamTaskPutTranstateIntoInputQ(pTask); - streamExecTask(pTask); // exec directly + int32_t code = streamTaskPutTranstateIntoInputQ(pTask); // todo: msg lost. + if (code) { + qError("s-task:%s failed put trans-state into inputQ, code:%s", id, tstrerror(code)); + } + (void) streamExecTask(pTask); // exec directly } else { STimeWindow* pWindow = &pTask->dataRange.window; tqDebug("s-task:%s level:%d verRange:%" PRId64 "-%" PRId64 " window:%" PRId64 "-%" PRId64 @@ -811,7 +814,10 @@ static void doStartFillhistoryStep2(SStreamTask* pTask, SStreamTask* pStreamTask pStreamTask->id.idStr); ASSERT(pTask->status.schedStatus == TASK_SCHED_STATUS__WAITING); - streamSetParamForStreamScannerStep2(pTask, pStep2Range, pWindow); + int32_t code = streamSetParamForStreamScannerStep2(pTask, pStep2Range, pWindow); + if (code) { + tqError("s-task:%s level:%d failed to set step2 param", id, pTask->info.taskLevel); + } int64_t dstVer = pStep2Range->minVer; pTask->chkInfo.nextProcessVer = dstVer; @@ -820,12 +826,12 @@ static void doStartFillhistoryStep2(SStreamTask* pTask, SStreamTask* pStreamTask tqDebug("s-task:%s wal reader start scan WAL verRange:%" PRId64 "-%" PRId64 ", set sched-status:%d", id, dstVer, pStep2Range->maxVer, TASK_SCHED_STATUS__INACTIVE); - /*int8_t status = */ streamTaskSetSchedStatusInactive(pTask); + (void) streamTaskSetSchedStatusInactive(pTask); // now the fill-history task starts to scan data from wal files. - int32_t code = streamTaskHandleEvent(pTask->status.pSM, TASK_EVENT_SCANHIST_DONE); + code = streamTaskHandleEvent(pTask->status.pSM, TASK_EVENT_SCANHIST_DONE); if (code == TSDB_CODE_SUCCESS) { - tqScanWalAsync(pTq, false); + (void) tqScanWalAsync(pTq, false); } } } @@ -949,11 +955,11 @@ int32_t tqProcessTaskScanHistory(STQ* pTq, SRpcMsg* pMsg) { pTask->streamTaskId.taskId, pTask->id.idStr); tqDebug("s-task:%s fill-history task set status to be dropping", id); - streamBuildAndSendDropTaskMsg(pTask->pMsgCb, pMeta->vgId, &pTask->id, 0); + code = streamBuildAndSendDropTaskMsg(pTask->pMsgCb, pMeta->vgId, &pTask->id, 0); atomic_store_32(&pTask->status.inScanHistorySentinel, 0); streamMetaReleaseTask(pMeta, pTask); - return -1; + return code; // todo: handle failure } ASSERT(pStreamTask->info.taskLevel == TASK_LEVEL__SOURCE); @@ -971,15 +977,14 @@ int32_t tqProcessTaskRunReq(STQ* pTq, SRpcMsg* pMsg) { // extracted submit data from wal files for all tasks if (pReq->reqType == STREAM_EXEC_T_EXTRACT_WAL_DATA) { - tqScanWal(pTq); - return 0; + return tqScanWal(pTq); } int32_t code = tqStreamTaskProcessRunReq(pTq->pStreamMeta, pMsg, vnodeIsRoleLeader(pTq->pVnode)); // let's continue scan data in the wal files if (code == 0 && (pReq->reqType >= 0 || pReq->reqType == STREAM_EXEC_T_RESUME_TASK)) { - tqScanWalAsync(pTq, false); + (void) tqScanWalAsync(pTq, false); // it's ok to failed } return code; @@ -1044,7 +1049,11 @@ int32_t tqStreamProgressRetrieveReq(STQ *pTq, SRpcMsg *pMsg) { pRsp->subFetchIdx = req.subFetchIdx; pRsp->vgId = req.vgId; pRsp->streamId = req.streamId; - tSerializeStreamProgressRsp(pRsp, sizeof(SStreamProgressRsp) + sizeof(SMsgHead), pRsp); + code = tSerializeStreamProgressRsp(pRsp, sizeof(SStreamProgressRsp) + sizeof(SMsgHead), pRsp); + if (code) { + goto _OVER; + } + SRpcMsg rsp = {.info = pMsg->info, .code = 0}; rsp.pCont = pRspBuf; pRspBuf = NULL; @@ -1079,18 +1088,18 @@ int32_t tqProcessTaskCheckPointSourceReq(STQ* pTq, SRpcMsg* pMsg, SRpcMsg* pRsp) tqError("vgId:%d failed to decode checkpoint-source msg, code:%s", vgId, tstrerror(code)); SRpcMsg rsp = {0}; - streamTaskBuildCheckpointSourceRsp(&req, &pMsg->info, &rsp, TSDB_CODE_SUCCESS); + (void) streamTaskBuildCheckpointSourceRsp(&req, &pMsg->info, &rsp, TSDB_CODE_SUCCESS); tmsgSendRsp(&rsp); // error occurs - return code; + return TSDB_CODE_SUCCESS; // always return success to mnode, todo: handle failure of build and send msg to mnode } tDecoderClear(&decoder); if (!vnodeIsRoleLeader(pTq->pVnode)) { tqDebug("vgId:%d not leader, ignore checkpoint-source msg, s-task:0x%x", vgId, req.taskId); SRpcMsg rsp = {0}; - streamTaskBuildCheckpointSourceRsp(&req, &pMsg->info, &rsp, TSDB_CODE_SUCCESS); + (void) streamTaskBuildCheckpointSourceRsp(&req, &pMsg->info, &rsp, TSDB_CODE_SUCCESS); tmsgSendRsp(&rsp); // error occurs - return TSDB_CODE_SUCCESS; + return TSDB_CODE_SUCCESS; // always return success to mnode, todo: handle failure of build and send msg to mnode } if (!pTq->pVnode->restored) { @@ -1098,9 +1107,9 @@ int32_t tqProcessTaskCheckPointSourceReq(STQ* pTq, SRpcMsg* pMsg, SRpcMsg* pRsp) ", transId:%d s-task:0x%x ignore it", vgId, req.checkpointId, req.transId, req.taskId); SRpcMsg rsp = {0}; - streamTaskBuildCheckpointSourceRsp(&req, &pMsg->info, &rsp, TSDB_CODE_SUCCESS); + (void) streamTaskBuildCheckpointSourceRsp(&req, &pMsg->info, &rsp, TSDB_CODE_SUCCESS); tmsgSendRsp(&rsp); // error occurs - return TSDB_CODE_SUCCESS; + return TSDB_CODE_SUCCESS; // always return success to mnode, , todo: handle failure of build and send msg to mnode } SStreamTask* pTask = NULL; @@ -1110,7 +1119,7 @@ int32_t tqProcessTaskCheckPointSourceReq(STQ* pTq, SRpcMsg* pMsg, SRpcMsg* pRsp) " transId:%d it may have been destroyed", vgId, req.taskId, req.checkpointId, req.transId); SRpcMsg rsp = {0}; - streamTaskBuildCheckpointSourceRsp(&req, &pMsg->info, &rsp, TSDB_CODE_SUCCESS); + (void) streamTaskBuildCheckpointSourceRsp(&req, &pMsg->info, &rsp, TSDB_CODE_SUCCESS); tmsgSendRsp(&rsp); // error occurs return TSDB_CODE_SUCCESS; } @@ -1123,13 +1132,13 @@ int32_t tqProcessTaskCheckPointSourceReq(STQ* pTq, SRpcMsg* pMsg, SRpcMsg* pRsp) streamMetaReleaseTask(pMeta, pTask); SRpcMsg rsp = {0}; - streamTaskBuildCheckpointSourceRsp(&req, &pMsg->info, &rsp, TSDB_CODE_SUCCESS); + (void) streamTaskBuildCheckpointSourceRsp(&req, &pMsg->info, &rsp, TSDB_CODE_SUCCESS); tmsgSendRsp(&rsp); // error occurs - return TSDB_CODE_SUCCESS; + return TSDB_CODE_SUCCESS; // todo retry handle error } // todo save the checkpoint failed info - taosThreadMutexLock(&pTask->lock); + streamMutexLock(&pTask->lock); ETaskStatus status = streamTaskGetStatus(pTask).state; if (req.mndTrigger == 1) { @@ -1137,13 +1146,12 @@ int32_t tqProcessTaskCheckPointSourceReq(STQ* pTq, SRpcMsg* pMsg, SRpcMsg* pRsp) tqError("s-task:%s not ready for checkpoint, since it is halt, ignore checkpointId:%" PRId64 ", set it failure", pTask->id.idStr, req.checkpointId); - taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); streamMetaReleaseTask(pMeta, pTask); SRpcMsg rsp = {0}; - streamTaskBuildCheckpointSourceRsp(&req, &pMsg->info, &rsp, TSDB_CODE_SUCCESS); + (void) streamTaskBuildCheckpointSourceRsp(&req, &pMsg->info, &rsp, TSDB_CODE_SUCCESS); tmsgSendRsp(&rsp); // error occurs - return TSDB_CODE_SUCCESS; } } else { @@ -1162,7 +1170,7 @@ int32_t tqProcessTaskCheckPointSourceReq(STQ* pTq, SRpcMsg* pMsg, SRpcMsg* pRsp) " transId:%d already handled, ignore msg and continue process checkpoint", pTask->id.idStr, checkpointId, req.transId); - taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); streamMetaReleaseTask(pMeta, pTask); return TSDB_CODE_SUCCESS; @@ -1171,19 +1179,24 @@ int32_t tqProcessTaskCheckPointSourceReq(STQ* pTq, SRpcMsg* pMsg, SRpcMsg* pRsp) tqWarn("s-task:%s repeatly recv checkpoint-source msg checkpointId:%" PRId64 " transId:%d already handled, return success", pTask->id.idStr, req.checkpointId, req.transId); - taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); streamMetaReleaseTask(pMeta, pTask); SRpcMsg rsp = {0}; - streamTaskBuildCheckpointSourceRsp(&req, &pMsg->info, &rsp, TSDB_CODE_SUCCESS); + (void) streamTaskBuildCheckpointSourceRsp(&req, &pMsg->info, &rsp, TSDB_CODE_SUCCESS); tmsgSendRsp(&rsp); // error occurs return TSDB_CODE_SUCCESS; } } - streamProcessCheckpointSourceReq(pTask, &req); - taosThreadMutexUnlock(&pTask->lock); + code = streamProcessCheckpointSourceReq(pTask, &req); + streamMutexUnlock(&pTask->lock); + + if (code) { + qError("s-task:%s (vgId:%d) failed to process checkpoint-source req, code:%s", pTask->id.idStr, vgId, tstrerror(code)); + return code; + } if (req.mndTrigger) { qInfo("s-task:%s (vgId:%d) level:%d receive checkpoint-source msg chkpt:%" PRId64 ", transId:%d, ", pTask->id.idStr, @@ -1198,13 +1211,13 @@ int32_t tqProcessTaskCheckPointSourceReq(STQ* pTq, SRpcMsg* pMsg, SRpcMsg* pRsp) code = streamAddCheckpointSourceRspMsg(&req, &pMsg->info, pTask); if (code != TSDB_CODE_SUCCESS) { SRpcMsg rsp = {0}; - streamTaskBuildCheckpointSourceRsp(&req, &pMsg->info, &rsp, TSDB_CODE_SUCCESS); + (void) streamTaskBuildCheckpointSourceRsp(&req, &pMsg->info, &rsp, TSDB_CODE_SUCCESS); tmsgSendRsp(&rsp); // error occurs - return code; + return TSDB_CODE_SUCCESS; } streamMetaReleaseTask(pMeta, pTask); - return code; + return TSDB_CODE_SUCCESS; } // downstream task has complete the stream task checkpoint procedure, let's start the handle the rsp by execute task diff --git a/source/dnode/vnode/src/tq/tqScan.c b/source/dnode/vnode/src/tq/tqScan.c index 5df8c97962..d072d7199c 100644 --- a/source/dnode/vnode/src/tq/tqScan.c +++ b/source/dnode/vnode/src/tq/tqScan.c @@ -115,14 +115,15 @@ int32_t tqScanData(STQ* pTq, STqHandle* pHandle, SMqDataRsp* pRsp, STqOffsetVal* if (pDataBlock == NULL) { break; } + STqOffsetVal offset = {0}; - qStreamExtractOffset(task, &offset); + code = qStreamExtractOffset(task, &offset); + TSDB_CHECK_CODE(code, line, END); + pHandle->block = NULL; code = createOneDataBlock(pDataBlock, true, &pHandle->block); - if (code) { - return code; - } + TSDB_CHECK_CODE(code, line, END); pHandle->blockTime = offset.ts; tOffsetDestroy(&offset); @@ -140,8 +141,11 @@ int32_t tqScanData(STQ* pTq, STqHandle* pHandle, SMqDataRsp* pRsp, STqOffsetVal* } else { code = copyDataBlock(pHandle->block, pDataBlock); TSDB_CHECK_CODE(code, line, END); + STqOffsetVal offset = {0}; - qStreamExtractOffset(task, &offset); + code = qStreamExtractOffset(task, &offset); + TSDB_CHECK_CODE(code, line, END); + pRsp->sleepTime = offset.ts - pHandle->blockTime; pHandle->blockTime = offset.ts; tOffsetDestroy(&offset); @@ -164,10 +168,11 @@ int32_t tqScanData(STQ* pTq, STqHandle* pHandle, SMqDataRsp* pRsp, STqOffsetVal* tqDebug("consumer:0x%" PRIx64 " vgId:%d tmq task executed finished, total blocks:%d, totalRows:%d", pHandle->consumerId, vgId, pRsp->common.blockNum, totalRows); - qStreamExtractOffset(task, &pRsp->common.rspOffset); + code = qStreamExtractOffset(task, &pRsp->common.rspOffset); END: - if ( code!= 0){ - tqError("consumer:0x%" PRIx64 " vgId:%d tmq task executed error, line:%d code:%d", pHandle->consumerId, vgId, line, code); + if (code != 0) { + tqError("consumer:0x%" PRIx64 " vgId:%d tmq task executed error, line:%d code:%d", pHandle->consumerId, vgId, line, + code); } return code; } @@ -241,31 +246,40 @@ int32_t tqScanTaosx(STQ* pTq, const STqHandle* pHandle, STaosxRsp* pRsp, SMqBatc // get meta SMqBatchMetaRsp* tmp = qStreamExtractMetaMsg(task); if (taosArrayGetSize(tmp->batchMetaReq) > 0) { - qStreamExtractOffset(task, &tmp->rspOffset); + code = qStreamExtractOffset(task, &tmp->rspOffset); + if (code) { + return code; + } + *pBatchMetaRsp = *tmp; tqDebug("tmqsnap task get meta"); break; } if (pDataBlock == NULL) { - qStreamExtractOffset(task, pOffset); + code = qStreamExtractOffset(task, pOffset); + if (code) { + break; + } + if (pOffset->type == TMQ_OFFSET__SNAPSHOT_DATA) { continue; } + tqDebug("tmqsnap vgId: %d, tsdb consume over, switch to wal, ver %" PRId64, TD_VID(pTq->pVnode), pHandle->snapshotVer + 1); - qStreamExtractOffset(task, &pRsp->common.rspOffset); + code = qStreamExtractOffset(task, &pRsp->common.rspOffset); break; } if (pRsp->common.blockNum > 0) { tqDebug("tmqsnap task exec exited, get data"); - qStreamExtractOffset(task, &pRsp->common.rspOffset); + code = qStreamExtractOffset(task, &pRsp->common.rspOffset); break; } } - return 0; + return code; } 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/tsdbRead2.c b/source/dnode/vnode/src/tsdb/tsdbRead2.c index a3210dbfd9..4fedb68a78 100644 --- a/source/dnode/vnode/src/tsdb/tsdbRead2.c +++ b/source/dnode/vnode/src/tsdb/tsdbRead2.c @@ -48,7 +48,7 @@ typedef struct { static int32_t getCurrentBlockInfo(SDataBlockIter* pBlockIter, SFileDataBlockInfo** pInfo); static int32_t buildDataBlockFromBufImpl(STableBlockScanInfo* pBlockScanInfo, int64_t endKey, int32_t capacity, STsdbReader* pReader); -static int32_t getValidMemRow(SIterInfo* pIter, const SArray* pDelList, STsdbReader* pReader, TSDBROW** pRes); +static void getValidMemRow(SIterInfo* pIter, const SArray* pDelList, STsdbReader* pReader, TSDBROW** pRes); static int32_t doMergeRowsInFileBlocks(SBlockData* pBlockData, STableBlockScanInfo* pScanInfo, SRowKey* pKey, STsdbReader* pReader); static int32_t doMergeRowsInSttBlock(SSttBlockReader* pSttBlockReader, STableBlockScanInfo* pScanInfo, @@ -3866,11 +3866,11 @@ bool hasBeenDropped(const SArray* pDelList, int32_t* index, int64_t key, int64_t return false; } -FORCE_INLINE int32_t getValidMemRow(SIterInfo* pIter, const SArray* pDelList, STsdbReader* pReader, TSDBROW** pRes) { +FORCE_INLINE void getValidMemRow(SIterInfo* pIter, const SArray* pDelList, STsdbReader* pReader, TSDBROW** pRes) { *pRes = NULL; if (!pIter->hasVal) { - return TSDB_CODE_SUCCESS; + return; } int32_t order = pReader->info.order; @@ -3880,20 +3880,20 @@ FORCE_INLINE int32_t getValidMemRow(SIterInfo* pIter, const SArray* pDelList, ST TSDBROW_INIT_KEY(pRow, key); if (outOfTimeWindow(key.ts, &pReader->info.window)) { pIter->hasVal = false; - return TSDB_CODE_SUCCESS; + return; } // it is a valid data version if (key.version <= pReader->info.verRange.maxVer && key.version >= pReader->info.verRange.minVer) { if (pDelList == NULL || TARRAY_SIZE(pDelList) == 0) { *pRes = pRow; - return TSDB_CODE_SUCCESS; + return; } else { bool dropped = hasBeenDropped(pDelList, &pIter->index, key.ts, key.version, order, &pReader->info.verRange, pReader->suppInfo.numOfPks > 0); if (!dropped) { *pRes = pRow; - return TSDB_CODE_SUCCESS; + return; } } } @@ -3901,7 +3901,7 @@ FORCE_INLINE int32_t getValidMemRow(SIterInfo* pIter, const SArray* pDelList, ST while (1) { pIter->hasVal = tsdbTbDataIterNext(pIter->iter); if (!pIter->hasVal) { - return TSDB_CODE_SUCCESS; + return; } pRow = tsdbTbDataIterGet(pIter->iter); @@ -3909,19 +3909,19 @@ FORCE_INLINE int32_t getValidMemRow(SIterInfo* pIter, const SArray* pDelList, ST TSDBROW_INIT_KEY(pRow, key); if (outOfTimeWindow(key.ts, &pReader->info.window)) { pIter->hasVal = false; - return TSDB_CODE_SUCCESS; + return; } if (key.version <= pReader->info.verRange.maxVer && key.version >= pReader->info.verRange.minVer) { if (pDelList == NULL || TARRAY_SIZE(pDelList) == 0) { *pRes = pRow; - return TSDB_CODE_SUCCESS; + return; } else { bool dropped = hasBeenDropped(pDelList, &pIter->index, key.ts, key.version, order, &pReader->info.verRange, pReader->suppInfo.numOfPks > 0); if (!dropped) { *pRes = pRow; - return TSDB_CODE_SUCCESS; + return; } } } 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/executor/src/executor.c b/source/libs/executor/src/executor.c index c4cc49e8ea..75c335a6a8 100644 --- a/source/libs/executor/src/executor.c +++ b/source/libs/executor/src/executor.c @@ -1158,14 +1158,15 @@ SMqBatchMetaRsp* qStreamExtractMetaMsg(qTaskInfo_t tinfo) { return &pTaskInfo->streamInfo.btMetaRsp; } -void qStreamExtractOffset(qTaskInfo_t tinfo, STqOffsetVal* pOffset) { +int32_t qStreamExtractOffset(qTaskInfo_t tinfo, STqOffsetVal* pOffset) { SExecTaskInfo* pTaskInfo = (SExecTaskInfo*)tinfo; - int32_t code = tOffsetCopy(pOffset, &pTaskInfo->streamInfo.currentOffset); - if (code != TSDB_CODE_SUCCESS) { + tOffsetCopy(pOffset, &pTaskInfo->streamInfo.currentOffset); + return 0; + /*if (code != TSDB_CODE_SUCCESS) { qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); pTaskInfo->code = code; T_LONG_JMP(pTaskInfo->env, code); - } + }*/ } int32_t initQueryTableDataCondForTmq(SQueryTableDataCond* pCond, SSnapContext* sContext, SMetaTableInfo* pMtInfo) { @@ -1436,8 +1437,7 @@ int32_t qStreamPrepareScan(qTaskInfo_t tinfo, STqOffsetVal* pOffset, int8_t subT } end: - tOffsetCopy(&pTaskInfo->streamInfo.currentOffset, pOffset); - + (void) tOffsetCopy(&pTaskInfo->streamInfo.currentOffset, pOffset); return 0; } diff --git a/source/libs/executor/src/mergejoinoperator.c b/source/libs/executor/src/mergejoinoperator.c index 8db4c6335f..2c485cdd1b 100644 --- a/source/libs/executor/src/mergejoinoperator.c +++ b/source/libs/executor/src/mergejoinoperator.c @@ -309,14 +309,8 @@ int32_t mJoinFilterAndMarkHashRows(SSDataBlock* pBlock, SFilterInfo* pFilterInfo } code = extractQualifiedTupleByFilterResult(pBlock, p, status); - if (code != TSDB_CODE_SUCCESS) { - goto _err; - } - - code = TSDB_CODE_SUCCESS; _err: - colDataDestroy(p); taosMemoryFree(p); @@ -379,14 +373,8 @@ int32_t mJoinFilterAndMarkRows(SSDataBlock* pBlock, SFilterInfo* pFilterInfo, SM } code = extractQualifiedTupleByFilterResult(pBlock, p, status); - if (code != TSDB_CODE_SUCCESS) { - goto _return; - } - - code = TSDB_CODE_SUCCESS; _return: - colDataDestroy(p); taosMemoryFree(p); diff --git a/source/libs/function/src/tudf.c b/source/libs/function/src/tudf.c index 7c0ddb6175..66e503fd89 100644 --- a/source/libs/function/src/tudf.c +++ b/source/libs/function/src/tudf.c @@ -896,14 +896,14 @@ int32_t convertDataBlockToUdfDataBlock(SSDataBlock *block, SUdfDataBlock *udfBlo } int32_t convertUdfColumnToDataBlock(SUdfColumn *udfCol, SSDataBlock *block) { - int32_t code = 0, lino = 0; - SUdfColumnMeta* meta = &udfCol->colMeta; + int32_t code = 0, lino = 0; + SUdfColumnMeta *meta = &udfCol->colMeta; SColumnInfoData colInfoData = createColumnInfoData(meta->type, meta->bytes, 1); code = blockDataAppendColInfo(block, &colInfoData); TAOS_CHECK_GOTO(code, &lino, _exit); - code = blockDataEnsureCapacity(block, udfCol->colData.numOfRows); + code = blockDataEnsureCapacity(block, udfCol->colData.numOfRows); TAOS_CHECK_GOTO(code, &lino, _exit); SColumnInfoData *col = NULL; diff --git a/source/libs/stream/src/streamStartHistory.c b/source/libs/stream/src/streamStartHistory.c index db0784d572..0dbb6ed454 100644 --- a/source/libs/stream/src/streamStartHistory.c +++ b/source/libs/stream/src/streamStartHistory.c @@ -80,7 +80,7 @@ int32_t streamStartScanHistoryAsync(SStreamTask* pTask, int8_t igUntreated) { return tmsgPutToQueue(pTask->pMsgCb, STREAM_QUEUE, &rpcMsg); } -int32_t streamExecScanHistoryInFuture(SStreamTask* pTask, int32_t idleDuration) { +void streamExecScanHistoryInFuture(SStreamTask* pTask, int32_t idleDuration) { int32_t numOfTicks = idleDuration / SCANHISTORY_IDLE_TIME_SLICE; if (numOfTicks <= 0) { numOfTicks = 1; @@ -91,10 +91,10 @@ int32_t streamExecScanHistoryInFuture(SStreamTask* pTask, int32_t idleDuration) // add ref for task SStreamTask* p = NULL; int32_t code = streamMetaAcquireTask(pTask->pMeta, pTask->id.streamId, pTask->id.taskId, &p); - if (p == NULL) { + if (p == NULL || code != 0) { stError("s-task:0x%x failed to acquire task, status:%s, not exec scan-history data", pTask->id.taskId, streamTaskGetStatus(pTask).name); - return TSDB_CODE_SUCCESS; + return; } pTask->schedHistoryInfo.numOfTicks = numOfTicks; @@ -109,8 +109,6 @@ int32_t streamExecScanHistoryInFuture(SStreamTask* pTask, int32_t idleDuration) streamTmrReset(doExecScanhistoryInFuture, SCANHISTORY_IDLE_TIME_SLICE, pTask, streamTimer, &pTask->schedHistoryInfo.pTimer, pTask->pMeta->vgId, " start-history-task-tmr"); } - - return TSDB_CODE_SUCCESS; } int32_t streamTaskStartScanHistory(SStreamTask* pTask) { diff --git a/source/libs/stream/src/streamTask.c b/source/libs/stream/src/streamTask.c index 141bd8fc3e..99528d01b0 100644 --- a/source/libs/stream/src/streamTask.c +++ b/source/libs/stream/src/streamTask.c @@ -766,8 +766,7 @@ int32_t streamTaskClearHTaskAttr(SStreamTask* pTask, int32_t resetRelHalt) { int32_t streamBuildAndSendDropTaskMsg(SMsgCb* pMsgCb, int32_t vgId, SStreamTaskId* pTaskId, int64_t resetRelHalt) { SVDropStreamTaskReq* pReq = rpcMallocCont(sizeof(SVDropStreamTaskReq)); if (pReq == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - return -1; + return terrno; } pReq->head.vgId = vgId; @@ -1089,11 +1088,10 @@ int32_t streamTaskSetActiveCheckpointInfo(SStreamTask* pTask, int64_t activeChec return TSDB_CODE_SUCCESS; } -int32_t streamTaskSetFailedChkptInfo(SStreamTask* pTask, int32_t transId, int64_t checkpointId) { +void streamTaskSetFailedChkptInfo(SStreamTask* pTask, int32_t transId, int64_t checkpointId) { pTask->chkInfo.pActiveInfo->transId = transId; pTask->chkInfo.pActiveInfo->activeId = checkpointId; pTask->chkInfo.pActiveInfo->failedId = checkpointId; - return TSDB_CODE_SUCCESS; } int32_t streamTaskCreateActiveChkptInfo(SActiveCheckpointInfo** pRes) { diff --git a/source/libs/stream/src/streamTaskSm.c b/source/libs/stream/src/streamTaskSm.c index c3e0df52d4..275c9255d2 100644 --- a/source/libs/stream/src/streamTaskSm.c +++ b/source/libs/stream/src/streamTaskSm.c @@ -270,7 +270,7 @@ int32_t streamTaskRestoreStatus(SStreamTask* pTask) { code = TSDB_CODE_FAILED; // failed to restore the status, since it is not in pause status } - (void)taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); return code; } 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;