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

Merge branch '3.0' into fix/syntax

This commit is contained in:
Haojun Liao 2024-07-30 10:13:52 +08:00
parent 0bb263076e e6d3fe878f
commit 5148438da7
118 changed files with 1967 additions and 1789 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/common/tmsg.h
View File

@ -3641,7 +3641,7 @@ int32_t tEncodeSTqOffsetVal(SEncoder* pEncoder, const STqOffsetVal* pOffsetVal);
int32_t tDecodeSTqOffsetVal(SDecoder* pDecoder, STqOffsetVal* pOffsetVal); int32_t tDecodeSTqOffsetVal(SDecoder* pDecoder, STqOffsetVal* pOffsetVal);
void tFormatOffset(char* buf, int32_t maxLen, const STqOffsetVal* pVal); void tFormatOffset(char* buf, int32_t maxLen, const STqOffsetVal* pVal);
bool tOffsetEqual(const STqOffsetVal* pLeft, const STqOffsetVal* pRight); bool tOffsetEqual(const STqOffsetVal* pLeft, const STqOffsetVal* pRight);
void tOffsetCopy(STqOffsetVal* pLeft, const STqOffsetVal* pRight); int32_t tOffsetCopy(STqOffsetVal* pLeft, const STqOffsetVal* pRight);
void tOffsetDestroy(void* pVal); void tOffsetDestroy(void* pVal);
typedef struct { typedef struct {

4
include/util/tlockfree.h
View File

@ -84,7 +84,7 @@ int32_t taosWTryLockLatch(SRWLatch *pLatch);
int32_t old_ = atomic_add_fetch_32((x), 0); \ int32_t old_ = atomic_add_fetch_32((x), 0); \
if (old_ & 0x00000001) { \ if (old_ & 0x00000001) { \
if (i_ % 1000 == 0) { \ if (i_ % 1000 == 0) { \
sched_yield(); \ (void)sched_yield(); \
} \ } \
continue; \ continue; \
} }
@ -99,7 +99,7 @@ int32_t taosWTryLockLatch(SRWLatch *pLatch);
taosCorBeginRead(x) if (atomic_val_compare_exchange_32((x), old_, old_ + 1) != old_) { continue; } taosCorBeginRead(x) if (atomic_val_compare_exchange_32((x), old_, old_ + 1) != old_) { continue; }
#define taosCorEndWrite(x) \ #define taosCorEndWrite(x) \
atomic_add_fetch_32((x), 1); \ (void)atomic_add_fetch_32((x), 1); \
break; \ break; \
} }

3
source/client/src/clientMain.c
View File

@ -85,7 +85,6 @@ void taos_cleanup(void) {
tscWarn("failed to close clientReqRefPool"); tscWarn("failed to close clientReqRefPool");
} }
DestroyRegexCache();
rpcCleanup(); rpcCleanup();
tscDebug("rpc cleanup"); tscDebug("rpc cleanup");
@ -93,6 +92,8 @@ void taos_cleanup(void) {
tmqMgmtClose(); tmqMgmtClose();
DestroyRegexCache();
tscInfo("all local resources released"); tscInfo("all local resources released");
taosCleanupCfg(); taosCleanupCfg();
taosCloseLog(); taosCloseLog();

8
source/common/src/rsync.c
View File

@ -32,10 +32,10 @@ static void removeEmptyDir() {
empty = false; empty = false;
} }
if (empty) taosRemoveDir(filename); if (empty) taosRemoveDir(filename);
taosCloseDir(&pDirTmp); (void)taosCloseDir(&pDirTmp);
} }
taosCloseDir(&pDir); (void)taosCloseDir(&pDir);
} }
#ifdef WINDOWS #ifdef WINDOWS
@ -92,12 +92,12 @@ static int32_t generateConfigFile(char* confDir) {
uDebug("[rsync] conf:%s", confContent); uDebug("[rsync] conf:%s", confContent);
if (taosWriteFile(pFile, confContent, strlen(confContent)) <= 0) { if (taosWriteFile(pFile, confContent, strlen(confContent)) <= 0) {
uError("[rsync] write conf file error," ERRNO_ERR_FORMAT, ERRNO_ERR_DATA); uError("[rsync] write conf file error," ERRNO_ERR_FORMAT, ERRNO_ERR_DATA);
taosCloseFile(&pFile); (void)taosCloseFile(&pFile);
code = TAOS_SYSTEM_ERROR(errno); code = TAOS_SYSTEM_ERROR(errno);
return code; return code;
} }
taosCloseFile(&pFile); (void)taosCloseFile(&pFile);
return 0; return 0;
} }

37
source/common/src/tdataformat.c
View File

@ -706,7 +706,10 @@ static int32_t tRowMergeImpl(SArray *aRowP, STSchema *pTSchema, int32_t iStart,
if (code) goto _exit; if (code) goto _exit;
taosArrayRemoveBatch(aRowP, iStart, nRow, (FDelete)tRowPDestroy); taosArrayRemoveBatch(aRowP, iStart, nRow, (FDelete)tRowPDestroy);
taosArrayInsert(aRowP, iStart, &pRow); if (taosArrayInsert(aRowP, iStart, &pRow) == NULL) {
code = terrno;
goto _exit;
}
_exit: _exit:
if (aIter) { if (aIter) {
@ -1708,7 +1711,7 @@ bool tTagGet(const STag *pTag, STagVal *pTagVal) {
offset = pTag->idx[midx]; offset = pTag->idx[midx];
} }
tGetTagVal(p + offset, &tv, isJson); (void)tGetTagVal(p + offset, &tv, isJson);
if (isJson) { if (isJson) {
c = tTagValJsonCmprFn(pTagVal, &tv); c = tTagValJsonCmprFn(pTagVal, &tv);
} else { } else {
@ -1758,7 +1761,7 @@ int32_t tTagToValArray(const STag *pTag, SArray **ppArray) {
} else { } else {
offset = pTag->idx[iTag]; 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) { if (taosArrayPush(*ppArray, &tv) == NULL) {
code = TSDB_CODE_OUT_OF_MEMORY; code = TSDB_CODE_OUT_OF_MEMORY;
goto _err; goto _err;
@ -1788,7 +1791,7 @@ void tTagSetCid(const STag *pTag, int16_t iTag, int16_t cid) {
offset = pTag->idx[iTag]; offset = pTag->idx[iTag];
} }
tPutI16v(p + offset, cid); (void)tPutI16v(p + offset, cid);
} }
// STSchema ======================================== // STSchema ========================================
@ -3152,16 +3155,16 @@ static int32_t tColDataCopyRowSingleCol(SColData *pFromColData, int32_t iFromRow
SET_BIT1(pToColData->pBitMap, iToRow, GET_BIT1(pFromColData->pBitMap, iFromRow)); SET_BIT1(pToColData->pBitMap, iToRow, GET_BIT1(pFromColData->pBitMap, iFromRow));
} break; } break;
case HAS_VALUE: { case HAS_VALUE: {
tColDataCopyRowCell(pFromColData, iFromRow, pToColData, iToRow); (void)tColDataCopyRowCell(pFromColData, iFromRow, pToColData, iToRow);
} break; } break;
case (HAS_VALUE | HAS_NONE): case (HAS_VALUE | HAS_NONE):
case (HAS_VALUE | HAS_NULL): { case (HAS_VALUE | HAS_NULL): {
SET_BIT1(pToColData->pBitMap, iToRow, GET_BIT1(pFromColData->pBitMap, iFromRow)); SET_BIT1(pToColData->pBitMap, iToRow, GET_BIT1(pFromColData->pBitMap, iFromRow));
tColDataCopyRowCell(pFromColData, iFromRow, pToColData, iToRow); (void)tColDataCopyRowCell(pFromColData, iFromRow, pToColData, iToRow);
} break; } break;
case (HAS_VALUE | HAS_NULL | HAS_NONE): { case (HAS_VALUE | HAS_NULL | HAS_NONE): {
SET_BIT2(pToColData->pBitMap, iToRow, GET_BIT2(pFromColData->pBitMap, iFromRow)); SET_BIT2(pToColData->pBitMap, iToRow, GET_BIT2(pFromColData->pBitMap, iFromRow));
tColDataCopyRowCell(pFromColData, iFromRow, pToColData, iToRow); (void)tColDataCopyRowCell(pFromColData, iFromRow, pToColData, iToRow);
} break; } break;
default: default:
return -1; return -1;
@ -3235,24 +3238,24 @@ static int32_t tColDataMergeSortMerge(SColData *aColData, int32_t start, int32_t
tColDataArrGetRowKey(aColData, nColData, j, &keyj); tColDataArrGetRowKey(aColData, nColData, j, &keyj);
while (i <= mid && j <= end) { while (i <= mid && j <= end) {
if (tRowKeyCompare(&keyi, &keyj) <= 0) { if (tRowKeyCompare(&keyi, &keyj) <= 0) {
tColDataCopyRowAppend(aColData, i++, aDstColData, nColData); (void)tColDataCopyRowAppend(aColData, i++, aDstColData, nColData);
tColDataArrGetRowKey(aColData, nColData, i, &keyi); tColDataArrGetRowKey(aColData, nColData, i, &keyi);
} else { } else {
tColDataCopyRowAppend(aColData, j++, aDstColData, nColData); (void)tColDataCopyRowAppend(aColData, j++, aDstColData, nColData);
tColDataArrGetRowKey(aColData, nColData, j, &keyj); tColDataArrGetRowKey(aColData, nColData, j, &keyj);
} }
} }
while (i <= mid) { while (i <= mid) {
tColDataCopyRowAppend(aColData, i++, aDstColData, nColData); (void)tColDataCopyRowAppend(aColData, i++, aDstColData, nColData);
} }
while (j <= end) { while (j <= end) {
tColDataCopyRowAppend(aColData, j++, aDstColData, nColData); (void)tColDataCopyRowAppend(aColData, j++, aDstColData, nColData);
} }
for (i = start, k = 0; i <= end; ++i, ++k) { for (i = start, k = 0; i <= end; ++i, ++k) {
tColDataCopyRow(aDstColData, k, aColData, i, nColData); (void)tColDataCopyRow(aDstColData, k, aColData, i, nColData);
} }
if (aDstColData) { if (aDstColData) {
@ -3551,7 +3554,7 @@ void tColDataSortMerge(SArray *colDataArr) {
// sort ------- // sort -------
if (doSort) { if (doSort) {
tColDataSort(aColData, nColData); (void)tColDataSort(aColData, nColData);
} }
if (doMerge != 1) { if (doMerge != 1) {
@ -4209,17 +4212,17 @@ int32_t tValueColumnGet(SValueColumn *valCol, int32_t idx, SValue *value) {
int32_t offset, nextOffset; int32_t offset, nextOffset;
SBufferReader reader = BUFFER_READER_INITIALIZER(idx * sizeof(offset), &valCol->offsets); SBufferReader reader = BUFFER_READER_INITIALIZER(idx * sizeof(offset), &valCol->offsets);
tBufferGetI32(&reader, &offset); (void)tBufferGetI32(&reader, &offset);
if (idx == valCol->numOfValues - 1) { if (idx == valCol->numOfValues - 1) {
nextOffset = tBufferGetSize(&valCol->data); nextOffset = tBufferGetSize(&valCol->data);
} else { } else {
tBufferGetI32(&reader, &nextOffset); (void)tBufferGetI32(&reader, &nextOffset);
} }
value->nData = nextOffset - offset; value->nData = nextOffset - offset;
value->pData = (uint8_t *)tBufferGetDataAt(&valCol->data, offset); value->pData = (uint8_t *)tBufferGetDataAt(&valCol->data, offset);
} else { } else {
SBufferReader reader = BUFFER_READER_INITIALIZER(idx * tDataTypes[value->type].bytes, &valCol->data); 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; return 0;
} }
@ -4269,7 +4272,7 @@ int32_t tValueColumnDecompress(void *input, const SValueColumnCompressInfo *info
SBuffer *assist) { SBuffer *assist) {
int32_t code; int32_t code;
tValueColumnClear(valCol); (void)tValueColumnClear(valCol);
valCol->type = info->type; valCol->type = info->type;
// offset // offset
if (IS_VAR_DATA_TYPE(valCol->type)) { if (IS_VAR_DATA_TYPE(valCol->type)) {

45
source/common/src/tglobal.c
View File

@ -396,6 +396,7 @@ struct SConfig *taosGetCfg() { return tsCfg; }
static int32_t taosLoadCfg(SConfig *pCfg, const char **envCmd, const char *inputCfgDir, const char *envFile, static int32_t taosLoadCfg(SConfig *pCfg, const char **envCmd, const char *inputCfgDir, const char *envFile,
char *apolloUrl) { char *apolloUrl) {
int32_t code = 0;
char cfgDir[PATH_MAX] = {0}; char cfgDir[PATH_MAX] = {0};
char cfgFile[PATH_MAX + 100] = {0}; char cfgFile[PATH_MAX + 100] = {0};
@ -424,32 +425,32 @@ static int32_t taosLoadCfg(SConfig *pCfg, const char **envCmd, const char *input
} }
if (apolloUrl != NULL && apolloUrl[0] == '\0') { if (apolloUrl != NULL && apolloUrl[0] == '\0') {
TAOS_CHECK_RETURN(cfgGetApollUrl(envCmd, envFile, apolloUrl)); (void)(cfgGetApollUrl(envCmd, envFile, apolloUrl));
} }
if (cfgLoad(pCfg, CFG_STYPE_APOLLO_URL, apolloUrl) != 0) { if ((code = cfgLoad(pCfg, CFG_STYPE_APOLLO_URL, apolloUrl)) != 0) {
uError("failed to load from apollo url:%s since %s", apolloUrl, terrstr()); uError("failed to load from apollo url:%s since %s", apolloUrl, tstrerror(code));
TAOS_RETURN(TSDB_CODE_INVALID_CFG); TAOS_RETURN(code);
} }
if (cfgLoad(pCfg, CFG_STYPE_CFG_FILE, cfgFile) != 0) { if ((code = cfgLoad(pCfg, CFG_STYPE_CFG_FILE, cfgFile)) != 0) {
uError("failed to load from cfg file:%s since %s", cfgFile, terrstr()); uError("failed to load from cfg file:%s since %s", cfgFile, tstrerror(code));
TAOS_RETURN(TSDB_CODE_INVALID_CFG); TAOS_RETURN(code);
} }
if (cfgLoad(pCfg, CFG_STYPE_ENV_FILE, envFile) != 0) { if ((code = cfgLoad(pCfg, CFG_STYPE_ENV_FILE, envFile)) != 0) {
uError("failed to load from env file:%s since %s", envFile, terrstr()); uError("failed to load from env file:%s since %s", envFile, tstrerror(code));
TAOS_RETURN(TSDB_CODE_INVALID_CFG); TAOS_RETURN(code);
} }
if (cfgLoad(pCfg, CFG_STYPE_ENV_VAR, NULL) != 0) { if ((code = cfgLoad(pCfg, CFG_STYPE_ENV_VAR, NULL)) != 0) {
uError("failed to load from global env variables since %s", terrstr()); uError("failed to load from global env variables since %s", tstrerror(code));
TAOS_RETURN(TSDB_CODE_INVALID_CFG); TAOS_RETURN(code);
} }
if (cfgLoad(pCfg, CFG_STYPE_ENV_CMD, envCmd) != 0) { if ((code = cfgLoad(pCfg, CFG_STYPE_ENV_CMD, envCmd)) != 0) {
uError("failed to load from cmd env variables since %s", terrstr()); uError("failed to load from cmd env variables since %s", tstrerror(code));
TAOS_RETURN(TSDB_CODE_INVALID_CFG); TAOS_RETURN(code);
} }
TAOS_RETURN(TSDB_CODE_SUCCESS); TAOS_RETURN(TSDB_CODE_SUCCESS);
@ -1280,12 +1281,12 @@ int32_t taosCreateLog(const char *logname, int32_t logFileNum, const char *cfgDi
} }
if ((code = taosLoadCfg(pCfg, envCmd, cfgDir, envFile, apolloUrl)) != TSDB_CODE_SUCCESS) { if ((code = taosLoadCfg(pCfg, envCmd, cfgDir, envFile, apolloUrl)) != TSDB_CODE_SUCCESS) {
printf("failed to load cfg since %s", tstrerror(code)); printf("failed to load cfg since %s\n", tstrerror(code));
goto _exit; goto _exit;
} }
if ((code = cfgLoadFromArray(pCfg, pArgs)) != TSDB_CODE_SUCCESS) { if ((code = cfgLoadFromArray(pCfg, pArgs)) != TSDB_CODE_SUCCESS) {
printf("failed to load cfg from array since %s", tstrerror(code)); printf("failed to load cfg from array since %s\n", tstrerror(code));
goto _exit; goto _exit;
} }
@ -1302,12 +1303,12 @@ int32_t taosCreateLog(const char *logname, int32_t logFileNum, const char *cfgDi
TAOS_CHECK_RETURN(taosSetAllDebugFlag(pCfg, pDebugItem->i32)); TAOS_CHECK_RETURN(taosSetAllDebugFlag(pCfg, pDebugItem->i32));
if ((code = taosMulModeMkDir(tsLogDir, 0777, true)) != TSDB_CODE_SUCCESS) { if ((code = taosMulModeMkDir(tsLogDir, 0777, true)) != TSDB_CODE_SUCCESS) {
printf("failed to create dir:%s since %s", tsLogDir, tstrerror(code)); printf("failed to create dir:%s since %s\n", tsLogDir, tstrerror(code));
goto _exit; goto _exit;
} }
if ((code = taosInitLog(logname, logFileNum)) != 0) { if ((code = taosInitLog(logname, logFileNum)) != 0) {
printf("failed to init log file since %s", terrstr()); printf("failed to init log file since %s\n", tstrerror(code));
goto _exit; goto _exit;
} }
@ -1329,12 +1330,12 @@ int32_t taosReadDataFolder(const char *cfgDir, const char **envCmd, const char *
if (cfgAddInt32(pCfg, "dDebugFlag", dDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER) != 0) return -1; if (cfgAddInt32(pCfg, "dDebugFlag", dDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER) != 0) return -1;
if ((code = taosLoadCfg(pCfg, envCmd, cfgDir, envFile, apolloUrl)) != 0) { if ((code = taosLoadCfg(pCfg, envCmd, cfgDir, envFile, apolloUrl)) != 0) {
printf("failed to load cfg since %s", terrstr()); printf("failed to load cfg since %s\n", tstrerror(code));
goto _exit; goto _exit;
} }
if ((code = cfgLoadFromArray(pCfg, pArgs)) != 0) { if ((code = cfgLoadFromArray(pCfg, pArgs)) != 0) {
printf("failed to load cfg from array since %s", terrstr()); printf("failed to load cfg from array since %s\n", tstrerror(code));
goto _exit; goto _exit;
} }

47
source/common/src/tmsg.c
View File

@ -522,7 +522,7 @@ int32_t tDeserializeSClientHbBatchReq(void *buf, int32_t bufLen, SClientHbBatchR
} }
if (!tDecodeIsEnd(&decoder)) { if (!tDecodeIsEnd(&decoder)) {
tDecodeI64(&decoder, &pBatchReq->ipWhiteList); if (tDecodeI64(&decoder, &pBatchReq->ipWhiteList) < 0) return -1;
} }
tEndDecode(&decoder); tEndDecode(&decoder);
@ -2163,21 +2163,21 @@ int32_t tDeserializeSGetUserAuthRspImpl(SDecoder *pDecoder, SGetUserAuthRsp *pRs
char db[TSDB_DB_FNAME_LEN] = {0}; char db[TSDB_DB_FNAME_LEN] = {0};
if (tDecodeCStrTo(pDecoder, db) < 0) goto _err; if (tDecodeCStrTo(pDecoder, db) < 0) goto _err;
int32_t len = strlen(db); 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) { for (int32_t i = 0; i < numOfReadDbs; ++i) {
char db[TSDB_DB_FNAME_LEN] = {0}; char db[TSDB_DB_FNAME_LEN] = {0};
if (tDecodeCStrTo(pDecoder, db) < 0) goto _err; if (tDecodeCStrTo(pDecoder, db) < 0) goto _err;
int32_t len = strlen(db); 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) { for (int32_t i = 0; i < numOfWriteDbs; ++i) {
char db[TSDB_DB_FNAME_LEN] = {0}; char db[TSDB_DB_FNAME_LEN] = {0};
if (tDecodeCStrTo(pDecoder, db) < 0) goto _err; if (tDecodeCStrTo(pDecoder, db) < 0) goto _err;
int32_t len = strlen(db); 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)) { 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 ((value = taosMemoryCalloc(valuelen + 1, sizeof(char))) == NULL) goto _err;
if (tDecodeCStrTo(pDecoder, value) < 0) 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(key);
taosMemoryFreeClear(value); taosMemoryFreeClear(value);
@ -2228,7 +2228,7 @@ int32_t tDeserializeSGetUserAuthRspImpl(SDecoder *pDecoder, SGetUserAuthRsp *pRs
if ((value = taosMemoryCalloc(valuelen + 1, sizeof(char))) == NULL) goto _err; if ((value = taosMemoryCalloc(valuelen + 1, sizeof(char))) == NULL) goto _err;
if (tDecodeCStrTo(pDecoder, value) < 0) goto _err; if (tDecodeCStrTo(pDecoder, value) < 0) goto _err;
taosHashPut(pRsp->writeTbs, key, keyLen, value, valuelen + 1); if (taosHashPut(pRsp->writeTbs, key, keyLen, value, valuelen + 1) < 0) goto _err;
taosMemoryFreeClear(key); taosMemoryFreeClear(key);
taosMemoryFreeClear(value); taosMemoryFreeClear(value);
@ -2247,7 +2247,7 @@ int32_t tDeserializeSGetUserAuthRspImpl(SDecoder *pDecoder, SGetUserAuthRsp *pRs
if ((value = taosMemoryCalloc(valuelen + 1, sizeof(char))) == NULL) goto _err; if ((value = taosMemoryCalloc(valuelen + 1, sizeof(char))) == NULL) goto _err;
if (tDecodeCStrTo(pDecoder, value) < 0) 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(key);
taosMemoryFreeClear(value); taosMemoryFreeClear(value);
@ -2266,7 +2266,7 @@ int32_t tDeserializeSGetUserAuthRspImpl(SDecoder *pDecoder, SGetUserAuthRsp *pRs
if ((value = taosMemoryCalloc(valuelen + 1, sizeof(char))) == NULL) goto _err; if ((value = taosMemoryCalloc(valuelen + 1, sizeof(char))) == NULL) goto _err;
if (tDecodeCStrTo(pDecoder, value) < 0) 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(key);
taosMemoryFreeClear(value); taosMemoryFreeClear(value);
@ -2285,7 +2285,7 @@ int32_t tDeserializeSGetUserAuthRspImpl(SDecoder *pDecoder, SGetUserAuthRsp *pRs
if ((value = taosMemoryCalloc(valuelen + 1, sizeof(char))) == NULL) goto _err; if ((value = taosMemoryCalloc(valuelen + 1, sizeof(char))) == NULL) goto _err;
if (tDecodeCStrTo(pDecoder, value) < 0) goto _err; if (tDecodeCStrTo(pDecoder, value) < 0) goto _err;
taosHashPut(pRsp->writeViews, key, keyLen, value, valuelen + 1); if (taosHashPut(pRsp->writeViews, key, keyLen, value, valuelen + 1) < 0) goto _err;
taosMemoryFreeClear(key); taosMemoryFreeClear(key);
taosMemoryFreeClear(value); taosMemoryFreeClear(value);
@ -2304,7 +2304,7 @@ int32_t tDeserializeSGetUserAuthRspImpl(SDecoder *pDecoder, SGetUserAuthRsp *pRs
if ((value = taosMemoryCalloc(valuelen + 1, sizeof(char))) == NULL) goto _err; if ((value = taosMemoryCalloc(valuelen + 1, sizeof(char))) == NULL) goto _err;
if (tDecodeCStrTo(pDecoder, value) < 0) 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(key);
taosMemoryFreeClear(value); taosMemoryFreeClear(value);
@ -2320,7 +2320,7 @@ int32_t tDeserializeSGetUserAuthRspImpl(SDecoder *pDecoder, SGetUserAuthRsp *pRs
int32_t ref = 0; int32_t ref = 0;
if (tDecodeI32(pDecoder, &ref) < 0) goto _err; 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); taosMemoryFreeClear(key);
} }
// since 3.0.7.0 // since 3.0.7.0
@ -4240,7 +4240,7 @@ int32_t tSerializeSDbCfgRsp(void *buf, int32_t bufLen, const SDbCfgRsp *pRsp) {
tEncoderInit(&encoder, buf, bufLen); tEncoderInit(&encoder, buf, bufLen);
if (tStartEncode(&encoder) < 0) return -1; if (tStartEncode(&encoder) < 0) return -1;
tSerializeSDbCfgRspImpl(&encoder, pRsp); if (tSerializeSDbCfgRspImpl(&encoder, pRsp) < 0) return -1;
tEndEncode(&encoder); tEndEncode(&encoder);
int32_t tlen = encoder.pos; int32_t tlen = encoder.pos;
tEncoderClear(&encoder); tEncoderClear(&encoder);
@ -7101,7 +7101,7 @@ int32_t tDeserializeSMqSeekReq(void *buf, int32_t bufLen, SMqSeekReq *pReq) {
if (tStartDecode(&decoder) < 0) return -1; if (tStartDecode(&decoder) < 0) return -1;
if (tDecodeI64(&decoder, &pReq->consumerId) < 0) return -1; if (tDecodeI64(&decoder, &pReq->consumerId) < 0) return -1;
tDecodeCStrTo(&decoder, pReq->subKey); if (tDecodeCStrTo(&decoder, pReq->subKey) < 0) return -1;
tEndDecode(&decoder); tEndDecode(&decoder);
@ -7815,8 +7815,8 @@ int32_t tEncodeTSma(SEncoder *pCoder, const STSma *pSma) {
if (tEncodeCStr(pCoder, pSma->tagsFilter) < 0) return -1; if (tEncodeCStr(pCoder, pSma->tagsFilter) < 0) return -1;
} }
tEncodeSSchemaWrapper(pCoder, &pSma->schemaRow); if (tEncodeSSchemaWrapper(pCoder, &pSma->schemaRow) < 0) return -1;
tEncodeSSchemaWrapper(pCoder, &pSma->schemaTag); if (tEncodeSSchemaWrapper(pCoder, &pSma->schemaTag) < 0) return -1;
return 0; return 0;
} }
@ -7861,8 +7861,8 @@ int32_t tDecodeTSma(SDecoder *pCoder, STSma *pSma, bool deepCopy) {
pSma->tagsFilter = NULL; pSma->tagsFilter = NULL;
} }
// only needed in dstVgroup // only needed in dstVgroup
tDecodeSSchemaWrapperEx(pCoder, &pSma->schemaRow); if (tDecodeSSchemaWrapperEx(pCoder, &pSma->schemaRow) < 0) return -1;
tDecodeSSchemaWrapperEx(pCoder, &pSma->schemaTag); if (tDecodeSSchemaWrapperEx(pCoder, &pSma->schemaTag) < 0) return -1;
return 0; return 0;
} }
@ -7870,7 +7870,7 @@ int32_t tDecodeTSma(SDecoder *pCoder, STSma *pSma, bool deepCopy) {
int32_t tEncodeSVCreateTSmaReq(SEncoder *pCoder, const SVCreateTSmaReq *pReq) { int32_t tEncodeSVCreateTSmaReq(SEncoder *pCoder, const SVCreateTSmaReq *pReq) {
if (tStartEncode(pCoder) < 0) return -1; if (tStartEncode(pCoder) < 0) return -1;
tEncodeTSma(pCoder, pReq); if (tEncodeTSma(pCoder, pReq) < 0) return -1;
tEndEncode(pCoder); tEndEncode(pCoder);
return 0; return 0;
@ -7879,7 +7879,7 @@ int32_t tEncodeSVCreateTSmaReq(SEncoder *pCoder, const SVCreateTSmaReq *pReq) {
int32_t tDecodeSVCreateTSmaReq(SDecoder *pCoder, SVCreateTSmaReq *pReq) { int32_t tDecodeSVCreateTSmaReq(SDecoder *pCoder, SVCreateTSmaReq *pReq) {
if (tStartDecode(pCoder) < 0) return -1; if (tStartDecode(pCoder) < 0) return -1;
tDecodeTSma(pCoder, pReq, false); if (tDecodeTSma(pCoder, pReq, false) < 0) return -1;
tEndDecode(pCoder); tEndDecode(pCoder);
return 0; return 0;
@ -9238,17 +9238,18 @@ bool tOffsetEqual(const STqOffsetVal *pLeft, const STqOffsetVal *pRight) {
return false; return false;
} }
void tOffsetCopy(STqOffsetVal *pLeft, const STqOffsetVal *pRight) { int32_t tOffsetCopy(STqOffsetVal *pLeft, const STqOffsetVal *pRight) {
tOffsetDestroy(pLeft); tOffsetDestroy(pLeft);
*pLeft = *pRight; *pLeft = *pRight;
if (IS_VAR_DATA_TYPE(pRight->primaryKey.type)) { if (IS_VAR_DATA_TYPE(pRight->primaryKey.type)) {
pLeft->primaryKey.pData = taosMemoryMalloc(pRight->primaryKey.nData); pLeft->primaryKey.pData = taosMemoryMalloc(pRight->primaryKey.nData);
if (pLeft->primaryKey.pData == NULL) { if (pLeft->primaryKey.pData == NULL) {
uError("failed to allocate memory for offset"); uError("failed to allocate memory for offset");
return; return terrno;
} }
(void)memcpy(pLeft->primaryKey.pData, pRight->primaryKey.pData, pRight->primaryKey.nData); (void)memcpy(pLeft->primaryKey.pData, pRight->primaryKey.pData, pRight->primaryKey.nData);
} }
return 0;
} }
void tOffsetDestroy(void *param) { void tOffsetDestroy(void *param) {
@ -10740,7 +10741,7 @@ void tFreeSMDropTbReqOnSingleVg(void *p) {
int32_t tSerializeSMDropTbsReq(void *buf, int32_t bufLen, const SMDropTbsReq *pReq) { int32_t tSerializeSMDropTbsReq(void *buf, int32_t bufLen, const SMDropTbsReq *pReq) {
SEncoder encoder = {0}; SEncoder encoder = {0};
tEncoderInit(&encoder, buf, bufLen); tEncoderInit(&encoder, buf, bufLen);
tStartEncode(&encoder); if (tStartEncode(&encoder) < 0) return -1;
int32_t size = pReq->pVgReqs ? pReq->pVgReqs->size : 0; int32_t size = pReq->pVgReqs ? pReq->pVgReqs->size : 0;
if (tEncodeI32(&encoder, size) < 0) return -1; if (tEncodeI32(&encoder, size) < 0) return -1;
for (int32_t i = 0; i < size; ++i) { for (int32_t i = 0; i < size; ++i) {
@ -10756,7 +10757,7 @@ int32_t tSerializeSMDropTbsReq(void *buf, int32_t bufLen, const SMDropTbsReq *pR
int32_t tDeserializeSMDropTbsReq(void *buf, int32_t bufLen, SMDropTbsReq *pReq) { int32_t tDeserializeSMDropTbsReq(void *buf, int32_t bufLen, SMDropTbsReq *pReq) {
SDecoder decoder = {0}; SDecoder decoder = {0};
tDecoderInit(&decoder, buf, bufLen); tDecoderInit(&decoder, buf, bufLen);
tStartDecode(&decoder); if (tStartDecode(&decoder) < 0) return -1;
int32_t size = 0; int32_t size = 0;
if (tDecodeI32(&decoder, &size) < 0) return -1; if (tDecodeI32(&decoder, &size) < 0) return -1;
pReq->pVgReqs = taosArrayInit(size, sizeof(SMDropTbReqsOnSingleVg)); pReq->pVgReqs = taosArrayInit(size, sizeof(SMDropTbReqsOnSingleVg));

42
source/dnode/mgmt/exe/dmMain.c
View File

@ -80,11 +80,11 @@ static void dmSetAssert(int32_t signum, void *sigInfo, void *context) { tsAssert
static void dmStopDnode(int signum, void *sigInfo, void *context) { static void dmStopDnode(int signum, void *sigInfo, void *context) {
// taosIgnSignal(SIGUSR1); // taosIgnSignal(SIGUSR1);
// taosIgnSignal(SIGUSR2); // taosIgnSignal(SIGUSR2);
taosIgnSignal(SIGTERM); (void)taosIgnSignal(SIGTERM);
taosIgnSignal(SIGHUP); (void)taosIgnSignal(SIGHUP);
taosIgnSignal(SIGINT); (void)taosIgnSignal(SIGINT);
taosIgnSignal(SIGABRT); (void)taosIgnSignal(SIGABRT);
taosIgnSignal(SIGBREAK); (void)taosIgnSignal(SIGBREAK);
dInfo("shut down signal is %d", signum); dInfo("shut down signal is %d", signum);
#ifndef WINDOWS #ifndef WINDOWS
@ -102,11 +102,11 @@ void dmLogCrash(int signum, void *sigInfo, void *context) {
// taosIgnSignal(SIGBREAK); // taosIgnSignal(SIGBREAK);
#ifndef WINDOWS #ifndef WINDOWS
taosIgnSignal(SIGBUS); (void)taosIgnSignal(SIGBUS);
#endif #endif
taosIgnSignal(SIGABRT); (void)taosIgnSignal(SIGABRT);
taosIgnSignal(SIGFPE); (void)taosIgnSignal(SIGFPE);
taosIgnSignal(SIGSEGV); (void)taosIgnSignal(SIGSEGV);
char *pMsg = NULL; char *pMsg = NULL;
const char *flags = "UTL FATAL "; const char *flags = "UTL FATAL ";
@ -135,23 +135,23 @@ _return:
} }
static void dmSetSignalHandle() { static void dmSetSignalHandle() {
taosSetSignal(SIGUSR1, dmSetDebugFlag); (void)taosSetSignal(SIGUSR1, dmSetDebugFlag);
taosSetSignal(SIGUSR2, dmSetAssert); (void)taosSetSignal(SIGUSR2, dmSetAssert);
taosSetSignal(SIGTERM, dmStopDnode); (void)taosSetSignal(SIGTERM, dmStopDnode);
taosSetSignal(SIGHUP, dmStopDnode); (void)taosSetSignal(SIGHUP, dmStopDnode);
taosSetSignal(SIGINT, dmStopDnode); (void)taosSetSignal(SIGINT, dmStopDnode);
taosSetSignal(SIGBREAK, dmStopDnode); (void)taosSetSignal(SIGBREAK, dmStopDnode);
#ifndef WINDOWS #ifndef WINDOWS
taosSetSignal(SIGTSTP, dmStopDnode); (void)taosSetSignal(SIGTSTP, dmStopDnode);
taosSetSignal(SIGQUIT, dmStopDnode); (void)taosSetSignal(SIGQUIT, dmStopDnode);
#endif #endif
#ifndef WINDOWS #ifndef WINDOWS
taosSetSignal(SIGBUS, dmLogCrash); (void)taosSetSignal(SIGBUS, dmLogCrash);
#endif #endif
taosSetSignal(SIGABRT, dmLogCrash); (void)taosSetSignal(SIGABRT, dmLogCrash);
taosSetSignal(SIGFPE, dmLogCrash); (void)taosSetSignal(SIGFPE, dmLogCrash);
taosSetSignal(SIGSEGV, dmLogCrash); (void)taosSetSignal(SIGSEGV, dmLogCrash);
} }
static int32_t dmParseArgs(int32_t argc, char const *argv[]) { static int32_t dmParseArgs(int32_t argc, char const *argv[]) {

57
source/dnode/mgmt/mgmt_dnode/src/dmHandle.c
View File

@ -21,32 +21,45 @@
extern SConfig *tsCfg; extern SConfig *tsCfg;
static void dmUpdateDnodeCfg(SDnodeMgmt *pMgmt, SDnodeCfg *pCfg) { static void dmUpdateDnodeCfg(SDnodeMgmt *pMgmt, SDnodeCfg *pCfg) {
int32_t code = 0;
if (pMgmt->pData->dnodeId == 0 || pMgmt->pData->clusterId == 0) { if (pMgmt->pData->dnodeId == 0 || pMgmt->pData->clusterId == 0) {
dInfo("set local info, dnodeId:%d clusterId:%" PRId64, pCfg->dnodeId, pCfg->clusterId); dInfo("set local info, dnodeId:%d clusterId:%" PRId64, pCfg->dnodeId, pCfg->clusterId);
taosThreadRwlockWrlock(&pMgmt->pData->lock); (void)taosThreadRwlockWrlock(&pMgmt->pData->lock);
pMgmt->pData->dnodeId = pCfg->dnodeId; pMgmt->pData->dnodeId = pCfg->dnodeId;
pMgmt->pData->clusterId = pCfg->clusterId; pMgmt->pData->clusterId = pCfg->clusterId;
dmWriteEps(pMgmt->pData); code = dmWriteEps(pMgmt->pData);
taosThreadRwlockUnlock(&pMgmt->pData->lock); if (code != 0) {
dInfo("failed to set local info, dnodeId:%d clusterId:%" PRId64 " reason:%s", pCfg->dnodeId, pCfg->clusterId,
tstrerror(code));
}
(void)taosThreadRwlockUnlock(&pMgmt->pData->lock);
} }
} }
static void dmMayShouldUpdateIpWhiteList(SDnodeMgmt *pMgmt, int64_t ver) { static void dmMayShouldUpdateIpWhiteList(SDnodeMgmt *pMgmt, int64_t ver) {
int32_t code = 0;
dDebug("ip-white-list on dnode ver: %" PRId64 ", status ver: %" PRId64 "", pMgmt->pData->ipWhiteVer, ver); dDebug("ip-white-list on dnode ver: %" PRId64 ", status ver: %" PRId64 "", pMgmt->pData->ipWhiteVer, ver);
if (pMgmt->pData->ipWhiteVer == ver) { if (pMgmt->pData->ipWhiteVer == ver) {
if (ver == 0) { if (ver == 0) {
dDebug("disable ip-white-list on dnode ver: %" PRId64 ", status ver: %" PRId64 "", pMgmt->pData->ipWhiteVer, ver); dDebug("disable ip-white-list on dnode ver: %" PRId64 ", status ver: %" PRId64 "", pMgmt->pData->ipWhiteVer, ver);
rpcSetIpWhite(pMgmt->msgCb.serverRpc, NULL); rpcSetIpWhite(pMgmt->msgCb.serverRpc, NULL);
// pMgmt->ipWhiteVer = ver;
} }
return; return;
} }
int64_t oldVer = pMgmt->pData->ipWhiteVer; int64_t oldVer = pMgmt->pData->ipWhiteVer;
// pMgmt->ipWhiteVer = ver;
SRetrieveIpWhiteReq req = {.ipWhiteVer = oldVer}; SRetrieveIpWhiteReq req = {.ipWhiteVer = oldVer};
int32_t contLen = tSerializeRetrieveIpWhite(NULL, 0, &req); int32_t contLen = tSerializeRetrieveIpWhite(NULL, 0, &req);
if (contLen < 0) {
dError("failed to serialize ip white list request since: %s", tstrerror(contLen));
return;
}
void *pHead = rpcMallocCont(contLen); void *pHead = rpcMallocCont(contLen);
tSerializeRetrieveIpWhite(pHead, contLen, &req); contLen = tSerializeRetrieveIpWhite(pHead, contLen, &req);
if (contLen < 0) {
rpcFreeCont(pHead);
dError("failed to serialize ip white list request since:%s", tstrerror(contLen));
return;
}
SRpcMsg rpcMsg = {.pCont = pHead, SRpcMsg rpcMsg = {.pCont = pHead,
.contLen = contLen, .contLen = contLen,
@ -57,9 +70,12 @@ static void dmMayShouldUpdateIpWhiteList(SDnodeMgmt *pMgmt, int64_t ver) {
.info.handle = 0}; .info.handle = 0};
SEpSet epset = {0}; SEpSet epset = {0};
dmGetMnodeEpSet(pMgmt->pData, &epset); (void)dmGetMnodeEpSet(pMgmt->pData, &epset);
rpcSendRequest(pMgmt->msgCb.clientRpc, &epset, &rpcMsg, NULL); code = rpcSendRequest(pMgmt->msgCb.clientRpc, &epset, &rpcMsg, NULL);
if (code != 0) {
dError("failed to send retrieve ip white list request since:%s", tstrerror(code));
}
} }
static void dmProcessStatusRsp(SDnodeMgmt *pMgmt, SRpcMsg *pRsp) { static void dmProcessStatusRsp(SDnodeMgmt *pMgmt, SRpcMsg *pRsp) {
const STraceId *trace = &pRsp->info.traceId; const STraceId *trace = &pRsp->info.traceId;
@ -72,7 +88,7 @@ static void dmProcessStatusRsp(SDnodeMgmt *pMgmt, SRpcMsg *pRsp) {
pMgmt->pData->dropped = 1; pMgmt->pData->dropped = 1;
dmWriteEps(pMgmt->pData); dmWriteEps(pMgmt->pData);
dInfo("dnode will exit since it is in the dropped state"); dInfo("dnode will exit since it is in the dropped state");
raise(SIGINT); (void)raise(SIGINT);
} }
} else { } else {
SStatusRsp statusRsp = {0}; SStatusRsp statusRsp = {0};
@ -93,9 +109,10 @@ static void dmProcessStatusRsp(SDnodeMgmt *pMgmt, SRpcMsg *pRsp) {
} }
void dmSendStatusReq(SDnodeMgmt *pMgmt) { void dmSendStatusReq(SDnodeMgmt *pMgmt) {
int32_t code = 0;
SStatusReq req = {0}; SStatusReq req = {0};
taosThreadRwlockRdlock(&pMgmt->pData->lock); (void)taosThreadRwlockRdlock(&pMgmt->pData->lock);
req.sver = tsVersion; req.sver = tsVersion;
req.dnodeVer = pMgmt->pData->dnodeVer; req.dnodeVer = pMgmt->pData->dnodeVer;
req.dnodeId = pMgmt->pData->dnodeId; req.dnodeId = pMgmt->pData->dnodeId;
@ -129,7 +146,7 @@ void dmSendStatusReq(SDnodeMgmt *pMgmt) {
memcpy(req.clusterCfg.timezone, tsTimezoneStr, TD_TIMEZONE_LEN); memcpy(req.clusterCfg.timezone, tsTimezoneStr, TD_TIMEZONE_LEN);
memcpy(req.clusterCfg.locale, tsLocale, TD_LOCALE_LEN); memcpy(req.clusterCfg.locale, tsLocale, TD_LOCALE_LEN);
memcpy(req.clusterCfg.charset, tsCharset, TD_LOCALE_LEN); memcpy(req.clusterCfg.charset, tsCharset, TD_LOCALE_LEN);
taosThreadRwlockUnlock(&pMgmt->pData->lock); (void)taosThreadRwlockUnlock(&pMgmt->pData->lock);
SMonVloadInfo vinfo = {0}; SMonVloadInfo vinfo = {0};
(*pMgmt->getVnodeLoadsFp)(&vinfo); (*pMgmt->getVnodeLoadsFp)(&vinfo);
@ -146,8 +163,17 @@ void dmSendStatusReq(SDnodeMgmt *pMgmt) {
req.ipWhiteVer = pMgmt->pData->ipWhiteVer; req.ipWhiteVer = pMgmt->pData->ipWhiteVer;
int32_t contLen = tSerializeSStatusReq(NULL, 0, &req); int32_t contLen = tSerializeSStatusReq(NULL, 0, &req);
if (contLen < 0) {
dError("failed to serialize status req since %s", tstrerror(contLen));
return;
}
void *pHead = rpcMallocCont(contLen); void *pHead = rpcMallocCont(contLen);
tSerializeSStatusReq(pHead, contLen, &req); tSerializeSStatusReq(pHead, contLen, &req);
if (contLen < 0) {
rpcFreeCont(pHead);
dError("failed to serialize status req since %s", tstrerror(contLen));
return;
}
tFreeSStatusReq(&req); tFreeSStatusReq(&req);
SRpcMsg rpcMsg = {.pCont = pHead, SRpcMsg rpcMsg = {.pCont = pHead,
@ -163,8 +189,15 @@ void dmSendStatusReq(SDnodeMgmt *pMgmt) {
SEpSet epSet = {0}; SEpSet epSet = {0};
int8_t epUpdated = 0; int8_t epUpdated = 0;
dmGetMnodeEpSet(pMgmt->pData, &epSet); (void)dmGetMnodeEpSet(pMgmt->pData, &epSet);
code =
rpcSendRecvWithTimeout(pMgmt->msgCb.statusRpc, &epSet, &rpcMsg, &rpcRsp, &epUpdated, tsStatusInterval * 5 * 1000); rpcSendRecvWithTimeout(pMgmt->msgCb.statusRpc, &epSet, &rpcMsg, &rpcRsp, &epUpdated, tsStatusInterval * 5 * 1000);
if (code != 0) {
dError("failed to send status req since %s", tstrerror(code));
return;
}
if (rpcRsp.code != 0) { if (rpcRsp.code != 0) {
dmRotateMnodeEpSet(pMgmt->pData); dmRotateMnodeEpSet(pMgmt->pData);
char tbuf[512]; char tbuf[512];

66
source/dnode/mgmt/mgmt_dnode/src/dmWorker.c
View File

@ -266,22 +266,22 @@ static void *dmCrashReportThreadFp(void *param) {
int32_t dmStartStatusThread(SDnodeMgmt *pMgmt) { int32_t dmStartStatusThread(SDnodeMgmt *pMgmt) {
int32_t code = 0; int32_t code = 0;
TdThreadAttr thAttr; TdThreadAttr thAttr;
taosThreadAttrInit(&thAttr); (void)taosThreadAttrInit(&thAttr);
taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE); (void)taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE);
if (taosThreadCreate(&pMgmt->statusThread, &thAttr, dmStatusThreadFp, pMgmt) != 0) { if (taosThreadCreate(&pMgmt->statusThread, &thAttr, dmStatusThreadFp, pMgmt) != 0) {
code = TAOS_SYSTEM_ERROR(errno); code = TAOS_SYSTEM_ERROR(errno);
dError("failed to create status thread since %s", tstrerror(code)); dError("failed to create status thread since %s", tstrerror(code));
return code; return code;
} }
taosThreadAttrDestroy(&thAttr); (void)taosThreadAttrDestroy(&thAttr);
tmsgReportStartup("dnode-status", "initialized"); tmsgReportStartup("dnode-status", "initialized");
return 0; return 0;
} }
void dmStopStatusThread(SDnodeMgmt *pMgmt) { void dmStopStatusThread(SDnodeMgmt *pMgmt) {
if (taosCheckPthreadValid(pMgmt->statusThread)) { if (taosCheckPthreadValid(pMgmt->statusThread)) {
taosThreadJoin(pMgmt->statusThread, NULL); (void)taosThreadJoin(pMgmt->statusThread, NULL);
taosThreadClear(&pMgmt->statusThread); taosThreadClear(&pMgmt->statusThread);
} }
} }
@ -289,40 +289,40 @@ void dmStopStatusThread(SDnodeMgmt *pMgmt) {
int32_t dmStartNotifyThread(SDnodeMgmt *pMgmt) { int32_t dmStartNotifyThread(SDnodeMgmt *pMgmt) {
int32_t code = 0; int32_t code = 0;
TdThreadAttr thAttr; TdThreadAttr thAttr;
taosThreadAttrInit(&thAttr); (void)taosThreadAttrInit(&thAttr);
taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE); (void)taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE);
if (taosThreadCreate(&pMgmt->notifyThread, &thAttr, dmNotifyThreadFp, pMgmt) != 0) { if (taosThreadCreate(&pMgmt->notifyThread, &thAttr, dmNotifyThreadFp, pMgmt) != 0) {
code = TAOS_SYSTEM_ERROR(errno); code = TAOS_SYSTEM_ERROR(errno);
dError("failed to create notify thread since %s", strerror(code)); dError("failed to create notify thread since %s", strerror(code));
return code; return code;
} }
taosThreadAttrDestroy(&thAttr); (void)taosThreadAttrDestroy(&thAttr);
tmsgReportStartup("dnode-notify", "initialized"); tmsgReportStartup("dnode-notify", "initialized");
return 0; return 0;
} }
void dmStopNotifyThread(SDnodeMgmt *pMgmt) { void dmStopNotifyThread(SDnodeMgmt *pMgmt) {
if (taosCheckPthreadValid(pMgmt->notifyThread)) { if (taosCheckPthreadValid(pMgmt->notifyThread)) {
tsem_post(&dmNotifyHdl.sem); (void)tsem_post(&dmNotifyHdl.sem);
taosThreadJoin(pMgmt->notifyThread, NULL); (void)taosThreadJoin(pMgmt->notifyThread, NULL);
taosThreadClear(&pMgmt->notifyThread); taosThreadClear(&pMgmt->notifyThread);
} }
tsem_destroy(&dmNotifyHdl.sem); (void)tsem_destroy(&dmNotifyHdl.sem);
} }
int32_t dmStartMonitorThread(SDnodeMgmt *pMgmt) { int32_t dmStartMonitorThread(SDnodeMgmt *pMgmt) {
int32_t code = 0; int32_t code = 0;
TdThreadAttr thAttr; TdThreadAttr thAttr;
taosThreadAttrInit(&thAttr); (void)taosThreadAttrInit(&thAttr);
taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE); (void)taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE);
if (taosThreadCreate(&pMgmt->monitorThread, &thAttr, dmMonitorThreadFp, pMgmt) != 0) { if (taosThreadCreate(&pMgmt->monitorThread, &thAttr, dmMonitorThreadFp, pMgmt) != 0) {
code = TAOS_SYSTEM_ERROR(errno); code = TAOS_SYSTEM_ERROR(errno);
dError("failed to create monitor thread since %s", tstrerror(code)); dError("failed to create monitor thread since %s", tstrerror(code));
return code; return code;
} }
taosThreadAttrDestroy(&thAttr); (void)taosThreadAttrDestroy(&thAttr);
tmsgReportStartup("dnode-monitor", "initialized"); tmsgReportStartup("dnode-monitor", "initialized");
return 0; return 0;
} }
@ -330,30 +330,30 @@ int32_t dmStartMonitorThread(SDnodeMgmt *pMgmt) {
int32_t dmStartAuditThread(SDnodeMgmt *pMgmt) { int32_t dmStartAuditThread(SDnodeMgmt *pMgmt) {
int32_t code = 0; int32_t code = 0;
TdThreadAttr thAttr; TdThreadAttr thAttr;
taosThreadAttrInit(&thAttr); (void)taosThreadAttrInit(&thAttr);
taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE); (void)taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE);
if (taosThreadCreate(&pMgmt->auditThread, &thAttr, dmAuditThreadFp, pMgmt) != 0) { if (taosThreadCreate(&pMgmt->auditThread, &thAttr, dmAuditThreadFp, pMgmt) != 0) {
code = TAOS_SYSTEM_ERROR(errno); code = TAOS_SYSTEM_ERROR(errno);
dError("failed to create audit thread since %s", tstrerror(code)); dError("failed to create audit thread since %s", tstrerror(code));
return code; return code;
} }
taosThreadAttrDestroy(&thAttr); (void)taosThreadAttrDestroy(&thAttr);
tmsgReportStartup("dnode-audit", "initialized"); tmsgReportStartup("dnode-audit", "initialized");
return 0; return 0;
} }
void dmStopMonitorThread(SDnodeMgmt *pMgmt) { void dmStopMonitorThread(SDnodeMgmt *pMgmt) {
if (taosCheckPthreadValid(pMgmt->monitorThread)) { if (taosCheckPthreadValid(pMgmt->monitorThread)) {
taosThreadJoin(pMgmt->monitorThread, NULL); (void)taosThreadJoin(pMgmt->monitorThread, NULL);
taosThreadClear(&pMgmt->monitorThread); (void)taosThreadClear(&pMgmt->monitorThread);
} }
} }
void dmStopAuditThread(SDnodeMgmt *pMgmt) { void dmStopAuditThread(SDnodeMgmt *pMgmt) {
if (taosCheckPthreadValid(pMgmt->auditThread)) { if (taosCheckPthreadValid(pMgmt->auditThread)) {
taosThreadJoin(pMgmt->auditThread, NULL); (void)taosThreadJoin(pMgmt->auditThread, NULL);
taosThreadClear(&pMgmt->auditThread); (void)taosThreadClear(&pMgmt->auditThread);
} }
} }
@ -364,15 +364,15 @@ int32_t dmStartCrashReportThread(SDnodeMgmt *pMgmt) {
} }
TdThreadAttr thAttr; TdThreadAttr thAttr;
taosThreadAttrInit(&thAttr); (void)taosThreadAttrInit(&thAttr);
taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE); (void)taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE);
if (taosThreadCreate(&pMgmt->crashReportThread, &thAttr, dmCrashReportThreadFp, pMgmt) != 0) { if (taosThreadCreate(&pMgmt->crashReportThread, &thAttr, dmCrashReportThreadFp, pMgmt) != 0) {
code = TAOS_SYSTEM_ERROR(errno); code = TAOS_SYSTEM_ERROR(errno);
dError("failed to create crashReport thread since %s", tstrerror(code)); dError("failed to create crashReport thread since %s", tstrerror(code));
return code; return code;
} }
taosThreadAttrDestroy(&thAttr); (void)taosThreadAttrDestroy(&thAttr);
tmsgReportStartup("dnode-crashReport", "initialized"); tmsgReportStartup("dnode-crashReport", "initialized");
return 0; return 0;
} }
@ -383,8 +383,8 @@ void dmStopCrashReportThread(SDnodeMgmt *pMgmt) {
} }
if (taosCheckPthreadValid(pMgmt->crashReportThread)) { if (taosCheckPthreadValid(pMgmt->crashReportThread)) {
taosThreadJoin(pMgmt->crashReportThread, NULL); (void)taosThreadJoin(pMgmt->crashReportThread, NULL);
taosThreadClear(&pMgmt->crashReportThread); (void)taosThreadClear(&pMgmt->crashReportThread);
} }
} }
@ -454,7 +454,11 @@ static void dmProcessMgmtQueue(SQueueInfo *pInfo, SRpcMsg *pMsg) {
.contLen = pMsg->info.rspLen, .contLen = pMsg->info.rspLen,
.info = pMsg->info, .info = pMsg->info,
}; };
rpcSendResponse(&rsp);
code = rpcSendResponse(&rsp);
if (code != 0) {
dError("failed to send response since %s", tstrerror(code));
}
} }
dTrace("msg:%p, is freed, code:0x%x", pMsg, code); dTrace("msg:%p, is freed, code:0x%x", pMsg, code);
@ -463,6 +467,7 @@ static void dmProcessMgmtQueue(SQueueInfo *pInfo, SRpcMsg *pMsg) {
} }
int32_t dmStartWorker(SDnodeMgmt *pMgmt) { int32_t dmStartWorker(SDnodeMgmt *pMgmt) {
int32_t code = 0;
SSingleWorkerCfg cfg = { SSingleWorkerCfg cfg = {
.min = 1, .min = 1,
.max = 1, .max = 1,
@ -470,9 +475,9 @@ int32_t dmStartWorker(SDnodeMgmt *pMgmt) {
.fp = (FItem)dmProcessMgmtQueue, .fp = (FItem)dmProcessMgmtQueue,
.param = pMgmt, .param = pMgmt,
}; };
if (tSingleWorkerInit(&pMgmt->mgmtWorker, &cfg) != 0) { if ((code = tSingleWorkerInit(&pMgmt->mgmtWorker, &cfg)) != 0) {
dError("failed to start dnode-mgmt worker since %s", terrstr()); dError("failed to start dnode-mgmt worker since %s", tstrerror(code));
return -1; return code;
} }
dDebug("dnode workers are initialized"); dDebug("dnode workers are initialized");
@ -487,6 +492,5 @@ void dmStopWorker(SDnodeMgmt *pMgmt) {
int32_t dmPutNodeMsgToMgmtQueue(SDnodeMgmt *pMgmt, SRpcMsg *pMsg) { int32_t dmPutNodeMsgToMgmtQueue(SDnodeMgmt *pMgmt, SRpcMsg *pMsg) {
SSingleWorker *pWorker = &pMgmt->mgmtWorker; SSingleWorker *pWorker = &pMgmt->mgmtWorker;
dTrace("msg:%p, put into worker %s", pMsg, pWorker->name); dTrace("msg:%p, put into worker %s", pMsg, pWorker->name);
taosWriteQitem(pWorker->queue, pMsg); return taosWriteQitem(pWorker->queue, pMsg);
return 0;
} }

4
source/dnode/mgmt/mgmt_mnode/src/mmHandle.c
View File

@ -17,12 +17,12 @@
#include "mmInt.h" #include "mmInt.h"
void mmGetMonitorInfo(SMnodeMgmt *pMgmt, SMonMmInfo *pInfo) { void mmGetMonitorInfo(SMnodeMgmt *pMgmt, SMonMmInfo *pInfo) {
mndGetMonitorInfo(pMgmt->pMnode, &pInfo->cluster, &pInfo->vgroup, &pInfo->stb, &pInfo->grant); (void)mndGetMonitorInfo(pMgmt->pMnode, &pInfo->cluster, &pInfo->vgroup, &pInfo->stb, &pInfo->grant);
} }
void mmGetMnodeLoads(SMnodeMgmt *pMgmt, SMonMloadInfo *pInfo) { void mmGetMnodeLoads(SMnodeMgmt *pMgmt, SMonMloadInfo *pInfo) {
pInfo->isMnode = 1; pInfo->isMnode = 1;
mndGetLoad(pMgmt->pMnode, &pInfo->load); (void)mndGetLoad(pMgmt->pMnode, &pInfo->load);
} }
int32_t mmProcessCreateReq(const SMgmtInputOpt *pInput, SRpcMsg *pMsg) { int32_t mmProcessCreateReq(const SMgmtInputOpt *pInput, SRpcMsg *pMsg) {

8
source/dnode/mgmt/mgmt_mnode/src/mmInt.c
View File

@ -68,7 +68,7 @@ static void mmClose(SMnodeMgmt *pMgmt) {
if (pMgmt->pMnode != NULL) { if (pMgmt->pMnode != NULL) {
mmStopWorker(pMgmt); mmStopWorker(pMgmt);
mndClose(pMgmt->pMnode); mndClose(pMgmt->pMnode);
taosThreadRwlockDestroy(&pMgmt->lock); (void)taosThreadRwlockDestroy(&pMgmt->lock);
pMgmt->pMnode = NULL; pMgmt->pMnode = NULL;
} }
@ -107,7 +107,7 @@ static int32_t mmOpen(SMgmtInputOpt *pInput, SMgmtOutputOpt *pOutput) {
pMgmt->msgCb = pInput->msgCb; pMgmt->msgCb = pInput->msgCb;
pMgmt->msgCb.putToQueueFp = (PutToQueueFp)mmPutMsgToQueue; pMgmt->msgCb.putToQueueFp = (PutToQueueFp)mmPutMsgToQueue;
pMgmt->msgCb.mgmt = pMgmt; pMgmt->msgCb.mgmt = pMgmt;
taosThreadRwlockInit(&pMgmt->lock, NULL); (void)taosThreadRwlockInit(&pMgmt->lock, NULL);
SMnodeOpt option = {0}; SMnodeOpt option = {0};
if ((code = mmReadFile(pMgmt->path, &option)) != 0) { if ((code = mmReadFile(pMgmt->path, &option)) != 0) {
@ -163,9 +163,9 @@ static int32_t mmStart(SMnodeMgmt *pMgmt) {
static void mmStop(SMnodeMgmt *pMgmt) { static void mmStop(SMnodeMgmt *pMgmt) {
dDebug("mnode-mgmt start to stop"); dDebug("mnode-mgmt start to stop");
mndPreClose(pMgmt->pMnode); mndPreClose(pMgmt->pMnode);
taosThreadRwlockWrlock(&pMgmt->lock); (void)taosThreadRwlockWrlock(&pMgmt->lock);
pMgmt->stopped = 1; pMgmt->stopped = 1;
taosThreadRwlockUnlock(&pMgmt->lock); (void)taosThreadRwlockUnlock(&pMgmt->lock);
mndStop(pMgmt->pMnode); mndStop(pMgmt->pMnode);
} }

24
source/dnode/mgmt/mgmt_mnode/src/mmWorker.c
View File

@ -20,20 +20,20 @@
static inline int32_t mmAcquire(SMnodeMgmt *pMgmt) { static inline int32_t mmAcquire(SMnodeMgmt *pMgmt) {
int32_t code = 0; int32_t code = 0;
taosThreadRwlockRdlock(&pMgmt->lock); (void)taosThreadRwlockRdlock(&pMgmt->lock);
if (pMgmt->stopped) { if (pMgmt->stopped) {
code = -1; code = -1;
} else { } else {
atomic_add_fetch_32(&pMgmt->refCount, 1); (void)atomic_add_fetch_32(&pMgmt->refCount, 1);
} }
taosThreadRwlockUnlock(&pMgmt->lock); (void)taosThreadRwlockUnlock(&pMgmt->lock);
return code; return code;
} }
static inline void mmRelease(SMnodeMgmt *pMgmt) { static inline void mmRelease(SMnodeMgmt *pMgmt) {
taosThreadRwlockRdlock(&pMgmt->lock); (void)taosThreadRwlockRdlock(&pMgmt->lock);
atomic_sub_fetch_32(&pMgmt->refCount, 1); (void)atomic_sub_fetch_32(&pMgmt->refCount, 1);
taosThreadRwlockUnlock(&pMgmt->lock); (void)taosThreadRwlockUnlock(&pMgmt->lock);
} }
static inline void mmSendRsp(SRpcMsg *pMsg, int32_t code) { static inline void mmSendRsp(SRpcMsg *pMsg, int32_t code) {
@ -100,16 +100,16 @@ static void mmProcessSyncMsg(SQueueInfo *pInfo, SRpcMsg *pMsg) {
static inline int32_t mmPutMsgToWorker(SMnodeMgmt *pMgmt, SSingleWorker *pWorker, SRpcMsg *pMsg) { static inline int32_t mmPutMsgToWorker(SMnodeMgmt *pMgmt, SSingleWorker *pWorker, SRpcMsg *pMsg) {
const STraceId *trace = &pMsg->info.traceId; const STraceId *trace = &pMsg->info.traceId;
int32_t code = 0;
if (mmAcquire(pMgmt) == 0) { if ((code = mmAcquire(pMgmt)) == 0) {
dGTrace("msg:%p, put into %s queue, type:%s", pMsg, pWorker->name, TMSG_INFO(pMsg->msgType)); dGTrace("msg:%p, put into %s queue, type:%s", pMsg, pWorker->name, TMSG_INFO(pMsg->msgType));
taosWriteQitem(pWorker->queue, pMsg); code = taosWriteQitem(pWorker->queue, pMsg);
mmRelease(pMgmt); mmRelease(pMgmt);
return 0; return code;
} else { } else {
dGTrace("msg:%p, failed to put into %s queue since %s, type:%s", pMsg, pWorker->name, terrstr(), dGTrace("msg:%p, failed to put into %s queue since %s, type:%s", pMsg, pWorker->name, tstrerror(code),
TMSG_INFO(pMsg->msgType)); TMSG_INFO(pMsg->msgType));
return -1; return code;
} }
} }

4
source/dnode/mgmt/mgmt_qnode/src/qmHandle.c
View File

@ -18,13 +18,13 @@
void qmGetMonitorInfo(SQnodeMgmt *pMgmt, SMonQmInfo *qmInfo) { void qmGetMonitorInfo(SQnodeMgmt *pMgmt, SMonQmInfo *qmInfo) {
SQnodeLoad qload = {0}; SQnodeLoad qload = {0};
qndGetLoad(pMgmt->pQnode, &qload); (void)qndGetLoad(pMgmt->pQnode, &qload);
qload.dnodeId = pMgmt->pData->dnodeId; qload.dnodeId = pMgmt->pData->dnodeId;
} }
void qmGetQnodeLoads(SQnodeMgmt *pMgmt, SQnodeLoad *pInfo) { void qmGetQnodeLoads(SQnodeMgmt *pMgmt, SQnodeLoad *pInfo) {
qndGetLoad(pMgmt->pQnode, pInfo); (void)qndGetLoad(pMgmt->pQnode, pInfo);
pInfo->dnodeId = pMgmt->pData->dnodeId; pInfo->dnodeId = pMgmt->pData->dnodeId;
} }

15
source/dnode/mgmt/mgmt_qnode/src/qmWorker.c
View File

@ -23,7 +23,7 @@ static inline void qmSendRsp(SRpcMsg *pMsg, int32_t code) {
.contLen = pMsg->info.rspLen, .contLen = pMsg->info.rspLen,
.info = pMsg->info, .info = pMsg->info,
}; };
tmsgSendRsp(&rsp); (void)tmsgSendRsp(&rsp);
} }
static void qmProcessQueue(SQueueInfo *pInfo, SRpcMsg *pMsg) { static void qmProcessQueue(SQueueInfo *pInfo, SRpcMsg *pMsg) {
@ -43,8 +43,7 @@ static void qmProcessQueue(SQueueInfo *pInfo, SRpcMsg *pMsg) {
static int32_t qmPutNodeMsgToWorker(SSingleWorker *pWorker, SRpcMsg *pMsg) { static int32_t qmPutNodeMsgToWorker(SSingleWorker *pWorker, SRpcMsg *pMsg) {
dTrace("msg:%p, put into worker %s, type:%s", pMsg, pWorker->name, TMSG_INFO(pMsg->msgType)); dTrace("msg:%p, put into worker %s, type:%s", pMsg, pWorker->name, TMSG_INFO(pMsg->msgType));
taosWriteQitem(pWorker->queue, pMsg); return taosWriteQitem(pWorker->queue, pMsg);
return 0;
} }
int32_t qmPutNodeMsgToQueryQueue(SQnodeMgmt *pMgmt, SRpcMsg *pMsg) { int32_t qmPutNodeMsgToQueryQueue(SQnodeMgmt *pMgmt, SRpcMsg *pMsg) {
@ -69,18 +68,18 @@ int32_t qmPutRpcMsgToQueue(SQnodeMgmt *pMgmt, EQueueType qtype, SRpcMsg *pRpc) {
switch (qtype) { switch (qtype) {
case QUERY_QUEUE: case QUERY_QUEUE:
dTrace("msg:%p, is created and will put into qnode-query queue, len:%d", pMsg, pRpc->contLen); dTrace("msg:%p, is created and will put into qnode-query queue, len:%d", pMsg, pRpc->contLen);
taosWriteQitem(pMgmt->queryWorker.queue, pMsg); code = taosWriteQitem(pMgmt->queryWorker.queue, pMsg);
return 0; return code;
case READ_QUEUE: case READ_QUEUE:
case FETCH_QUEUE: case FETCH_QUEUE:
dTrace("msg:%p, is created and will put into qnode-fetch queue, len:%d", pMsg, pRpc->contLen); dTrace("msg:%p, is created and will put into qnode-fetch queue, len:%d", pMsg, pRpc->contLen);
taosWriteQitem(pMgmt->fetchWorker.queue, pMsg); code = taosWriteQitem(pMgmt->fetchWorker.queue, pMsg);
return 0; return code;
default: default:
terrno = TSDB_CODE_INVALID_PARA; terrno = TSDB_CODE_INVALID_PARA;
rpcFreeCont(pMsg->pCont); rpcFreeCont(pMsg->pCont);
taosFreeQitem(pMsg); taosFreeQitem(pMsg);
return -1; return terrno;
} }
} }

4
source/dnode/mgmt/mgmt_snode/src/smWorker.c
View File

@ -23,7 +23,7 @@ static inline void smSendRsp(SRpcMsg *pMsg, int32_t code) {
.contLen = pMsg->info.rspLen, .contLen = pMsg->info.rspLen,
.info = pMsg->info, .info = pMsg->info,
}; };
tmsgSendRsp(&rsp); (void)tmsgSendRsp(&rsp);
} }
static void smProcessWriteQueue(SQueueInfo *pInfo, STaosQall *qall, int32_t numOfMsgs) { static void smProcessWriteQueue(SQueueInfo *pInfo, STaosQall *qall, int32_t numOfMsgs) {
@ -31,7 +31,7 @@ static void smProcessWriteQueue(SQueueInfo *pInfo, STaosQall *qall, int32_t numO
for (int32_t i = 0; i < numOfMsgs; i++) { for (int32_t i = 0; i < numOfMsgs; i++) {
SRpcMsg *pMsg = NULL; SRpcMsg *pMsg = NULL;
taosGetQitem(qall, (void **)&pMsg); (void)taosGetQitem(qall, (void **)&pMsg);
const STraceId *trace = &pMsg->info.traceId; const STraceId *trace = &pMsg->info.traceId;
dTrace("msg:%p, get from snode-write queue", pMsg); dTrace("msg:%p, get from snode-write queue", pMsg);

6
source/dnode/mgmt/mgmt_vnode/src/vmFile.c
View File

@ -20,13 +20,13 @@
#define MAX_CONTENT_LEN 2 * 1024 * 1024 #define MAX_CONTENT_LEN 2 * 1024 * 1024
int32_t vmGetVnodeListFromHash(SVnodeMgmt *pMgmt, int32_t *numOfVnodes, SVnodeObj ***ppVnodes) { int32_t vmGetVnodeListFromHash(SVnodeMgmt *pMgmt, int32_t *numOfVnodes, SVnodeObj ***ppVnodes) {
taosThreadRwlockRdlock(&pMgmt->lock); (void)taosThreadRwlockRdlock(&pMgmt->lock);
int32_t num = 0; int32_t num = 0;
int32_t size = taosHashGetSize(pMgmt->hash); int32_t size = taosHashGetSize(pMgmt->hash);
SVnodeObj **pVnodes = taosMemoryCalloc(size, sizeof(SVnodeObj *)); SVnodeObj **pVnodes = taosMemoryCalloc(size, sizeof(SVnodeObj *));
if (pVnodes == NULL) { if (pVnodes == NULL) {
taosThreadRwlockUnlock(&pMgmt->lock); (void)taosThreadRwlockUnlock(&pMgmt->lock);
return TSDB_CODE_OUT_OF_MEMORY; return TSDB_CODE_OUT_OF_MEMORY;
} }
@ -44,7 +44,7 @@ int32_t vmGetVnodeListFromHash(SVnodeMgmt *pMgmt, int32_t *numOfVnodes, SVnodeOb
} }
} }
taosThreadRwlockUnlock(&pMgmt->lock); (void)taosThreadRwlockUnlock(&pMgmt->lock);
*numOfVnodes = num; *numOfVnodes = num;
*ppVnodes = pVnodes; *ppVnodes = pVnodes;

41
source/dnode/mgmt/mgmt_vnode/src/vmHandle.c
View File

@ -22,7 +22,7 @@ void vmGetVnodeLoads(SVnodeMgmt *pMgmt, SMonVloadInfo *pInfo, bool isReset) {
tfsUpdateSize(pMgmt->pTfs); tfsUpdateSize(pMgmt->pTfs);
taosThreadRwlockRdlock(&pMgmt->lock); (void)taosThreadRwlockRdlock(&pMgmt->lock);
void *pIter = taosHashIterate(pMgmt->hash, NULL); void *pIter = taosHashIterate(pMgmt->hash, NULL);
while (pIter) { while (pIter) {
@ -32,21 +32,21 @@ void vmGetVnodeLoads(SVnodeMgmt *pMgmt, SMonVloadInfo *pInfo, bool isReset) {
SVnodeObj *pVnode = *ppVnode; SVnodeObj *pVnode = *ppVnode;
SVnodeLoad vload = {.vgId = pVnode->vgId}; SVnodeLoad vload = {.vgId = pVnode->vgId};
if (!pVnode->failed) { if (!pVnode->failed) {
vnodeGetLoad(pVnode->pImpl, &vload); (void)vnodeGetLoad(pVnode->pImpl, &vload);
if (isReset) vnodeResetLoad(pVnode->pImpl, &vload); if (isReset) vnodeResetLoad(pVnode->pImpl, &vload);
} }
taosArrayPush(pInfo->pVloads, &vload); (void)taosArrayPush(pInfo->pVloads, &vload);
pIter = taosHashIterate(pMgmt->hash, pIter); pIter = taosHashIterate(pMgmt->hash, pIter);
} }
taosThreadRwlockUnlock(&pMgmt->lock); (void)taosThreadRwlockUnlock(&pMgmt->lock);
} }
void vmGetVnodeLoadsLite(SVnodeMgmt *pMgmt, SMonVloadInfo *pInfo) { void vmGetVnodeLoadsLite(SVnodeMgmt *pMgmt, SMonVloadInfo *pInfo) {
pInfo->pVloads = taosArrayInit(pMgmt->state.totalVnodes, sizeof(SVnodeLoadLite)); pInfo->pVloads = taosArrayInit(pMgmt->state.totalVnodes, sizeof(SVnodeLoadLite));
if (!pInfo->pVloads) return; if (!pInfo->pVloads) return;
taosThreadRwlockRdlock(&pMgmt->lock); (void)taosThreadRwlockRdlock(&pMgmt->lock);
void *pIter = taosHashIterate(pMgmt->hash, NULL); void *pIter = taosHashIterate(pMgmt->hash, NULL);
while (pIter) { while (pIter) {
@ -57,13 +57,13 @@ void vmGetVnodeLoadsLite(SVnodeMgmt *pMgmt, SMonVloadInfo *pInfo) {
if (!pVnode->failed) { if (!pVnode->failed) {
SVnodeLoadLite vload = {0}; SVnodeLoadLite vload = {0};
if (vnodeGetLoadLite(pVnode->pImpl, &vload) == 0) { if (vnodeGetLoadLite(pVnode->pImpl, &vload) == 0) {
taosArrayPush(pInfo->pVloads, &vload); (void)taosArrayPush(pInfo->pVloads, &vload);
} }
} }
pIter = taosHashIterate(pMgmt->hash, pIter); pIter = taosHashIterate(pMgmt->hash, pIter);
} }
taosThreadRwlockUnlock(&pMgmt->lock); (void)taosThreadRwlockUnlock(&pMgmt->lock);
} }
void vmGetMonitorInfo(SVnodeMgmt *pMgmt, SMonVmInfo *pInfo) { void vmGetMonitorInfo(SVnodeMgmt *pMgmt, SMonVmInfo *pInfo) {
@ -109,7 +109,7 @@ void vmGetMonitorInfo(SVnodeMgmt *pMgmt, SMonVmInfo *pInfo) {
pMgmt->state.numOfBatchInsertReqs = numOfBatchInsertReqs; pMgmt->state.numOfBatchInsertReqs = numOfBatchInsertReqs;
pMgmt->state.numOfBatchInsertSuccessReqs = numOfBatchInsertSuccessReqs; pMgmt->state.numOfBatchInsertSuccessReqs = numOfBatchInsertSuccessReqs;
tfsGetMonitorInfo(pMgmt->pTfs, &pInfo->tfs); (void)tfsGetMonitorInfo(pMgmt->pTfs, &pInfo->tfs);
taosArrayDestroy(pVloads); taosArrayDestroy(pVloads);
} }
@ -200,7 +200,7 @@ static void vmGenerateVnodeCfg(SCreateVnodeReq *pCreate, SVnodeCfg *pCfg) {
pNode->nodePort = pCreate->replicas[pCfg->syncCfg.replicaNum].port; pNode->nodePort = pCreate->replicas[pCfg->syncCfg.replicaNum].port;
pNode->nodeRole = TAOS_SYNC_ROLE_VOTER; pNode->nodeRole = TAOS_SYNC_ROLE_VOTER;
tstrncpy(pNode->nodeFqdn, pCreate->replicas[pCfg->syncCfg.replicaNum].fqdn, TSDB_FQDN_LEN); tstrncpy(pNode->nodeFqdn, pCreate->replicas[pCfg->syncCfg.replicaNum].fqdn, TSDB_FQDN_LEN);
tmsgUpdateDnodeInfo(&pNode->nodeId, &pNode->clusterId, pNode->nodeFqdn, &pNode->nodePort); (void)tmsgUpdateDnodeInfo(&pNode->nodeId, &pNode->clusterId, pNode->nodeFqdn, &pNode->nodePort);
pCfg->syncCfg.replicaNum++; pCfg->syncCfg.replicaNum++;
} }
if (pCreate->selfIndex != -1) { if (pCreate->selfIndex != -1) {
@ -212,7 +212,7 @@ static void vmGenerateVnodeCfg(SCreateVnodeReq *pCreate, SVnodeCfg *pCfg) {
pNode->nodePort = pCreate->learnerReplicas[pCfg->syncCfg.totalReplicaNum].port; pNode->nodePort = pCreate->learnerReplicas[pCfg->syncCfg.totalReplicaNum].port;
pNode->nodeRole = TAOS_SYNC_ROLE_LEARNER; pNode->nodeRole = TAOS_SYNC_ROLE_LEARNER;
tstrncpy(pNode->nodeFqdn, pCreate->learnerReplicas[pCfg->syncCfg.totalReplicaNum].fqdn, TSDB_FQDN_LEN); tstrncpy(pNode->nodeFqdn, pCreate->learnerReplicas[pCfg->syncCfg.totalReplicaNum].fqdn, TSDB_FQDN_LEN);
tmsgUpdateDnodeInfo(&pNode->nodeId, &pNode->clusterId, pNode->nodeFqdn, &pNode->nodePort); (void)tmsgUpdateDnodeInfo(&pNode->nodeId, &pNode->clusterId, pNode->nodeFqdn, &pNode->nodePort);
pCfg->syncCfg.totalReplicaNum++; pCfg->syncCfg.totalReplicaNum++;
} }
pCfg->syncCfg.totalReplicaNum += pCfg->syncCfg.replicaNum; pCfg->syncCfg.totalReplicaNum += pCfg->syncCfg.replicaNum;
@ -323,7 +323,7 @@ int32_t vmProcessCreateVnodeReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
SVnodeObj *pVnode = vmAcquireVnodeImpl(pMgmt, req.vgId, false); SVnodeObj *pVnode = vmAcquireVnodeImpl(pMgmt, req.vgId, false);
if (pVnode != NULL && (req.replica == 1 || !pVnode->failed)) { if (pVnode != NULL && (req.replica == 1 || !pVnode->failed)) {
dError("vgId:%d, already exist", req.vgId); dError("vgId:%d, already exist", req.vgId);
tFreeSCreateVnodeReq(&req); (void)tFreeSCreateVnodeReq(&req);
vmReleaseVnode(pMgmt, pVnode); vmReleaseVnode(pMgmt, pVnode);
code = TSDB_CODE_VND_ALREADY_EXIST; code = TSDB_CODE_VND_ALREADY_EXIST;
return 0; return 0;
@ -392,7 +392,7 @@ _OVER:
TMSG_INFO(pMsg->msgType)); TMSG_INFO(pMsg->msgType));
} }
tFreeSCreateVnodeReq(&req); (void)tFreeSCreateVnodeReq(&req);
terrno = code; terrno = code;
return code; return code;
} }
@ -779,10 +779,11 @@ int32_t vmProcessAlterVnodeReplicaReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
} }
int32_t vmProcessDropVnodeReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) { int32_t vmProcessDropVnodeReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
int32_t code = 0;
SDropVnodeReq dropReq = {0}; SDropVnodeReq dropReq = {0};
if (tDeserializeSDropVnodeReq(pMsg->pCont, pMsg->contLen, &dropReq) != 0) { if (tDeserializeSDropVnodeReq(pMsg->pCont, pMsg->contLen, &dropReq) != 0) {
terrno = TSDB_CODE_INVALID_MSG; terrno = TSDB_CODE_INVALID_MSG;
return -1; return terrno;
} }
int32_t vgId = dropReq.vgId; int32_t vgId = dropReq.vgId;
@ -791,25 +792,25 @@ int32_t vmProcessDropVnodeReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
if (dropReq.dnodeId != pMgmt->pData->dnodeId) { if (dropReq.dnodeId != pMgmt->pData->dnodeId) {
terrno = TSDB_CODE_INVALID_MSG; terrno = TSDB_CODE_INVALID_MSG;
dError("vgId:%d, dnodeId:%d not matched with local dnode", dropReq.vgId, dropReq.dnodeId); dError("vgId:%d, dnodeId:%d not matched with local dnode", dropReq.vgId, dropReq.dnodeId);
return -1; return terrno;
} }
SVnodeObj *pVnode = vmAcquireVnodeImpl(pMgmt, vgId, false); SVnodeObj *pVnode = vmAcquireVnodeImpl(pMgmt, vgId, false);
if (pVnode == NULL) { if (pVnode == NULL) {
dInfo("vgId:%d, failed to drop since %s", vgId, terrstr()); dInfo("vgId:%d, failed to drop since %s", vgId, terrstr());
terrno = TSDB_CODE_VND_NOT_EXIST; terrno = TSDB_CODE_VND_NOT_EXIST;
return -1; return terrno;
} }
pVnode->dropped = 1; pVnode->dropped = 1;
if (vmWriteVnodeListToFile(pMgmt) != 0) { if ((code = vmWriteVnodeListToFile(pMgmt)) != 0) {
pVnode->dropped = 0; pVnode->dropped = 0;
vmReleaseVnode(pMgmt, pVnode); vmReleaseVnode(pMgmt, pVnode);
return -1; return code;
} }
vmCloseVnode(pMgmt, pVnode, false); vmCloseVnode(pMgmt, pVnode, false);
vmWriteVnodeListToFile(pMgmt); (void)vmWriteVnodeListToFile(pMgmt);
dInfo("vgId:%d, is dropped", vgId); dInfo("vgId:%d, is dropped", vgId);
return 0; return 0;
@ -864,7 +865,7 @@ int32_t vmProcessArbHeartBeatReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
continue; continue;
} }
taosArrayPush(arbHbRsp.hbMembers, &rspMember); (void)taosArrayPush(arbHbRsp.hbMembers, &rspMember);
vmReleaseVnode(pMgmt, pVnode); vmReleaseVnode(pMgmt, pVnode);
} }
@ -895,7 +896,7 @@ int32_t vmProcessArbHeartBeatReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
_OVER: _OVER:
tFreeSVArbHeartBeatReq(&arbHbReq); tFreeSVArbHeartBeatReq(&arbHbReq);
tFreeSVArbHeartBeatRsp(&arbHbRsp); tFreeSVArbHeartBeatRsp(&arbHbRsp);
return terrno == TSDB_CODE_SUCCESS ? 0 : -1; return terrno;
} }
SArray *vmGetMsgHandles() { SArray *vmGetMsgHandles() {

76
source/dnode/mgmt/mgmt_vnode/src/vmInt.c
View File

@ -23,12 +23,12 @@ int32_t vmGetPrimaryDisk(SVnodeMgmt *pMgmt, int32_t vgId) {
int32_t diskId = -1; int32_t diskId = -1;
SVnodeObj *pVnode = NULL; SVnodeObj *pVnode = NULL;
taosThreadRwlockRdlock(&pMgmt->lock); (void)taosThreadRwlockRdlock(&pMgmt->lock);
taosHashGetDup(pMgmt->hash, &vgId, sizeof(int32_t), (void *)&pVnode); (void)taosHashGetDup(pMgmt->hash, &vgId, sizeof(int32_t), (void *)&pVnode);
if (pVnode != NULL) { if (pVnode != NULL) {
diskId = pVnode->diskPrimary; diskId = pVnode->diskPrimary;
} }
taosThreadRwlockUnlock(&pMgmt->lock); (void)taosThreadRwlockUnlock(&pMgmt->lock);
return diskId; return diskId;
} }
@ -96,8 +96,8 @@ int32_t vmAllocPrimaryDisk(SVnodeMgmt *pMgmt, int32_t vgId) {
SVnodeObj *vmAcquireVnodeImpl(SVnodeMgmt *pMgmt, int32_t vgId, bool strict) { SVnodeObj *vmAcquireVnodeImpl(SVnodeMgmt *pMgmt, int32_t vgId, bool strict) {
SVnodeObj *pVnode = NULL; SVnodeObj *pVnode = NULL;
taosThreadRwlockRdlock(&pMgmt->lock); (void)taosThreadRwlockRdlock(&pMgmt->lock);
taosHashGetDup(pMgmt->hash, &vgId, sizeof(int32_t), (void *)&pVnode); (void)taosHashGetDup(pMgmt->hash, &vgId, sizeof(int32_t), (void *)&pVnode);
if (pVnode == NULL || strict && (pVnode->dropped || pVnode->failed)) { if (pVnode == NULL || strict && (pVnode->dropped || pVnode->failed)) {
terrno = TSDB_CODE_VND_INVALID_VGROUP_ID; terrno = TSDB_CODE_VND_INVALID_VGROUP_ID;
pVnode = NULL; pVnode = NULL;
@ -105,7 +105,7 @@ SVnodeObj *vmAcquireVnodeImpl(SVnodeMgmt *pMgmt, int32_t vgId, bool strict) {
int32_t refCount = atomic_add_fetch_32(&pVnode->refCount, 1); int32_t refCount = atomic_add_fetch_32(&pVnode->refCount, 1);
// dTrace("vgId:%d, acquire vnode, ref:%d", pVnode->vgId, refCount); // dTrace("vgId:%d, acquire vnode, ref:%d", pVnode->vgId, refCount);
} }
taosThreadRwlockUnlock(&pMgmt->lock); (void)taosThreadRwlockUnlock(&pMgmt->lock);
return pVnode; return pVnode;
} }
@ -115,10 +115,10 @@ SVnodeObj *vmAcquireVnode(SVnodeMgmt *pMgmt, int32_t vgId) { return vmAcquireVno
void vmReleaseVnode(SVnodeMgmt *pMgmt, SVnodeObj *pVnode) { void vmReleaseVnode(SVnodeMgmt *pMgmt, SVnodeObj *pVnode) {
if (pVnode == NULL) return; if (pVnode == NULL) return;
taosThreadRwlockRdlock(&pMgmt->lock); (void)taosThreadRwlockRdlock(&pMgmt->lock);
int32_t refCount = atomic_sub_fetch_32(&pVnode->refCount, 1); int32_t refCount = atomic_sub_fetch_32(&pVnode->refCount, 1);
// dTrace("vgId:%d, release vnode, ref:%d", pVnode->vgId, refCount); // dTrace("vgId:%d, release vnode, ref:%d", pVnode->vgId, refCount);
taosThreadRwlockUnlock(&pMgmt->lock); (void)taosThreadRwlockUnlock(&pMgmt->lock);
} }
static void vmFreeVnodeObj(SVnodeObj **ppVnode) { static void vmFreeVnodeObj(SVnodeObj **ppVnode) {
@ -163,15 +163,15 @@ int32_t vmOpenVnode(SVnodeMgmt *pMgmt, SWrapperCfg *pCfg, SVnode *pImpl) {
pVnode->failed = 1; pVnode->failed = 1;
} }
taosThreadRwlockWrlock(&pMgmt->lock); (void)taosThreadRwlockWrlock(&pMgmt->lock);
SVnodeObj *pOld = NULL; SVnodeObj *pOld = NULL;
taosHashGetDup(pMgmt->hash, &pVnode->vgId, sizeof(int32_t), (void *)&pOld); (void)taosHashGetDup(pMgmt->hash, &pVnode->vgId, sizeof(int32_t), (void *)&pOld);
if (pOld) { if (pOld) {
ASSERT(pOld->failed); ASSERT(pOld->failed);
vmFreeVnodeObj(&pOld); vmFreeVnodeObj(&pOld);
} }
int32_t code = taosHashPut(pMgmt->hash, &pVnode->vgId, sizeof(int32_t), &pVnode, sizeof(SVnodeObj *)); int32_t code = taosHashPut(pMgmt->hash, &pVnode->vgId, sizeof(int32_t), &pVnode, sizeof(SVnodeObj *));
taosThreadRwlockUnlock(&pMgmt->lock); (void)taosThreadRwlockUnlock(&pMgmt->lock);
return code; return code;
} }
@ -184,9 +184,9 @@ void vmCloseVnode(SVnodeMgmt *pMgmt, SVnodeObj *pVnode, bool commitAndRemoveWal)
vnodeProposeCommitOnNeed(pVnode->pImpl, atExit); vnodeProposeCommitOnNeed(pVnode->pImpl, atExit);
} }
taosThreadRwlockWrlock(&pMgmt->lock); (void)taosThreadRwlockWrlock(&pMgmt->lock);
taosHashRemove(pMgmt->hash, &pVnode->vgId, sizeof(int32_t)); (void)taosHashRemove(pMgmt->hash, &pVnode->vgId, sizeof(int32_t));
taosThreadRwlockUnlock(&pMgmt->lock); (void)taosThreadRwlockUnlock(&pMgmt->lock);
vmReleaseVnode(pMgmt, pVnode); vmReleaseVnode(pMgmt, pVnode);
if (pVnode->failed) { if (pVnode->failed) {
@ -235,8 +235,8 @@ void vmCloseVnode(SVnodeMgmt *pMgmt, SVnodeObj *pVnode, bool commitAndRemoveWal)
if (commitAndRemoveWal) { if (commitAndRemoveWal) {
dInfo("vgId:%d, commit data for vnode split", pVnode->vgId); dInfo("vgId:%d, commit data for vnode split", pVnode->vgId);
vnodeSyncCommit(pVnode->pImpl); (void)vnodeSyncCommit(pVnode->pImpl);
vnodeBegin(pVnode->pImpl); (void)vnodeBegin(pVnode->pImpl);
dInfo("vgId:%d, commit data finished", pVnode->vgId); dInfo("vgId:%d, commit data finished", pVnode->vgId);
} }
@ -250,8 +250,8 @@ _closed:
if (commitAndRemoveWal) { if (commitAndRemoveWal) {
snprintf(path, TSDB_FILENAME_LEN, "vnode%svnode%d%swal", TD_DIRSEP, pVnode->vgId, TD_DIRSEP); snprintf(path, TSDB_FILENAME_LEN, "vnode%svnode%d%swal", TD_DIRSEP, pVnode->vgId, TD_DIRSEP);
dInfo("vgId:%d, remove all wals, path:%s", pVnode->vgId, path); dInfo("vgId:%d, remove all wals, path:%s", pVnode->vgId, path);
tfsRmdir(pMgmt->pTfs, path); (void)tfsRmdir(pMgmt->pTfs, path);
tfsMkdir(pMgmt->pTfs, path); (void)tfsMkdir(pMgmt->pTfs, path);
} }
if (pVnode->dropped) { if (pVnode->dropped) {
@ -332,7 +332,7 @@ static void *vmOpenVnodeInThread(void *param) {
dInfo("vgId:%d, is opened by thread:%d", pCfg->vgId, pThread->threadIndex); dInfo("vgId:%d, is opened by thread:%d", pCfg->vgId, pThread->threadIndex);
pThread->opened++; pThread->opened++;
atomic_add_fetch_32(&pMgmt->state.openVnodes, 1); (void)atomic_add_fetch_32(&pMgmt->state.openVnodes, 1);
} }
dInfo("thread:%d, numOfVnodes:%d, opened:%d failed:%d", pThread->threadIndex, pThread->vnodeNum, pThread->opened, dInfo("thread:%d, numOfVnodes:%d, opened:%d failed:%d", pThread->threadIndex, pThread->vnodeNum, pThread->opened,
@ -381,13 +381,13 @@ static int32_t vmOpenVnodes(SVnodeMgmt *pMgmt) {
if (pThread->vnodeNum == 0) continue; if (pThread->vnodeNum == 0) continue;
TdThreadAttr thAttr; TdThreadAttr thAttr;
taosThreadAttrInit(&thAttr); (void)taosThreadAttrInit(&thAttr);
taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE); (void)taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE);
if (taosThreadCreate(&pThread->thread, &thAttr, vmOpenVnodeInThread, pThread) != 0) { if (taosThreadCreate(&pThread->thread, &thAttr, vmOpenVnodeInThread, pThread) != 0) {
dError("thread:%d, failed to create thread to open vnode, reason:%s", pThread->threadIndex, strerror(errno)); dError("thread:%d, failed to create thread to open vnode, reason:%s", pThread->threadIndex, strerror(errno));
} }
taosThreadAttrDestroy(&thAttr); (void)taosThreadAttrDestroy(&thAttr);
} }
bool updateVnodesList = false; bool updateVnodesList = false;
@ -395,7 +395,7 @@ static int32_t vmOpenVnodes(SVnodeMgmt *pMgmt) {
for (int32_t t = 0; t < threadNum; ++t) { for (int32_t t = 0; t < threadNum; ++t) {
SVnodeThread *pThread = &threads[t]; SVnodeThread *pThread = &threads[t];
if (pThread->vnodeNum > 0 && taosCheckPthreadValid(pThread->thread)) { if (pThread->vnodeNum > 0 && taosCheckPthreadValid(pThread->thread)) {
taosThreadJoin(pThread->thread, NULL); (void)taosThreadJoin(pThread->thread, NULL);
taosThreadClear(&pThread->thread); taosThreadClear(&pThread->thread);
} }
taosMemoryFree(pThread->pCfgs); taosMemoryFree(pThread->pCfgs);
@ -484,19 +484,19 @@ static void vmCloseVnodes(SVnodeMgmt *pMgmt) {
if (pThread->vnodeNum == 0) continue; if (pThread->vnodeNum == 0) continue;
TdThreadAttr thAttr; TdThreadAttr thAttr;
taosThreadAttrInit(&thAttr); (void)taosThreadAttrInit(&thAttr);
taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE); (void)taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE);
if (taosThreadCreate(&pThread->thread, &thAttr, vmCloseVnodeInThread, pThread) != 0) { if (taosThreadCreate(&pThread->thread, &thAttr, vmCloseVnodeInThread, pThread) != 0) {
dError("thread:%d, failed to create thread to close vnode since %s", pThread->threadIndex, strerror(errno)); dError("thread:%d, failed to create thread to close vnode since %s", pThread->threadIndex, strerror(errno));
} }
taosThreadAttrDestroy(&thAttr); (void)taosThreadAttrDestroy(&thAttr);
} }
for (int32_t t = 0; t < threadNum; ++t) { for (int32_t t = 0; t < threadNum; ++t) {
SVnodeThread *pThread = &threads[t]; SVnodeThread *pThread = &threads[t];
if (pThread->vnodeNum > 0 && taosCheckPthreadValid(pThread->thread)) { if (pThread->vnodeNum > 0 && taosCheckPthreadValid(pThread->thread)) {
taosThreadJoin(pThread->thread, NULL); (void)taosThreadJoin(pThread->thread, NULL);
taosThreadClear(&pThread->thread); taosThreadClear(&pThread->thread);
} }
taosMemoryFree(pThread->ppVnodes); taosMemoryFree(pThread->ppVnodes);
@ -519,8 +519,8 @@ static void vmCleanup(SVnodeMgmt *pMgmt) {
vmCloseVnodes(pMgmt); vmCloseVnodes(pMgmt);
vmStopWorker(pMgmt); vmStopWorker(pMgmt);
vnodeCleanup(); vnodeCleanup();
taosThreadRwlockDestroy(&pMgmt->lock); (void)taosThreadRwlockDestroy(&pMgmt->lock);
taosThreadMutexDestroy(&pMgmt->createLock); (void)taosThreadMutexDestroy(&pMgmt->createLock);
taosMemoryFree(pMgmt); taosMemoryFree(pMgmt);
} }
@ -569,22 +569,22 @@ static void *vmThreadFp(void *param) {
static int32_t vmInitTimer(SVnodeMgmt *pMgmt) { static int32_t vmInitTimer(SVnodeMgmt *pMgmt) {
int32_t code = 0; int32_t code = 0;
TdThreadAttr thAttr; TdThreadAttr thAttr;
taosThreadAttrInit(&thAttr); (void)taosThreadAttrInit(&thAttr);
taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE); (void)taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE);
if (taosThreadCreate(&pMgmt->thread, &thAttr, vmThreadFp, pMgmt) != 0) { if (taosThreadCreate(&pMgmt->thread, &thAttr, vmThreadFp, pMgmt) != 0) {
code = TAOS_SYSTEM_ERROR(errno); code = TAOS_SYSTEM_ERROR(errno);
dError("failed to create vnode timer thread since %s", tstrerror(code)); dError("failed to create vnode timer thread since %s", tstrerror(code));
return code; return code;
} }
taosThreadAttrDestroy(&thAttr); (void)taosThreadAttrDestroy(&thAttr);
return 0; return 0;
} }
static void vmCleanupTimer(SVnodeMgmt *pMgmt) { static void vmCleanupTimer(SVnodeMgmt *pMgmt) {
pMgmt->stop = true; pMgmt->stop = true;
if (taosCheckPthreadValid(pMgmt->thread)) { if (taosCheckPthreadValid(pMgmt->thread)) {
taosThreadJoin(pMgmt->thread, NULL); (void)taosThreadJoin(pMgmt->thread, NULL);
taosThreadClear(&pMgmt->thread); taosThreadClear(&pMgmt->thread);
} }
} }
@ -707,7 +707,7 @@ static void *vmRestoreVnodeInThread(void *param) {
} else { } else {
dInfo("vgId:%d, is restored by thread:%d", pVnode->vgId, pThread->threadIndex); dInfo("vgId:%d, is restored by thread:%d", pVnode->vgId, pThread->threadIndex);
pThread->opened++; pThread->opened++;
atomic_add_fetch_32(&pMgmt->state.openVnodes, 1); (void)atomic_add_fetch_32(&pMgmt->state.openVnodes, 1);
} }
} }
@ -761,20 +761,20 @@ static int32_t vmStartVnodes(SVnodeMgmt *pMgmt) {
if (pThread->vnodeNum == 0) continue; if (pThread->vnodeNum == 0) continue;
TdThreadAttr thAttr; TdThreadAttr thAttr;
taosThreadAttrInit(&thAttr); (void)taosThreadAttrInit(&thAttr);
taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE); (void)taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE);
if (taosThreadCreate(&pThread->thread, &thAttr, vmRestoreVnodeInThread, pThread) != 0) { if (taosThreadCreate(&pThread->thread, &thAttr, vmRestoreVnodeInThread, pThread) != 0) {
dError("thread:%d, failed to create thread to restore vnode since %s", pThread->threadIndex, strerror(errno)); dError("thread:%d, failed to create thread to restore vnode since %s", pThread->threadIndex, strerror(errno));
ASSERT(errno == 0); ASSERT(errno == 0);
} }
taosThreadAttrDestroy(&thAttr); (void)taosThreadAttrDestroy(&thAttr);
} }
for (int32_t t = 0; t < threadNum; ++t) { for (int32_t t = 0; t < threadNum; ++t) {
SVnodeThread *pThread = &threads[t]; SVnodeThread *pThread = &threads[t];
if (pThread->vnodeNum > 0 && taosCheckPthreadValid(pThread->thread)) { if (pThread->vnodeNum > 0 && taosCheckPthreadValid(pThread->thread)) {
taosThreadJoin(pThread->thread, NULL); (void)taosThreadJoin(pThread->thread, NULL);
taosThreadClear(&pThread->thread); taosThreadClear(&pThread->thread);
} }
taosMemoryFree(pThread->ppVnodes); taosMemoryFree(pThread->ppVnodes);

4
source/dnode/mgmt/mgmt_vnode/src/vmWorker.c
View File

@ -187,7 +187,7 @@ static void vmProcessSyncQueue(SQueueInfo *pInfo, STaosQall *qall, int32_t numOf
static void vmSendResponse(SRpcMsg *pMsg) { static void vmSendResponse(SRpcMsg *pMsg) {
if (pMsg->info.handle) { if (pMsg->info.handle) {
SRpcMsg rsp = {.info = pMsg->info, .code = terrno}; SRpcMsg rsp = {.info = pMsg->info, .code = terrno};
rpcSendResponse(&rsp); (void)rpcSendResponse(&rsp);
} }
} }
@ -236,7 +236,7 @@ static int32_t vmPutMsgToQueue(SVnodeMgmt *pMgmt, SRpcMsg *pMsg, EQueueType qtyp
dError("vgId:%d, msg:%p preprocess query msg failed since %s", pVnode->vgId, pMsg, tstrerror(code)); dError("vgId:%d, msg:%p preprocess query msg failed since %s", pVnode->vgId, pMsg, tstrerror(code));
} else { } else {
dGTrace("vgId:%d, msg:%p put into vnode-query queue", pVnode->vgId, pMsg); dGTrace("vgId:%d, msg:%p put into vnode-query queue", pVnode->vgId, pMsg);
taosWriteQitem(pVnode->pQueryQ, pMsg); code = taosWriteQitem(pVnode->pQueryQ, pMsg);
} }
break; break;
case STREAM_QUEUE: case STREAM_QUEUE:

8
source/dnode/mgmt/node_mgmt/src/dmEnv.c
View File

@ -47,8 +47,8 @@ static int32_t dmCheckRepeatInit(SDnode *pDnode) {
} }
static int32_t dmInitSystem() { static int32_t dmInitSystem() {
taosIgnSIGPIPE(); (void)taosIgnSIGPIPE();
taosBlockSIGPIPE(); (void)taosBlockSIGPIPE();
taosResolveCRC(); taosResolveCRC();
return 0; return 0;
} }
@ -200,10 +200,10 @@ void dmCleanup() {
auditCleanup(); auditCleanup();
syncCleanUp(); syncCleanUp();
walCleanUp(); walCleanUp();
udfcClose(); (void)udfcClose();
udfStopUdfd(); udfStopUdfd();
taosStopCacheRefreshWorker(); taosStopCacheRefreshWorker();
dmDiskClose(); (void)dmDiskClose();
DestroyRegexCache(); DestroyRegexCache();
#if defined(USE_S3) #if defined(USE_S3)

39
source/dnode/mgmt/node_mgmt/src/dmMgmt.c
View File

@ -47,7 +47,8 @@ int32_t dmInitDnode(SDnode *pDnode) {
} }
// compress module init // compress module init
tsCompressInit(tsLossyColumns, tsFPrecision, tsDPrecision, tsMaxRange, tsCurRange, (int)tsIfAdtFse, tsCompressor); (void)tsCompressInit(tsLossyColumns, tsFPrecision, tsDPrecision, tsMaxRange, tsCurRange, (int)tsIfAdtFse,
tsCompressor);
pDnode->wrappers[DNODE].func = dmGetMgmtFunc(); pDnode->wrappers[DNODE].func = dmGetMgmtFunc();
pDnode->wrappers[MNODE].func = mmGetMgmtFunc(); pDnode->wrappers[MNODE].func = mmGetMgmtFunc();
@ -60,7 +61,7 @@ int32_t dmInitDnode(SDnode *pDnode) {
pWrapper->pDnode = pDnode; pWrapper->pDnode = pDnode;
pWrapper->name = dmNodeName(ntype); pWrapper->name = dmNodeName(ntype);
pWrapper->ntype = ntype; pWrapper->ntype = ntype;
taosThreadRwlockInit(&pWrapper->lock, NULL); (void)taosThreadRwlockInit(&pWrapper->lock, NULL);
snprintf(path, sizeof(path), "%s%s%s", tsDataDir, TD_DIRSEP, pWrapper->name); snprintf(path, sizeof(path), "%s%s%s", tsDataDir, TD_DIRSEP, pWrapper->name);
pWrapper->path = taosStrdup(path); pWrapper->path = taosStrdup(path);
@ -214,8 +215,8 @@ int32_t dmInitVars(SDnode *pDnode) {
return -1; return -1;
} }
taosThreadRwlockInit(&pData->lock, NULL); (void)taosThreadRwlockInit(&pData->lock, NULL);
taosThreadMutexInit(&pDnode->mutex, NULL); (void)taosThreadMutexInit(&pDnode->mutex, NULL);
return 0; return 0;
} }
@ -223,16 +224,16 @@ void dmClearVars(SDnode *pDnode) {
for (EDndNodeType ntype = DNODE; ntype < NODE_END; ++ntype) { for (EDndNodeType ntype = DNODE; ntype < NODE_END; ++ntype) {
SMgmtWrapper *pWrapper = &pDnode->wrappers[ntype]; SMgmtWrapper *pWrapper = &pDnode->wrappers[ntype];
taosMemoryFreeClear(pWrapper->path); taosMemoryFreeClear(pWrapper->path);
taosThreadRwlockDestroy(&pWrapper->lock); (void)taosThreadRwlockDestroy(&pWrapper->lock);
} }
if (pDnode->lockfile != NULL) { if (pDnode->lockfile != NULL) {
taosUnLockFile(pDnode->lockfile); (void)taosUnLockFile(pDnode->lockfile);
taosCloseFile(&pDnode->lockfile); (void)taosCloseFile(&pDnode->lockfile);
pDnode->lockfile = NULL; pDnode->lockfile = NULL;
} }
SDnodeData *pData = &pDnode->data; SDnodeData *pData = &pDnode->data;
taosThreadRwlockWrlock(&pData->lock); (void)taosThreadRwlockWrlock(&pData->lock);
if (pData->oldDnodeEps != NULL) { if (pData->oldDnodeEps != NULL) {
if (dmWriteEps(pData) == 0) { if (dmWriteEps(pData) == 0) {
dmRemoveDnodePairs(pData); dmRemoveDnodePairs(pData);
@ -248,10 +249,10 @@ void dmClearVars(SDnode *pDnode) {
taosHashCleanup(pData->dnodeHash); taosHashCleanup(pData->dnodeHash);
pData->dnodeHash = NULL; pData->dnodeHash = NULL;
} }
taosThreadRwlockUnlock(&pData->lock); (void)taosThreadRwlockUnlock(&pData->lock);
taosThreadRwlockDestroy(&pData->lock); (void)taosThreadRwlockDestroy(&pData->lock);
taosThreadMutexDestroy(&pDnode->mutex); (void)taosThreadMutexDestroy(&pDnode->mutex);
memset(&pDnode->mutex, 0, sizeof(pDnode->mutex)); memset(&pDnode->mutex, 0, sizeof(pDnode->mutex));
} }
@ -266,14 +267,14 @@ SMgmtWrapper *dmAcquireWrapper(SDnode *pDnode, EDndNodeType ntype) {
SMgmtWrapper *pWrapper = &pDnode->wrappers[ntype]; SMgmtWrapper *pWrapper = &pDnode->wrappers[ntype];
SMgmtWrapper *pRetWrapper = pWrapper; SMgmtWrapper *pRetWrapper = pWrapper;
taosThreadRwlockRdlock(&pWrapper->lock); (void)taosThreadRwlockRdlock(&pWrapper->lock);
if (pWrapper->deployed) { if (pWrapper->deployed) {
int32_t refCount = atomic_add_fetch_32(&pWrapper->refCount, 1); int32_t refCount = atomic_add_fetch_32(&pWrapper->refCount, 1);
// dTrace("node:%s, is acquired, ref:%d", pWrapper->name, refCount); // dTrace("node:%s, is acquired, ref:%d", pWrapper->name, refCount);
} else { } else {
pRetWrapper = NULL; pRetWrapper = NULL;
} }
taosThreadRwlockUnlock(&pWrapper->lock); (void)taosThreadRwlockUnlock(&pWrapper->lock);
return pRetWrapper; return pRetWrapper;
} }
@ -281,7 +282,7 @@ SMgmtWrapper *dmAcquireWrapper(SDnode *pDnode, EDndNodeType ntype) {
int32_t dmMarkWrapper(SMgmtWrapper *pWrapper) { int32_t dmMarkWrapper(SMgmtWrapper *pWrapper) {
int32_t code = 0; int32_t code = 0;
taosThreadRwlockRdlock(&pWrapper->lock); (void)taosThreadRwlockRdlock(&pWrapper->lock);
if (pWrapper->deployed) { if (pWrapper->deployed) {
int32_t refCount = atomic_add_fetch_32(&pWrapper->refCount, 1); int32_t refCount = atomic_add_fetch_32(&pWrapper->refCount, 1);
// dTrace("node:%s, is marked, ref:%d", pWrapper->name, refCount); // dTrace("node:%s, is marked, ref:%d", pWrapper->name, refCount);
@ -304,7 +305,7 @@ int32_t dmMarkWrapper(SMgmtWrapper *pWrapper) {
break; break;
} }
} }
taosThreadRwlockUnlock(&pWrapper->lock); (void)taosThreadRwlockUnlock(&pWrapper->lock);
return code; return code;
} }
@ -312,9 +313,9 @@ int32_t dmMarkWrapper(SMgmtWrapper *pWrapper) {
void dmReleaseWrapper(SMgmtWrapper *pWrapper) { void dmReleaseWrapper(SMgmtWrapper *pWrapper) {
if (pWrapper == NULL) return; if (pWrapper == NULL) return;
taosThreadRwlockRdlock(&pWrapper->lock); (void)taosThreadRwlockRdlock(&pWrapper->lock);
int32_t refCount = atomic_sub_fetch_32(&pWrapper->refCount, 1); int32_t refCount = atomic_sub_fetch_32(&pWrapper->refCount, 1);
taosThreadRwlockUnlock(&pWrapper->lock); (void)taosThreadRwlockUnlock(&pWrapper->lock);
// dTrace("node:%s, is released, ref:%d", pWrapper->name, refCount); // dTrace("node:%s, is released, ref:%d", pWrapper->name, refCount);
} }
@ -343,7 +344,7 @@ void dmProcessNetTestReq(SDnode *pDnode, SRpcMsg *pMsg) {
rsp.contLen = pMsg->contLen; rsp.contLen = pMsg->contLen;
} }
rpcSendResponse(&rsp); (void)rpcSendResponse(&rsp);
rpcFreeCont(pMsg->pCont); rpcFreeCont(pMsg->pCont);
} }
@ -365,6 +366,6 @@ void dmProcessServerStartupStatus(SDnode *pDnode, SRpcMsg *pMsg) {
} }
} }
rpcSendResponse(&rsp); (void)rpcSendResponse(&rsp);
rpcFreeCont(pMsg->pCont); rpcFreeCont(pMsg->pCont);
} }

4
source/dnode/mgmt/node_mgmt/src/dmNodes.c
View File

@ -77,12 +77,12 @@ void dmCloseNode(SMgmtWrapper *pWrapper) {
taosMsleep(10); taosMsleep(10);
} }
taosThreadRwlockWrlock(&pWrapper->lock); (void)taosThreadRwlockWrlock(&pWrapper->lock);
if (pWrapper->pMgmt != NULL) { if (pWrapper->pMgmt != NULL) {
(*pWrapper->func.closeFp)(pWrapper->pMgmt); (*pWrapper->func.closeFp)(pWrapper->pMgmt);
pWrapper->pMgmt = NULL; pWrapper->pMgmt = NULL;
} }
taosThreadRwlockUnlock(&pWrapper->lock); (void)taosThreadRwlockUnlock(&pWrapper->lock);
dInfo("node:%s, has been closed", pWrapper->name); dInfo("node:%s, has been closed", pWrapper->name);
} }

40
source/dnode/mgmt/node_mgmt/src/dmTransport.c
View File

@ -18,18 +18,22 @@
#include "qworker.h" #include "qworker.h"
#include "tversion.h" #include "tversion.h"
static inline void dmSendRsp(SRpcMsg *pMsg) { rpcSendResponse(pMsg); } static inline void dmSendRsp(SRpcMsg *pMsg) { (void)rpcSendResponse(pMsg); }
static inline void dmBuildMnodeRedirectRsp(SDnode *pDnode, SRpcMsg *pMsg) { static inline void dmBuildMnodeRedirectRsp(SDnode *pDnode, SRpcMsg *pMsg) {
SEpSet epSet = {0}; SEpSet epSet = {0};
dmGetMnodeEpSetForRedirect(&pDnode->data, pMsg, &epSet); dmGetMnodeEpSetForRedirect(&pDnode->data, pMsg, &epSet);
const int32_t contLen = tSerializeSEpSet(NULL, 0, &epSet); int32_t contLen = tSerializeSEpSet(NULL, 0, &epSet);
pMsg->pCont = rpcMallocCont(contLen); pMsg->pCont = rpcMallocCont(contLen);
if (pMsg->pCont == NULL) { if (pMsg->pCont == NULL) {
pMsg->code = TSDB_CODE_OUT_OF_MEMORY; pMsg->code = TSDB_CODE_OUT_OF_MEMORY;
} else { } else {
tSerializeSEpSet(pMsg->pCont, contLen, &epSet); contLen = tSerializeSEpSet(pMsg->pCont, contLen, &epSet);
if (contLen < 0) {
pMsg->code = contLen;
return;
}
pMsg->contLen = contLen; pMsg->contLen = contLen;
} }
} }
@ -67,12 +71,15 @@ static int32_t dmConvertErrCode(tmsg_t msgType, int32_t code) {
static void dmUpdateRpcIpWhite(SDnodeData *pData, void *pTrans, SRpcMsg *pRpc) { static void dmUpdateRpcIpWhite(SDnodeData *pData, void *pTrans, SRpcMsg *pRpc) {
int32_t code = 0; int32_t code = 0;
SUpdateIpWhite ipWhite = {0}; // aosMemoryCalloc(1, sizeof(SUpdateIpWhite)); SUpdateIpWhite ipWhite = {0}; // aosMemoryCalloc(1, sizeof(SUpdateIpWhite));
tDeserializeSUpdateIpWhite(pRpc->pCont, pRpc->contLen, &ipWhite); code = tDeserializeSUpdateIpWhite(pRpc->pCont, pRpc->contLen, &ipWhite);
if (code < 0) {
dError("failed to update rpc ip-white since: %s", tstrerror(code));
return;
}
code = rpcSetIpWhite(pTrans, &ipWhite); code = rpcSetIpWhite(pTrans, &ipWhite);
pData->ipWhiteVer = ipWhite.ver; pData->ipWhiteVer = ipWhite.ver;
tFreeSUpdateIpWhiteReq(&ipWhite); (void)tFreeSUpdateIpWhiteReq(&ipWhite);
rpcFreeCont(pRpc->pCont); rpcFreeCont(pRpc->pCont);
} }
@ -81,7 +88,7 @@ static bool dmIsForbiddenIp(int8_t forbidden, char *user, uint32_t clientIp) {
SIpV4Range range = {.ip = clientIp, .mask = 32}; SIpV4Range range = {.ip = clientIp, .mask = 32};
char buf[36] = {0}; char buf[36] = {0};
rpcUtilSIpRangeToStr(&range, buf); (void)rpcUtilSIpRangeToStr(&range, buf);
dError("User:%s host:%s not in ip white list", user, buf); dError("User:%s host:%s not in ip white list", user, buf);
return true; return true;
} else { } else {
@ -100,7 +107,7 @@ static void dmProcessRpcMsg(SDnode *pDnode, SRpcMsg *pRpc, SEpSet *pEpSet) {
pRpc->info.handle, pRpc->contLen, pRpc->code, pRpc->info.ahandle, pRpc->info.refId); pRpc->info.handle, pRpc->contLen, pRpc->code, pRpc->info.ahandle, pRpc->info.refId);
int32_t svrVer = 0; int32_t svrVer = 0;
taosVersionStrToInt(version, &svrVer); (void)taosVersionStrToInt(version, &svrVer);
if ((code = taosCheckVersionCompatible(pRpc->info.cliVer, svrVer, 3)) != 0) { if ((code = taosCheckVersionCompatible(pRpc->info.cliVer, svrVer, 3)) != 0) {
dError("Version not compatible, cli ver: %d, svr ver: %d", pRpc->info.cliVer, svrVer); dError("Version not compatible, cli ver: %d, svr ver: %d", pRpc->info.cliVer, svrVer);
goto _OVER; goto _OVER;
@ -296,7 +303,7 @@ static inline int32_t dmSendReq(const SEpSet *pEpSet, SRpcMsg *pMsg) {
return code; return code;
} else { } else {
pMsg->info.handle = 0; pMsg->info.handle = 0;
rpcSendRequest(pDnode->trans.clientRpc, pEpSet, pMsg, NULL); (void)rpcSendRequest(pDnode->trans.clientRpc, pEpSet, pMsg, NULL);
return 0; return 0;
} }
} }
@ -315,14 +322,13 @@ static inline int32_t dmSendSyncReq(const SEpSet *pEpSet, SRpcMsg *pMsg) {
pMsg->info.handle); pMsg->info.handle);
return code; return code;
} else { } else {
rpcSendRequest(pDnode->trans.syncRpc, pEpSet, pMsg, NULL); return rpcSendRequest(pDnode->trans.syncRpc, pEpSet, pMsg, NULL);
return 0;
} }
} }
static inline void dmRegisterBrokenLinkArg(SRpcMsg *pMsg) { rpcRegisterBrokenLinkArg(pMsg); } static inline void dmRegisterBrokenLinkArg(SRpcMsg *pMsg) { (void)rpcRegisterBrokenLinkArg(pMsg); }
static inline void dmReleaseHandle(SRpcHandleInfo *pHandle, int8_t type) { rpcReleaseHandle(pHandle, type); } static inline void dmReleaseHandle(SRpcHandleInfo *pHandle, int8_t type) { (void)rpcReleaseHandle(pHandle, type); }
static bool rpcRfp(int32_t code, tmsg_t msgType) { static bool rpcRfp(int32_t code, tmsg_t msgType) {
if (code == TSDB_CODE_RPC_NETWORK_UNAVAIL || code == TSDB_CODE_RPC_BROKEN_LINK || code == TSDB_CODE_MNODE_NOT_FOUND || if (code == TSDB_CODE_RPC_NETWORK_UNAVAIL || code == TSDB_CODE_RPC_BROKEN_LINK || code == TSDB_CODE_MNODE_NOT_FOUND ||
@ -382,7 +388,7 @@ int32_t dmInitClient(SDnode *pDnode) {
rpcInit.batchSize = 8 * 1024; rpcInit.batchSize = 8 * 1024;
rpcInit.timeToGetConn = tsTimeToGetAvailableConn; rpcInit.timeToGetConn = tsTimeToGetAvailableConn;
taosVersionStrToInt(version, &(rpcInit.compatibilityVer)); (void)taosVersionStrToInt(version, &(rpcInit.compatibilityVer));
pTrans->clientRpc = rpcOpen(&rpcInit); pTrans->clientRpc = rpcOpen(&rpcInit);
if (pTrans->clientRpc == NULL) { if (pTrans->clientRpc == NULL) {
@ -426,7 +432,7 @@ int32_t dmInitStatusClient(SDnode *pDnode) {
rpcInit.supportBatch = 1; rpcInit.supportBatch = 1;
rpcInit.batchSize = 8 * 1024; rpcInit.batchSize = 8 * 1024;
rpcInit.timeToGetConn = tsTimeToGetAvailableConn; rpcInit.timeToGetConn = tsTimeToGetAvailableConn;
taosVersionStrToInt(version, &(rpcInit.compatibilityVer)); (void)taosVersionStrToInt(version, &(rpcInit.compatibilityVer));
pTrans->statusRpc = rpcOpen(&rpcInit); pTrans->statusRpc = rpcOpen(&rpcInit);
if (pTrans->statusRpc == NULL) { if (pTrans->statusRpc == NULL) {
@ -471,7 +477,7 @@ int32_t dmInitSyncClient(SDnode *pDnode) {
rpcInit.supportBatch = 1; rpcInit.supportBatch = 1;
rpcInit.batchSize = 8 * 1024; rpcInit.batchSize = 8 * 1024;
rpcInit.timeToGetConn = tsTimeToGetAvailableConn; rpcInit.timeToGetConn = tsTimeToGetAvailableConn;
taosVersionStrToInt(version, &(rpcInit.compatibilityVer)); (void)taosVersionStrToInt(version, &(rpcInit.compatibilityVer));
pTrans->syncRpc = rpcOpen(&rpcInit); pTrans->syncRpc = rpcOpen(&rpcInit);
if (pTrans->syncRpc == NULL) { if (pTrans->syncRpc == NULL) {
@ -522,7 +528,7 @@ int32_t dmInitServer(SDnode *pDnode) {
rpcInit.idleTime = tsShellActivityTimer * 1000; rpcInit.idleTime = tsShellActivityTimer * 1000;
rpcInit.parent = pDnode; rpcInit.parent = pDnode;
rpcInit.compressSize = tsCompressMsgSize; rpcInit.compressSize = tsCompressMsgSize;
taosVersionStrToInt(version, &(rpcInit.compatibilityVer)); (void)taosVersionStrToInt(version, &(rpcInit.compatibilityVer));
pTrans->serverRpc = rpcOpen(&rpcInit); pTrans->serverRpc = rpcOpen(&rpcInit);
if (pTrans->serverRpc == NULL) { if (pTrans->serverRpc == NULL) {
dError("failed to init dnode rpc server"); dError("failed to init dnode rpc server");

60
source/dnode/mgmt/node_util/src/dmEps.c
View File

@ -33,7 +33,7 @@ static int32_t dmReadDnodePairs(SDnodeData *pData);
void dmGetDnodeEp(void *data, int32_t dnodeId, char *pEp, char *pFqdn, uint16_t *pPort) { void dmGetDnodeEp(void *data, int32_t dnodeId, char *pEp, char *pFqdn, uint16_t *pPort) {
SDnodeData *pData = data; SDnodeData *pData = data;
taosThreadRwlockRdlock(&pData->lock); (void)taosThreadRwlockRdlock(&pData->lock);
SDnodeEp *pDnodeEp = taosHashGet(pData->dnodeHash, &dnodeId, sizeof(int32_t)); SDnodeEp *pDnodeEp = taosHashGet(pData->dnodeHash, &dnodeId, sizeof(int32_t));
if (pDnodeEp != NULL) { if (pDnodeEp != NULL) {
@ -48,7 +48,7 @@ void dmGetDnodeEp(void *data, int32_t dnodeId, char *pEp, char *pFqdn, uint16_t
} }
} }
taosThreadRwlockUnlock(&pData->lock); (void)taosThreadRwlockUnlock(&pData->lock);
} }
static int32_t dmDecodeEps(SJson *pJson, SDnodeData *pData) { static int32_t dmDecodeEps(SJson *pJson, SDnodeData *pData) {
@ -255,8 +255,8 @@ _OVER:
if (taosArrayGetSize(pData->dnodeEps) == 0) { if (taosArrayGetSize(pData->dnodeEps) == 0) {
SDnodeEp dnodeEp = {0}; SDnodeEp dnodeEp = {0};
dnodeEp.isMnode = 1; dnodeEp.isMnode = 1;
taosGetFqdnPortFromEp(tsFirst, &dnodeEp.ep); (void)taosGetFqdnPortFromEp(tsFirst, &dnodeEp.ep);
taosArrayPush(pData->dnodeEps, &dnodeEp); (void)taosArrayPush(pData->dnodeEps, &dnodeEp);
} }
if ((code = dmReadDnodePairs(pData)) != 0) { if ((code = dmReadDnodePairs(pData)) != 0) {
@ -337,7 +337,7 @@ int32_t dmWriteEps(SDnodeData *pData) {
if (taosWriteFile(pFile, buffer, len) <= 0) TAOS_CHECK_GOTO(TAOS_SYSTEM_ERROR(errno), NULL, _OVER); if (taosWriteFile(pFile, buffer, len) <= 0) TAOS_CHECK_GOTO(TAOS_SYSTEM_ERROR(errno), NULL, _OVER);
if (taosFsyncFile(pFile) < 0) TAOS_CHECK_GOTO(TAOS_SYSTEM_ERROR(errno), NULL, _OVER); if (taosFsyncFile(pFile) < 0) TAOS_CHECK_GOTO(TAOS_SYSTEM_ERROR(errno), NULL, _OVER);
taosCloseFile(&pFile); (void)taosCloseFile(&pFile);
if (taosRenameFile(file, realfile) != 0) TAOS_CHECK_GOTO(TAOS_SYSTEM_ERROR(errno), NULL, _OVER); if (taosRenameFile(file, realfile) != 0) TAOS_CHECK_GOTO(TAOS_SYSTEM_ERROR(errno), NULL, _OVER);
code = 0; code = 0;
@ -348,7 +348,7 @@ int32_t dmWriteEps(SDnodeData *pData) {
_OVER: _OVER:
if (pJson != NULL) tjsonDelete(pJson); if (pJson != NULL) tjsonDelete(pJson);
if (buffer != NULL) taosMemoryFree(buffer); if (buffer != NULL) taosMemoryFree(buffer);
if (pFile != NULL) taosCloseFile(&pFile); if (pFile != NULL) (void)taosCloseFile(&pFile);
if (code != 0) { if (code != 0) {
dError("failed to write dnode file:%s since %s, dnodeVer:%" PRId64, realfile, tstrerror(code), pData->dnodeVer); dError("failed to write dnode file:%s since %s, dnodeVer:%" PRId64, realfile, tstrerror(code), pData->dnodeVer);
@ -358,18 +358,18 @@ _OVER:
int32_t dmGetDnodeSize(SDnodeData *pData) { int32_t dmGetDnodeSize(SDnodeData *pData) {
int32_t size = 0; int32_t size = 0;
taosThreadRwlockRdlock(&pData->lock); (void)taosThreadRwlockRdlock(&pData->lock);
size = taosArrayGetSize(pData->dnodeEps); size = taosArrayGetSize(pData->dnodeEps);
taosThreadRwlockUnlock(&pData->lock); (void)taosThreadRwlockUnlock(&pData->lock);
return size; return size;
} }
void dmUpdateEps(SDnodeData *pData, SArray *eps) { void dmUpdateEps(SDnodeData *pData, SArray *eps) {
taosThreadRwlockWrlock(&pData->lock); (void)taosThreadRwlockWrlock(&pData->lock);
dDebug("new dnode list get from mnode, dnodeVer:%" PRId64, pData->dnodeVer); dDebug("new dnode list get from mnode, dnodeVer:%" PRId64, pData->dnodeVer);
dmResetEps(pData, eps); dmResetEps(pData, eps);
dmWriteEps(pData); (void)dmWriteEps(pData);
taosThreadRwlockUnlock(&pData->lock); (void)taosThreadRwlockUnlock(&pData->lock);
} }
static void dmResetEps(SDnodeData *pData, SArray *dnodeEps) { static void dmResetEps(SDnodeData *pData, SArray *dnodeEps) {
@ -398,7 +398,7 @@ static void dmResetEps(SDnodeData *pData, SArray *dnodeEps) {
for (int32_t i = 0; i < numOfEps; i++) { for (int32_t i = 0; i < numOfEps; i++) {
SDnodeEp *pDnodeEp = taosArrayGet(dnodeEps, i); SDnodeEp *pDnodeEp = taosArrayGet(dnodeEps, i);
taosHashPut(pData->dnodeHash, &pDnodeEp->id, sizeof(int32_t), pDnodeEp, sizeof(SDnodeEp)); (void)taosHashPut(pData->dnodeHash, &pDnodeEp->id, sizeof(int32_t), pDnodeEp, sizeof(SDnodeEp));
} }
pData->validMnodeEps = true; pData->validMnodeEps = true;
@ -418,7 +418,7 @@ static void dmPrintEps(SDnodeData *pData) {
static bool dmIsEpChanged(SDnodeData *pData, int32_t dnodeId, const char *ep) { static bool dmIsEpChanged(SDnodeData *pData, int32_t dnodeId, const char *ep) {
bool changed = false; bool changed = false;
if (dnodeId == 0) return changed; if (dnodeId == 0) return changed;
taosThreadRwlockRdlock(&pData->lock); (void)taosThreadRwlockRdlock(&pData->lock);
SDnodeEp *pDnodeEp = taosHashGet(pData->dnodeHash, &dnodeId, sizeof(int32_t)); SDnodeEp *pDnodeEp = taosHashGet(pData->dnodeHash, &dnodeId, sizeof(int32_t));
if (pDnodeEp != NULL) { if (pDnodeEp != NULL) {
@ -430,14 +430,14 @@ static bool dmIsEpChanged(SDnodeData *pData, int32_t dnodeId, const char *ep) {
} }
} }
taosThreadRwlockUnlock(&pData->lock); (void)taosThreadRwlockUnlock(&pData->lock);
return changed; return changed;
} }
void dmGetMnodeEpSet(SDnodeData *pData, SEpSet *pEpSet) { void dmGetMnodeEpSet(SDnodeData *pData, SEpSet *pEpSet) {
taosThreadRwlockRdlock(&pData->lock); (void)taosThreadRwlockRdlock(&pData->lock);
*pEpSet = pData->mnodeEps; *pEpSet = pData->mnodeEps;
taosThreadRwlockUnlock(&pData->lock); (void)taosThreadRwlockUnlock(&pData->lock);
} }
void dmEpSetToStr(char *buf, int32_t len, SEpSet *epSet) { void dmEpSetToStr(char *buf, int32_t len, SEpSet *epSet) {
@ -464,12 +464,12 @@ static FORCE_INLINE void dmSwapEps(SEp *epLhs, SEp *epRhs) {
} }
void dmRotateMnodeEpSet(SDnodeData *pData) { void dmRotateMnodeEpSet(SDnodeData *pData) {
taosThreadRwlockRdlock(&pData->lock); (void)taosThreadRwlockRdlock(&pData->lock);
SEpSet *pEpSet = &pData->mnodeEps; SEpSet *pEpSet = &pData->mnodeEps;
for (int i = 1; i < pEpSet->numOfEps; i++) { for (int i = 1; i < pEpSet->numOfEps; i++) {
dmSwapEps(&pEpSet->eps[i - 1], &pEpSet->eps[i]); dmSwapEps(&pEpSet->eps[i - 1], &pEpSet->eps[i]);
} }
taosThreadRwlockUnlock(&pData->lock); (void)taosThreadRwlockUnlock(&pData->lock);
} }
void dmGetMnodeEpSetForRedirect(SDnodeData *pData, SRpcMsg *pMsg, SEpSet *pEpSet) { void dmGetMnodeEpSetForRedirect(SDnodeData *pData, SRpcMsg *pMsg, SEpSet *pEpSet) {
@ -486,9 +486,9 @@ void dmGetMnodeEpSetForRedirect(SDnodeData *pData, SRpcMsg *pMsg, SEpSet *pEpSet
void dmSetMnodeEpSet(SDnodeData *pData, SEpSet *pEpSet) { void dmSetMnodeEpSet(SDnodeData *pData, SEpSet *pEpSet) {
if (memcmp(pEpSet, &pData->mnodeEps, sizeof(SEpSet)) == 0) return; if (memcmp(pEpSet, &pData->mnodeEps, sizeof(SEpSet)) == 0) return;
taosThreadRwlockWrlock(&pData->lock); (void)taosThreadRwlockWrlock(&pData->lock);
pData->mnodeEps = *pEpSet; pData->mnodeEps = *pEpSet;
taosThreadRwlockUnlock(&pData->lock); (void)taosThreadRwlockUnlock(&pData->lock);
dInfo("mnode is changed, num:%d use:%d", pEpSet->numOfEps, pEpSet->inUse); dInfo("mnode is changed, num:%d use:%d", pEpSet->numOfEps, pEpSet->inUse);
for (int32_t i = 0; i < pEpSet->numOfEps; ++i) { for (int32_t i = 0; i < pEpSet->numOfEps; ++i) {
@ -502,7 +502,7 @@ bool dmUpdateDnodeInfo(void *data, int32_t *did, int64_t *clusterId, char *fqdn,
int32_t dnodeId = -1; int32_t dnodeId = -1;
if (did != NULL) dnodeId = *did; if (did != NULL) dnodeId = *did;
taosThreadRwlockRdlock(&pData->lock); (void)taosThreadRwlockRdlock(&pData->lock);
if (pData->oldDnodeEps != NULL) { if (pData->oldDnodeEps != NULL) {
int32_t size = (int32_t)taosArrayGetSize(pData->oldDnodeEps); int32_t size = (int32_t)taosArrayGetSize(pData->oldDnodeEps);
@ -542,7 +542,7 @@ bool dmUpdateDnodeInfo(void *data, int32_t *did, int64_t *clusterId, char *fqdn,
} }
} }
taosThreadRwlockUnlock(&pData->lock); (void)taosThreadRwlockUnlock(&pData->lock);
return updated; return updated;
} }
@ -550,26 +550,26 @@ static int32_t dmDecodeEpPairs(SJson *pJson, SDnodeData *pData) {
int32_t code = 0; int32_t code = 0;
SJson *dnodes = tjsonGetObjectItem(pJson, "dnodes"); SJson *dnodes = tjsonGetObjectItem(pJson, "dnodes");
if (dnodes == NULL) return -1; if (dnodes == NULL) return TSDB_CODE_INVALID_CFG_VALUE;
int32_t numOfDnodes = tjsonGetArraySize(dnodes); int32_t numOfDnodes = tjsonGetArraySize(dnodes);
for (int32_t i = 0; i < numOfDnodes; ++i) { for (int32_t i = 0; i < numOfDnodes; ++i) {
SJson *dnode = tjsonGetArrayItem(dnodes, i); SJson *dnode = tjsonGetArrayItem(dnodes, i);
if (dnode == NULL) return -1; if (dnode == NULL) return TSDB_CODE_INVALID_CFG_VALUE;
SDnodeEpPair pair = {0}; SDnodeEpPair pair = {0};
tjsonGetInt32ValueFromDouble(dnode, "id", pair.id, code); tjsonGetInt32ValueFromDouble(dnode, "id", pair.id, code);
if (code < 0) return -1; if (code < 0) return TSDB_CODE_INVALID_CFG_VALUE;
code = tjsonGetStringValue(dnode, "fqdn", pair.oldFqdn); code = tjsonGetStringValue(dnode, "fqdn", pair.oldFqdn);
if (code < 0) return -1; if (code < 0) return TSDB_CODE_INVALID_CFG_VALUE;
tjsonGetUInt16ValueFromDouble(dnode, "port", pair.oldPort, code); tjsonGetUInt16ValueFromDouble(dnode, "port", pair.oldPort, code);
if (code < 0) return -1; if (code < 0) return TSDB_CODE_INVALID_CFG_VALUE;
code = tjsonGetStringValue(dnode, "new_fqdn", pair.newFqdn); code = tjsonGetStringValue(dnode, "new_fqdn", pair.newFqdn);
if (code < 0) return -1; if (code < 0) return TSDB_CODE_INVALID_CFG_VALUE;
tjsonGetUInt16ValueFromDouble(dnode, "new_port", pair.newPort, code); tjsonGetUInt16ValueFromDouble(dnode, "new_port", pair.newPort, code);
if (code < 0) return -1; if (code < 0) return TSDB_CODE_INVALID_CFG_VALUE;
if (taosArrayPush(pData->oldDnodeEps, &pair) == NULL) return -1; if (taosArrayPush(pData->oldDnodeEps, &pair) == NULL) return TSDB_CODE_OUT_OF_MEMORY;
} }
return code; return code;

10
source/dnode/mnode/impl/src/mndDnode.c
View File

@ -185,7 +185,7 @@ static int32_t mndCreateDefaultDnode(SMnode *pMnode) {
TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _OVER); TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _OVER);
code = 0; code = 0;
mndUpdateIpWhiteForAllUser(pMnode, TSDB_DEFAULT_USER, dnodeObj.fqdn, IP_WHITE_ADD, (void)mndUpdateIpWhiteForAllUser(pMnode, TSDB_DEFAULT_USER, dnodeObj.fqdn, IP_WHITE_ADD,
1); // TODO: check the return value 1); // TODO: check the return value
_OVER: _OVER:
@ -916,7 +916,8 @@ static int32_t mndCreateDnode(SMnode *pMnode, SRpcMsg *pReq, SCreateDnodeReq *pC
TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _OVER); TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _OVER);
code = 0; code = 0;
mndUpdateIpWhiteForAllUser(pMnode, TSDB_DEFAULT_USER, dnodeObj.fqdn, IP_WHITE_ADD, 1); // TODO: check the return value (void)mndUpdateIpWhiteForAllUser(pMnode, TSDB_DEFAULT_USER, dnodeObj.fqdn, IP_WHITE_ADD,
1); // TODO: check the return value
_OVER: _OVER:
mndTransDrop(pTrans); mndTransDrop(pTrans);
sdbFreeRaw(pRaw); sdbFreeRaw(pRaw);
@ -1231,7 +1232,8 @@ static int32_t mndDropDnode(SMnode *pMnode, SRpcMsg *pReq, SDnodeObj *pDnode, SM
TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _OVER); TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _OVER);
mndUpdateIpWhiteForAllUser(pMnode, TSDB_DEFAULT_USER, pDnode->fqdn, IP_WHITE_DROP, 1); // TODO: check the return value (void)mndUpdateIpWhiteForAllUser(pMnode, TSDB_DEFAULT_USER, pDnode->fqdn, IP_WHITE_DROP,
1); // TODO: check the return value
code = 0; code = 0;
_OVER: _OVER:
@ -1749,7 +1751,7 @@ static int32_t mndRetrieveDnodes(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pB
#ifdef TD_ENTERPRISE #ifdef TD_ENTERPRISE
STR_TO_VARSTR(buf, pDnode->machineId); STR_TO_VARSTR(buf, pDnode->machineId);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, buf, false); (void)colDataSetVal(pColInfo, numOfRows, buf, false);
#endif #endif
numOfRows++; numOfRows++;

18
source/dnode/mnode/impl/src/mndDump.c
View File

@ -74,7 +74,7 @@ void dumpFunc(SSdb *pSdb, SJson *json) {
void dumpDb(SSdb *pSdb, SJson *json) { void dumpDb(SSdb *pSdb, SJson *json) {
void *pIter = NULL; void *pIter = NULL;
SJson *items = tjsonCreateObject(); SJson *items = tjsonCreateObject();
tjsonAddItemToObject(json, "dbs", items); (void)tjsonAddItemToObject(json, "dbs", items);
while (1) { while (1) {
SDbObj *pObj = NULL; SDbObj *pObj = NULL;
@ -82,7 +82,7 @@ void dumpDb(SSdb *pSdb, SJson *json) {
if (pIter == NULL) break; if (pIter == NULL) break;
SJson *item = tjsonCreateObject(); SJson *item = tjsonCreateObject();
tjsonAddItemToObject(items, "db", item); (void)tjsonAddItemToObject(items, "db", item);
(void)tjsonAddStringToObject(item, "name", mndGetDbStr(pObj->name)); (void)tjsonAddStringToObject(item, "name", mndGetDbStr(pObj->name));
(void)tjsonAddStringToObject(item, "acct", pObj->acct); (void)tjsonAddStringToObject(item, "acct", pObj->acct);
@ -546,7 +546,7 @@ void dumpHeader(SSdb *pSdb, SJson *json) {
(void)tjsonAddStringToObject(json, "applyConfig", i642str(pSdb->applyConfig)); (void)tjsonAddStringToObject(json, "applyConfig", i642str(pSdb->applyConfig));
SJson *maxIdsJson = tjsonCreateObject(); SJson *maxIdsJson = tjsonCreateObject();
tjsonAddItemToObject(json, "maxIds", maxIdsJson); (void)tjsonAddItemToObject(json, "maxIds", maxIdsJson);
for (int32_t i = 0; i < SDB_MAX; ++i) { for (int32_t i = 0; i < SDB_MAX; ++i) {
if(i == 5) continue; if(i == 5) continue;
int64_t maxId = 0; int64_t maxId = 0;
@ -557,7 +557,7 @@ void dumpHeader(SSdb *pSdb, SJson *json) {
} }
SJson *tableVersJson = tjsonCreateObject(); SJson *tableVersJson = tjsonCreateObject();
tjsonAddItemToObject(json, "tableVers", tableVersJson); (void)tjsonAddItemToObject(json, "tableVers", tableVersJson);
for (int32_t i = 0; i < SDB_MAX; ++i) { for (int32_t i = 0; i < SDB_MAX; ++i) {
int64_t tableVer = 0; int64_t tableVer = 0;
if (i < SDB_MAX) { if (i < SDB_MAX) {
@ -581,8 +581,8 @@ void mndDumpSdb() {
msgCb.mgmt = (SMgmtWrapper *)(&msgCb); // hack msgCb.mgmt = (SMgmtWrapper *)(&msgCb); // hack
tmsgSetDefault(&msgCb); tmsgSetDefault(&msgCb);
walInit(); (void)walInit();
syncInit(); (void)syncInit();
SMnodeOpt opt = {.msgCb = msgCb}; SMnodeOpt opt = {.msgCb = msgCb};
SMnode *pMnode = mndOpen(path, &opt); SMnode *pMnode = mndOpen(path, &opt);
@ -620,10 +620,10 @@ void mndDumpSdb() {
mError("failed to write %s since %s", file, terrstr()); mError("failed to write %s since %s", file, terrstr());
return; return;
} }
taosWriteFile(pFile, pCont, contLen); (void)taosWriteFile(pFile, pCont, contLen);
taosWriteFile(pFile, "\n", 1); (void)taosWriteFile(pFile, "\n", 1);
UNUSED(taosFsyncFile(pFile)); UNUSED(taosFsyncFile(pFile));
taosCloseFile(&pFile); (void)taosCloseFile(&pFile);
tjsonDelete(json); tjsonDelete(json);
taosMemoryFree(pCont); taosMemoryFree(pCont);

2
source/dnode/mnode/impl/src/mndFunc.c
View File

@ -598,7 +598,7 @@ static int32_t mndProcessRetrieveFuncReq(SRpcMsg *pReq) {
goto RETRIEVE_FUNC_OVER; goto RETRIEVE_FUNC_OVER;
} }
tSerializeSRetrieveFuncRsp(pRsp, contLen, &retrieveRsp); (void)tSerializeSRetrieveFuncRsp(pRsp, contLen, &retrieveRsp);
pReq->info.rsp = pRsp; pReq->info.rsp = pRsp;
pReq->info.rspLen = contLen; pReq->info.rspLen = contLen;

24
source/dnode/mnode/impl/src/mndIndex.c
View File

@ -159,7 +159,7 @@ static void *mndBuildDropIdxReq(SMnode *pMnode, SVgObj *pVgroup, SStbObj *pStbOb
pHead->vgId = htonl(pVgroup->vgId); pHead->vgId = htonl(pVgroup->vgId);
void *pBuf = POINTER_SHIFT(pHead, sizeof(SMsgHead)); void *pBuf = POINTER_SHIFT(pHead, sizeof(SMsgHead));
tSerializeSDropIdxReq(pBuf, len - sizeof(SMsgHead), &req); (void)tSerializeSDropIdxReq(pBuf, len - sizeof(SMsgHead), &req);
*contLen = len; *contLen = len;
return pHead; return pHead;
_err: _err:
@ -333,10 +333,10 @@ void mndReleaseIdx(SMnode *pMnode, SIdxObj *pIdx) {
SDbObj *mndAcquireDbByIdx(SMnode *pMnode, const char *idxName) { SDbObj *mndAcquireDbByIdx(SMnode *pMnode, const char *idxName) {
SName name = {0}; SName name = {0};
tNameFromString(&name, idxName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); (void)tNameFromString(&name, idxName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
char db[TSDB_TABLE_FNAME_LEN] = {0}; char db[TSDB_TABLE_FNAME_LEN] = {0};
tNameGetFullDbName(&name, db); (void)tNameGetFullDbName(&name, db);
return mndAcquireDb(pMnode, db); return mndAcquireDb(pMnode, db);
} }
@ -578,7 +578,7 @@ int32_t mndRetrieveTagIdx(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, i
cols = 0; cols = 0;
SName idxName = {0}; SName idxName = {0};
tNameFromString(&idxName, pIdx->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); (void)tNameFromString(&idxName, pIdx->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
char n1[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0}; char n1[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};
STR_TO_VARSTR(n1, (char *)tNameGetTableName(&idxName)); STR_TO_VARSTR(n1, (char *)tNameGetTableName(&idxName));
@ -587,37 +587,37 @@ int32_t mndRetrieveTagIdx(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, i
STR_TO_VARSTR(n2, (char *)mndGetDbStr(pIdx->db)); STR_TO_VARSTR(n2, (char *)mndGetDbStr(pIdx->db));
SName stbName = {0}; SName stbName = {0};
tNameFromString(&stbName, pIdx->stb, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); (void)tNameFromString(&stbName, pIdx->stb, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
char n3[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0}; char n3[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};
STR_TO_VARSTR(n3, (char *)tNameGetTableName(&stbName)); STR_TO_VARSTR(n3, (char *)tNameGetTableName(&stbName));
SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)n1, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)n1, false);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)n2, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)n2, false);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)n3, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)n3, false);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, NULL, true); (void)colDataSetVal(pColInfo, numOfRows, NULL, true);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)&pIdx->createdTime, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pIdx->createdTime, false);
char col[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0}; char col[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};
STR_TO_VARSTR(col, (char *)pIdx->colName); STR_TO_VARSTR(col, (char *)pIdx->colName);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)col, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)col, false);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
char tag[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0}; char tag[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};
STR_TO_VARSTR(tag, (char *)"tag_index"); STR_TO_VARSTR(tag, (char *)"tag_index");
colDataSetVal(pColInfo, numOfRows, (const char *)tag, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)tag, false);
numOfRows++; numOfRows++;
sdbRelease(pSdb, pIdx); sdbRelease(pSdb, pIdx);

118
source/dnode/mnode/impl/src/mndMain.c
View File

@ -48,32 +48,32 @@
static inline int32_t mndAcquireRpc(SMnode *pMnode) { static inline int32_t mndAcquireRpc(SMnode *pMnode) {
int32_t code = 0; int32_t code = 0;
taosThreadRwlockRdlock(&pMnode->lock); (void)taosThreadRwlockRdlock(&pMnode->lock);
if (pMnode->stopped) { if (pMnode->stopped) {
code = TSDB_CODE_APP_IS_STOPPING; code = TSDB_CODE_APP_IS_STOPPING;
} else if (!mndIsLeader(pMnode)) { } else if (!mndIsLeader(pMnode)) {
code = -1; code = -1;
} else { } else {
#if 1 #if 1
atomic_add_fetch_32(&pMnode->rpcRef, 1); (void)atomic_add_fetch_32(&pMnode->rpcRef, 1);
#else #else
int32_t ref = atomic_add_fetch_32(&pMnode->rpcRef, 1); int32_t ref = atomic_add_fetch_32(&pMnode->rpcRef, 1);
mTrace("mnode rpc is acquired, ref:%d", ref); mTrace("mnode rpc is acquired, ref:%d", ref);
#endif #endif
} }
taosThreadRwlockUnlock(&pMnode->lock); (void)taosThreadRwlockUnlock(&pMnode->lock);
TAOS_RETURN(code); TAOS_RETURN(code);
} }
static inline void mndReleaseRpc(SMnode *pMnode) { static inline void mndReleaseRpc(SMnode *pMnode) {
taosThreadRwlockRdlock(&pMnode->lock); (void)taosThreadRwlockRdlock(&pMnode->lock);
#if 1 #if 1
atomic_sub_fetch_32(&pMnode->rpcRef, 1); (void)atomic_sub_fetch_32(&pMnode->rpcRef, 1);
#else #else
int32_t ref = atomic_sub_fetch_32(&pMnode->rpcRef, 1); int32_t ref = atomic_sub_fetch_32(&pMnode->rpcRef, 1);
mTrace("mnode rpc is released, ref:%d", ref); mTrace("mnode rpc is released, ref:%d", ref);
#endif #endif
taosThreadRwlockUnlock(&pMnode->lock); (void)taosThreadRwlockUnlock(&pMnode->lock);
} }
static void *mndBuildTimerMsg(int32_t *pContLen) { static void *mndBuildTimerMsg(int32_t *pContLen) {
@ -85,7 +85,7 @@ static void *mndBuildTimerMsg(int32_t *pContLen) {
void *pReq = rpcMallocCont(contLen); void *pReq = rpcMallocCont(contLen);
if (pReq == NULL) return NULL; if (pReq == NULL) return NULL;
tSerializeSMTimerMsg(pReq, contLen, &timerReq); (void)tSerializeSMTimerMsg(pReq, contLen, &timerReq);
*pContLen = contLen; *pContLen = contLen;
return pReq; return pReq;
} }
@ -96,7 +96,8 @@ static void mndPullupTrans(SMnode *pMnode) {
void *pReq = mndBuildTimerMsg(&contLen); void *pReq = mndBuildTimerMsg(&contLen);
if (pReq != NULL) { if (pReq != NULL) {
SRpcMsg rpcMsg = {.msgType = TDMT_MND_TRANS_TIMER, .pCont = pReq, .contLen = contLen}; SRpcMsg rpcMsg = {.msgType = TDMT_MND_TRANS_TIMER, .pCont = pReq, .contLen = contLen};
tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg); //TODO check return value
(void)tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg);
} }
} }
@ -106,7 +107,8 @@ static void mndPullupCompacts(SMnode *pMnode) {
void *pReq = mndBuildTimerMsg(&contLen); void *pReq = mndBuildTimerMsg(&contLen);
if (pReq != NULL) { if (pReq != NULL) {
SRpcMsg rpcMsg = {.msgType = TDMT_MND_COMPACT_TIMER, .pCont = pReq, .contLen = contLen}; SRpcMsg rpcMsg = {.msgType = TDMT_MND_COMPACT_TIMER, .pCont = pReq, .contLen = contLen};
tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg); //TODO check return value
(void)tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg);
} }
} }
@ -115,7 +117,8 @@ static void mndPullupTtl(SMnode *pMnode) {
int32_t contLen = 0; int32_t contLen = 0;
void *pReq = mndBuildTimerMsg(&contLen); void *pReq = mndBuildTimerMsg(&contLen);
SRpcMsg rpcMsg = {.msgType = TDMT_MND_TTL_TIMER, .pCont = pReq, .contLen = contLen}; SRpcMsg rpcMsg = {.msgType = TDMT_MND_TTL_TIMER, .pCont = pReq, .contLen = contLen};
tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg); //TODO check return value
(void)tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg);
} }
static void mndPullupTrimDb(SMnode *pMnode) { static void mndPullupTrimDb(SMnode *pMnode) {
@ -123,7 +126,8 @@ static void mndPullupTrimDb(SMnode *pMnode) {
int32_t contLen = 0; int32_t contLen = 0;
void *pReq = mndBuildTimerMsg(&contLen); void *pReq = mndBuildTimerMsg(&contLen);
SRpcMsg rpcMsg = {.msgType = TDMT_MND_S3MIGRATE_DB_TIMER, .pCont = pReq, .contLen = contLen}; SRpcMsg rpcMsg = {.msgType = TDMT_MND_S3MIGRATE_DB_TIMER, .pCont = pReq, .contLen = contLen};
tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg); // TODO check return value
(void)tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg);
} }
static void mndPullupS3MigrateDb(SMnode *pMnode) { static void mndPullupS3MigrateDb(SMnode *pMnode) {
@ -131,7 +135,8 @@ static void mndPullupS3MigrateDb(SMnode *pMnode) {
int32_t contLen = 0; int32_t contLen = 0;
void *pReq = mndBuildTimerMsg(&contLen); void *pReq = mndBuildTimerMsg(&contLen);
SRpcMsg rpcMsg = {.msgType = TDMT_MND_TRIM_DB_TIMER, .pCont = pReq, .contLen = contLen}; SRpcMsg rpcMsg = {.msgType = TDMT_MND_TRIM_DB_TIMER, .pCont = pReq, .contLen = contLen};
tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg); // TODO check return value
(void)tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg);
} }
static int32_t mndPullupArbHeartbeat(SMnode *pMnode) { static int32_t mndPullupArbHeartbeat(SMnode *pMnode) {
@ -155,7 +160,7 @@ static void mndCalMqRebalance(SMnode *pMnode) {
void *pReq = mndBuildTimerMsg(&contLen); void *pReq = mndBuildTimerMsg(&contLen);
if (pReq != NULL) { if (pReq != NULL) {
SRpcMsg rpcMsg = {.msgType = TDMT_MND_TMQ_TIMER, .pCont = pReq, .contLen = contLen}; SRpcMsg rpcMsg = {.msgType = TDMT_MND_TMQ_TIMER, .pCont = pReq, .contLen = contLen};
tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg); (void)tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg);
} }
} }
@ -164,7 +169,8 @@ static void mndStreamCheckpointTimer(SMnode *pMnode) {
if (pMsg != NULL) { if (pMsg != NULL) {
int32_t size = sizeof(SMStreamDoCheckpointMsg); int32_t size = sizeof(SMStreamDoCheckpointMsg);
SRpcMsg rpcMsg = {.msgType = TDMT_MND_STREAM_BEGIN_CHECKPOINT, .pCont = pMsg, .contLen = size}; SRpcMsg rpcMsg = {.msgType = TDMT_MND_STREAM_BEGIN_CHECKPOINT, .pCont = pMsg, .contLen = size};
tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg); // TODO check return value
(void)tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg);
} }
} }
@ -173,7 +179,8 @@ static void mndStreamCheckNode(SMnode *pMnode) {
void *pReq = mndBuildTimerMsg(&contLen); void *pReq = mndBuildTimerMsg(&contLen);
if (pReq != NULL) { if (pReq != NULL) {
SRpcMsg rpcMsg = {.msgType = TDMT_MND_NODECHECK_TIMER, .pCont = pReq, .contLen = contLen}; SRpcMsg rpcMsg = {.msgType = TDMT_MND_NODECHECK_TIMER, .pCont = pReq, .contLen = contLen};
tmsgPutToQueue(&pMnode->msgCb, READ_QUEUE, &rpcMsg); // TODO check return value
(void)tmsgPutToQueue(&pMnode->msgCb, READ_QUEUE, &rpcMsg);
} }
} }
@ -182,7 +189,8 @@ static void mndStreamConsensusChkpt(SMnode *pMnode) {
void *pReq = mndBuildTimerMsg(&contLen); void *pReq = mndBuildTimerMsg(&contLen);
if (pReq != NULL) { if (pReq != NULL) {
SRpcMsg rpcMsg = {.msgType = TDMT_MND_STREAM_CONSEN_TIMER, .pCont = pReq, .contLen = contLen}; SRpcMsg rpcMsg = {.msgType = TDMT_MND_STREAM_CONSEN_TIMER, .pCont = pReq, .contLen = contLen};
tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg); // TODO check return value
(void)tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg);
} }
} }
@ -192,7 +200,8 @@ static void mndPullupTelem(SMnode *pMnode) {
void *pReq = mndBuildTimerMsg(&contLen); void *pReq = mndBuildTimerMsg(&contLen);
if (pReq != NULL) { if (pReq != NULL) {
SRpcMsg rpcMsg = {.msgType = TDMT_MND_TELEM_TIMER, .pCont = pReq, .contLen = contLen}; SRpcMsg rpcMsg = {.msgType = TDMT_MND_TELEM_TIMER, .pCont = pReq, .contLen = contLen};
tmsgPutToQueue(&pMnode->msgCb, READ_QUEUE, &rpcMsg); // TODO check return value
(void)tmsgPutToQueue(&pMnode->msgCb, READ_QUEUE, &rpcMsg);
} }
} }
@ -203,7 +212,8 @@ static void mndPullupGrant(SMnode *pMnode) {
if (pReq != NULL) { if (pReq != NULL) {
SRpcMsg rpcMsg = { SRpcMsg rpcMsg = {
.msgType = TDMT_MND_GRANT_HB_TIMER, .pCont = pReq, .contLen = contLen, .info.ahandle = (void *)0x9527}; .msgType = TDMT_MND_GRANT_HB_TIMER, .pCont = pReq, .contLen = contLen, .info.ahandle = (void *)0x9527};
tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg); // TODO check return value
(void)tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg);
} }
} }
@ -214,7 +224,8 @@ static void mndIncreaseUpTime(SMnode *pMnode) {
if (pReq != NULL) { if (pReq != NULL) {
SRpcMsg rpcMsg = { SRpcMsg rpcMsg = {
.msgType = TDMT_MND_UPTIME_TIMER, .pCont = pReq, .contLen = contLen, .info.ahandle = (void *)0x9528}; .msgType = TDMT_MND_UPTIME_TIMER, .pCont = pReq, .contLen = contLen, .info.ahandle = (void *)0x9528};
tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg); // TODO check return value
(void)tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg);
} }
} }
@ -287,24 +298,24 @@ static void mndCheckDnodeOffline(SMnode *pMnode) {
static bool mnodeIsNotLeader(SMnode *pMnode) { static bool mnodeIsNotLeader(SMnode *pMnode) {
terrno = 0; terrno = 0;
taosThreadRwlockRdlock(&pMnode->lock); (void)taosThreadRwlockRdlock(&pMnode->lock);
SSyncState state = syncGetState(pMnode->syncMgmt.sync); SSyncState state = syncGetState(pMnode->syncMgmt.sync);
if (terrno != 0) { if (terrno != 0) {
taosThreadRwlockUnlock(&pMnode->lock); (void)taosThreadRwlockUnlock(&pMnode->lock);
return true; return true;
} }
if (state.state != TAOS_SYNC_STATE_LEADER) { if (state.state != TAOS_SYNC_STATE_LEADER) {
taosThreadRwlockUnlock(&pMnode->lock); (void)taosThreadRwlockUnlock(&pMnode->lock);
terrno = TSDB_CODE_SYN_NOT_LEADER; terrno = TSDB_CODE_SYN_NOT_LEADER;
return true; return true;
} }
if (!state.restored || !pMnode->restored) { if (!state.restored || !pMnode->restored) {
taosThreadRwlockUnlock(&pMnode->lock); (void)taosThreadRwlockUnlock(&pMnode->lock);
terrno = TSDB_CODE_SYN_RESTORING; terrno = TSDB_CODE_SYN_RESTORING;
return true; return true;
} }
taosThreadRwlockUnlock(&pMnode->lock); (void)taosThreadRwlockUnlock(&pMnode->lock);
return false; return false;
} }
@ -429,21 +440,21 @@ static void *mndThreadFp(void *param) {
static int32_t mndInitTimer(SMnode *pMnode) { static int32_t mndInitTimer(SMnode *pMnode) {
int32_t code = 0; int32_t code = 0;
TdThreadAttr thAttr; TdThreadAttr thAttr;
taosThreadAttrInit(&thAttr); (void)taosThreadAttrInit(&thAttr);
taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE); (void)taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE);
if ((code = taosThreadCreate(&pMnode->thread, &thAttr, mndThreadFp, pMnode)) != 0) { if ((code = taosThreadCreate(&pMnode->thread, &thAttr, mndThreadFp, pMnode)) != 0) {
mError("failed to create timer thread since %s", strerror(errno)); mError("failed to create timer thread since %s", strerror(errno));
TAOS_RETURN(code); TAOS_RETURN(code);
} }
taosThreadAttrDestroy(&thAttr); (void)taosThreadAttrDestroy(&thAttr);
tmsgReportStartup("mnode-timer", "initialized"); tmsgReportStartup("mnode-timer", "initialized");
TAOS_RETURN(code); TAOS_RETURN(code);
} }
static void mndCleanupTimer(SMnode *pMnode) { static void mndCleanupTimer(SMnode *pMnode) {
if (taosCheckPthreadValid(pMnode->thread)) { if (taosCheckPthreadValid(pMnode->thread)) {
taosThreadJoin(pMnode->thread, NULL); (void)taosThreadJoin(pMnode->thread, NULL);
taosThreadClear(&pMnode->thread); taosThreadClear(&pMnode->thread);
} }
} }
@ -467,7 +478,7 @@ static int32_t mndCreateDir(SMnode *pMnode, const char *path) {
static int32_t mndInitWal(SMnode *pMnode) { static int32_t mndInitWal(SMnode *pMnode) {
int32_t code = 0; int32_t code = 0;
char path[PATH_MAX + 20] = {0}; char path[PATH_MAX + 20] = {0};
snprintf(path, sizeof(path), "%s%swal", pMnode->path, TD_DIRSEP); (void)snprintf(path, sizeof(path), "%s%swal", pMnode->path, TD_DIRSEP);
SWalCfg cfg = {.vgId = 1, SWalCfg cfg = {.vgId = 1,
.fsyncPeriod = 0, .fsyncPeriod = 0,
.rollPeriod = -1, .rollPeriod = -1,
@ -486,7 +497,7 @@ static int32_t mndInitWal(SMnode *pMnode) {
TAOS_RETURN(code); TAOS_RETURN(code);
} }
else{ else{
strncpy(cfg.encryptKey, tsEncryptKey, ENCRYPT_KEY_LEN); (void)strncpy(cfg.encryptKey, tsEncryptKey, ENCRYPT_KEY_LEN);
} }
} }
#endif #endif
@ -642,8 +653,8 @@ static void mndSetOptions(SMnode *pMnode, const SMnodeOpt *pOption) {
pMnode->syncMgmt.numOfReplicas = pOption->numOfReplicas; pMnode->syncMgmt.numOfReplicas = pOption->numOfReplicas;
pMnode->syncMgmt.numOfTotalReplicas = pOption->numOfTotalReplicas; pMnode->syncMgmt.numOfTotalReplicas = pOption->numOfTotalReplicas;
pMnode->syncMgmt.lastIndex = pOption->lastIndex; pMnode->syncMgmt.lastIndex = pOption->lastIndex;
memcpy(pMnode->syncMgmt.replicas, pOption->replicas, sizeof(pOption->replicas)); (void)memcpy(pMnode->syncMgmt.replicas, pOption->replicas, sizeof(pOption->replicas));
memcpy(pMnode->syncMgmt.nodeRoles, pOption->nodeRoles, sizeof(pOption->nodeRoles)); (void)memcpy(pMnode->syncMgmt.nodeRoles, pOption->nodeRoles, sizeof(pOption->nodeRoles));
} }
SMnode *mndOpen(const char *path, const SMnodeOpt *pOption) { SMnode *mndOpen(const char *path, const SMnodeOpt *pOption) {
@ -656,7 +667,7 @@ SMnode *mndOpen(const char *path, const SMnodeOpt *pOption) {
mError("failed to open mnode since %s", terrstr()); mError("failed to open mnode since %s", terrstr());
return NULL; return NULL;
} }
memset(pMnode, 0, sizeof(SMnode)); (void)memset(pMnode, 0, sizeof(SMnode));
char timestr[24] = "1970-01-01 00:00:00.00"; char timestr[24] = "1970-01-01 00:00:00.00";
(void)taosParseTime(timestr, &pMnode->checkTime, (int32_t)strlen(timestr), TSDB_TIME_PRECISION_MILLI, 0); (void)taosParseTime(timestr, &pMnode->checkTime, (int32_t)strlen(timestr), TSDB_TIME_PRECISION_MILLI, 0);
@ -704,6 +715,7 @@ SMnode *mndOpen(const char *path, const SMnodeOpt *pOption) {
void mndPreClose(SMnode *pMnode) { void mndPreClose(SMnode *pMnode) {
if (pMnode != NULL) { if (pMnode != NULL) {
// TODO check return value
syncLeaderTransfer(pMnode->syncMgmt.sync); syncLeaderTransfer(pMnode->syncMgmt.sync);
syncPreStop(pMnode->syncMgmt.sync); syncPreStop(pMnode->syncMgmt.sync);
sdbWriteFile(pMnode->pSdb, 0); sdbWriteFile(pMnode->pSdb, 0);
@ -785,9 +797,9 @@ static int32_t mndCheckMnodeState(SRpcMsg *pMsg) {
} }
SMnode *pMnode = pMsg->info.node; SMnode *pMnode = pMsg->info.node;
taosThreadRwlockRdlock(&pMnode->lock); (void)taosThreadRwlockRdlock(&pMnode->lock);
if (pMnode->stopped) { if (pMnode->stopped) {
taosThreadRwlockUnlock(&pMnode->lock); (void)taosThreadRwlockUnlock(&pMnode->lock);
code = TSDB_CODE_APP_IS_STOPPING; code = TSDB_CODE_APP_IS_STOPPING;
TAOS_RETURN(code); TAOS_RETURN(code);
} }
@ -795,31 +807,31 @@ static int32_t mndCheckMnodeState(SRpcMsg *pMsg) {
terrno = 0; terrno = 0;
SSyncState state = syncGetState(pMnode->syncMgmt.sync); SSyncState state = syncGetState(pMnode->syncMgmt.sync);
if (terrno != 0) { if (terrno != 0) {
taosThreadRwlockUnlock(&pMnode->lock); (void)taosThreadRwlockUnlock(&pMnode->lock);
code = terrno; code = terrno;
TAOS_RETURN(code); TAOS_RETURN(code);
} }
if (state.state != TAOS_SYNC_STATE_LEADER) { if (state.state != TAOS_SYNC_STATE_LEADER) {
taosThreadRwlockUnlock(&pMnode->lock); (void)taosThreadRwlockUnlock(&pMnode->lock);
code = TSDB_CODE_SYN_NOT_LEADER; code = TSDB_CODE_SYN_NOT_LEADER;
goto _OVER; goto _OVER;
} }
if (!state.restored || !pMnode->restored) { if (!state.restored || !pMnode->restored) {
taosThreadRwlockUnlock(&pMnode->lock); (void)taosThreadRwlockUnlock(&pMnode->lock);
code = TSDB_CODE_SYN_RESTORING; code = TSDB_CODE_SYN_RESTORING;
goto _OVER; goto _OVER;
} }
#if 1 #if 1
atomic_add_fetch_32(&pMnode->rpcRef, 1); (void)atomic_add_fetch_32(&pMnode->rpcRef, 1);
#else #else
int32_t ref = atomic_add_fetch_32(&pMnode->rpcRef, 1); int32_t ref = atomic_add_fetch_32(&pMnode->rpcRef, 1);
mTrace("mnode rpc is acquired, ref:%d", ref); mTrace("mnode rpc is acquired, ref:%d", ref);
#endif #endif
taosThreadRwlockUnlock(&pMnode->lock); (void)taosThreadRwlockUnlock(&pMnode->lock);
TAOS_RETURN(code); TAOS_RETURN(code);
_OVER: _OVER:
@ -854,7 +866,7 @@ _OVER:
int32_t contLen = tSerializeSEpSet(NULL, 0, &epSet); int32_t contLen = tSerializeSEpSet(NULL, 0, &epSet);
pMsg->info.rsp = rpcMallocCont(contLen); pMsg->info.rsp = rpcMallocCont(contLen);
if (pMsg->info.rsp != NULL) { if (pMsg->info.rsp != NULL) {
tSerializeSEpSet(pMsg->info.rsp, contLen, &epSet); (void)tSerializeSEpSet(pMsg->info.rsp, contLen, &epSet);
pMsg->info.hasEpSet = 1; pMsg->info.hasEpSet = 1;
pMsg->info.rspLen = contLen; pMsg->info.rspLen = contLen;
} }
@ -973,7 +985,7 @@ int32_t mndGetMonitorInfo(SMnode *pMnode, SMonClusterInfo *pClusterInfo, SMonVgr
} else { } else {
tstrncpy(desc.status, "offline", sizeof(desc.status)); tstrncpy(desc.status, "offline", sizeof(desc.status));
} }
taosArrayPush(pClusterInfo->dnodes, &desc); (void)taosArrayPush(pClusterInfo->dnodes, &desc);
sdbRelease(pSdb, pObj); sdbRelease(pSdb, pObj);
} }
@ -999,7 +1011,7 @@ int32_t mndGetMonitorInfo(SMnode *pMnode, SMonClusterInfo *pClusterInfo, SMonVgr
tstrncpy(desc.role, syncStr(pObj->syncState), sizeof(desc.role)); tstrncpy(desc.role, syncStr(pObj->syncState), sizeof(desc.role));
desc.syncState = pObj->syncState; desc.syncState = pObj->syncState;
} }
taosArrayPush(pClusterInfo->mnodes, &desc); (void)taosArrayPush(pClusterInfo->mnodes, &desc);
sdbRelease(pSdb, pObj); sdbRelease(pSdb, pObj);
} }
@ -1017,8 +1029,8 @@ int32_t mndGetMonitorInfo(SMnode *pMnode, SMonClusterInfo *pClusterInfo, SMonVgr
desc.vgroup_id = pVgroup->vgId; desc.vgroup_id = pVgroup->vgId;
SName name = {0}; SName name = {0};
tNameFromString(&name, pVgroup->dbName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); (void)tNameFromString(&name, pVgroup->dbName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
tNameGetDbName(&name, desc.database_name); (void)tNameGetDbName(&name, desc.database_name);
desc.tables_num = pVgroup->numOfTables; desc.tables_num = pVgroup->numOfTables;
pGrantInfo->timeseries_used += pVgroup->numOfTimeSeries; pGrantInfo->timeseries_used += pVgroup->numOfTimeSeries;
@ -1039,7 +1051,7 @@ int32_t mndGetMonitorInfo(SMnode *pMnode, SMonClusterInfo *pClusterInfo, SMonVgr
pClusterInfo->vnodes_total++; pClusterInfo->vnodes_total++;
} }
taosArrayPush(pVgroupInfo->vgroups, &desc); (void)taosArrayPush(pVgroupInfo->vgroups, &desc);
sdbRelease(pSdb, pVgroup); sdbRelease(pSdb, pVgroup);
} }
@ -1053,14 +1065,14 @@ int32_t mndGetMonitorInfo(SMnode *pMnode, SMonClusterInfo *pClusterInfo, SMonVgr
SMonStbDesc desc = {0}; SMonStbDesc desc = {0};
SName name1 = {0}; SName name1 = {0};
tNameFromString(&name1, pStb->db, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); (void)tNameFromString(&name1, pStb->db, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
tNameGetDbName(&name1, desc.database_name); (void)tNameGetDbName(&name1, desc.database_name);
SName name2 = {0}; SName name2 = {0};
tNameFromString(&name2, pStb->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); (void)tNameFromString(&name2, pStb->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
tstrncpy(desc.stb_name, tNameGetTableName(&name2), TSDB_TABLE_NAME_LEN); tstrncpy(desc.stb_name, tNameGetTableName(&name2), TSDB_TABLE_NAME_LEN);
taosArrayPush(pStbInfo->stbs, &desc); (void)taosArrayPush(pStbInfo->stbs, &desc);
sdbRelease(pSdb, pStb); sdbRelease(pSdb, pStb);
} }
@ -1096,12 +1108,12 @@ void mndSetRestored(SMnode *pMnode, bool restored) {
if (restored) { if (restored) {
taosThreadRwlockWrlock(&pMnode->lock); taosThreadRwlockWrlock(&pMnode->lock);
pMnode->restored = true; pMnode->restored = true;
taosThreadRwlockUnlock(&pMnode->lock); (void)taosThreadRwlockUnlock(&pMnode->lock);
mInfo("mnode set restored:%d", restored); mInfo("mnode set restored:%d", restored);
} else { } else {
taosThreadRwlockWrlock(&pMnode->lock); taosThreadRwlockWrlock(&pMnode->lock);
pMnode->restored = false; pMnode->restored = false;
taosThreadRwlockUnlock(&pMnode->lock); (void)taosThreadRwlockUnlock(&pMnode->lock);
mInfo("mnode set restored:%d", restored); mInfo("mnode set restored:%d", restored);
while (1) { while (1) {
if (pMnode->rpcRef <= 0) break; if (pMnode->rpcRef <= 0) break;
@ -1115,7 +1127,7 @@ bool mndGetRestored(SMnode *pMnode) { return pMnode->restored; }
void mndSetStop(SMnode *pMnode) { void mndSetStop(SMnode *pMnode) {
taosThreadRwlockWrlock(&pMnode->lock); taosThreadRwlockWrlock(&pMnode->lock);
pMnode->stopped = true; pMnode->stopped = true;
taosThreadRwlockUnlock(&pMnode->lock); (void)taosThreadRwlockUnlock(&pMnode->lock);
mInfo("mnode set stopped"); mInfo("mnode set stopped");
} }

22
source/dnode/mnode/impl/src/mndMnode.c
View File

@ -270,7 +270,7 @@ void mndGetMnodeEpSet(SMnode *pMnode, SEpSet *pEpSet) {
} }
} }
if (pObj->pDnode != NULL) { if (pObj->pDnode != NULL) {
addEpIntoEpSet(pEpSet, pObj->pDnode->fqdn, pObj->pDnode->port); (void)addEpIntoEpSet(pEpSet, pObj->pDnode->fqdn, pObj->pDnode->port);
} }
sdbRelease(pSdb, pObj); sdbRelease(pSdb, pObj);
} }
@ -341,7 +341,7 @@ static int32_t mndBuildCreateMnodeRedoAction(STrans *pTrans, SDCreateMnodeReq *p
int32_t code = 0; int32_t code = 0;
int32_t contLen = tSerializeSDCreateMnodeReq(NULL, 0, pCreateReq); int32_t contLen = tSerializeSDCreateMnodeReq(NULL, 0, pCreateReq);
void *pReq = taosMemoryMalloc(contLen); void *pReq = taosMemoryMalloc(contLen);
tSerializeSDCreateMnodeReq(pReq, contLen, pCreateReq); (void)tSerializeSDCreateMnodeReq(pReq, contLen, pCreateReq);
STransAction action = { STransAction action = {
.epSet = *pCreateEpSet, .epSet = *pCreateEpSet,
@ -363,7 +363,7 @@ static int32_t mndBuildAlterMnodeTypeRedoAction(STrans *pTrans, SDAlterMnodeType
int32_t code = 0; int32_t code = 0;
int32_t contLen = tSerializeSDCreateMnodeReq(NULL, 0, pAlterMnodeTypeReq); int32_t contLen = tSerializeSDCreateMnodeReq(NULL, 0, pAlterMnodeTypeReq);
void *pReq = taosMemoryMalloc(contLen); void *pReq = taosMemoryMalloc(contLen);
tSerializeSDCreateMnodeReq(pReq, contLen, pAlterMnodeTypeReq); (void)tSerializeSDCreateMnodeReq(pReq, contLen, pAlterMnodeTypeReq);
STransAction action = { STransAction action = {
.epSet = *pAlterMnodeTypeEpSet, .epSet = *pAlterMnodeTypeEpSet,
@ -385,7 +385,7 @@ static int32_t mndBuildAlterMnodeRedoAction(STrans *pTrans, SDCreateMnodeReq *pA
int32_t code = 0; int32_t code = 0;
int32_t contLen = tSerializeSDCreateMnodeReq(NULL, 0, pAlterReq); int32_t contLen = tSerializeSDCreateMnodeReq(NULL, 0, pAlterReq);
void *pReq = taosMemoryMalloc(contLen); void *pReq = taosMemoryMalloc(contLen);
tSerializeSDCreateMnodeReq(pReq, contLen, pAlterReq); (void)tSerializeSDCreateMnodeReq(pReq, contLen, pAlterReq);
STransAction action = { STransAction action = {
.epSet = *pAlterEpSet, .epSet = *pAlterEpSet,
@ -407,7 +407,7 @@ static int32_t mndBuildDropMnodeRedoAction(STrans *pTrans, SDDropMnodeReq *pDrop
int32_t code = 0; int32_t code = 0;
int32_t contLen = tSerializeSCreateDropMQSNodeReq(NULL, 0, pDropReq); int32_t contLen = tSerializeSCreateDropMQSNodeReq(NULL, 0, pDropReq);
void *pReq = taosMemoryMalloc(contLen); void *pReq = taosMemoryMalloc(contLen);
tSerializeSCreateDropMQSNodeReq(pReq, contLen, pDropReq); (void)tSerializeSCreateDropMQSNodeReq(pReq, contLen, pDropReq);
STransAction action = { STransAction action = {
.epSet = *pDroprEpSet, .epSet = *pDroprEpSet,
@ -881,13 +881,13 @@ static int32_t mndRetrieveMnodes(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pB
cols = 0; cols = 0;
SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)&pObj->id, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pObj->id, false);
char b1[TSDB_EP_LEN + VARSTR_HEADER_SIZE] = {0}; char b1[TSDB_EP_LEN + VARSTR_HEADER_SIZE] = {0};
STR_WITH_MAXSIZE_TO_VARSTR(b1, pObj->pDnode->ep, TSDB_EP_LEN + VARSTR_HEADER_SIZE); STR_WITH_MAXSIZE_TO_VARSTR(b1, pObj->pDnode->ep, TSDB_EP_LEN + VARSTR_HEADER_SIZE);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, b1, false); (void)colDataSetVal(pColInfo, numOfRows, b1, false);
char role[20] = "offline"; char role[20] = "offline";
if (pObj->id == pMnode->selfDnodeId) { if (pObj->id == pMnode->selfDnodeId) {
@ -904,7 +904,7 @@ static int32_t mndRetrieveMnodes(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pB
char b2[12 + VARSTR_HEADER_SIZE] = {0}; char b2[12 + VARSTR_HEADER_SIZE] = {0};
STR_WITH_MAXSIZE_TO_VARSTR(b2, role, pShow->pMeta->pSchemas[cols].bytes); STR_WITH_MAXSIZE_TO_VARSTR(b2, role, pShow->pMeta->pSchemas[cols].bytes);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)b2, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)b2, false);
const char *status = "ready"; const char *status = "ready";
if (objStatus == SDB_STATUS_CREATING) status = "creating"; if (objStatus == SDB_STATUS_CREATING) status = "creating";
@ -913,14 +913,14 @@ static int32_t mndRetrieveMnodes(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pB
char b3[9 + VARSTR_HEADER_SIZE] = {0}; char b3[9 + VARSTR_HEADER_SIZE] = {0};
STR_WITH_MAXSIZE_TO_VARSTR(b3, status, pShow->pMeta->pSchemas[cols].bytes); STR_WITH_MAXSIZE_TO_VARSTR(b3, status, pShow->pMeta->pSchemas[cols].bytes);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)b3, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)b3, false);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)&pObj->createdTime, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pObj->createdTime, false);
int64_t roleTimeMs = (isDnodeOnline) ? pObj->roleTimeMs : 0; int64_t roleTimeMs = (isDnodeOnline) ? pObj->roleTimeMs : 0;
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)&roleTimeMs, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)&roleTimeMs, false);
numOfRows++; numOfRows++;
sdbRelease(pSdb, pObj); sdbRelease(pSdb, pObj);

136
source/dnode/mnode/impl/src/mndProfile.c
View File

@ -263,7 +263,7 @@ static int32_t mndProcessConnectReq(SRpcMsg *pReq) {
if (connReq.db[0]) { if (connReq.db[0]) {
char db[TSDB_DB_FNAME_LEN] = {0}; char db[TSDB_DB_FNAME_LEN] = {0};
snprintf(db, TSDB_DB_FNAME_LEN, "%d%s%s", pUser->acctId, TS_PATH_DELIMITER, connReq.db); (void)snprintf(db, TSDB_DB_FNAME_LEN, "%d%s%s", pUser->acctId, TS_PATH_DELIMITER, connReq.db);
pDb = mndAcquireDb(pMnode, db); pDb = mndAcquireDb(pMnode, db);
if (pDb == NULL) { if (pDb == NULL) {
if (0 != strcmp(connReq.db, TSDB_INFORMATION_SCHEMA_DB) && if (0 != strcmp(connReq.db, TSDB_INFORMATION_SCHEMA_DB) &&
@ -307,9 +307,9 @@ static int32_t mndProcessConnectReq(SRpcMsg *pReq) {
tstrncpy(connectRsp.monitorParas.tsSlowLogExceptDb, tsSlowLogExceptDb, TSDB_DB_NAME_LEN); tstrncpy(connectRsp.monitorParas.tsSlowLogExceptDb, tsSlowLogExceptDb, TSDB_DB_NAME_LEN);
connectRsp.whiteListVer = pUser->ipWhiteListVer; connectRsp.whiteListVer = pUser->ipWhiteListVer;
strcpy(connectRsp.sVer, version); (void)strcpy(connectRsp.sVer, version);
snprintf(connectRsp.sDetailVer, sizeof(connectRsp.sDetailVer), "ver:%s\nbuild:%s\ngitinfo:%s", version, buildinfo, (void)snprintf(connectRsp.sDetailVer, sizeof(connectRsp.sDetailVer), "ver:%s\nbuild:%s\ngitinfo:%s", version,
gitinfo); buildinfo, gitinfo);
mndGetMnodeEpSet(pMnode, &connectRsp.epSet); mndGetMnodeEpSet(pMnode, &connectRsp.epSet);
int32_t contLen = tSerializeSConnectRsp(NULL, 0, &connectRsp); int32_t contLen = tSerializeSConnectRsp(NULL, 0, &connectRsp);
@ -335,7 +335,7 @@ static int32_t mndProcessConnectReq(SRpcMsg *pReq) {
code = 0; code = 0;
char detail[1000] = {0}; char detail[1000] = {0};
sprintf(detail, "app:%s", connReq.app); (void)sprintf(detail, "app:%s", connReq.app);
auditRecord(pReq, pMnode->clusterId, "login", "", "", detail, strlen(detail)); auditRecord(pReq, pMnode->clusterId, "login", "", "", detail, strlen(detail));
@ -371,9 +371,9 @@ static SAppObj *mndCreateApp(SMnode *pMnode, uint32_t clientIp, SAppHbReq *pReq)
app.appId = pReq->appId; app.appId = pReq->appId;
app.ip = clientIp; app.ip = clientIp;
app.pid = pReq->pid; app.pid = pReq->pid;
strcpy(app.name, pReq->name); (void)strcpy(app.name, pReq->name);
app.startTime = pReq->startTime; app.startTime = pReq->startTime;
memcpy(&app.summary, &pReq->summary, sizeof(pReq->summary)); (void)memcpy(&app.summary, &pReq->summary, sizeof(pReq->summary));
app.lastAccessTimeMs = taosGetTimestampMs(); app.lastAccessTimeMs = taosGetTimestampMs();
const int32_t keepTime = tsShellActivityTimer * 3; const int32_t keepTime = tsShellActivityTimer * 3;
@ -456,7 +456,7 @@ static int32_t mndUpdateAppInfo(SMnode *pMnode, SClientHbReq *pHbReq, SRpcConnIn
} }
} }
memcpy(&pApp->summary, &pReq->summary, sizeof(pReq->summary)); (void)memcpy(&pApp->summary, &pReq->summary, sizeof(pReq->summary));
mndReleaseApp(pMnode, pApp); mndReleaseApp(pMnode, pApp);
@ -492,7 +492,7 @@ static int32_t mndProcessQueryHeartBeat(SMnode *pMnode, SRpcMsg *pMsg, SClientHb
SRpcConnInfo connInfo = pMsg->info.conn; SRpcConnInfo connInfo = pMsg->info.conn;
if (0 != pHbReq->app.appId) { if (0 != pHbReq->app.appId) {
mndUpdateAppInfo(pMnode, pHbReq, &connInfo); TAOS_CHECK_RETURN(mndUpdateAppInfo(pMnode, pHbReq, &connInfo));
} }
if (pHbReq->query) { if (pHbReq->query) {
@ -520,7 +520,7 @@ static int32_t mndProcessQueryHeartBeat(SMnode *pMnode, SRpcMsg *pMsg, SClientHb
TAOS_RETURN(code); TAOS_RETURN(code);
} }
mndSaveQueryList(pConn, pBasic); TAOS_CHECK_RETURN(mndSaveQueryList(pConn, pBasic));
if (pConn->killed != 0) { if (pConn->killed != 0) {
rspBasic->killConnection = 1; rspBasic->killConnection = 1;
} }
@ -546,7 +546,8 @@ static int32_t mndProcessQueryHeartBeat(SMnode *pMnode, SRpcMsg *pMsg, SClientHb
int32_t kvNum = taosHashGetSize(pHbReq->info); int32_t kvNum = taosHashGetSize(pHbReq->info);
if (NULL == pHbReq->info || kvNum <= 0) { if (NULL == pHbReq->info || kvNum <= 0) {
taosArrayPush(pBatchRsp->rsps, &hbRsp); // TODO return value
(void)taosArrayPush(pBatchRsp->rsps, &hbRsp);
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
@ -589,31 +590,31 @@ static int32_t mndProcessQueryHeartBeat(SMnode *pMnode, SRpcMsg *pMsg, SClientHb
case HEARTBEAT_KEY_USER_AUTHINFO: { case HEARTBEAT_KEY_USER_AUTHINFO: {
void *rspMsg = NULL; void *rspMsg = NULL;
int32_t rspLen = 0; int32_t rspLen = 0;
mndValidateUserAuthInfo(pMnode, kv->value, kv->valueLen / sizeof(SUserAuthVersion), &rspMsg, &rspLen, (void)mndValidateUserAuthInfo(pMnode, kv->value, kv->valueLen / sizeof(SUserAuthVersion), &rspMsg, &rspLen,
pObj->ipWhiteListVer); pObj->ipWhiteListVer);
if (rspMsg && rspLen > 0) { if (rspMsg && rspLen > 0) {
SKv kv1 = {.key = HEARTBEAT_KEY_USER_AUTHINFO, .valueLen = rspLen, .value = rspMsg}; SKv kv1 = {.key = HEARTBEAT_KEY_USER_AUTHINFO, .valueLen = rspLen, .value = rspMsg};
taosArrayPush(hbRsp.info, &kv1); (void)taosArrayPush(hbRsp.info, &kv1);
} }
break; break;
} }
case HEARTBEAT_KEY_DBINFO: { case HEARTBEAT_KEY_DBINFO: {
void *rspMsg = NULL; void *rspMsg = NULL;
int32_t rspLen = 0; int32_t rspLen = 0;
mndValidateDbInfo(pMnode, kv->value, kv->valueLen / sizeof(SDbCacheInfo), &rspMsg, &rspLen); (void)mndValidateDbInfo(pMnode, kv->value, kv->valueLen / sizeof(SDbCacheInfo), &rspMsg, &rspLen);
if (rspMsg && rspLen > 0) { if (rspMsg && rspLen > 0) {
SKv kv1 = {.key = HEARTBEAT_KEY_DBINFO, .valueLen = rspLen, .value = rspMsg}; SKv kv1 = {.key = HEARTBEAT_KEY_DBINFO, .valueLen = rspLen, .value = rspMsg};
taosArrayPush(hbRsp.info, &kv1); (void)taosArrayPush(hbRsp.info, &kv1);
} }
break; break;
} }
case HEARTBEAT_KEY_STBINFO: { case HEARTBEAT_KEY_STBINFO: {
void *rspMsg = NULL; void *rspMsg = NULL;
int32_t rspLen = 0; int32_t rspLen = 0;
mndValidateStbInfo(pMnode, kv->value, kv->valueLen / sizeof(SSTableVersion), &rspMsg, &rspLen); (void)mndValidateStbInfo(pMnode, kv->value, kv->valueLen / sizeof(SSTableVersion), &rspMsg, &rspLen);
if (rspMsg && rspLen > 0) { if (rspMsg && rspLen > 0) {
SKv kv1 = {.key = HEARTBEAT_KEY_STBINFO, .valueLen = rspLen, .value = rspMsg}; SKv kv1 = {.key = HEARTBEAT_KEY_STBINFO, .valueLen = rspLen, .value = rspMsg};
taosArrayPush(hbRsp.info, &kv1); (void)taosArrayPush(hbRsp.info, &kv1);
} }
break; break;
} }
@ -628,10 +629,10 @@ static int32_t mndProcessQueryHeartBeat(SMnode *pMnode, SRpcMsg *pMsg, SClientHb
void *rspMsg = NULL; void *rspMsg = NULL;
int32_t rspLen = 0; int32_t rspLen = 0;
mndValidateViewInfo(pMnode, kv->value, kv->valueLen / sizeof(SViewVersion), &rspMsg, &rspLen); (void)mndValidateViewInfo(pMnode, kv->value, kv->valueLen / sizeof(SViewVersion), &rspMsg, &rspLen);
if (rspMsg && rspLen > 0) { if (rspMsg && rspLen > 0) {
SKv kv1 = {.key = HEARTBEAT_KEY_VIEWINFO, .valueLen = rspLen, .value = rspMsg}; SKv kv1 = {.key = HEARTBEAT_KEY_VIEWINFO, .valueLen = rspLen, .value = rspMsg};
taosArrayPush(hbRsp.info, &kv1); (void)taosArrayPush(hbRsp.info, &kv1);
} }
break; break;
} }
@ -639,10 +640,10 @@ static int32_t mndProcessQueryHeartBeat(SMnode *pMnode, SRpcMsg *pMsg, SClientHb
case HEARTBEAT_KEY_TSMA: { case HEARTBEAT_KEY_TSMA: {
void *rspMsg = NULL; void *rspMsg = NULL;
int32_t rspLen = 0; int32_t rspLen = 0;
mndValidateTSMAInfo(pMnode, kv->value, kv->valueLen / sizeof(STSMAVersion), &rspMsg, &rspLen); (void)mndValidateTSMAInfo(pMnode, kv->value, kv->valueLen / sizeof(STSMAVersion), &rspMsg, &rspLen);
if (rspMsg && rspLen > 0) { if (rspMsg && rspLen > 0) {
SKv kv = {.key = HEARTBEAT_KEY_TSMA, .valueLen = rspLen, .value = rspMsg}; SKv kv = {.key = HEARTBEAT_KEY_TSMA, .valueLen = rspLen, .value = rspMsg};
taosArrayPush(hbRsp.info, &kv); (void)taosArrayPush(hbRsp.info, &kv);
} }
break; break;
} }
@ -655,9 +656,10 @@ static int32_t mndProcessQueryHeartBeat(SMnode *pMnode, SRpcMsg *pMsg, SClientHb
pIter = taosHashIterate(pHbReq->info, pIter); pIter = taosHashIterate(pHbReq->info, pIter);
} }
taosArrayPush(pBatchRsp->rsps, &hbRsp); if (taosArrayPush(pBatchRsp->rsps, &hbRsp) == NULL) {
if (terrno != 0) code = terrno;
return TSDB_CODE_SUCCESS; }
TAOS_RETURN(code);
} }
static int32_t mndProcessHeartBeatReq(SRpcMsg *pReq) { static int32_t mndProcessHeartBeatReq(SRpcMsg *pReq) {
@ -675,9 +677,9 @@ static int32_t mndProcessHeartBeatReq(SRpcMsg *pReq) {
SConnPreparedObj obj = {0}; SConnPreparedObj obj = {0};
obj.totalDnodes = mndGetDnodeSize(pMnode); obj.totalDnodes = mndGetDnodeSize(pMnode);
obj.ipWhiteListVer = batchReq.ipWhiteList; obj.ipWhiteListVer = batchReq.ipWhiteList;
mndGetOnlineDnodeNum(pMnode, &obj.onlineDnodes); TAOS_CHECK_RETURN(mndGetOnlineDnodeNum(pMnode, &obj.onlineDnodes));
mndGetMnodeEpSet(pMnode, &obj.epSet); mndGetMnodeEpSet(pMnode, &obj.epSet);
mndCreateQnodeList(pMnode, &obj.pQnodeList, -1); TAOS_CHECK_RETURN(mndCreateQnodeList(pMnode, &obj.pQnodeList, -1));
SClientHbBatchRsp batchRsp = {0}; SClientHbBatchRsp batchRsp = {0};
batchRsp.svrTimestamp = taosGetTimestampSec(); batchRsp.svrTimestamp = taosGetTimestampSec();
@ -845,32 +847,32 @@ static int32_t mndRetrieveConns(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBl
cols = 0; cols = 0;
SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)&pConn->id, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pConn->id, false);
char user[TSDB_USER_LEN + VARSTR_HEADER_SIZE] = {0}; char user[TSDB_USER_LEN + VARSTR_HEADER_SIZE] = {0};
STR_TO_VARSTR(user, pConn->user); STR_TO_VARSTR(user, pConn->user);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)user, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)user, false);
char app[TSDB_APP_NAME_LEN + VARSTR_HEADER_SIZE]; char app[TSDB_APP_NAME_LEN + VARSTR_HEADER_SIZE];
STR_TO_VARSTR(app, pConn->app); STR_TO_VARSTR(app, pConn->app);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)app, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)app, false);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)&pConn->pid, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pConn->pid, false);
char endpoint[TSDB_IPv4ADDR_LEN + 6 + VARSTR_HEADER_SIZE] = {0}; char endpoint[TSDB_IPv4ADDR_LEN + 6 + VARSTR_HEADER_SIZE] = {0};
sprintf(&endpoint[VARSTR_HEADER_SIZE], "%s:%d", taosIpStr(pConn->ip), pConn->port); (void)sprintf(&endpoint[VARSTR_HEADER_SIZE], "%s:%d", taosIpStr(pConn->ip), pConn->port);
varDataLen(endpoint) = strlen(&endpoint[VARSTR_HEADER_SIZE]); varDataLen(endpoint) = strlen(&endpoint[VARSTR_HEADER_SIZE]);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)endpoint, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)endpoint, false);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)&pConn->loginTimeMs, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pConn->loginTimeMs, false);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)&pConn->lastAccessTimeMs, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pConn->lastAccessTimeMs, false);
numOfRows++; numOfRows++;
} }
@ -903,50 +905,50 @@ static int32_t packQueriesIntoBlock(SShowObj *pShow, SConnObj *pConn, SSDataBloc
cols = 0; cols = 0;
char queryId[26 + VARSTR_HEADER_SIZE] = {0}; char queryId[26 + VARSTR_HEADER_SIZE] = {0};
sprintf(&queryId[VARSTR_HEADER_SIZE], "%x:%" PRIx64, pConn->id, pQuery->reqRid); (void)sprintf(&queryId[VARSTR_HEADER_SIZE], "%x:%" PRIx64, pConn->id, pQuery->reqRid);
varDataLen(queryId) = strlen(&queryId[VARSTR_HEADER_SIZE]); varDataLen(queryId) = strlen(&queryId[VARSTR_HEADER_SIZE]);
SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, curRowIndex, (const char *)queryId, false); (void)colDataSetVal(pColInfo, curRowIndex, (const char *)queryId, false);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, curRowIndex, (const char *)&pQuery->queryId, false); (void)colDataSetVal(pColInfo, curRowIndex, (const char *)&pQuery->queryId, false);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, curRowIndex, (const char *)&pConn->id, false); (void)colDataSetVal(pColInfo, curRowIndex, (const char *)&pConn->id, false);
char app[TSDB_APP_NAME_LEN + VARSTR_HEADER_SIZE]; char app[TSDB_APP_NAME_LEN + VARSTR_HEADER_SIZE];
STR_TO_VARSTR(app, pConn->app); STR_TO_VARSTR(app, pConn->app);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, curRowIndex, (const char *)app, false); (void)colDataSetVal(pColInfo, curRowIndex, (const char *)app, false);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, curRowIndex, (const char *)&pConn->pid, false); (void)colDataSetVal(pColInfo, curRowIndex, (const char *)&pConn->pid, false);
char user[TSDB_USER_LEN + VARSTR_HEADER_SIZE] = {0}; char user[TSDB_USER_LEN + VARSTR_HEADER_SIZE] = {0};
STR_TO_VARSTR(user, pConn->user); STR_TO_VARSTR(user, pConn->user);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, curRowIndex, (const char *)user, false); (void)colDataSetVal(pColInfo, curRowIndex, (const char *)user, false);
char endpoint[TSDB_IPv4ADDR_LEN + 6 + VARSTR_HEADER_SIZE] = {0}; char endpoint[TSDB_IPv4ADDR_LEN + 6 + VARSTR_HEADER_SIZE] = {0};
sprintf(&endpoint[VARSTR_HEADER_SIZE], "%s:%d", taosIpStr(pConn->ip), pConn->port); (void)sprintf(&endpoint[VARSTR_HEADER_SIZE], "%s:%d", taosIpStr(pConn->ip), pConn->port);
varDataLen(endpoint) = strlen(&endpoint[VARSTR_HEADER_SIZE]); varDataLen(endpoint) = strlen(&endpoint[VARSTR_HEADER_SIZE]);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, curRowIndex, (const char *)endpoint, false); (void)colDataSetVal(pColInfo, curRowIndex, (const char *)endpoint, false);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, curRowIndex, (const char *)&pQuery->stime, false); (void)colDataSetVal(pColInfo, curRowIndex, (const char *)&pQuery->stime, false);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, curRowIndex, (const char *)&pQuery->useconds, false); (void)colDataSetVal(pColInfo, curRowIndex, (const char *)&pQuery->useconds, false);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, curRowIndex, (const char *)&pQuery->stableQuery, false); (void)colDataSetVal(pColInfo, curRowIndex, (const char *)&pQuery->stableQuery, false);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, curRowIndex, (const char *)&pQuery->isSubQuery, false); (void)colDataSetVal(pColInfo, curRowIndex, (const char *)&pQuery->isSubQuery, false);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, curRowIndex, (const char *)&pQuery->subPlanNum, false); (void)colDataSetVal(pColInfo, curRowIndex, (const char *)&pQuery->subPlanNum, false);
char subStatus[TSDB_SHOW_SUBQUERY_LEN + VARSTR_HEADER_SIZE] = {0}; char subStatus[TSDB_SHOW_SUBQUERY_LEN + VARSTR_HEADER_SIZE] = {0};
int64_t reserve = 64; int64_t reserve = 64;
@ -965,12 +967,12 @@ static int32_t packQueriesIntoBlock(SShowObj *pShow, SConnObj *pConn, SSDataBloc
} }
varDataLen(subStatus) = strlen(&subStatus[VARSTR_HEADER_SIZE]); varDataLen(subStatus) = strlen(&subStatus[VARSTR_HEADER_SIZE]);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, curRowIndex, subStatus, (varDataLen(subStatus) == 0) ? true : false); (void)colDataSetVal(pColInfo, curRowIndex, subStatus, (varDataLen(subStatus) == 0) ? true : false);
char sql[TSDB_SHOW_SQL_LEN + VARSTR_HEADER_SIZE] = {0}; char sql[TSDB_SHOW_SQL_LEN + VARSTR_HEADER_SIZE] = {0};
STR_TO_VARSTR(sql, pQuery->sql); STR_TO_VARSTR(sql, pQuery->sql);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, curRowIndex, (const char *)sql, false); (void)colDataSetVal(pColInfo, curRowIndex, (const char *)sql, false);
pBlock->info.rows++; pBlock->info.rows++;
} }
@ -1037,55 +1039,55 @@ static int32_t mndRetrieveApps(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlo
cols = 0; cols = 0;
SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->appId, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->appId, false);
char ip[TSDB_IPv4ADDR_LEN + 6 + VARSTR_HEADER_SIZE] = {0}; char ip[TSDB_IPv4ADDR_LEN + 6 + VARSTR_HEADER_SIZE] = {0};
sprintf(&ip[VARSTR_HEADER_SIZE], "%s", taosIpStr(pApp->ip)); (void)sprintf(&ip[VARSTR_HEADER_SIZE], "%s", taosIpStr(pApp->ip));
varDataLen(ip) = strlen(&ip[VARSTR_HEADER_SIZE]); varDataLen(ip) = strlen(&ip[VARSTR_HEADER_SIZE]);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)ip, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)ip, false);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->pid, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->pid, false);
char name[TSDB_APP_NAME_LEN + 6 + VARSTR_HEADER_SIZE] = {0}; char name[TSDB_APP_NAME_LEN + 6 + VARSTR_HEADER_SIZE] = {0};
sprintf(&name[VARSTR_HEADER_SIZE], "%s", pApp->name); (void)sprintf(&name[VARSTR_HEADER_SIZE], "%s", pApp->name);
varDataLen(name) = strlen(&name[VARSTR_HEADER_SIZE]); varDataLen(name) = strlen(&name[VARSTR_HEADER_SIZE]);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)name, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)name, false);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->startTime, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->startTime, false);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->summary.numOfInsertsReq, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->summary.numOfInsertsReq, false);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->summary.numOfInsertRows, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->summary.numOfInsertRows, false);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->summary.insertElapsedTime, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->summary.insertElapsedTime, false);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->summary.insertBytes, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->summary.insertBytes, false);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->summary.fetchBytes, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->summary.fetchBytes, false);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->summary.queryElapsedTime, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->summary.queryElapsedTime, false);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->summary.numOfSlowQueries, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->summary.numOfSlowQueries, false);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->summary.totalRequests, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->summary.totalRequests, false);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->summary.currentRequests, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->summary.currentRequests, false);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->lastAccessTimeMs, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pApp->lastAccessTimeMs, false);
numOfRows++; numOfRows++;
} }

12
source/dnode/mnode/impl/src/mndSnode.c
View File

@ -223,7 +223,7 @@ static int32_t mndSetCreateSnodeRedoActions(STrans *pTrans, SDnodeObj *pDnode, S
code = TSDB_CODE_OUT_OF_MEMORY; code = TSDB_CODE_OUT_OF_MEMORY;
TAOS_RETURN(code); TAOS_RETURN(code);
} }
tSerializeSCreateDropMQSNodeReq(pReq, contLen, &createReq); (void)tSerializeSCreateDropMQSNodeReq(pReq, contLen, &createReq);
STransAction action = {0}; STransAction action = {0};
action.epSet = mndGetDnodeEpset(pDnode); action.epSet = mndGetDnodeEpset(pDnode);
@ -251,7 +251,7 @@ static int32_t mndSetCreateSnodeUndoActions(STrans *pTrans, SDnodeObj *pDnode, S
code = TSDB_CODE_OUT_OF_MEMORY; code = TSDB_CODE_OUT_OF_MEMORY;
TAOS_RETURN(code); TAOS_RETURN(code);
} }
tSerializeSCreateDropMQSNodeReq(pReq, contLen, &dropReq); (void)tSerializeSCreateDropMQSNodeReq(pReq, contLen, &dropReq);
STransAction action = {0}; STransAction action = {0};
action.epSet = mndGetDnodeEpset(pDnode); action.epSet = mndGetDnodeEpset(pDnode);
@ -383,7 +383,7 @@ static int32_t mndSetDropSnodeRedoActions(STrans *pTrans, SDnodeObj *pDnode, SSn
code = TSDB_CODE_OUT_OF_MEMORY; code = TSDB_CODE_OUT_OF_MEMORY;
TAOS_RETURN(code); TAOS_RETURN(code);
} }
tSerializeSCreateDropMQSNodeReq(pReq, contLen, &dropReq); (void)tSerializeSCreateDropMQSNodeReq(pReq, contLen, &dropReq);
STransAction action = {0}; STransAction action = {0};
action.epSet = mndGetDnodeEpset(pDnode); action.epSet = mndGetDnodeEpset(pDnode);
@ -482,16 +482,16 @@ static int32_t mndRetrieveSnodes(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pB
cols = 0; cols = 0;
SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)&pObj->id, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pObj->id, false);
char ep[TSDB_EP_LEN + VARSTR_HEADER_SIZE] = {0}; char ep[TSDB_EP_LEN + VARSTR_HEADER_SIZE] = {0};
STR_WITH_MAXSIZE_TO_VARSTR(ep, pObj->pDnode->ep, pShow->pMeta->pSchemas[cols].bytes); STR_WITH_MAXSIZE_TO_VARSTR(ep, pObj->pDnode->ep, pShow->pMeta->pSchemas[cols].bytes);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)ep, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)ep, false);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)&pObj->createdTime, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pObj->createdTime, false);
numOfRows++; numOfRows++;
sdbRelease(pSdb, pObj); sdbRelease(pSdb, pObj);

203
source/dnode/mnode/impl/src/mndStb.c
View File

@ -278,7 +278,7 @@ static SSdbRow *mndStbActionDecode(SSdbRaw *pRaw) {
for (int32_t i = 0; i < pStb->numOfFuncs; ++i) { for (int32_t i = 0; i < pStb->numOfFuncs; ++i) {
char funcName[TSDB_FUNC_NAME_LEN] = {0}; char funcName[TSDB_FUNC_NAME_LEN] = {0};
SDB_GET_BINARY(pRaw, dataPos, funcName, TSDB_FUNC_NAME_LEN, _OVER) SDB_GET_BINARY(pRaw, dataPos, funcName, TSDB_FUNC_NAME_LEN, _OVER)
taosArrayPush(pStb->pFuncs, funcName); (void)taosArrayPush(pStb->pFuncs, funcName);
} }
if (pStb->commentLen > 0) { if (pStb->commentLen > 0) {
@ -479,10 +479,10 @@ void mndReleaseStb(SMnode *pMnode, SStbObj *pStb) {
SDbObj *mndAcquireDbByStb(SMnode *pMnode, const char *stbName) { SDbObj *mndAcquireDbByStb(SMnode *pMnode, const char *stbName) {
SName name = {0}; SName name = {0};
tNameFromString(&name, stbName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); if ((terrno = tNameFromString(&name, stbName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE)) != 0) return NULL;
char db[TSDB_TABLE_FNAME_LEN] = {0}; char db[TSDB_TABLE_FNAME_LEN] = {0};
tNameGetFullDbName(&name, db); (void)tNameGetFullDbName(&name, db);
return mndAcquireDb(pMnode, db); return mndAcquireDb(pMnode, db);
} }
@ -503,9 +503,11 @@ void *mndBuildVCreateStbReq(SMnode *pMnode, SVgObj *pVgroup, SStbObj *pStb, int3
SName name = {0}; SName name = {0};
SVCreateStbReq req = {0}; SVCreateStbReq req = {0};
tNameFromString(&name, pStb->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); if ((terrno = tNameFromString(&name, pStb->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE)) != 0) {
goto _err;
}
char dbFName[TSDB_DB_FNAME_LEN] = {0}; char dbFName[TSDB_DB_FNAME_LEN] = {0};
tNameGetFullDbName(&name, dbFName); (void)tNameGetFullDbName(&name, dbFName);
req.name = (char *)tNameGetTableName(&name); req.name = (char *)tNameGetTableName(&name);
req.suid = pStb->uid; req.suid = pStb->uid;
@ -600,7 +602,9 @@ static void *mndBuildVDropStbReq(SMnode *pMnode, SVgObj *pVgroup, SStbObj *pStb,
SMsgHead *pHead = NULL; SMsgHead *pHead = NULL;
SEncoder encoder = {0}; SEncoder encoder = {0};
tNameFromString(&name, pStb->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); if ((terrno = tNameFromString(&name, pStb->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE)) != 0) {
return NULL;
}
req.name = (char *)tNameGetTableName(&name); req.name = (char *)tNameGetTableName(&name);
req.suid = pStb->uid; req.suid = pStb->uid;
@ -621,7 +625,7 @@ static void *mndBuildVDropStbReq(SMnode *pMnode, SVgObj *pVgroup, SStbObj *pStb,
void *pBuf = POINTER_SHIFT(pHead, sizeof(SMsgHead)); void *pBuf = POINTER_SHIFT(pHead, sizeof(SMsgHead));
tEncoderInit(&encoder, pBuf, contLen - sizeof(SMsgHead)); tEncoderInit(&encoder, pBuf, contLen - sizeof(SMsgHead));
tEncodeSVDropStbReq(&encoder, &req); (void)tEncodeSVDropStbReq(&encoder, &req);
tEncoderClear(&encoder); tEncoderClear(&encoder);
*pContLen = contLen; *pContLen = contLen;
@ -948,7 +952,9 @@ int32_t mndBuildStbFromReq(SMnode *pMnode, SStbObj *pDst, SMCreateStbReq *pCreat
} }
static int32_t mndGenIdxNameForFirstTag(char *fullname, char *dbname, char *stbname, char *tagname) { static int32_t mndGenIdxNameForFirstTag(char *fullname, char *dbname, char *stbname, char *tagname) {
SName name = {0}; SName name = {0};
tNameFromString(&name, stbname, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); if ((terrno = tNameFromString(&name, stbname, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE)) != 0) {
return -1;
}
return snprintf(fullname, TSDB_INDEX_FNAME_LEN, "%s.%s_%s", dbname, tagname, tNameGetTableName(&name)); return snprintf(fullname, TSDB_INDEX_FNAME_LEN, "%s.%s_%s", dbname, tagname, tNameGetTableName(&name));
} }
@ -969,7 +975,9 @@ static int32_t mndCreateStb(SMnode *pMnode, SRpcMsg *pReq, SMCreateStbReq *pCrea
TAOS_CHECK_GOTO(mndBuildStbFromReq(pMnode, &stbObj, pCreate, pDb), NULL, _OVER); TAOS_CHECK_GOTO(mndBuildStbFromReq(pMnode, &stbObj, pCreate, pDb), NULL, _OVER);
SSchema *pSchema = &(stbObj.pTags[0]); SSchema *pSchema = &(stbObj.pTags[0]);
mndGenIdxNameForFirstTag(fullIdxName, pDb->name, stbObj.name, pSchema->name); if (mndGenIdxNameForFirstTag(fullIdxName, pDb->name, stbObj.name, pSchema->name) < 0) {
goto _OVER;
}
SSIdx idx = {0}; SSIdx idx = {0};
if (mndAcquireGlobalIdx(pMnode, fullIdxName, SDB_IDX, &idx) == 0 && idx.pIdx != NULL) { if (mndAcquireGlobalIdx(pMnode, fullIdxName, SDB_IDX, &idx) == 0 && idx.pIdx != NULL) {
code = TSDB_CODE_MND_TAG_INDEX_ALREADY_EXIST; code = TSDB_CODE_MND_TAG_INDEX_ALREADY_EXIST;
@ -995,7 +1003,7 @@ static int32_t mndCreateStb(SMnode *pMnode, SRpcMsg *pReq, SMCreateStbReq *pCrea
_OVER: _OVER:
mndTransDrop(pTrans); mndTransDrop(pTrans);
mndStbActionDelete(pMnode->pSdb, &stbObj); (void)mndStbActionDelete(pMnode->pSdb, &stbObj);
TAOS_RETURN(code); TAOS_RETURN(code);
} }
@ -1031,7 +1039,7 @@ static int32_t mndProcessTtlTimer(SRpcMsg *pReq) {
} }
pHead->contLen = htonl(contLen); pHead->contLen = htonl(contLen);
pHead->vgId = htonl(pVgroup->vgId); pHead->vgId = htonl(pVgroup->vgId);
tSerializeSVDropTtlTableReq((char *)pHead + sizeof(SMsgHead), reqLen, &ttlReq); (void)tSerializeSVDropTtlTableReq((char *)pHead + sizeof(SMsgHead), reqLen, &ttlReq);
SRpcMsg rpcMsg = { SRpcMsg rpcMsg = {
.msgType = TDMT_VND_FETCH_TTL_EXPIRED_TBS, .pCont = pHead, .contLen = contLen, .info = pReq->info}; .msgType = TDMT_VND_FETCH_TTL_EXPIRED_TBS, .pCont = pHead, .contLen = contLen, .info = pReq->info};
@ -1069,7 +1077,7 @@ static int32_t mndProcessTrimDbTimer(SRpcMsg *pReq) {
} }
pHead->contLen = htonl(contLen); pHead->contLen = htonl(contLen);
pHead->vgId = htonl(pVgroup->vgId); pHead->vgId = htonl(pVgroup->vgId);
tSerializeSVTrimDbReq((char *)pHead + sizeof(SMsgHead), reqLen, &trimReq); (void)tSerializeSVTrimDbReq((char *)pHead + sizeof(SMsgHead), reqLen, &trimReq);
SRpcMsg rpcMsg = {.msgType = TDMT_VND_TRIM, .pCont = pHead, .contLen = contLen}; SRpcMsg rpcMsg = {.msgType = TDMT_VND_TRIM, .pCont = pHead, .contLen = contLen};
SEpSet epSet = mndGetVgroupEpset(pMnode, pVgroup); SEpSet epSet = mndGetVgroupEpset(pMnode, pVgroup);
@ -1106,7 +1114,7 @@ static int32_t mndProcessS3MigrateDbTimer(SRpcMsg *pReq) {
} }
pHead->contLen = htonl(contLen); pHead->contLen = htonl(contLen);
pHead->vgId = htonl(pVgroup->vgId); pHead->vgId = htonl(pVgroup->vgId);
tSerializeSVS3MigrateDbReq((char *)pHead + sizeof(SMsgHead), reqLen, &s3migrateReq); (void)tSerializeSVS3MigrateDbReq((char *)pHead + sizeof(SMsgHead), reqLen, &s3migrateReq);
SRpcMsg rpcMsg = {.msgType = TDMT_VND_S3MIGRATE, .pCont = pHead, .contLen = contLen}; SRpcMsg rpcMsg = {.msgType = TDMT_VND_S3MIGRATE, .pCont = pHead, .contLen = contLen};
SEpSet epSet = mndGetVgroupEpset(pMnode, pVgroup); SEpSet epSet = mndGetVgroupEpset(pMnode, pVgroup);
@ -1335,7 +1343,7 @@ static int32_t mndProcessCreateStbReq(SRpcMsg *pReq) {
if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS; if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;
SName name = {0}; SName name = {0};
tNameFromString(&name, createReq.name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); TAOS_CHECK_RETURN(tNameFromString(&name, createReq.name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE));
if (createReq.sql == NULL && createReq.sqlLen == 0) { if (createReq.sql == NULL && createReq.sqlLen == 0) {
char detail[1000] = {0}; char detail[1000] = {0};
@ -1499,7 +1507,12 @@ static int32_t mndCheckAlterColForTopic(SMnode *pMnode, const char *stbFullName,
} }
SNodeList *pNodeList = NULL; SNodeList *pNodeList = NULL;
nodesCollectColumns((SSelectStmt *)pAst, SQL_CLAUSE_FROM, NULL, COLLECT_COL_TYPE_ALL, &pNodeList); if ((code = nodesCollectColumns((SSelectStmt *)pAst, SQL_CLAUSE_FROM, NULL, COLLECT_COL_TYPE_ALL, &pNodeList)) !=
0) {
sdbRelease(pSdb, pTopic);
sdbCancelFetch(pSdb, pIter);
TAOS_RETURN(code);
}
SNode *pNode = NULL; SNode *pNode = NULL;
FOREACH(pNode, pNodeList) { FOREACH(pNode, pNodeList) {
SColumnNode *pCol = (SColumnNode *)pNode; SColumnNode *pCol = (SColumnNode *)pNode;
@ -1549,7 +1562,13 @@ static int32_t mndCheckAlterColForStream(SMnode *pMnode, const char *stbFullName
} }
SNodeList *pNodeList = NULL; SNodeList *pNodeList = NULL;
nodesCollectColumns((SSelectStmt *)pAst, SQL_CLAUSE_FROM, NULL, COLLECT_COL_TYPE_ALL, &pNodeList); if ((code = nodesCollectColumns((SSelectStmt *)pAst, SQL_CLAUSE_FROM, NULL, COLLECT_COL_TYPE_ALL, &pNodeList)) !=
0) {
sdbRelease(pSdb, pStream);
sdbCancelFetch(pSdb, pIter);
TAOS_RETURN(code);
}
SNode *pNode = NULL; SNode *pNode = NULL;
FOREACH(pNode, pNodeList) { FOREACH(pNode, pNodeList) {
SColumnNode *pCol = (SColumnNode *)pNode; SColumnNode *pCol = (SColumnNode *)pNode;
@ -1600,7 +1619,11 @@ static int32_t mndCheckAlterColForTSma(SMnode *pMnode, const char *stbFullName,
} }
SNodeList *pNodeList = NULL; SNodeList *pNodeList = NULL;
nodesCollectColumns((SSelectStmt *)pAst, SQL_CLAUSE_FROM, NULL, COLLECT_COL_TYPE_ALL, &pNodeList); if ((code = nodesCollectColumns((SSelectStmt *)pAst, SQL_CLAUSE_FROM, NULL, COLLECT_COL_TYPE_ALL, &pNodeList)) !=
0) {
sdbCancelFetch(pSdb, pIter);
TAOS_RETURN(code);
}
SNode *pNode = NULL; SNode *pNode = NULL;
FOREACH(pNode, pNodeList) { FOREACH(pNode, pNodeList) {
SColumnNode *pCol = (SColumnNode *)pNode; SColumnNode *pCol = (SColumnNode *)pNode;
@ -2291,7 +2314,7 @@ static int32_t mndBuildSMAlterStbRsp(SDbObj *pDb, SStbObj *pObj, void **pCont, i
uint32_t contLen = 0; uint32_t contLen = 0;
SMAlterStbRsp alterRsp = {0}; SMAlterStbRsp alterRsp = {0};
SName name = {0}; SName name = {0};
tNameFromString(&name, pObj->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); TAOS_CHECK_RETURN(tNameFromString(&name, pObj->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE));
alterRsp.pMeta = taosMemoryCalloc(1, sizeof(STableMetaRsp)); alterRsp.pMeta = taosMemoryCalloc(1, sizeof(STableMetaRsp));
if (NULL == alterRsp.pMeta) { if (NULL == alterRsp.pMeta) {
@ -2313,7 +2336,7 @@ static int32_t mndBuildSMAlterStbRsp(SDbObj *pDb, SStbObj *pObj, void **pCont, i
void *cont = taosMemoryMalloc(contLen); void *cont = taosMemoryMalloc(contLen);
tEncoderInit(&ec, cont, contLen); tEncoderInit(&ec, cont, contLen);
tEncodeSMAlterStbRsp(&ec, &alterRsp); (void)tEncodeSMAlterStbRsp(&ec, &alterRsp);
tEncoderClear(&ec); tEncoderClear(&ec);
tFreeSMAlterStbRsp(&alterRsp); tFreeSMAlterStbRsp(&alterRsp);
@ -2344,7 +2367,7 @@ int32_t mndBuildSMCreateStbRsp(SMnode *pMnode, char *dbFName, char *stbFName, vo
uint32_t contLen = 0; uint32_t contLen = 0;
SMCreateStbRsp stbRsp = {0}; SMCreateStbRsp stbRsp = {0};
SName name = {0}; SName name = {0};
tNameFromString(&name, pObj->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); TAOS_CHECK_GOTO(tNameFromString(&name, pObj->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE), NULL, _OVER);
stbRsp.pMeta = taosMemoryCalloc(1, sizeof(STableMetaRsp)); stbRsp.pMeta = taosMemoryCalloc(1, sizeof(STableMetaRsp));
if (NULL == stbRsp.pMeta) { if (NULL == stbRsp.pMeta) {
@ -2366,7 +2389,7 @@ int32_t mndBuildSMCreateStbRsp(SMnode *pMnode, char *dbFName, char *stbFName, vo
void *cont = taosMemoryMalloc(contLen); void *cont = taosMemoryMalloc(contLen);
tEncoderInit(&ec, cont, contLen); tEncoderInit(&ec, cont, contLen);
tEncodeSMCreateStbRsp(&ec, &stbRsp); (void)tEncodeSMCreateStbRsp(&ec, &stbRsp);
tEncoderClear(&ec); tEncoderClear(&ec);
tFreeSMCreateStbRsp(&stbRsp); tFreeSMCreateStbRsp(&stbRsp);
@ -2605,6 +2628,7 @@ static int32_t mndProcessAlterStbReq(SRpcMsg *pReq) {
if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS; if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;
SName name = {0}; SName name = {0};
// TODO check return value
tNameFromString(&name, alterReq.name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); tNameFromString(&name, alterReq.name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
auditRecord(pReq, pMnode->clusterId, "alterStb", name.dbname, name.tname, alterReq.sql, alterReq.sqlLen); auditRecord(pReq, pMnode->clusterId, "alterStb", name.dbname, name.tname, alterReq.sql, alterReq.sqlLen);
@ -2755,7 +2779,12 @@ static int32_t mndCheckDropStbForTopic(SMnode *pMnode, const char *stbFullName,
} }
SNodeList *pNodeList = NULL; SNodeList *pNodeList = NULL;
nodesCollectColumns((SSelectStmt *)pAst, SQL_CLAUSE_FROM, NULL, COLLECT_COL_TYPE_ALL, &pNodeList); if ((code = nodesCollectColumns((SSelectStmt *)pAst, SQL_CLAUSE_FROM, NULL, COLLECT_COL_TYPE_ALL, &pNodeList)) !=
0) {
sdbRelease(pSdb, pTopic);
sdbCancelFetch(pSdb, pIter);
TAOS_RETURN(code);
}
SNode *pNode = NULL; SNode *pNode = NULL;
FOREACH(pNode, pNodeList) { FOREACH(pNode, pNodeList) {
SColumnNode *pCol = (SColumnNode *)pNode; SColumnNode *pCol = (SColumnNode *)pNode;
@ -2803,7 +2832,12 @@ static int32_t mndCheckDropStbForStream(SMnode *pMnode, const char *stbFullName,
} }
SNodeList *pNodeList = NULL; SNodeList *pNodeList = NULL;
nodesCollectColumns((SSelectStmt *)pAst, SQL_CLAUSE_FROM, NULL, COLLECT_COL_TYPE_ALL, &pNodeList); if ((code = nodesCollectColumns((SSelectStmt *)pAst, SQL_CLAUSE_FROM, NULL, COLLECT_COL_TYPE_ALL, &pNodeList)) !=
0) {
sdbCancelFetch(pSdb, pIter);
sdbRelease(pSdb, pStream);
TAOS_RETURN(code);
}
SNode *pNode = NULL; SNode *pNode = NULL;
FOREACH(pNode, pNodeList) { FOREACH(pNode, pNodeList) {
SColumnNode *pCol = (SColumnNode *)pNode; SColumnNode *pCol = (SColumnNode *)pNode;
@ -2882,7 +2916,8 @@ static int32_t mndProcessDropStbReq(SRpcMsg *pReq) {
if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS; if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;
SName name = {0}; SName name = {0};
tNameFromString(&name, dropReq.name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); // TODO check return value
(void)tNameFromString(&name, dropReq.name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
auditRecord(pReq, pMnode->clusterId, "dropStb", name.dbname, name.tname, dropReq.sql, dropReq.sqlLen); auditRecord(pReq, pMnode->clusterId, "dropStb", name.dbname, name.tname, dropReq.sql, dropReq.sqlLen);
@ -2933,7 +2968,7 @@ static int32_t mndProcessTableMetaReq(SRpcMsg *pReq) {
goto _OVER; goto _OVER;
} }
tSerializeSTableMetaRsp(pRsp, rspLen, &metaRsp); (void)tSerializeSTableMetaRsp(pRsp, rspLen, &metaRsp);
pReq->info.rsp = pRsp; pReq->info.rsp = pRsp;
pReq->info.rspLen = rspLen; pReq->info.rspLen = rspLen;
code = 0; code = 0;
@ -2984,7 +3019,7 @@ static int32_t mndProcessTableCfgReq(SRpcMsg *pReq) {
goto _OVER; goto _OVER;
} }
tSerializeSTableCfgRsp(pRsp, rspLen, &cfgRsp); (void)tSerializeSTableCfgRsp(pRsp, rspLen, &cfgRsp);
pReq->info.rsp = pRsp; pReq->info.rsp = pRsp;
pReq->info.rspLen = rspLen; pReq->info.rspLen = rspLen;
code = 0; code = 0;
@ -3034,7 +3069,7 @@ int32_t mndValidateStbInfo(SMnode *pMnode, SSTableVersion *pStbVersions, int32_t
tstrncpy(metaRsp.dbFName, pStbVersion->dbFName, sizeof(metaRsp.dbFName)); tstrncpy(metaRsp.dbFName, pStbVersion->dbFName, sizeof(metaRsp.dbFName));
tstrncpy(metaRsp.tbName, pStbVersion->stbName, sizeof(metaRsp.tbName)); tstrncpy(metaRsp.tbName, pStbVersion->stbName, sizeof(metaRsp.tbName));
tstrncpy(metaRsp.stbName, pStbVersion->stbName, sizeof(metaRsp.stbName)); tstrncpy(metaRsp.stbName, pStbVersion->stbName, sizeof(metaRsp.stbName));
taosArrayPush(hbRsp.pMetaRsp, &metaRsp); (void)taosArrayPush(hbRsp.pMetaRsp, &metaRsp);
continue; continue;
} }
@ -3047,11 +3082,11 @@ int32_t mndValidateStbInfo(SMnode *pMnode, SSTableVersion *pStbVersions, int32_t
tstrncpy(metaRsp.dbFName, pStbVersion->dbFName, sizeof(metaRsp.dbFName)); tstrncpy(metaRsp.dbFName, pStbVersion->dbFName, sizeof(metaRsp.dbFName));
tstrncpy(metaRsp.tbName, pStbVersion->stbName, sizeof(metaRsp.tbName)); tstrncpy(metaRsp.tbName, pStbVersion->stbName, sizeof(metaRsp.tbName));
tstrncpy(metaRsp.stbName, pStbVersion->stbName, sizeof(metaRsp.stbName)); tstrncpy(metaRsp.stbName, pStbVersion->stbName, sizeof(metaRsp.stbName));
taosArrayPush(hbRsp.pMetaRsp, &metaRsp); (void)taosArrayPush(hbRsp.pMetaRsp, &metaRsp);
continue; continue;
} }
taosArrayPush(hbRsp.pMetaRsp, &metaRsp); (void)taosArrayPush(hbRsp.pMetaRsp, &metaRsp);
} }
if (sma) { if (sma) {
@ -3075,7 +3110,7 @@ int32_t mndValidateStbInfo(SMnode *pMnode, SSTableVersion *pStbVersions, int32_t
strcpy(indexRsp.dbFName, pStbVersion->dbFName); strcpy(indexRsp.dbFName, pStbVersion->dbFName);
strcpy(indexRsp.tbName, pStbVersion->stbName); strcpy(indexRsp.tbName, pStbVersion->stbName);
taosArrayPush(hbRsp.pIndexRsp, &indexRsp); (void)taosArrayPush(hbRsp.pIndexRsp, &indexRsp);
} }
} }
@ -3093,7 +3128,7 @@ int32_t mndValidateStbInfo(SMnode *pMnode, SSTableVersion *pStbVersions, int32_t
TAOS_RETURN(code); TAOS_RETURN(code);
} }
tSerializeSSTbHbRsp(pRsp, rspLen, &hbRsp); (void)tSerializeSSTbHbRsp(pRsp, rspLen, &hbRsp);
tFreeSSTbHbRsp(&hbRsp); tFreeSSTbHbRsp(&hbRsp);
*ppRsp = pRsp; *ppRsp = pRsp;
*pRspLen = rspLen; *pRspLen = rspLen;
@ -3130,23 +3165,23 @@ int32_t mndGetNumOfStbs(SMnode *pMnode, char *dbName, int32_t *pNumOfStbs) {
void mndExtractDbNameFromStbFullName(const char *stbFullName, char *dst) { void mndExtractDbNameFromStbFullName(const char *stbFullName, char *dst) {
SName name = {0}; SName name = {0};
tNameFromString(&name, stbFullName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); (void)tNameFromString(&name, stbFullName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
tNameGetFullDbName(&name, dst); (void)tNameGetFullDbName(&name, dst);
} }
void mndExtractShortDbNameFromStbFullName(const char *stbFullName, char *dst) { void mndExtractShortDbNameFromStbFullName(const char *stbFullName, char *dst) {
SName name = {0}; SName name = {0};
tNameFromString(&name, stbFullName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); (void)tNameFromString(&name, stbFullName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
tNameGetDbName(&name, dst); (void)tNameGetDbName(&name, dst);
} }
void mndExtractShortDbNameFromDbFullName(const char *stbFullName, char *dst) { void mndExtractShortDbNameFromDbFullName(const char *stbFullName, char *dst) {
SName name = {0}; SName name = {0};
tNameFromString(&name, stbFullName, T_NAME_ACCT | T_NAME_DB); (void)tNameFromString(&name, stbFullName, T_NAME_ACCT | T_NAME_DB);
tNameGetDbName(&name, dst); (void)tNameGetDbName(&name, dst);
} }
void mndExtractTbNameFromStbFullName(const char *stbFullName, char *dst, int32_t dstSize) { void mndExtractTbNameFromStbFullName(const char *stbFullName, char *dst, int32_t dstSize) {
@ -3473,37 +3508,37 @@ static int32_t mndRetrieveStb(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBloc
varDataSetLen(stbName, strlen(&stbName[VARSTR_HEADER_SIZE])); varDataSetLen(stbName, strlen(&stbName[VARSTR_HEADER_SIZE]));
SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)stbName, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)stbName, false);
char db[TSDB_DB_NAME_LEN + VARSTR_HEADER_SIZE] = {0}; char db[TSDB_DB_NAME_LEN + VARSTR_HEADER_SIZE] = {0};
tNameFromString(&name, pStb->db, T_NAME_ACCT | T_NAME_DB); (void)tNameFromString(&name, pStb->db, T_NAME_ACCT | T_NAME_DB);
tNameGetDbName(&name, varDataVal(db)); (void)tNameGetDbName(&name, varDataVal(db));
varDataSetLen(db, strlen(varDataVal(db))); varDataSetLen(db, strlen(varDataVal(db)));
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)db, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)db, false);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)&pStb->createdTime, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pStb->createdTime, false);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)&pStb->numOfColumns, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pStb->numOfColumns, false);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)&pStb->numOfTags, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pStb->numOfTags, false);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)&pStb->updateTime, false); // number of tables (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pStb->updateTime, false); // number of tables
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
if (pStb->commentLen > 0) { if (pStb->commentLen > 0) {
char comment[TSDB_TB_COMMENT_LEN + VARSTR_HEADER_SIZE] = {0}; char comment[TSDB_TB_COMMENT_LEN + VARSTR_HEADER_SIZE] = {0};
STR_TO_VARSTR(comment, pStb->comment); STR_TO_VARSTR(comment, pStb->comment);
colDataSetVal(pColInfo, numOfRows, comment, false); (void)colDataSetVal(pColInfo, numOfRows, comment, false);
} else if (pStb->commentLen == 0) { } else if (pStb->commentLen == 0) {
char comment[VARSTR_HEADER_SIZE + VARSTR_HEADER_SIZE] = {0}; char comment[VARSTR_HEADER_SIZE + VARSTR_HEADER_SIZE] = {0};
STR_TO_VARSTR(comment, ""); STR_TO_VARSTR(comment, "");
colDataSetVal(pColInfo, numOfRows, comment, false); (void)colDataSetVal(pColInfo, numOfRows, comment, false);
} else { } else {
colDataSetNULL(pColInfo, numOfRows); colDataSetNULL(pColInfo, numOfRows);
} }
@ -3513,14 +3548,14 @@ static int32_t mndRetrieveStb(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBloc
varDataSetLen(watermark, strlen(varDataVal(watermark))); varDataSetLen(watermark, strlen(varDataVal(watermark)));
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)watermark, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)watermark, false);
char maxDelay[64 + VARSTR_HEADER_SIZE] = {0}; char maxDelay[64 + VARSTR_HEADER_SIZE] = {0};
sprintf(varDataVal(maxDelay), "%" PRId64 "a,%" PRId64 "a", pStb->maxdelay[0], pStb->maxdelay[1]); sprintf(varDataVal(maxDelay), "%" PRId64 "a,%" PRId64 "a", pStb->maxdelay[0], pStb->maxdelay[1]);
varDataSetLen(maxDelay, strlen(varDataVal(maxDelay))); varDataSetLen(maxDelay, strlen(varDataVal(maxDelay)));
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)maxDelay, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)maxDelay, false);
char rollup[160 + VARSTR_HEADER_SIZE] = {0}; char rollup[160 + VARSTR_HEADER_SIZE] = {0};
int32_t rollupNum = (int32_t)taosArrayGetSize(pStb->pFuncs); int32_t rollupNum = (int32_t)taosArrayGetSize(pStb->pFuncs);
@ -3530,16 +3565,16 @@ static int32_t mndRetrieveStb(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBloc
for (int32_t i = 0; i < rollupNum; ++i) { for (int32_t i = 0; i < rollupNum; ++i) {
char *funcName = taosArrayGet(pStb->pFuncs, i); char *funcName = taosArrayGet(pStb->pFuncs, i);
if (i) { if (i) {
strncat(varDataVal(rollup), sep, rollupLen); (void)strncat(varDataVal(rollup), sep, rollupLen);
rollupLen -= sepLen; rollupLen -= sepLen;
} }
strncat(varDataVal(rollup), funcName, rollupLen); (void)strncat(varDataVal(rollup), funcName, rollupLen);
rollupLen -= strlen(funcName); rollupLen -= strlen(funcName);
} }
varDataSetLen(rollup, strlen(varDataVal(rollup))); varDataSetLen(rollup, strlen(varDataVal(rollup)));
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)rollup, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)rollup, false);
numOfRows++; numOfRows++;
sdbRelease(pSdb, pStb); sdbRelease(pSdb, pStb);
@ -3577,20 +3612,20 @@ static int32_t buildDbColsInfoBlock(const SSDataBlock *p, const SSysTableMeta *p
for (int32_t j = 0; j < pm->colNum; j++) { for (int32_t j = 0; j < pm->colNum; j++) {
// table name // table name
SColumnInfoData *pColInfoData = taosArrayGet(p->pDataBlock, 0); SColumnInfoData *pColInfoData = taosArrayGet(p->pDataBlock, 0);
colDataSetVal(pColInfoData, numOfRows, tName, false); (void)colDataSetVal(pColInfoData, numOfRows, tName, false);
// database name // database name
pColInfoData = taosArrayGet(p->pDataBlock, 1); pColInfoData = taosArrayGet(p->pDataBlock, 1);
colDataSetVal(pColInfoData, numOfRows, dName, false); (void)colDataSetVal(pColInfoData, numOfRows, dName, false);
pColInfoData = taosArrayGet(p->pDataBlock, 2); pColInfoData = taosArrayGet(p->pDataBlock, 2);
colDataSetVal(pColInfoData, numOfRows, typeName, false); (void)colDataSetVal(pColInfoData, numOfRows, typeName, false);
// col name // col name
char colName[TSDB_COL_NAME_LEN + VARSTR_HEADER_SIZE] = {0}; char colName[TSDB_COL_NAME_LEN + VARSTR_HEADER_SIZE] = {0};
STR_TO_VARSTR(colName, pm->schema[j].name); STR_TO_VARSTR(colName, pm->schema[j].name);
pColInfoData = taosArrayGet(p->pDataBlock, 3); pColInfoData = taosArrayGet(p->pDataBlock, 3);
colDataSetVal(pColInfoData, numOfRows, colName, false); (void)colDataSetVal(pColInfoData, numOfRows, colName, false);
// col type // col type
int8_t colType = pm->schema[j].type; int8_t colType = pm->schema[j].type;
@ -3605,10 +3640,10 @@ static int32_t buildDbColsInfoBlock(const SSDataBlock *p, const SSysTableMeta *p
(int32_t)((pm->schema[j].bytes - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE)); (int32_t)((pm->schema[j].bytes - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE));
} }
varDataSetLen(colTypeStr, colTypeLen); varDataSetLen(colTypeStr, colTypeLen);
colDataSetVal(pColInfoData, numOfRows, (char *)colTypeStr, false); (void)colDataSetVal(pColInfoData, numOfRows, (char *)colTypeStr, false);
pColInfoData = taosArrayGet(p->pDataBlock, 5); pColInfoData = taosArrayGet(p->pDataBlock, 5);
colDataSetVal(pColInfoData, numOfRows, (const char *)&pm->schema[j].bytes, false); (void)colDataSetVal(pColInfoData, numOfRows, (const char *)&pm->schema[j].bytes, false);
for (int32_t k = 6; k <= 8; ++k) { for (int32_t k = 6; k <= 8; ++k) {
pColInfoData = taosArrayGet(p->pDataBlock, k); pColInfoData = taosArrayGet(p->pDataBlock, k);
colDataSetNULL(pColInfoData, numOfRows); colDataSetNULL(pColInfoData, numOfRows);
@ -3724,26 +3759,26 @@ static int32_t mndRetrieveStbCol(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pB
mDebug("mndRetrieveStbCol get stable cols, stable name:%s, db:%s", pStb->name, pStb->db); mDebug("mndRetrieveStbCol get stable cols, stable name:%s, db:%s", pStb->name, pStb->db);
char db[TSDB_DB_NAME_LEN + VARSTR_HEADER_SIZE] = {0}; char db[TSDB_DB_NAME_LEN + VARSTR_HEADER_SIZE] = {0};
tNameFromString(&name, pStb->db, T_NAME_ACCT | T_NAME_DB); (void)tNameFromString(&name, pStb->db, T_NAME_ACCT | T_NAME_DB);
tNameGetDbName(&name, varDataVal(db)); (void)tNameGetDbName(&name, varDataVal(db));
varDataSetLen(db, strlen(varDataVal(db))); varDataSetLen(db, strlen(varDataVal(db)));
for (int i = 0; i < pStb->numOfColumns; i++) { for (int i = 0; i < pStb->numOfColumns; i++) {
int32_t cols = 0; int32_t cols = 0;
SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)stbName, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)stbName, false);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)db, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)db, false);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, typeName, false); (void)colDataSetVal(pColInfo, numOfRows, typeName, false);
// col name // col name
char colName[TSDB_COL_NAME_LEN + VARSTR_HEADER_SIZE] = {0}; char colName[TSDB_COL_NAME_LEN + VARSTR_HEADER_SIZE] = {0};
STR_TO_VARSTR(colName, pStb->pColumns[i].name); STR_TO_VARSTR(colName, pStb->pColumns[i].name);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, colName, false); (void)colDataSetVal(pColInfo, numOfRows, colName, false);
// col type // col type
int8_t colType = pStb->pColumns[i].type; int8_t colType = pStb->pColumns[i].type;
@ -3758,10 +3793,10 @@ static int32_t mndRetrieveStbCol(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pB
(int32_t)((pStb->pColumns[i].bytes - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE)); (int32_t)((pStb->pColumns[i].bytes - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE));
} }
varDataSetLen(colTypeStr, colTypeLen); varDataSetLen(colTypeStr, colTypeLen);
colDataSetVal(pColInfo, numOfRows, (char *)colTypeStr, false); (void)colDataSetVal(pColInfo, numOfRows, (char *)colTypeStr, false);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetVal(pColInfo, numOfRows, (const char *)&pStb->pColumns[i].bytes, false); (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pStb->pColumns[i].bytes, false);
while (cols < pShow->numOfColumns) { while (cols < pShow->numOfColumns) {
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
colDataSetNULL(pColInfo, numOfRows); colDataSetNULL(pColInfo, numOfRows);
@ -4064,7 +4099,7 @@ static void *mndBuildVDropTbsReq(SMnode *pMnode, const SVgroupInfo *pVgInfo, con
void *pBuf = POINTER_SHIFT(pHead, sizeof(SMsgHead)); void *pBuf = POINTER_SHIFT(pHead, sizeof(SMsgHead));
tEncoderInit(&encoder, pBuf, contLen - sizeof(SMsgHead)); tEncoderInit(&encoder, pBuf, contLen - sizeof(SMsgHead));
tEncodeSVDropTbBatchReq(&encoder, pReq); (void)tEncodeSVDropTbBatchReq(&encoder, pReq);
tEncoderClear(&encoder); tEncoderClear(&encoder);
*len = contLen; *len = contLen;
@ -4155,10 +4190,19 @@ static int32_t mndDropTbAdd(SMnode *pMnode, SHashObj *pVgHashMap, const SVgroupI
if (pReqs == NULL) { if (pReqs == NULL) {
reqs.info = *pVgInfo; reqs.info = *pVgInfo;
reqs.req.pArray = taosArrayInit(TARRAY_MIN_SIZE, sizeof(SVDropTbReq)); reqs.req.pArray = taosArrayInit(TARRAY_MIN_SIZE, sizeof(SVDropTbReq));
taosArrayPush(reqs.req.pArray, &req); if (reqs.req.pArray == NULL) {
taosHashPut(pVgHashMap, &pVgInfo->vgId, sizeof(pVgInfo->vgId), &reqs, sizeof(reqs)); return TSDB_CODE_OUT_OF_MEMORY;
}
if (taosArrayPush(reqs.req.pArray, &req) == NULL) {
return TSDB_CODE_OUT_OF_MEMORY;
}
if (taosHashPut(pVgHashMap, &pVgInfo->vgId, sizeof(pVgInfo->vgId), &reqs, sizeof(reqs)) != 0) {
return TSDB_CODE_OUT_OF_MEMORY;
}
} else { } else {
taosArrayPush(pReqs->req.pArray, &req); if (taosArrayPush(pReqs->req.pArray, &req) == NULL) {
return TSDB_CODE_OUT_OF_MEMORY;
}
} }
return 0; return 0;
} }
@ -4231,7 +4275,10 @@ static int32_t mndDropTbAddTsmaResTbsForSingleVg(SMnode *pMnode, SMndDropTbsWith
code = TSDB_CODE_OUT_OF_MEMORY; code = TSDB_CODE_OUT_OF_MEMORY;
goto _end; goto _end;
} }
taosHashPut(pCtx->pTsmaMap, &pTb->suid, sizeof(pTb->suid), &infos, sizeof(infos)); if (taosHashPut(pCtx->pTsmaMap, &pTb->suid, sizeof(pTb->suid), &infos, sizeof(infos)) != 0) {
code = TSDB_CODE_OUT_OF_MEMORY;
goto _end;
}
} }
} }
@ -4258,11 +4305,15 @@ static int32_t mndDropTbAddTsmaResTbsForSingleVg(SMnode *pMnode, SMndDropTbsWith
sdbRelease(pMnode->pSdb, pSma); sdbRelease(pMnode->pSdb, pSma);
goto _end; goto _end;
} }
taosHashPut(pCtx->pDbMap, pSma->db, TSDB_DB_FNAME_LEN, &info.dbInfo, sizeof(SMDropTbDbInfo)); if (taosHashPut(pCtx->pDbMap, pSma->db, TSDB_DB_FNAME_LEN, &info.dbInfo, sizeof(SMDropTbDbInfo)) != 0) {
sdbCancelFetch(pMnode->pSdb, pIter);
sdbRelease(pMnode->pSdb, pSma);
goto _end;
}
} else { } else {
info.dbInfo = *pDbInfo; info.dbInfo = *pDbInfo;
} }
taosArrayPush(pInfos->pTsmaInfos, &info); (void)taosArrayPush(pInfos->pTsmaInfos, &info);
} }
sdbRelease(pMnode->pSdb, pSma); sdbRelease(pMnode->pSdb, pSma);
} }
@ -4270,7 +4321,7 @@ static int32_t mndDropTbAddTsmaResTbsForSingleVg(SMnode *pMnode, SMndDropTbsWith
// generate vg req map // generate vg req map
for (int32_t i = 0; i < pTbs->size; ++i) { for (int32_t i = 0; i < pTbs->size; ++i) {
SVDropTbReq *pTb = taosArrayGet(pTbs, i); SVDropTbReq *pTb = taosArrayGet(pTbs, i);
mndDropTbAdd(pMnode, pCtx->pVgMap, &vgInfo, pTb->name, pTb->suid, pTb->igNotExists); TAOS_CHECK_GOTO(mndDropTbAdd(pMnode, pCtx->pVgMap, &vgInfo, pTb->name, pTb->suid, pTb->igNotExists), NULL, _end);
SMDropTbTsmaInfos *pInfos = taosHashGet(pCtx->pTsmaMap, &pTb->suid, sizeof(pTb->suid)); SMDropTbTsmaInfos *pInfos = taosHashGet(pCtx->pTsmaMap, &pTb->suid, sizeof(pTb->suid));
SArray *pVgInfos = NULL; SArray *pVgInfos = NULL;
@ -4282,8 +4333,8 @@ static int32_t mndDropTbAddTsmaResTbsForSingleVg(SMnode *pMnode, SMndDropTbsWith
taosGetTbHashVal(buf, len, pInfo->dbInfo.hashMethod, pInfo->dbInfo.hashPrefix, pInfo->dbInfo.hashSuffix); taosGetTbHashVal(buf, len, pInfo->dbInfo.hashMethod, pInfo->dbInfo.hashPrefix, pInfo->dbInfo.hashSuffix);
const SVgroupInfo *pVgInfo = taosArraySearch(pInfo->dbInfo.dbVgInfos, &hashVal, vgHashValCmp, TD_EQ); const SVgroupInfo *pVgInfo = taosArraySearch(pInfo->dbInfo.dbVgInfos, &hashVal, vgHashValCmp, TD_EQ);
void *p = taosStrdup(buf + strlen(pInfo->tsmaResTbDbFName) + TSDB_NAME_DELIMITER_LEN); void *p = taosStrdup(buf + strlen(pInfo->tsmaResTbDbFName) + TSDB_NAME_DELIMITER_LEN);
taosArrayPush(pCtx->pResTbNames, &p); (void)taosArrayPush(pCtx->pResTbNames, &p);
mndDropTbAdd(pMnode, pCtx->pVgMap, pVgInfo, p, pInfo->suid, true); TAOS_CHECK_GOTO(mndDropTbAdd(pMnode, pCtx->pVgMap, pVgInfo, p, pInfo->suid, true), NULL, _end);
} }
} }
_end: _end:

2
source/dnode/mnode/impl/src/mndSubscribe.c
View File

@ -1375,7 +1375,7 @@ static int32_t buildResult(SSDataBlock *pBlock, int32_t *numOfRows, int64_t cons
if (data) { if (data) {
// vg id // vg id
char buf[TSDB_OFFSET_LEN * 2 + VARSTR_HEADER_SIZE] = {0}; char buf[TSDB_OFFSET_LEN * 2 + VARSTR_HEADER_SIZE] = {0};
tFormatOffset(varDataVal(buf), TSDB_OFFSET_LEN, &data->offset); (void)tFormatOffset(varDataVal(buf), TSDB_OFFSET_LEN, &data->offset);
(void)sprintf(varDataVal(buf) + strlen(varDataVal(buf)), "/%" PRId64, data->ever); (void)sprintf(varDataVal(buf) + strlen(varDataVal(buf)), "/%" PRId64, data->ever);
varDataSetLen(buf, strlen(varDataVal(buf))); varDataSetLen(buf, strlen(varDataVal(buf)));
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);

6
source/dnode/vnode/src/inc/meta.h
View File

@ -39,9 +39,9 @@ typedef struct SMetaCache SMetaCache;
// clang-format on // clang-format on
// metaOpen ================== // metaOpen ==================
int32_t metaRLock(SMeta* pMeta); void metaRLock(SMeta* pMeta);
int32_t metaWLock(SMeta* pMeta); void metaWLock(SMeta* pMeta);
int32_t metaULock(SMeta* pMeta); void metaULock(SMeta* pMeta);
// metaEntry ================== // metaEntry ==================
int metaEncodeEntry(SEncoder* pCoder, const SMetaEntry* pME); int metaEncodeEntry(SEncoder* pCoder, const SMetaEntry* pME);

30
source/dnode/vnode/src/meta/metaCache.c
View File

@ -156,7 +156,7 @@ int32_t metaCacheOpen(SMeta* pMeta) {
} }
taosHashSetFreeFp(pMeta->pCache->sTagFilterResCache.pTableEntry, freeCacheEntryFp); 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); pMeta->pCache->STbGroupResCache.pResCache = taosLRUCacheInit(5 * 1024 * 1024, -1, 0.5);
if (pMeta->pCache->STbGroupResCache.pResCache == NULL) { if (pMeta->pCache->STbGroupResCache.pResCache == NULL) {
@ -171,7 +171,7 @@ int32_t metaCacheOpen(SMeta* pMeta) {
} }
taosHashSetFreeFp(pMeta->pCache->STbGroupResCache.pTableEntry, freeCacheEntryFp); taosHashSetFreeFp(pMeta->pCache->STbGroupResCache.pTableEntry, freeCacheEntryFp);
taosThreadMutexInit(&pMeta->pCache->STbGroupResCache.lock, NULL); (void)taosThreadMutexInit(&pMeta->pCache->STbGroupResCache.lock, NULL);
pMeta->pCache->STbFilterCache.pStb = pMeta->pCache->STbFilterCache.pStb =
taosHashInit(0, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK); taosHashInit(0, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK);
@ -201,11 +201,11 @@ void metaCacheClose(SMeta* pMeta) {
statsCacheClose(pMeta); statsCacheClose(pMeta);
taosLRUCacheCleanup(pMeta->pCache->sTagFilterResCache.pUidResCache); taosLRUCacheCleanup(pMeta->pCache->sTagFilterResCache.pUidResCache);
taosThreadMutexDestroy(&pMeta->pCache->sTagFilterResCache.lock); (void)taosThreadMutexDestroy(&pMeta->pCache->sTagFilterResCache.lock);
taosHashCleanup(pMeta->pCache->sTagFilterResCache.pTableEntry); taosHashCleanup(pMeta->pCache->sTagFilterResCache.pTableEntry);
taosLRUCacheCleanup(pMeta->pCache->STbGroupResCache.pResCache); taosLRUCacheCleanup(pMeta->pCache->STbGroupResCache.pResCache);
taosThreadMutexDestroy(&pMeta->pCache->STbGroupResCache.lock); (void)taosThreadMutexDestroy(&pMeta->pCache->STbGroupResCache.lock);
taosHashCleanup(pMeta->pCache->STbGroupResCache.pTableEntry); taosHashCleanup(pMeta->pCache->STbGroupResCache.pTableEntry);
taosHashCleanup(pMeta->pCache->STbFilterCache.pStb); taosHashCleanup(pMeta->pCache->STbFilterCache.pStb);
@ -495,7 +495,7 @@ static int checkAllEntriesInCache(const STagFilterResEntry* pEntry, SArray* pInv
return TSDB_CODE_OUT_OF_MEMORY; return TSDB_CODE_OUT_OF_MEMORY;
} }
} else { } 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; int32_t size = *(int32_t*)p;
// set the result into the buffer // 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; (*pEntry)->hitTimes += 1;
@ -562,7 +564,7 @@ int32_t metaGetCachedTableUidList(void* pVnode, tb_uid_t suid, const uint8_t* pK
((double)(*pEntry)->hitTimes) / acc); ((double)(*pEntry)->hitTimes) / acc);
} }
taosLRUCacheRelease(pCache, pHandle, false); (void)taosLRUCacheRelease(pCache, pHandle, false);
// unlock meta // unlock meta
(void)taosThreadMutexUnlock(pLock); (void)taosThreadMutexUnlock(pLock);
@ -618,7 +620,7 @@ static int32_t addNewEntry(SHashObj* pTableEntry, const void* pKey, int32_t keyL
p->hitTimes = 0; p->hitTimes = 0;
tdListInit(&p->list, keyLen); tdListInit(&p->list, keyLen);
TAOS_CHECK_RETURN(taosHashPut(pTableEntry, &suid, sizeof(uint64_t), &p, POINTER_BYTES)); TAOS_CHECK_RETURN(taosHashPut(pTableEntry, &suid, sizeof(uint64_t), &p, POINTER_BYTES));
tdListAppend(&p->list, pKey); (void)tdListAppend(&p->list, pKey);
return 0; 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 } else { // check if it exists or not
size_t size = listNEles(&(*pEntry)->list); size_t size = listNEles(&(*pEntry)->list);
if (size == 0) { if (size == 0) {
tdListAppend(&(*pEntry)->list, pKey); (void)tdListAppend(&(*pEntry)->list, pKey);
} else { } else {
SListNode* pNode = listHead(&(*pEntry)->list); SListNode* pNode = listHead(&(*pEntry)->list);
uint64_t* p = (uint64_t*)pNode->data; 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); (void)taosThreadMutexUnlock(pLock);
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} else { // not equal, append it } 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); ((double)(*pEntry)->hitTimes) / acc);
} }
taosLRUCacheRelease(pCache, pHandle, false); (void)taosLRUCacheRelease(pCache, pHandle, false);
// unlock meta // unlock meta
(void)taosThreadMutexUnlock(pLock); (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 } else { // check if it exists or not
size_t size = listNEles(&(*pEntry)->list); size_t size = listNEles(&(*pEntry)->list);
if (size == 0) { if (size == 0) {
tdListAppend(&(*pEntry)->list, pKey); (void)tdListAppend(&(*pEntry)->list, pKey);
} else { } else {
SListNode* pNode = listHead(&(*pEntry)->list); SListNode* pNode = listHead(&(*pEntry)->list);
uint64_t* p = (uint64_t*)pNode->data; uint64_t* p = (uint64_t*)pNode->data;
@ -848,13 +850,13 @@ int32_t metaPutTbGroupToCache(void* pVnode, uint64_t suid, const void* pKey, int
(void)taosThreadMutexUnlock(pLock); (void)taosThreadMutexUnlock(pLock);
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} else { // not equal, append it } else { // not equal, append it
tdListAppend(&(*pEntry)->list, pKey); (void)tdListAppend(&(*pEntry)->list, pKey);
} }
} }
} }
// add to cache. // add to cache.
taosLRUCacheInsert(pCache, key, TAG_FILTER_RES_KEY_LEN, pPayload, payloadLen, freeTbGroupCachePayload, NULL, (void)taosLRUCacheInsert(pCache, key, TAG_FILTER_RES_KEY_LEN, pPayload, payloadLen, freeTbGroupCachePayload, NULL,
TAOS_LRU_PRIORITY_LOW, NULL); TAOS_LRU_PRIORITY_LOW, NULL);
_end: _end:
(void)taosThreadMutexUnlock(pLock); (void)taosThreadMutexUnlock(pLock);

42
source/dnode/vnode/src/meta/metaOpen.c
View File

@ -29,10 +29,10 @@ static int ncolIdxCmpr(const void *pKey1, int kLen1, const void *pKey2, int kLen
static int32_t metaInitLock(SMeta *pMeta) { static int32_t metaInitLock(SMeta *pMeta) {
TdThreadRwlockAttr attr; TdThreadRwlockAttr attr;
taosThreadRwlockAttrInit(&attr); (void)taosThreadRwlockAttrInit(&attr);
taosThreadRwlockAttrSetKindNP(&attr, PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP); (void)taosThreadRwlockAttrSetKindNP(&attr, PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP);
taosThreadRwlockInit(&pMeta->lock, &attr); (void)taosThreadRwlockInit(&pMeta->lock, &attr);
taosThreadRwlockAttrDestroy(&attr); (void)taosThreadRwlockAttrDestroy(&attr);
return 0; return 0;
} }
static int32_t metaDestroyLock(SMeta *pMeta) { return taosThreadRwlockDestroy(&pMeta->lock); } 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}; char indexFullPath[128] = {0};
// create handle // 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); offset = strlen(path);
snprintf(path + offset, TSDB_FILENAME_LEN - offset - 1, "%s%s", TD_DIRSEP, VNODE_META_DIR); 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); TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit);
} }
metaInitLock(pMeta); (void)metaInitLock(pMeta);
pMeta->path = (char *)&pMeta[1]; pMeta->path = (char *)&pMeta[1];
strcpy(pMeta->path, path); strcpy(pMeta->path, path);
taosRealPath(pMeta->path, NULL, strlen(path) + 1); (void)taosRealPath(pMeta->path, NULL, strlen(path) + 1);
pMeta->pVnode = pVnode; pMeta->pVnode = pVnode;
// create path if not created yet // create path if not created yet
taosMkDir(pMeta->path); (void)taosMkDir(pMeta->path);
// open env // open env
code = tdbOpen(pMeta->path, pVnode->config.szPage, pVnode->config.szCache, &pMeta->pEnv, rollback, 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; return code;
} }
int32_t metaRLock(SMeta *pMeta) { void metaRLock(SMeta *pMeta) {
metaTrace("meta rlock %p", &pMeta->lock); metaTrace("meta rlock %p", &pMeta->lock);
int32_t code = taosThreadRwlockRdlock(&pMeta->lock); (void)taosThreadRwlockRdlock(&pMeta->lock);
if (code) {
return TAOS_SYSTEM_ERROR(code);
}
return 0;
} }
int32_t metaWLock(SMeta *pMeta) { void metaWLock(SMeta *pMeta) {
metaTrace("meta wlock %p", &pMeta->lock); metaTrace("meta wlock %p", &pMeta->lock);
int32_t code = taosThreadRwlockWrlock(&pMeta->lock); (void)taosThreadRwlockWrlock(&pMeta->lock);
if (code) {
return TAOS_SYSTEM_ERROR(code);
}
return 0;
} }
int32_t metaULock(SMeta *pMeta) { void metaULock(SMeta *pMeta) {
metaTrace("meta ulock %p", &pMeta->lock); metaTrace("meta ulock %p", &pMeta->lock);
int32_t code = taosThreadRwlockUnlock(&pMeta->lock); (void)taosThreadRwlockUnlock(&pMeta->lock);
if (code) {
return TAOS_SYSTEM_ERROR(code);
}
return 0;
} }
static void metaCleanup(SMeta **ppMeta) { static void metaCleanup(SMeta **ppMeta) {
@ -235,7 +223,7 @@ static void metaCleanup(SMeta **ppMeta) {
if (pMeta->pSkmDb) tdbTbClose(pMeta->pSkmDb); if (pMeta->pSkmDb) tdbTbClose(pMeta->pSkmDb);
if (pMeta->pTbDb) tdbTbClose(pMeta->pTbDb); if (pMeta->pTbDb) tdbTbClose(pMeta->pTbDb);
if (pMeta->pEnv) tdbClose(pMeta->pEnv); if (pMeta->pEnv) tdbClose(pMeta->pEnv);
metaDestroyLock(pMeta); (void)metaDestroyLock(pMeta);
taosMemoryFreeClear(*ppMeta); taosMemoryFreeClear(*ppMeta);
} }

82
source/dnode/vnode/src/meta/metaQuery.c
View File

@ -252,7 +252,7 @@ void metaCloseTbCursor(SMTbCursor *pTbCur) {
if (!pTbCur->paused) { if (!pTbCur->paused) {
metaReaderClear(&pTbCur->mr); metaReaderClear(&pTbCur->mr);
if (pTbCur->pDbc) { if (pTbCur->pDbc) {
tdbTbcClose((TBC *)pTbCur->pDbc); (void)tdbTbcClose((TBC *)pTbCur->pDbc);
} }
} }
taosMemoryFree(pTbCur); taosMemoryFree(pTbCur);
@ -262,7 +262,7 @@ void metaCloseTbCursor(SMTbCursor *pTbCur) {
void metaPauseTbCursor(SMTbCursor *pTbCur) { void metaPauseTbCursor(SMTbCursor *pTbCur) {
if (!pTbCur->paused) { if (!pTbCur->paused) {
metaReaderClear(&pTbCur->mr); metaReaderClear(&pTbCur->mr);
tdbTbcClose((TBC *)pTbCur->pDbc); (void)tdbTbcClose((TBC *)pTbCur->pDbc);
pTbCur->paused = 1; pTbCur->paused = 1;
} }
} }
@ -270,19 +270,19 @@ void metaResumeTbCursor(SMTbCursor *pTbCur, int8_t first, int8_t move) {
if (pTbCur->paused) { if (pTbCur->paused) {
metaReaderDoInit(&pTbCur->mr, pTbCur->pMeta, META_READER_LOCK); 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) { if (first) {
tdbTbcMoveToFirst((TBC *)pTbCur->pDbc); (void)tdbTbcMoveToFirst((TBC *)pTbCur->pDbc);
} else { } else {
int c = 1; int c = 1;
tdbTbcMoveTo(pTbCur->pDbc, pTbCur->pKey, pTbCur->kLen, &c); (void)tdbTbcMoveTo(pTbCur->pDbc, pTbCur->pKey, pTbCur->kLen, &c);
if (c == 0) { if (c == 0) {
if (move) tdbTbcMoveToNext(pTbCur->pDbc); if (move) tdbTbcMoveToNext(pTbCur->pDbc);
} else if (c < 0) { } else if (c < 0) {
tdbTbcMoveToPrev(pTbCur->pDbc); (void)tdbTbcMoveToPrev(pTbCur->pDbc);
} else { } else {
tdbTbcMoveToNext(pTbCur->pDbc); (void)tdbTbcMoveToNext(pTbCur->pDbc);
} }
} }
@ -303,7 +303,7 @@ int32_t metaTbCursorNext(SMTbCursor *pTbCur, ETableType jumpTableType) {
tDecoderClear(&pTbCur->mr.coder); tDecoderClear(&pTbCur->mr.coder);
metaGetTableEntryByVersion(&pTbCur->mr, ((SUidIdxVal *)pTbCur->pVal)[0].version, *(tb_uid_t *)pTbCur->pKey); (void)metaGetTableEntryByVersion(&pTbCur->mr, ((SUidIdxVal *)pTbCur->pVal)[0].version, *(tb_uid_t *)pTbCur->pKey);
if (pTbCur->mr.me.type == jumpTableType) { if (pTbCur->mr.me.type == jumpTableType) {
continue; continue;
} }
@ -327,7 +327,7 @@ int32_t metaTbCursorPrev(SMTbCursor *pTbCur, ETableType jumpTableType) {
tDecoderClear(&pTbCur->mr.coder); tDecoderClear(&pTbCur->mr.coder);
metaGetTableEntryByVersion(&pTbCur->mr, ((SUidIdxVal *)pTbCur->pVal)[0].version, *(tb_uid_t *)pTbCur->pKey); (void)metaGetTableEntryByVersion(&pTbCur->mr, ((SUidIdxVal *)pTbCur->pVal)[0].version, *(tb_uid_t *)pTbCur->pKey);
if (pTbCur->mr.me.type == jumpTableType) { if (pTbCur->mr.me.type == jumpTableType) {
continue; continue;
} }
@ -355,11 +355,11 @@ _query:
version = ((SUidIdxVal *)pData)[0].version; version = ((SUidIdxVal *)pData)[0].version;
tdbTbGet(pMeta->pTbDb, &(STbDbKey){.uid = uid, .version = version}, sizeof(STbDbKey), &pData, &nData); (void)tdbTbGet(pMeta->pTbDb, &(STbDbKey){.uid = uid, .version = version}, sizeof(STbDbKey), &pData, &nData);
SMetaEntry me = {0}; SMetaEntry me = {0};
tDecoderInit(&dc, pData, nData); tDecoderInit(&dc, pData, nData);
metaDecodeEntry(&dc, &me); (void)metaDecodeEntry(&dc, &me);
if (me.type == TSDB_SUPER_TABLE) { if (me.type == TSDB_SUPER_TABLE) {
if (sver == -1 || sver == me.stbEntry.schemaRow.version) { if (sver == -1 || sver == me.stbEntry.schemaRow.version) {
pSchema = tCloneSSchemaWrapper(&me.stbEntry.schemaRow); pSchema = tCloneSSchemaWrapper(&me.stbEntry.schemaRow);
@ -385,7 +385,7 @@ _query:
} }
tDecoderInit(&dc, pData, nData); tDecoderInit(&dc, pData, nData);
tDecodeSSchemaWrapperEx(&dc, &schema); (void)tDecodeSSchemaWrapperEx(&dc, &schema);
pSchema = tCloneSSchemaWrapper(&schema); pSchema = tCloneSSchemaWrapper(&schema);
tDecoderClear(&dc); tDecoderClear(&dc);
@ -433,7 +433,7 @@ void metaCloseCtbCursor(SMCtbCursor *pCtbCur) {
if (!pCtbCur->paused) { if (!pCtbCur->paused) {
if (pCtbCur->pMeta && pCtbCur->lock) metaULock(pCtbCur->pMeta); if (pCtbCur->pMeta && pCtbCur->lock) metaULock(pCtbCur->pMeta);
if (pCtbCur->pCur) { if (pCtbCur->pCur) {
tdbTbcClose(pCtbCur->pCur); (void)tdbTbcClose(pCtbCur->pCur);
} }
} }
tdbFree(pCtbCur->pKey); tdbFree(pCtbCur->pKey);
@ -444,7 +444,7 @@ void metaCloseCtbCursor(SMCtbCursor *pCtbCur) {
void metaPauseCtbCursor(SMCtbCursor *pCtbCur) { void metaPauseCtbCursor(SMCtbCursor *pCtbCur) {
if (!pCtbCur->paused) { if (!pCtbCur->paused) {
tdbTbcClose((TBC *)pCtbCur->pCur); (void)tdbTbcClose((TBC *)pCtbCur->pCur);
if (pCtbCur->lock) { if (pCtbCur->lock) {
metaULock(pCtbCur->pMeta); metaULock(pCtbCur->pMeta);
} }
@ -472,17 +472,17 @@ int32_t metaResumeCtbCursor(SMCtbCursor *pCtbCur, int8_t first) {
ctbIdxKey.suid = pCtbCur->suid; ctbIdxKey.suid = pCtbCur->suid;
ctbIdxKey.uid = INT64_MIN; ctbIdxKey.uid = INT64_MIN;
int c = 0; int c = 0;
tdbTbcMoveTo(pCtbCur->pCur, &ctbIdxKey, sizeof(ctbIdxKey), &c); (void)tdbTbcMoveTo(pCtbCur->pCur, &ctbIdxKey, sizeof(ctbIdxKey), &c);
if (c > 0) { if (c > 0) {
tdbTbcMoveToNext(pCtbCur->pCur); (void)tdbTbcMoveToNext(pCtbCur->pCur);
} }
} else { } else {
int c = 0; int c = 0;
ret = tdbTbcMoveTo(pCtbCur->pCur, pCtbCur->pKey, pCtbCur->kLen, &c); ret = tdbTbcMoveTo(pCtbCur->pCur, pCtbCur->pKey, pCtbCur->kLen, &c);
if (c < 0) { if (c < 0) {
tdbTbcMoveToPrev(pCtbCur->pCur); (void)tdbTbcMoveToPrev(pCtbCur->pCur);
} else { } else {
tdbTbcMoveToNext(pCtbCur->pCur); (void)tdbTbcMoveToNext(pCtbCur->pCur);
} }
} }
} }
@ -540,9 +540,9 @@ SMStbCursor *metaOpenStbCursor(SMeta *pMeta, tb_uid_t suid) {
} }
// move to the suid // move to the suid
tdbTbcMoveTo(pStbCur->pCur, &suid, sizeof(suid), &c); (void)tdbTbcMoveTo(pStbCur->pCur, &suid, sizeof(suid), &c);
if (c > 0) { if (c > 0) {
tdbTbcMoveToNext(pStbCur->pCur); (void)tdbTbcMoveToNext(pStbCur->pCur);
} }
return pStbCur; return pStbCur;
@ -552,7 +552,7 @@ void metaCloseStbCursor(SMStbCursor *pStbCur) {
if (pStbCur) { if (pStbCur) {
if (pStbCur->pMeta) metaULock(pStbCur->pMeta); if (pStbCur->pMeta) metaULock(pStbCur->pMeta);
if (pStbCur->pCur) { if (pStbCur->pCur) {
tdbTbcClose(pStbCur->pCur); (void)tdbTbcClose(pStbCur->pCur);
tdbFree(pStbCur->pKey); tdbFree(pStbCur->pKey);
tdbFree(pStbCur->pVal); tdbFree(pStbCur->pVal);
@ -603,35 +603,35 @@ int32_t metaGetTbTSchemaEx(SMeta *pMeta, tb_uid_t suid, tb_uid_t uid, int32_t sv
skmDbKey.uid = suid ? suid : uid; skmDbKey.uid = suid ? suid : uid;
skmDbKey.sver = INT32_MAX; skmDbKey.sver = INT32_MAX;
tdbTbcOpen(pMeta->pSkmDb, &pSkmDbC, NULL); (void)tdbTbcOpen(pMeta->pSkmDb, &pSkmDbC, NULL);
metaRLock(pMeta); metaRLock(pMeta);
if (tdbTbcMoveTo(pSkmDbC, &skmDbKey, sizeof(skmDbKey), &c) < 0) { if (tdbTbcMoveTo(pSkmDbC, &skmDbKey, sizeof(skmDbKey), &c) < 0) {
metaULock(pMeta); metaULock(pMeta);
tdbTbcClose(pSkmDbC); (void)tdbTbcClose(pSkmDbC);
code = TSDB_CODE_NOT_FOUND; code = TSDB_CODE_NOT_FOUND;
goto _exit; goto _exit;
} }
if (c == 0) { if (c == 0) {
metaULock(pMeta); metaULock(pMeta);
tdbTbcClose(pSkmDbC); (void)tdbTbcClose(pSkmDbC);
code = TSDB_CODE_FAILED; code = TSDB_CODE_FAILED;
metaError("meta/query: incorrect c: %" PRId32 ".", c); metaError("meta/query: incorrect c: %" PRId32 ".", c);
goto _exit; goto _exit;
} }
if (c < 0) { if (c < 0) {
tdbTbcMoveToPrev(pSkmDbC); (void)tdbTbcMoveToPrev(pSkmDbC);
} }
const void *pKey = NULL; const void *pKey = NULL;
int32_t nKey = 0; int32_t nKey = 0;
tdbTbcGet(pSkmDbC, &pKey, &nKey, NULL, NULL); (void)tdbTbcGet(pSkmDbC, &pKey, &nKey, NULL, NULL);
if (((SSkmDbKey *)pKey)->uid != skmDbKey.uid) { if (((SSkmDbKey *)pKey)->uid != skmDbKey.uid) {
metaULock(pMeta); metaULock(pMeta);
tdbTbcClose(pSkmDbC); (void)tdbTbcClose(pSkmDbC);
code = TSDB_CODE_NOT_FOUND; code = TSDB_CODE_NOT_FOUND;
goto _exit; 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; sver = ((SSkmDbKey *)pKey)->sver;
metaULock(pMeta); metaULock(pMeta);
tdbTbcClose(pSkmDbC); (void)tdbTbcClose(pSkmDbC);
} }
} }
@ -753,9 +753,9 @@ SMSmaCursor *metaOpenSmaCursor(SMeta *pMeta, tb_uid_t uid) {
// move to the suid // move to the suid
smaIdxKey.uid = uid; smaIdxKey.uid = uid;
smaIdxKey.smaUid = INT64_MIN; smaIdxKey.smaUid = INT64_MIN;
tdbTbcMoveTo(pSmaCur->pCur, &smaIdxKey, sizeof(smaIdxKey), &c); (void)tdbTbcMoveTo(pSmaCur->pCur, &smaIdxKey, sizeof(smaIdxKey), &c);
if (c > 0) { if (c > 0) {
tdbTbcMoveToNext(pSmaCur->pCur); (void)tdbTbcMoveToNext(pSmaCur->pCur);
} }
return pSmaCur; return pSmaCur;
@ -765,7 +765,7 @@ void metaCloseSmaCursor(SMSmaCursor *pSmaCur) {
if (pSmaCur) { if (pSmaCur) {
if (pSmaCur->pMeta) metaULock(pSmaCur->pMeta); if (pSmaCur->pMeta) metaULock(pSmaCur->pMeta);
if (pSmaCur->pCur) { if (pSmaCur->pCur) {
tdbTbcClose(pSmaCur->pCur); (void)tdbTbcClose(pSmaCur->pCur);
tdbFree(pSmaCur->pKey); tdbFree(pSmaCur->pKey);
tdbFree(pSmaCur->pVal); tdbFree(pSmaCur->pVal);
@ -863,7 +863,7 @@ STSmaWrapper *metaGetSmaInfoByTable(SMeta *pMeta, tb_uid_t uid, bool deepCopy) {
_err: _err:
metaReaderClear(&mr); metaReaderClear(&mr);
taosArrayDestroy(pSmaIds); taosArrayDestroy(pSmaIds);
tFreeTSmaWrapper(pSW, deepCopy); (void)tFreeTSmaWrapper(pSW, deepCopy);
return NULL; return NULL;
} }
@ -1086,7 +1086,7 @@ int32_t metaFilterCreateTime(void *pVnode, SMetaFltParam *arg, SArray *pUids) {
END: END:
if (pCursor->pMeta) metaULock(pCursor->pMeta); if (pCursor->pMeta) metaULock(pCursor->pMeta);
if (pCursor->pCur) tdbTbcClose(pCursor->pCur); if (pCursor->pCur) (void)tdbTbcClose(pCursor->pCur);
taosMemoryFree(pCursor); taosMemoryFree(pCursor);
return ret; return ret;
} }
@ -1153,7 +1153,7 @@ int32_t metaFilterTableName(void *pVnode, SMetaFltParam *arg, SArray *pUids) {
END: END:
if (pCursor->pMeta) metaULock(pCursor->pMeta); if (pCursor->pMeta) metaULock(pCursor->pMeta);
if (pCursor->pCur) tdbTbcClose(pCursor->pCur); if (pCursor->pCur) (void)tdbTbcClose(pCursor->pCur);
taosMemoryFree(buf); taosMemoryFree(buf);
taosMemoryFree(pKey); taosMemoryFree(pKey);
@ -1182,7 +1182,7 @@ int32_t metaFilterTtl(void *pVnode, SMetaFltParam *arg, SArray *pUids) {
END: END:
if (pCursor->pMeta) metaULock(pCursor->pMeta); if (pCursor->pMeta) metaULock(pCursor->pMeta);
if (pCursor->pCur) tdbTbcClose(pCursor->pCur); if (pCursor->pCur) (void)tdbTbcClose(pCursor->pCur);
taosMemoryFree(buf); taosMemoryFree(buf);
taosMemoryFree(pKey); taosMemoryFree(pKey);
@ -1221,7 +1221,7 @@ int32_t metaFilterTableIds(void *pVnode, SMetaFltParam *arg, SArray *pUids) {
} }
tbDbKey.uid = param->suid; tbDbKey.uid = param->suid;
tbDbKey.version = ((SUidIdxVal *)pData)[0].version; tbDbKey.version = ((SUidIdxVal *)pData)[0].version;
tdbTbGet(pMeta->pTbDb, &tbDbKey, sizeof(tbDbKey), &pData, &nData); (void)tdbTbGet(pMeta->pTbDb, &tbDbKey, sizeof(tbDbKey), &pData, &nData);
tDecoderInit(&dc, pData, nData); tDecoderInit(&dc, pData, nData);
ret = metaDecodeEntry(&dc, &oStbEntry); ret = metaDecodeEntry(&dc, &oStbEntry);
@ -1353,7 +1353,7 @@ int32_t metaFilterTableIds(void *pVnode, SMetaFltParam *arg, SArray *pUids) {
END: END:
if (pCursor->pMeta) metaULock(pCursor->pMeta); 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); if (oStbEntry.pBuf) taosMemoryFree(oStbEntry.pBuf);
tDecoderClear(&dc); tDecoderClear(&dc);
tdbFree(pData); tdbFree(pData);
@ -1427,7 +1427,7 @@ int32_t metaGetTableTags(void *pVnode, uint64_t suid, SArray *pUidTagInfo) {
taosHashInit(numOfElems / 0.7, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK); taosHashInit(numOfElems / 0.7, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK);
for (int i = 0; i < numOfElems; i++) { for (int i = 0; i < numOfElems; i++) {
STUidTagInfo *pTagInfo = taosArrayGet(pUidTagInfo, i); STUidTagInfo *pTagInfo = taosArrayGet(pUidTagInfo, i);
taosHashPut(pSepecifiedUidMap, &pTagInfo->uid, sizeof(uint64_t), &i, sizeof(int32_t)); (void)taosHashPut(pSepecifiedUidMap, &pTagInfo->uid, sizeof(uint64_t), &i, sizeof(int32_t));
} }
} }
@ -1513,7 +1513,7 @@ int32_t metaGetInfo(SMeta *pMeta, int64_t uid, SMetaInfo *pInfo, SMetaReader *pR
} }
// upsert the cache // upsert the cache
metaWLock(pMeta); metaWLock(pMeta);
metaCacheUpsert(pMeta, pInfo); (void)metaCacheUpsert(pMeta, pInfo);
metaULock(pMeta); metaULock(pMeta);
if (lock) { if (lock) {
@ -1565,7 +1565,7 @@ int32_t metaGetStbStats(void *pVnode, int64_t uid, int64_t *numOfTables, int32_t
// upsert the cache // upsert the cache
metaWLock(pVnodeObj->pMeta); metaWLock(pVnodeObj->pMeta);
metaStatsCacheUpsert(pVnodeObj->pMeta, &state); (void)metaStatsCacheUpsert(pVnodeObj->pMeta, &state);
metaULock(pVnodeObj->pMeta); metaULock(pVnodeObj->pMeta);
_exit: _exit:
@ -1578,6 +1578,6 @@ void metaUpdateStbStats(SMeta *pMeta, int64_t uid, int64_t deltaCtb, int32_t del
if (metaStatsCacheGet(pMeta, uid, &stats) == TSDB_CODE_SUCCESS) { if (metaStatsCacheGet(pMeta, uid, &stats) == TSDB_CODE_SUCCESS) {
stats.ctbNum += deltaCtb; stats.ctbNum += deltaCtb;
stats.colNum += deltaCol; stats.colNum += deltaCol;
metaStatsCacheUpsert(pMeta, &stats); (void)metaStatsCacheUpsert(pMeta, &stats);
} }
} }

20
source/dnode/vnode/src/meta/metaSnapshot.c
View File

@ -59,7 +59,7 @@ _exit:
void metaSnapReaderClose(SMetaSnapReader** ppReader) { void metaSnapReaderClose(SMetaSnapReader** ppReader) {
if (ppReader && *ppReader) { if (ppReader && *ppReader) {
tdbTbcClose((*ppReader)->pTbc); (void)tdbTbcClose((*ppReader)->pTbc);
taosMemoryFree(*ppReader); taosMemoryFree(*ppReader);
*ppReader = NULL; *ppReader = NULL;
} }
@ -87,7 +87,7 @@ int32_t metaSnapRead(SMetaSnapReader* pReader, uint8_t** ppData) {
if (key.version < pReader->sver // if (key.version < pReader->sver //
|| metaGetInfo(pReader->pMeta, key.uid, &info, NULL) == TSDB_CODE_NOT_FOUND) { || metaGetInfo(pReader->pMeta, key.uid, &info, NULL) == TSDB_CODE_NOT_FOUND) {
tdbTbcMoveToNext(pReader->pTbc); (void)tdbTbcMoveToNext(pReader->pTbc);
continue; 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", metaDebug("vgId:%d, vnode snapshot meta read data, version:%" PRId64 " uid:%" PRId64 " blockLen:%d",
TD_VID(pReader->pMeta->pVnode), key.version, key.uid, nData); TD_VID(pReader->pMeta->pVnode), key.version, key.uid, nData);
tdbTbcMoveToNext(pReader->pTbc); (void)tdbTbcMoveToNext(pReader->pTbc);
break; break;
} }
@ -233,7 +233,7 @@ static int32_t MoveToSnapShotVersion(SSnapContext* ctx) {
return TAOS_GET_TERRNO(code); return TAOS_GET_TERRNO(code);
} }
if (c < 0) { if (c < 0) {
tdbTbcMoveToPrev((TBC*)ctx->pCur); (void)tdbTbcMoveToPrev((TBC*)ctx->pCur);
} }
return 0; return 0;
} }
@ -296,7 +296,8 @@ static int32_t saveSuperTableInfoForChildTable(SMetaEntry* me, SHashObj* suidInf
END: END:
destroySTableInfoForChildTable(&dataTmp); 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, int32_t buildSnapContext(SVnode* pVnode, int64_t snapVersion, int64_t suid, int8_t subType, int8_t withMeta,
@ -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); ctx->suidInfo = taosHashInit(100, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, HASH_NO_LOCK);
if (ctx->suidInfo == NULL) { 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); taosHashSetFreeFp(ctx->suidInfo, destroySTableInfoForChildTable);
ctx->index = 0; ctx->index = 0;
ctx->idList = taosArrayInit(100, sizeof(int64_t)); ctx->idList = taosArrayInit(100, sizeof(int64_t));
if (ctx->idList == NULL) { if (ctx->idList == NULL) {
return TAOS_GET_TERRNO(TSDB_CODE_OUT_OF_MEMORY);; return TAOS_GET_TERRNO(TSDB_CODE_OUT_OF_MEMORY);
;
} }
void* pKey = NULL; void* pKey = NULL;
void* pVal = NULL; void* pVal = NULL;
@ -348,7 +351,8 @@ int32_t buildSnapContext(SVnode* pVnode, int64_t snapVersion, int64_t suid, int8
continue; 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; continue;
} }

341
source/dnode/vnode/src/meta/metaTable.c
View File

@ -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); term = indexTermCreate(suid, ADD_VALUE, TSDB_DATA_TYPE_BOOL, key, nKey, (const char *)&val, len);
} }
if (term != NULL) { if (term != NULL) {
indexMultiTermAdd(terms, term); (void)indexMultiTermAdd(terms, term);
} }
} }
indexJsonPut(pMeta->pTagIvtIdx, terms, tuid); (void)indexJsonPut(pMeta->pTagIvtIdx, terms, tuid);
indexMultiTermDestroy(terms); indexMultiTermDestroy(terms);
taosArrayDestroy(pTagVals); taosArrayDestroy(pTagVals);
@ -223,10 +223,10 @@ int metaDelJsonVarFromIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry, const SSche
term = indexTermCreate(suid, DEL_VALUE, TSDB_DATA_TYPE_BOOL, key, nKey, (const char *)&val, len); term = indexTermCreate(suid, DEL_VALUE, TSDB_DATA_TYPE_BOOL, key, nKey, (const char *)&val, len);
} }
if (term != NULL) { if (term != NULL) {
indexMultiTermAdd(terms, term); (void)indexMultiTermAdd(terms, term);
} }
} }
indexJsonPut(pMeta->pTagIvtIdx, terms, tuid); (void)indexJsonPut(pMeta->pTagIvtIdx, terms, tuid);
indexMultiTermDestroy(terms); indexMultiTermDestroy(terms);
taosArrayDestroy(pTagVals); taosArrayDestroy(pTagVals);
#endif #endif
@ -239,7 +239,7 @@ static inline void metaTimeSeriesNotifyCheck(SMeta *pMeta) {
int64_t deltaTS = nTimeSeries - pMeta->pVnode->config.vndStats.numOfReportedTimeSeries; int64_t deltaTS = nTimeSeries - pMeta->pVnode->config.vndStats.numOfReportedTimeSeries;
if (deltaTS > tsTimeSeriesThreshold) { if (deltaTS > tsTimeSeriesThreshold) {
if (0 == atomic_val_compare_exchange_8(&dmNotifyHdl.state, 1, 2)) { if (0 == atomic_val_compare_exchange_8(&dmNotifyHdl.state, 1, 2)) {
tsem_post(&dmNotifyHdl.sem); (void)tsem_post(&dmNotifyHdl.sem);
} }
} }
#endif #endif
@ -323,10 +323,10 @@ int metaDropSTable(SMeta *pMeta, int64_t verison, SVDropStbReq *pReq, SArray *tb
// drop all child tables // drop all child tables
TBC *pCtbIdxc = NULL; 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); rc = tdbTbcMoveTo(pCtbIdxc, &(SCtbIdxKey){.suid = pReq->suid, .uid = INT64_MIN}, sizeof(SCtbIdxKey), &c);
if (rc < 0) { if (rc < 0) {
tdbTbcClose(pCtbIdxc); (void)tdbTbcClose(pCtbIdxc);
metaWLock(pMeta); metaWLock(pMeta);
goto _drop_super_table; 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)); (void)taosArrayPush(tbUidList, &(((SCtbIdxKey *)pKey)->uid));
} }
tdbTbcClose(pCtbIdxc); (void)tdbTbcClose(pCtbIdxc);
(void)tsdbCacheDropSubTables(pMeta->pVnode->pTsdb, tbUidList, pReq->suid); (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++) { for (int32_t iChild = 0; iChild < taosArrayGetSize(tbUidList); iChild++) {
tb_uid_t uid = *(tb_uid_t *)taosArrayGet(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
_drop_super_table: _drop_super_table:
tdbTbGet(pMeta->pUidIdx, &pReq->suid, sizeof(tb_uid_t), &pData, &nData); tdbTbGet(pMeta->pUidIdx, &pReq->suid, sizeof(tb_uid_t), &pData, &nData);
tdbTbDelete(pMeta->pTbDb, &(STbDbKey){.version = ((SUidIdxVal *)pData)[0].version, .uid = pReq->suid}, (void)tdbTbDelete(pMeta->pTbDb, &(STbDbKey){.version = ((SUidIdxVal *)pData)[0].version, .uid = pReq->suid},
sizeof(STbDbKey), pMeta->txn); sizeof(STbDbKey), pMeta->txn);
tdbTbDelete(pMeta->pNameIdx, pReq->name, strlen(pReq->name) + 1, pMeta->txn); (void)tdbTbDelete(pMeta->pNameIdx, pReq->name, strlen(pReq->name) + 1, pMeta->txn);
tdbTbDelete(pMeta->pUidIdx, &pReq->suid, sizeof(tb_uid_t), pMeta->txn); (void)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->pSuidIdx, &pReq->suid, sizeof(tb_uid_t), pMeta->txn);
metaStatsCacheDrop(pMeta, pReq->suid); (void)metaStatsCacheDrop(pMeta, pReq->suid);
metaULock(pMeta); metaULock(pMeta);
@ -387,10 +387,10 @@ static void metaGetSubtables(SMeta *pMeta, int64_t suid, SArray *uids) {
int nKey = 0; int nKey = 0;
TBC *pCtbIdxc = NULL; 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); int rc = tdbTbcMoveTo(pCtbIdxc, &(SCtbIdxKey){.suid = suid, .uid = INT64_MIN}, sizeof(SCtbIdxKey), &c);
if (rc < 0) { if (rc < 0) {
tdbTbcClose(pCtbIdxc); (void)tdbTbcClose(pCtbIdxc);
metaWLock(pMeta); metaWLock(pMeta);
return; return;
} }
@ -410,7 +410,7 @@ static void metaGetSubtables(SMeta *pMeta, int64_t suid, SArray *uids) {
tdbFree(pKey); tdbFree(pKey);
tdbTbcClose(pCtbIdxc); (void)tdbTbcClose(pCtbIdxc);
} }
int metaAlterSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) { 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 ret;
int32_t c = -2; 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); ret = tdbTbcMoveTo(pUidIdxc, &pReq->suid, sizeof(tb_uid_t), &c);
if (ret < 0 || c) { if (ret < 0 || c) {
tdbTbcClose(pUidIdxc); (void)tdbTbcClose(pUidIdxc);
return terrno = TSDB_CODE_TDB_STB_NOT_EXIST; return terrno = TSDB_CODE_TDB_STB_NOT_EXIST;
} }
ret = tdbTbcGet(pUidIdxc, NULL, NULL, &pData, &nData); ret = tdbTbcGet(pUidIdxc, NULL, NULL, &pData, &nData);
if (ret < 0) { if (ret < 0) {
tdbTbcClose(pUidIdxc); (void)tdbTbcClose(pUidIdxc);
return terrno = TSDB_CODE_TDB_STB_NOT_EXIST; return terrno = TSDB_CODE_TDB_STB_NOT_EXIST;
} }
oversion = ((SUidIdxVal *)pData)[0].version; 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); ret = tdbTbcMoveTo(pTbDbc, &((STbDbKey){.uid = pReq->suid, .version = oversion}), sizeof(STbDbKey), &c);
if (!(ret == 0 && c == 0)) { if (!(ret == 0 && c == 0)) {
tdbTbcClose(pUidIdxc); (void)tdbTbcClose(pUidIdxc);
tdbTbcClose(pTbDbc); (void)tdbTbcClose(pTbDbc);
metaError("meta/table: invalide ret: %" PRId32 " or c: %" PRId32 "alter stb failed.", ret, c); metaError("meta/table: invalide ret: %" PRId32 " or c: %" PRId32 "alter stb failed.", ret, c);
return terrno = TSDB_CODE_TDB_STB_NOT_EXIST; 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); ret = tdbTbcGet(pTbDbc, NULL, NULL, &pData, &nData);
if (ret < 0) { if (ret < 0) {
tdbTbcClose(pUidIdxc); (void)tdbTbcClose(pUidIdxc);
tdbTbcClose(pTbDbc); (void)tdbTbcClose(pTbDbc);
return terrno = TSDB_CODE_TDB_STB_NOT_EXIST; return terrno = TSDB_CODE_TDB_STB_NOT_EXIST;
} }
@ -463,7 +463,7 @@ int metaAlterSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) {
oStbEntry.pBuf = taosMemoryMalloc(nData); oStbEntry.pBuf = taosMemoryMalloc(nData);
memcpy(oStbEntry.pBuf, pData, nData); memcpy(oStbEntry.pBuf, pData, nData);
tDecoderInit(&dc, oStbEntry.pBuf, nData); tDecoderInit(&dc, oStbEntry.pBuf, nData);
metaDecodeEntry(&dc, &oStbEntry); (void)metaDecodeEntry(&dc, &oStbEntry);
nStbEntry.version = version; nStbEntry.version = version;
nStbEntry.type = TSDB_SUPER_TABLE; nStbEntry.type = TSDB_SUPER_TABLE;
@ -487,7 +487,7 @@ int metaAlterSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) {
int8_t col_type = pReq->schemaRow.pSchema[nCols - 1].type; int8_t col_type = pReq->schemaRow.pSchema[nCols - 1].type;
metaGetSubtables(pMeta, pReq->suid, uids); metaGetSubtables(pMeta, pReq->suid, uids);
tsdbCacheNewSTableColumn(pTsdb, uids, cid, col_type); (void)tsdbCacheNewSTableColumn(pTsdb, uids, cid, col_type);
} else if (deltaCol == -1) { } else if (deltaCol == -1) {
int16_t cid = -1; int16_t cid = -1;
bool hasPrimaryKey = false; bool hasPrimaryKey = false;
@ -503,7 +503,7 @@ int metaAlterSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) {
if (cid != -1) { if (cid != -1) {
metaGetSubtables(pMeta, pReq->suid, uids); metaGetSubtables(pMeta, pReq->suid, uids);
tsdbCacheDropSTableColumn(pTsdb, uids, cid, hasPrimaryKey); (void)tsdbCacheDropSTableColumn(pTsdb, uids, cid, hasPrimaryKey);
} }
} }
if (uids) taosArrayDestroy(uids); if (uids) taosArrayDestroy(uids);
@ -512,25 +512,25 @@ int metaAlterSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) {
metaWLock(pMeta); metaWLock(pMeta);
// compare two entry // compare two entry
if (oStbEntry.stbEntry.schemaRow.version != pReq->schemaRow.version) { if (oStbEntry.stbEntry.schemaRow.version != pReq->schemaRow.version) {
metaSaveToSkmDb(pMeta, &nStbEntry); (void)metaSaveToSkmDb(pMeta, &nStbEntry);
} }
// update table.db // update table.db
metaSaveToTbDb(pMeta, &nStbEntry); (void)metaSaveToTbDb(pMeta, &nStbEntry);
// update uid index // update uid index
metaUpdateUidIdx(pMeta, &nStbEntry); (void)metaUpdateUidIdx(pMeta, &nStbEntry);
// metaStatsCacheDrop(pMeta, nStbEntry.uid); // metaStatsCacheDrop(pMeta, nStbEntry.uid);
if (updStat) { if (updStat) {
metaUpdateStbStats(pMeta, pReq->suid, 0, deltaCol); (void)metaUpdateStbStats(pMeta, pReq->suid, 0, deltaCol);
} }
metaULock(pMeta); metaULock(pMeta);
if (updStat) { if (updStat) {
int64_t ctbNum; int64_t ctbNum;
metaGetStbStats(pMeta->pVnode, pReq->suid, &ctbNum, NULL); (void)metaGetStbStats(pMeta->pVnode, pReq->suid, &ctbNum, NULL);
pMeta->pVnode->config.vndStats.numOfTimeSeries += (ctbNum * deltaCol); pMeta->pVnode->config.vndStats.numOfTimeSeries += (ctbNum * deltaCol);
metaTimeSeriesNotifyCheck(pMeta); metaTimeSeriesNotifyCheck(pMeta);
} }
@ -540,8 +540,8 @@ int metaAlterSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) {
_exit: _exit:
if (oStbEntry.pBuf) taosMemoryFree(oStbEntry.pBuf); if (oStbEntry.pBuf) taosMemoryFree(oStbEntry.pBuf);
tDecoderClear(&dc); tDecoderClear(&dc);
tdbTbcClose(pTbDbc); (void)tdbTbcClose(pTbDbc);
tdbTbcClose(pUidIdxc); (void)tdbTbcClose(pUidIdxc);
return 0; return 0;
} }
int metaAddIndexToSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) { int metaAddIndexToSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) {
@ -568,7 +568,7 @@ int metaAddIndexToSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) {
tbDbKey.uid = suid; tbDbKey.uid = suid;
tbDbKey.version = ((SUidIdxVal *)pData)[0].version; tbDbKey.version = ((SUidIdxVal *)pData)[0].version;
tdbTbGet(pMeta->pTbDb, &tbDbKey, sizeof(tbDbKey), &pData, &nData); (void)tdbTbGet(pMeta->pTbDb, &tbDbKey, sizeof(tbDbKey), &pData, &nData);
tDecoderInit(&dc, pData, nData); tDecoderInit(&dc, pData, nData);
ret = metaDecodeEntry(&dc, &oStbEntry); ret = metaDecodeEntry(&dc, &oStbEntry);
@ -619,10 +619,10 @@ int metaAddIndexToSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) {
* iterator all pTdDbc by uid and version * iterator all pTdDbc by uid and version
*/ */
TBC *pCtbIdxc = NULL; 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); int rc = tdbTbcMoveTo(pCtbIdxc, &(SCtbIdxKey){.suid = suid, .uid = INT64_MIN}, sizeof(SCtbIdxKey), &c);
if (rc < 0) { if (rc < 0) {
tdbTbcClose(pCtbIdxc); (void)tdbTbcClose(pCtbIdxc);
goto _err; goto _err;
} }
for (;;) { for (;;) {
@ -632,7 +632,7 @@ int metaAddIndexToSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) {
if (rc < 0) { if (rc < 0) {
tdbFree(pKey); tdbFree(pKey);
tdbFree(pVal); tdbFree(pVal);
tdbTbcClose(pCtbIdxc); (void)tdbTbcClose(pCtbIdxc);
pCtbIdxc = NULL; pCtbIdxc = NULL;
break; break;
} }
@ -667,12 +667,12 @@ int metaAddIndexToSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) {
tdbFree(pVal); tdbFree(pVal);
if (rc < 0) { if (rc < 0) {
metaDestroyTagIdxKey(pTagIdxKey); metaDestroyTagIdxKey(pTagIdxKey);
tdbTbcClose(pCtbIdxc); (void)tdbTbcClose(pCtbIdxc);
goto _err; goto _err;
} }
metaWLock(pMeta); metaWLock(pMeta);
tdbTbUpsert(pMeta->pTagIdx, pTagIdxKey, nTagIdxKey, NULL, 0, pMeta->txn); (void)tdbTbUpsert(pMeta->pTagIdx, pTagIdxKey, nTagIdxKey, NULL, 0, pMeta->txn);
metaULock(pMeta); metaULock(pMeta);
metaDestroyTagIdxKey(pTagIdxKey); metaDestroyTagIdxKey(pTagIdxKey);
pTagIdxKey = NULL; pTagIdxKey = NULL;
@ -688,16 +688,16 @@ int metaAddIndexToSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) {
metaWLock(pMeta); metaWLock(pMeta);
// update table.db // update table.db
metaSaveToTbDb(pMeta, &nStbEntry); (void)metaSaveToTbDb(pMeta, &nStbEntry);
// update uid index // update uid index
metaUpdateUidIdx(pMeta, &nStbEntry); (void)metaUpdateUidIdx(pMeta, &nStbEntry);
metaULock(pMeta); metaULock(pMeta);
if (oStbEntry.pBuf) taosMemoryFree(oStbEntry.pBuf); if (oStbEntry.pBuf) taosMemoryFree(oStbEntry.pBuf);
tDecoderClear(&dc); tDecoderClear(&dc);
tdbFree(pData); tdbFree(pData);
tdbTbcClose(pCtbIdxc); (void)tdbTbcClose(pCtbIdxc);
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
_err: _err:
if (oStbEntry.pBuf) taosMemoryFree(oStbEntry.pBuf); if (oStbEntry.pBuf) taosMemoryFree(oStbEntry.pBuf);
@ -729,7 +729,7 @@ int metaDropIndexFromSTable(SMeta *pMeta, int64_t version, SDropIndexReq *pReq)
tbDbKey.uid = suid; tbDbKey.uid = suid;
tbDbKey.version = ((SUidIdxVal *)pData)[0].version; tbDbKey.version = ((SUidIdxVal *)pData)[0].version;
tdbTbGet(pMeta->pTbDb, &tbDbKey, sizeof(tbDbKey), &pData, &nData); (void)tdbTbGet(pMeta->pTbDb, &tbDbKey, sizeof(tbDbKey), &pData, &nData);
tDecoderInit(&dc, pData, nData); tDecoderInit(&dc, pData, nData);
ret = metaDecodeEntry(&dc, &oStbEntry); ret = metaDecodeEntry(&dc, &oStbEntry);
if (ret < 0) { if (ret < 0) {
@ -756,10 +756,10 @@ int metaDropIndexFromSTable(SMeta *pMeta, int64_t version, SDropIndexReq *pReq)
* iterator all pTdDbc by uid and version * iterator all pTdDbc by uid and version
*/ */
TBC *pCtbIdxc = NULL; 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); int rc = tdbTbcMoveTo(pCtbIdxc, &(SCtbIdxKey){.suid = suid, .uid = INT64_MIN}, sizeof(SCtbIdxKey), &c);
if (rc < 0) { if (rc < 0) {
tdbTbcClose(pCtbIdxc); (void)tdbTbcClose(pCtbIdxc);
goto _err; goto _err;
} }
for (;;) { for (;;) {
@ -769,7 +769,7 @@ int metaDropIndexFromSTable(SMeta *pMeta, int64_t version, SDropIndexReq *pReq)
if (rc < 0) { if (rc < 0) {
tdbFree(pKey); tdbFree(pKey);
tdbFree(pVal); tdbFree(pVal);
tdbTbcClose(pCtbIdxc); (void)tdbTbcClose(pCtbIdxc);
pCtbIdxc = NULL; pCtbIdxc = NULL;
break; break;
} }
@ -804,12 +804,12 @@ int metaDropIndexFromSTable(SMeta *pMeta, int64_t version, SDropIndexReq *pReq)
tdbFree(pVal); tdbFree(pVal);
if (rc < 0) { if (rc < 0) {
metaDestroyTagIdxKey(pTagIdxKey); metaDestroyTagIdxKey(pTagIdxKey);
tdbTbcClose(pCtbIdxc); (void)tdbTbcClose(pCtbIdxc);
goto _err; goto _err;
} }
metaWLock(pMeta); metaWLock(pMeta);
tdbTbDelete(pMeta->pTagIdx, pTagIdxKey, nTagIdxKey, pMeta->txn); (void)tdbTbDelete(pMeta->pTagIdx, pTagIdxKey, nTagIdxKey, pMeta->txn);
metaULock(pMeta); metaULock(pMeta);
metaDestroyTagIdxKey(pTagIdxKey); metaDestroyTagIdxKey(pTagIdxKey);
pTagIdxKey = NULL; pTagIdxKey = NULL;
@ -836,9 +836,9 @@ int metaDropIndexFromSTable(SMeta *pMeta, int64_t version, SDropIndexReq *pReq)
metaWLock(pMeta); metaWLock(pMeta);
// update table.db // update table.db
metaSaveToTbDb(pMeta, &nStbEntry); (void)metaSaveToTbDb(pMeta, &nStbEntry);
// update uid index // update uid index
metaUpdateUidIdx(pMeta, &nStbEntry); (void)metaUpdateUidIdx(pMeta, &nStbEntry);
metaULock(pMeta); metaULock(pMeta);
tDeleteSchemaWrapper(tag); tDeleteSchemaWrapper(tag);
@ -849,7 +849,7 @@ int metaDropIndexFromSTable(SMeta *pMeta, int64_t version, SDropIndexReq *pReq)
tDecoderClear(&dc); tDecoderClear(&dc);
tdbFree(pData); tdbFree(pData);
tdbTbcClose(pCtbIdxc); (void)tdbTbcClose(pCtbIdxc);
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
_err: _err:
if (oStbEntry.pBuf) taosMemoryFree(oStbEntry.pBuf); if (oStbEntry.pBuf) taosMemoryFree(oStbEntry.pBuf);
@ -937,18 +937,18 @@ int metaCreateTable(SMeta *pMeta, int64_t ver, SVCreateTbReq *pReq, STableMetaRs
if (!sysTbl) { if (!sysTbl) {
int32_t nCols = 0; int32_t nCols = 0;
metaGetStbStats(pMeta->pVnode, me.ctbEntry.suid, 0, &nCols); (void)metaGetStbStats(pMeta->pVnode, me.ctbEntry.suid, 0, &nCols);
pStats->numOfTimeSeries += nCols - 1; pStats->numOfTimeSeries += nCols - 1;
} }
metaWLock(pMeta); metaWLock(pMeta);
metaUpdateStbStats(pMeta, me.ctbEntry.suid, 1, 0); (void)metaUpdateStbStats(pMeta, me.ctbEntry.suid, 1, 0);
metaUidCacheClear(pMeta, me.ctbEntry.suid); (void)metaUidCacheClear(pMeta, me.ctbEntry.suid);
metaTbGroupCacheClear(pMeta, me.ctbEntry.suid); (void)metaTbGroupCacheClear(pMeta, me.ctbEntry.suid);
metaULock(pMeta); metaULock(pMeta);
if (!TSDB_CACHE_NO(pMeta->pVnode->config)) { if (!TSDB_CACHE_NO(pMeta->pVnode->config)) {
tsdbCacheNewTable(pMeta->pVnode->pTsdb, me.uid, me.ctbEntry.suid, NULL); (void)tsdbCacheNewTable(pMeta->pVnode->pTsdb, me.uid, me.ctbEntry.suid, NULL);
} }
} else { } else {
me.ntbEntry.btime = pReq->btime; me.ntbEntry.btime = pReq->btime;
@ -964,7 +964,7 @@ int metaCreateTable(SMeta *pMeta, int64_t ver, SVCreateTbReq *pReq, STableMetaRs
pStats->numOfNTimeSeries += me.ntbEntry.schemaRow.nCols - 1; pStats->numOfNTimeSeries += me.ntbEntry.schemaRow.nCols - 1;
if (!TSDB_CACHE_NO(pMeta->pVnode->config)) { if (!TSDB_CACHE_NO(pMeta->pVnode->config)) {
tsdbCacheNewTable(pMeta->pVnode->pTsdb, me.uid, -1, &me.ntbEntry.schemaRow); (void)tsdbCacheNewTable(pMeta->pVnode->pTsdb, me.uid, -1, &me.ntbEntry.schemaRow);
} }
} }
@ -982,7 +982,7 @@ int metaCreateTable(SMeta *pMeta, int64_t ver, SVCreateTbReq *pReq, STableMetaRs
(*pMetaRsp)->suid = pReq->ctb.suid; (*pMetaRsp)->suid = pReq->ctb.suid;
strcpy((*pMetaRsp)->tbName, pReq->name); strcpy((*pMetaRsp)->tbName, pReq->name);
} else { } 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++) { for (int32_t i = 0; i < pReq->colCmpr.nCols; i++) {
SColCmpr *p = &pReq->colCmpr.pColCmpr[i]; SColCmpr *p = &pReq->colCmpr.pColCmpr[i];
(*pMetaRsp)->pSchemaExt[i].colId = p->id; (*pMetaRsp)->pSchemaExt[i].colId = p->id;
@ -1036,7 +1036,7 @@ int metaDropTable(SMeta *pMeta, int64_t version, SVDropTbReq *pReq, SArray *tbUi
(void)taosArrayPush(tbUids, &uid); (void)taosArrayPush(tbUids, &uid);
if (!TSDB_CACHE_NO(pMeta->pVnode->config)) { if (!TSDB_CACHE_NO(pMeta->pVnode->config)) {
tsdbCacheDropTable(pMeta->pVnode->pTsdb, uid, suid, NULL); (void)tsdbCacheDropTable(pMeta->pVnode->pTsdb, uid, suid, NULL);
} }
} }
@ -1062,7 +1062,7 @@ void metaDropTables(SMeta *pMeta, SArray *tbUids) {
tb_uid_t suid = 0; tb_uid_t suid = 0;
int8_t sysTbl = 0; int8_t sysTbl = 0;
int type; int type;
metaDropTableByUid(pMeta, uid, &type, &suid, &sysTbl); (void)metaDropTableByUid(pMeta, uid, &type, &suid, &sysTbl);
if (!sysTbl && type == TSDB_CHILD_TABLE && suid != 0 && suidHash) { if (!sysTbl && type == TSDB_CHILD_TABLE && suid != 0 && suidHash) {
int64_t *pVal = tSimpleHashGet(suidHash, &suid, sizeof(tb_uid_t)); int64_t *pVal = tSimpleHashGet(suidHash, &suid, sizeof(tb_uid_t));
if (pVal) { if (pVal) {
@ -1070,7 +1070,7 @@ void metaDropTables(SMeta *pMeta, SArray *tbUids) {
} else { } else {
nCtbDropped = 1; nCtbDropped = 1;
} }
tSimpleHashPut(suidHash, &suid, sizeof(tb_uid_t), &nCtbDropped, sizeof(int64_t)); (void)tSimpleHashPut(suidHash, &suid, sizeof(tb_uid_t), &nCtbDropped, sizeof(int64_t));
} }
/* /*
if (!TSDB_CACHE_NO(pMeta->pVnode->config)) { if (!TSDB_CACHE_NO(pMeta->pVnode->config)) {
@ -1111,7 +1111,7 @@ static int32_t metaFilterTableByHash(SMeta *pMeta, SArray *uidList) {
code = tdbTbcMoveToFirst(pCur); code = tdbTbcMoveToFirst(pCur);
if (code) { if (code) {
tdbTbcClose(pCur); (void)tdbTbcClose(pCur);
return code; return code;
} }
@ -1127,7 +1127,7 @@ static int32_t metaFilterTableByHash(SMeta *pMeta, SArray *uidList) {
SMetaEntry me = {0}; SMetaEntry me = {0};
SDecoder dc = {0}; SDecoder dc = {0};
tDecoderInit(&dc, pData, nData); tDecoderInit(&dc, pData, nData);
metaDecodeEntry(&dc, &me); (void)metaDecodeEntry(&dc, &me);
if (me.type != TSDB_SUPER_TABLE) { if (me.type != TSDB_SUPER_TABLE) {
char tbFName[TSDB_TABLE_FNAME_LEN + 1]; char tbFName[TSDB_TABLE_FNAME_LEN + 1];
@ -1142,7 +1142,7 @@ static int32_t metaFilterTableByHash(SMeta *pMeta, SArray *uidList) {
} }
tdbFree(pData); tdbFree(pData);
tdbFree(pKey); tdbFree(pKey);
tdbTbcClose(pCur); (void)tdbTbcClose(pCur);
return 0; return 0;
} }
@ -1237,7 +1237,7 @@ static int metaDropTableByUid(SMeta *pMeta, tb_uid_t uid, int *type, tb_uid_t *p
} }
int64_t version = ((SUidIdxVal *)pData)[0].version; int64_t version = ((SUidIdxVal *)pData)[0].version;
tdbTbGet(pMeta->pTbDb, &(STbDbKey){.version = version, .uid = uid}, sizeof(STbDbKey), &pData, &nData); (void)tdbTbGet(pMeta->pTbDb, &(STbDbKey){.version = version, .uid = uid}, sizeof(STbDbKey), &pData, &nData);
tDecoderInit(&dc, pData, nData); tDecoderInit(&dc, pData, nData);
rc = metaDecodeEntry(&dc, &e); rc = metaDecodeEntry(&dc, &e);
@ -1260,7 +1260,7 @@ static int metaDropTableByUid(SMeta *pMeta, tb_uid_t uid, int *type, tb_uid_t *p
SMetaEntry stbEntry = {0}; SMetaEntry stbEntry = {0};
tDecoderInit(&tdc, tData, tLen); tDecoderInit(&tdc, tData, tLen);
metaDecodeEntry(&tdc, &stbEntry); (void)metaDecodeEntry(&tdc, &stbEntry);
if (pSysTbl) *pSysTbl = metaTbInFilterCache(pMeta, stbEntry.name, 1) ? 1 : 0; if (pSysTbl) *pSysTbl = metaTbInFilterCache(pMeta, stbEntry.name, 1) ? 1 : 0;
@ -1268,7 +1268,7 @@ static int metaDropTableByUid(SMeta *pMeta, tb_uid_t uid, int *type, tb_uid_t *p
SSchemaWrapper *pTagSchema = &stbEntry.stbEntry.schemaTag; SSchemaWrapper *pTagSchema = &stbEntry.stbEntry.schemaTag;
if (pTagSchema->nCols == 1 && pTagSchema->pSchema[0].type == TSDB_DATA_TYPE_JSON) { if (pTagSchema->nCols == 1 && pTagSchema->pSchema[0].type == TSDB_DATA_TYPE_JSON) {
pTagColumn = &stbEntry.stbEntry.schemaTag.pSchema[0]; pTagColumn = &stbEntry.stbEntry.schemaTag.pSchema[0];
metaDelJsonVarFromIdx(pMeta, &e, pTagColumn); (void)metaDelJsonVarFromIdx(pMeta, &e, pTagColumn);
} else { } else {
for (int i = 0; i < pTagSchema->nCols; i++) { for (int i = 0; i < pTagSchema->nCols; i++) {
pTagColumn = &stbEntry.stbEntry.schemaTag.pSchema[i]; pTagColumn = &stbEntry.stbEntry.schemaTag.pSchema[i];
@ -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, if (metaCreateTagIdxKey(e.ctbEntry.suid, pTagColumn->colId, pTagData, nTagData, pTagColumn->type, uid,
&pTagIdxKey, &nTagIdxKey) == 0) { &pTagIdxKey, &nTagIdxKey) == 0) {
tdbTbDelete(pMeta->pTagIdx, pTagIdxKey, nTagIdxKey, pMeta->txn); (void)tdbTbDelete(pMeta->pTagIdx, pTagIdxKey, nTagIdxKey, pMeta->txn);
} }
metaDestroyTagIdxKey(pTagIdxKey); metaDestroyTagIdxKey(pTagIdxKey);
pTagIdxKey = NULL; 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); (void)tdbTbDelete(pMeta->pTbDb, &(STbDbKey){.version = version, .uid = uid}, sizeof(STbDbKey), pMeta->txn);
tdbTbDelete(pMeta->pNameIdx, e.name, strlen(e.name) + 1, pMeta->txn); (void)tdbTbDelete(pMeta->pNameIdx, e.name, strlen(e.name) + 1, pMeta->txn);
tdbTbDelete(pMeta->pUidIdx, &uid, sizeof(uid), 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_CHILD_TABLE || e.type == TSDB_NORMAL_TABLE) metaDeleteBtimeIdx(pMeta, &e);
if (e.type == TSDB_NORMAL_TABLE) metaDeleteNcolIdx(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_SUPER_TABLE) metaDeleteTtl(pMeta, &e);
if (e.type == TSDB_CHILD_TABLE) { 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; --pMeta->pVnode->config.vndStats.numOfCTables;
metaUpdateStbStats(pMeta, e.ctbEntry.suid, -1, 0); (void)metaUpdateStbStats(pMeta, e.ctbEntry.suid, -1, 0);
metaUidCacheClear(pMeta, e.ctbEntry.suid); (void)metaUidCacheClear(pMeta, e.ctbEntry.suid);
metaTbGroupCacheClear(pMeta, e.ctbEntry.suid); (void)metaTbGroupCacheClear(pMeta, e.ctbEntry.suid);
/* /*
if (!TSDB_CACHE_NO(pMeta->pVnode->config)) { if (!TSDB_CACHE_NO(pMeta->pVnode->config)) {
tsdbCacheDropTable(pMeta->pVnode->pTsdb, e.uid, e.ctbEntry.suid, NULL); tsdbCacheDropTable(pMeta->pVnode->pTsdb, e.uid, e.ctbEntry.suid, NULL);
@ -1341,16 +1342,16 @@ static int metaDropTableByUid(SMeta *pMeta, tb_uid_t uid, int *type, tb_uid_t *p
} }
*/ */
} else if (e.type == TSDB_SUPER_TABLE) { } 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) // drop schema.db (todo)
metaStatsCacheDrop(pMeta, uid); (void)metaStatsCacheDrop(pMeta, uid);
metaUidCacheClear(pMeta, uid); (void)metaUidCacheClear(pMeta, uid);
metaTbGroupCacheClear(pMeta, uid); (void)metaTbGroupCacheClear(pMeta, uid);
--pMeta->pVnode->config.vndStats.numOfSTables; --pMeta->pVnode->config.vndStats.numOfSTables;
} }
metaCacheDrop(pMeta, uid); (void)metaCacheDrop(pMeta, uid);
tDecoderClear(&dc); tDecoderClear(&dc);
tdbFree(pData); tdbFree(pData);
@ -1423,30 +1424,30 @@ static int metaAlterTableColumn(SMeta *pMeta, int64_t version, SVAlterTbReq *pAl
// search uid index // search uid index
TBC *pUidIdxc = NULL; TBC *pUidIdxc = NULL;
tdbTbcOpen(pMeta->pUidIdx, &pUidIdxc, NULL); (void)tdbTbcOpen(pMeta->pUidIdx, &pUidIdxc, NULL);
tdbTbcMoveTo(pUidIdxc, &uid, sizeof(uid), &c); (void)tdbTbcMoveTo(pUidIdxc, &uid, sizeof(uid), &c);
if (c != 0) { if (c != 0) {
tdbTbcClose(pUidIdxc); (void)tdbTbcClose(pUidIdxc);
metaError("meta/table: invalide c: %" PRId32 " alt tb column failed.", c); metaError("meta/table: invalide c: %" PRId32 " alt tb column failed.", c);
return TSDB_CODE_FAILED; return TSDB_CODE_FAILED;
} }
tdbTbcGet(pUidIdxc, NULL, NULL, &pData, &nData); (void)tdbTbcGet(pUidIdxc, NULL, NULL, &pData, &nData);
oversion = ((SUidIdxVal *)pData)[0].version; oversion = ((SUidIdxVal *)pData)[0].version;
// search table.db // search table.db
TBC *pTbDbc = NULL; TBC *pTbDbc = NULL;
tdbTbcOpen(pMeta->pTbDb, &pTbDbc, NULL); (void)tdbTbcOpen(pMeta->pTbDb, &pTbDbc, NULL);
tdbTbcMoveTo(pTbDbc, &((STbDbKey){.uid = uid, .version = oversion}), sizeof(STbDbKey), &c); (void)tdbTbcMoveTo(pTbDbc, &((STbDbKey){.uid = uid, .version = oversion}), sizeof(STbDbKey), &c);
if (c != 0) { if (c != 0) {
tdbTbcClose(pUidIdxc); (void)tdbTbcClose(pUidIdxc);
tdbTbcClose(pTbDbc); (void)tdbTbcClose(pTbDbc);
metaError("meta/table: invalide c: %" PRId32 " alt tb column failed.", c); metaError("meta/table: invalide c: %" PRId32 " alt tb column failed.", c);
return TSDB_CODE_FAILED; return TSDB_CODE_FAILED;
} }
tdbTbcGet(pTbDbc, NULL, NULL, &pData, &nData); (void)tdbTbcGet(pTbDbc, NULL, NULL, &pData, &nData);
// get table entry // get table entry
SDecoder dc = {0}; SDecoder dc = {0};
@ -1455,8 +1456,8 @@ static int metaAlterTableColumn(SMeta *pMeta, int64_t version, SVAlterTbReq *pAl
tDecoderInit(&dc, entry.pBuf, nData); tDecoderInit(&dc, entry.pBuf, nData);
ret = metaDecodeEntry(&dc, &entry); ret = metaDecodeEntry(&dc, &entry);
if (ret != 0) { if (ret != 0) {
tdbTbcClose(pUidIdxc); (void)tdbTbcClose(pUidIdxc);
tdbTbcClose(pTbDbc); (void)tdbTbcClose(pTbDbc);
tDecoderClear(&dc); tDecoderClear(&dc);
metaError("meta/table: invalide ret: %" PRId32 " alt tb column failed.", ret); metaError("meta/table: invalide ret: %" PRId32 " alt tb column failed.", ret);
return ret; return ret;
@ -1536,7 +1537,7 @@ static int metaAlterTableColumn(SMeta *pMeta, int64_t version, SVAlterTbReq *pAl
SSchema *pCol = &pSchema->pSchema[entry.ntbEntry.schemaRow.nCols - 1]; SSchema *pCol = &pSchema->pSchema[entry.ntbEntry.schemaRow.nCols - 1];
uint32_t compress = pAlterTbReq->action == TSDB_ALTER_TABLE_ADD_COLUMN ? createDefaultColCmprByType(pCol->type) uint32_t compress = pAlterTbReq->action == TSDB_ALTER_TABLE_ADD_COLUMN ? createDefaultColCmprByType(pCol->type)
: pAlterTbReq->compress; : pAlterTbReq->compress;
updataTableColCmpr(&entry.colCmpr, pCol, 1, compress); (void)updataTableColCmpr(&entry.colCmpr, pCol, 1, compress);
freeColCmpr = true; freeColCmpr = true;
ASSERT(entry.colCmpr.nCols == pSchema->nCols); ASSERT(entry.colCmpr.nCols == pSchema->nCols);
break; break;
@ -1574,7 +1575,7 @@ static int metaAlterTableColumn(SMeta *pMeta, int64_t version, SVAlterTbReq *pAl
(void)tsdbCacheDropNTableColumn(pMeta->pVnode->pTsdb, entry.uid, cid, hasPrimayKey); (void)tsdbCacheDropNTableColumn(pMeta->pVnode->pTsdb, entry.uid, cid, hasPrimayKey);
} }
updataTableColCmpr(&entry.colCmpr, &tScheam, 0, 0); (void)updataTableColCmpr(&entry.colCmpr, &tScheam, 0, 0);
ASSERT(entry.colCmpr.nCols == pSchema->nCols); ASSERT(entry.colCmpr.nCols == pSchema->nCols);
break; break;
case TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES: case TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES:
@ -1620,20 +1621,20 @@ static int metaAlterTableColumn(SMeta *pMeta, int64_t version, SVAlterTbReq *pAl
// do actual write // do actual write
metaWLock(pMeta); metaWLock(pMeta);
metaDeleteNcolIdx(pMeta, &oldEntry); (void)metaDeleteNcolIdx(pMeta, &oldEntry);
metaUpdateNcolIdx(pMeta, &entry); (void)metaUpdateNcolIdx(pMeta, &entry);
// save to table db // 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); 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++) { for (int32_t i = 0; i < entry.colCmpr.nCols; i++) {
SColCmpr *p = &entry.colCmpr.pColCmpr[i]; SColCmpr *p = &entry.colCmpr.pColCmpr[i];
pMetaRsp->pSchemaExt[i].colId = p->id; 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 (pNewSchema) taosMemoryFree(pNewSchema);
if (freeColCmpr) taosMemoryFree(entry.colCmpr.pColCmpr); if (freeColCmpr) taosMemoryFree(entry.colCmpr.pColCmpr);
tdbTbcClose(pTbDbc); (void)tdbTbcClose(pTbDbc);
tdbTbcClose(pUidIdxc); (void)tdbTbcClose(pUidIdxc);
tDecoderClear(&dc); tDecoderClear(&dc);
return 0; return 0;
_err: _err:
if (entry.pBuf) taosMemoryFree(entry.pBuf); if (entry.pBuf) taosMemoryFree(entry.pBuf);
tdbTbcClose(pTbDbc); (void)tdbTbcClose(pTbDbc);
tdbTbcClose(pUidIdxc); (void)tdbTbcClose(pUidIdxc);
tDecoderClear(&dc); tDecoderClear(&dc);
return TSDB_CODE_FAILED; return TSDB_CODE_FAILED;
@ -1688,15 +1689,15 @@ static int metaUpdateTableTagVal(SMeta *pMeta, int64_t version, SVAlterTbReq *pA
// search uid index // search uid index
TBC *pUidIdxc = NULL; TBC *pUidIdxc = NULL;
tdbTbcOpen(pMeta->pUidIdx, &pUidIdxc, NULL); (void)tdbTbcOpen(pMeta->pUidIdx, &pUidIdxc, NULL);
tdbTbcMoveTo(pUidIdxc, &uid, sizeof(uid), &c); (void)tdbTbcMoveTo(pUidIdxc, &uid, sizeof(uid), &c);
if (c != 0) { if (c != 0) {
tdbTbcClose(pUidIdxc); (void)tdbTbcClose(pUidIdxc);
metaError("meta/table: invalide c: %" PRId32 " update tb tag val failed.", c); metaError("meta/table: invalide c: %" PRId32 " update tb tag val failed.", c);
return terrno = TSDB_CODE_TDB_TABLE_NOT_EXIST; return terrno = TSDB_CODE_TDB_TABLE_NOT_EXIST;
} }
tdbTbcGet(pUidIdxc, NULL, NULL, &pData, &nData); (void)tdbTbcGet(pUidIdxc, NULL, NULL, &pData, &nData);
oversion = ((SUidIdxVal *)pData)[0].version; oversion = ((SUidIdxVal *)pData)[0].version;
// search table.db // search table.db
@ -1705,34 +1706,34 @@ static int metaUpdateTableTagVal(SMeta *pMeta, int64_t version, SVAlterTbReq *pA
SDecoder dc2 = {0}; SDecoder dc2 = {0};
/* get ctbEntry */ /* get ctbEntry */
tdbTbcOpen(pMeta->pTbDb, &pTbDbc, NULL); (void)tdbTbcOpen(pMeta->pTbDb, &pTbDbc, NULL);
tdbTbcMoveTo(pTbDbc, &((STbDbKey){.uid = uid, .version = oversion}), sizeof(STbDbKey), &c); (void)tdbTbcMoveTo(pTbDbc, &((STbDbKey){.uid = uid, .version = oversion}), sizeof(STbDbKey), &c);
if (c != 0) { if (c != 0) {
tdbTbcClose(pUidIdxc); (void)tdbTbcClose(pUidIdxc);
tdbTbcClose(pTbDbc); (void)tdbTbcClose(pTbDbc);
metaError("meta/table: invalide c: %" PRId32 " update tb tag val failed.", c); metaError("meta/table: invalide c: %" PRId32 " update tb tag val failed.", c);
return terrno = TSDB_CODE_TDB_TABLE_NOT_EXIST; return terrno = TSDB_CODE_TDB_TABLE_NOT_EXIST;
} }
tdbTbcGet(pTbDbc, NULL, NULL, &pData, &nData); (void)tdbTbcGet(pTbDbc, NULL, NULL, &pData, &nData);
ctbEntry.pBuf = taosMemoryMalloc(nData); ctbEntry.pBuf = taosMemoryMalloc(nData);
memcpy(ctbEntry.pBuf, pData, nData); memcpy(ctbEntry.pBuf, pData, nData);
tDecoderInit(&dc1, ctbEntry.pBuf, nData); tDecoderInit(&dc1, ctbEntry.pBuf, nData);
metaDecodeEntry(&dc1, &ctbEntry); (void)metaDecodeEntry(&dc1, &ctbEntry);
/* get stbEntry*/ /* get stbEntry*/
tdbTbGet(pMeta->pUidIdx, &ctbEntry.ctbEntry.suid, sizeof(tb_uid_t), &pVal, &nVal); (void)tdbTbGet(pMeta->pUidIdx, &ctbEntry.ctbEntry.suid, sizeof(tb_uid_t), &pVal, &nVal);
if (!pVal) { if (!pVal) {
terrno = TSDB_CODE_INVALID_MSG; terrno = TSDB_CODE_INVALID_MSG;
goto _err; goto _err;
} }
tdbTbGet(pMeta->pTbDb, &((STbDbKey){.uid = ctbEntry.ctbEntry.suid, .version = ((SUidIdxVal *)pVal)[0].version}), (void)tdbTbGet(pMeta->pTbDb, &((STbDbKey){.uid = ctbEntry.ctbEntry.suid, .version = ((SUidIdxVal *)pVal)[0].version}),
sizeof(STbDbKey), (void **)&stbEntry.pBuf, &nVal); sizeof(STbDbKey), (void **)&stbEntry.pBuf, &nVal);
tdbFree(pVal); tdbFree(pVal);
tDecoderInit(&dc2, stbEntry.pBuf, nVal); tDecoderInit(&dc2, stbEntry.pBuf, nVal);
metaDecodeEntry(&dc2, &stbEntry); (void)metaDecodeEntry(&dc2, &stbEntry);
SSchemaWrapper *pTagSchema = &stbEntry.stbEntry.schemaTag; SSchemaWrapper *pTagSchema = &stbEntry.stbEntry.schemaTag;
SSchema *pColumn = NULL; SSchema *pColumn = NULL;
@ -1802,12 +1803,12 @@ static int metaUpdateTableTagVal(SMeta *pMeta, int64_t version, SVAlterTbReq *pA
metaWLock(pMeta); metaWLock(pMeta);
// save to table.db // save to table.db
metaSaveToTbDb(pMeta, &ctbEntry); (void)metaSaveToTbDb(pMeta, &ctbEntry);
// save to uid.idx // save to uid.idx
metaUpdateUidIdx(pMeta, &ctbEntry); (void)metaUpdateUidIdx(pMeta, &ctbEntry);
metaUpdateTagIdx(pMeta, &ctbEntry); (void)metaUpdateTagIdx(pMeta, &ctbEntry);
if (NULL == ctbEntry.ctbEntry.pTags) { if (NULL == ctbEntry.ctbEntry.pTags) {
metaError("meta/table: null tags, update tag val failed."); metaError("meta/table: null tags, update tag val failed.");
@ -1815,13 +1816,13 @@ static int metaUpdateTableTagVal(SMeta *pMeta, int64_t version, SVAlterTbReq *pA
} }
SCtbIdxKey ctbIdxKey = {.suid = ctbEntry.ctbEntry.suid, .uid = uid}; SCtbIdxKey ctbIdxKey = {.suid = ctbEntry.ctbEntry.suid, .uid = uid};
tdbTbUpsert(pMeta->pCtbIdx, &ctbIdxKey, sizeof(ctbIdxKey), ctbEntry.ctbEntry.pTags, (void)tdbTbUpsert(pMeta->pCtbIdx, &ctbIdxKey, sizeof(ctbIdxKey), ctbEntry.ctbEntry.pTags,
((STag *)(ctbEntry.ctbEntry.pTags))->len, pMeta->txn); ((STag *)(ctbEntry.ctbEntry.pTags))->len, pMeta->txn);
metaUidCacheClear(pMeta, ctbEntry.ctbEntry.suid); (void)metaUidCacheClear(pMeta, ctbEntry.ctbEntry.suid);
metaTbGroupCacheClear(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); metaULock(pMeta);
@ -1830,8 +1831,8 @@ static int metaUpdateTableTagVal(SMeta *pMeta, int64_t version, SVAlterTbReq *pA
taosMemoryFree((void *)ctbEntry.ctbEntry.pTags); taosMemoryFree((void *)ctbEntry.ctbEntry.pTags);
if (ctbEntry.pBuf) taosMemoryFree(ctbEntry.pBuf); if (ctbEntry.pBuf) taosMemoryFree(ctbEntry.pBuf);
if (stbEntry.pBuf) tdbFree(stbEntry.pBuf); if (stbEntry.pBuf) tdbFree(stbEntry.pBuf);
tdbTbcClose(pTbDbc); (void)tdbTbcClose(pTbDbc);
tdbTbcClose(pUidIdxc); (void)tdbTbcClose(pUidIdxc);
return 0; return 0;
_err: _err:
@ -1839,8 +1840,8 @@ _err:
tDecoderClear(&dc2); tDecoderClear(&dc2);
if (ctbEntry.pBuf) taosMemoryFree(ctbEntry.pBuf); if (ctbEntry.pBuf) taosMemoryFree(ctbEntry.pBuf);
if (stbEntry.pBuf) tdbFree(stbEntry.pBuf); if (stbEntry.pBuf) tdbFree(stbEntry.pBuf);
tdbTbcClose(pTbDbc); (void)tdbTbcClose(pTbDbc);
tdbTbcClose(pUidIdxc); (void)tdbTbcClose(pUidIdxc);
return -1; return -1;
} }
@ -1868,30 +1869,30 @@ static int metaUpdateTableOptions(SMeta *pMeta, int64_t version, SVAlterTbReq *p
// search uid index // search uid index
TBC *pUidIdxc = NULL; TBC *pUidIdxc = NULL;
tdbTbcOpen(pMeta->pUidIdx, &pUidIdxc, NULL); (void)tdbTbcOpen(pMeta->pUidIdx, &pUidIdxc, NULL);
tdbTbcMoveTo(pUidIdxc, &uid, sizeof(uid), &c); (void)tdbTbcMoveTo(pUidIdxc, &uid, sizeof(uid), &c);
if (c != 0) { if (c != 0) {
tdbTbcClose(pUidIdxc); (void)tdbTbcClose(pUidIdxc);
metaError("meta/table: invalide c: %" PRId32 " update tb options failed.", c); metaError("meta/table: invalide c: %" PRId32 " update tb options failed.", c);
return TSDB_CODE_FAILED; return TSDB_CODE_FAILED;
} }
tdbTbcGet(pUidIdxc, NULL, NULL, &pData, &nData); (void)tdbTbcGet(pUidIdxc, NULL, NULL, &pData, &nData);
oversion = ((SUidIdxVal *)pData)[0].version; oversion = ((SUidIdxVal *)pData)[0].version;
// search table.db // search table.db
TBC *pTbDbc = NULL; TBC *pTbDbc = NULL;
tdbTbcOpen(pMeta->pTbDb, &pTbDbc, NULL); (void)tdbTbcOpen(pMeta->pTbDb, &pTbDbc, NULL);
tdbTbcMoveTo(pTbDbc, &((STbDbKey){.uid = uid, .version = oversion}), sizeof(STbDbKey), &c); (void)tdbTbcMoveTo(pTbDbc, &((STbDbKey){.uid = uid, .version = oversion}), sizeof(STbDbKey), &c);
if (c != 0) { if (c != 0) {
tdbTbcClose(pUidIdxc); (void)tdbTbcClose(pUidIdxc);
tdbTbcClose(pTbDbc); (void)tdbTbcClose(pTbDbc);
metaError("meta/table: invalide c: %" PRId32 " update tb options failed.", c); metaError("meta/table: invalide c: %" PRId32 " update tb options failed.", c);
return TSDB_CODE_FAILED; return TSDB_CODE_FAILED;
} }
tdbTbcGet(pTbDbc, NULL, NULL, &pData, &nData); (void)tdbTbcGet(pTbDbc, NULL, NULL, &pData, &nData);
// get table entry // get table entry
SDecoder dc = {0}; SDecoder dc = {0};
@ -1901,8 +1902,8 @@ static int metaUpdateTableOptions(SMeta *pMeta, int64_t version, SVAlterTbReq *p
ret = metaDecodeEntry(&dc, &entry); ret = metaDecodeEntry(&dc, &entry);
if (ret != 0) { if (ret != 0) {
tDecoderClear(&dc); tDecoderClear(&dc);
tdbTbcClose(pUidIdxc); (void)tdbTbcClose(pUidIdxc);
tdbTbcClose(pTbDbc); (void)tdbTbcClose(pTbDbc);
metaError("meta/table: invalide ret: %" PRId32 " alt tb options failed.", ret); metaError("meta/table: invalide ret: %" PRId32 " alt tb options failed.", ret);
return TSDB_CODE_FAILED; return TSDB_CODE_FAILED;
} }
@ -1912,9 +1913,9 @@ static int metaUpdateTableOptions(SMeta *pMeta, int64_t version, SVAlterTbReq *p
// build SMetaEntry // build SMetaEntry
if (entry.type == TSDB_CHILD_TABLE) { if (entry.type == TSDB_CHILD_TABLE) {
if (pAlterTbReq->updateTTL) { if (pAlterTbReq->updateTTL) {
metaDeleteTtl(pMeta, &entry); (void)metaDeleteTtl(pMeta, &entry);
entry.ctbEntry.ttlDays = pAlterTbReq->newTTL; entry.ctbEntry.ttlDays = pAlterTbReq->newTTL;
metaUpdateTtl(pMeta, &entry); (void)metaUpdateTtl(pMeta, &entry);
} }
if (pAlterTbReq->newCommentLen >= 0) { if (pAlterTbReq->newCommentLen >= 0) {
entry.ctbEntry.commentLen = pAlterTbReq->newCommentLen; entry.ctbEntry.commentLen = pAlterTbReq->newCommentLen;
@ -1922,9 +1923,9 @@ static int metaUpdateTableOptions(SMeta *pMeta, int64_t version, SVAlterTbReq *p
} }
} else { } else {
if (pAlterTbReq->updateTTL) { if (pAlterTbReq->updateTTL) {
metaDeleteTtl(pMeta, &entry); (void)metaDeleteTtl(pMeta, &entry);
entry.ntbEntry.ttlDays = pAlterTbReq->newTTL; entry.ntbEntry.ttlDays = pAlterTbReq->newTTL;
metaUpdateTtl(pMeta, &entry); (void)metaUpdateTtl(pMeta, &entry);
} }
if (pAlterTbReq->newCommentLen >= 0) { if (pAlterTbReq->newCommentLen >= 0) {
entry.ntbEntry.commentLen = pAlterTbReq->newCommentLen; entry.ntbEntry.commentLen = pAlterTbReq->newCommentLen;
@ -1933,14 +1934,14 @@ static int metaUpdateTableOptions(SMeta *pMeta, int64_t version, SVAlterTbReq *p
} }
// save to table db // save to table db
metaSaveToTbDb(pMeta, &entry); (void)metaSaveToTbDb(pMeta, &entry);
metaUpdateUidIdx(pMeta, &entry); (void)metaUpdateUidIdx(pMeta, &entry);
metaUpdateChangeTime(pMeta, entry.uid, pAlterTbReq->ctimeMs); (void)metaUpdateChangeTime(pMeta, entry.uid, pAlterTbReq->ctimeMs);
metaULock(pMeta); metaULock(pMeta);
tdbTbcClose(pTbDbc); (void)tdbTbcClose(pTbDbc);
tdbTbcClose(pUidIdxc); (void)tdbTbcClose(pUidIdxc);
tDecoderClear(&dc); tDecoderClear(&dc);
if (entry.pBuf) taosMemoryFree(entry.pBuf); if (entry.pBuf) taosMemoryFree(entry.pBuf);
return 0; return 0;
@ -1981,7 +1982,7 @@ static int metaAddTagIndex(SMeta *pMeta, int64_t version, SVAlterTbReq *pAlterTb
STbDbKey tbDbKey = {0}; STbDbKey tbDbKey = {0};
tbDbKey.uid = suid; tbDbKey.uid = suid;
tbDbKey.version = ((SUidIdxVal *)pVal)[0].version; tbDbKey.version = ((SUidIdxVal *)pVal)[0].version;
tdbTbGet(pMeta->pTbDb, &tbDbKey, sizeof(tbDbKey), &pVal, &nVal); (void)tdbTbGet(pMeta->pTbDb, &tbDbKey, sizeof(tbDbKey), &pVal, &nVal);
tDecoderInit(&dc, pVal, nVal); tDecoderInit(&dc, pVal, nVal);
ret = metaDecodeEntry(&dc, &stbEntry); ret = metaDecodeEntry(&dc, &stbEntry);
if (ret < 0) { if (ret < 0) {
@ -2017,10 +2018,10 @@ static int metaAddTagIndex(SMeta *pMeta, int64_t version, SVAlterTbReq *pAlterTb
* iterator all pTdDbc by uid and version * iterator all pTdDbc by uid and version
*/ */
TBC *pCtbIdxc = NULL; 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); int rc = tdbTbcMoveTo(pCtbIdxc, &(SCtbIdxKey){.suid = suid, .uid = INT64_MIN}, sizeof(SCtbIdxKey), &c);
if (rc < 0) { if (rc < 0) {
tdbTbcClose(pCtbIdxc); (void)tdbTbcClose(pCtbIdxc);
goto _err; goto _err;
} }
for (;;) { for (;;) {
@ -2057,14 +2058,14 @@ static int metaAddTagIndex(SMeta *pMeta, int64_t version, SVAlterTbReq *pAlterTb
tdbFree(pKey); tdbFree(pKey);
tdbFree(pVal); tdbFree(pVal);
metaDestroyTagIdxKey(pTagIdxKey); metaDestroyTagIdxKey(pTagIdxKey);
tdbTbcClose(pCtbIdxc); (void)tdbTbcClose(pCtbIdxc);
goto _err; goto _err;
} }
tdbTbUpsert(pMeta->pTagIdx, pTagIdxKey, nTagIdxKey, NULL, 0, pMeta->txn); (void)tdbTbUpsert(pMeta->pTagIdx, pTagIdxKey, nTagIdxKey, NULL, 0, pMeta->txn);
metaDestroyTagIdxKey(pTagIdxKey); metaDestroyTagIdxKey(pTagIdxKey);
pTagIdxKey = NULL; pTagIdxKey = NULL;
} }
tdbTbcClose(pCtbIdxc); (void)tdbTbcClose(pCtbIdxc);
return 0; return 0;
_err: _err:
@ -2115,7 +2116,7 @@ static int metaDropTagIndex(SMeta *pMeta, int64_t version, SVAlterTbReq *pAlterT
STbDbKey tbDbKey = {0}; STbDbKey tbDbKey = {0};
tbDbKey.uid = suid; tbDbKey.uid = suid;
tbDbKey.version = ((SUidIdxVal *)pVal)[0].version; tbDbKey.version = ((SUidIdxVal *)pVal)[0].version;
tdbTbGet(pMeta->pTbDb, &tbDbKey, sizeof(tbDbKey), &pVal, &nVal); (void)tdbTbGet(pMeta->pTbDb, &tbDbKey, sizeof(tbDbKey), &pVal, &nVal);
tDecoderInit(&dc, pVal, nVal); tDecoderInit(&dc, pVal, nVal);
ret = metaDecodeEntry(&dc, &stbEntry); ret = metaDecodeEntry(&dc, &stbEntry);
@ -2156,7 +2157,7 @@ static int metaDropTagIndex(SMeta *pMeta, int64_t version, SVAlterTbReq *pAlterT
SArray *tagIdxList = taosArrayInit(512, sizeof(SMetaPair)); SArray *tagIdxList = taosArrayInit(512, sizeof(SMetaPair));
TBC *pTagIdxc = NULL; TBC *pTagIdxc = NULL;
tdbTbcOpen(pMeta->pTagIdx, &pTagIdxc, NULL); (void)tdbTbcOpen(pMeta->pTagIdx, &pTagIdxc, NULL);
int rc = int rc =
tdbTbcMoveTo(pTagIdxc, &(STagIdxKey){.suid = suid, .cid = INT32_MIN, .type = pCol->type}, sizeof(STagIdxKey), &c); tdbTbcMoveTo(pTagIdxc, &(STagIdxKey){.suid = suid, .cid = INT32_MIN, .type = pCol->type}, sizeof(STagIdxKey), &c);
for (;;) { for (;;) {
@ -2173,12 +2174,12 @@ static int metaDropTagIndex(SMeta *pMeta, int64_t version, SVAlterTbReq *pAlterT
SMetaPair pair = {.key = pKey, nKey = nKey}; SMetaPair pair = {.key = pKey, nKey = nKey};
(void)taosArrayPush(tagIdxList, &pair); (void)taosArrayPush(tagIdxList, &pair);
} }
tdbTbcClose(pTagIdxc); (void)tdbTbcClose(pTagIdxc);
metaWLock(pMeta); metaWLock(pMeta);
for (int i = 0; i < taosArrayGetSize(tagIdxList); i++) { for (int i = 0; i < taosArrayGetSize(tagIdxList); i++) {
SMetaPair *pair = taosArrayGet(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); metaULock(pMeta);
@ -2265,9 +2266,9 @@ int32_t metaUpdateTableColCompress(SMeta *pMeta, int64_t version, SVAlterTbReq *
tbEntry.version = version; tbEntry.version = version;
metaWLock(pMeta); metaWLock(pMeta);
metaSaveToTbDb(pMeta, &tbEntry); (void)metaSaveToTbDb(pMeta, &tbEntry);
metaUpdateUidIdx(pMeta, &tbEntry); (void)metaUpdateUidIdx(pMeta, &tbEntry);
metaUpdateChangeTime(pMeta, suid, pReq->ctimeMs); (void)metaUpdateChangeTime(pMeta, suid, pReq->ctimeMs);
metaULock(pMeta); metaULock(pMeta);
@ -2362,7 +2363,7 @@ static int metaUpdateUidIdx(SMeta *pMeta, const SMetaEntry *pME) {
// upsert cache // upsert cache
SMetaInfo info; SMetaInfo info;
metaGetEntryInfo(pME, &info); metaGetEntryInfo(pME, &info);
metaCacheUpsert(pMeta, &info); (void)metaCacheUpsert(pMeta, &info);
SUidIdxVal uidIdxVal = {.suid = info.suid, .version = info.version, .skmVer = info.skmVer}; SUidIdxVal uidIdxVal = {.suid = info.suid, .version = info.version, .skmVer = info.skmVer};
@ -2478,7 +2479,7 @@ static int metaUpdateTagIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry) {
} }
tbDbKey.uid = pCtbEntry->ctbEntry.suid; tbDbKey.uid = pCtbEntry->ctbEntry.suid;
tbDbKey.version = ((SUidIdxVal *)pData)[0].version; tbDbKey.version = ((SUidIdxVal *)pData)[0].version;
tdbTbGet(pMeta->pTbDb, &tbDbKey, sizeof(tbDbKey), &pData, &nData); (void)tdbTbGet(pMeta->pTbDb, &tbDbKey, sizeof(tbDbKey), &pData, &nData);
tDecoderInit(&dc, pData, nData); tDecoderInit(&dc, pData, nData);
ret = metaDecodeEntry(&dc, &stbEntry); ret = metaDecodeEntry(&dc, &stbEntry);
@ -2525,7 +2526,7 @@ static int metaUpdateTagIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry) {
ret = -1; ret = -1;
goto end; goto end;
} }
tdbTbUpsert(pMeta->pTagIdx, pTagIdxKey, nTagIdxKey, NULL, 0, pMeta->txn); (void)tdbTbUpsert(pMeta->pTagIdx, pTagIdxKey, nTagIdxKey, NULL, 0, pMeta->txn);
metaDestroyTagIdxKey(pTagIdxKey); metaDestroyTagIdxKey(pTagIdxKey);
pTagIdxKey = NULL; pTagIdxKey = NULL;
} }
@ -2574,7 +2575,7 @@ static int metaSaveToSkmDb(SMeta *pMeta, const SMetaEntry *pME) {
} }
tEncoderInit(&coder, pVal, vLen); tEncoderInit(&coder, pVal, vLen);
tEncodeSSchemaWrapper(&coder, pSW); (void)tEncodeSSchemaWrapper(&coder, pSW);
if (tdbTbInsert(pMeta->pSkmDb, &skmDbKey, sizeof(skmDbKey), pVal, vLen, pMeta->txn) < 0) { if (tdbTbInsert(pMeta->pSkmDb, &skmDbKey, sizeof(skmDbKey), pVal, vLen, pMeta->txn) < 0) {
rcode = -1; rcode = -1;
@ -2662,7 +2663,7 @@ int32_t colCompressDebug(SHashObj *pColCmprObj) {
p = taosHashIterate(pColCmprObj, p); p = taosHashIterate(pColCmprObj, p);
uint8_t l1, l2, lvl; uint8_t l1, l2, lvl;
tcompressDebug(cmprAlg, &l1, &l2, &lvl); (void)tcompressDebug(cmprAlg, &l1, &l2, &lvl);
const char *l1str = columnEncodeStr(l1); const char *l1str = columnEncodeStr(l1);
const char *l2str = columnCompressStr(l2); const char *l2str = columnCompressStr(l2);
@ -2711,7 +2712,7 @@ int32_t metaGetColCmpr(SMeta *pMeta, tb_uid_t uid, SHashObj **ppColCmprObj) {
SColCmprWrapper *p = &e.colCmpr; SColCmprWrapper *p = &e.colCmpr;
for (int32_t i = 0; i < p->nCols; i++) { for (int32_t i = 0; i < p->nCols; i++) {
SColCmpr *pCmpr = &p->pColCmpr[i]; SColCmpr *pCmpr = &p->pColCmpr[i];
taosHashPut(pColCmprObj, &pCmpr->id, sizeof(pCmpr->id), &pCmpr->alg, sizeof(pCmpr->alg)); (void)taosHashPut(pColCmprObj, &pCmpr->id, sizeof(pCmpr->id), &pCmpr->alg, sizeof(pCmpr->alg));
} }
} else { } else {
tDecoderClear(&dc); tDecoderClear(&dc);
@ -2725,7 +2726,7 @@ int32_t metaGetColCmpr(SMeta *pMeta, tb_uid_t uid, SHashObj **ppColCmprObj) {
metaULock(pMeta); metaULock(pMeta);
*ppColCmprObj = pColCmprObj; *ppColCmprObj = pColCmprObj;
colCompressDebug(pColCmprObj); (void)colCompressDebug(pColCmprObj);
return 0; return 0;
} }

2
source/dnode/vnode/src/tsdb/tsdbCache.c
View File

@ -3274,7 +3274,7 @@ _err:
TAOS_RETURN(code); 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) { void tsdbCacheSetCapacity(SVnode *pVnode, size_t capacity) {
taosLRUCacheSetCapacity(pVnode->pTsdb->lruCache, capacity); taosLRUCacheSetCapacity(pVnode->pTsdb->lruCache, capacity);

38
source/dnode/vnode/src/tsdb/tsdbCommit2.c
View File

@ -251,7 +251,7 @@ static int32_t tsdbCommitOpenReader(SCommitter2 *committer) {
_exit: _exit:
if (code) { if (code) {
tsdbCommitCloseReader(committer); TAOS_UNUSED(tsdbCommitCloseReader(committer));
tsdbError("vgId:%d %s failed at %s:%d since %s", TD_VID(committer->tsdb->pVnode), __func__, __FILE__, lino, tsdbError("vgId:%d %s failed at %s:%d since %s", TD_VID(committer->tsdb->pVnode), __func__, __FILE__, lino,
tstrerror(code)); tstrerror(code));
} }
@ -259,8 +259,8 @@ _exit:
} }
static int32_t tsdbCommitCloseIter(SCommitter2 *committer) { static int32_t tsdbCommitCloseIter(SCommitter2 *committer) {
tsdbIterMergerClose(&committer->tombIterMerger); TAOS_UNUSED(tsdbIterMergerClose(&committer->tombIterMerger));
tsdbIterMergerClose(&committer->dataIterMerger); TAOS_UNUSED(tsdbIterMergerClose(&committer->dataIterMerger));
TARRAY2_CLEAR(committer->tombIterArray, tsdbIterClose); TARRAY2_CLEAR(committer->tombIterArray, tsdbIterClose);
TARRAY2_CLEAR(committer->dataIterArray, tsdbIterClose); TARRAY2_CLEAR(committer->dataIterArray, tsdbIterClose);
return 0; return 0;
@ -322,7 +322,7 @@ static int32_t tsdbCommitOpenIter(SCommitter2 *committer) {
_exit: _exit:
if (code) { if (code) {
tsdbCommitCloseIter(committer); TAOS_UNUSED(tsdbCommitCloseIter(committer));
tsdbError("vgId:%d %s failed at %s:%d since %s", TD_VID(committer->tsdb->pVnode), __func__, __FILE__, lino, tsdbError("vgId:%d %s failed at %s:%d since %s", TD_VID(committer->tsdb->pVnode), __func__, __FILE__, lino,
tstrerror(code)); tstrerror(code));
} }
@ -335,7 +335,7 @@ static int32_t tsdbCommitFileSetBegin(SCommitter2 *committer) {
STsdb *tsdb = committer->tsdb; STsdb *tsdb = committer->tsdb;
// check if can commit // check if can commit
tsdbFSCheckCommit(tsdb, committer->ctx->info->fid); TAOS_UNUSED(tsdbFSCheckCommit(tsdb, committer->ctx->info->fid));
committer->ctx->expLevel = tsdbFidLevel(committer->ctx->info->fid, &tsdb->keepCfg, committer->now); committer->ctx->expLevel = tsdbFidLevel(committer->ctx->info->fid, &tsdb->keepCfg, committer->now);
tsdbFidKeyRange(committer->ctx->info->fid, committer->minutes, committer->precision, &committer->ctx->minKey, tsdbFidKeyRange(committer->ctx->info->fid, committer->minutes, committer->precision, &committer->ctx->minKey,
@ -344,7 +344,7 @@ static int32_t tsdbCommitFileSetBegin(SCommitter2 *committer) {
TAOS_CHECK_GOTO(tfsAllocDisk(committer->tsdb->pVnode->pTfs, committer->ctx->expLevel, &committer->ctx->did), &lino, TAOS_CHECK_GOTO(tfsAllocDisk(committer->tsdb->pVnode->pTfs, committer->ctx->expLevel, &committer->ctx->did), &lino,
_exit); _exit);
tfsMkdirRecurAt(committer->tsdb->pVnode->pTfs, committer->tsdb->path, committer->ctx->did); TAOS_UNUSED(tfsMkdirRecurAt(committer->tsdb->pVnode->pTfs, committer->tsdb->path, committer->ctx->did));
committer->ctx->tbid->suid = 0; committer->ctx->tbid->suid = 0;
committer->ctx->tbid->uid = 0; committer->ctx->tbid->uid = 0;
@ -430,12 +430,12 @@ static int32_t tsdbCommitInfoDestroy(STsdb *pTsdb) {
if (pTsdb->commitInfo) { if (pTsdb->commitInfo) {
for (int32_t i = 0; i < taosArrayGetSize(pTsdb->commitInfo->arr); i++) { for (int32_t i = 0; i < taosArrayGetSize(pTsdb->commitInfo->arr); i++) {
SFileSetCommitInfo *info = *(SFileSetCommitInfo **)taosArrayGet(pTsdb->commitInfo->arr, i); SFileSetCommitInfo *info = *(SFileSetCommitInfo **)taosArrayGet(pTsdb->commitInfo->arr, i);
vHashDrop(pTsdb->commitInfo->ht, info); TAOS_UNUSED(vHashDrop(pTsdb->commitInfo->ht, info));
tsdbTFileSetClear(&info->fset); tsdbTFileSetClear(&info->fset);
taosMemoryFree(info); taosMemoryFree(info);
} }
vHashDestroy(&pTsdb->commitInfo->ht); TAOS_UNUSED(vHashDestroy(&pTsdb->commitInfo->ht));
taosArrayDestroy(pTsdb->commitInfo->arr); taosArrayDestroy(pTsdb->commitInfo->arr);
pTsdb->commitInfo->arr = NULL; pTsdb->commitInfo->arr = NULL;
taosMemoryFreeClear(pTsdb->commitInfo); taosMemoryFreeClear(pTsdb->commitInfo);
@ -461,7 +461,7 @@ static int32_t tsdbCommitInfoInit(STsdb *pTsdb) {
_exit: _exit:
if (code) { if (code) {
tsdbCommitInfoDestroy(pTsdb); TAOS_UNUSED(tsdbCommitInfoDestroy(pTsdb));
tsdbError("vgId:%d %s failed at %s:%d since %s", TD_VID(pTsdb->pVnode), __func__, __FILE__, lino, tstrerror(code)); tsdbError("vgId:%d %s failed at %s:%d since %s", TD_VID(pTsdb->pVnode), __func__, __FILE__, lino, tstrerror(code));
} }
return code; return code;
@ -531,7 +531,7 @@ static int32_t tsdbCommitInfoBuild(STsdb *tsdb) {
SFileSetCommitInfo tinfo = { SFileSetCommitInfo tinfo = {
.fid = fid, .fid = fid,
}; };
vHashGet(tsdb->commitInfo->ht, &tinfo, (void **)&info); TAOS_UNUSED(vHashGet(tsdb->commitInfo->ht, &tinfo, (void **)&info));
if (info == NULL) { if (info == NULL) {
TAOS_CHECK_GOTO(tsdbCommitInfoAdd(tsdb, fid), &lino, _exit); TAOS_CHECK_GOTO(tsdbCommitInfoAdd(tsdb, fid), &lino, _exit);
} }
@ -555,7 +555,7 @@ static int32_t tsdbCommitInfoBuild(STsdb *tsdb) {
}; };
// check if the file set already on the commit list // check if the file set already on the commit list
vHashGet(tsdb->commitInfo->ht, &tinfo, (void **)&info); TAOS_UNUSED(vHashGet(tsdb->commitInfo->ht, &tinfo, (void **)&info));
if (info != NULL) { if (info != NULL) {
continue; continue;
} }
@ -589,7 +589,7 @@ static int32_t tsdbCommitInfoBuild(STsdb *tsdb) {
// begin tasks on file set // begin tasks on file set
for (int i = 0; i < taosArrayGetSize(tsdb->commitInfo->arr); i++) { for (int i = 0; i < taosArrayGetSize(tsdb->commitInfo->arr); i++) {
SFileSetCommitInfo *info = *(SFileSetCommitInfo **)taosArrayGet(tsdb->commitInfo->arr, i); SFileSetCommitInfo *info = *(SFileSetCommitInfo **)taosArrayGet(tsdb->commitInfo->arr, i);
tsdbBeginTaskOnFileSet(tsdb, info->fid, &fset); TAOS_UNUSED(tsdbBeginTaskOnFileSet(tsdb, info->fid, &fset));
if (fset) { if (fset) {
code = tsdbTFileSetInitCopy(tsdb, fset, &info->fset); code = tsdbTFileSetInitCopy(tsdb, fset, &info->fset);
if (code) { if (code) {
@ -603,7 +603,7 @@ static int32_t tsdbCommitInfoBuild(STsdb *tsdb) {
_exit: _exit:
if (code) { if (code) {
tsdbCommitInfoDestroy(tsdb); TAOS_UNUSED(tsdbCommitInfoDestroy(tsdb));
tsdbError("vgId:%d %s failed at %s:%d since %s", TD_VID(tsdb->pVnode), __func__, __FILE__, lino, tstrerror(code)); tsdbError("vgId:%d %s failed at %s:%d since %s", TD_VID(tsdb->pVnode), __func__, __FILE__, lino, tstrerror(code));
} }
return code; return code;
@ -689,7 +689,7 @@ int32_t tsdbCommitBegin(STsdb *tsdb, SCommitInfo *info) {
(void)taosThreadMutexLock(&tsdb->mutex); (void)taosThreadMutexLock(&tsdb->mutex);
tsdb->imem = NULL; tsdb->imem = NULL;
(void)taosThreadMutexUnlock(&tsdb->mutex); (void)taosThreadMutexUnlock(&tsdb->mutex);
tsdbUnrefMemTable(imem, NULL, true); TAOS_UNUSED(tsdbUnrefMemTable(imem, NULL, true));
} else { } else {
SCommitter2 committer = {0}; SCommitter2 committer = {0};
@ -730,14 +730,14 @@ int32_t tsdbCommitCommit(STsdb *tsdb) {
for (int32_t i = 0; i < taosArrayGetSize(tsdb->commitInfo->arr); i++) { for (int32_t i = 0; i < taosArrayGetSize(tsdb->commitInfo->arr); i++) {
SFileSetCommitInfo *info = *(SFileSetCommitInfo **)taosArrayGet(tsdb->commitInfo->arr, i); SFileSetCommitInfo *info = *(SFileSetCommitInfo **)taosArrayGet(tsdb->commitInfo->arr, i);
if (info->fset) { if (info->fset) {
tsdbFinishTaskOnFileSet(tsdb, info->fid); TAOS_UNUSED(tsdbFinishTaskOnFileSet(tsdb, info->fid));
} }
} }
(void)taosThreadMutexUnlock(&tsdb->mutex); (void)taosThreadMutexUnlock(&tsdb->mutex);
tsdbCommitInfoDestroy(tsdb); TAOS_UNUSED(tsdbCommitInfoDestroy(tsdb));
tsdbUnrefMemTable(pMemTable, NULL, true); TAOS_UNUSED(tsdbUnrefMemTable(pMemTable, NULL, true));
} }
_exit: _exit:
@ -761,11 +761,11 @@ int32_t tsdbCommitAbort(STsdb *pTsdb) {
for (int32_t i = 0; i < taosArrayGetSize(pTsdb->commitInfo->arr); i++) { for (int32_t i = 0; i < taosArrayGetSize(pTsdb->commitInfo->arr); i++) {
SFileSetCommitInfo *info = *(SFileSetCommitInfo **)taosArrayGet(pTsdb->commitInfo->arr, i); SFileSetCommitInfo *info = *(SFileSetCommitInfo **)taosArrayGet(pTsdb->commitInfo->arr, i);
if (info->fset) { if (info->fset) {
tsdbFinishTaskOnFileSet(pTsdb, info->fid); TAOS_UNUSED(tsdbFinishTaskOnFileSet(pTsdb, info->fid));
} }
} }
(void)taosThreadMutexUnlock(&pTsdb->mutex); (void)taosThreadMutexUnlock(&pTsdb->mutex);
tsdbCommitInfoDestroy(pTsdb); TAOS_UNUSED(tsdbCommitInfoDestroy(pTsdb));
_exit: _exit:
if (code) { if (code) {

6
source/dnode/vnode/src/tsdb/tsdbDataFileRAW.c
View File

@ -35,7 +35,7 @@ int32_t tsdbDataFileRAWReaderOpen(const char *fname, const SDataFileRAWReaderCon
} }
} else { } else {
char fname1[TSDB_FILENAME_LEN]; char fname1[TSDB_FILENAME_LEN];
tsdbTFileName(config->tsdb, &config->file, fname1); (void)tsdbTFileName(config->tsdb, &config->file, fname1);
TAOS_CHECK_GOTO(tsdbOpenFile(fname1, config->tsdb, TD_FILE_READ, &reader[0]->fd, lcn), &lino, _exit); TAOS_CHECK_GOTO(tsdbOpenFile(fname1, config->tsdb, TD_FILE_READ, &reader[0]->fd, lcn), &lino, _exit);
} }
@ -159,7 +159,7 @@ static int32_t tsdbDataFileRAWWriterOpenDataFD(SDataFileRAWWriter *writer) {
flag |= (TD_FILE_CREATE | TD_FILE_TRUNC); flag |= (TD_FILE_CREATE | TD_FILE_TRUNC);
} }
tsdbTFileName(writer->config->tsdb, &writer->file, fname); (void)tsdbTFileName(writer->config->tsdb, &writer->file, fname);
TAOS_CHECK_GOTO(tsdbOpenFile(fname, writer->config->tsdb, flag, &writer->fd, writer->file.lcn), &lino, _exit); TAOS_CHECK_GOTO(tsdbOpenFile(fname, writer->config->tsdb, flag, &writer->fd, writer->file.lcn), &lino, _exit);
_exit: _exit:
@ -202,7 +202,7 @@ int32_t tsdbDataFileRAWWriterClose(SDataFileRAWWriter **writer, bool abort, TFil
} else { } else {
TAOS_CHECK_GOTO(tsdbDataFileRAWWriterCloseCommit(writer[0], opArr), &lino, _exit); TAOS_CHECK_GOTO(tsdbDataFileRAWWriterCloseCommit(writer[0], opArr), &lino, _exit);
} }
tsdbDataFileRAWWriterDoClose(writer[0]); (void)tsdbDataFileRAWWriterDoClose(writer[0]);
} }
taosMemoryFree(writer[0]); taosMemoryFree(writer[0]);
writer[0] = NULL; writer[0] = NULL;

32
source/dnode/vnode/src/tsdb/tsdbDataFileRW.c
View File

@ -135,7 +135,7 @@ int32_t tsdbDataFileReaderOpen(const char *fname[], const SDataFileReaderConfig
for (int32_t i = 0; i < TSDB_FTYPE_MAX; ++i) { for (int32_t i = 0; i < TSDB_FTYPE_MAX; ++i) {
if (config->files[i].exist) { if (config->files[i].exist) {
char fname1[TSDB_FILENAME_LEN]; 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; 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); 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) { static int32_t tsdbDataFileWriterDoClose(SDataFileWriter *writer) {
if (writer->ctx->reader) { if (writer->ctx->reader) {
tsdbDataFileReaderClose(&writer->ctx->reader); (void)tsdbDataFileReaderClose(&writer->ctx->reader);
} }
tTombBlockDestroy(writer->tombBlock); 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 // write to file
for (int32_t i = 0; i < 10; ++i) { 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, code = metaGetColCmpr(writer->config->tsdb->pVnode->pMeta, bData->suid != 0 ? bData->suid : bData->uid,
&cmprInfo.pColCmpr); &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++) { for (int32_t i = 0; i < ARRAY_SIZE(tombBlock->buffers); i++) {
tBufferClear(buffer0); tBufferClear(buffer0);
@ -1640,8 +1640,8 @@ static int32_t tsdbDataFileWriterCloseCommit(SDataFileWriter *writer, TFileOpArr
.fid = writer->config->fid, .fid = writer->config->fid,
.nf = writer->files[ftype], .nf = writer->files[ftype],
}; };
tsdbTFileUpdVerRange(&op.nf, ofRange); (void)tsdbTFileUpdVerRange(&op.nf, ofRange);
tsdbTFileUpdVerRange(&op.nf, writer->ctx->range); (void)tsdbTFileUpdVerRange(&op.nf, writer->ctx->range);
TAOS_CHECK_GOTO(TARRAY2_APPEND(opArr, op), &lino, _exit); TAOS_CHECK_GOTO(TARRAY2_APPEND(opArr, op), &lino, _exit);
// .data // .data
@ -1652,7 +1652,7 @@ static int32_t tsdbDataFileWriterCloseCommit(SDataFileWriter *writer, TFileOpArr
.fid = writer->config->fid, .fid = writer->config->fid,
.nf = writer->files[ftype], .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); TAOS_CHECK_GOTO(TARRAY2_APPEND(opArr, op), &lino, _exit);
} else if (writer->config->files[ftype].file.size != writer->files[ftype].size) { } else if (writer->config->files[ftype].file.size != writer->files[ftype].size) {
op = (STFileOp){ op = (STFileOp){
@ -1661,7 +1661,7 @@ static int32_t tsdbDataFileWriterCloseCommit(SDataFileWriter *writer, TFileOpArr
.of = writer->config->files[ftype].file, .of = writer->config->files[ftype].file,
.nf = writer->files[ftype], .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); TAOS_CHECK_GOTO(TARRAY2_APPEND(opArr, op), &lino, _exit);
} }
@ -1673,7 +1673,7 @@ static int32_t tsdbDataFileWriterCloseCommit(SDataFileWriter *writer, TFileOpArr
.fid = writer->config->fid, .fid = writer->config->fid,
.nf = writer->files[ftype], .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); TAOS_CHECK_GOTO(TARRAY2_APPEND(opArr, op), &lino, _exit);
} else if (writer->config->files[ftype].file.size != writer->files[ftype].size) { } else if (writer->config->files[ftype].file.size != writer->files[ftype].size) {
op = (STFileOp){ op = (STFileOp){
@ -1682,7 +1682,7 @@ static int32_t tsdbDataFileWriterCloseCommit(SDataFileWriter *writer, TFileOpArr
.of = writer->config->files[ftype].file, .of = writer->config->files[ftype].file,
.nf = writer->files[ftype], .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); TAOS_CHECK_GOTO(TARRAY2_APPEND(opArr, op), &lino, _exit);
} }
} }
@ -1716,8 +1716,8 @@ static int32_t tsdbDataFileWriterCloseCommit(SDataFileWriter *writer, TFileOpArr
.fid = writer->config->fid, .fid = writer->config->fid,
.nf = writer->files[ftype], .nf = writer->files[ftype],
}; };
tsdbTFileUpdVerRange(&op.nf, ofRange); (void)tsdbTFileUpdVerRange(&op.nf, ofRange);
tsdbTFileUpdVerRange(&op.nf, writer->ctx->tombRange); (void)tsdbTFileUpdVerRange(&op.nf, writer->ctx->tombRange);
TAOS_CHECK_GOTO(TARRAY2_APPEND(opArr, op), &lino, _exit); TAOS_CHECK_GOTO(TARRAY2_APPEND(opArr, op), &lino, _exit);
} }
int32_t encryptAlgorithm = writer->config->tsdb->pVnode->config.tsdbCfg.encryptAlgorithm; 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; 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); TAOS_CHECK_GOTO(tsdbOpenFile(fname, writer->config->tsdb, flag, &writer->fd[ftype], lcn), &lino, _exit);
if (writer->files[ftype].size == 0) { if (writer->files[ftype].size == 0) {
@ -1804,7 +1804,7 @@ int32_t tsdbDataFileWriterClose(SDataFileWriter **writer, bool abort, TFileOpArr
} else { } else {
TAOS_CHECK_GOTO(tsdbDataFileWriterCloseCommit(writer[0], opArr), &lino, _exit); TAOS_CHECK_GOTO(tsdbDataFileWriterCloseCommit(writer[0], opArr), &lino, _exit);
} }
tsdbDataFileWriterDoClose(writer[0]); (void)tsdbDataFileWriterDoClose(writer[0]);
} }
taosMemoryFree(writer[0]); taosMemoryFree(writer[0]);
writer[0] = NULL; 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 flag = (TD_FILE_READ | TD_FILE_WRITE | TD_FILE_CREATE | TD_FILE_TRUNC);
int32_t lcn = writer->files[ftype].lcn; 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); TAOS_CHECK_GOTO(tsdbOpenFile(fname, writer->config->tsdb, flag, &writer->fd[ftype], lcn), &lino, _exit);

86
source/dnode/vnode/src/tsdb/tsdbFS2.c
View File

@ -46,7 +46,7 @@ static int32_t create_fs(STsdb *pTsdb, STFileSystem **fs) {
} }
fs[0]->tsdb = pTsdb; fs[0]->tsdb = pTsdb;
tsem_init(&fs[0]->canEdit, 0, 1); (void)tsem_init(&fs[0]->canEdit, 0, 1);
fs[0]->fsstate = TSDB_FS_STATE_NORMAL; fs[0]->fsstate = TSDB_FS_STATE_NORMAL;
fs[0]->neid = 0; fs[0]->neid = 0;
TARRAY2_INIT(fs[0]->fSetArr); TARRAY2_INIT(fs[0]->fSetArr);
@ -60,7 +60,7 @@ static int32_t destroy_fs(STFileSystem **fs) {
TARRAY2_DESTROY(fs[0]->fSetArr, NULL); TARRAY2_DESTROY(fs[0]->fSetArr, NULL);
TARRAY2_DESTROY(fs[0]->fSetArrTmp, NULL); TARRAY2_DESTROY(fs[0]->fSetArrTmp, NULL);
tsem_destroy(&fs[0]->canEdit); (void)tsem_destroy(&fs[0]->canEdit);
taosMemoryFree(fs[0]); taosMemoryFree(fs[0]);
fs[0] = NULL; fs[0] = NULL;
return 0; return 0;
@ -69,7 +69,7 @@ static int32_t destroy_fs(STFileSystem **fs) {
int32_t current_fname(STsdb *pTsdb, char *fname, EFCurrentT ftype) { int32_t current_fname(STsdb *pTsdb, char *fname, EFCurrentT ftype) {
int32_t offset = 0; int32_t offset = 0;
vnodeGetPrimaryDir(pTsdb->path, pTsdb->pVnode->diskPrimary, pTsdb->pVnode->pTfs, fname, TSDB_FILENAME_LEN); (void)vnodeGetPrimaryDir(pTsdb->path, pTsdb->pVnode->diskPrimary, pTsdb->pVnode->pTfs, fname, TSDB_FILENAME_LEN);
offset = strlen(fname); offset = strlen(fname);
snprintf(fname + offset, TSDB_FILENAME_LEN - offset - 1, "%s%s", TD_DIRSEP, gCurrentFname[ftype]); snprintf(fname + offset, TSDB_FILENAME_LEN - offset - 1, "%s%s", TD_DIRSEP, gCurrentFname[ftype]);
@ -105,7 +105,7 @@ _exit:
tsdbError("%s failed at %s:%d since %s", __func__, fname, __LINE__, tstrerror(code)); tsdbError("%s failed at %s:%d since %s", __func__, fname, __LINE__, tstrerror(code));
} }
taosMemoryFree(data); taosMemoryFree(data);
taosCloseFile(&fp); (void)taosCloseFile(&fp);
return code; return code;
} }
@ -144,7 +144,7 @@ _exit:
tsdbError("%s failed at %s:%d since %s", __func__, fname, __LINE__, tstrerror(code)); tsdbError("%s failed at %s:%d since %s", __func__, fname, __LINE__, tstrerror(code));
json[0] = NULL; json[0] = NULL;
} }
taosCloseFile(&fp); (void)taosCloseFile(&fp);
taosMemoryFree(data); taosMemoryFree(data);
return code; return code;
} }
@ -174,7 +174,7 @@ int32_t save_fs(const TFileSetArray *arr, const char *fname) {
if (!item) { if (!item) {
TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit); TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit);
} }
cJSON_AddItemToArray(ajson, item); (void)cJSON_AddItemToArray(ajson, item);
code = tsdbTFileSetToJson(fset, item); code = tsdbTFileSetToJson(fset, item);
TSDB_CHECK_CODE(code, lino, _exit); TSDB_CHECK_CODE(code, lino, _exit);
@ -255,7 +255,7 @@ static int32_t apply_commit(STFileSystem *fs) {
if (fset1 && fset2) { if (fset1 && fset2) {
if (fset1->fid < fset2->fid) { if (fset1->fid < fset2->fid) {
// delete fset1 // delete fset1
tsdbTFileSetRemove(fset1); (void)tsdbTFileSetRemove(fset1);
i1++; i1++;
} else if (fset1->fid > fset2->fid) { } else if (fset1->fid > fset2->fid) {
// create new file set with fid of fset2->fid // create new file set with fid of fset2->fid
@ -274,7 +274,7 @@ static int32_t apply_commit(STFileSystem *fs) {
} }
} else if (fset1) { } else if (fset1) {
// delete fset1 // delete fset1
tsdbTFileSetRemove(fset1); (void)tsdbTFileSetRemove(fset1);
i1++; i1++;
} else { } else {
// create new file set with fid of fset2->fid // create new file set with fid of fset2->fid
@ -298,11 +298,11 @@ static int32_t commit_edit(STFileSystem *fs) {
char current[TSDB_FILENAME_LEN]; char current[TSDB_FILENAME_LEN];
char current_t[TSDB_FILENAME_LEN]; char current_t[TSDB_FILENAME_LEN];
current_fname(fs->tsdb, current, TSDB_FCURRENT); (void)current_fname(fs->tsdb, current, TSDB_FCURRENT);
if (fs->etype == TSDB_FEDIT_COMMIT) { if (fs->etype == TSDB_FEDIT_COMMIT) {
current_fname(fs->tsdb, current_t, TSDB_FCURRENT_C); (void)current_fname(fs->tsdb, current_t, TSDB_FCURRENT_C);
} else { } else {
current_fname(fs->tsdb, current_t, TSDB_FCURRENT_M); (void)current_fname(fs->tsdb, current_t, TSDB_FCURRENT_M);
} }
int32_t code; int32_t code;
@ -333,9 +333,9 @@ static int32_t abort_edit(STFileSystem *fs) {
char fname[TSDB_FILENAME_LEN]; char fname[TSDB_FILENAME_LEN];
if (fs->etype == TSDB_FEDIT_COMMIT) { if (fs->etype == TSDB_FEDIT_COMMIT) {
current_fname(fs->tsdb, fname, TSDB_FCURRENT_C); (void)current_fname(fs->tsdb, fname, TSDB_FCURRENT_C);
} else { } else {
current_fname(fs->tsdb, fname, TSDB_FCURRENT_M); (void)current_fname(fs->tsdb, fname, TSDB_FCURRENT_M);
} }
int32_t code; int32_t code;
@ -368,7 +368,7 @@ static int32_t tsdbFSDoScanAndFixFile(STFileSystem *fs, const STFileObj *fobj) {
if (tsS3Enabled && fobj->f->lcn > 1) { if (tsS3Enabled && fobj->f->lcn > 1) {
char fname1[TSDB_FILENAME_LEN]; char fname1[TSDB_FILENAME_LEN];
tsdbTFileLastChunkName(fs->tsdb, fobj->f, fname1); (void)tsdbTFileLastChunkName(fs->tsdb, fobj->f, fname1);
if (!taosCheckExistFile(fname1)) { if (!taosCheckExistFile(fname1)) {
code = TSDB_CODE_FILE_CORRUPTED; code = TSDB_CODE_FILE_CORRUPTED;
tsdbError("vgId:%d %s failed since file:%s does not exist", TD_VID(fs->tsdb->pVnode), __func__, fname1); tsdbError("vgId:%d %s failed since file:%s does not exist", TD_VID(fs->tsdb->pVnode), __func__, fname1);
@ -419,7 +419,7 @@ static int32_t tsdbFSCreateFileObjHash(STFileSystem *fs, STFileHash *hash) {
} }
// vnode.json // vnode.json
current_fname(fs->tsdb, fname, TSDB_FCURRENT); (void)current_fname(fs->tsdb, fname, TSDB_FCURRENT);
code = tsdbFSAddEntryToFileObjHash(hash, fname); code = tsdbFSAddEntryToFileObjHash(hash, fname);
TSDB_CHECK_CODE(code, lino, _exit); TSDB_CHECK_CODE(code, lino, _exit);
@ -603,9 +603,9 @@ static int32_t open_fs(STFileSystem *fs, int8_t rollback) {
char cCurrent[TSDB_FILENAME_LEN]; char cCurrent[TSDB_FILENAME_LEN];
char mCurrent[TSDB_FILENAME_LEN]; char mCurrent[TSDB_FILENAME_LEN];
current_fname(pTsdb, fCurrent, TSDB_FCURRENT); (void)current_fname(pTsdb, fCurrent, TSDB_FCURRENT);
current_fname(pTsdb, cCurrent, TSDB_FCURRENT_C); (void)current_fname(pTsdb, cCurrent, TSDB_FCURRENT_C);
current_fname(pTsdb, mCurrent, TSDB_FCURRENT_M); (void)current_fname(pTsdb, mCurrent, TSDB_FCURRENT_M);
if (taosCheckExistFile(fCurrent)) { // current.json exists if (taosCheckExistFile(fCurrent)) { // current.json exists
code = load_fs(pTsdb, fCurrent, fs->fSetArr); code = load_fs(pTsdb, fCurrent, fs->fSetArr);
@ -744,7 +744,7 @@ int32_t tsdbOpenFS(STsdb *pTsdb, STFileSystem **fs, int8_t rollback) {
_exit: _exit:
if (code) { if (code) {
tsdbError("vgId:%d %s failed at line %d since %s", TD_VID(pTsdb->pVnode), __func__, lino, tstrerror(code)); tsdbError("vgId:%d %s failed at line %d since %s", TD_VID(pTsdb->pVnode), __func__, lino, tstrerror(code));
destroy_fs(fs); (void)destroy_fs(fs);
} else { } else {
tsdbInfo("vgId:%d %s success", TD_VID(pTsdb->pVnode), __func__); tsdbInfo("vgId:%d %s success", TD_VID(pTsdb->pVnode), __func__);
} }
@ -777,7 +777,7 @@ int32_t tsdbDisableAndCancelAllBgTask(STsdb *pTsdb) {
} }
fset->channel = (SVAChannelID){0}; fset->channel = (SVAChannelID){0};
fset->mergeScheduled = false; fset->mergeScheduled = false;
tsdbFSSetBlockCommit(fset, false); (void)tsdbFSSetBlockCommit(fset, false);
fset->channelOpened = false; fset->channelOpened = false;
} }
} }
@ -787,12 +787,12 @@ int32_t tsdbDisableAndCancelAllBgTask(STsdb *pTsdb) {
// destroy all channels // destroy all channels
for (int32_t i = 0; i < taosArrayGetSize(channelArray); i++) { for (int32_t i = 0; i < taosArrayGetSize(channelArray); i++) {
SVAChannelID *channel = taosArrayGet(channelArray, i); SVAChannelID *channel = taosArrayGet(channelArray, i);
vnodeAChannelDestroy(channel, true); (void)vnodeAChannelDestroy(channel, true);
} }
taosArrayDestroy(channelArray); taosArrayDestroy(channelArray);
#ifdef TD_ENTERPRISE #ifdef TD_ENTERPRISE
tsdbStopAllCompTask(pTsdb); (void)tsdbStopAllCompTask(pTsdb);
#endif #endif
return 0; return 0;
} }
@ -807,9 +807,9 @@ int32_t tsdbEnableBgTask(STsdb *pTsdb) {
int32_t tsdbCloseFS(STFileSystem **fs) { int32_t tsdbCloseFS(STFileSystem **fs) {
if (fs[0] == NULL) return 0; if (fs[0] == NULL) return 0;
tsdbDisableAndCancelAllBgTask((*fs)->tsdb); (void)tsdbDisableAndCancelAllBgTask((*fs)->tsdb);
close_file_system(fs[0]); (void)close_file_system(fs[0]);
destroy_fs(fs); (void)destroy_fs(fs);
return 0; return 0;
} }
@ -832,12 +832,12 @@ int32_t tsdbFSEditBegin(STFileSystem *fs, const TFileOpArray *opArray, EFEditT e
char current_t[TSDB_FILENAME_LEN]; char current_t[TSDB_FILENAME_LEN];
if (etype == TSDB_FEDIT_COMMIT) { if (etype == TSDB_FEDIT_COMMIT) {
current_fname(fs->tsdb, current_t, TSDB_FCURRENT_C); (void)current_fname(fs->tsdb, current_t, TSDB_FCURRENT_C);
} else { } else {
current_fname(fs->tsdb, current_t, TSDB_FCURRENT_M); (void)current_fname(fs->tsdb, current_t, TSDB_FCURRENT_M);
} }
tsem_wait(&fs->canEdit); (void)tsem_wait(&fs->canEdit);
fs->etype = etype; fs->etype = etype;
// edit // edit
@ -864,7 +864,7 @@ static int32_t tsdbFSSetBlockCommit(STFileSet *fset, bool block) {
} else { } else {
fset->blockCommit = false; fset->blockCommit = false;
if (fset->numWaitCommit > 0) { if (fset->numWaitCommit > 0) {
taosThreadCondSignal(&fset->canCommit); (void)taosThreadCondSignal(&fset->canCommit);
} }
} }
return 0; return 0;
@ -873,11 +873,11 @@ static int32_t tsdbFSSetBlockCommit(STFileSet *fset, bool block) {
int32_t tsdbFSCheckCommit(STsdb *tsdb, int32_t fid) { int32_t tsdbFSCheckCommit(STsdb *tsdb, int32_t fid) {
(void)taosThreadMutexLock(&tsdb->mutex); (void)taosThreadMutexLock(&tsdb->mutex);
STFileSet *fset; STFileSet *fset;
tsdbFSGetFSet(tsdb->pFS, fid, &fset); (void)tsdbFSGetFSet(tsdb->pFS, fid, &fset);
if (fset) { if (fset) {
while (fset->blockCommit) { while (fset->blockCommit) {
fset->numWaitCommit++; fset->numWaitCommit++;
taosThreadCondWait(&fset->canCommit, &tsdb->mutex); (void)taosThreadCondWait(&fset->canCommit, &tsdb->mutex);
fset->numWaitCommit--; fset->numWaitCommit--;
} }
} }
@ -901,13 +901,13 @@ int32_t tsdbFSEditCommit(STFileSystem *fs) {
STFileSet *fset; STFileSet *fset;
TARRAY2_FOREACH_REVERSE(fs->fSetArr, fset) { TARRAY2_FOREACH_REVERSE(fs->fSetArr, fset) {
if (TARRAY2_SIZE(fset->lvlArr) == 0) { if (TARRAY2_SIZE(fset->lvlArr) == 0) {
tsdbFSSetBlockCommit(fset, false); (void)tsdbFSSetBlockCommit(fset, false);
continue; continue;
} }
SSttLvl *lvl = TARRAY2_FIRST(fset->lvlArr); SSttLvl *lvl = TARRAY2_FIRST(fset->lvlArr);
if (lvl->level != 0) { if (lvl->level != 0) {
tsdbFSSetBlockCommit(fset, false); (void)tsdbFSSetBlockCommit(fset, false);
continue; continue;
} }
@ -932,9 +932,9 @@ int32_t tsdbFSEditCommit(STFileSystem *fs) {
} }
if (numFile >= sttTrigger * BLOCK_COMMIT_FACTOR) { if (numFile >= sttTrigger * BLOCK_COMMIT_FACTOR) {
tsdbFSSetBlockCommit(fset, true); (void)tsdbFSSetBlockCommit(fset, true);
} else { } else {
tsdbFSSetBlockCommit(fset, false); (void)tsdbFSSetBlockCommit(fset, false);
} }
} }
} }
@ -945,13 +945,13 @@ _exit:
} else { } else {
tsdbInfo("vgId:%d %s done, etype:%d", TD_VID(fs->tsdb->pVnode), __func__, fs->etype); tsdbInfo("vgId:%d %s done, etype:%d", TD_VID(fs->tsdb->pVnode), __func__, fs->etype);
} }
tsem_post(&fs->canEdit); (void)tsem_post(&fs->canEdit);
return code; return code;
} }
int32_t tsdbFSEditAbort(STFileSystem *fs) { int32_t tsdbFSEditAbort(STFileSystem *fs) {
int32_t code = abort_edit(fs); int32_t code = abort_edit(fs);
tsem_post(&fs->canEdit); (void)tsem_post(&fs->canEdit);
return code; return code;
} }
@ -1163,7 +1163,7 @@ int32_t tsdbFSCreateRefRangedSnapshot(STFileSystem *fs, int64_t sver, int64_t ev
(void)taosThreadMutexUnlock(&fs->tsdb->mutex); (void)taosThreadMutexUnlock(&fs->tsdb->mutex);
if (code) { if (code) {
tsdbTFileSetRangeClear(&fsr1); (void)tsdbTFileSetRangeClear(&fsr1);
TARRAY2_DESTROY(fsrArr[0], tsdbTFileSetRangeClear); TARRAY2_DESTROY(fsrArr[0], tsdbTFileSetRangeClear);
fsrArr[0] = NULL; fsrArr[0] = NULL;
} }
@ -1181,15 +1181,15 @@ int32_t tsdbFSDestroyRefRangedSnapshot(TFileSetRangeArray **fsrArr) { return tsd
int32_t tsdbBeginTaskOnFileSet(STsdb *tsdb, int32_t fid, STFileSet **fset) { int32_t tsdbBeginTaskOnFileSet(STsdb *tsdb, int32_t fid, STFileSet **fset) {
int16_t sttTrigger = tsdb->pVnode->config.sttTrigger; int16_t sttTrigger = tsdb->pVnode->config.sttTrigger;
tsdbFSGetFSet(tsdb->pFS, fid, fset); (void)tsdbFSGetFSet(tsdb->pFS, fid, fset);
if (sttTrigger == 1 && (*fset)) { if (sttTrigger == 1 && (*fset)) {
for (;;) { for (;;) {
if ((*fset)->taskRunning) { if ((*fset)->taskRunning) {
(*fset)->numWaitTask++; (*fset)->numWaitTask++;
taosThreadCondWait(&(*fset)->beginTask, &tsdb->mutex); (void)taosThreadCondWait(&(*fset)->beginTask, &tsdb->mutex);
tsdbFSGetFSet(tsdb->pFS, fid, fset); (void)tsdbFSGetFSet(tsdb->pFS, fid, fset);
ASSERT(fset != NULL); ASSERT(fset != NULL);
(*fset)->numWaitTask--; (*fset)->numWaitTask--;
@ -1209,11 +1209,11 @@ int32_t tsdbFinishTaskOnFileSet(STsdb *tsdb, int32_t fid) {
int16_t sttTrigger = tsdb->pVnode->config.sttTrigger; int16_t sttTrigger = tsdb->pVnode->config.sttTrigger;
if (sttTrigger == 1) { if (sttTrigger == 1) {
STFileSet *fset = NULL; STFileSet *fset = NULL;
tsdbFSGetFSet(tsdb->pFS, fid, &fset); (void)tsdbFSGetFSet(tsdb->pFS, fid, &fset);
if (fset != NULL && fset->taskRunning) { if (fset != NULL && fset->taskRunning) {
fset->taskRunning = false; fset->taskRunning = false;
if (fset->numWaitTask > 0) { if (fset->numWaitTask > 0) {
taosThreadCondSignal(&fset->beginTask); (void)taosThreadCondSignal(&fset->beginTask);
} }
tsdbInfo("vgId:%d finish task on file set:%d", TD_VID(tsdb->pVnode), fid); tsdbInfo("vgId:%d finish task on file set:%d", TD_VID(tsdb->pVnode), fid);
} }

7
source/dnode/vnode/src/tsdb/tsdbFSet2.c
View File

@ -45,7 +45,7 @@ static int32_t tsdbSttLvlInitEx(STsdb *pTsdb, const SSttLvl *lvl1, SSttLvl **lvl
STFileObj *fobj; STFileObj *fobj;
code = tsdbTFileObjInit(pTsdb, fobj1->f, &fobj); code = tsdbTFileObjInit(pTsdb, fobj1->f, &fobj);
if (code) { if (code) {
tsdbSttLvlClear(lvl); (void)tsdbSttLvlClear(lvl);
return code; return code;
} }
@ -79,7 +79,7 @@ static int32_t tsdbSttLvlFilteredInitEx(STsdb *pTsdb, const SSttLvl *lvl1, int64
STFileObj *fobj; STFileObj *fobj;
code = tsdbTFileObjInit(pTsdb, fobj1->f, &fobj); code = tsdbTFileObjInit(pTsdb, fobj1->f, &fobj);
if (code) { if (code) {
tsdbSttLvlClear(lvl); (void)tsdbSttLvlClear(lvl);
return code; return code;
} }
@ -522,7 +522,8 @@ int32_t tsdbTFileSetFilteredInitDup(STsdb *pTsdb, const STFileSet *fset1, int64_
.fid = fobj->f->fid, .fid = fobj->f->fid,
.of = fobj->f[0], .of = fobj->f[0],
}; };
TARRAY2_APPEND(fopArr, op); code = TARRAY2_APPEND(fopArr, op);
if (code) return code;
} }
} }

2
source/dnode/vnode/src/tsdb/tsdbFile.c
View File

@ -221,7 +221,7 @@ void tsdbDelFileName(STsdb *pTsdb, SDelFile *pFile, char fname[]) {
int32_t offset = 0; int32_t offset = 0;
SVnode *pVnode = pTsdb->pVnode; SVnode *pVnode = pTsdb->pVnode;
vnodeGetPrimaryDir(pTsdb->path, pVnode->diskPrimary, pVnode->pTfs, fname, TSDB_FILENAME_LEN); (void)vnodeGetPrimaryDir(pTsdb->path, pVnode->diskPrimary, pVnode->pTfs, fname, TSDB_FILENAME_LEN);
offset = strlen(fname); offset = strlen(fname);
snprintf((char *)fname + offset, TSDB_FILENAME_LEN - offset - 1, "%sv%dver%" PRId64 ".del", TD_DIRSEP, snprintf((char *)fname + offset, TSDB_FILENAME_LEN - offset - 1, "%sv%dver%" PRId64 ".del", TD_DIRSEP,
TD_VID(pTsdb->pVnode), pFile->commitID); TD_VID(pTsdb->pVnode), pFile->commitID);

2
source/dnode/vnode/src/tsdb/tsdbIter.c
View File

@ -224,7 +224,7 @@ static int32_t tsdbMemTableIterNext(STsdbIter *iter, const TABLEID *tbid) {
iter->row->row = row[0]; iter->row->row = row[0];
tsdbTbDataIterNext(iter->memtData->tbIter); (void)tsdbTbDataIterNext(iter->memtData->tbIter);
goto _exit; goto _exit;
} }

12
source/dnode/vnode/src/tsdb/tsdbMerge.c
View File

@ -215,7 +215,7 @@ static int32_t tsdbMergeFileSetBeginOpenReader(SMerger *merger) {
TAOS_CHECK_GOTO(tsdbSttFileReaderOpen(fobj->fname, &config, &reader), &lino, _exit); TAOS_CHECK_GOTO(tsdbSttFileReaderOpen(fobj->fname, &config, &reader), &lino, _exit);
if ((code = TARRAY2_APPEND(merger->sttReaderArr, reader))) { if ((code = TARRAY2_APPEND(merger->sttReaderArr, reader))) {
tsdbSttFileReaderClose(&reader); (void)tsdbSttFileReaderClose(&reader);
TSDB_CHECK_CODE(code, lino, _exit); TSDB_CHECK_CODE(code, lino, _exit);
} }
} }
@ -230,7 +230,7 @@ _exit:
if (code) { if (code) {
tsdbError("vgId:%d %s failed at %s:%d since %s", TD_VID(merger->tsdb->pVnode), __func__, __FILE__, lino, tsdbError("vgId:%d %s failed at %s:%d since %s", TD_VID(merger->tsdb->pVnode), __func__, __FILE__, lino,
tstrerror(code)); tstrerror(code));
tsdbMergeFileSetEndCloseReader(merger); (void)tsdbMergeFileSetEndCloseReader(merger);
} }
return code; return code;
} }
@ -282,7 +282,7 @@ static int32_t tsdbMergeFileSetBeginOpenWriter(SMerger *merger) {
TAOS_CHECK_GOTO(tfsAllocDisk(merger->tsdb->pVnode->pTfs, level, &did), &lino, _exit); TAOS_CHECK_GOTO(tfsAllocDisk(merger->tsdb->pVnode->pTfs, level, &did), &lino, _exit);
tfsMkdirRecurAt(merger->tsdb->pVnode->pTfs, merger->tsdb->path, did); (void)tfsMkdirRecurAt(merger->tsdb->pVnode->pTfs, merger->tsdb->path, did);
SFSetWriterConfig config = { SFSetWriterConfig config = {
.tsdb = merger->tsdb, .tsdb = merger->tsdb,
.toSttOnly = true, .toSttOnly = true,
@ -355,9 +355,9 @@ static int32_t tsdbMergeFileSetEndCloseWriter(SMerger *merger) {
} }
static int32_t tsdbMergeFileSetEndCloseIter(SMerger *merger) { static int32_t tsdbMergeFileSetEndCloseIter(SMerger *merger) {
tsdbIterMergerClose(&merger->tombIterMerger); (void)tsdbIterMergerClose(&merger->tombIterMerger);
TARRAY2_CLEAR(merger->tombIterArr, tsdbIterClose); TARRAY2_CLEAR(merger->tombIterArr, tsdbIterClose);
tsdbIterMergerClose(&merger->dataIterMerger); (void)tsdbIterMergerClose(&merger->dataIterMerger);
TARRAY2_CLEAR(merger->dataIterArr, tsdbIterClose); TARRAY2_CLEAR(merger->dataIterArr, tsdbIterClose);
return 0; return 0;
} }
@ -479,7 +479,7 @@ static int32_t tsdbMergeGetFSet(SMerger *merger) {
STFileSet *fset; STFileSet *fset;
(void)taosThreadMutexLock(&merger->tsdb->mutex); (void)taosThreadMutexLock(&merger->tsdb->mutex);
tsdbFSGetFSet(merger->tsdb->pFS, merger->fid, &fset); (void)tsdbFSGetFSet(merger->tsdb->pFS, merger->fid, &fset);
if (fset == NULL) { if (fset == NULL) {
(void)taosThreadMutexUnlock(&merger->tsdb->mutex); (void)taosThreadMutexUnlock(&merger->tsdb->mutex);
return 0; return 0;

18
source/dnode/vnode/src/tsdb/tsdbOpen.c
View File

@ -57,18 +57,18 @@ 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); snprintf(pTsdb->path, TD_PATH_MAX, "%s%s%s", pVnode->path, TD_DIRSEP, dir);
// taosRealPath(pTsdb->path, NULL, slen); // taosRealPath(pTsdb->path, NULL, slen);
pTsdb->pVnode = pVnode; pTsdb->pVnode = pVnode;
taosThreadMutexInit(&pTsdb->mutex, NULL); (void)taosThreadMutexInit(&pTsdb->mutex, NULL);
if (!pKeepCfg) { if (!pKeepCfg) {
tsdbSetKeepCfg(pTsdb, &pVnode->config.tsdbCfg); (void)tsdbSetKeepCfg(pTsdb, &pVnode->config.tsdbCfg);
} else { } else {
memcpy(&pTsdb->keepCfg, pKeepCfg, sizeof(STsdbKeepCfg)); memcpy(&pTsdb->keepCfg, pKeepCfg, sizeof(STsdbKeepCfg));
} }
// create dir // create dir
if (pVnode->pTfs) { if (pVnode->pTfs) {
tfsMkdir(pVnode->pTfs, pTsdb->path); (void)tfsMkdir(pVnode->pTfs, pTsdb->path);
} else { } else {
taosMkDir(pTsdb->path); (void)taosMkDir(pTsdb->path);
} }
// open tsdb // open tsdb
@ -87,8 +87,8 @@ int32_t tsdbOpen(SVnode *pVnode, STsdb **ppTsdb, const char *dir, STsdbKeepCfg *
_exit: _exit:
if (code) { if (code) {
tsdbError("vgId:%d %s failed at %s:%d since %s", TD_VID(pVnode), __func__, __FILE__, lino, tstrerror(code)); tsdbError("vgId:%d %s failed at %s:%d since %s", TD_VID(pVnode), __func__, __FILE__, lino, tstrerror(code));
tsdbCloseFS(&pTsdb->pFS); (void)tsdbCloseFS(&pTsdb->pFS);
taosThreadMutexDestroy(&pTsdb->mutex); (void)taosThreadMutexDestroy(&pTsdb->mutex);
taosMemoryFree(pTsdb); taosMemoryFree(pTsdb);
} else { } else {
tsdbDebug("vgId:%d, tsdb is opened at %s, days:%d, keep:%d,%d,%d, keepTimeoffset:%d", TD_VID(pVnode), pTsdb->path, tsdbDebug("vgId:%d, tsdb is opened at %s, days:%d, keep:%d,%d,%d, keepTimeoffset:%d", TD_VID(pVnode), pTsdb->path,
@ -110,12 +110,12 @@ int32_t tsdbClose(STsdb **pTsdb) {
(*pTsdb)->mem = NULL; (*pTsdb)->mem = NULL;
(void)taosThreadMutexUnlock(&(*pTsdb)->mutex); (void)taosThreadMutexUnlock(&(*pTsdb)->mutex);
tsdbCloseFS(&(*pTsdb)->pFS); (void)tsdbCloseFS(&(*pTsdb)->pFS);
tsdbCloseCache(*pTsdb); tsdbCloseCache(*pTsdb);
#ifdef TD_ENTERPRISE #ifdef TD_ENTERPRISE
tsdbCloseCompMonitor(*pTsdb); (void)tsdbCloseCompMonitor(*pTsdb);
#endif #endif
taosThreadMutexDestroy(&(*pTsdb)->mutex); (void)taosThreadMutexDestroy(&(*pTsdb)->mutex);
taosMemoryFreeClear(*pTsdb); taosMemoryFreeClear(*pTsdb);
} }
return 0; return 0;

12
source/dnode/vnode/src/tsdb/tsdbReaderWriter.c
View File

@ -35,7 +35,7 @@ static int32_t tsdbOpenFileImpl(STsdbFD *pFD) {
int32_t vid = 0; int32_t vid = 0;
const char *object_name = taosDirEntryBaseName((char *)path); const char *object_name = taosDirEntryBaseName((char *)path);
sscanf(object_name, "v%df%dver%" PRId64 ".data", &vid, &pFD->fid, &pFD->cid); (void)sscanf(object_name, "v%df%dver%" PRId64 ".data", &vid, &pFD->fid, &pFD->cid);
char *dot = strrchr(lc_path, '.'); char *dot = strrchr(lc_path, '.');
if (!dot) { if (!dot) {
@ -124,7 +124,7 @@ void tsdbCloseFile(STsdbFD **ppFD) {
if (pFD) { if (pFD) {
taosMemoryFree(pFD->pBuf); taosMemoryFree(pFD->pBuf);
// if (!pFD->s3File) { // if (!pFD->s3File) {
taosCloseFile(&pFD->pFD); (void)taosCloseFile(&pFD->pFD);
//} //}
taosMemoryFree(pFD); taosMemoryFree(pFD);
*ppFD = NULL; *ppFD = NULL;
@ -156,7 +156,7 @@ static int32_t tsdbWriteFilePage(STsdbFD *pFD, int32_t encryptAlgorithm, char *e
TSDB_CHECK_CODE(code = TAOS_SYSTEM_ERROR(errno), lino, _exit); TSDB_CHECK_CODE(code = TAOS_SYSTEM_ERROR(errno), lino, _exit);
} }
taosCalcChecksumAppend(0, pFD->pBuf, pFD->szPage); (void)taosCalcChecksumAppend(0, pFD->pBuf, pFD->szPage);
if (encryptAlgorithm == DND_CA_SM4) { if (encryptAlgorithm == DND_CA_SM4) {
// if(tsiEncryptAlgorithm == DND_CA_SM4 && (tsiEncryptScope & DND_CS_TSDB) == DND_CS_TSDB){ // if(tsiEncryptAlgorithm == DND_CA_SM4 && (tsiEncryptScope & DND_CS_TSDB) == DND_CS_TSDB){
@ -430,7 +430,7 @@ static int32_t tsdbReadFileS3(STsdbFD *pFD, int64_t offset, uint8_t *pBuf, int64
code = tsdbCacheGetPageS3(pFD->pTsdb->pgCache, pFD, pgno, &handle); code = tsdbCacheGetPageS3(pFD->pTsdb->pgCache, pFD, pgno, &handle);
if (code != TSDB_CODE_SUCCESS) { if (code != TSDB_CODE_SUCCESS) {
if (handle) { if (handle) {
tsdbCacheRelease(pFD->pTsdb->pgCache, handle); (void)tsdbCacheRelease(pFD->pTsdb->pgCache, handle);
} }
TSDB_CHECK_CODE(code, lino, _exit); TSDB_CHECK_CODE(code, lino, _exit);
} }
@ -441,7 +441,7 @@ static int32_t tsdbReadFileS3(STsdbFD *pFD, int64_t offset, uint8_t *pBuf, int64
uint8_t *pPage = (uint8_t *)taosLRUCacheValue(pFD->pTsdb->pgCache, handle); uint8_t *pPage = (uint8_t *)taosLRUCacheValue(pFD->pTsdb->pgCache, handle);
memcpy(pFD->pBuf, pPage, pFD->szPage); memcpy(pFD->pBuf, pPage, pFD->szPage);
tsdbCacheRelease(pFD->pTsdb->pgCache, handle); (void)tsdbCacheRelease(pFD->pTsdb->pgCache, handle);
// check // check
if (pgno > 1 && !taosCheckChecksumWhole(pFD->pBuf, pFD->szPage)) { if (pgno > 1 && !taosCheckChecksumWhole(pFD->pBuf, pFD->szPage)) {
@ -477,7 +477,7 @@ static int32_t tsdbReadFileS3(STsdbFD *pFD, int64_t offset, uint8_t *pBuf, int64
int nPage = pgnoEnd - pgno + 1; int nPage = pgnoEnd - pgno + 1;
for (int i = 0; i < nPage; ++i) { for (int i = 0; i < nPage; ++i) {
if (pFD->szFile != pgno) { // DONOT cache last volatile page if (pFD->szFile != pgno) { // DONOT cache last volatile page
tsdbCacheSetPageS3(pFD->pTsdb->pgCache, pFD, pgno, pBlock + i * pFD->szPage); (void)tsdbCacheSetPageS3(pFD->pTsdb->pgCache, pFD, pgno, pBlock + i * pFD->szPage);
} }
if (szHint > 0 && n >= size) { if (szHint > 0 && n >= size) {

42
source/dnode/vnode/src/tsdb/tsdbRetention.c
View File

@ -71,8 +71,8 @@ static int32_t tsdbDoCopyFileLC(SRTNer *rtner, const STFileObj *from, const STFi
char fname_from[TSDB_FILENAME_LEN]; char fname_from[TSDB_FILENAME_LEN];
char fname_to[TSDB_FILENAME_LEN]; char fname_to[TSDB_FILENAME_LEN];
tsdbTFileLastChunkName(rtner->tsdb, from->f, fname_from); (void)tsdbTFileLastChunkName(rtner->tsdb, from->f, fname_from);
tsdbTFileLastChunkName(rtner->tsdb, to, fname_to); (void)tsdbTFileLastChunkName(rtner->tsdb, to, fname_to);
fdFrom = taosOpenFile(fname_from, TD_FILE_READ); fdFrom = taosOpenFile(fname_from, TD_FILE_READ);
if (fdFrom == NULL) { if (fdFrom == NULL) {
@ -99,8 +99,8 @@ _exit:
tsdbError("vgId:%d, %s failed at %s:%d since %s", TD_VID(rtner->tsdb->pVnode), __func__, __FILE__, lino, tsdbError("vgId:%d, %s failed at %s:%d since %s", TD_VID(rtner->tsdb->pVnode), __func__, __FILE__, lino,
tstrerror(code)); tstrerror(code));
} }
taosCloseFile(&fdFrom); (void)taosCloseFile(&fdFrom);
taosCloseFile(&fdTo); (void)taosCloseFile(&fdTo);
return code; return code;
} }
@ -112,7 +112,7 @@ static int32_t tsdbDoCopyFile(SRTNer *rtner, const STFileObj *from, const STFile
TdFilePtr fdFrom = NULL; TdFilePtr fdFrom = NULL;
TdFilePtr fdTo = NULL; TdFilePtr fdTo = NULL;
tsdbTFileName(rtner->tsdb, to, fname); (void)tsdbTFileName(rtner->tsdb, to, fname);
fdFrom = taosOpenFile(from->fname, TD_FILE_READ); fdFrom = taosOpenFile(from->fname, TD_FILE_READ);
if (fdFrom == NULL) { if (fdFrom == NULL) {
@ -136,8 +136,8 @@ _exit:
tsdbError("vgId:%d, %s failed at %s:%d since %s", TD_VID(rtner->tsdb->pVnode), __func__, __FILE__, lino, tsdbError("vgId:%d, %s failed at %s:%d since %s", TD_VID(rtner->tsdb->pVnode), __func__, __FILE__, lino,
tstrerror(code)); tstrerror(code));
} }
taosCloseFile(&fdFrom); (void)taosCloseFile(&fdFrom);
taosCloseFile(&fdTo); (void)taosCloseFile(&fdTo);
return code; return code;
} }
@ -255,7 +255,7 @@ static int32_t tsdbDoRetention(SRTNer *rtner) {
SDiskID did; SDiskID did;
TAOS_CHECK_GOTO(tfsAllocDisk(rtner->tsdb->pVnode->pTfs, expLevel, &did), &lino, _exit); TAOS_CHECK_GOTO(tfsAllocDisk(rtner->tsdb->pVnode->pTfs, expLevel, &did), &lino, _exit);
tfsMkdirRecurAt(rtner->tsdb->pVnode->pTfs, rtner->tsdb->path, did); (void)tfsMkdirRecurAt(rtner->tsdb->pVnode->pTfs, rtner->tsdb->path, did);
// data // data
for (int32_t ftype = 0; ftype < TSDB_FTYPE_MAX && (fobj = fset->farr[ftype], 1); ++ftype) { for (int32_t ftype = 0; ftype < TSDB_FTYPE_MAX && (fobj = fset->farr[ftype], 1); ++ftype) {
@ -316,7 +316,7 @@ static int32_t tsdbRetention(void *arg) {
// begin task // begin task
(void)taosThreadMutexLock(&pTsdb->mutex); (void)taosThreadMutexLock(&pTsdb->mutex);
tsdbBeginTaskOnFileSet(pTsdb, rtnArg->fid, &fset); (void)tsdbBeginTaskOnFileSet(pTsdb, rtnArg->fid, &fset);
if (fset && (code = tsdbTFileSetInitCopy(pTsdb, fset, &rtner.fset))) { if (fset && (code = tsdbTFileSetInitCopy(pTsdb, fset, &rtner.fset))) {
(void)taosThreadMutexUnlock(&pTsdb->mutex); (void)taosThreadMutexUnlock(&pTsdb->mutex);
TSDB_CHECK_CODE(code, lino, _exit); TSDB_CHECK_CODE(code, lino, _exit);
@ -337,7 +337,7 @@ static int32_t tsdbRetention(void *arg) {
_exit: _exit:
if (rtner.fset) { if (rtner.fset) {
(void)taosThreadMutexLock(&pTsdb->mutex); (void)taosThreadMutexLock(&pTsdb->mutex);
tsdbFinishTaskOnFileSet(pTsdb, rtnArg->fid); (void)tsdbFinishTaskOnFileSet(pTsdb, rtnArg->fid);
(void)taosThreadMutexUnlock(&pTsdb->mutex); (void)taosThreadMutexUnlock(&pTsdb->mutex);
} }
@ -427,7 +427,7 @@ static int32_t tsdbCopyFileS3(SRTNer *rtner, const STFileObj *from, const STFile
TdFilePtr fdFrom = NULL; TdFilePtr fdFrom = NULL;
// TdFilePtr fdTo = NULL; // TdFilePtr fdTo = NULL;
tsdbTFileName(rtner->tsdb, to, fname); (void)tsdbTFileName(rtner->tsdb, to, fname);
fdFrom = taosOpenFile(from->fname, TD_FILE_READ); fdFrom = taosOpenFile(from->fname, TD_FILE_READ);
if (fdFrom == NULL) { if (fdFrom == NULL) {
@ -442,7 +442,7 @@ _exit:
tsdbError("vgId:%d %s failed at line %s:%d since %s", TD_VID(rtner->tsdb->pVnode), __func__, __FILE__, lino, tsdbError("vgId:%d %s failed at line %s:%d since %s", TD_VID(rtner->tsdb->pVnode), __func__, __FILE__, lino,
tstrerror(code)); tstrerror(code));
} }
taosCloseFile(&fdFrom); (void)taosCloseFile(&fdFrom);
return code; return code;
} }
@ -486,7 +486,7 @@ static int32_t tsdbMigrateDataFileLCS3(SRTNer *rtner, const STFileObj *fobj, int
TAOS_CHECK_GOTO(TARRAY2_APPEND(&rtner->fopArr, op), &lino, _exit); TAOS_CHECK_GOTO(TARRAY2_APPEND(&rtner->fopArr, op), &lino, _exit);
char fname[TSDB_FILENAME_LEN]; char fname[TSDB_FILENAME_LEN];
tsdbTFileName(rtner->tsdb, &op.nf, fname); (void)tsdbTFileName(rtner->tsdb, &op.nf, fname);
char *object_name = taosDirEntryBaseName(fname); char *object_name = taosDirEntryBaseName(fname);
char object_name_prefix[TSDB_FILENAME_LEN]; char object_name_prefix[TSDB_FILENAME_LEN];
int32_t node_id = vnodeNodeId(rtner->tsdb->pVnode); int32_t node_id = vnodeNodeId(rtner->tsdb->pVnode);
@ -542,8 +542,8 @@ _exit:
tsdbError("vgId:%d %s failed at line %s:%d since %s", TD_VID(rtner->tsdb->pVnode), __func__, __FILE__, lino, tsdbError("vgId:%d %s failed at line %s:%d since %s", TD_VID(rtner->tsdb->pVnode), __func__, __FILE__, lino,
tstrerror(code)); tstrerror(code));
} }
taosCloseFile(&fdFrom); (void)taosCloseFile(&fdFrom);
taosCloseFile(&fdTo); (void)taosCloseFile(&fdTo);
return code; return code;
} }
@ -587,7 +587,7 @@ static int32_t tsdbMigrateDataFileS3(SRTNer *rtner, const STFileObj *fobj, int64
TAOS_CHECK_GOTO(TARRAY2_APPEND(&rtner->fopArr, op), &lino, _exit); TAOS_CHECK_GOTO(TARRAY2_APPEND(&rtner->fopArr, op), &lino, _exit);
char fname[TSDB_FILENAME_LEN]; char fname[TSDB_FILENAME_LEN];
tsdbTFileName(rtner->tsdb, &op.nf, fname); (void)tsdbTFileName(rtner->tsdb, &op.nf, fname);
char *object_name = taosDirEntryBaseName(fname); char *object_name = taosDirEntryBaseName(fname);
char object_name_prefix[TSDB_FILENAME_LEN]; char object_name_prefix[TSDB_FILENAME_LEN];
int32_t node_id = vnodeNodeId(rtner->tsdb->pVnode); int32_t node_id = vnodeNodeId(rtner->tsdb->pVnode);
@ -640,8 +640,8 @@ _exit:
tsdbError("vgId:%d %s failed at line %s:%d since %s", TD_VID(rtner->tsdb->pVnode), __func__, __FILE__, lino, tsdbError("vgId:%d %s failed at line %s:%d since %s", TD_VID(rtner->tsdb->pVnode), __func__, __FILE__, lino,
tstrerror(code)); tstrerror(code));
} }
taosCloseFile(&fdFrom); (void)taosCloseFile(&fdFrom);
taosCloseFile(&fdTo); (void)taosCloseFile(&fdTo);
return code; return code;
} }
@ -673,7 +673,7 @@ static int32_t tsdbDoS3Migrate(SRTNer *rtner) {
if (/*lcn < 1 && */ taosCheckExistFile(fobj->fname)) { if (/*lcn < 1 && */ taosCheckExistFile(fobj->fname)) {
int32_t mtime = 0; int32_t mtime = 0;
int64_t size = 0; int64_t size = 0;
taosStatFile(fobj->fname, &size, &mtime, NULL); (void)taosStatFile(fobj->fname, &size, &mtime, NULL);
if (size > chunksize && mtime < rtner->now - tsS3UploadDelaySec) { if (size > chunksize && mtime < rtner->now - tsS3UploadDelaySec) {
if (pCfg->s3Compact && lcn < 0) { if (pCfg->s3Compact && lcn < 0) {
extern int32_t tsdbAsyncCompact(STsdb * tsdb, const STimeWindow *tw, bool sync); extern int32_t tsdbAsyncCompact(STsdb * tsdb, const STimeWindow *tw, bool sync);
@ -695,12 +695,12 @@ static int32_t tsdbDoS3Migrate(SRTNer *rtner) {
TAOS_CHECK_GOTO(TSDB_CODE_INVALID_PARA, &lino, _exit); TAOS_CHECK_GOTO(TSDB_CODE_INVALID_PARA, &lino, _exit);
} }
char fname1[TSDB_FILENAME_LEN]; char fname1[TSDB_FILENAME_LEN];
tsdbTFileLastChunkName(rtner->tsdb, fobj->f, fname1); (void)tsdbTFileLastChunkName(rtner->tsdb, fobj->f, fname1);
if (taosCheckExistFile(fname1)) { if (taosCheckExistFile(fname1)) {
int32_t mtime = 0; int32_t mtime = 0;
int64_t size = 0; int64_t size = 0;
taosStatFile(fname1, &size, &mtime, NULL); (void)taosStatFile(fname1, &size, &mtime, NULL);
if (size > chunksize && mtime < rtner->now - tsS3UploadDelaySec) { if (size > chunksize && mtime < rtner->now - tsS3UploadDelaySec) {
TAOS_CHECK_GOTO(tsdbMigrateDataFileLCS3(rtner, fobj, size, chunksize), &lino, _exit); TAOS_CHECK_GOTO(tsdbMigrateDataFileLCS3(rtner, fobj, size, chunksize), &lino, _exit);
} }

2
source/dnode/vnode/src/tsdb/tsdbSnapInfo.c
View File

@ -196,7 +196,7 @@ int32_t tsdbFSetPartListToRangeDiff(STsdbFSetPartList* pList, TFileSetRangeArray
_err: _err:
if (pDiff) { if (pDiff) {
tsdbTFileSetRangeArrayDestroy(&pDiff); (void)tsdbTFileSetRangeArrayDestroy(&pDiff);
} }
return code; return code;
} }

48
source/dnode/vnode/src/tsdb/tsdbSnapshot.c
View File

@ -59,7 +59,7 @@ struct STsdbSnapReader {
static int32_t tsdbSnapReadFileSetCloseReader(STsdbSnapReader* reader) { static int32_t tsdbSnapReadFileSetCloseReader(STsdbSnapReader* reader) {
TARRAY2_CLEAR(reader->sttReaderArr, tsdbSttFileReaderClose); TARRAY2_CLEAR(reader->sttReaderArr, tsdbSttFileReaderClose);
tsdbDataFileReaderClose(&reader->dataReader); TAOS_UNUSED(tsdbDataFileReaderClose(&reader->dataReader));
return 0; return 0;
} }
@ -107,7 +107,7 @@ static int32_t tsdbSnapReadFileSetOpenReader(STsdbSnapReader* reader) {
TSDB_CHECK_CODE(code, lino, _exit); TSDB_CHECK_CODE(code, lino, _exit);
if ((code = TARRAY2_APPEND(reader->sttReaderArr, sttReader))) { if ((code = TARRAY2_APPEND(reader->sttReaderArr, sttReader))) {
tsdbSttFileReaderClose(&sttReader); TAOS_UNUSED(tsdbSttFileReaderClose(&sttReader));
TSDB_CHECK_CODE(code, lino, _exit); TSDB_CHECK_CODE(code, lino, _exit);
} }
} }
@ -115,7 +115,7 @@ static int32_t tsdbSnapReadFileSetOpenReader(STsdbSnapReader* reader) {
_exit: _exit:
if (code) { if (code) {
tsdbSnapReadFileSetCloseReader(reader); TAOS_UNUSED(tsdbSnapReadFileSetCloseReader(reader));
TSDB_ERROR_LOG(TD_VID(reader->tsdb->pVnode), code, lino); TSDB_ERROR_LOG(TD_VID(reader->tsdb->pVnode), code, lino);
} }
return code; return code;
@ -199,8 +199,8 @@ _exit:
} }
static int32_t tsdbSnapReadFileSetCloseIter(STsdbSnapReader* reader) { static int32_t tsdbSnapReadFileSetCloseIter(STsdbSnapReader* reader) {
tsdbIterMergerClose(&reader->dataIterMerger); TAOS_UNUSED(tsdbIterMergerClose(&reader->dataIterMerger));
tsdbIterMergerClose(&reader->tombIterMerger); TAOS_UNUSED(tsdbIterMergerClose(&reader->tombIterMerger));
TARRAY2_CLEAR(reader->dataIterArr, tsdbIterClose); TARRAY2_CLEAR(reader->dataIterArr, tsdbIterClose);
TARRAY2_CLEAR(reader->tombIterArr, tsdbIterClose); TARRAY2_CLEAR(reader->tombIterArr, tsdbIterClose);
return 0; return 0;
@ -232,8 +232,8 @@ _exit:
} }
static int32_t tsdbSnapReadRangeEnd(STsdbSnapReader* reader) { static int32_t tsdbSnapReadRangeEnd(STsdbSnapReader* reader) {
tsdbSnapReadFileSetCloseIter(reader); TAOS_UNUSED(tsdbSnapReadFileSetCloseIter(reader));
tsdbSnapReadFileSetCloseReader(reader); TAOS_UNUSED(tsdbSnapReadFileSetCloseReader(reader));
reader->ctx->fsr = NULL; reader->ctx->fsr = NULL;
return 0; return 0;
} }
@ -384,7 +384,7 @@ static int32_t tsdbSnapReadTombData(STsdbSnapReader* reader, uint8_t** data) {
int32_t lino = 0; int32_t lino = 0;
SMetaInfo info; SMetaInfo info;
tTombBlockClear(reader->tombBlock); TAOS_UNUSED(tTombBlockClear(reader->tombBlock));
TABLEID tbid[1] = {0}; TABLEID tbid[1] = {0};
for (STombRecord* record; (record = tsdbIterMergerGetTombRecord(reader->tombIterMerger)) != NULL;) { for (STombRecord* record; (record = tsdbIterMergerGetTombRecord(reader->tombIterMerger)) != NULL;) {
@ -441,7 +441,7 @@ _exit:
if (code) { if (code) {
tsdbError("vgId:%d %s failed at %s:%d since %s, sver:%" PRId64 " ever:%" PRId64 " type:%d", TD_VID(tsdb->pVnode), tsdbError("vgId:%d %s failed at %s:%d since %s, sver:%" PRId64 " ever:%" PRId64 " type:%d", TD_VID(tsdb->pVnode),
__func__, __FILE__, lino, tstrerror(code), sver, ever, type); __func__, __FILE__, lino, tstrerror(code), sver, ever, type);
tsdbTFileSetRangeArrayDestroy(&reader[0]->fsrArr); TAOS_UNUSED(tsdbTFileSetRangeArrayDestroy(&reader[0]->fsrArr));
taosMemoryFree(reader[0]); taosMemoryFree(reader[0]);
reader[0] = NULL; reader[0] = NULL;
} else { } else {
@ -460,21 +460,21 @@ int32_t tsdbSnapReaderClose(STsdbSnapReader** reader) {
STsdb* tsdb = reader[0]->tsdb; STsdb* tsdb = reader[0]->tsdb;
tTombBlockDestroy(reader[0]->tombBlock); TAOS_UNUSED(tTombBlockDestroy(reader[0]->tombBlock));
tBlockDataDestroy(reader[0]->blockData); tBlockDataDestroy(reader[0]->blockData);
tsdbIterMergerClose(&reader[0]->dataIterMerger); TAOS_UNUSED(tsdbIterMergerClose(&reader[0]->dataIterMerger));
tsdbIterMergerClose(&reader[0]->tombIterMerger); TAOS_UNUSED(tsdbIterMergerClose(&reader[0]->tombIterMerger));
TARRAY2_DESTROY(reader[0]->dataIterArr, tsdbIterClose); TARRAY2_DESTROY(reader[0]->dataIterArr, tsdbIterClose);
TARRAY2_DESTROY(reader[0]->tombIterArr, tsdbIterClose); TARRAY2_DESTROY(reader[0]->tombIterArr, tsdbIterClose);
TARRAY2_DESTROY(reader[0]->sttReaderArr, tsdbSttFileReaderClose); TARRAY2_DESTROY(reader[0]->sttReaderArr, tsdbSttFileReaderClose);
tsdbDataFileReaderClose(&reader[0]->dataReader); TAOS_UNUSED(tsdbDataFileReaderClose(&reader[0]->dataReader));
tsdbFSDestroyRefRangedSnapshot(&reader[0]->fsrArr); TAOS_UNUSED(tsdbFSDestroyRefRangedSnapshot(&reader[0]->fsrArr));
tDestroyTSchema(reader[0]->skmTb->pTSchema); tDestroyTSchema(reader[0]->skmTb->pTSchema);
for (int32_t i = 0; i < ARRAY_SIZE(reader[0]->buffers); ++i) { for (int32_t i = 0; i < ARRAY_SIZE(reader[0]->buffers); ++i) {
tBufferDestroy(reader[0]->buffers + i); TAOS_UNUSED(tBufferDestroy(reader[0]->buffers + i));
} }
taosMemoryFree(reader[0]); taosMemoryFree(reader[0]);
@ -706,7 +706,7 @@ _exit:
static int32_t tsdbSnapWriteFileSetCloseReader(STsdbSnapWriter* writer) { static int32_t tsdbSnapWriteFileSetCloseReader(STsdbSnapWriter* writer) {
TARRAY2_CLEAR(writer->ctx->sttReaderArr, tsdbSttFileReaderClose); TARRAY2_CLEAR(writer->ctx->sttReaderArr, tsdbSttFileReaderClose);
tsdbDataFileReaderClose(&writer->ctx->dataReader); TAOS_UNUSED(tsdbDataFileReaderClose(&writer->ctx->dataReader));
return 0; return 0;
} }
@ -782,8 +782,8 @@ _exit:
} }
static int32_t tsdbSnapWriteFileSetCloseIter(STsdbSnapWriter* writer) { static int32_t tsdbSnapWriteFileSetCloseIter(STsdbSnapWriter* writer) {
tsdbIterMergerClose(&writer->ctx->dataIterMerger); TAOS_UNUSED(tsdbIterMergerClose(&writer->ctx->dataIterMerger));
tsdbIterMergerClose(&writer->ctx->tombIterMerger); TAOS_UNUSED(tsdbIterMergerClose(&writer->ctx->tombIterMerger));
TARRAY2_CLEAR(writer->ctx->dataIterArr, tsdbIterClose); TARRAY2_CLEAR(writer->ctx->dataIterArr, tsdbIterClose);
TARRAY2_CLEAR(writer->ctx->tombIterArr, tsdbIterClose); TARRAY2_CLEAR(writer->ctx->tombIterArr, tsdbIterClose);
return 0; return 0;
@ -838,7 +838,7 @@ static int32_t tsdbSnapWriteFileSetBegin(STsdbSnapWriter* writer, int32_t fid) {
code = TSDB_CODE_NO_AVAIL_DISK; code = TSDB_CODE_NO_AVAIL_DISK;
TSDB_CHECK_CODE(code, lino, _exit); TSDB_CHECK_CODE(code, lino, _exit);
} }
tfsMkdirRecurAt(writer->tsdb->pVnode->pTfs, writer->tsdb->path, writer->ctx->did); TAOS_UNUSED(tfsMkdirRecurAt(writer->tsdb->pVnode->pTfs, writer->tsdb->path, writer->ctx->did));
writer->ctx->hasData = true; writer->ctx->hasData = true;
writer->ctx->hasTomb = true; writer->ctx->hasTomb = true;
@ -993,7 +993,7 @@ static int32_t tsdbSnapWriteDecmprTombBlock(SSnapDataHdr* hdr, STombBlock* tombB
int32_t code = 0; int32_t code = 0;
int32_t lino = 0; int32_t lino = 0;
tTombBlockClear(tombBlock); TAOS_UNUSED(tTombBlockClear(tombBlock));
int64_t size = hdr->size; int64_t size = hdr->size;
ASSERT(size % TOMB_RECORD_ELEM_NUM == 0); ASSERT(size % TOMB_RECORD_ELEM_NUM == 0);
@ -1140,15 +1140,15 @@ int32_t tsdbSnapWriterClose(STsdbSnapWriter** writer, int8_t rollback) {
(void)taosThreadMutexUnlock(&writer[0]->tsdb->mutex); (void)taosThreadMutexUnlock(&writer[0]->tsdb->mutex);
} }
tsdbIterMergerClose(&writer[0]->ctx->tombIterMerger); TAOS_UNUSED(tsdbIterMergerClose(&writer[0]->ctx->tombIterMerger));
tsdbIterMergerClose(&writer[0]->ctx->dataIterMerger); TAOS_UNUSED(tsdbIterMergerClose(&writer[0]->ctx->dataIterMerger));
TARRAY2_DESTROY(writer[0]->ctx->tombIterArr, tsdbIterClose); TARRAY2_DESTROY(writer[0]->ctx->tombIterArr, tsdbIterClose);
TARRAY2_DESTROY(writer[0]->ctx->dataIterArr, tsdbIterClose); TARRAY2_DESTROY(writer[0]->ctx->dataIterArr, tsdbIterClose);
TARRAY2_DESTROY(writer[0]->ctx->sttReaderArr, tsdbSttFileReaderClose); TARRAY2_DESTROY(writer[0]->ctx->sttReaderArr, tsdbSttFileReaderClose);
tsdbDataFileReaderClose(&writer[0]->ctx->dataReader); TAOS_UNUSED(tsdbDataFileReaderClose(&writer[0]->ctx->dataReader));
TARRAY2_DESTROY(writer[0]->fopArr, NULL); TARRAY2_DESTROY(writer[0]->fopArr, NULL);
tsdbFSDestroyCopyRangedSnapshot(&writer[0]->fsetArr); TAOS_UNUSED(tsdbFSDestroyCopyRangedSnapshot(&writer[0]->fsetArr));
for (int32_t i = 0; i < ARRAY_SIZE(writer[0]->buffers); ++i) { for (int32_t i = 0; i < ARRAY_SIZE(writer[0]->buffers); ++i) {
tBufferDestroy(writer[0]->buffers + i); tBufferDestroy(writer[0]->buffers + i);

2
source/dnode/vnode/src/tsdb/tsdbSttFileRW.c
View File

@ -507,7 +507,7 @@ static int32_t tsdbFileDoWriteSttBlockData(STsdbFD *fd, SBlockData *blockData, S
if (sttBlk->maxVer < blockData->aVersion[iRow]) sttBlk->maxVer = blockData->aVersion[iRow]; 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)); TAOS_CHECK_RETURN(tBlockDataCompress(blockData, info, buffers, buffers + 4));
sttBlk->bInfo.offset = *fileSize; sttBlk->bInfo.offset = *fileSize;

10
source/dnode/vnode/src/tsdb/tsdbUpgrade.c
View File

@ -79,7 +79,7 @@ static int32_t tsdbUpgradeHead(STsdb *tsdb, SDFileSet *pDFileSet, SDataFReader *
// open fd // open fd
char fname[TSDB_FILENAME_LEN]; char fname[TSDB_FILENAME_LEN];
tsdbTFileName(tsdb, &file, fname); (void)tsdbTFileName(tsdb, &file, fname);
TAOS_CHECK_GOTO(tsdbOpenFile(fname, tsdb, TD_FILE_READ | TD_FILE_WRITE, &ctx->fd, 0), &lino, _exit); TAOS_CHECK_GOTO(tsdbOpenFile(fname, tsdb, TD_FILE_READ | TD_FILE_WRITE, &ctx->fd, 0), &lino, _exit);
@ -321,7 +321,7 @@ static int32_t tsdbUpgradeStt(STsdb *tsdb, SDFileSet *pDFileSet, SDataFReader *r
if (TARRAY2_SIZE(lvl->fobjArr) > 0) { if (TARRAY2_SIZE(lvl->fobjArr) > 0) {
TAOS_CHECK_GOTO(TARRAY2_APPEND(fset->lvlArr, lvl), &lino, _exit); TAOS_CHECK_GOTO(TARRAY2_APPEND(fset->lvlArr, lvl), &lino, _exit);
} else { } else {
tsdbSttLvlClear(&lvl); (void)tsdbSttLvlClear(&lvl);
} }
_exit: _exit:
@ -358,7 +358,7 @@ static int32_t tsdbUpgradeFileSet(STsdb *tsdb, SDFileSet *pDFileSet, TFileSetArr
TAOS_CHECK_GOTO(tsdbUpgradeStt(tsdb, pDFileSet, reader, fset), &lino, _exit); TAOS_CHECK_GOTO(tsdbUpgradeStt(tsdb, pDFileSet, reader, fset), &lino, _exit);
} }
tsdbDataFReaderClose(&reader); (void)tsdbDataFReaderClose(&reader);
TAOS_CHECK_GOTO(TARRAY2_APPEND(fileSetArray, fset), &lino, _exit); TAOS_CHECK_GOTO(TARRAY2_APPEND(fileSetArray, fset), &lino, _exit);
@ -570,7 +570,7 @@ _exit:
if (code) { if (code) {
tsdbError("vgId:%d %s failed at %s:%d since %s", TD_VID(tsdb->pVnode), __func__, __FILE__, lino, tstrerror(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); taosArrayDestroy(aDelIdx);
return code; return code;
} }
@ -612,7 +612,7 @@ static int32_t tsdbUpgradeFileSystem(STsdb *tsdb, int8_t rollback) {
// save new file system // save new file system
char fname[TSDB_FILENAME_LEN]; 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); TAOS_CHECK_GOTO(save_fs(fileSetArray, fname), &lino, _exit);
_exit: _exit:

4
source/dnode/vnode/src/tsdb/tsdbUtil.c
View File

@ -107,7 +107,7 @@ _exit:
void tMapDataGetItemByIdx(SMapData *pMapData, int32_t idx, void *pItem, int32_t (*tGetItemFn)(uint8_t *, void *)) { void tMapDataGetItemByIdx(SMapData *pMapData, int32_t idx, void *pItem, int32_t (*tGetItemFn)(uint8_t *, void *)) {
ASSERT(idx >= 0 && idx < pMapData->nItem); 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 #ifdef BUILD_NO_CALL
@ -613,7 +613,7 @@ void tsdbRowGetColVal(TSDBROW *pRow, STSchema *pTSchema, int32_t iCol, SColVal *
SValue value; SValue value;
if (pRow->type == TSDBROW_ROW_FMT) { 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) { } else if (pRow->type == TSDBROW_COL_FMT) {
if (iCol == 0) { if (iCol == 0) {
*pColVal = *pColVal =

4
source/dnode/vnode/src/vnd/vnodeAsync.c
View File

@ -389,7 +389,7 @@ static int32_t vnodeAsyncDestroy(SVAsync **async) {
// set stop and broadcast // set stop and broadcast
(void)taosThreadMutexLock(&(*async)->mutex); (void)taosThreadMutexLock(&(*async)->mutex);
(*async)->stop = true; (*async)->stop = true;
taosThreadCondBroadcast(&(*async)->hasTask); (void)taosThreadCondBroadcast(&(*async)->hasTask);
(void)taosThreadMutexUnlock(&(*async)->mutex); (void)taosThreadMutexUnlock(&(*async)->mutex);
// join all workers // join all workers
@ -666,7 +666,7 @@ int32_t vnodeAsyncSetWorkers(int64_t asyncID, int32_t numWorkers) {
(void)taosThreadMutexLock(&async->mutex); (void)taosThreadMutexLock(&async->mutex);
async->numWorkers = numWorkers; async->numWorkers = numWorkers;
if (async->numIdleWorkers > 0) { if (async->numIdleWorkers > 0) {
taosThreadCondBroadcast(&async->hasTask); (void)taosThreadCondBroadcast(&async->hasTask);
} }
(void)taosThreadMutexUnlock(&async->mutex); (void)taosThreadMutexUnlock(&async->mutex);

2
source/dnode/vnode/src/vnd/vnodeCommit.c
View File

@ -291,7 +291,7 @@ static int32_t vnodePrepareCommit(SVnode *pVnode, SCommitInfo *pInfo) {
code = vnodeSaveInfo(dir, &pInfo->info); code = vnodeSaveInfo(dir, &pInfo->info);
TSDB_CHECK_CODE(code, lino, _exit); TSDB_CHECK_CODE(code, lino, _exit);
tsdbPreCommit(pVnode->pTsdb); (void)tsdbPreCommit(pVnode->pTsdb);
code = metaPrepareAsyncCommit(pVnode->pMeta); code = metaPrepareAsyncCommit(pVnode->pMeta);
TSDB_CHECK_CODE(code, lino, _exit); TSDB_CHECK_CODE(code, lino, _exit);

6
source/dnode/vnode/src/vnd/vnodeOpen.c
View File

@ -404,7 +404,7 @@ SVnode *vnodeOpen(const char *path, int32_t diskPrimary, STfs *pTfs, SMsgCb msgC
(void)taosThreadMutexInit(&pVnode->lock, NULL); (void)taosThreadMutexInit(&pVnode->lock, NULL);
pVnode->blocked = false; pVnode->blocked = false;
tsem_init(&pVnode->syncSem, 0, 0); (void)tsem_init(&pVnode->syncSem, 0, 0);
(void)taosThreadMutexInit(&pVnode->mutex, NULL); (void)taosThreadMutexInit(&pVnode->mutex, NULL);
(void)taosThreadCondInit(&pVnode->poolNotEmpty, NULL); (void)taosThreadCondInit(&pVnode->poolNotEmpty, NULL);
@ -546,8 +546,8 @@ void vnodeClose(SVnode *pVnode) {
(void)vnodeCloseBufPool(pVnode); (void)vnodeCloseBufPool(pVnode);
// destroy handle // destroy handle
tsem_destroy(&pVnode->syncSem); (void)tsem_destroy(&pVnode->syncSem);
taosThreadCondDestroy(&pVnode->poolNotEmpty); (void)taosThreadCondDestroy(&pVnode->poolNotEmpty);
(void)taosThreadMutexDestroy(&pVnode->mutex); (void)taosThreadMutexDestroy(&pVnode->mutex);
(void)taosThreadMutexDestroy(&pVnode->lock); (void)taosThreadMutexDestroy(&pVnode->lock);
taosMemoryFree(pVnode); taosMemoryFree(pVnode);

4
source/dnode/vnode/src/vnd/vnodeSnapshot.c
View File

@ -610,7 +610,7 @@ int32_t vnodeSnapWriterOpen(SVnode *pVnode, SSnapshotParam *pParam, SVSnapWriter
int64_t ever = pParam->end; int64_t ever = pParam->end;
// cancel and disable all bg task // cancel and disable all bg task
vnodeCancelAndDisableAllBgTask(pVnode); (void)vnodeCancelAndDisableAllBgTask(pVnode);
// alloc // alloc
pWriter = (SVSnapWriter *)taosMemoryCalloc(1, sizeof(*pWriter)); pWriter = (SVSnapWriter *)taosMemoryCalloc(1, sizeof(*pWriter));
@ -749,7 +749,7 @@ _exit:
vInfo("vgId:%d, vnode snapshot writer closed, rollback:%d", TD_VID(pVnode), rollback); vInfo("vgId:%d, vnode snapshot writer closed, rollback:%d", TD_VID(pVnode), rollback);
taosMemoryFree(pWriter); taosMemoryFree(pWriter);
} }
vnodeEnableBgTask(pVnode); (void)vnodeEnableBgTask(pVnode);
return code; return code;
} }

8
source/dnode/vnode/src/vnd/vnodeSvr.c
View File

@ -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, vTrace("vgId:%d, process %s request, code:0x%x index:%" PRId64, TD_VID(pVnode), TMSG_INFO(pMsg->msgType), pRsp->code,
ver); ver);
walApplyVer(pVnode->pWal, ver); (void)walApplyVer(pVnode->pWal, ver);
code = tqPushMsg(pVnode->pTq, pMsg->msgType); code = tqPushMsg(pVnode->pTq, pMsg->msgType);
if (code) { if (code) {
@ -1405,7 +1405,7 @@ static int32_t vnodeProcessDropTbReq(SVnode *pVnode, int64_t ver, void *pReq, in
} }
(void)tqUpdateTbUidList(pVnode->pTq, tbUids, false); (void)tqUpdateTbUidList(pVnode->pTq, tbUids, false);
tdUpdateTbUidList(pVnode->pSma, pStore, false); (void)tdUpdateTbUidList(pVnode->pSma, pStore, false);
if (tsEnableAuditCreateTable) { if (tsEnableAuditCreateTable) {
int64_t clusterId = pVnode->config.syncCfg.nodeInfo[0].clusterId; int64_t clusterId = pVnode->config.syncCfg.nodeInfo[0].clusterId;
@ -1440,7 +1440,7 @@ _exit:
tEncodeSize(tEncodeSVDropTbBatchRsp, &rsp, pRsp->contLen, ret); tEncodeSize(tEncodeSVDropTbBatchRsp, &rsp, pRsp->contLen, ret);
pRsp->pCont = rpcMallocCont(pRsp->contLen); pRsp->pCont = rpcMallocCont(pRsp->contLen);
tEncoderInit(&encoder, pRsp->pCont, pRsp->contLen); tEncoderInit(&encoder, pRsp->pCont, pRsp->contLen);
tEncodeSVDropTbBatchRsp(&encoder, &rsp); (void)tEncodeSVDropTbBatchRsp(&encoder, &rsp);
tEncoderClear(&encoder); tEncoderClear(&encoder);
taosArrayDestroy(rsp.pArray); taosArrayDestroy(rsp.pArray);
taosArrayDestroy(tbNames); taosArrayDestroy(tbNames);
@ -2158,7 +2158,7 @@ static int32_t vnodeProcessBatchDeleteReq(SVnode *pVnode, int64_t ver, void *pRe
SBatchDeleteReq deleteReq; SBatchDeleteReq deleteReq;
SDecoder decoder; SDecoder decoder;
tDecoderInit(&decoder, pReq, len); tDecoderInit(&decoder, pReq, len);
tDecodeSBatchDeleteReq(&decoder, &deleteReq); (void)tDecodeSBatchDeleteReq(&decoder, &deleteReq);
SMetaReader mr = {0}; SMetaReader mr = {0};
metaReaderDoInit(&mr, pVnode->pMeta, META_READER_NOLOCK); metaReaderDoInit(&mr, pVnode->pMeta, META_READER_NOLOCK);

2
source/dnode/vnode/src/vnd/vnodeSync.c
View File

@ -583,7 +583,7 @@ static void vnodeRestoreFinish(const SSyncFSM *pFsm, const SyncIndex commitIdx)
streamMetaWUnLock(pMeta); streamMetaWUnLock(pMeta);
tqInfo("vgId:%d stream task already loaded, start them", vgId); 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; return;
} }
} }

2
source/libs/index/inc/indexUtil.h
View File

@ -55,7 +55,7 @@ extern "C" {
} \ } \
} \ } \
if (f == false) { \ if (f == false) { \
taosArrayPush(dst, &tgt); \ (void)taosArrayPush(dst, &tgt); \
} \ } \
} }

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

@ -74,7 +74,7 @@ void indexCleanup() {
// refacto later // refacto later
taosCleanUpScheduler(indexQhandle); taosCleanUpScheduler(indexQhandle);
taosMemoryFreeClear(indexQhandle); taosMemoryFreeClear(indexQhandle);
taosCloseRef(indexRefMgt); (void)taosCloseRef(indexRefMgt);
} }
typedef struct SIdxColInfo { typedef struct SIdxColInfo {
@ -99,15 +99,15 @@ static void idxMergeCacheAndTFile(SArray* result, IterateValue* icache, IterateV
static void idxPost(void* idx) { static void idxPost(void* idx) {
SIndex* pIdx = idx; SIndex* pIdx = idx;
tsem_post(&pIdx->sem); (void)tsem_post(&pIdx->sem);
} }
static void indexWait(void* idx) { static void indexWait(void* idx) {
SIndex* pIdx = idx; SIndex* pIdx = idx;
tsem_wait(&pIdx->sem); (void)tsem_wait(&pIdx->sem);
} }
int32_t indexOpen(SIndexOpts* opts, const char* path, SIndex** index) { int32_t indexOpen(SIndexOpts* opts, const char* path, SIndex** index) {
taosThreadOnce(&isInit, indexEnvInit); (void)taosThreadOnce(&isInit, indexEnvInit);
int code = TSDB_CODE_SUCCESS; int code = TSDB_CODE_SUCCESS;
SIndex* idx = taosMemoryCalloc(1, sizeof(SIndex)); SIndex* idx = taosMemoryCalloc(1, sizeof(SIndex));
@ -137,8 +137,8 @@ int32_t indexOpen(SIndexOpts* opts, const char* path, SIndex** index) {
TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, NULL, END); TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, NULL, END);
} }
taosThreadMutexInit(&idx->mtx, NULL); (void)taosThreadMutexInit(&idx->mtx, NULL);
tsem_init(&idx->sem, 0, 0); (void)tsem_init(&idx->sem, 0, 0);
idx->refId = idxAddRef(idx); idx->refId = idxAddRef(idx);
idx->opts = *opts; idx->opts = *opts;
@ -158,8 +158,8 @@ END:
void indexDestroy(void* handle) { void indexDestroy(void* handle) {
if (handle == NULL) return; if (handle == NULL) return;
SIndex* idx = handle; SIndex* idx = handle;
taosThreadMutexDestroy(&idx->mtx); (void)taosThreadMutexDestroy(&idx->mtx);
tsem_destroy(&idx->sem); (void)tsem_destroy(&idx->sem);
idxTFileDestroy(idx->tindex); idxTFileDestroy(idx->tindex);
taosMemoryFree(idx->path); taosMemoryFree(idx->path);
@ -190,7 +190,7 @@ void indexClose(SIndex* sIdx) {
} }
idxReleaseRef(sIdx->refId); idxReleaseRef(sIdx->refId);
idxRemoveRef(sIdx->refId); (void)idxRemoveRef(sIdx->refId);
} }
int64_t idxAddRef(void* p) { int64_t idxAddRef(void* p) {
// impl // impl
@ -203,16 +203,16 @@ int32_t idxRemoveRef(int64_t ref) {
void idxAcquireRef(int64_t ref) { void idxAcquireRef(int64_t ref) {
// impl // impl
taosAcquireRef(indexRefMgt, ref); (void)taosAcquireRef(indexRefMgt, ref);
} }
void idxReleaseRef(int64_t ref) { void idxReleaseRef(int64_t ref) {
// impl // impl
taosReleaseRef(indexRefMgt, ref); (void)taosReleaseRef(indexRefMgt, ref);
} }
int32_t indexPut(SIndex* index, SIndexMultiTerm* fVals, uint64_t uid) { int32_t indexPut(SIndex* index, SIndexMultiTerm* fVals, uint64_t uid) {
// TODO(yihao): reduce the lock range // TODO(yihao): reduce the lock range
taosThreadMutexLock(&index->mtx); (void)taosThreadMutexLock(&index->mtx);
for (int i = 0; i < taosArrayGetSize(fVals); i++) { for (int i = 0; i < taosArrayGetSize(fVals); i++) {
SIndexTerm* p = taosArrayGetP(fVals, i); SIndexTerm* p = taosArrayGetP(fVals, i);
@ -223,10 +223,10 @@ int32_t indexPut(SIndex* index, SIndexMultiTerm* fVals, uint64_t uid) {
IndexCache** cache = taosHashGet(index->colObj, buf, sz); IndexCache** cache = taosHashGet(index->colObj, buf, sz);
if (cache == NULL) { if (cache == NULL) {
IndexCache* pCache = idxCacheCreate(index, p->suid, p->colName, p->colType); IndexCache* pCache = idxCacheCreate(index, p->suid, p->colName, p->colType);
taosHashPut(index->colObj, buf, sz, &pCache, sizeof(void*)); (void)taosHashPut(index->colObj, buf, sz, &pCache, sizeof(void*));
} }
} }
taosThreadMutexUnlock(&index->mtx); (void)taosThreadMutexUnlock(&index->mtx);
for (int i = 0; i < taosArrayGetSize(fVals); i++) { for (int i = 0; i < taosArrayGetSize(fVals); i++) {
SIndexTerm* p = taosArrayGetP(fVals, i); SIndexTerm* p = taosArrayGetP(fVals, i);
@ -255,8 +255,8 @@ int32_t indexSearch(SIndex* index, SIndexMultiTermQuery* multiQuerys, SArray* re
for (size_t i = 0; i < nQuery; i++) { for (size_t i = 0; i < nQuery; i++) {
SIndexTermQuery* qterm = taosArrayGet(multiQuerys->query, i); SIndexTermQuery* qterm = taosArrayGet(multiQuerys->query, i);
SArray* trslt = NULL; SArray* trslt = NULL;
idxTermSearch(index, qterm, &trslt); (void)idxTermSearch(index, qterm, &trslt);
taosArrayPush(iRslts, (void*)&trslt); (void)taosArrayPush(iRslts, (void*)&trslt);
} }
idxMergeFinalResults(iRslts, opera, result); idxMergeFinalResults(iRslts, opera, result);
idxInterRsltDestroy(iRslts); idxInterRsltDestroy(iRslts);
@ -295,7 +295,7 @@ void indexMultiTermQueryDestroy(SIndexMultiTermQuery* pQuery) {
}; };
int32_t indexMultiTermQueryAdd(SIndexMultiTermQuery* pQuery, SIndexTerm* term, EIndexQueryType qType) { int32_t indexMultiTermQueryAdd(SIndexMultiTermQuery* pQuery, SIndexTerm* term, EIndexQueryType qType) {
SIndexTermQuery q = {.qType = qType, .term = term}; SIndexTermQuery q = {.qType = qType, .term = term};
taosArrayPush(pQuery->query, &q); (void)taosArrayPush(pQuery->query, &q);
return 0; return 0;
} }
@ -341,7 +341,7 @@ void indexTermDestroy(SIndexTerm* p) {
SIndexMultiTerm* indexMultiTermCreate() { return taosArrayInit(4, sizeof(SIndexTerm*)); } SIndexMultiTerm* indexMultiTermCreate() { return taosArrayInit(4, sizeof(SIndexTerm*)); }
int32_t indexMultiTermAdd(SIndexMultiTerm* terms, SIndexTerm* term) { int32_t indexMultiTermAdd(SIndexMultiTerm* terms, SIndexTerm* term) {
taosArrayPush(terms, &term); (void)taosArrayPush(terms, &term);
return 0; return 0;
} }
void indexMultiTermDestroy(SIndexMultiTerm* terms) { void indexMultiTermDestroy(SIndexMultiTerm* terms) {
@ -374,7 +374,7 @@ void indexRebuild(SIndexJson* idx, void* iter) {
schedMsg.fp = idxSchedRebuildIdx; schedMsg.fp = idxSchedRebuildIdx;
schedMsg.ahandle = idx; schedMsg.ahandle = idx;
idxAcquireRef(idx->refId); idxAcquireRef(idx->refId);
taosScheduleTask(indexQhandle, &schedMsg); (void)taosScheduleTask(indexQhandle, &schedMsg);
} }
/* /*
@ -415,10 +415,10 @@ static int32_t idxTermSearch(SIndex* sIdx, SIndexTermQuery* query, SArray** resu
int32_t sz = idxSerialCacheKey(&key, buf); int32_t sz = idxSerialCacheKey(&key, buf);
taosThreadMutexLock(&sIdx->mtx); (void)taosThreadMutexLock(&sIdx->mtx);
IndexCache** pCache = taosHashGet(sIdx->colObj, buf, sz); IndexCache** pCache = taosHashGet(sIdx->colObj, buf, sz);
cache = (pCache == NULL) ? NULL : *pCache; cache = (pCache == NULL) ? NULL : *pCache;
taosThreadMutexUnlock(&sIdx->mtx); (void)taosThreadMutexUnlock(&sIdx->mtx);
*result = taosArrayInit(4, sizeof(uint64_t)); *result = taosArrayInit(4, sizeof(uint64_t));
if (*result == NULL) { if (*result == NULL) {
@ -501,7 +501,7 @@ static void idxMayMergeTempToFinalRslt(SArray* result, TFileValue* tfv, SIdxTRsl
idxTRsltMergeTo(tr, lv->tableId); idxTRsltMergeTo(tr, lv->tableId);
idxTRsltClear(tr); idxTRsltClear(tr);
taosArrayPush(result, &tfv); (void)taosArrayPush(result, &tfv);
} else if (tfv == NULL) { } else if (tfv == NULL) {
// handle last iterator // handle last iterator
idxTRsltMergeTo(tr, lv->tableId); idxTRsltMergeTo(tr, lv->tableId);
@ -509,7 +509,7 @@ static void idxMayMergeTempToFinalRslt(SArray* result, TFileValue* tfv, SIdxTRsl
tfileValueDestroy(tfv); tfileValueDestroy(tfv);
} }
} else { } else {
taosArrayPush(result, &tfv); (void)taosArrayPush(result, &tfv);
} }
} }
static void idxMergeCacheAndTFile(SArray* result, IterateValue* cv, IterateValue* tv, SIdxTRslt* tr) { static void idxMergeCacheAndTFile(SArray* result, IterateValue* cv, IterateValue* tv, SIdxTRslt* tr) {
@ -528,7 +528,7 @@ static void idxMergeCacheAndTFile(SArray* result, IterateValue* cv, IterateValue
} }
} }
if (tv != NULL) { if (tv != NULL) {
taosArrayAddAll(tr->total, tv->val); (void)taosArrayAddAll(tr->total, tv->val);
} }
} }
static void idxDestroyFinalRslt(SArray* result) { static void idxDestroyFinalRslt(SArray* result) {
@ -655,9 +655,9 @@ static int64_t idxGetAvailableVer(SIndex* sIdx, IndexCache* cache) {
IndexTFile* tf = (IndexTFile*)(sIdx->tindex); IndexTFile* tf = (IndexTFile*)(sIdx->tindex);
taosThreadMutexLock(&tf->mtx); (void)taosThreadMutexLock(&tf->mtx);
TFileReader* rd = tfileCacheGet(tf->cache, &key); TFileReader* rd = tfileCacheGet(tf->cache, &key);
taosThreadMutexUnlock(&tf->mtx); (void)taosThreadMutexUnlock(&tf->mtx);
if (rd != NULL) { if (rd != NULL) {
ver = (ver > rd->header.version ? ver : rd->header.version) + 1; ver = (ver > rd->header.version ? ver : rd->header.version) + 1;
@ -698,9 +698,9 @@ static int32_t idxGenTFile(SIndex* sIdx, IndexCache* cache, SArray* batch) {
TFileHeader* header = &reader->header; TFileHeader* header = &reader->header;
ICacheKey key = {.suid = cache->suid, .colName = header->colName, .nColName = strlen(header->colName)}; ICacheKey key = {.suid = cache->suid, .colName = header->colName, .nColName = strlen(header->colName)};
taosThreadMutexLock(&tf->mtx); (void)taosThreadMutexLock(&tf->mtx);
code = tfileCachePut(tf->cache, &key, reader); code = tfileCachePut(tf->cache, &key, reader);
taosThreadMutexUnlock(&tf->mtx); (void)taosThreadMutexUnlock(&tf->mtx);
return code; return code;
@ -717,7 +717,7 @@ int32_t idxSerialCacheKey(ICacheKey* key, char* buf) {
char* p = buf; char* p = buf;
char tbuf[65] = {0}; char tbuf[65] = {0};
idxInt2str((int64_t)key->suid, tbuf, 0); (void)idxInt2str((int64_t)key->suid, tbuf, 0);
SERIALIZE_STR_VAR_TO_BUF(buf, tbuf, strlen(tbuf)); SERIALIZE_STR_VAR_TO_BUF(buf, tbuf, strlen(tbuf));
SERIALIZE_VAR_TO_BUF(buf, '_', char); SERIALIZE_VAR_TO_BUF(buf, '_', char);

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

@ -104,7 +104,7 @@ static int32_t cacheSearchTerm(void* cache, SIndexTerm* term, SIdxTRslt* tr, STe
} }
taosMemoryFree(pCt); taosMemoryFree(pCt);
tSkipListDestroyIter(iter); (void)tSkipListDestroyIter(iter);
return 0; return 0;
} }
static int32_t cacheSearchPrefix(void* cache, SIndexTerm* term, SIdxTRslt* tr, STermValueType* s) { static int32_t cacheSearchPrefix(void* cache, SIndexTerm* term, SIdxTRslt* tr, STermValueType* s) {
@ -162,7 +162,7 @@ static int32_t cacheSearchCompareFunc(void* cache, SIndexTerm* term, SIdxTRslt*
} }
} }
taosMemoryFree(pCt); taosMemoryFree(pCt);
tSkipListDestroyIter(iter); (void)tSkipListDestroyIter(iter);
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
static int32_t cacheSearchLessThan(void* cache, SIndexTerm* term, SIdxTRslt* tr, STermValueType* s) { static int32_t cacheSearchLessThan(void* cache, SIndexTerm* term, SIdxTRslt* tr, STermValueType* s) {
@ -222,7 +222,7 @@ static int32_t cacheSearchTerm_JSON(void* cache, SIndexTerm* term, SIdxTRslt* tr
taosMemoryFree(pCt); taosMemoryFree(pCt);
taosMemoryFree(exBuf); taosMemoryFree(exBuf);
tSkipListDestroyIter(iter); (void)tSkipListDestroyIter(iter);
return 0; return 0;
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
@ -329,7 +329,7 @@ static int32_t cacheSearchCompareFunc_JSON(void* cache, SIndexTerm* term, SIdxTR
taosMemoryFree(pCt); taosMemoryFree(pCt);
taosMemoryFree(exBuf); taosMemoryFree(exBuf);
tSkipListDestroyIter(iter); (void)tSkipListDestroyIter(iter);
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
@ -356,8 +356,8 @@ IndexCache* idxCacheCreate(SIndex* idx, uint64_t suid, const char* colName, int8
cache->suid = suid; cache->suid = suid;
cache->occupiedMem = 0; cache->occupiedMem = 0;
taosThreadMutexInit(&cache->mtx, NULL); (void)taosThreadMutexInit(&cache->mtx, NULL);
taosThreadCondInit(&cache->finished, NULL); (void)taosThreadCondInit(&cache->finished, NULL);
idxCacheRef(cache); idxCacheRef(cache);
if (idx != NULL) { if (idx != NULL) {
@ -368,10 +368,10 @@ IndexCache* idxCacheCreate(SIndex* idx, uint64_t suid, const char* colName, int8
void idxCacheDebug(IndexCache* cache) { void idxCacheDebug(IndexCache* cache) {
MemTable* tbl = NULL; MemTable* tbl = NULL;
taosThreadMutexLock(&cache->mtx); (void)taosThreadMutexLock(&cache->mtx);
tbl = cache->mem; tbl = cache->mem;
idxMemRef(tbl); idxMemRef(tbl);
taosThreadMutexUnlock(&cache->mtx); (void)taosThreadMutexUnlock(&cache->mtx);
{ {
SSkipList* slt = tbl->mem; SSkipList* slt = tbl->mem;
@ -384,7 +384,7 @@ void idxCacheDebug(IndexCache* cache) {
indexInfo("{colVal: %s, version: %" PRId64 "} \t", ct->colVal, ct->version); indexInfo("{colVal: %s, version: %" PRId64 "} \t", ct->colVal, ct->version);
} }
} }
tSkipListDestroyIter(iter); (void)tSkipListDestroyIter(iter);
idxMemUnRef(tbl); idxMemUnRef(tbl);
} }
@ -405,7 +405,7 @@ void idxCacheDebug(IndexCache* cache) {
indexInfo("{colVal: %s, version: %" PRId64 "} \t", ct->colVal, ct->version); indexInfo("{colVal: %s, version: %" PRId64 "} \t", ct->colVal, ct->version);
} }
} }
tSkipListDestroyIter(iter); (void)tSkipListDestroyIter(iter);
} }
idxMemUnRef(tbl); idxMemUnRef(tbl);
@ -422,16 +422,16 @@ void idxCacheDestroySkiplist(SSkipList* slt) {
taosMemoryFree(ct); taosMemoryFree(ct);
} }
} }
tSkipListDestroyIter(iter); (void)tSkipListDestroyIter(iter);
tSkipListDestroy(slt); tSkipListDestroy(slt);
} }
void idxCacheBroadcast(void* cache) { void idxCacheBroadcast(void* cache) {
IndexCache* pCache = cache; IndexCache* pCache = cache;
taosThreadCondBroadcast(&pCache->finished); (void)taosThreadCondBroadcast(&pCache->finished);
} }
void idxCacheWait(void* cache) { void idxCacheWait(void* cache) {
IndexCache* pCache = cache; IndexCache* pCache = cache;
taosThreadCondWait(&pCache->finished, &pCache->mtx); (void)taosThreadCondWait(&pCache->finished, &pCache->mtx);
} }
void idxCacheDestroyImm(IndexCache* cache) { void idxCacheDestroyImm(IndexCache* cache) {
if (cache == NULL) { if (cache == NULL) {
@ -444,7 +444,7 @@ void idxCacheDestroyImm(IndexCache* cache) {
cache->imm = NULL; // or throw int bg thread cache->imm = NULL; // or throw int bg thread
idxCacheBroadcast(cache); idxCacheBroadcast(cache);
taosThreadMutexUnlock(&cache->mtx); (void)taosThreadMutexUnlock(&cache->mtx);
idxMemUnRef(tbl); idxMemUnRef(tbl);
idxMemUnRef(tbl); idxMemUnRef(tbl);
@ -459,8 +459,8 @@ void idxCacheDestroy(void* cache) {
idxMemUnRef(pCache->imm); idxMemUnRef(pCache->imm);
taosMemoryFree(pCache->colName); taosMemoryFree(pCache->colName);
taosThreadMutexDestroy(&pCache->mtx); (void)taosThreadMutexDestroy(&pCache->mtx);
taosThreadCondDestroy(&pCache->finished); (void)taosThreadCondDestroy(&pCache->finished);
if (pCache->index != NULL) { if (pCache->index != NULL) {
idxReleaseRef(((SIndex*)pCache->index)->refId); idxReleaseRef(((SIndex*)pCache->index)->refId);
} }
@ -475,7 +475,7 @@ Iterate* idxCacheIteratorCreate(IndexCache* cache) {
if (iter == NULL) { if (iter == NULL) {
return NULL; return NULL;
} }
taosThreadMutexLock(&cache->mtx); (void)taosThreadMutexLock(&cache->mtx);
idxMemRef(cache->imm); idxMemRef(cache->imm);
@ -486,7 +486,7 @@ Iterate* idxCacheIteratorCreate(IndexCache* cache) {
iter->next = idxCacheIteratorNext; iter->next = idxCacheIteratorNext;
iter->getValue = idxCacheIteratorGetValue; iter->getValue = idxCacheIteratorGetValue;
taosThreadMutexUnlock(&cache->mtx); (void)taosThreadMutexUnlock(&cache->mtx);
return iter; return iter;
} }
@ -494,7 +494,7 @@ void idxCacheIteratorDestroy(Iterate* iter) {
if (iter == NULL) { if (iter == NULL) {
return; return;
} }
tSkipListDestroyIter(iter->iter); (void)tSkipListDestroyIter(iter->iter);
iterateValueDestroy(&iter->val, true); iterateValueDestroy(&iter->val, true);
taosMemoryFree(iter); taosMemoryFree(iter);
} }
@ -508,7 +508,7 @@ int idxCacheSchedToMerge(IndexCache* pCache, bool notify) {
} }
schedMsg.msg = NULL; schedMsg.msg = NULL;
idxAcquireRef(pCache->index->refId); idxAcquireRef(pCache->index->refId);
taosScheduleTask(indexQhandle, &schedMsg); (void)taosScheduleTask(indexQhandle, &schedMsg);
return 0; return 0;
} }
@ -548,7 +548,7 @@ int idxCachePut(void* cache, SIndexTerm* term, uint64_t uid) {
// encode data // encode data
CacheTerm* ct = taosMemoryCalloc(1, sizeof(CacheTerm)); CacheTerm* ct = taosMemoryCalloc(1, sizeof(CacheTerm));
if (ct == NULL) { if (ct == NULL) {
return -1; return TSDB_CODE_OUT_OF_MEMORY;
} }
// set up key // set up key
ct->colType = term->colType; ct->colType = term->colType;
@ -556,6 +556,10 @@ int idxCachePut(void* cache, SIndexTerm* term, uint64_t uid) {
ct->colVal = idxPackJsonData(term); ct->colVal = idxPackJsonData(term);
} else { } else {
ct->colVal = (char*)taosMemoryCalloc(1, sizeof(char) * (term->nColVal + 1)); ct->colVal = (char*)taosMemoryCalloc(1, sizeof(char) * (term->nColVal + 1));
if (ct->colVal == NULL) {
taosMemoryFree(ct);
return TSDB_CODE_OUT_OF_MEMORY;
}
memcpy(ct->colVal, term->colVal, term->nColVal); memcpy(ct->colVal, term->colVal, term->nColVal);
} }
ct->version = atomic_add_fetch_64(&pCache->version, 1); ct->version = atomic_add_fetch_64(&pCache->version, 1);
@ -565,15 +569,15 @@ int idxCachePut(void* cache, SIndexTerm* term, uint64_t uid) {
// ugly code, refactor later // ugly code, refactor later
int64_t estimate = sizeof(ct) + strlen(ct->colVal); int64_t estimate = sizeof(ct) + strlen(ct->colVal);
taosThreadMutexLock(&pCache->mtx); (void)taosThreadMutexLock(&pCache->mtx);
pCache->occupiedMem += estimate; pCache->occupiedMem += estimate;
idxCacheMakeRoomForWrite(pCache); idxCacheMakeRoomForWrite(pCache);
MemTable* tbl = pCache->mem; MemTable* tbl = pCache->mem;
idxMemRef(tbl); idxMemRef(tbl);
tSkipListPut(tbl->mem, (char*)ct); (void)tSkipListPut(tbl->mem, (char*)ct);
idxMemUnRef(tbl); idxMemUnRef(tbl);
taosThreadMutexUnlock(&pCache->mtx); (void)taosThreadMutexUnlock(&pCache->mtx);
idxCacheUnRef(pCache); idxCacheUnRef(pCache);
return 0; return 0;
} }
@ -581,13 +585,13 @@ void idxCacheForceToMerge(void* cache) {
IndexCache* pCache = cache; IndexCache* pCache = cache;
idxCacheRef(pCache); idxCacheRef(pCache);
taosThreadMutexLock(&pCache->mtx); (void)taosThreadMutexLock(&pCache->mtx);
indexInfo("%p is forced to merge into tfile", pCache); indexInfo("%p is forced to merge into tfile", pCache);
pCache->occupiedMem += MEM_SIGNAL_QUIT; pCache->occupiedMem += MEM_SIGNAL_QUIT;
idxCacheMakeRoomForWrite(pCache); idxCacheMakeRoomForWrite(pCache);
taosThreadMutexUnlock(&pCache->mtx); (void)taosThreadMutexUnlock(&pCache->mtx);
idxCacheUnRef(pCache); idxCacheUnRef(pCache);
return; return;
} }
@ -618,12 +622,12 @@ int idxCacheSearch(void* cache, SIndexTermQuery* query, SIdxTRslt* result, STerm
IndexCache* pCache = cache; IndexCache* pCache = cache;
MemTable *mem = NULL, *imm = NULL; MemTable *mem = NULL, *imm = NULL;
taosThreadMutexLock(&pCache->mtx); (void)taosThreadMutexLock(&pCache->mtx);
mem = pCache->mem; mem = pCache->mem;
imm = pCache->imm; imm = pCache->imm;
idxMemRef(mem); idxMemRef(mem);
idxMemRef(imm); idxMemRef(imm);
taosThreadMutexUnlock(&pCache->mtx); (void)taosThreadMutexUnlock(&pCache->mtx);
int64_t st = taosGetTimestampUs(); int64_t st = taosGetTimestampUs();
@ -759,7 +763,7 @@ static void idxDoMergeWork(SSchedMsg* msg) {
int quit = msg->thandle ? true : false; int quit = msg->thandle ? true : false;
taosMemoryFree(msg->thandle); taosMemoryFree(msg->thandle);
idxFlushCacheToTFile(sidx, pCache, quit); (void)idxFlushCacheToTFile(sidx, pCache, quit);
} }
static bool idxCacheIteratorNext(Iterate* itera) { static bool idxCacheIteratorNext(Iterate* itera) {
SSkipListIterator* iter = itera->iter; SSkipListIterator* iter = itera->iter;
@ -777,7 +781,7 @@ static bool idxCacheIteratorNext(Iterate* itera) {
iv->type = ct->operaType; iv->type = ct->operaType;
iv->ver = ct->version; iv->ver = ct->version;
iv->colVal = taosStrdup(ct->colVal); iv->colVal = taosStrdup(ct->colVal);
taosArrayPush(iv->val, &ct->uid); (void)taosArrayPush(iv->val, &ct->uid);
} }
return next; return next;
} }

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

@ -378,6 +378,9 @@ int32_t idxConvertData(void* src, int8_t type, void** dst) {
int32_t idxConvertDataToStr(void* src, int8_t type, void** dst) { int32_t idxConvertDataToStr(void* src, int8_t type, void** dst) {
if (src == NULL) { if (src == NULL) {
*dst = strndup(INDEX_DATA_NULL_STR, (int)strlen(INDEX_DATA_NULL_STR)); *dst = strndup(INDEX_DATA_NULL_STR, (int)strlen(INDEX_DATA_NULL_STR));
if (*dst == NULL) {
return TSDB_CODE_OUT_OF_MEMORY;
}
return (int32_t)strlen(INDEX_DATA_NULL_STR); return (int32_t)strlen(INDEX_DATA_NULL_STR);
} }
int tlen = tDataTypes[type].bytes; int tlen = tDataTypes[type].bytes;
@ -385,63 +388,96 @@ int32_t idxConvertDataToStr(void* src, int8_t type, void** dst) {
switch (type) { switch (type) {
case TSDB_DATA_TYPE_TIMESTAMP: case TSDB_DATA_TYPE_TIMESTAMP:
*dst = taosMemoryCalloc(1, bufSize + 1); *dst = taosMemoryCalloc(1, bufSize + 1);
idxInt2str(*(int64_t*)src, *dst, -1); if (*dst == NULL) {
return TSDB_CODE_OUT_OF_MEMORY;
}
(void)idxInt2str(*(int64_t*)src, *dst, -1);
tlen = strlen(*dst); tlen = strlen(*dst);
break; break;
case TSDB_DATA_TYPE_BOOL: case TSDB_DATA_TYPE_BOOL:
case TSDB_DATA_TYPE_UTINYINT: case TSDB_DATA_TYPE_UTINYINT:
*dst = taosMemoryCalloc(1, bufSize + 1); *dst = taosMemoryCalloc(1, bufSize + 1);
idxInt2str(*(uint8_t*)src, *dst, 1); if (*dst == NULL) {
return TSDB_CODE_OUT_OF_MEMORY;
}
(void)idxInt2str(*(uint8_t*)src, *dst, 1);
tlen = strlen(*dst); tlen = strlen(*dst);
break; break;
case TSDB_DATA_TYPE_TINYINT: case TSDB_DATA_TYPE_TINYINT:
*dst = taosMemoryCalloc(1, bufSize + 1); *dst = taosMemoryCalloc(1, bufSize + 1);
idxInt2str(*(int8_t*)src, *dst, 1); if (*dst == NULL) {
return TSDB_CODE_OUT_OF_MEMORY;
}
(void)idxInt2str(*(int8_t*)src, *dst, 1);
tlen = strlen(*dst); tlen = strlen(*dst);
break; break;
case TSDB_DATA_TYPE_SMALLINT: case TSDB_DATA_TYPE_SMALLINT:
*dst = taosMemoryCalloc(1, bufSize + 1); *dst = taosMemoryCalloc(1, bufSize + 1);
idxInt2str(*(int16_t*)src, *dst, -1); if (*dst == NULL) {
return TSDB_CODE_OUT_OF_MEMORY;
}
(void)idxInt2str(*(int16_t*)src, *dst, -1);
tlen = strlen(*dst); tlen = strlen(*dst);
break; break;
case TSDB_DATA_TYPE_USMALLINT: case TSDB_DATA_TYPE_USMALLINT:
*dst = taosMemoryCalloc(1, bufSize + 1); *dst = taosMemoryCalloc(1, bufSize + 1);
idxInt2str(*(uint16_t*)src, *dst, -1); (void)idxInt2str(*(uint16_t*)src, *dst, -1);
tlen = strlen(*dst); tlen = strlen(*dst);
break; break;
case TSDB_DATA_TYPE_INT: case TSDB_DATA_TYPE_INT:
*dst = taosMemoryCalloc(1, bufSize + 1); *dst = taosMemoryCalloc(1, bufSize + 1);
idxInt2str(*(int32_t*)src, *dst, -1); if (*dst == NULL) {
return TSDB_CODE_OUT_OF_MEMORY;
}
(void)idxInt2str(*(int32_t*)src, *dst, -1);
tlen = strlen(*dst); tlen = strlen(*dst);
break; break;
case TSDB_DATA_TYPE_UINT: case TSDB_DATA_TYPE_UINT:
*dst = taosMemoryCalloc(1, bufSize + 1); *dst = taosMemoryCalloc(1, bufSize + 1);
idxInt2str(*(uint32_t*)src, *dst, 1); if (*dst == NULL) {
return TSDB_CODE_OUT_OF_MEMORY;
}
(void)idxInt2str(*(uint32_t*)src, *dst, 1);
tlen = strlen(*dst); tlen = strlen(*dst);
break; break;
case TSDB_DATA_TYPE_BIGINT: case TSDB_DATA_TYPE_BIGINT:
*dst = taosMemoryCalloc(1, bufSize + 1); *dst = taosMemoryCalloc(1, bufSize + 1);
if (*dst == NULL) {
return TSDB_CODE_OUT_OF_MEMORY;
}
sprintf(*dst, "%" PRIu64, *(uint64_t*)src); sprintf(*dst, "%" PRIu64, *(uint64_t*)src);
tlen = strlen(*dst); tlen = strlen(*dst);
break; break;
case TSDB_DATA_TYPE_UBIGINT: case TSDB_DATA_TYPE_UBIGINT:
*dst = taosMemoryCalloc(1, bufSize + 1); *dst = taosMemoryCalloc(1, bufSize + 1);
idxInt2str(*(uint64_t*)src, *dst, 1); if (*dst == NULL) {
return TSDB_CODE_OUT_OF_MEMORY;
}
(void)idxInt2str(*(uint64_t*)src, *dst, 1);
tlen = strlen(*dst); tlen = strlen(*dst);
break; break;
case TSDB_DATA_TYPE_FLOAT: case TSDB_DATA_TYPE_FLOAT:
*dst = taosMemoryCalloc(1, bufSize + 1); *dst = taosMemoryCalloc(1, bufSize + 1);
if (*dst == NULL) {
return TSDB_CODE_OUT_OF_MEMORY;
}
sprintf(*dst, "%.9lf", *(float*)src); sprintf(*dst, "%.9lf", *(float*)src);
tlen = strlen(*dst); tlen = strlen(*dst);
break; break;
case TSDB_DATA_TYPE_DOUBLE: case TSDB_DATA_TYPE_DOUBLE:
*dst = taosMemoryCalloc(1, bufSize + 1); *dst = taosMemoryCalloc(1, bufSize + 1);
if (*dst == NULL) {
return TSDB_CODE_OUT_OF_MEMORY;
}
sprintf(*dst, "%.9lf", *(double*)src); sprintf(*dst, "%.9lf", *(double*)src);
tlen = strlen(*dst); tlen = strlen(*dst);
break; break;
case TSDB_DATA_TYPE_NCHAR: { case TSDB_DATA_TYPE_NCHAR: {
tlen = taosEncodeBinary(NULL, varDataVal(src), varDataLen(src)); tlen = taosEncodeBinary(NULL, varDataVal(src), varDataLen(src));
*dst = taosMemoryCalloc(1, tlen + 1); *dst = taosMemoryCalloc(1, tlen + 1);
if (*dst == NULL) {
return TSDB_CODE_OUT_OF_MEMORY;
}
tlen = taosEncodeBinary(dst, varDataVal(src), varDataLen(src)); tlen = taosEncodeBinary(dst, varDataVal(src), varDataLen(src));
*dst = (char*)*dst - tlen; *dst = (char*)*dst - tlen;
break; break;
@ -451,6 +487,9 @@ int32_t idxConvertDataToStr(void* src, int8_t type, void** dst) {
case TSDB_DATA_TYPE_GEOMETRY: { case TSDB_DATA_TYPE_GEOMETRY: {
tlen = taosEncodeBinary(NULL, varDataVal(src), varDataLen(src)); tlen = taosEncodeBinary(NULL, varDataVal(src), varDataLen(src));
*dst = taosMemoryCalloc(1, tlen + 1); *dst = taosMemoryCalloc(1, tlen + 1);
if (*dst == NULL) {
return TSDB_CODE_OUT_OF_MEMORY;
}
tlen = taosEncodeBinary(dst, varDataVal(src), varDataLen(src)); tlen = taosEncodeBinary(dst, varDataVal(src), varDataLen(src));
*dst = (char*)*dst - tlen; *dst = (char*)*dst - tlen;
break; break;

14
source/libs/index/src/indexFilter.c
View File

@ -646,7 +646,7 @@ static int32_t sifDoIndex(SIFParam *left, SIFParam *right, int8_t operType, SIFP
} }
SIndexMultiTermQuery *mtm = indexMultiTermQueryCreate(MUST); SIndexMultiTermQuery *mtm = indexMultiTermQueryCreate(MUST);
indexMultiTermQueryAdd(mtm, tm, qtype); (void)indexMultiTermQueryAdd(mtm, tm, qtype);
ret = indexJsonSearch(arg->ivtIdx, mtm, output->result); ret = indexJsonSearch(arg->ivtIdx, mtm, output->result);
indexMultiTermQueryDestroy(mtm); indexMultiTermQueryDestroy(mtm);
} else { } else {
@ -882,9 +882,9 @@ static int32_t sifExecLogic(SLogicConditionNode *node, SIFCtx *ctx, SIFParam *ou
if (ctx->noExec == false) { if (ctx->noExec == false) {
for (int32_t m = 0; m < node->pParameterList->length; m++) { for (int32_t m = 0; m < node->pParameterList->length; m++) {
if (node->condType == LOGIC_COND_TYPE_AND) { if (node->condType == LOGIC_COND_TYPE_AND) {
taosArrayAddAll(output->result, params[m].result); (void)taosArrayAddAll(output->result, params[m].result);
} else if (node->condType == LOGIC_COND_TYPE_OR) { } else if (node->condType == LOGIC_COND_TYPE_OR) {
taosArrayAddAll(output->result, params[m].result); (void)taosArrayAddAll(output->result, params[m].result);
} else if (node->condType == LOGIC_COND_TYPE_NOT) { } else if (node->condType == LOGIC_COND_TYPE_NOT) {
// taosArrayAddAll(output->result, params[m].result); // taosArrayAddAll(output->result, params[m].result);
} }
@ -1018,12 +1018,12 @@ static int32_t sifCalculate(SNode *pNode, SIFParam *pDst) {
SIF_ERR_RET(TSDB_CODE_APP_ERROR); SIF_ERR_RET(TSDB_CODE_APP_ERROR);
} }
if (res->result != NULL) { if (res->result != NULL) {
taosArrayAddAll(pDst->result, res->result); (void)taosArrayAddAll(pDst->result, res->result);
} }
pDst->status = res->status; pDst->status = res->status;
sifFreeParam(res); sifFreeParam(res);
taosHashRemove(ctx.pRes, (void *)&pNode, POINTER_BYTES); (void)taosHashRemove(ctx.pRes, (void *)&pNode, POINTER_BYTES);
} }
sifFreeRes(ctx.pRes); sifFreeRes(ctx.pRes);
return code; return code;
@ -1055,7 +1055,7 @@ static int32_t sifGetFltHint(SNode *pNode, SIdxFltStatus *status, SMetaDataFilte
} }
*status = res->status; *status = res->status;
sifFreeParam(res); sifFreeParam(res);
taosHashRemove(ctx.pRes, (void *)&pNode, POINTER_BYTES); (void)taosHashRemove(ctx.pRes, (void *)&pNode, POINTER_BYTES);
void *iter = taosHashIterate(ctx.pRes, NULL); void *iter = taosHashIterate(ctx.pRes, NULL);
while (iter != NULL) { while (iter != NULL) {
@ -1090,7 +1090,7 @@ int32_t doFilterTag(SNode *pFilterNode, SIndexMetaArg *metaArg, SArray *result,
*status = st; *status = st;
} }
taosArrayAddAll(result, param.result); (void)taosArrayAddAll(result, param.result);
sifFreeParam(&param); sifFreeParam(&param);
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }

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

@ -62,7 +62,7 @@ void fstUnFinishedNodesPushEmpty(FstUnFinishedNodes* nodes, bool isFinal) {
node->trans = taosArrayInit(16, sizeof(FstTransition)); node->trans = taosArrayInit(16, sizeof(FstTransition));
FstBuilderNodeUnfinished un = {.node = node, .last = NULL}; FstBuilderNodeUnfinished un = {.node = node, .last = NULL};
taosArrayPush(nodes->stack, &un); (void)taosArrayPush(nodes->stack, &un);
} }
FstBuilderNode* fstUnFinishedNodesPopRoot(FstUnFinishedNodes* nodes) { FstBuilderNode* fstUnFinishedNodesPopRoot(FstUnFinishedNodes* nodes) {
FstBuilderNodeUnfinished* un = taosArrayPop(nodes->stack); FstBuilderNodeUnfinished* un = taosArrayPop(nodes->stack);
@ -120,7 +120,7 @@ void fstUnFinishedNodesAddSuffix(FstUnFinishedNodes* nodes, FstSlice bs, Output
FstLastTransition* trn = fstLastTransitionCreate(data[i], 0); FstLastTransition* trn = fstLastTransitionCreate(data[i], 0);
FstBuilderNodeUnfinished un = {.node = n, .last = trn}; FstBuilderNodeUnfinished un = {.node = n, .last = trn};
taosArrayPush(nodes->stack, &un); (void)taosArrayPush(nodes->stack, &un);
} }
fstUnFinishedNodesPushEmpty(nodes, true); fstUnFinishedNodesPushEmpty(nodes, true);
} }
@ -214,9 +214,9 @@ void fstStateCompileForOneTransNext(IdxFstFile* w, CompiledAddr addr, uint8_t in
uint8_t v = fstStateCommInput(&s, &null); uint8_t v = fstStateCommInput(&s, &null);
if (null) { if (null) {
// w->write_all(&[inp]) // w->write_all(&[inp])
idxFileWrite(w, &inp, 1); (void)idxFileWrite(w, &inp, 1);
} }
idxFileWrite(w, &(s.val), 1); (void)idxFileWrite(w, &(s.val), 1);
// w->write_all(&[s.val]) // w->write_all(&[s.val])
return; return;
} }
@ -228,7 +228,7 @@ void fstStateCompileForOneTrans(IdxFstFile* w, CompiledAddr addr, FstTransition*
FST_SET_OUTPUT_PACK_SIZE(packSizes, outPackSize); FST_SET_OUTPUT_PACK_SIZE(packSizes, outPackSize);
FST_SET_TRANSITION_PACK_SIZE(packSizes, transPackSize); FST_SET_TRANSITION_PACK_SIZE(packSizes, transPackSize);
idxFileWrite(w, (char*)&packSizes, sizeof(packSizes)); (void)idxFileWrite(w, (char*)&packSizes, sizeof(packSizes));
FstState st = fstStateCreate(OneTrans); FstState st = fstStateCreate(OneTrans);
@ -237,9 +237,9 @@ void fstStateCompileForOneTrans(IdxFstFile* w, CompiledAddr addr, FstTransition*
bool null = false; bool null = false;
uint8_t inp = fstStateCommInput(&st, &null); uint8_t inp = fstStateCommInput(&st, &null);
if (null == true) { if (null == true) {
idxFileWrite(w, (char*)&trn->inp, sizeof(trn->inp)); (void)idxFileWrite(w, (char*)&trn->inp, sizeof(trn->inp));
} }
idxFileWrite(w, (char*)(&(st.val)), sizeof(st.val)); (void)idxFileWrite(w, (char*)(&(st.val)), sizeof(st.val));
return; return;
} }
void fstStateCompileForAnyTrans(IdxFstFile* w, CompiledAddr addr, FstBuilderNode* node) { void fstStateCompileForAnyTrans(IdxFstFile* w, CompiledAddr addr, FstBuilderNode* node) {
@ -295,24 +295,24 @@ void fstStateCompileForAnyTrans(IdxFstFile* w, CompiledAddr addr, FstBuilderNode
FstTransition* t = taosArrayGet(node->trans, i); FstTransition* t = taosArrayGet(node->trans, i);
index[t->inp] = i; index[t->inp] = i;
} }
idxFileWrite(w, (char*)index, 256); (void)idxFileWrite(w, (char*)index, 256);
taosMemoryFree(index); taosMemoryFree(index);
} }
idxFileWrite(w, (char*)&packSizes, 1); (void)idxFileWrite(w, (char*)&packSizes, 1);
bool null = false; bool null = false;
fstStateStateNtrans(&st, &null); (void)fstStateStateNtrans(&st, &null);
if (null == true) { if (null == true) {
// 256 can't be represented in a u8, so we abuse the fact that // 256 can't be represented in a u8, so we abuse the fact that
// the # of transitions can never be 1 here, since 1 is always // the # of transitions can never be 1 here, since 1 is always
// encoded in the state byte. // encoded in the state byte.
uint8_t v = 1; uint8_t v = 1;
if (sz == 256) { if (sz == 256) {
idxFileWrite(w, (char*)&v, 1); (void)idxFileWrite(w, (char*)&v, 1);
} else { } else {
idxFileWrite(w, (char*)&sz, 1); (void)idxFileWrite(w, (char*)&sz, 1);
} }
} }
idxFileWrite(w, (char*)(&(st.val)), 1); (void)idxFileWrite(w, (char*)(&(st.val)), 1);
return; return;
} }
@ -342,7 +342,7 @@ uint8_t fstStateCommInput(FstState* s, bool* null) {
uint64_t fstStateInputLen(FstState* s) { uint64_t fstStateInputLen(FstState* s) {
ASSERT(s->state == OneTransNext || s->state == OneTrans); ASSERT(s->state == OneTransNext || s->state == OneTrans);
bool null = false; bool null = false;
fstStateCommInput(s, &null); (void)fstStateCommInput(s, &null);
return null ? 1 : 0; return null ? 1 : 0;
} }
@ -499,7 +499,7 @@ uint64_t fstStateTransIndexSize(FstState* s, uint64_t version, uint64_t nTrans)
uint64_t fstStateNtransLen(FstState* s) { uint64_t fstStateNtransLen(FstState* s) {
ASSERT(s->state == AnyTrans); ASSERT(s->state == AnyTrans);
bool null = false; bool null = false;
fstStateStateNtrans(s, &null); (void)fstStateStateNtrans(s, &null);
return null == true ? 1 : 0; return null == true ? 1 : 0;
} }
uint64_t fstStateNtrans(FstState* s, FstSlice* slice) { uint64_t fstStateNtrans(FstState* s, FstSlice* slice) {
@ -673,12 +673,12 @@ bool fstNodeGetTransitionAddrAt(FstNode* node, uint64_t i, CompiledAddr* res) {
FstState* st = &node->state; FstState* st = &node->state;
if (st->state == OneTransNext) { if (st->state == OneTransNext) {
ASSERT(i == 0); ASSERT(i == 0);
fstStateTransAddr(st, node); (void)fstStateTransAddr(st, node);
} else if (st->state == OneTrans) { } else if (st->state == OneTrans) {
ASSERT(i == 0); ASSERT(i == 0);
fstStateTransAddr(st, node); (void)fstStateTransAddr(st, node);
} else if (st->state == AnyTrans) { } else if (st->state == AnyTrans) {
fstStateTransAddrForAnyTrans(st, node, i); (void)fstStateTransAddrForAnyTrans(st, node, i);
} else if (FST_STATE_EMPTY_FINAL(node)) { } else if (FST_STATE_EMPTY_FINAL(node)) {
s = false; s = false;
} else { } else {
@ -755,13 +755,13 @@ FstBuilder* fstBuilderCreate(void* w, FstType ty) {
char buf64[8] = {0}; char buf64[8] = {0};
void* pBuf64 = buf64; void* pBuf64 = buf64;
taosEncodeFixedU64(&pBuf64, VERSION); (void)taosEncodeFixedU64(&pBuf64, VERSION);
idxFileWrite(b->wrt, buf64, sizeof(buf64)); (void)idxFileWrite(b->wrt, buf64, sizeof(buf64));
pBuf64 = buf64; pBuf64 = buf64;
memset(buf64, 0, sizeof(buf64)); memset(buf64, 0, sizeof(buf64));
taosEncodeFixedU64(&pBuf64, ty); (void)taosEncodeFixedU64(&pBuf64, ty);
idxFileWrite(b->wrt, buf64, sizeof(buf64)); (void)idxFileWrite(b->wrt, buf64, sizeof(buf64));
return b; return b;
} }
@ -862,7 +862,7 @@ CompiledAddr fstBuilderCompile(FstBuilder* b, FstBuilderNode* bn) {
} }
CompiledAddr startAddr = (CompiledAddr)(FST_WRITER_COUNT(b->wrt)); CompiledAddr startAddr = (CompiledAddr)(FST_WRITER_COUNT(b->wrt));
fstBuilderNodeCompileTo(bn, b->wrt, b->lastAddr, startAddr); (void)fstBuilderNodeCompileTo(bn, b->wrt, b->lastAddr, startAddr);
b->lastAddr = (CompiledAddr)(FST_WRITER_COUNT(b->wrt) - 1); b->lastAddr = (CompiledAddr)(FST_WRITER_COUNT(b->wrt) - 1);
if (entry->state == NOTFOUND) { if (entry->state == NOTFOUND) {
FST_REGISTRY_CELL_INSERT(entry->cell, b->lastAddr); FST_REGISTRY_CELL_INSERT(entry->cell, b->lastAddr);
@ -881,23 +881,23 @@ void* fstBuilderInsertInner(FstBuilder* b) {
char buf64[8] = {0}; char buf64[8] = {0};
void* pBuf64 = buf64; void* pBuf64 = buf64;
taosEncodeFixedU64(&pBuf64, b->len); (void)taosEncodeFixedU64(&pBuf64, b->len);
idxFileWrite(b->wrt, buf64, sizeof(buf64)); (void)idxFileWrite(b->wrt, buf64, sizeof(buf64));
pBuf64 = buf64; pBuf64 = buf64;
taosEncodeFixedU64(&pBuf64, rootAddr); (void)taosEncodeFixedU64(&pBuf64, rootAddr);
idxFileWrite(b->wrt, buf64, sizeof(buf64)); (void)idxFileWrite(b->wrt, buf64, sizeof(buf64));
char buf32[4] = {0}; char buf32[4] = {0};
void* pBuf32 = buf32; void* pBuf32 = buf32;
uint32_t sum = idxFileMaskedCheckSum(b->wrt); uint32_t sum = idxFileMaskedCheckSum(b->wrt);
taosEncodeFixedU32(&pBuf32, sum); (void)taosEncodeFixedU32(&pBuf32, sum);
idxFileWrite(b->wrt, buf32, sizeof(buf32)); (void)idxFileWrite(b->wrt, buf32, sizeof(buf32));
idxFileFlush(b->wrt); (void)idxFileFlush(b->wrt);
return b->wrt; return b->wrt;
} }
void fstBuilderFinish(FstBuilder* b) { fstBuilderInsertInner(b); } void fstBuilderFinish(FstBuilder* b) { (void)fstBuilderInsertInner(b); }
FstSlice fstNodeAsSlice(FstNode* node) { FstSlice fstNodeAsSlice(FstNode* node) {
FstSlice* slice = &node->data; FstSlice* slice = &node->data;
@ -924,7 +924,7 @@ void fstBuilderNodeUnfinishedLastCompiled(FstBuilderNodeUnfinished* unNode, Comp
return; return;
} }
FstTransition t = {.inp = trn->inp, .out = trn->out, .addr = addr}; FstTransition t = {.inp = trn->inp, .out = trn->out, .addr = addr};
taosArrayPush(unNode->node->trans, &t); (void)taosArrayPush(unNode->node->trans, &t);
fstLastTransitionDestroy(trn); fstLastTransitionDestroy(trn);
unNode->last = NULL; unNode->last = NULL;
return; return;
@ -955,19 +955,19 @@ Fst* fstCreate(FstSlice* slice) {
uint64_t skip = 0; uint64_t skip = 0;
uint64_t version; uint64_t version;
taosDecodeFixedU64(buf, &version); (void)taosDecodeFixedU64(buf, &version);
skip += sizeof(version); skip += sizeof(version);
if (version == 0 || version > VERSION) { if (version == 0 || version > VERSION) {
return NULL; return NULL;
} }
uint64_t type; uint64_t type;
taosDecodeFixedU64(buf + skip, &type); (void)taosDecodeFixedU64(buf + skip, &type);
skip += sizeof(type); skip += sizeof(type);
uint32_t checkSum = 0; uint32_t checkSum = 0;
len -= sizeof(checkSum); len -= sizeof(checkSum);
taosDecodeFixedU32(buf + len, &checkSum); (void)taosDecodeFixedU32(buf + len, &checkSum);
if (taosCheckChecksum(buf, len, checkSum)) { if (taosCheckChecksum(buf, len, checkSum)) {
indexError("index file is corrupted"); indexError("index file is corrupted");
// verify fst // verify fst
@ -975,11 +975,11 @@ Fst* fstCreate(FstSlice* slice) {
} }
CompiledAddr rootAddr; CompiledAddr rootAddr;
len -= sizeof(rootAddr); len -= sizeof(rootAddr);
taosDecodeFixedU64(buf + len, &rootAddr); (void)taosDecodeFixedU64(buf + len, &rootAddr);
uint64_t fstLen; uint64_t fstLen;
len -= sizeof(fstLen); len -= sizeof(fstLen);
taosDecodeFixedU64(buf + len, &fstLen); (void)taosDecodeFixedU64(buf + len, &fstLen);
// TODO(validate root addr) // TODO(validate root addr)
Fst* fst = (Fst*)taosMemoryCalloc(1, sizeof(Fst)); Fst* fst = (Fst*)taosMemoryCalloc(1, sizeof(Fst));
if (fst == NULL) { if (fst == NULL) {
@ -1001,7 +1001,7 @@ Fst* fstCreate(FstSlice* slice) {
*s = fstSliceCopy(slice, 0, FST_SLICE_LEN(slice) - 1); *s = fstSliceCopy(slice, 0, FST_SLICE_LEN(slice) - 1);
fst->data = s; fst->data = s;
taosThreadMutexInit(&fst->mtx, NULL); (void)taosThreadMutexInit(&fst->mtx, NULL);
return fst; return fst;
FST_CREAT_FAILED: FST_CREAT_FAILED:
@ -1029,7 +1029,7 @@ bool fstGet(Fst* fst, FstSlice* b, Output* out) {
uint8_t* data = fstSliceData(b, &len); uint8_t* data = fstSliceData(b, &len);
SArray* nodes = (SArray*)taosArrayInit(len, sizeof(FstNode*)); SArray* nodes = (SArray*)taosArrayInit(len, sizeof(FstNode*));
taosArrayPush(nodes, &root); (void)taosArrayPush(nodes, &root);
for (uint32_t i = 0; i < len; i++) { for (uint32_t i = 0; i < len; i++) {
uint8_t inp = data[i]; uint8_t inp = data[i];
Output res = 0; Output res = 0;
@ -1038,10 +1038,10 @@ bool fstGet(Fst* fst, FstSlice* b, Output* out) {
} }
FstTransition trn; FstTransition trn;
fstNodeGetTransitionAt(root, res, &trn); (void)fstNodeGetTransitionAt(root, res, &trn);
tOut += trn.out; tOut += trn.out;
root = fstGetNode(fst, trn.addr); root = fstGetNode(fst, trn.addr);
taosArrayPush(nodes, &root); (void)taosArrayPush(nodes, &root);
} }
if (!FST_NODE_IS_FINAL(root)) { if (!FST_NODE_IS_FINAL(root)) {
goto _return; goto _return;
@ -1163,7 +1163,7 @@ FStmSt* stmStCreate(Fst* fst, FAutoCtx* automation, FstBoundWithData* min, FstBo
sws->stack = (SArray*)taosArrayInit(256, sizeof(FstStreamState)); sws->stack = (SArray*)taosArrayInit(256, sizeof(FstStreamState));
sws->endAt = max; sws->endAt = max;
stmStSeekMin(sws, min); (void)stmStSeekMin(sws, min);
return sws; return sws;
} }
@ -1188,7 +1188,7 @@ bool stmStSeekMin(FStmSt* sws, FstBoundWithData* min) {
.trans = 0, .trans = 0,
.out = {.null = false, .out = 0}, .out = {.null = false, .out = 0},
.autState = automFuncs[aut->type].start(aut)}; // auto.start callback .autState = automFuncs[aut->type].start(aut)}; // auto.start callback
taosArrayPush(sws->stack, &s); (void)taosArrayPush(sws->stack, &s);
return true; return true;
} }
FstSlice* key = NULL; FstSlice* key = NULL;
@ -1214,15 +1214,15 @@ bool stmStSeekMin(FStmSt* sws, FstBoundWithData* min) {
uint64_t res = 0; uint64_t res = 0;
if (fstNodeFindInput(node, b, &res)) { if (fstNodeFindInput(node, b, &res)) {
FstTransition trn; FstTransition trn;
fstNodeGetTransitionAt(node, res, &trn); (void)fstNodeGetTransitionAt(node, res, &trn);
void* preState = autState; void* preState = autState;
autState = automFuncs[aut->type].accept(aut, preState, b); autState = automFuncs[aut->type].accept(aut, preState, b);
taosArrayPush(sws->inp, &b); (void)taosArrayPush(sws->inp, &b);
FstStreamState s = {.node = node, .trans = res + 1, .out = {.null = false, .out = out}, .autState = preState}; FstStreamState s = {.node = node, .trans = res + 1, .out = {.null = false, .out = out}, .autState = preState};
node = NULL; node = NULL;
taosArrayPush(sws->stack, &s); (void)taosArrayPush(sws->stack, &s);
out += trn.out; out += trn.out;
node = fstGetNode(sws->fst, trn.addr); node = fstGetNode(sws->fst, trn.addr);
} else { } else {
@ -1241,7 +1241,7 @@ bool stmStSeekMin(FStmSt* sws, FstBoundWithData* min) {
} }
FstStreamState s = {.node = node, .trans = i, .out = {.null = false, .out = out}, .autState = autState}; FstStreamState s = {.node = node, .trans = i, .out = {.null = false, .out = out}, .autState = autState};
taosArrayPush(sws->stack, &s); (void)taosArrayPush(sws->stack, &s);
taosMemoryFree(trans); taosMemoryFree(trans);
return true; return true;
} }
@ -1254,15 +1254,15 @@ bool stmStSeekMin(FStmSt* sws, FstBoundWithData* min) {
FstStreamState* s = taosArrayGet(sws->stack, sz - 1); FstStreamState* s = taosArrayGet(sws->stack, sz - 1);
if (inclusize) { if (inclusize) {
s->trans -= 1; s->trans -= 1;
taosArrayPop(sws->inp); (void)taosArrayPop(sws->inp);
} else { } else {
FstNode* n = s->node; FstNode* n = s->node;
uint64_t trans = s->trans; uint64_t trans = s->trans;
FstTransition trn; FstTransition trn;
fstNodeGetTransitionAt(n, trans - 1, &trn); (void)fstNodeGetTransitionAt(n, trans - 1, &trn);
FstStreamState s = { FstStreamState s = {
.node = fstGetNode(sws->fst, trn.addr), .trans = 0, .out = {.null = false, .out = out}, .autState = autState}; .node = fstGetNode(sws->fst, trn.addr), .trans = 0, .out = {.null = false, .out = out}, .autState = autState};
taosArrayPush(sws->stack, &s); (void)taosArrayPush(sws->stack, &s);
return true; return true;
} }
return false; return false;
@ -1291,13 +1291,13 @@ FStmStRslt* stmStNextWith(FStmSt* sws, streamCallback__fn callback) {
FstStreamState* p = (FstStreamState*)taosArrayPop(sws->stack); FstStreamState* p = (FstStreamState*)taosArrayPop(sws->stack);
if (p->trans >= FST_NODE_LEN(p->node) || !automFuncs[aut->type].canMatch(aut, p->autState)) { if (p->trans >= FST_NODE_LEN(p->node) || !automFuncs[aut->type].canMatch(aut, p->autState)) {
if (FST_NODE_ADDR(p->node) != fstGetRootAddr(sws->fst)) { if (FST_NODE_ADDR(p->node) != fstGetRootAddr(sws->fst)) {
taosArrayPop(sws->inp); (void)taosArrayPop(sws->inp);
} }
fstStreamStateDestroy(p); fstStreamStateDestroy(p);
continue; continue;
} }
FstTransition trn; FstTransition trn;
fstNodeGetTransitionAt(p->node, p->trans, &trn); (void)fstNodeGetTransitionAt(p->node, p->trans, &trn);
Output out = p->out.out + trn.out; Output out = p->out.out + trn.out;
void* nextState = automFuncs[aut->type].accept(aut, p->autState, trn.inp); void* nextState = automFuncs[aut->type].accept(aut, p->autState, trn.inp);
@ -1305,8 +1305,8 @@ FStmStRslt* stmStNextWith(FStmSt* sws, streamCallback__fn callback) {
bool isMatch = automFuncs[aut->type].isMatch(aut, nextState); bool isMatch = automFuncs[aut->type].isMatch(aut, nextState);
FstNode* nextNode = fstGetNode(sws->fst, trn.addr); FstNode* nextNode = fstGetNode(sws->fst, trn.addr);
taosArrayPush(nodes, &nextNode); (void)taosArrayPush(nodes, &nextNode);
taosArrayPush(sws->inp, &(trn.inp)); (void)taosArrayPush(sws->inp, &(trn.inp));
if (FST_NODE_IS_FINAL(nextNode)) { if (FST_NODE_IS_FINAL(nextNode)) {
void* eofState = automFuncs[aut->type].acceptEof(aut, nextState); void* eofState = automFuncs[aut->type].acceptEof(aut, nextState);
@ -1315,10 +1315,10 @@ FStmStRslt* stmStNextWith(FStmSt* sws, streamCallback__fn callback) {
} }
} }
FstStreamState s1 = {.node = p->node, .trans = p->trans + 1, .out = p->out, .autState = p->autState}; FstStreamState s1 = {.node = p->node, .trans = p->trans + 1, .out = p->out, .autState = p->autState};
taosArrayPush(sws->stack, &s1); (void)taosArrayPush(sws->stack, &s1);
FstStreamState s2 = {.node = nextNode, .trans = 0, .out = {.null = false, .out = out}, .autState = nextState}; FstStreamState s2 = {.node = nextNode, .trans = 0, .out = {.null = false, .out = out}, .autState = nextState};
taosArrayPush(sws->stack, &s2); (void)taosArrayPush(sws->stack, &s2);
int32_t isz = taosArrayGetSize(sws->inp); int32_t isz = taosArrayGetSize(sws->inp);
uint8_t* buf = (uint8_t*)taosMemoryMalloc(isz * sizeof(uint8_t)); uint8_t* buf = (uint8_t*)taosMemoryMalloc(isz * sizeof(uint8_t));

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

@ -74,7 +74,7 @@ FstDfa *dfaBuilderBuild(FstDfaBuilder *builder) {
uint32_t result; uint32_t result;
SArray *states = taosArrayInit(0, sizeof(uint32_t)); SArray *states = taosArrayInit(0, sizeof(uint32_t));
if (dfaBuilderCacheState(builder, cur, &result)) { if (dfaBuilderCacheState(builder, cur, &result)) {
taosArrayPush(states, &result); (void)taosArrayPush(states, &result);
} }
SHashObj *seen = taosHashInit(12, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), false, HASH_NO_LOCK); SHashObj *seen = taosHashInit(12, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), false, HASH_NO_LOCK);
while (taosArrayGetSize(states) != 0) { while (taosArrayGetSize(states) != 0) {
@ -83,8 +83,8 @@ FstDfa *dfaBuilderBuild(FstDfaBuilder *builder) {
uint32_t ns, dummpy = 0; uint32_t ns, dummpy = 0;
if (dfaBuilderRunState(builder, cur, nxt, result, i, &ns)) { if (dfaBuilderRunState(builder, cur, nxt, result, i, &ns)) {
if (taosHashGet(seen, &ns, sizeof(ns)) == NULL) { if (taosHashGet(seen, &ns, sizeof(ns)) == NULL) {
taosHashPut(seen, &ns, sizeof(ns), &dummpy, sizeof(dummpy)); (void)taosHashPut(seen, &ns, sizeof(ns), &dummpy, sizeof(dummpy));
taosArrayPush(states, &ns); (void)taosArrayPush(states, &ns);
} }
} }
if (taosArrayGetSize(builder->dfa->states) > STATE_LIMIT) { if (taosArrayGetSize(builder->dfa->states) > STATE_LIMIT) {
@ -108,7 +108,7 @@ bool dfaBuilderRunState(FstDfaBuilder *builder, FstSparseSet *cur, FstSparseSet
bool succ = sparSetAdd(cur, ip, NULL); bool succ = sparSetAdd(cur, ip, NULL);
if (succ == false) return false; if (succ == false) return false;
} }
dfaRun(builder->dfa, cur, next, byte); (void)dfaRun(builder->dfa, cur, next, byte);
t = taosArrayGet(builder->dfa->states, state); t = taosArrayGet(builder->dfa->states, state);
@ -133,10 +133,10 @@ bool dfaBuilderCacheState(FstDfaBuilder *builder, FstSparseSet *set, uint32_t *r
if (inst->ty == JUMP || inst->ty == SPLIT) { if (inst->ty == JUMP || inst->ty == SPLIT) {
continue; continue;
} else if (inst->ty == RANGE) { } else if (inst->ty == RANGE) {
taosArrayPush(tinsts, &ip); (void)taosArrayPush(tinsts, &ip);
} else if (inst->ty == MATCH) { } else if (inst->ty == MATCH) {
isMatch = true; isMatch = true;
taosArrayPush(tinsts, &ip); (void)taosArrayPush(tinsts, &ip);
} }
} }
if (taosArrayGetSize(tinsts) == 0) { if (taosArrayGetSize(tinsts) == 0) {
@ -149,10 +149,10 @@ bool dfaBuilderCacheState(FstDfaBuilder *builder, FstSparseSet *set, uint32_t *r
taosArrayDestroy(tinsts); taosArrayDestroy(tinsts);
} else { } else {
DfaState st = {.insts = tinsts, .isMatch = isMatch}; DfaState st = {.insts = tinsts, .isMatch = isMatch};
taosArrayPush(builder->dfa->states, &st); (void)taosArrayPush(builder->dfa->states, &st);
int32_t sz = taosArrayGetSize(builder->dfa->states) - 1; int32_t sz = taosArrayGetSize(builder->dfa->states) - 1;
taosHashPut(builder->cache, &tinsts, sizeof(POINTER_BYTES), &sz, sizeof(sz)); (void)taosHashPut(builder->cache, &tinsts, sizeof(POINTER_BYTES), &sz, sizeof(sz));
*result = sz; *result = sz;
} }
return true; return true;

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

@ -38,7 +38,7 @@ static FORCE_INLINE void idxGenLRUKey(char* buf, const char* path, int32_t block
char* p = buf; char* p = buf;
SERIALIZE_STR_VAR_TO_BUF(p, path, strlen(path)); SERIALIZE_STR_VAR_TO_BUF(p, path, strlen(path));
SERIALIZE_VAR_TO_BUF(p, '_', char); SERIALIZE_VAR_TO_BUF(p, '_', char);
idxInt2str(blockId, p, 0); (void)idxInt2str(blockId, p, 0);
return; return;
} }
static FORCE_INLINE int idxFileCtxDoWrite(IFileCtx* ctx, uint8_t* buf, int len) { static FORCE_INLINE int idxFileCtxDoWrite(IFileCtx* ctx, uint8_t* buf, int len) {
@ -48,7 +48,7 @@ static FORCE_INLINE int idxFileCtxDoWrite(IFileCtx* ctx, uint8_t* buf, int len)
if (len + ctx->file.wBufOffset >= cap) { if (len + ctx->file.wBufOffset >= cap) {
int32_t nw = cap - ctx->file.wBufOffset; int32_t nw = cap - ctx->file.wBufOffset;
memcpy(ctx->file.wBuf + ctx->file.wBufOffset, buf, nw); memcpy(ctx->file.wBuf + ctx->file.wBufOffset, buf, nw);
taosWriteFile(ctx->file.pFile, ctx->file.wBuf, cap); (void)taosWriteFile(ctx->file.pFile, ctx->file.wBuf, cap);
memset(ctx->file.wBuf, 0, cap); memset(ctx->file.wBuf, 0, cap);
ctx->file.wBufOffset = 0; ctx->file.wBufOffset = 0;
@ -58,7 +58,7 @@ static FORCE_INLINE int idxFileCtxDoWrite(IFileCtx* ctx, uint8_t* buf, int len)
nw = (len / cap) * cap; nw = (len / cap) * cap;
if (nw != 0) { if (nw != 0) {
taosWriteFile(ctx->file.pFile, buf, nw); (void)taosWriteFile(ctx->file.pFile, buf, nw);
} }
len -= nw; len -= nw;
@ -112,7 +112,7 @@ static int idxFileCtxDoReadFrom(IFileCtx* ctx, uint8_t* buf, int len, int32_t of
SDataBlock* blk = taosLRUCacheValue(ctx->lru, h); SDataBlock* blk = taosLRUCacheValue(ctx->lru, h);
nread = TMIN(blkLeft, len); nread = TMIN(blkLeft, len);
memcpy(buf + total, blk->buf + blkOffset, nread); memcpy(buf + total, blk->buf + blkOffset, nread);
taosLRUCacheRelease(ctx->lru, h, false); (void)taosLRUCacheRelease(ctx->lru, h, false);
} else { } else {
int32_t left = ctx->file.size - offset; int32_t left = ctx->file.size - offset;
if (left < kBlockSize) { if (left < kBlockSize) {
@ -162,7 +162,7 @@ static FORCE_INLINE int idxFileCtxGetSize(IFileCtx* ctx) {
return ctx->offset; return ctx->offset;
} else { } else {
int64_t file_size = 0; int64_t file_size = 0;
taosStatFile(ctx->file.buf, &file_size, NULL, NULL); (void)taosStatFile(ctx->file.buf, &file_size, NULL, NULL);
return (int)file_size; return (int)file_size;
} }
} }
@ -250,16 +250,16 @@ void idxFileCtxDestroy(IFileCtx* ctx, bool remove) {
int32_t nw = taosWriteFile(ctx->file.pFile, ctx->file.wBuf, ctx->file.wBufOffset); int32_t nw = taosWriteFile(ctx->file.pFile, ctx->file.wBuf, ctx->file.wBufOffset);
ctx->file.wBufOffset = 0; ctx->file.wBufOffset = 0;
} }
ctx->flush(ctx); (void)(ctx->flush(ctx));
taosMemoryFreeClear(ctx->file.wBuf); taosMemoryFreeClear(ctx->file.wBuf);
taosCloseFile(&ctx->file.pFile); (void)taosCloseFile(&ctx->file.pFile);
if (ctx->file.readOnly) { if (ctx->file.readOnly) {
#ifdef USE_MMAP #ifdef USE_MMAP
munmap(ctx->file.ptr, ctx->file.size); munmap(ctx->file.ptr, ctx->file.size);
#endif #endif
} }
if (remove) { if (remove) {
unlink(ctx->file.buf); (void)unlink(ctx->file.buf);
} }
} }
taosMemoryFree(ctx); taosMemoryFree(ctx);

4
source/libs/index/src/indexFstNode.c
View File

@ -68,7 +68,7 @@ FstBuilderNode* fstBuilderNodeClone(FstBuilderNode* src) {
for (size_t i = 0; i < sz; i++) { for (size_t i = 0; i < sz; i++) {
FstTransition* tran = taosArrayGet(src->trans, i); FstTransition* tran = taosArrayGet(src->trans, i);
taosArrayPush(trans, tran); (void)taosArrayPush(trans, tran);
} }
node->trans = trans; node->trans = trans;
@ -91,7 +91,7 @@ void fstBuilderNodeCloneFrom(FstBuilderNode* dst, FstBuilderNode* src) {
dst->trans = taosArrayInit(sz, sizeof(FstTransition)); dst->trans = taosArrayInit(sz, sizeof(FstTransition));
for (size_t i = 0; i < sz; i++) { for (size_t i = 0; i < sz; i++) {
FstTransition* trn = taosArrayGet(src->trans, i); FstTransition* trn = taosArrayGet(src->trans, i);
taosArrayPush(dst->trans, trn); (void)taosArrayPush(dst->trans, trn);
} }
} }

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

@ -24,12 +24,22 @@ FstRegex *regexCreate(const char *str) {
} }
regex->orig = taosStrdup(str); regex->orig = taosStrdup(str);
if (regex->orig == NULL) {
taosMemoryFree(regex);
return NULL;
}
// construct insts based on str // construct insts based on str
SArray *insts = taosArrayInit(256, sizeof(uint8_t)); SArray *insts = taosArrayInit(256, sizeof(uint8_t));
if (insts == NULL) {
taosMemoryFree(regex->orig);
taosMemoryFree(regex);
return NULL;
}
for (int i = 0; i < strlen(str); i++) { for (int i = 0; i < strlen(str); i++) {
uint8_t v = str[i]; uint8_t v = str[i];
taosArrayPush(insts, &v); (void)taosArrayPush(insts, &v);
} }
FstDfaBuilder *builder = dfaBuilderCreate(insts); FstDfaBuilder *builder = dfaBuilderCreate(insts);
regex->dfa = dfaBuilderBuild(builder); regex->dfa = dfaBuilderBuild(builder);

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

@ -83,7 +83,7 @@ FstRegistry* fstRegistryCreate(uint64_t tableSize, uint64_t mruSize) {
for (uint64_t i = 0; i < nCells; i++) { for (uint64_t i = 0; i < nCells; i++) {
FstRegistryCell cell = {.addr = NONE_ADDRESS, .node = fstBuilderNodeDefault()}; FstRegistryCell cell = {.addr = NONE_ADDRESS, .node = fstBuilderNodeDefault()};
taosArrayPush(tb, &cell); (void)taosArrayPush(tb, &cell);
} }
registry->table = tb; registry->table = tb;

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

@ -81,7 +81,7 @@ FstSlice fstSliceCreate(uint8_t* data, uint64_t len) {
str->len = len; str->len = len;
str->data = taosMemoryMalloc(len * sizeof(uint8_t)); str->data = taosMemoryMalloc(len * sizeof(uint8_t));
if (data != NULL) { if (data != NULL && str->data != NULL) {
memcpy(str->data, data, len); memcpy(str->data, data, len);
} }
@ -91,7 +91,7 @@ FstSlice fstSliceCreate(uint8_t* data, uint64_t len) {
// just shallow copy // just shallow copy
FstSlice fstSliceCopy(FstSlice* s, int32_t start, int32_t end) { FstSlice fstSliceCopy(FstSlice* s, int32_t start, int32_t end) {
FstString* str = s->str; FstString* str = s->str;
atomic_add_fetch_32(&str->ref, 1); (void)atomic_add_fetch_32(&str->ref, 1);
FstSlice t = {.str = str, .start = start + s->start, .end = end + s->start}; FstSlice t = {.str = str, .start = start + s->start, .end = end + s->start};
return t; return t;

46
source/libs/index/src/indexTfile.c
View File

@ -125,7 +125,7 @@ TFileCache* tfileCacheCreate(SIndex* idx, const char* path) {
char buf[128] = {0}; char buf[128] = {0};
int32_t sz = idxSerialCacheKey(&key, buf); int32_t sz = idxSerialCacheKey(&key, buf);
taosHashPut(tcache->tableCache, buf, sz, &reader, sizeof(void*)); (void)taosHashPut(tcache->tableCache, buf, sz, &reader, sizeof(void*));
tfileReaderRef(reader); tfileReaderRef(reader);
} }
taosArrayDestroyEx(files, tfileDestroyFileName); taosArrayDestroyEx(files, tfileDestroyFileName);
@ -172,7 +172,7 @@ int32_t tfileCachePut(TFileCache* tcache, ICacheKey* key, TFileReader* reader) {
TFileReader** p = taosHashGet(tcache->tableCache, buf, sz); TFileReader** p = taosHashGet(tcache->tableCache, buf, sz);
if (p != NULL && *p != NULL) { if (p != NULL && *p != NULL) {
TFileReader* oldRdr = *p; TFileReader* oldRdr = *p;
taosHashRemove(tcache->tableCache, buf, sz); (void)taosHashRemove(tcache->tableCache, buf, sz);
indexInfo("found %s, should remove file %s", buf, oldRdr->ctx->file.buf); indexInfo("found %s, should remove file %s", buf, oldRdr->ctx->file.buf);
oldRdr->remove = true; oldRdr->remove = true;
tfileReaderUnRef(oldRdr); tfileReaderUnRef(oldRdr);
@ -265,7 +265,7 @@ static int32_t tfSearchPrefix(void* reader, SIndexTerm* tem, SIdxTRslt* tr) {
FStmSt* st = stmBuilderIntoStm(sb); FStmSt* st = stmBuilderIntoStm(sb);
FStmStRslt* rt = NULL; FStmStRslt* rt = NULL;
while ((rt = stmStNextWith(st, NULL)) != NULL) { while ((rt = stmStNextWith(st, NULL)) != NULL) {
taosArrayPush(offsets, &(rt->out.out)); (void)taosArrayPush(offsets, &(rt->out.out));
swsResultDestroy(rt); swsResultDestroy(rt);
} }
stmStDestroy(st); stmStDestroy(st);
@ -337,7 +337,7 @@ static int32_t tfSearchCompareFunc(void* reader, SIndexTerm* tem, SIdxTRslt* tr,
TExeCond cond = cmpFn(ch, p, tem->colType); TExeCond cond = cmpFn(ch, p, tem->colType);
if (MATCH == cond) { if (MATCH == cond) {
tfileReaderLoadTableIds((TFileReader*)reader, rt->out.out, tr->total); (void)tfileReaderLoadTableIds((TFileReader*)reader, rt->out.out, tr->total);
} else if (CONTINUE == cond) { } else if (CONTINUE == cond) {
} else if (BREAK == cond) { } else if (BREAK == cond) {
swsResultDestroy(rt); swsResultDestroy(rt);
@ -474,7 +474,7 @@ static int32_t tfSearchCompareFunc_JSON(void* reader, SIndexTerm* tem, SIdxTRslt
taosMemoryFree(tBuf); taosMemoryFree(tBuf);
} }
if (MATCH == cond) { if (MATCH == cond) {
tfileReaderLoadTableIds((TFileReader*)reader, rt->out.out, tr->total); (void)tfileReaderLoadTableIds((TFileReader*)reader, rt->out.out, tr->total);
} else if (CONTINUE == cond) { } else if (CONTINUE == cond) {
} else if (BREAK == cond) { } else if (BREAK == cond) {
swsResultDestroy(rt); swsResultDestroy(rt);
@ -552,7 +552,7 @@ int32_t tfileWriterCreate(IFileCtx* ctx, TFileHeader* header, TFileWriter** pWri
} }
tw->ctx = ctx; tw->ctx = ctx;
tw->header = *header; tw->header = *header;
tfileWriteHeader(tw); (void)tfileWriteHeader(tw);
*pWriter = tw; *pWriter = tw;
return code; return code;
@ -571,7 +571,7 @@ int tfileWriterPut(TFileWriter* tw, void* data, bool order) {
} else { } else {
fn = getComparFunc(colType, 0); fn = getComparFunc(colType, 0);
} }
taosArraySortPWithExt((SArray*)(data), tfileValueCompare, &fn); (void)taosArraySortPWithExt((SArray*)(data), tfileValueCompare, &fn);
} }
int32_t sz = taosArrayGetSize((SArray*)data); int32_t sz = taosArrayGetSize((SArray*)data);
@ -586,7 +586,7 @@ int tfileWriterPut(TFileWriter* tw, void* data, bool order) {
if (tbsz == 0) continue; if (tbsz == 0) continue;
fstOffset += TF_TABLE_TATOAL_SIZE(tbsz); fstOffset += TF_TABLE_TATOAL_SIZE(tbsz);
} }
tfileWriteFstOffset(tw, fstOffset); (void)tfileWriteFstOffset(tw, fstOffset);
int32_t cap = 4 * 1024; int32_t cap = 4 * 1024;
char* buf = taosMemoryCalloc(1, cap); char* buf = taosMemoryCalloc(1, cap);
@ -614,7 +614,7 @@ int tfileWriterPut(TFileWriter* tw, void* data, bool order) {
char* p = buf; char* p = buf;
tfileSerialTableIdsToBuf(p, v->tableId); tfileSerialTableIdsToBuf(p, v->tableId);
tw->ctx->write(tw->ctx, buf, ttsz); (void)(tw->ctx->write(tw->ctx, buf, ttsz));
v->offset = tw->offset; v->offset = tw->offset;
tw->offset += ttsz; tw->offset += ttsz;
memset(buf, 0, cap); memset(buf, 0, cap);
@ -642,7 +642,7 @@ int tfileWriterPut(TFileWriter* tw, void* data, bool order) {
} }
} }
fstBuilderDestroy(tw->fb); fstBuilderDestroy(tw->fb);
tfileWriteFooter(tw); (void)tfileWriteFooter(tw);
return 0; return 0;
} }
void tfileWriterClose(TFileWriter* tw) { void tfileWriterClose(TFileWriter* tw) {
@ -679,7 +679,7 @@ void idxTFileDestroy(IndexTFile* tfile) {
if (tfile == NULL) { if (tfile == NULL) {
return; return;
} }
taosThreadMutexDestroy(&tfile->mtx); (void)taosThreadMutexDestroy(&tfile->mtx);
tfileCacheDestroy(tfile->cache); tfileCacheDestroy(tfile->cache);
taosMemoryFree(tfile); taosMemoryFree(tfile);
} }
@ -696,9 +696,9 @@ int idxTFileSearch(void* tfile, SIndexTermQuery* query, SIdxTRslt* result) {
SIndexTerm* term = query->term; SIndexTerm* term = query->term;
ICacheKey key = {.suid = term->suid, .colType = term->colType, .colName = term->colName, .nColName = term->nColName}; ICacheKey key = {.suid = term->suid, .colType = term->colType, .colName = term->colName, .nColName = term->nColName};
taosThreadMutexLock(&pTfile->mtx); (void)taosThreadMutexLock(&pTfile->mtx);
TFileReader* reader = tfileCacheGet(pTfile->cache, &key); TFileReader* reader = tfileCacheGet(pTfile->cache, &key);
taosThreadMutexUnlock(&pTfile->mtx); (void)taosThreadMutexUnlock(&pTfile->mtx);
if (reader == NULL) { if (reader == NULL) {
return 0; return 0;
} }
@ -802,9 +802,9 @@ TFileReader* tfileGetReaderByCol(IndexTFile* tf, uint64_t suid, char* colName) {
TFileReader* rd = NULL; TFileReader* rd = NULL;
ICacheKey key = {.suid = suid, .colType = TSDB_DATA_TYPE_BINARY, .colName = colName, .nColName = strlen(colName)}; ICacheKey key = {.suid = suid, .colType = TSDB_DATA_TYPE_BINARY, .colName = colName, .nColName = strlen(colName)};
taosThreadMutexLock(&tf->mtx); (void)taosThreadMutexLock(&tf->mtx);
rd = tfileCacheGet(tf->cache, &key); rd = tfileCacheGet(tf->cache, &key);
taosThreadMutexUnlock(&tf->mtx); (void)taosThreadMutexUnlock(&tf->mtx);
return rd; return rd;
} }
@ -838,7 +838,7 @@ int tfileValuePush(TFileValue* tf, uint64_t val) {
if (tf == NULL) { if (tf == NULL) {
return -1; return -1;
} }
taosArrayPush(tf->tableId, &val); (void)taosArrayPush(tf->tableId, &val);
return 0; return 0;
} }
void tfileValueDestroy(TFileValue* tf) { void tfileValueDestroy(TFileValue* tf) {
@ -897,7 +897,7 @@ static int tfileWriteData(TFileWriter* write, TFileValue* tval) {
static int tfileWriteFooter(TFileWriter* write) { static int tfileWriteFooter(TFileWriter* write) {
char buf[sizeof(FILE_MAGIC_NUMBER) + 1] = {0}; char buf[sizeof(FILE_MAGIC_NUMBER) + 1] = {0};
void* pBuf = (void*)buf; void* pBuf = (void*)buf;
taosEncodeFixedU64((void**)(void*)&pBuf, FILE_MAGIC_NUMBER); (void)taosEncodeFixedU64((void**)(void*)&pBuf, FILE_MAGIC_NUMBER);
int nwrite = write->ctx->write(write->ctx, buf, (int32_t)strlen(buf)); int nwrite = write->ctx->write(write->ctx, buf, (int32_t)strlen(buf));
indexInfo("tfile write footer size: %d", write->ctx->size(write->ctx)); indexInfo("tfile write footer size: %d", write->ctx->size(write->ctx));
@ -964,7 +964,7 @@ static int tfileReaderLoadTableIds(TFileReader* reader, int32_t offset, SArray*
while (nid > 0) { while (nid > 0) {
int32_t left = block + sizeof(block) - p; int32_t left = block + sizeof(block) - p;
if (left >= sizeof(uint64_t)) { if (left >= sizeof(uint64_t)) {
taosArrayPush(result, (uint64_t*)p); (void)taosArrayPush(result, (uint64_t*)p);
p += sizeof(uint64_t); p += sizeof(uint64_t);
} else { } else {
char buf[sizeof(uint64_t)] = {0}; char buf[sizeof(uint64_t)] = {0};
@ -975,7 +975,7 @@ static int tfileReaderLoadTableIds(TFileReader* reader, int32_t offset, SArray*
nread = ctx->readFrom(ctx, block, sizeof(block), offset); nread = ctx->readFrom(ctx, block, sizeof(block), offset);
memcpy(buf + left, block, sizeof(uint64_t) - left); memcpy(buf + left, block, sizeof(uint64_t) - left);
taosArrayPush(result, (uint64_t*)buf); (void)taosArrayPush(result, (uint64_t*)buf);
p = block + sizeof(uint64_t) - left; p = block + sizeof(uint64_t) - left;
} }
nid -= 1; nid -= 1;
@ -996,7 +996,7 @@ static int tfileReaderVerify(TFileReader* reader) {
return -1; return -1;
} }
taosDecodeFixedU64(buf, &tMagicNumber); (void)taosDecodeFixedU64(buf, &tMagicNumber);
return tMagicNumber == FILE_MAGIC_NUMBER ? 0 : -1; return tMagicNumber == FILE_MAGIC_NUMBER ? 0 : -1;
} }
@ -1040,12 +1040,12 @@ static SArray* tfileGetFileList(const char* path) {
size_t len = strlen(path) + 1 + strlen(file) + 1; size_t len = strlen(path) + 1 + strlen(file) + 1;
char* buf = taosMemoryCalloc(1, len); char* buf = taosMemoryCalloc(1, len);
sprintf(buf, "%s/%s", path, file); sprintf(buf, "%s/%s", path, file);
taosArrayPush(files, &buf); (void)taosArrayPush(files, &buf);
} }
taosCloseDir(&pDir); (void)taosCloseDir(&pDir);
taosArraySort(files, tfileCompare); taosArraySort(files, tfileCompare);
tfileRmExpireFile(files); (void)tfileRmExpireFile(files);
return files; return files;
} }

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

@ -64,7 +64,7 @@ void iIntersection(SArray *in, SArray *out) {
} }
} }
if (has == true) { if (has == true) {
taosArrayPush(out, &tgt); (void)taosArrayPush(out, &tgt);
} }
} }
taosMemoryFreeClear(mi); taosMemoryFreeClear(mi);
@ -75,7 +75,7 @@ void iUnion(SArray *in, SArray *out) {
return; return;
} }
if (sz == 1) { if (sz == 1) {
taosArrayAddAll(out, taosArrayGetP(in, 0)); (void)taosArrayAddAll(out, taosArrayGetP(in, 0));
return; return;
} }
@ -108,7 +108,7 @@ void iUnion(SArray *in, SArray *out) {
continue; continue;
} }
} }
taosArrayPush(out, &mVal); (void)taosArrayPush(out, &mVal);
} else { } else {
break; break;
} }
@ -198,11 +198,11 @@ void idxTRsltMergeTo(SIdxTRslt *tr, SArray *result) {
if (taosArrayGetSize(tr->total) == 0 || taosArrayGetSize(tr->add) == 0) { if (taosArrayGetSize(tr->total) == 0 || taosArrayGetSize(tr->add) == 0) {
SArray *t = taosArrayGetSize(tr->total) == 0 ? tr->add : tr->total; SArray *t = taosArrayGetSize(tr->total) == 0 ? tr->add : tr->total;
taosArrayAddAll(result, t); (void)taosArrayAddAll(result, t);
} else { } else {
SArray *arrs = taosArrayInit(2, sizeof(void *)); SArray *arrs = taosArrayInit(2, sizeof(void *));
taosArrayPush(arrs, &tr->total); (void)taosArrayPush(arrs, &tr->total);
taosArrayPush(arrs, &tr->add); (void)taosArrayPush(arrs, &tr->add);
iUnion(arrs, result); iUnion(arrs, result);
taosArrayDestroy(arrs); taosArrayDestroy(arrs);
} }

8
source/libs/monitorfw/src/taos_collector.c
View File

@ -39,18 +39,18 @@ taos_collector_t *taos_collector_new(const char *name) {
self->name = taos_strdup(name); self->name = taos_strdup(name);
self->metrics = taos_map_new(); self->metrics = taos_map_new();
if (self->metrics == NULL) { if (self->metrics == NULL) {
taos_collector_destroy(self); (void)taos_collector_destroy(self);
return NULL; return NULL;
} }
r = taos_map_set_free_value_fn(self->metrics, &taos_metric_free_generic); r = taos_map_set_free_value_fn(self->metrics, &taos_metric_free_generic);
if (r) { if (r) {
taos_collector_destroy(self); (void)taos_collector_destroy(self);
return NULL; return NULL;
} }
self->collect_fn = &taos_collector_default_collect; self->collect_fn = &taos_collector_default_collect;
self->string_builder = taos_string_builder_new(); self->string_builder = taos_string_builder_new();
if (self->string_builder == NULL) { if (self->string_builder == NULL) {
taos_collector_destroy(self); (void)taos_collector_destroy(self);
return NULL; return NULL;
} }
self->proc_limits_file_path = NULL; self->proc_limits_file_path = NULL;
@ -93,7 +93,7 @@ int taos_collector_destroy_generic(void *gen) {
void taos_collector_free_generic(void *gen) { void taos_collector_free_generic(void *gen) {
taos_collector_t *self = (taos_collector_t *)gen; taos_collector_t *self = (taos_collector_t *)gen;
taos_collector_destroy(self); (void)taos_collector_destroy(self);
} }
int taos_collector_set_collect_fn(taos_collector_t *self, taos_collect_fn *fn) { int taos_collector_set_collect_fn(taos_collector_t *self, taos_collect_fn *fn) {

16
source/libs/monitorfw/src/taos_collector_registry.c
View File

@ -50,8 +50,8 @@ taos_collector_registry_t *taos_collector_registry_new(const char *name) {
self->name = taos_strdup(name); self->name = taos_strdup(name);
self->collectors = taos_map_new(); self->collectors = taos_map_new();
taos_map_set_free_value_fn(self->collectors, &taos_collector_free_generic); (void)taos_map_set_free_value_fn(self->collectors, &taos_collector_free_generic);
taos_map_set(self->collectors, "default", taos_collector_new("default")); if (taos_map_set(self->collectors, "default", taos_collector_new("default")) != 0) return NULL;
self->metric_formatter = taos_metric_formatter_new(); self->metric_formatter = taos_metric_formatter_new();
self->string_builder = taos_string_builder_new(); self->string_builder = taos_string_builder_new();
@ -237,15 +237,15 @@ int taos_collector_registry_clear_batch(taos_collector_registry_t *self){
} }
const char *taos_collector_registry_bridge_new(taos_collector_registry_t *self, char *ts, char *format, char** prom_str) { const char *taos_collector_registry_bridge_new(taos_collector_registry_t *self, char *ts, char *format, char** prom_str) {
taos_metric_formatter_clear(self->metric_formatter); if (taos_metric_formatter_clear(self->metric_formatter) != 0) return NULL;
SJson* pJson = tjsonCreateArray(); SJson* pJson = tjsonCreateArray();
SJson* item = tjsonCreateObject(); SJson* item = tjsonCreateObject();
tjsonAddItemToArray(pJson, item); (void)tjsonAddItemToArray(pJson, item);
tjsonAddStringToObject(item, "ts", ts); (void)tjsonAddStringToObject(item, "ts", ts);
tjsonAddDoubleToObject(item, "protocol", 2); (void)tjsonAddDoubleToObject(item, "protocol", 2);
SJson* array = tjsonCreateArray(); SJson* array = tjsonCreateArray();
tjsonAddItemToObject(item, "tables", array); (void)tjsonAddItemToObject(item, "tables", array);
if(taos_metric_formatter_load_metrics_new(self->metric_formatter, self->collectors, ts, format, array) != 0){ if(taos_metric_formatter_load_metrics_new(self->metric_formatter, self->collectors, ts, format, array) != 0){
TAOS_LOG("failed to load metrics"); TAOS_LOG("failed to load metrics");
@ -304,7 +304,7 @@ const char *taos_collector_registry_bridge_new(taos_collector_registry_t *self,
_OVER: _OVER:
tjsonDelete(pJson); tjsonDelete(pJson);
if(tmp_builder != NULL){ if(tmp_builder != NULL){
taos_string_builder_destroy(tmp_builder); (void)taos_string_builder_destroy(tmp_builder);
} }
return NULL; return NULL;

21
source/libs/monitorfw/src/taos_map.c
View File

@ -59,7 +59,7 @@ int taos_map_node_destroy(taos_map_node_t *self) {
void taos_map_node_free(void *item) { void taos_map_node_free(void *item) {
taos_map_node_t *map_node = (taos_map_node_t *)item; taos_map_node_t *map_node = (taos_map_node_t *)item;
taos_map_node_destroy(map_node); (void)taos_map_node_destroy(map_node);
} }
taos_linked_list_compare_t taos_map_node_compare(void *item_a, void *item_b) { taos_linked_list_compare_t taos_map_node_compare(void *item_a, void *item_b) {
@ -87,7 +87,7 @@ taos_map_t *taos_map_new() {
// we will only have to deallocate each key once. That will happen on taos_map_node_destroy. // we will only have to deallocate each key once. That will happen on taos_map_node_destroy.
r = taos_linked_list_set_free_fn(self->keys, taos_linked_list_no_op_free); r = taos_linked_list_set_free_fn(self->keys, taos_linked_list_no_op_free);
if (r) { if (r) {
taos_map_destroy(self); (void)taos_map_destroy(self);
return NULL; return NULL;
} }
@ -98,12 +98,12 @@ taos_map_t *taos_map_new() {
self->addrs[i] = taos_linked_list_new(); self->addrs[i] = taos_linked_list_new();
r = taos_linked_list_set_free_fn(self->addrs[i], taos_map_node_free); r = taos_linked_list_set_free_fn(self->addrs[i], taos_map_node_free);
if (r) { if (r) {
taos_map_destroy(self); (void)taos_map_destroy(self);
return NULL; return NULL;
} }
r = taos_linked_list_set_compare_fn(self->addrs[i], taos_map_node_compare); r = taos_linked_list_set_compare_fn(self->addrs[i], taos_map_node_compare);
if (r) { if (r) {
taos_map_destroy(self); (void)taos_map_destroy(self);
return NULL; return NULL;
} }
} }
@ -112,7 +112,7 @@ taos_map_t *taos_map_new() {
r = pthread_rwlock_init(self->rwlock, NULL); r = pthread_rwlock_init(self->rwlock, NULL);
if (r) { if (r) {
TAOS_LOG(TAOS_PTHREAD_RWLOCK_INIT_ERROR); TAOS_LOG(TAOS_PTHREAD_RWLOCK_INIT_ERROR);
taos_map_destroy(self); (void)taos_map_destroy(self);
return NULL; return NULL;
} }
@ -188,12 +188,12 @@ static void *taos_map_get_internal(const char *key, size_t *size, size_t *max_si
taos_map_node_t *current_map_node = (taos_map_node_t *)current_node->item; taos_map_node_t *current_map_node = (taos_map_node_t *)current_node->item;
taos_linked_list_compare_t result = taos_linked_list_compare(list, current_map_node, temp_map_node); taos_linked_list_compare_t result = taos_linked_list_compare(list, current_map_node, temp_map_node);
if (result == TAOS_EQUAL) { if (result == TAOS_EQUAL) {
taos_map_node_destroy(temp_map_node); (void)taos_map_node_destroy(temp_map_node);
temp_map_node = NULL; temp_map_node = NULL;
return current_map_node->value; return current_map_node->value;
} }
} }
taos_map_node_destroy(temp_map_node); (void)taos_map_node_destroy(temp_map_node);
temp_map_node = NULL; temp_map_node = NULL;
return NULL; return NULL;
} }
@ -248,8 +248,8 @@ static int taos_map_set_internal(const char *key, void *value, size_t *size, siz
return 0; return 0;
} }
} }
taos_linked_list_append(list, map_node); if (taos_linked_list_append(list, map_node) != 0) return 1;
taos_linked_list_append(keys, (char *)map_node->key); if (taos_linked_list_append(keys, (char *)map_node->key) != 0) return 1;
(*size)++; (*size)++;
return 0; return 0;
} }
@ -311,7 +311,8 @@ int taos_map_ensure_space(taos_map_t *self) {
self->addrs[i] = NULL; self->addrs[i] = NULL;
} }
// Destroy the collection of keys in the map // Destroy the collection of keys in the map
taos_linked_list_destroy(self->keys); r = taos_linked_list_destroy(self->keys);
if (r) return r;
self->keys = NULL; self->keys = NULL;
// Deallocate the backbone of the map // Deallocate the backbone of the map

10
source/libs/monitorfw/src/taos_metric.c
View File

@ -49,12 +49,12 @@ taos_metric_t *taos_metric_new(taos_metric_type_t metric_type, const char *name,
for (int i = 0; i < label_key_count; i++) { for (int i = 0; i < label_key_count; i++) {
if (strcmp(label_keys[i], "le") == 0) { if (strcmp(label_keys[i], "le") == 0) {
TAOS_LOG(TAOS_METRIC_INVALID_LABEL_NAME); TAOS_LOG(TAOS_METRIC_INVALID_LABEL_NAME);
taos_metric_destroy(self); (void)taos_metric_destroy(self);
return NULL; return NULL;
} }
if (strcmp(label_keys[i], "quantile") == 0) { if (strcmp(label_keys[i], "quantile") == 0) {
TAOS_LOG(TAOS_METRIC_INVALID_LABEL_NAME); TAOS_LOG(TAOS_METRIC_INVALID_LABEL_NAME);
taos_metric_destroy(self); (void)taos_metric_destroy(self);
return NULL; return NULL;
} }
k[i] = taos_strdup(label_keys[i]); k[i] = taos_strdup(label_keys[i]);
@ -68,14 +68,14 @@ taos_metric_t *taos_metric_new(taos_metric_type_t metric_type, const char *name,
} else { } else {
r = taos_map_set_free_value_fn(self->samples, &taos_metric_sample_free_generic); r = taos_map_set_free_value_fn(self->samples, &taos_metric_sample_free_generic);
if (r) { if (r) {
taos_metric_destroy(self); (void)taos_metric_destroy(self);
return NULL; return NULL;
} }
} }
self->formatter = taos_metric_formatter_new(); self->formatter = taos_metric_formatter_new();
if (self->formatter == NULL) { if (self->formatter == NULL) {
taos_metric_destroy(self); (void)taos_metric_destroy(self);
return NULL; return NULL;
} }
self->rwlock = (pthread_rwlock_t *)taos_malloc(sizeof(pthread_rwlock_t)); self->rwlock = (pthread_rwlock_t *)taos_malloc(sizeof(pthread_rwlock_t));
@ -140,7 +140,7 @@ int taos_metric_destroy_generic(void *item) {
void taos_metric_free_generic(void *item) { void taos_metric_free_generic(void *item) {
taos_metric_t *self = (taos_metric_t *)item; taos_metric_t *self = (taos_metric_t *)item;
taos_metric_destroy(self); (void)taos_metric_destroy(self);
} }
taos_metric_sample_t *taos_metric_sample_from_labels(taos_metric_t *self, const char **label_values) { taos_metric_sample_t *taos_metric_sample_from_labels(taos_metric_t *self, const char **label_values) {

4
source/libs/monitorfw/src/taos_metric_formatter.c
View File

@ -34,12 +34,12 @@ taos_metric_formatter_t *taos_metric_formatter_new() {
taos_metric_formatter_t *self = (taos_metric_formatter_t *)taos_malloc(sizeof(taos_metric_formatter_t)); taos_metric_formatter_t *self = (taos_metric_formatter_t *)taos_malloc(sizeof(taos_metric_formatter_t));
self->string_builder = taos_string_builder_new(); self->string_builder = taos_string_builder_new();
if (self->string_builder == NULL) { if (self->string_builder == NULL) {
taos_metric_formatter_destroy(self); (void)taos_metric_formatter_destroy(self);
return NULL; return NULL;
} }
self->err_builder = taos_string_builder_new(); self->err_builder = taos_string_builder_new();
if (self->err_builder == NULL) { if (self->err_builder == NULL) {
taos_metric_formatter_destroy(self); (void)taos_metric_formatter_destroy(self);
return NULL; return NULL;
} }
return self; return self;

30
source/libs/monitorfw/src/taos_metric_formatter_custom.c
View File

@ -88,17 +88,17 @@ int taos_metric_formatter_load_sample_new(taos_metric_formatter_t *self, taos_me
char* value = *(pair + 1); char* value = *(pair + 1);
SJson* tag = tjsonCreateObject(); SJson* tag = tjsonCreateObject();
tjsonAddStringToObject(tag, "name", key); (void)tjsonAddStringToObject(tag, "name", key);
tjsonAddStringToObject(tag, "value", value); (void)tjsonAddStringToObject(tag, "value", value);
tjsonAddItemToArray(arrayTag, tag); (void)tjsonAddItemToArray(arrayTag, tag);
} }
tjsonAddItemToObject(item, "tags", arrayTag); (void)tjsonAddItemToObject(item, "tags", arrayTag);
metrics = tjsonCreateArray(); metrics = tjsonCreateArray();
tjsonAddItemToObject(item, "metrics", metrics); (void)tjsonAddItemToObject(item, "metrics", metrics);
tjsonAddItemToArray(arrayMetricGroups, item); (void)tjsonAddItemToArray(arrayMetricGroups, item);
} }
else{ else{
metrics = tjsonGetObjectItem(item, "metrics"); metrics = tjsonGetObjectItem(item, "metrics");
@ -109,20 +109,20 @@ int taos_metric_formatter_load_sample_new(taos_metric_formatter_t *self, taos_me
taosMemoryFreeClear(keyvalues); taosMemoryFreeClear(keyvalues);
SJson* metric = tjsonCreateObject(); SJson* metric = tjsonCreateObject();
tjsonAddStringToObject(metric, "name", metricName); (void)tjsonAddStringToObject(metric, "name", metricName);
double old_value = 0; double old_value = 0;
#define USE_EXCHANGE #define USE_EXCHANGE
#ifdef USE_EXCHANGE #ifdef USE_EXCHANGE
taos_metric_sample_exchange(sample, 0, &old_value); (void)taos_metric_sample_exchange(sample, 0, &old_value);
#else #else
old_value = sample->r_value; old_value = sample->r_value;
taos_metric_sample_set(sample, 0); taos_metric_sample_set(sample, 0);
#endif #endif
tjsonAddDoubleToObject(metric, "value", old_value); (void)tjsonAddDoubleToObject(metric, "value", old_value);
tjsonAddDoubleToObject(metric, "type", metric_type); (void)tjsonAddDoubleToObject(metric, "type", metric_type);
tjsonAddItemToArray(metrics, metric); (void)tjsonAddItemToArray(metrics, metric);
return 0; return 0;
} }
@ -150,7 +150,7 @@ int taos_metric_formatter_load_metric_new(taos_metric_formatter_t *self, taos_me
SJson* table = tjsonGetArrayItem(tableArray, i); SJson* table = tjsonGetArrayItem(tableArray, i);
char tableName[MONITOR_TABLENAME_LEN] = {0}; char tableName[MONITOR_TABLENAME_LEN] = {0};
tjsonGetStringValue(table, "name", tableName); (void)tjsonGetStringValue(table, "name", tableName);
if(strcmp(tableName, arr[0]) == 0){ if(strcmp(tableName, arr[0]) == 0){
isFound = true; isFound = true;
arrayMetricGroups = tjsonGetObjectItem(table, "metric_groups"); arrayMetricGroups = tjsonGetObjectItem(table, "metric_groups");
@ -161,10 +161,10 @@ int taos_metric_formatter_load_metric_new(taos_metric_formatter_t *self, taos_me
if(!isFound){ if(!isFound){
table = tjsonCreateObject(); table = tjsonCreateObject();
tjsonAddStringToObject(table, "name", arr[0]); (void)tjsonAddStringToObject(table, "name", arr[0]);
arrayMetricGroups = tjsonCreateArray(); arrayMetricGroups = tjsonCreateArray();
tjsonAddItemToObject(table, "metric_groups", arrayMetricGroups); (void)tjsonAddItemToObject(table, "metric_groups", arrayMetricGroups);
} }
int32_t sample_count = 0; int32_t sample_count = 0;
@ -183,7 +183,7 @@ int taos_metric_formatter_load_metric_new(taos_metric_formatter_t *self, taos_me
} }
if(!isFound && sample_count > 0){ if(!isFound && sample_count > 0){
tjsonAddItemToArray(tableArray, table); (void)tjsonAddItemToArray(tableArray, table);
} }
else{ else{
if(table != NULL) tjsonDelete(table); if(table != NULL) tjsonDelete(table);

2
source/libs/monitorfw/src/taos_metric_sample.c
View File

@ -63,7 +63,7 @@ int taos_metric_sample_destroy_generic(void *gen) {
void taos_metric_sample_free_generic(void *gen) { void taos_metric_sample_free_generic(void *gen) {
taos_metric_sample_t *self = (taos_metric_sample_t *)gen; taos_metric_sample_t *self = (taos_metric_sample_t *)gen;
taos_metric_sample_destroy(self); (void)taos_metric_sample_destroy(self);
} }
int taos_metric_sample_add(taos_metric_sample_t *self, double r_value) { int taos_metric_sample_add(taos_metric_sample_t *self, double r_value) {

4
source/libs/monitorfw/src/taos_monitor_util.c
View File

@ -84,10 +84,10 @@ bool taos_monitor_is_match(const SJson* tags, char** pairs, int32_t count) {
SJson* item = tjsonGetArrayItem(tags, i); SJson* item = tjsonGetArrayItem(tags, i);
char item_name[MONITOR_TAG_NAME_LEN] = {0}; char item_name[MONITOR_TAG_NAME_LEN] = {0};
tjsonGetStringValue(item, "name", item_name); (void)tjsonGetStringValue(item, "name", item_name);
char item_value[MONITOR_TAG_VALUE_LEN] = {0}; char item_value[MONITOR_TAG_VALUE_LEN] = {0};
tjsonGetStringValue(item, "value", item_value); (void)tjsonGetStringValue(item, "value", item_value);
bool isfound = false; bool isfound = false;
for(int32_t j = 0; j < count; j++){ for(int32_t j = 0; j < count; j++){

2
source/libs/monitorfw/src/taos_string_builder.c
View File

@ -44,7 +44,7 @@ taos_string_builder_t *taos_string_builder_new(void) {
self->init_size = TAOS_STRING_BUILDER_INIT_SIZE; self->init_size = TAOS_STRING_BUILDER_INIT_SIZE;
r = taos_string_builder_init(self); r = taos_string_builder_init(self);
if (r) { if (r) {
taos_string_builder_destroy(self); (void)taos_string_builder_destroy(self);
return NULL; return NULL;
} }

12
source/libs/sync/src/syncCommit.c
View File

@ -76,10 +76,8 @@ int64_t syncNodeUpdateCommitIndex(SSyncNode* ths, SyncIndex commitIndex) {
SyncIndex lastVer = ths->pLogStore->syncLogLastIndex(ths->pLogStore); SyncIndex lastVer = ths->pLogStore->syncLogLastIndex(ths->pLogStore);
commitIndex = TMAX(commitIndex, ths->commitIndex); commitIndex = TMAX(commitIndex, ths->commitIndex);
ths->commitIndex = TMIN(commitIndex, lastVer); ths->commitIndex = TMIN(commitIndex, lastVer);
if ((code = ths->pLogStore->syncLogUpdateCommitIndex(ths->pLogStore, ths->commitIndex)) != 0) {
// TODO add return when error // TODO add return when error
sError("failed to update commit index since %s", tstrerror(code)); (void)ths->pLogStore->syncLogUpdateCommitIndex(ths->pLogStore, ths->commitIndex);
}
return ths->commitIndex; return ths->commitIndex;
} }
@ -87,10 +85,8 @@ int64_t syncNodeCheckCommitIndex(SSyncNode* ths, SyncIndex indexLikely) {
int32_t code = 0; int32_t code = 0;
if (indexLikely > ths->commitIndex && syncNodeAgreedUpon(ths, indexLikely)) { if (indexLikely > ths->commitIndex && syncNodeAgreedUpon(ths, indexLikely)) {
SyncIndex commitIndex = indexLikely; SyncIndex commitIndex = indexLikely;
if ((code = syncNodeUpdateCommitIndex(ths, commitIndex)) != 0) {
// TODO add return when error // TODO add return when error
sError("failed to update commit index since %s", tstrerror(code)); (void)syncNodeUpdateCommitIndex(ths, commitIndex);
}
sTrace("vgId:%d, agreed upon. role:%d, term:%" PRId64 ", index:%" PRId64 "", ths->vgId, ths->state, sTrace("vgId:%d, agreed upon. role:%d, term:%" PRId64 ", index:%" PRId64 "", ths->vgId, ths->state,
raftStoreGetTerm(ths), commitIndex); raftStoreGetTerm(ths), commitIndex);
} }
@ -102,9 +98,7 @@ int64_t syncNodeUpdateAssignedCommitIndex(SSyncNode* ths, SyncIndex assignedComm
SyncIndex lastVer = ths->pLogStore->syncLogLastIndex(ths->pLogStore); SyncIndex lastVer = ths->pLogStore->syncLogLastIndex(ths->pLogStore);
assignedCommitIndex = TMAX(assignedCommitIndex, ths->assignedCommitIndex); assignedCommitIndex = TMAX(assignedCommitIndex, ths->assignedCommitIndex);
ths->assignedCommitIndex = TMIN(assignedCommitIndex, lastVer); ths->assignedCommitIndex = TMIN(assignedCommitIndex, lastVer);
if ((code = ths->pLogStore->syncLogUpdateCommitIndex(ths->pLogStore, ths->assignedCommitIndex)) != 0) {
// TODO add return when error // TODO add return when error
sError("failed to update commit index since %s", tstrerror(code)); (void)ths->pLogStore->syncLogUpdateCommitIndex(ths->pLogStore, ths->assignedCommitIndex);
}
return ths->commitIndex; return ths->commitIndex;
} }

12
source/libs/sync/src/syncEnv.c
View File

@ -69,13 +69,13 @@ void syncCleanUp() {
if (gNodeRefId != -1) { if (gNodeRefId != -1) {
sDebug("sync rsetId:%d is closed", gNodeRefId); sDebug("sync rsetId:%d is closed", gNodeRefId);
taosCloseRef(gNodeRefId); (void)taosCloseRef(gNodeRefId);
gNodeRefId = -1; gNodeRefId = -1;
} }
if (gHbDataRefId != -1) { if (gHbDataRefId != -1) {
sDebug("sync rsetId:%d is closed", gHbDataRefId); sDebug("sync rsetId:%d is closed", gHbDataRefId);
taosCloseRef(gHbDataRefId); (void)taosCloseRef(gHbDataRefId);
gHbDataRefId = -1; gHbDataRefId = -1;
} }
} }
@ -88,7 +88,7 @@ int64_t syncNodeAdd(SSyncNode *pNode) {
return pNode->rid; return pNode->rid;
} }
void syncNodeRemove(int64_t rid) { taosRemoveRef(gNodeRefId, rid); } void syncNodeRemove(int64_t rid) { (void)taosRemoveRef(gNodeRefId, rid); }
SSyncNode *syncNodeAcquire(int64_t rid) { SSyncNode *syncNodeAcquire(int64_t rid) {
SSyncNode *pNode = taosAcquireRef(gNodeRefId, rid); SSyncNode *pNode = taosAcquireRef(gNodeRefId, rid);
@ -101,7 +101,7 @@ SSyncNode *syncNodeAcquire(int64_t rid) {
} }
void syncNodeRelease(SSyncNode *pNode) { void syncNodeRelease(SSyncNode *pNode) {
if (pNode) taosReleaseRef(gNodeRefId, pNode->rid); if (pNode) (void)taosReleaseRef(gNodeRefId, pNode->rid);
} }
int64_t syncHbTimerDataAdd(SSyncHbTimerData *pData) { int64_t syncHbTimerDataAdd(SSyncHbTimerData *pData) {
@ -110,7 +110,7 @@ int64_t syncHbTimerDataAdd(SSyncHbTimerData *pData) {
return pData->rid; return pData->rid;
} }
void syncHbTimerDataRemove(int64_t rid) { taosRemoveRef(gHbDataRefId, rid); } void syncHbTimerDataRemove(int64_t rid) { (void)taosRemoveRef(gHbDataRefId, rid); }
SSyncHbTimerData *syncHbTimerDataAcquire(int64_t rid) { SSyncHbTimerData *syncHbTimerDataAcquire(int64_t rid) {
SSyncHbTimerData *pData = taosAcquireRef(gHbDataRefId, rid); SSyncHbTimerData *pData = taosAcquireRef(gHbDataRefId, rid);
@ -122,7 +122,7 @@ SSyncHbTimerData *syncHbTimerDataAcquire(int64_t rid) {
return pData; return pData;
} }
void syncHbTimerDataRelease(SSyncHbTimerData *pData) { taosReleaseRef(gHbDataRefId, pData->rid); } void syncHbTimerDataRelease(SSyncHbTimerData *pData) { (void)taosReleaseRef(gHbDataRefId, pData->rid); }
#if 0 #if 0
void syncEnvStartTimer() { void syncEnvStartTimer() {

151
source/libs/sync/src/syncMain.c
View File

@ -185,13 +185,14 @@ int32_t syncReconfig(int64_t rid, SSyncCfg* pNewCfg) {
syncNodeDoConfigChange(pSyncNode, pNewCfg, pNewCfg->lastIndex); syncNodeDoConfigChange(pSyncNode, pNewCfg, pNewCfg->lastIndex);
if (pSyncNode->state == TAOS_SYNC_STATE_LEADER || pSyncNode->state == TAOS_SYNC_STATE_ASSIGNED_LEADER) { if (pSyncNode->state == TAOS_SYNC_STATE_LEADER || pSyncNode->state == TAOS_SYNC_STATE_ASSIGNED_LEADER) {
syncNodeStopHeartbeatTimer(pSyncNode); // TODO check return value
(void)syncNodeStopHeartbeatTimer(pSyncNode);
for (int32_t i = 0; i < TSDB_MAX_REPLICA + TSDB_MAX_LEARNER_REPLICA; ++i) { for (int32_t i = 0; i < TSDB_MAX_REPLICA + TSDB_MAX_LEARNER_REPLICA; ++i) {
syncHbTimerInit(pSyncNode, &pSyncNode->peerHeartbeatTimerArr[i], pSyncNode->replicasId[i]); (void)syncHbTimerInit(pSyncNode, &pSyncNode->peerHeartbeatTimerArr[i], pSyncNode->replicasId[i]);
} }
syncNodeStartHeartbeatTimer(pSyncNode); (void)syncNodeStartHeartbeatTimer(pSyncNode);
// syncNodeReplicate(pSyncNode); // syncNodeReplicate(pSyncNode);
} }
@ -394,7 +395,8 @@ int32_t syncSendTimeoutRsp(int64_t rid, int64_t seq) {
syncNodeRelease(pNode); syncNodeRelease(pNode);
if (ret == 1) { if (ret == 1) {
sInfo("send timeout response, seq:%" PRId64 " handle:%p ahandle:%p", seq, rpcMsg.info.handle, rpcMsg.info.ahandle); sInfo("send timeout response, seq:%" PRId64 " handle:%p ahandle:%p", seq, rpcMsg.info.handle, rpcMsg.info.ahandle);
rpcSendResponse(&rpcMsg); // TODO check return value
(void)rpcSendResponse(&rpcMsg);
return 0; return 0;
} else { } else {
sError("no message handle to send timeout response, seq:%" PRId64, seq); sError("no message handle to send timeout response, seq:%" PRId64, seq);
@ -674,9 +676,9 @@ int32_t syncGetArbToken(int64_t rid, char* outToken) {
} }
memset(outToken, 0, TSDB_ARB_TOKEN_SIZE); memset(outToken, 0, TSDB_ARB_TOKEN_SIZE);
taosThreadMutexLock(&pSyncNode->arbTokenMutex); (void)taosThreadMutexLock(&pSyncNode->arbTokenMutex);
strncpy(outToken, pSyncNode->arbToken, TSDB_ARB_TOKEN_SIZE); strncpy(outToken, pSyncNode->arbToken, TSDB_ARB_TOKEN_SIZE);
taosThreadMutexUnlock(&pSyncNode->arbTokenMutex); (void)taosThreadMutexUnlock(&pSyncNode->arbTokenMutex);
syncNodeRelease(pSyncNode); syncNodeRelease(pSyncNode);
TAOS_RETURN(code); TAOS_RETURN(code);
@ -956,7 +958,7 @@ static int32_t syncHbTimerStart(SSyncNode* pSyncNode, SSyncTimer* pSyncTimer) {
sTrace("vgId:%d, start hb timer, rid:%" PRId64 " addr:%" PRId64, pSyncNode->vgId, pData->rid, pData->destId.addr); sTrace("vgId:%d, start hb timer, rid:%" PRId64 " addr:%" PRId64, pSyncNode->vgId, pData->rid, pData->destId.addr);
taosTmrReset(pSyncTimer->timerCb, pSyncTimer->timerMS / HEARTBEAT_TICK_NUM, (void*)(pData->rid), (void)taosTmrReset(pSyncTimer->timerCb, pSyncTimer->timerMS / HEARTBEAT_TICK_NUM, (void*)(pData->rid),
syncEnv()->pTimerManager, &pSyncTimer->pTimer); syncEnv()->pTimerManager, &pSyncTimer->pTimer);
} else { } else {
ret = TSDB_CODE_SYN_INTERNAL_ERROR; ret = TSDB_CODE_SYN_INTERNAL_ERROR;
@ -967,7 +969,7 @@ static int32_t syncHbTimerStart(SSyncNode* pSyncNode, SSyncTimer* pSyncTimer) {
static int32_t syncHbTimerStop(SSyncNode* pSyncNode, SSyncTimer* pSyncTimer) { static int32_t syncHbTimerStop(SSyncNode* pSyncNode, SSyncTimer* pSyncTimer) {
int32_t ret = 0; int32_t ret = 0;
atomic_add_fetch_64(&pSyncTimer->logicClock, 1); (void)atomic_add_fetch_64(&pSyncTimer->logicClock, 1);
if (!taosTmrStop(pSyncTimer->pTimer)) { if (!taosTmrStop(pSyncTimer->pTimer)) {
return TSDB_CODE_SYN_INTERNAL_ERROR; return TSDB_CODE_SYN_INTERNAL_ERROR;
} }
@ -983,7 +985,8 @@ int32_t syncNodeLogStoreRestoreOnNeed(SSyncNode* pNode) {
ASSERTS(pNode->pFsm != NULL, "pFsm not registered"); ASSERTS(pNode->pFsm != NULL, "pFsm not registered");
ASSERTS(pNode->pFsm->FpGetSnapshotInfo != NULL, "FpGetSnapshotInfo not registered"); ASSERTS(pNode->pFsm->FpGetSnapshotInfo != NULL, "FpGetSnapshotInfo not registered");
SSnapshot snapshot = {0}; SSnapshot snapshot = {0};
pNode->pFsm->FpGetSnapshotInfo(pNode->pFsm, &snapshot); // TODO check return value
(void)pNode->pFsm->FpGetSnapshotInfo(pNode->pFsm, &snapshot);
SyncIndex commitIndex = snapshot.lastApplyIndex; SyncIndex commitIndex = snapshot.lastApplyIndex;
SyncIndex firstVer = pNode->pLogStore->syncLogBeginIndex(pNode->pLogStore); SyncIndex firstVer = pNode->pLogStore->syncLogBeginIndex(pNode->pLogStore);
@ -1112,7 +1115,7 @@ SSyncNode* syncNodeOpen(SSyncInfo* pSyncInfo, int32_t vnodeVersion) {
} }
pSyncNode->arbTerm = -1; pSyncNode->arbTerm = -1;
taosThreadMutexInit(&pSyncNode->arbTokenMutex, NULL); (void)taosThreadMutexInit(&pSyncNode->arbTokenMutex, NULL);
syncUtilGenerateArbToken(pSyncNode->myNodeInfo.nodeId, pSyncInfo->vgId, pSyncNode->arbToken); syncUtilGenerateArbToken(pSyncNode->myNodeInfo.nodeId, pSyncInfo->vgId, pSyncNode->arbToken);
sInfo("vgId:%d, arb token:%s", pSyncNode->vgId, pSyncNode->arbToken); sInfo("vgId:%d, arb token:%s", pSyncNode->vgId, pSyncNode->arbToken);
@ -1220,7 +1223,8 @@ SSyncNode* syncNodeOpen(SSyncInfo* pSyncInfo, int32_t vnodeVersion) {
SyncIndex commitIndex = SYNC_INDEX_INVALID; SyncIndex commitIndex = SYNC_INDEX_INVALID;
if (pSyncNode->pFsm != NULL && pSyncNode->pFsm->FpGetSnapshotInfo != NULL) { if (pSyncNode->pFsm != NULL && pSyncNode->pFsm->FpGetSnapshotInfo != NULL) {
SSnapshot snapshot = {0}; SSnapshot snapshot = {0};
pSyncNode->pFsm->FpGetSnapshotInfo(pSyncNode->pFsm, &snapshot); // TODO check return value
(void)pSyncNode->pFsm->FpGetSnapshotInfo(pSyncNode->pFsm, &snapshot);
if (snapshot.lastApplyIndex > commitIndex) { if (snapshot.lastApplyIndex > commitIndex) {
commitIndex = snapshot.lastApplyIndex; commitIndex = snapshot.lastApplyIndex;
sNTrace(pSyncNode, "reset commit index by snapshot"); sNTrace(pSyncNode, "reset commit index by snapshot");
@ -1373,7 +1377,7 @@ _error:
void syncNodeMaybeUpdateCommitBySnapshot(SSyncNode* pSyncNode) { void syncNodeMaybeUpdateCommitBySnapshot(SSyncNode* pSyncNode) {
if (pSyncNode->pFsm != NULL && pSyncNode->pFsm->FpGetSnapshotInfo != NULL) { if (pSyncNode->pFsm != NULL && pSyncNode->pFsm->FpGetSnapshotInfo != NULL) {
SSnapshot snapshot = {0}; SSnapshot snapshot = {0};
pSyncNode->pFsm->FpGetSnapshotInfo(pSyncNode->pFsm, &snapshot); (void)pSyncNode->pFsm->FpGetSnapshotInfo(pSyncNode->pFsm, &snapshot);
if (snapshot.lastApplyIndex > pSyncNode->commitIndex) { if (snapshot.lastApplyIndex > pSyncNode->commitIndex) {
pSyncNode->commitIndex = snapshot.lastApplyIndex; pSyncNode->commitIndex = snapshot.lastApplyIndex;
} }
@ -1386,11 +1390,11 @@ int32_t syncNodeRestore(SSyncNode* pSyncNode) {
ASSERTS(pSyncNode->pLogStore != NULL, "log store not created"); ASSERTS(pSyncNode->pLogStore != NULL, "log store not created");
ASSERTS(pSyncNode->pLogBuf != NULL, "ring log buffer not created"); ASSERTS(pSyncNode->pLogBuf != NULL, "ring log buffer not created");
taosThreadMutexLock(&pSyncNode->pLogBuf->mutex); (void)taosThreadMutexLock(&pSyncNode->pLogBuf->mutex);
SyncIndex lastVer = pSyncNode->pLogStore->syncLogLastIndex(pSyncNode->pLogStore); SyncIndex lastVer = pSyncNode->pLogStore->syncLogLastIndex(pSyncNode->pLogStore);
SyncIndex commitIndex = pSyncNode->pLogStore->syncLogCommitIndex(pSyncNode->pLogStore); SyncIndex commitIndex = pSyncNode->pLogStore->syncLogCommitIndex(pSyncNode->pLogStore);
SyncIndex endIndex = pSyncNode->pLogBuf->endIndex; SyncIndex endIndex = pSyncNode->pLogBuf->endIndex;
taosThreadMutexUnlock(&pSyncNode->pLogBuf->mutex); (void)taosThreadMutexUnlock(&pSyncNode->pLogBuf->mutex);
if (lastVer != -1 && endIndex != lastVer + 1) { if (lastVer != -1 && endIndex != lastVer + 1) {
code = TSDB_CODE_WAL_LOG_INCOMPLETE; code = TSDB_CODE_WAL_LOG_INCOMPLETE;
@ -1439,7 +1443,8 @@ int32_t syncNodeStartStandBy(SSyncNode* pSyncNode) {
// state change // state change
pSyncNode->state = TAOS_SYNC_STATE_FOLLOWER; pSyncNode->state = TAOS_SYNC_STATE_FOLLOWER;
pSyncNode->roleTimeMs = taosGetTimestampMs(); pSyncNode->roleTimeMs = taosGetTimestampMs();
syncNodeStopHeartbeatTimer(pSyncNode); // TODO check return value
(void)syncNodeStopHeartbeatTimer(pSyncNode);
// reset elect timer, long enough // reset elect timer, long enough
int32_t electMS = TIMER_MAX_MS; int32_t electMS = TIMER_MAX_MS;
@ -1464,13 +1469,13 @@ void syncNodePreClose(SSyncNode* pSyncNode) {
ASSERT(pSyncNode->pFsm->FpApplyQueueItems != NULL); ASSERT(pSyncNode->pFsm->FpApplyQueueItems != NULL);
// stop elect timer // stop elect timer
syncNodeStopElectTimer(pSyncNode); (void)syncNodeStopElectTimer(pSyncNode);
// stop heartbeat timer // stop heartbeat timer
syncNodeStopHeartbeatTimer(pSyncNode); (void)syncNodeStopHeartbeatTimer(pSyncNode);
// stop ping timer // stop ping timer
syncNodeStopPingTimer(pSyncNode); (void)syncNodeStopPingTimer(pSyncNode);
// clean rsp // clean rsp
syncRespCleanRsp(pSyncNode->pSyncRespMgr); syncRespCleanRsp(pSyncNode->pSyncRespMgr);
@ -1497,9 +1502,9 @@ void syncNodeClose(SSyncNode* pSyncNode) {
syncRespCleanRsp(pSyncNode->pSyncRespMgr); syncRespCleanRsp(pSyncNode->pSyncRespMgr);
syncNodeStopPingTimer(pSyncNode); (void)syncNodeStopPingTimer(pSyncNode);
syncNodeStopElectTimer(pSyncNode); (void)syncNodeStopElectTimer(pSyncNode);
syncNodeStopHeartbeatTimer(pSyncNode); (void)syncNodeStopHeartbeatTimer(pSyncNode);
syncNodeLogReplDestroy(pSyncNode); syncNodeLogReplDestroy(pSyncNode);
syncRespMgrDestroy(pSyncNode->pSyncRespMgr); syncRespMgrDestroy(pSyncNode->pSyncRespMgr);
@ -1517,7 +1522,7 @@ void syncNodeClose(SSyncNode* pSyncNode) {
syncLogBufferDestroy(pSyncNode->pLogBuf); syncLogBufferDestroy(pSyncNode->pLogBuf);
pSyncNode->pLogBuf = NULL; pSyncNode->pLogBuf = NULL;
taosThreadMutexDestroy(&pSyncNode->arbTokenMutex); (void)taosThreadMutexDestroy(&pSyncNode->arbTokenMutex);
for (int32_t i = 0; i < TSDB_MAX_REPLICA + TSDB_MAX_LEARNER_REPLICA; ++i) { for (int32_t i = 0; i < TSDB_MAX_REPLICA + TSDB_MAX_LEARNER_REPLICA; ++i) {
if (pSyncNode->senders[i] != NULL) { if (pSyncNode->senders[i] != NULL) {
@ -1557,8 +1562,8 @@ ESyncStrategy syncNodeStrategy(SSyncNode* pSyncNode) { return pSyncNode->raftCfg
int32_t syncNodeStartPingTimer(SSyncNode* pSyncNode) { int32_t syncNodeStartPingTimer(SSyncNode* pSyncNode) {
int32_t ret = 0; int32_t ret = 0;
if (syncIsInit()) { if (syncIsInit()) {
taosTmrReset(pSyncNode->FpPingTimerCB, pSyncNode->pingTimerMS, (void*)pSyncNode->rid, syncEnv()->pTimerManager, (void)taosTmrReset(pSyncNode->FpPingTimerCB, pSyncNode->pingTimerMS, (void*)pSyncNode->rid,
&pSyncNode->pPingTimer); syncEnv()->pTimerManager, &pSyncNode->pPingTimer);
atomic_store_64(&pSyncNode->pingTimerLogicClock, pSyncNode->pingTimerLogicClockUser); atomic_store_64(&pSyncNode->pingTimerLogicClock, pSyncNode->pingTimerLogicClockUser);
} else { } else {
sError("vgId:%d, start ping timer error, sync env is stop", pSyncNode->vgId); sError("vgId:%d, start ping timer error, sync env is stop", pSyncNode->vgId);
@ -1568,8 +1573,9 @@ int32_t syncNodeStartPingTimer(SSyncNode* pSyncNode) {
int32_t syncNodeStopPingTimer(SSyncNode* pSyncNode) { int32_t syncNodeStopPingTimer(SSyncNode* pSyncNode) {
int32_t ret = 0; int32_t ret = 0;
atomic_add_fetch_64(&pSyncNode->pingTimerLogicClockUser, 1); (void)atomic_add_fetch_64(&pSyncNode->pingTimerLogicClockUser, 1);
taosTmrStop(pSyncNode->pPingTimer); // TODO check return value
(void)taosTmrStop(pSyncNode->pPingTimer);
pSyncNode->pPingTimer = NULL; pSyncNode->pPingTimer = NULL;
return ret; return ret;
} }
@ -1585,11 +1591,8 @@ int32_t syncNodeStartElectTimer(SSyncNode* pSyncNode, int32_t ms) {
pSyncNode->electTimerParam.pSyncNode = pSyncNode; pSyncNode->electTimerParam.pSyncNode = pSyncNode;
pSyncNode->electTimerParam.pData = NULL; pSyncNode->electTimerParam.pData = NULL;
if (!taosTmrReset(pSyncNode->FpElectTimerCB, pSyncNode->electTimerMS, (void*)(pSyncNode->rid), (void)taosTmrReset(pSyncNode->FpElectTimerCB, pSyncNode->electTimerMS, (void*)(pSyncNode->rid),
syncEnv()->pTimerManager, &pSyncNode->pElectTimer)) { syncEnv()->pTimerManager, &pSyncNode->pElectTimer);
ret = TSDB_CODE_SYN_INTERNAL_ERROR;
}
} else { } else {
sError("vgId:%d, start elect timer error, sync env is stop", pSyncNode->vgId); sError("vgId:%d, start elect timer error, sync env is stop", pSyncNode->vgId);
} }
@ -1598,8 +1601,9 @@ int32_t syncNodeStartElectTimer(SSyncNode* pSyncNode, int32_t ms) {
int32_t syncNodeStopElectTimer(SSyncNode* pSyncNode) { int32_t syncNodeStopElectTimer(SSyncNode* pSyncNode) {
int32_t ret = 0; int32_t ret = 0;
atomic_add_fetch_64(&pSyncNode->electTimerLogicClock, 1); (void)atomic_add_fetch_64(&pSyncNode->electTimerLogicClock, 1);
taosTmrStop(pSyncNode->pElectTimer); // TODO check return value
(void)taosTmrStop(pSyncNode->pElectTimer);
pSyncNode->pElectTimer = NULL; pSyncNode->pElectTimer = NULL;
return ret; return ret;
@ -1622,9 +1626,8 @@ void syncNodeResetElectTimer(SSyncNode* pSyncNode) {
electMS = syncUtilElectRandomMS(pSyncNode->electBaseLine, 2 * pSyncNode->electBaseLine); electMS = syncUtilElectRandomMS(pSyncNode->electBaseLine, 2 * pSyncNode->electBaseLine);
} }
if ((code = syncNodeRestartElectTimer(pSyncNode, electMS)) != 0) { // TODO check return value
sError("failed to restart elect timer since %s", tstrerror(code)); (void)syncNodeRestartElectTimer(pSyncNode, electMS);
}
sNTrace(pSyncNode, "reset elect timer, min:%d, max:%d, ms:%d", pSyncNode->electBaseLine, 2 * pSyncNode->electBaseLine, sNTrace(pSyncNode, "reset elect timer, min:%d, max:%d, ms:%d", pSyncNode->electBaseLine, 2 * pSyncNode->electBaseLine,
electMS); electMS);
@ -1634,7 +1637,7 @@ void syncNodeResetElectTimer(SSyncNode* pSyncNode) {
static int32_t syncNodeDoStartHeartbeatTimer(SSyncNode* pSyncNode) { static int32_t syncNodeDoStartHeartbeatTimer(SSyncNode* pSyncNode) {
int32_t ret = 0; int32_t ret = 0;
if (syncIsInit()) { if (syncIsInit()) {
taosTmrReset(pSyncNode->FpHeartbeatTimerCB, pSyncNode->heartbeatTimerMS, (void*)pSyncNode->rid, (void)taosTmrReset(pSyncNode->FpHeartbeatTimerCB, pSyncNode->heartbeatTimerMS, (void*)pSyncNode->rid,
syncEnv()->pTimerManager, &pSyncNode->pHeartbeatTimer); syncEnv()->pTimerManager, &pSyncNode->pHeartbeatTimer);
atomic_store_64(&pSyncNode->heartbeatTimerLogicClock, pSyncNode->heartbeatTimerLogicClockUser); atomic_store_64(&pSyncNode->heartbeatTimerLogicClock, pSyncNode->heartbeatTimerLogicClockUser);
} else { } else {
@ -1668,8 +1671,9 @@ int32_t syncNodeStopHeartbeatTimer(SSyncNode* pSyncNode) {
int32_t ret = 0; int32_t ret = 0;
#if 0 #if 0
atomic_add_fetch_64(&pSyncNode->heartbeatTimerLogicClockUser, 1); //TODO check return value
taosTmrStop(pSyncNode->pHeartbeatTimer); (void)atomic_add_fetch_64(&pSyncNode->heartbeatTimerLogicClockUser, 1);
(void)taosTmrStop(pSyncNode->pHeartbeatTimer);
pSyncNode->pHeartbeatTimer = NULL; pSyncNode->pHeartbeatTimer = NULL;
#endif #endif
@ -1685,8 +1689,9 @@ int32_t syncNodeStopHeartbeatTimer(SSyncNode* pSyncNode) {
#ifdef BUILD_NO_CALL #ifdef BUILD_NO_CALL
int32_t syncNodeRestartHeartbeatTimer(SSyncNode* pSyncNode) { int32_t syncNodeRestartHeartbeatTimer(SSyncNode* pSyncNode) {
syncNodeStopHeartbeatTimer(pSyncNode); // TODO check return value
syncNodeStartHeartbeatTimer(pSyncNode); (void)syncNodeStopHeartbeatTimer(pSyncNode);
(void)syncNodeStartHeartbeatTimer(pSyncNode);
return 0; return 0;
} }
#endif #endif
@ -1801,7 +1806,7 @@ void syncNodeDoConfigChange(SSyncNode* pSyncNode, SSyncCfg* pNewConfig, SyncInde
} }
// add last config index // add last config index
syncAddCfgIndex(pSyncNode, lastConfigChangeIndex); (void)syncAddCfgIndex(pSyncNode, lastConfigChangeIndex);
if (IamInNew) { if (IamInNew) {
//----------------------------------------- //-----------------------------------------
@ -1818,7 +1823,7 @@ void syncNodeDoConfigChange(SSyncNode* pSyncNode, SSyncCfg* pNewConfig, SyncInde
// init internal // init internal
pSyncNode->myNodeInfo = pSyncNode->raftCfg.cfg.nodeInfo[pSyncNode->raftCfg.cfg.myIndex]; pSyncNode->myNodeInfo = pSyncNode->raftCfg.cfg.nodeInfo[pSyncNode->raftCfg.cfg.myIndex];
syncUtilNodeInfo2RaftId(&pSyncNode->myNodeInfo, pSyncNode->vgId, &pSyncNode->myRaftId); (void)syncUtilNodeInfo2RaftId(&pSyncNode->myNodeInfo, pSyncNode->vgId, &pSyncNode->myRaftId);
// init peersNum, peers, peersId // init peersNum, peers, peersId
pSyncNode->peersNum = pSyncNode->raftCfg.cfg.totalReplicaNum - 1; pSyncNode->peersNum = pSyncNode->raftCfg.cfg.totalReplicaNum - 1;
@ -1831,14 +1836,14 @@ void syncNodeDoConfigChange(SSyncNode* pSyncNode, SSyncCfg* pNewConfig, SyncInde
} }
} }
for (int32_t i = 0; i < pSyncNode->peersNum; ++i) { for (int32_t i = 0; i < pSyncNode->peersNum; ++i) {
syncUtilNodeInfo2RaftId(&pSyncNode->peersNodeInfo[i], pSyncNode->vgId, &pSyncNode->peersId[i]); (void)syncUtilNodeInfo2RaftId(&pSyncNode->peersNodeInfo[i], pSyncNode->vgId, &pSyncNode->peersId[i]);
} }
// init replicaNum, replicasId // init replicaNum, replicasId
pSyncNode->replicaNum = pSyncNode->raftCfg.cfg.replicaNum; pSyncNode->replicaNum = pSyncNode->raftCfg.cfg.replicaNum;
pSyncNode->totalReplicaNum = pSyncNode->raftCfg.cfg.totalReplicaNum; pSyncNode->totalReplicaNum = pSyncNode->raftCfg.cfg.totalReplicaNum;
for (int32_t i = 0; i < pSyncNode->raftCfg.cfg.totalReplicaNum; ++i) { for (int32_t i = 0; i < pSyncNode->raftCfg.cfg.totalReplicaNum; ++i) {
syncUtilNodeInfo2RaftId(&pSyncNode->raftCfg.cfg.nodeInfo[i], pSyncNode->vgId, &pSyncNode->replicasId[i]); (void)syncUtilNodeInfo2RaftId(&pSyncNode->raftCfg.cfg.nodeInfo[i], pSyncNode->vgId, &pSyncNode->replicasId[i]);
} }
// update quorum first // update quorum first
@ -1884,7 +1889,7 @@ void syncNodeDoConfigChange(SSyncNode* pSyncNode, SSyncCfg* pNewConfig, SyncInde
// create new // create new
for (int32_t i = 0; i < TSDB_MAX_REPLICA + TSDB_MAX_LEARNER_REPLICA; ++i) { for (int32_t i = 0; i < TSDB_MAX_REPLICA + TSDB_MAX_LEARNER_REPLICA; ++i) {
if (pSyncNode->senders[i] == NULL) { if (pSyncNode->senders[i] == NULL) {
snapshotSenderCreate(pSyncNode, i, &pSyncNode->senders[i]); (void)snapshotSenderCreate(pSyncNode, i, &pSyncNode->senders[i]);
if (pSyncNode->senders[i] == NULL) { if (pSyncNode->senders[i] == NULL) {
// will be created later while send snapshot // will be created later while send snapshot
sSError(pSyncNode->senders[i], "snapshot sender create failed while reconfig"); sSError(pSyncNode->senders[i], "snapshot sender create failed while reconfig");
@ -1906,10 +1911,10 @@ void syncNodeDoConfigChange(SSyncNode* pSyncNode, SSyncCfg* pNewConfig, SyncInde
} }
// persist cfg // persist cfg
syncWriteCfgFile(pSyncNode); (void)syncWriteCfgFile(pSyncNode);
} else { } else {
// persist cfg // persist cfg
syncWriteCfgFile(pSyncNode); (void)syncWriteCfgFile(pSyncNode);
sNInfo(pSyncNode, "do not config change from %d to %d", oldConfig.totalReplicaNum, pNewConfig->totalReplicaNum); sNInfo(pSyncNode, "do not config change from %d to %d", oldConfig.totalReplicaNum, pNewConfig->totalReplicaNum);
} }
@ -1937,10 +1942,10 @@ void syncNodeStepDown(SSyncNode* pSyncNode, SyncTerm newTerm) {
} while (0); } while (0);
if (pSyncNode->state == TAOS_SYNC_STATE_ASSIGNED_LEADER) { if (pSyncNode->state == TAOS_SYNC_STATE_ASSIGNED_LEADER) {
taosThreadMutexLock(&pSyncNode->arbTokenMutex); (void)taosThreadMutexLock(&pSyncNode->arbTokenMutex);
syncUtilGenerateArbToken(pSyncNode->myNodeInfo.nodeId, pSyncNode->vgId, pSyncNode->arbToken); syncUtilGenerateArbToken(pSyncNode->myNodeInfo.nodeId, pSyncNode->vgId, pSyncNode->arbToken);
sInfo("vgId:%d, step down as assigned leader, new arbToken:%s", pSyncNode->vgId, pSyncNode->arbToken); sInfo("vgId:%d, step down as assigned leader, new arbToken:%s", pSyncNode->vgId, pSyncNode->arbToken);
taosThreadMutexUnlock(&pSyncNode->arbTokenMutex); (void)taosThreadMutexUnlock(&pSyncNode->arbTokenMutex);
} }
if (currentTerm < newTerm) { if (currentTerm < newTerm) {
@ -1969,7 +1974,7 @@ void syncNodeBecomeFollower(SSyncNode* pSyncNode, const char* debugStr) {
// state change // state change
pSyncNode->state = TAOS_SYNC_STATE_FOLLOWER; pSyncNode->state = TAOS_SYNC_STATE_FOLLOWER;
pSyncNode->roleTimeMs = taosGetTimestampMs(); pSyncNode->roleTimeMs = taosGetTimestampMs();
syncNodeStopHeartbeatTimer(pSyncNode); (void)syncNodeStopHeartbeatTimer(pSyncNode);
// trace log // trace log
sNTrace(pSyncNode, "become follower %s", debugStr); sNTrace(pSyncNode, "become follower %s", debugStr);
@ -1986,7 +1991,7 @@ void syncNodeBecomeFollower(SSyncNode* pSyncNode, const char* debugStr) {
pSyncNode->minMatchIndex = SYNC_INDEX_INVALID; pSyncNode->minMatchIndex = SYNC_INDEX_INVALID;
// reset log buffer // reset log buffer
syncLogBufferReset(pSyncNode->pLogBuf, pSyncNode); (void)syncLogBufferReset(pSyncNode->pLogBuf, pSyncNode);
// reset elect timer // reset elect timer
syncNodeResetElectTimer(pSyncNode); syncNodeResetElectTimer(pSyncNode);
@ -2011,7 +2016,7 @@ void syncNodeBecomeLearner(SSyncNode* pSyncNode, const char* debugStr) {
pSyncNode->minMatchIndex = SYNC_INDEX_INVALID; pSyncNode->minMatchIndex = SYNC_INDEX_INVALID;
// reset log buffer // reset log buffer
syncLogBufferReset(pSyncNode->pLogBuf, pSyncNode); (void)syncLogBufferReset(pSyncNode->pLogBuf, pSyncNode);
} }
// TLA+ Spec // TLA+ Spec
@ -2061,7 +2066,7 @@ void syncNodeBecomeLeader(SSyncNode* pSyncNode, const char* debugStr) {
} }
// init peer mgr // init peer mgr
syncNodePeerStateInit(pSyncNode); (void)syncNodePeerStateInit(pSyncNode);
#if 0 #if 0
// update sender private term // update sender private term
@ -2082,13 +2087,13 @@ void syncNodeBecomeLeader(SSyncNode* pSyncNode, const char* debugStr) {
} }
// stop elect timer // stop elect timer
syncNodeStopElectTimer(pSyncNode); (void)syncNodeStopElectTimer(pSyncNode);
// start heartbeat timer // start heartbeat timer
syncNodeStartHeartbeatTimer(pSyncNode); (void)syncNodeStartHeartbeatTimer(pSyncNode);
// send heartbeat right now // send heartbeat right now
syncNodeHeartbeatPeers(pSyncNode); (void)syncNodeHeartbeatPeers(pSyncNode);
// call back // call back
if (pSyncNode->pFsm != NULL && pSyncNode->pFsm->FpBecomeLeaderCb != NULL) { if (pSyncNode->pFsm != NULL && pSyncNode->pFsm->FpBecomeLeaderCb != NULL) {
@ -2099,7 +2104,7 @@ void syncNodeBecomeLeader(SSyncNode* pSyncNode, const char* debugStr) {
pSyncNode->minMatchIndex = SYNC_INDEX_INVALID; pSyncNode->minMatchIndex = SYNC_INDEX_INVALID;
// reset log buffer // reset log buffer
syncLogBufferReset(pSyncNode->pLogBuf, pSyncNode); (void)syncLogBufferReset(pSyncNode->pLogBuf, pSyncNode);
// trace log // trace log
sNInfo(pSyncNode, "become leader %s", debugStr); sNInfo(pSyncNode, "become leader %s", debugStr);
@ -2134,7 +2139,7 @@ void syncNodeBecomeAssignedLeader(SSyncNode* pSyncNode) {
} }
// init peer mgr // init peer mgr
syncNodePeerStateInit(pSyncNode); (void)syncNodePeerStateInit(pSyncNode);
// close receiver // close receiver
if (snapshotReceiverIsStart(pSyncNode->pNewNodeReceiver)) { if (snapshotReceiverIsStart(pSyncNode->pNewNodeReceiver)) {
@ -2142,13 +2147,13 @@ void syncNodeBecomeAssignedLeader(SSyncNode* pSyncNode) {
} }
// stop elect timer // stop elect timer
syncNodeStopElectTimer(pSyncNode); (void)syncNodeStopElectTimer(pSyncNode);
// start heartbeat timer // start heartbeat timer
syncNodeStartHeartbeatTimer(pSyncNode); (void)syncNodeStartHeartbeatTimer(pSyncNode);
// send heartbeat right now // send heartbeat right now
syncNodeHeartbeatPeers(pSyncNode); (void)syncNodeHeartbeatPeers(pSyncNode);
// call back // call back
if (pSyncNode->pFsm != NULL && pSyncNode->pFsm->FpBecomeAssignedLeaderCb != NULL) { if (pSyncNode->pFsm != NULL && pSyncNode->pFsm->FpBecomeAssignedLeaderCb != NULL) {
@ -2159,7 +2164,7 @@ void syncNodeBecomeAssignedLeader(SSyncNode* pSyncNode) {
pSyncNode->minMatchIndex = SYNC_INDEX_INVALID; pSyncNode->minMatchIndex = SYNC_INDEX_INVALID;
// reset log buffer // reset log buffer
syncLogBufferReset(pSyncNode->pLogBuf, pSyncNode); (void)syncLogBufferReset(pSyncNode->pLogBuf, pSyncNode);
// trace log // trace log
sNInfo(pSyncNode, "become assigned leader"); sNInfo(pSyncNode, "become assigned leader");
@ -2262,7 +2267,8 @@ bool syncNodeHasSnapshot(SSyncNode* pSyncNode) {
bool ret = false; bool ret = false;
SSnapshot snapshot = {.data = NULL, .lastApplyIndex = -1, .lastApplyTerm = 0, .lastConfigIndex = -1}; SSnapshot snapshot = {.data = NULL, .lastApplyIndex = -1, .lastApplyTerm = 0, .lastConfigIndex = -1};
if (pSyncNode->pFsm->FpGetSnapshotInfo != NULL) { if (pSyncNode->pFsm->FpGetSnapshotInfo != NULL) {
pSyncNode->pFsm->FpGetSnapshotInfo(pSyncNode->pFsm, &snapshot); // TODO check return value
(void)pSyncNode->pFsm->FpGetSnapshotInfo(pSyncNode->pFsm, &snapshot);
if (snapshot.lastApplyIndex >= SYNC_INDEX_BEGIN) { if (snapshot.lastApplyIndex >= SYNC_INDEX_BEGIN) {
ret = true; ret = true;
} }
@ -2275,7 +2281,8 @@ bool syncNodeHasSnapshot(SSyncNode* pSyncNode) {
SyncIndex syncNodeGetLastIndex(const SSyncNode* pSyncNode) { SyncIndex syncNodeGetLastIndex(const SSyncNode* pSyncNode) {
SSnapshot snapshot = {.data = NULL, .lastApplyIndex = -1, .lastApplyTerm = 0, .lastConfigIndex = -1}; SSnapshot snapshot = {.data = NULL, .lastApplyIndex = -1, .lastApplyTerm = 0, .lastConfigIndex = -1};
if (pSyncNode->pFsm->FpGetSnapshotInfo != NULL) { if (pSyncNode->pFsm->FpGetSnapshotInfo != NULL) {
pSyncNode->pFsm->FpGetSnapshotInfo(pSyncNode->pFsm, &snapshot); // TODO check return value
(void)pSyncNode->pFsm->FpGetSnapshotInfo(pSyncNode->pFsm, &snapshot);
} }
SyncIndex logLastIndex = pSyncNode->pLogStore->syncLogLastIndex(pSyncNode->pLogStore); SyncIndex logLastIndex = pSyncNode->pLogStore->syncLogLastIndex(pSyncNode->pLogStore);
@ -2291,7 +2298,8 @@ SyncTerm syncNodeGetLastTerm(SSyncNode* pSyncNode) {
// has snapshot // has snapshot
SSnapshot snapshot = {.data = NULL, .lastApplyIndex = -1, .lastApplyTerm = 0, .lastConfigIndex = -1}; SSnapshot snapshot = {.data = NULL, .lastApplyIndex = -1, .lastApplyTerm = 0, .lastConfigIndex = -1};
if (pSyncNode->pFsm->FpGetSnapshotInfo != NULL) { if (pSyncNode->pFsm->FpGetSnapshotInfo != NULL) {
pSyncNode->pFsm->FpGetSnapshotInfo(pSyncNode->pFsm, &snapshot); // TODO check return value
(void)pSyncNode->pFsm->FpGetSnapshotInfo(pSyncNode->pFsm, &snapshot);
} }
SyncIndex logLastIndex = pSyncNode->pLogStore->syncLogLastIndex(pSyncNode->pLogStore); SyncIndex logLastIndex = pSyncNode->pLogStore->syncLogLastIndex(pSyncNode->pLogStore);
@ -2386,7 +2394,8 @@ SyncTerm syncNodeGetPreTerm(SSyncNode* pSyncNode, SyncIndex index) {
return preTerm; return preTerm;
} else { } else {
if (pSyncNode->pFsm->FpGetSnapshotInfo != NULL) { if (pSyncNode->pFsm->FpGetSnapshotInfo != NULL) {
pSyncNode->pFsm->FpGetSnapshotInfo(pSyncNode->pFsm, &snapshot); // TODO check return value
(void)pSyncNode->pFsm->FpGetSnapshotInfo(pSyncNode->pFsm, &snapshot);
if (snapshot.lastApplyIndex == preIndex) { if (snapshot.lastApplyIndex == preIndex) {
return snapshot.lastApplyTerm; return snapshot.lastApplyTerm;
} }
@ -2433,7 +2442,7 @@ static void syncNodeEqPingTimer(void* param, void* tmrId) {
} }
_out: _out:
taosTmrReset(syncNodeEqPingTimer, pNode->pingTimerMS, (void*)pNode->rid, syncEnv()->pTimerManager, (void)taosTmrReset(syncNodeEqPingTimer, pNode->pingTimerMS, (void*)pNode->rid, syncEnv()->pTimerManager,
&pNode->pPingTimer); &pNode->pPingTimer);
} }
} }
@ -2510,7 +2519,7 @@ static void syncNodeEqHeartbeatTimer(void* param, void* tmrId) {
} }
_out: _out:
taosTmrReset(syncNodeEqHeartbeatTimer, pNode->heartbeatTimerMS, (void*)pNode->rid, syncEnv()->pTimerManager, (void)taosTmrReset(syncNodeEqHeartbeatTimer, pNode->heartbeatTimerMS, (void*)pNode->rid, syncEnv()->pTimerManager,
&pNode->pHeartbeatTimer); &pNode->pHeartbeatTimer);
} else { } else {
@ -2585,13 +2594,13 @@ static void syncNodeEqPeerHeartbeatTimer(void* param, void* tmrId) {
// send msg // send msg
sTrace("vgId:%d, send heartbeat to dnode:%d", pSyncNode->vgId, DID(&(pSyncMsg->destId))); sTrace("vgId:%d, send heartbeat to dnode:%d", pSyncNode->vgId, DID(&(pSyncMsg->destId)));
syncLogSendHeartbeat(pSyncNode, pSyncMsg, false, timerElapsed, pData->execTime); syncLogSendHeartbeat(pSyncNode, pSyncMsg, false, timerElapsed, pData->execTime);
syncNodeSendHeartbeat(pSyncNode, &pSyncMsg->destId, &rpcMsg); (void)syncNodeSendHeartbeat(pSyncNode, &pSyncMsg->destId, &rpcMsg);
} else { } else {
} }
if (syncIsInit()) { if (syncIsInit()) {
// sTrace("vgId:%d, reset peer hb timer", pSyncNode->vgId); // sTrace("vgId:%d, reset peer hb timer", pSyncNode->vgId);
taosTmrReset(syncNodeEqPeerHeartbeatTimer, pSyncTimer->timerMS / HEARTBEAT_TICK_NUM, (void*)hbDataRid, (void)taosTmrReset(syncNodeEqPeerHeartbeatTimer, pSyncTimer->timerMS / HEARTBEAT_TICK_NUM, (void*)hbDataRid,
syncEnv()->pTimerManager, &pSyncTimer->pTimer); syncEnv()->pTimerManager, &pSyncTimer->pTimer);
} else { } else {
sError("sync env is stop, reset peer hb timer error"); sError("sync env is stop, reset peer hb timer error");

14
source/libs/tdb/src/db/tdbBtree.c
View File

@ -235,7 +235,7 @@ int tdbBtreeDelete(SBTree *pBt, const void *pKey, int kLen, TXN *pTxn) {
int c; int c;
int ret; int ret;
tdbBtcOpen(&btc, pBt, pTxn); (void)tdbBtcOpen(&btc, pBt, pTxn);
/* /*
btc.coder.ofps = taosArrayInit(8, sizeof(SPage *)); btc.coder.ofps = taosArrayInit(8, sizeof(SPage *));
// btc.coder.ofps = taosArrayInit(8, sizeof(SPgno)); // 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; void *pTVal = NULL;
SCellDecoder cd = {0}; SCellDecoder cd = {0};
tdbBtcOpen(&btc, pBt, NULL); (void)tdbBtcOpen(&btc, pBt, NULL);
tdbTrace("tdb pget, btc: %p", &btc); tdbTrace("tdb pget, btc: %p", &btc);
@ -799,7 +799,7 @@ static int tdbBtreeBalanceNonRoot(SBTree *pBt, SPage *pParent, int idx, TXN *pTx
iNew = 0; iNew = 0;
nNewCells = 0; nNewCells = 0;
tdbBtreeInitPage(pNews[iNew], &iarg, 0); (void)tdbBtreeInitPage(pNews[iNew], &iarg, 0);
for (int iOld = 0; iOld < nOlds; iOld++) { for (int iOld = 0; iOld < nOlds; iOld++) {
SPage *pPage; SPage *pPage;
@ -828,7 +828,7 @@ static int tdbBtreeBalanceNonRoot(SBTree *pBt, SPage *pParent, int idx, TXN *pTx
if (iNew == nNews - 1 && pIntHdr->pgno == 0) { if (iNew == nNews - 1 && pIntHdr->pgno == 0) {
pIntHdr->pgno = TDB_PAGE_PGNO(pNews[iNew]); pIntHdr->pgno = TDB_PAGE_PGNO(pNews[iNew]);
} else { } 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 // TODO: pCell here may be inserted as an overflow cell, handle it
SCell *pNewCell = tdbOsMalloc(cd.kLen + 9); SCell *pNewCell = tdbOsMalloc(cd.kLen + 9);
@ -850,7 +850,7 @@ static int tdbBtreeBalanceNonRoot(SBTree *pBt, SPage *pParent, int idx, TXN *pTx
iNew++; iNew++;
nNewCells = 0; nNewCells = 0;
if (iNew < nNews) { if (iNew < nNews) {
tdbBtreeInitPage(pNews[iNew], &iarg, 0); (void)tdbBtreeInitPage(pNews[iNew], &iarg, 0);
} }
} }
} else { } else {
@ -875,7 +875,7 @@ static int tdbBtreeBalanceNonRoot(SBTree *pBt, SPage *pParent, int idx, TXN *pTx
iNew++; iNew++;
nNewCells = 0; nNewCells = 0;
if (iNew < nNews) { 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) { 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]); i8 flags = TDB_BTREE_ROOT | TDB_BTREE_PAGE_IS_LEAF(pNews[0]);
// copy content to the parent page // 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); (void)tdbPageCopy(pNews[0], pParent, 1);
if (!TDB_BTREE_PAGE_IS_LEAF(pNews[0])) { if (!TDB_BTREE_PAGE_IS_LEAF(pNews[0])) {

2
source/libs/tdb/src/db/tdbPager.c
View File

@ -968,7 +968,7 @@ static int tdbPagerInitPage(SPager *pPager, SPage *pPage, int (*initPage)(SPage
if (TDB_PAGE_INITIALIZED(pPage)) break; if (TDB_PAGE_INITIALIZED(pPage)) break;
nLoops++; nLoops++;
if (nLoops > 1000) { if (nLoops > 1000) {
sched_yield(); (void)sched_yield();
nLoops = 0; nLoops = 0;
} }
} }

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

@ -209,7 +209,7 @@ static FORCE_INLINE int32_t taosBuildDstAddr(const char* server, uint16_t port,
static void* httpThread(void* arg) { static void* httpThread(void* arg) {
SHttpModule* http = (SHttpModule*)arg; SHttpModule* http = (SHttpModule*)arg;
setThreadName("http-cli-send-thread"); setThreadName("http-cli-send-thread");
uv_run(http->loop, UV_RUN_DEFAULT); (void)uv_run(http->loop, UV_RUN_DEFAULT);
return NULL; return NULL;
} }
@ -332,7 +332,7 @@ static FORCE_INLINE void clientCloseCb(uv_handle_t* handle) {
SHttpModule* http = taosAcquireRef(httpRefMgt, cli->chanId); SHttpModule* http = taosAcquireRef(httpRefMgt, cli->chanId);
if (http != NULL) { if (http != NULL) {
http->connNum -= 1; http->connNum -= 1;
taosReleaseRef(httpRefMgt, chanId); (void)taosReleaseRef(httpRefMgt, chanId);
} }
destroyHttpClient(cli); destroyHttpClient(cli);
@ -389,7 +389,7 @@ static void clientConnCb(uv_connect_t* req, int32_t status) {
if (!uv_is_closing((uv_handle_t*)&cli->tcp)) { if (!uv_is_closing((uv_handle_t*)&cli->tcp)) {
uv_close((uv_handle_t*)&cli->tcp, clientCloseCb); uv_close((uv_handle_t*)&cli->tcp, clientCloseCb);
} }
taosReleaseRef(httpRefMgt, chanId); (void)taosReleaseRef(httpRefMgt, chanId);
return; return;
} }
http->connNum += 1; http->connNum += 1;
@ -404,7 +404,7 @@ static void clientConnCb(uv_connect_t* req, int32_t status) {
uv_close((uv_handle_t*)&cli->tcp, clientCloseCb); uv_close((uv_handle_t*)&cli->tcp, clientCloseCb);
} }
} }
taosReleaseRef(httpRefMgt, chanId); (void)taosReleaseRef(httpRefMgt, chanId);
} }
int32_t httpSendQuit(SHttpModule* http, int64_t chanId) { int32_t httpSendQuit(SHttpModule* http, int64_t chanId) {
@ -449,7 +449,7 @@ static void httpHandleQuit(SHttpMsg* msg) {
SHttpModule* http = taosAcquireRef(httpRefMgt, chanId); SHttpModule* http = taosAcquireRef(httpRefMgt, chanId);
if (http == NULL) return; if (http == NULL) return;
uv_walk(http->loop, httpWalkCb, NULL); uv_walk(http->loop, httpWalkCb, NULL);
taosReleaseRef(httpRefMgt, chanId); (void)taosReleaseRef(httpRefMgt, chanId);
} }
static bool httpFailFastShoudIgnoreMsg(SHashObj* pTable, char* server, int16_t port) { static bool httpFailFastShoudIgnoreMsg(SHashObj* pTable, char* server, int16_t port) {
@ -474,10 +474,10 @@ static void httpFailFastMayUpdate(SHashObj* pTable, char* server, int16_t port,
sprintf(buf, "%s:%d", server, port); sprintf(buf, "%s:%d", server, port);
if (succ) { if (succ) {
taosHashRemove(pTable, buf, strlen(buf)); (void)taosHashRemove(pTable, buf, strlen(buf));
} else { } else {
int32_t st = taosGetTimestampSec(); int32_t st = taosGetTimestampSec();
taosHashPut(pTable, buf, strlen(buf), &st, sizeof(st)); (void)taosHashPut(pTable, buf, strlen(buf), &st, sizeof(st));
} }
return; return;
} }
@ -559,7 +559,7 @@ static void httpHandleReq(SHttpMsg* msg) {
tError("http-report failed to alloc read buf, dst:%s:%d,chanId:%" PRId64 ", reason:%s", cli->addr, cli->port, tError("http-report failed to alloc read buf, dst:%s:%d,chanId:%" PRId64 ", reason:%s", cli->addr, cli->port,
chanId, tstrerror(TSDB_CODE_OUT_OF_MEMORY)); chanId, tstrerror(TSDB_CODE_OUT_OF_MEMORY));
destroyHttpClient(cli); destroyHttpClient(cli);
taosReleaseRef(httpRefMgt, chanId); (void)taosReleaseRef(httpRefMgt, chanId);
return; return;
} }
@ -568,7 +568,7 @@ static void httpHandleReq(SHttpMsg* msg) {
tError("http-report failed to init socket handle, dst:%s:%d,chanId:%" PRId64 ", reason:%s", cli->addr, cli->port, tError("http-report failed to init socket handle, dst:%s:%d,chanId:%" PRId64 ", reason:%s", cli->addr, cli->port,
chanId, uv_strerror(err)); chanId, uv_strerror(err));
destroyHttpClient(cli); destroyHttpClient(cli);
taosReleaseRef(httpRefMgt, chanId); (void)taosReleaseRef(httpRefMgt, chanId);
return; return;
} }
@ -578,7 +578,7 @@ static void httpHandleReq(SHttpMsg* msg) {
tError("http-report failed to open socket, dst:%s:%d, chanId:%" PRId64 ", reason:%s", cli->addr, cli->port, chanId, tError("http-report failed to open socket, dst:%s:%d, chanId:%" PRId64 ", reason:%s", cli->addr, cli->port, chanId,
tstrerror(TAOS_SYSTEM_ERROR(errno))); tstrerror(TAOS_SYSTEM_ERROR(errno)));
destroyHttpClient(cli); destroyHttpClient(cli);
taosReleaseRef(httpRefMgt, chanId); (void)taosReleaseRef(httpRefMgt, chanId);
return; return;
} }
@ -587,7 +587,7 @@ static void httpHandleReq(SHttpMsg* msg) {
tError("http-report failed to open socket, reason:%s, dst:%s:%d, chanId:%" PRId64 ",reason:%s", uv_strerror(ret), tError("http-report failed to open socket, reason:%s, dst:%s:%d, chanId:%" PRId64 ",reason:%s", uv_strerror(ret),
cli->addr, cli->port, chanId, uv_strerror(ret)); cli->addr, cli->port, chanId, uv_strerror(ret));
destroyHttpClient(cli); destroyHttpClient(cli);
taosReleaseRef(httpRefMgt, chanId); (void)taosReleaseRef(httpRefMgt, chanId);
return; return;
} }
@ -598,7 +598,7 @@ static void httpHandleReq(SHttpMsg* msg) {
httpFailFastMayUpdate(http->connStatusTable, cli->addr, cli->port, 0); httpFailFastMayUpdate(http->connStatusTable, cli->addr, cli->port, 0);
destroyHttpClient(cli); destroyHttpClient(cli);
} }
taosReleaseRef(httpRefMgt, chanId); (void)taosReleaseRef(httpRefMgt, chanId);
return; return;
END: END:
@ -608,7 +608,7 @@ END:
} }
httpDestroyMsg(msg); httpDestroyMsg(msg);
taosMemoryFree(header); taosMemoryFree(header);
taosReleaseRef(httpRefMgt, chanId); (void)taosReleaseRef(httpRefMgt, chanId);
} }
static void httpModuleDestroy(SHttpModule* http) { static void httpModuleDestroy(SHttpModule* http) {
@ -619,7 +619,7 @@ static void httpModuleDestroy(SHttpModule* http) {
transAsyncPoolDestroy(http->asyncPool); transAsyncPoolDestroy(http->asyncPool);
} }
if (http->loop) { if (http->loop) {
uv_loop_close(http->loop); (void)uv_loop_close(http->loop);
taosMemoryFree(http->loop); taosMemoryFree(http->loop);
} }
@ -673,7 +673,7 @@ int32_t taosSendHttpReportByChan(const char* server, const char* uri, uint16_t p
int32_t taosSendHttpReport(const char* server, const char* uri, uint16_t port, char* pCont, int32_t contLen, int32_t taosSendHttpReport(const char* server, const char* uri, uint16_t port, char* pCont, int32_t contLen,
EHttpCompFlag flag) { EHttpCompFlag flag) {
taosThreadOnce(&transHttpInit, transHttpEnvInit); (void)taosThreadOnce(&transHttpInit, transHttpEnvInit);
return taosSendHttpReportImplByChan(server, uri, port, pCont, contLen, flag, httpDefaultChanId); return taosSendHttpReportImplByChan(server, uri, port, pCont, contLen, flag, httpDefaultChanId);
} }
@ -743,7 +743,7 @@ _ERROR:
return code; return code;
} }
int64_t taosInitHttpChan() { int64_t taosInitHttpChan() {
taosThreadOnce(&transHttpInit, transHttpEnvInit); (void)taosThreadOnce(&transHttpInit, transHttpEnvInit);
return transInitHttpChanImpl(); return transInitHttpChanImpl();
} }
@ -762,14 +762,14 @@ void taosDestroyHttpChan(int64_t chanId) {
ret = httpSendQuit(load, chanId); ret = httpSendQuit(load, chanId);
if (ret != 0) { if (ret != 0) {
tDebug("http-report already destroyed, chanId %" PRId64 ",reason:%s", chanId, tstrerror(ret)); tDebug("http-report already destroyed, chanId %" PRId64 ",reason:%s", chanId, tstrerror(ret));
taosReleaseRef(httpRefMgt, chanId); (void)taosReleaseRef(httpRefMgt, chanId);
return; return;
} }
taosThreadJoin(load->thread, NULL); (void)taosThreadJoin(load->thread, NULL);
httpModuleDestroy(load); httpModuleDestroy(load);
taosReleaseRef(httpRefMgt, chanId); (void)taosReleaseRef(httpRefMgt, chanId);
taosRemoveRef(httpRefMgt, chanId); (void)taosRemoveRef(httpRefMgt, chanId);
} }

4
source/libs/transport/src/tmsgcb.c
View File

@ -59,7 +59,7 @@ int32_t tmsgSendSyncReq(const SEpSet* epSet, SRpcMsg* pMsg) {
void tmsgSendRsp(SRpcMsg* pMsg) { void tmsgSendRsp(SRpcMsg* pMsg) {
#if 1 #if 1
rpcSendResponse(pMsg); (void)rpcSendResponse(pMsg);
#else #else
return (*defaultMsgCb.sendRspFp)(pMsg); return (*defaultMsgCb.sendRspFp)(pMsg);
#endif #endif
@ -81,6 +81,6 @@ bool tmsgUpdateDnodeInfo(int32_t* dnodeId, int64_t* clusterId, char* fqdn, uint1
void tmsgUpdateDnodeEpSet(SEpSet* epset) { void tmsgUpdateDnodeEpSet(SEpSet* epset) {
for (int32_t i = 0; i < epset->numOfEps; ++i) { for (int32_t i = 0; i < epset->numOfEps; ++i) {
tmsgUpdateDnodeInfo(NULL, NULL, epset->eps[i].fqdn, &epset->eps[i].port); (void)tmsgUpdateDnodeInfo(NULL, NULL, epset->eps[i].fqdn, &epset->eps[i].port);
} }
} }

6
source/libs/transport/src/trans.c
View File

@ -111,7 +111,7 @@ void* rpcOpen(const SRpcInit* pInit) {
} }
int64_t refId = transAddExHandle(transGetInstMgt(), pRpc); int64_t refId = transAddExHandle(transGetInstMgt(), pRpc);
transAcquireExHandle(transGetInstMgt(), refId); (void)transAcquireExHandle(transGetInstMgt(), refId);
pRpc->refId = refId; pRpc->refId = refId;
return (void*)refId; return (void*)refId;
_end: _end:
@ -122,8 +122,8 @@ _end:
} }
void rpcClose(void* arg) { void rpcClose(void* arg) {
tInfo("start to close rpc"); tInfo("start to close rpc");
transRemoveExHandle(transGetInstMgt(), (int64_t)arg); (void)transRemoveExHandle(transGetInstMgt(), (int64_t)arg);
transReleaseExHandle(transGetInstMgt(), (int64_t)arg); (void)transReleaseExHandle(transGetInstMgt(), (int64_t)arg);
tInfo("end to close rpc"); tInfo("end to close rpc");
return; return;
} }

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

@ -232,9 +232,9 @@ static void cliWalkCb(uv_handle_t* handle, void* arg);
#define CLI_RELEASE_UV(loop) \ #define CLI_RELEASE_UV(loop) \
do { \ do { \
uv_walk(loop, cliWalkCb, NULL); \ (void)uv_walk(loop, cliWalkCb, NULL); \
uv_run(loop, UV_RUN_DEFAULT); \ (void)uv_run(loop, UV_RUN_DEFAULT); \
uv_loop_close(loop); \ (void)uv_loop_close(loop); \
} while (0); } while (0);
// snprintf may cause performance problem // snprintf may cause performance problem
@ -244,7 +244,7 @@ static void cliWalkCb(uv_handle_t* handle, void* arg);
int16_t len = strlen(ip); \ int16_t len = strlen(ip); \
if (ip != NULL) memcpy(t, ip, len); \ if (ip != NULL) memcpy(t, ip, len); \
t[len] = ':'; \ t[len] = ':'; \
titoa(port, 10, &t[len + 1]); \ (void)titoa(port, 10, &t[len + 1]); \
} while (0) } while (0)
#define CONN_PERSIST_TIME(para) ((para) <= 90000 ? 90000 : (para)) #define CONN_PERSIST_TIME(para) ((para) <= 90000 ? 90000 : (para))
@ -357,15 +357,15 @@ bool cliConnSendSeqMsg(int64_t refId, SCliConn* conn) {
taosWUnLockLatch(&exh->latch); taosWUnLockLatch(&exh->latch);
SCliMsg* t = QUEUE_DATA(h, SCliMsg, seqq); SCliMsg* t = QUEUE_DATA(h, SCliMsg, seqq);
transCtxMerge(&conn->ctx, &t->ctx->appCtx); transCtxMerge(&conn->ctx, &t->ctx->appCtx);
transQueuePush(&conn->cliMsgs, t); (void)transQueuePush(&conn->cliMsgs, t);
tDebug("pop from conn %p, refId: %" PRId64 "", conn, refId); tDebug("pop from conn %p, refId: %" PRId64 "", conn, refId);
transReleaseExHandle(transGetRefMgt(), refId); (void)transReleaseExHandle(transGetRefMgt(), refId);
cliSend(conn); cliSend(conn);
return true; return true;
} }
taosWUnLockLatch(&exh->latch); taosWUnLockLatch(&exh->latch);
tDebug("empty conn %p, refId: %" PRId64 "", conn, refId); tDebug("empty conn %p, refId: %" PRId64 "", conn, refId);
transReleaseExHandle(transGetRefMgt(), refId); (void)transReleaseExHandle(transGetRefMgt(), refId);
return false; return false;
} }
@ -376,9 +376,9 @@ void cliHandleResp(SCliConn* conn) {
if (conn->timer) { if (conn->timer) {
if (uv_is_active((uv_handle_t*)conn->timer)) { if (uv_is_active((uv_handle_t*)conn->timer)) {
tDebug("%s conn %p stop timer", CONN_GET_INST_LABEL(conn), conn); tDebug("%s conn %p stop timer", CONN_GET_INST_LABEL(conn), conn);
uv_timer_stop(conn->timer); (void)uv_timer_stop(conn->timer);
} }
taosArrayPush(pThrd->timerList, &conn->timer); (void)taosArrayPush(pThrd->timerList, &conn->timer);
conn->timer->data = NULL; conn->timer->data = NULL;
conn->timer = NULL; conn->timer = NULL;
} }
@ -486,7 +486,7 @@ void cliHandleResp(SCliConn* conn) {
return addConnToPool(pThrd->pool, conn); return addConnToPool(pThrd->pool, conn);
} }
uv_read_start((uv_stream_t*)conn->stream, cliAllocRecvBufferCb, cliRecvCb); (void)uv_read_start((uv_stream_t*)conn->stream, cliAllocRecvBufferCb, cliRecvCb);
} }
static void cliDestroyMsgInExhandle(int64_t refId) { static void cliDestroyMsgInExhandle(int64_t refId) {
if (refId == 0) return; if (refId == 0) return;
@ -500,7 +500,7 @@ static void cliDestroyMsgInExhandle(int64_t refId) {
destroyCmsg(t); destroyCmsg(t);
} }
taosWUnLockLatch(&exh->latch); taosWUnLockLatch(&exh->latch);
transReleaseExHandle(transGetRefMgt(), refId); (void)transReleaseExHandle(transGetRefMgt(), refId);
} }
} }
@ -588,9 +588,9 @@ void cliConnTimeout(uv_timer_t* handle) {
tTrace("%s conn %p conn timeout, ref:%d", CONN_GET_INST_LABEL(conn), conn, T_REF_VAL_GET(conn)); tTrace("%s conn %p conn timeout, ref:%d", CONN_GET_INST_LABEL(conn), conn, T_REF_VAL_GET(conn));
uv_timer_stop(handle); (void)uv_timer_stop(handle);
handle->data = NULL; handle->data = NULL;
taosArrayPush(pThrd->timerList, &conn->timer); (void)taosArrayPush(pThrd->timerList, &conn->timer);
conn->timer = NULL; conn->timer = NULL;
cliMayUpdateFqdnCache(pThrd->fqdn2ipCache, conn->dstAddr); cliMayUpdateFqdnCache(pThrd->fqdn2ipCache, conn->dstAddr);
@ -600,7 +600,7 @@ void cliReadTimeoutCb(uv_timer_t* handle) {
// set up timeout cb // set up timeout cb
SCliConn* conn = handle->data; SCliConn* conn = handle->data;
tTrace("%s conn %p timeout, ref:%d", CONN_GET_INST_LABEL(conn), conn, T_REF_VAL_GET(conn)); tTrace("%s conn %p timeout, ref:%d", CONN_GET_INST_LABEL(conn), conn, T_REF_VAL_GET(conn));
uv_read_stop(conn->stream); (void)uv_read_stop(conn->stream);
cliHandleExceptImpl(conn, TSDB_CODE_RPC_TIMEOUT); cliHandleExceptImpl(conn, TSDB_CODE_RPC_TIMEOUT);
} }
@ -687,7 +687,7 @@ static SCliConn* getConnFromPool2(SCliThrd* pThrd, char* key, SCliMsg** pMsg) {
SConnList* plist = taosHashGet((SHashObj*)pool, key, klen); SConnList* plist = taosHashGet((SHashObj*)pool, key, klen);
if (plist == NULL) { if (plist == NULL) {
SConnList list = {0}; SConnList list = {0};
taosHashPut((SHashObj*)pool, key, klen, (void*)&list, sizeof(list)); (void)taosHashPut((SHashObj*)pool, key, klen, (void*)&list, sizeof(list));
plist = taosHashGet(pool, key, klen); plist = taosHashGet(pool, key, klen);
SMsgList* nList = taosMemoryCalloc(1, sizeof(SMsgList)); SMsgList* nList = taosMemoryCalloc(1, sizeof(SMsgList));
@ -800,8 +800,8 @@ static void addConnToPool(void* pool, SCliConn* conn) {
SCliThrd* thrd = conn->hostThrd; SCliThrd* thrd = conn->hostThrd;
if (conn->timer != NULL) { if (conn->timer != NULL) {
uv_timer_stop(conn->timer); (void)uv_timer_stop(conn->timer);
taosArrayPush(thrd->timerList, &conn->timer); (void)taosArrayPush(thrd->timerList, &conn->timer);
conn->timer->data = NULL; conn->timer->data = NULL;
conn->timer = NULL; conn->timer = NULL;
} }
@ -827,7 +827,7 @@ static void addConnToPool(void* pool, SCliConn* conn) {
pMsg->ctx->task = NULL; pMsg->ctx->task = NULL;
transCtxMerge(&conn->ctx, &pMsg->ctx->appCtx); transCtxMerge(&conn->ctx, &pMsg->ctx->appCtx);
transQueuePush(&conn->cliMsgs, pMsg); (void)transQueuePush(&conn->cliMsgs, pMsg);
conn->status = ConnNormal; conn->status = ConnNormal;
cliSend(conn); cliSend(conn);
@ -851,8 +851,8 @@ static void addConnToPool(void* pool, SCliConn* conn) {
} }
static int32_t allocConnRef(SCliConn* conn, bool update) { static int32_t allocConnRef(SCliConn* conn, bool update) {
if (update) { if (update) {
transReleaseExHandle(transGetRefMgt(), conn->refId); (void)transReleaseExHandle(transGetRefMgt(), conn->refId);
transRemoveExHandle(transGetRefMgt(), conn->refId); (void)transRemoveExHandle(transGetRefMgt(), conn->refId);
conn->refId = -1; conn->refId = -1;
} }
@ -887,8 +887,8 @@ static int32_t allocConnRef(SCliConn* conn, bool update) {
static int32_t specifyConnRef(SCliConn* conn, bool update, int64_t handle) { static int32_t specifyConnRef(SCliConn* conn, bool update, int64_t handle) {
if (update) { if (update) {
transReleaseExHandle(transGetRefMgt(), conn->refId); (void)transReleaseExHandle(transGetRefMgt(), conn->refId);
transRemoveExHandle(transGetRefMgt(), conn->refId); (void)transRemoveExHandle(transGetRefMgt(), conn->refId);
conn->refId = -1; conn->refId = -1;
} }
SExHandle* exh = transAcquireExHandle(transGetRefMgt(), handle); SExHandle* exh = transAcquireExHandle(transGetRefMgt(), handle);
@ -982,7 +982,7 @@ static int32_t cliCreateConn(SCliThrd* pThrd, SCliConn** pCliConn) {
} }
tDebug("no available timer, create a timer %p", timer); tDebug("no available timer, create a timer %p", timer);
uv_timer_init(pThrd->loop, timer); (void)uv_timer_init(pThrd->loop, timer);
} }
timer->data = conn; timer->data = conn;
@ -1000,7 +1000,7 @@ static int32_t cliCreateConn(SCliThrd* pThrd, SCliConn** pCliConn) {
conn->broken = false; conn->broken = false;
transRefCliHandle(conn); transRefCliHandle(conn);
atomic_add_fetch_32(&pThrd->connCount, 1); (void)atomic_add_fetch_32(&pThrd->connCount, 1);
TAOS_CHECK_GOTO(allocConnRef(conn, false), NULL, _failed); TAOS_CHECK_GOTO(allocConnRef(conn, false), NULL, _failed);
@ -1038,8 +1038,8 @@ static void cliDestroyConn(SCliConn* conn, bool clear) {
conn->list = NULL; conn->list = NULL;
transReleaseExHandle(transGetRefMgt(), conn->refId); (void)transReleaseExHandle(transGetRefMgt(), conn->refId);
transRemoveExHandle(transGetRefMgt(), conn->refId); (void)transRemoveExHandle(transGetRefMgt(), conn->refId);
conn->refId = -1; conn->refId = -1;
if (conn->task != NULL) { if (conn->task != NULL) {
@ -1047,15 +1047,15 @@ static void cliDestroyConn(SCliConn* conn, bool clear) {
conn->task = NULL; conn->task = NULL;
} }
if (conn->timer != NULL) { if (conn->timer != NULL) {
uv_timer_stop(conn->timer); (void)uv_timer_stop(conn->timer);
conn->timer->data = NULL; conn->timer->data = NULL;
taosArrayPush(pThrd->timerList, &conn->timer); (void)taosArrayPush(pThrd->timerList, &conn->timer);
conn->timer = NULL; conn->timer = NULL;
} }
if (clear) { if (clear) {
if (!uv_is_closing((uv_handle_t*)conn->stream)) { if (!uv_is_closing((uv_handle_t*)conn->stream)) {
uv_read_stop(conn->stream); (void)uv_read_stop(conn->stream);
uv_close((uv_handle_t*)conn->stream, cliDestroy); uv_close((uv_handle_t*)conn->stream, cliDestroy);
} }
} }
@ -1067,16 +1067,16 @@ static void cliDestroy(uv_handle_t* handle) {
SCliConn* conn = handle->data; SCliConn* conn = handle->data;
SCliThrd* pThrd = conn->hostThrd; SCliThrd* pThrd = conn->hostThrd;
if (conn->timer != NULL) { if (conn->timer != NULL) {
uv_timer_stop(conn->timer); (void)uv_timer_stop(conn->timer);
taosArrayPush(pThrd->timerList, &conn->timer); (void)taosArrayPush(pThrd->timerList, &conn->timer);
conn->timer->data = NULL; conn->timer->data = NULL;
conn->timer = NULL; conn->timer = NULL;
} }
atomic_sub_fetch_32(&pThrd->connCount, 1); (void)atomic_sub_fetch_32(&pThrd->connCount, 1);
transReleaseExHandle(transGetRefMgt(), conn->refId); (void)transReleaseExHandle(transGetRefMgt(), conn->refId);
transRemoveExHandle(transGetRefMgt(), conn->refId); (void)transRemoveExHandle(transGetRefMgt(), conn->refId);
taosMemoryFree(conn->dstAddr); taosMemoryFree(conn->dstAddr);
taosMemoryFree(conn->stream); taosMemoryFree(conn->stream);
@ -1084,7 +1084,7 @@ static void cliDestroy(uv_handle_t* handle) {
tTrace("%s conn %p destroy successfully", CONN_GET_INST_LABEL(conn), conn); tTrace("%s conn %p destroy successfully", CONN_GET_INST_LABEL(conn), conn);
transReqQueueClear(&conn->wreqQueue); transReqQueueClear(&conn->wreqQueue);
transDestroyBuffer(&conn->readBuf); (void)transDestroyBuffer(&conn->readBuf);
taosMemoryFree(conn); taosMemoryFree(conn);
} }
@ -1093,7 +1093,7 @@ static bool cliHandleNoResp(SCliConn* conn) {
if (!transQueueEmpty(&conn->cliMsgs)) { if (!transQueueEmpty(&conn->cliMsgs)) {
SCliMsg* pMsg = transQueueGet(&conn->cliMsgs, 0); SCliMsg* pMsg = transQueueGet(&conn->cliMsgs, 0);
if (REQUEST_NO_RESP(&pMsg->msg)) { if (REQUEST_NO_RESP(&pMsg->msg)) {
transQueuePop(&conn->cliMsgs); (void)transQueuePop(&conn->cliMsgs);
destroyCmsg(pMsg); destroyCmsg(pMsg);
res = true; res = true;
} }
@ -1138,7 +1138,7 @@ static void cliSendCb(uv_write_t* req, int status) {
tTrace("%s conn %p no resp required", CONN_GET_INST_LABEL(pConn), pConn); tTrace("%s conn %p no resp required", CONN_GET_INST_LABEL(pConn), pConn);
return; return;
} }
uv_read_start((uv_stream_t*)pConn->stream, cliAllocRecvBufferCb, cliRecvCb); (void)uv_read_start((uv_stream_t*)pConn->stream, cliAllocRecvBufferCb, cliRecvCb);
} }
void cliSendBatch(SCliConn* pConn) { void cliSendBatch(SCliConn* pConn) {
SCliThrd* pThrd = pConn->hostThrd; SCliThrd* pThrd = pConn->hostThrd;
@ -1197,7 +1197,7 @@ void cliSendBatch(SCliConn* pConn) {
req->data = pConn; req->data = pConn;
tDebug("%s conn %p start to send batch msg, batch size:%d, msgLen:%d", CONN_GET_INST_LABEL(pConn), pConn, tDebug("%s conn %p start to send batch msg, batch size:%d, msgLen:%d", CONN_GET_INST_LABEL(pConn), pConn,
pBatch->wLen, pBatch->batchSize); pBatch->wLen, pBatch->batchSize);
uv_write(req, (uv_stream_t*)pConn->stream, wb, wLen, cliSendBatchCb); (void)uv_write(req, (uv_stream_t*)pConn->stream, wb, wLen, cliSendBatchCb);
taosMemoryFree(wb); taosMemoryFree(wb);
} }
void cliSend(SCliConn* pConn) { void cliSend(SCliConn* pConn) {
@ -1252,13 +1252,13 @@ void cliSend(SCliConn* pConn) {
if (timer == NULL) { if (timer == NULL) {
timer = taosMemoryCalloc(1, sizeof(uv_timer_t)); timer = taosMemoryCalloc(1, sizeof(uv_timer_t));
tDebug("no available timer, create a timer %p", timer); tDebug("no available timer, create a timer %p", timer);
uv_timer_init(pThrd->loop, timer); (void)uv_timer_init(pThrd->loop, timer);
} }
timer->data = pConn; timer->data = pConn;
pConn->timer = timer; pConn->timer = timer;
tGTrace("%s conn %p start timer for msg:%s", CONN_GET_INST_LABEL(pConn), pConn, TMSG_INFO(pMsg->msgType)); tGTrace("%s conn %p start timer for msg:%s", CONN_GET_INST_LABEL(pConn), pConn, TMSG_INFO(pMsg->msgType));
uv_timer_start((uv_timer_t*)pConn->timer, cliReadTimeoutCb, TRANS_READ_TIMEOUT, 0); (void)uv_timer_start((uv_timer_t*)pConn->timer, cliReadTimeoutCb, TRANS_READ_TIMEOUT, 0);
} }
if (pHead->comp == 0 && pMsg->info.compressed == 0 && pConn->clientIp != pConn->serverIp) { if (pHead->comp == 0 && pMsg->info.compressed == 0 && pConn->clientIp != pConn->serverIp) {
@ -1345,9 +1345,9 @@ static void cliHandleBatchReq(SCliBatch* pBatch, SCliThrd* pThrd) {
uint32_t ipaddr = 0; uint32_t ipaddr = 0;
if ((code = cliGetIpFromFqdnCache(pThrd->fqdn2ipCache, pList->ip, &ipaddr)) != 0) { if ((code = cliGetIpFromFqdnCache(pThrd->fqdn2ipCache, pList->ip, &ipaddr)) != 0) {
uv_timer_stop(conn->timer); (void)uv_timer_stop(conn->timer);
conn->timer->data = NULL; conn->timer->data = NULL;
taosArrayPush(pThrd->timerList, &conn->timer); (void)taosArrayPush(pThrd->timerList, &conn->timer);
conn->timer = NULL; conn->timer = NULL;
cliHandleFastFail(conn, code); cliHandleFastFail(conn, code);
return; return;
@ -1381,9 +1381,9 @@ static void cliHandleBatchReq(SCliBatch* pBatch, SCliThrd* pThrd) {
ret = uv_tcp_connect(&conn->connReq, (uv_tcp_t*)(conn->stream), (const struct sockaddr*)&addr, cliConnCb); ret = uv_tcp_connect(&conn->connReq, (uv_tcp_t*)(conn->stream), (const struct sockaddr*)&addr, cliConnCb);
if (ret != 0) { if (ret != 0) {
uv_timer_stop(conn->timer); (void)uv_timer_stop(conn->timer);
conn->timer->data = NULL; conn->timer->data = NULL;
taosArrayPush(pThrd->timerList, &conn->timer); (void)taosArrayPush(pThrd->timerList, &conn->timer);
conn->timer = NULL; conn->timer = NULL;
cliMayUpdateFqdnCache(pThrd->fqdn2ipCache, conn->dstAddr); cliMayUpdateFqdnCache(pThrd->fqdn2ipCache, conn->dstAddr);
@ -1461,7 +1461,7 @@ static void cliHandleFastFail(SCliConn* pConn, int status) {
} }
} else { } else {
SFailFastItem item = {.count = 1, .timestamp = cTimestamp}; SFailFastItem item = {.count = 1, .timestamp = cTimestamp};
taosHashPut(pThrd->failFastCache, pConn->dstAddr, strlen(pConn->dstAddr), &item, sizeof(SFailFastItem)); (void)taosHashPut(pThrd->failFastCache, pConn->dstAddr, strlen(pConn->dstAddr), &item, sizeof(SFailFastItem));
} }
} }
} else { } else {
@ -1499,12 +1499,12 @@ void cliConnCb(uv_connect_t* req, int status) {
struct sockaddr peername, sockname; struct sockaddr peername, sockname;
int addrlen = sizeof(peername); int addrlen = sizeof(peername);
uv_tcp_getpeername((uv_tcp_t*)pConn->stream, &peername, &addrlen); (void)uv_tcp_getpeername((uv_tcp_t*)pConn->stream, &peername, &addrlen);
transSockInfo2Str(&peername, pConn->dst); (void)transSockInfo2Str(&peername, pConn->dst);
addrlen = sizeof(sockname); addrlen = sizeof(sockname);
uv_tcp_getsockname((uv_tcp_t*)pConn->stream, &sockname, &addrlen); (void)uv_tcp_getsockname((uv_tcp_t*)pConn->stream, &sockname, &addrlen);
transSockInfo2Str(&sockname, pConn->src); (void)transSockInfo2Str(&sockname, pConn->src);
struct sockaddr_in addr = *(struct sockaddr_in*)&sockname; struct sockaddr_in addr = *(struct sockaddr_in*)&sockname;
struct sockaddr_in saddr = *(struct sockaddr_in*)&peername; struct sockaddr_in saddr = *(struct sockaddr_in*)&peername;
@ -1554,8 +1554,8 @@ static void cliHandleQuit(SCliMsg* pMsg, SCliThrd* pThrd) {
tDebug("cli work thread %p start to quit", pThrd); tDebug("cli work thread %p start to quit", pThrd);
destroyCmsg(pMsg); destroyCmsg(pMsg);
destroyConnPool(pThrd); (void)destroyConnPool(pThrd);
uv_walk(pThrd->loop, cliWalkCb, NULL); (void)uv_walk(pThrd->loop, cliWalkCb, NULL);
} }
static void cliHandleRelease(SCliMsg* pMsg, SCliThrd* pThrd) { static void cliHandleRelease(SCliMsg* pMsg, SCliThrd* pThrd) {
int64_t refId = (int64_t)(pMsg->msg.info.handle); int64_t refId = (int64_t)(pMsg->msg.info.handle);
@ -1570,7 +1570,7 @@ static void cliHandleRelease(SCliMsg* pMsg, SCliThrd* pThrd) {
SCliConn* conn = exh->handle; SCliConn* conn = exh->handle;
taosRUnLockLatch(&exh->latch); taosRUnLockLatch(&exh->latch);
transReleaseExHandle(transGetRefMgt(), refId); (void)transReleaseExHandle(transGetRefMgt(), refId);
tDebug("%s conn %p start to release to inst", CONN_GET_INST_LABEL(conn), conn); tDebug("%s conn %p start to release to inst", CONN_GET_INST_LABEL(conn), conn);
if (T_REF_VAL_GET(conn) == 2) { if (T_REF_VAL_GET(conn) == 2) {
@ -1705,7 +1705,7 @@ static void cliMayUpdateFqdnCache(SHashObj* cache, char* dst) {
if (i > 0) { if (i > 0) {
char fqdn[TSDB_FQDN_LEN + 1] = {0}; char fqdn[TSDB_FQDN_LEN + 1] = {0};
memcpy(fqdn, dst, i); memcpy(fqdn, dst, i);
cliUpdateFqdnCache(cache, fqdn); (void)cliUpdateFqdnCache(cache, fqdn);
} }
} }
@ -1742,7 +1742,7 @@ void cliHandleReq(SCliMsg* pMsg, SCliThrd* pThrd) {
if (ignore == true) { if (ignore == true) {
// persist conn already release by server // persist conn already release by server
STransMsg resp = {0}; STransMsg resp = {0};
cliBuildExceptResp(pMsg, &resp); (void)cliBuildExceptResp(pMsg, &resp);
// refactorr later // refactorr later
resp.info.cliVer = pTransInst->compatibilityVer; resp.info.cliVer = pTransInst->compatibilityVer;
@ -1780,16 +1780,16 @@ void cliHandleReq(SCliMsg* pMsg, SCliThrd* pThrd) {
if (refId != 0) specifyConnRef(conn, true, refId); if (refId != 0) specifyConnRef(conn, true, refId);
transCtxMerge(&conn->ctx, &pMsg->ctx->appCtx); transCtxMerge(&conn->ctx, &pMsg->ctx->appCtx);
transQueuePush(&conn->cliMsgs, pMsg); (void)transQueuePush(&conn->cliMsgs, pMsg);
conn->dstAddr = taosStrdup(addr); conn->dstAddr = taosStrdup(addr);
uint32_t ipaddr; uint32_t ipaddr;
int32_t code = cliGetIpFromFqdnCache(pThrd->fqdn2ipCache, fqdn, &ipaddr); int32_t code = cliGetIpFromFqdnCache(pThrd->fqdn2ipCache, fqdn, &ipaddr);
if (code != 0) { if (code != 0) {
uv_timer_stop(conn->timer); (void)uv_timer_stop(conn->timer);
conn->timer->data = NULL; conn->timer->data = NULL;
taosArrayPush(pThrd->timerList, &conn->timer); (void)taosArrayPush(pThrd->timerList, &conn->timer);
conn->timer = NULL; conn->timer = NULL;
cliHandleExcept(conn, code); cliHandleExcept(conn, code);
@ -1829,14 +1829,14 @@ void cliHandleReq(SCliMsg* pMsg, SCliThrd* pThrd) {
if (ret != 0) { if (ret != 0) {
uv_timer_stop(conn->timer); uv_timer_stop(conn->timer);
conn->timer->data = NULL; conn->timer->data = NULL;
taosArrayPush(pThrd->timerList, &conn->timer); (void)taosArrayPush(pThrd->timerList, &conn->timer);
conn->timer = NULL; conn->timer = NULL;
cliMayUpdateFqdnCache(pThrd->fqdn2ipCache, conn->dstAddr); cliMayUpdateFqdnCache(pThrd->fqdn2ipCache, conn->dstAddr);
cliHandleFastFail(conn, ret); cliHandleFastFail(conn, ret);
return; return;
} }
uv_timer_start(conn->timer, cliConnTimeout, TRANS_CONN_TIMEOUT, 0); (void)uv_timer_start(conn->timer, cliConnTimeout, TRANS_CONN_TIMEOUT, 0);
} }
tGTrace("%s conn %p ready", pTransInst->label, conn); tGTrace("%s conn %p ready", pTransInst->label, conn);
} }
@ -1989,9 +1989,9 @@ static void cliAsyncCb(uv_async_t* handle) {
// batch process to avoid to lock/unlock frequently // batch process to avoid to lock/unlock frequently
queue wq; queue wq;
taosThreadMutexLock(&item->mtx); (void)taosThreadMutexLock(&item->mtx);
QUEUE_MOVE(&item->qmsg, &wq); QUEUE_MOVE(&item->qmsg, &wq);
taosThreadMutexUnlock(&item->mtx); (void)taosThreadMutexUnlock(&item->mtx);
int8_t supportBatch = pTransInst->supportBatch; int8_t supportBatch = pTransInst->supportBatch;
if (supportBatch == 0) { if (supportBatch == 0) {
@ -2012,9 +2012,9 @@ static void cliPrepareCb(uv_prepare_t* handle) {
SAsyncItem* item = async->data; SAsyncItem* item = async->data;
queue wq; queue wq;
taosThreadMutexLock(&item->mtx); (void)taosThreadMutexLock(&item->mtx);
QUEUE_MOVE(&item->qmsg, &wq); QUEUE_MOVE(&item->qmsg, &wq);
taosThreadMutexUnlock(&item->mtx); (void)taosThreadMutexUnlock(&item->mtx);
int count = 0; int count = 0;
while (!QUEUE_IS_EMPTY(&wq)) { while (!QUEUE_IS_EMPTY(&wq)) {
@ -2068,7 +2068,7 @@ bool cliRecvReleaseReq(SCliConn* conn, STransMsgHead* pHead) {
tDebug("%s conn %p receive release request, refId:%" PRId64 ", may ignore", CONN_GET_INST_LABEL(conn), conn, tDebug("%s conn %p receive release request, refId:%" PRId64 ", may ignore", CONN_GET_INST_LABEL(conn), conn,
conn->refId); conn->refId);
transClearBuffer(&conn->readBuf); (void)transClearBuffer(&conn->readBuf);
transFreeMsg(transContFromHead((char*)pHead)); transFreeMsg(transContFromHead((char*)pHead));
for (int i = 0; ahandle == 0 && i < transQueueSize(&conn->cliMsgs); i++) { for (int i = 0; ahandle == 0 && i < transQueueSize(&conn->cliMsgs); i++) {
@ -2243,8 +2243,8 @@ static int32_t createThrdObj(void* trans, SCliThrd** ppThrd) {
if (timer == NULL) { if (timer == NULL) {
TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, NULL, _end); TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, NULL, _end);
} }
uv_timer_init(pThrd->loop, timer); (void)uv_timer_init(pThrd->loop, timer);
taosArrayPush(pThrd->timerList, &timer); (void)taosArrayPush(pThrd->timerList, &timer);
} }
pThrd->pool = createConnPool(4); pThrd->pool = createConnPool(4);
@ -2288,7 +2288,7 @@ static int32_t createThrdObj(void* trans, SCliThrd** ppThrd) {
_end: _end:
if (pThrd) { if (pThrd) {
uv_loop_close(pThrd->loop); (void)uv_loop_close(pThrd->loop);
taosMemoryFree(pThrd->loop); taosMemoryFree(pThrd->loop);
taosMemoryFree(pThrd->prepare); taosMemoryFree(pThrd->prepare);
taosThreadMutexDestroy(&pThrd->msgMtx); taosThreadMutexDestroy(&pThrd->msgMtx);
@ -2312,9 +2312,9 @@ static void destroyThrdObj(SCliThrd* pThrd) {
return; return;
} }
taosThreadJoin(pThrd->thread, NULL); (void)taosThreadJoin(pThrd->thread, NULL);
CLI_RELEASE_UV(pThrd->loop); CLI_RELEASE_UV(pThrd->loop);
taosThreadMutexDestroy(&pThrd->msgMtx); (void)taosThreadMutexDestroy(&pThrd->msgMtx);
TRANS_DESTROY_ASYNC_POOL_MSG(pThrd->asyncPool, SCliMsg, destroyCmsgWrapper, (void*)pThrd); TRANS_DESTROY_ASYNC_POOL_MSG(pThrd->asyncPool, SCliMsg, destroyCmsgWrapper, (void*)pThrd);
transAsyncPoolDestroy(pThrd->asyncPool); transAsyncPoolDestroy(pThrd->asyncPool);
@ -2381,9 +2381,9 @@ void cliWalkCb(uv_handle_t* handle, void* arg) {
if (uv_handle_get_type(handle) == UV_TIMER) { if (uv_handle_get_type(handle) == UV_TIMER) {
// do nothing // do nothing
} else { } else {
uv_read_stop((uv_stream_t*)handle); (void)uv_read_stop((uv_stream_t*)handle);
} }
uv_close(handle, cliDestroy); (void)uv_close(handle, cliDestroy);
} }
} }
@ -2421,7 +2421,7 @@ static void cliSchedMsgToDebug(SCliMsg* pMsg, char* label) {
STransConnCtx* pCtx = pMsg->ctx; STransConnCtx* pCtx = pMsg->ctx;
STraceId* trace = &pMsg->msg.info.traceId; STraceId* trace = &pMsg->msg.info.traceId;
char tbuf[512] = {0}; char tbuf[512] = {0};
epsetToStr(&pCtx->epSet, tbuf, tListLen(tbuf)); (void)epsetToStr(&pCtx->epSet, tbuf, tListLen(tbuf));
tGDebug("%s retry on next node,use:%s, step: %d,timeout:%" PRId64 "", label, tbuf, pCtx->retryStep, tGDebug("%s retry on next node,use:%s, step: %d,timeout:%" PRId64 "", label, tbuf, pCtx->retryStep,
pCtx->retryNextInterval); pCtx->retryNextInterval);
return; return;
@ -2436,7 +2436,7 @@ static void cliSchedMsgToNextNode(SCliMsg* pMsg, SCliThrd* pThrd) {
arg->param1 = pMsg; arg->param1 = pMsg;
arg->param2 = pThrd; arg->param2 = pThrd;
transDQSched(pThrd->delayQueue, doDelayTask, arg, pCtx->retryNextInterval); (void)transDQSched(pThrd->delayQueue, doDelayTask, arg, pCtx->retryNextInterval);
} }
FORCE_INLINE bool cliTryExtractEpSet(STransMsg* pResp, SEpSet* dst) { FORCE_INLINE bool cliTryExtractEpSet(STransMsg* pResp, SEpSet* dst) {
@ -2654,7 +2654,7 @@ int cliAppCb(SCliConn* pConn, STransMsg* pResp, SCliMsg* pMsg) {
if (hasEpSet) { if (hasEpSet) {
if (rpcDebugFlag & DEBUG_TRACE) { if (rpcDebugFlag & DEBUG_TRACE) {
char tbuf[512] = {0}; char tbuf[512] = {0};
epsetToStr(&pCtx->epSet, tbuf, tListLen(tbuf)); (void)epsetToStr(&pCtx->epSet, tbuf, tListLen(tbuf));
tGTrace("%s conn %p extract epset from msg", CONN_GET_INST_LABEL(pConn), pConn); tGTrace("%s conn %p extract epset from msg", CONN_GET_INST_LABEL(pConn), pConn);
} }
} }
@ -2666,7 +2666,7 @@ int cliAppCb(SCliConn* pConn, STransMsg* pResp, SCliMsg* pMsg) {
} else { } else {
memcpy((char*)pCtx->pRsp, (char*)pResp, sizeof(*pResp)); memcpy((char*)pCtx->pRsp, (char*)pResp, sizeof(*pResp));
} }
tsem_post(pCtx->pSem); (void)tsem_post(pCtx->pSem);
pCtx->pRsp = NULL; pCtx->pRsp = NULL;
} else { } else {
STransSyncMsg* pSyncMsg = taosAcquireRef(transGetSyncMsgMgt(), pCtx->syncMsgRef); STransSyncMsg* pSyncMsg = taosAcquireRef(transGetSyncMsgMgt(), pCtx->syncMsgRef);
@ -2676,8 +2676,8 @@ int cliAppCb(SCliConn* pConn, STransMsg* pResp, SCliMsg* pMsg) {
pSyncMsg->hasEpSet = 1; pSyncMsg->hasEpSet = 1;
epsetAssign(&pSyncMsg->epSet, &pCtx->epSet); epsetAssign(&pSyncMsg->epSet, &pCtx->epSet);
} }
tsem2_post(pSyncMsg->pSem); (void)tsem2_post(pSyncMsg->pSem);
taosReleaseRef(transGetSyncMsgMgt(), pCtx->syncMsgRef); (void)taosReleaseRef(transGetSyncMsgMgt(), pCtx->syncMsgRef);
} else { } else {
rpcFreeCont(pResp->pCont); rpcFreeCont(pResp->pCont);
} }
@ -2746,7 +2746,7 @@ static FORCE_INLINE SCliThrd* transGetWorkThrdFromHandle(STrans* trans, int64_t
pThrd = exh->pThrd; pThrd = exh->pThrd;
taosWUnLockLatch(&exh->latch); taosWUnLockLatch(&exh->latch);
transReleaseExHandle(transGetRefMgt(), handle); (void)transReleaseExHandle(transGetRefMgt(), handle);
return pThrd; return pThrd;
} }
@ -2839,7 +2839,7 @@ int transSendRequest(void* shandle, const SEpSet* pEpSet, STransMsg* pReq, STran
SCliThrd* pThrd = transGetWorkThrd(pTransInst, handle); SCliThrd* pThrd = transGetWorkThrd(pTransInst, handle);
if (pThrd == NULL) { if (pThrd == NULL) {
transFreeMsg(pReq->pCont); transFreeMsg(pReq->pCont);
transReleaseExHandle(transGetInstMgt(), (int64_t)shandle); (void)transReleaseExHandle(transGetInstMgt(), (int64_t)shandle);
return TSDB_CODE_RPC_BROKEN_LINK; return TSDB_CODE_RPC_BROKEN_LINK;
} }
if (handle != 0) { if (handle != 0) {
@ -2854,19 +2854,19 @@ int transSendRequest(void* shandle, const SEpSet* pEpSet, STransMsg* pReq, STran
QUEUE_PUSH(&exh->q, &pCliMsg->seqq); QUEUE_PUSH(&exh->q, &pCliMsg->seqq);
taosWUnLockLatch(&exh->latch); taosWUnLockLatch(&exh->latch);
tDebug("msg refId: %" PRId64 "", handle); tDebug("msg refId: %" PRId64 "", handle);
transReleaseExHandle(transGetInstMgt(), (int64_t)shandle); (void)transReleaseExHandle(transGetInstMgt(), (int64_t)shandle);
return 0; return 0;
} }
exh->inited = 1; exh->inited = 1;
taosWUnLockLatch(&exh->latch); taosWUnLockLatch(&exh->latch);
transReleaseExHandle(transGetRefMgt(), handle); (void)transReleaseExHandle(transGetRefMgt(), handle);
} }
} }
SCliMsg* pCliMsg = NULL; SCliMsg* pCliMsg = NULL;
code = transInitMsg(shandle, pEpSet, pReq, ctx, &pCliMsg); code = transInitMsg(shandle, pEpSet, pReq, ctx, &pCliMsg);
if (code != 0) { if (code != 0) {
transReleaseExHandle(transGetInstMgt(), (int64_t)shandle); (void)transReleaseExHandle(transGetInstMgt(), (int64_t)shandle);
return code; return code;
} }
@ -2875,10 +2875,10 @@ int transSendRequest(void* shandle, const SEpSet* pEpSet, STransMsg* pReq, STran
EPSET_GET_INUSE_IP(pEpSet), EPSET_GET_INUSE_PORT(pEpSet), pReq->info.ahandle); EPSET_GET_INUSE_IP(pEpSet), EPSET_GET_INUSE_PORT(pEpSet), pReq->info.ahandle);
if ((code = transAsyncSend(pThrd->asyncPool, &(pCliMsg->q))) != 0) { if ((code = transAsyncSend(pThrd->asyncPool, &(pCliMsg->q))) != 0) {
destroyCmsg(pCliMsg); destroyCmsg(pCliMsg);
transReleaseExHandle(transGetInstMgt(), (int64_t)shandle); (void)transReleaseExHandle(transGetInstMgt(), (int64_t)shandle);
return (code == TSDB_CODE_RPC_ASYNC_MODULE_QUIT ? TSDB_CODE_RPC_MODULE_QUIT : code); return (code == TSDB_CODE_RPC_ASYNC_MODULE_QUIT ? TSDB_CODE_RPC_MODULE_QUIT : code);
} }
transReleaseExHandle(transGetInstMgt(), (int64_t)shandle); (void)transReleaseExHandle(transGetInstMgt(), (int64_t)shandle);
return 0; return 0;
} }
@ -2958,11 +2958,11 @@ int transSendRecv(void* shandle, const SEpSet* pEpSet, STransMsg* pReq, STransMs
_RETURN: _RETURN:
tsem_destroy(sem); tsem_destroy(sem);
taosMemoryFree(sem); taosMemoryFree(sem);
transReleaseExHandle(transGetInstMgt(), (int64_t)shandle); (void)transReleaseExHandle(transGetInstMgt(), (int64_t)shandle);
taosMemoryFree(pTransRsp); taosMemoryFree(pTransRsp);
return code; return code;
_RETURN1: _RETURN1:
transReleaseExHandle(transGetInstMgt(), (int64_t)shandle); (void)transReleaseExHandle(transGetInstMgt(), (int64_t)shandle);
taosMemoryFree(pTransRsp); taosMemoryFree(pTransRsp);
taosMemoryFree(pReq->pCont); taosMemoryFree(pReq->pCont);
return code; return code;
@ -2998,7 +2998,7 @@ int32_t transCreateSyncMsg(STransMsg* pTransMsg, int64_t* refId) {
return 0; return 0;
_EXIT: _EXIT:
tsem2_destroy(sem); (void)tsem2_destroy(sem);
taosMemoryFree(sem); taosMemoryFree(sem);
taosMemoryFree(pSyncMsg); taosMemoryFree(pSyncMsg);
return code; return code;
@ -3083,14 +3083,14 @@ int transSendRecvWithTimeout(void* shandle, SEpSet* pEpSet, STransMsg* pReq, STr
code = 0; code = 0;
} }
_RETURN: _RETURN:
transReleaseExHandle(transGetInstMgt(), (int64_t)shandle); (void)transReleaseExHandle(transGetInstMgt(), (int64_t)shandle);
taosReleaseRef(transGetSyncMsgMgt(), ref); (void)taosReleaseRef(transGetSyncMsgMgt(), ref);
taosRemoveRef(transGetSyncMsgMgt(), ref); taosRemoveRef(transGetSyncMsgMgt(), ref);
return code; return code;
_RETURN2: _RETURN2:
transFreeMsg(pReq->pCont); transFreeMsg(pReq->pCont);
taosMemoryFree(pTransMsg); taosMemoryFree(pTransMsg);
transReleaseExHandle(transGetInstMgt(), (int64_t)shandle); (void)transReleaseExHandle(transGetInstMgt(), (int64_t)shandle);
return code; return code;
} }
/* /*
@ -3141,7 +3141,7 @@ int transSetDefaultAddr(void* shandle, const char* ip, const char* fqdn) {
} }
} }
transReleaseExHandle(transGetInstMgt(), (int64_t)shandle); (void)transReleaseExHandle(transGetInstMgt(), (int64_t)shandle);
return code; return code;
} }

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

@ -237,7 +237,7 @@ bool transReadComplete(SConnBuffer* connBuf) {
int transSetConnOption(uv_tcp_t* stream, int keepalive) { int transSetConnOption(uv_tcp_t* stream, int keepalive) {
#if defined(WINDOWS) || defined(DARWIN) #if defined(WINDOWS) || defined(DARWIN)
#else #else
uv_tcp_keepalive(stream, 1, keepalive); return uv_tcp_keepalive(stream, 1, keepalive);
#endif #endif
return uv_tcp_nodelay(stream, 1); return uv_tcp_nodelay(stream, 1);
// int ret = uv_tcp_keepalive(stream, 5, 60); // int ret = uv_tcp_keepalive(stream, 5, 60);
@ -269,7 +269,7 @@ int32_t transAsyncPoolCreate(uv_loop_t* loop, int sz, void* arg, AsyncCB cb, SAs
} }
item->pThrd = arg; item->pThrd = arg;
QUEUE_INIT(&item->qmsg); QUEUE_INIT(&item->qmsg);
taosThreadMutexInit(&item->mtx, NULL); (void)taosThreadMutexInit(&item->mtx, NULL);
async->data = item; async->data = item;
err = uv_async_init(loop, async, cb); err = uv_async_init(loop, async, cb);
@ -298,7 +298,7 @@ void transAsyncPoolDestroy(SAsyncPool* pool) {
SAsyncItem* item = async->data; SAsyncItem* item = async->data;
if (item == NULL) continue; if (item == NULL) continue;
taosThreadMutexDestroy(&item->mtx); (void)taosThreadMutexDestroy(&item->mtx);
taosMemoryFree(item); taosMemoryFree(item);
} }
taosMemoryFree(pool->asyncs); taosMemoryFree(pool->asyncs);
@ -325,9 +325,9 @@ int transAsyncSend(SAsyncPool* pool, queue* q) {
uv_async_t* async = &(pool->asyncs[idx]); uv_async_t* async = &(pool->asyncs[idx]);
SAsyncItem* item = async->data; SAsyncItem* item = async->data;
taosThreadMutexLock(&item->mtx); (void)taosThreadMutexLock(&item->mtx);
QUEUE_PUSH(&item->qmsg, q); QUEUE_PUSH(&item->qmsg, q);
taosThreadMutexUnlock(&item->mtx); (void)taosThreadMutexUnlock(&item->mtx);
int ret = uv_async_send(async); int ret = uv_async_send(async);
if (ret != 0) { if (ret != 0) {
tError("failed to send async,reason:%s", uv_err_name(ret)); tError("failed to send async,reason:%s", uv_err_name(ret));
@ -391,7 +391,7 @@ void* transCtxDumpVal(STransCtx* ctx, int32_t key) {
return NULL; return NULL;
} }
void* ret = NULL; void* ret = NULL;
(*cVal->clone)(cVal->val, &ret); (void)(*cVal->clone)(cVal->val, &ret);
return ret; return ret;
} }
void* transCtxDumpBrokenlinkVal(STransCtx* ctx, int32_t* msgType) { void* transCtxDumpBrokenlinkVal(STransCtx* ctx, int32_t* msgType) {
@ -399,7 +399,7 @@ void* transCtxDumpBrokenlinkVal(STransCtx* ctx, int32_t* msgType) {
if (ctx->brokenVal.clone == NULL) { if (ctx->brokenVal.clone == NULL) {
return ret; return ret;
} }
(*ctx->brokenVal.clone)(ctx->brokenVal.val, &ret); (void)(*ctx->brokenVal.clone)(ctx->brokenVal.val, &ret);
*msgType = ctx->brokenVal.msgType; *msgType = ctx->brokenVal.msgType;
@ -451,7 +451,7 @@ bool transQueuePush(STransQueue* queue, void* arg) {
if (queue->q == NULL) { if (queue->q == NULL) {
return true; return true;
} }
taosArrayPush(queue->q, &arg); (void)taosArrayPush(queue->q, &arg);
if (taosArrayGetSize(queue->q) > 1) { if (taosArrayGetSize(queue->q) > 1) {
return false; return false;
} }
@ -545,7 +545,7 @@ static void transDQTimeout(uv_timer_t* timer) {
} }
} while (1); } while (1);
if (timeout != 0) { if (timeout != 0) {
uv_timer_start(queue->timer, transDQTimeout, timeout, 0); (void)uv_timer_start(queue->timer, transDQTimeout, timeout, 0);
} }
} }
int32_t transDQCreate(uv_loop_t* loop, SDelayQueue** queue) { int32_t transDQCreate(uv_loop_t* loop, SDelayQueue** queue) {
@ -610,7 +610,7 @@ void transDQDestroy(SDelayQueue* queue, void (*freeFunc)(void* arg)) {
taosMemoryFree(queue); taosMemoryFree(queue);
} }
void transDQCancel(SDelayQueue* queue, SDelayTask* task) { void transDQCancel(SDelayQueue* queue, SDelayTask* task) {
uv_timer_stop(queue->timer); (void)uv_timer_stop(queue->timer);
if (heapSize(queue->heap) <= 0) { if (heapSize(queue->heap) <= 0) {
taosMemoryFree(task->arg); taosMemoryFree(task->arg);
@ -630,7 +630,7 @@ void transDQCancel(SDelayQueue* queue, SDelayTask* task) {
SDelayTask* task = container_of(minNode, SDelayTask, node); SDelayTask* task = container_of(minNode, SDelayTask, node);
uint64_t timeout = now > task->execTime ? now - task->execTime : 0; uint64_t timeout = now > task->execTime ? now - task->execTime : 0;
uv_timer_start(queue->timer, transDQTimeout, timeout, 0); (void)uv_timer_start(queue->timer, transDQTimeout, timeout, 0);
} }
} }
@ -655,7 +655,7 @@ SDelayTask* transDQSched(SDelayQueue* queue, void (*func)(void* arg), void* arg,
tTrace("timer %p put task into delay queue, timeoutMs:%" PRIu64, queue->timer, timeoutMs); tTrace("timer %p put task into delay queue, timeoutMs:%" PRIu64, queue->timer, timeoutMs);
heapInsert(queue->heap, &task->node); heapInsert(queue->heap, &task->node);
uv_timer_start(queue->timer, transDQTimeout, timeoutMs, 0); (void)uv_timer_start(queue->timer, transDQTimeout, timeoutMs, 0);
return task; return task;
} }
@ -703,7 +703,7 @@ static void transInitEnv() {
refMgt = transOpenRefMgt(50000, transDestroyExHandle); refMgt = transOpenRefMgt(50000, transDestroyExHandle);
instMgt = taosOpenRef(50, rpcCloseImpl); instMgt = taosOpenRef(50, rpcCloseImpl);
transSyncMsgMgt = taosOpenRef(50, transDestroySyncMsg); transSyncMsgMgt = taosOpenRef(50, transDestroySyncMsg);
uv_os_setenv("UV_TCP_SINGLE_ACCEPT", "1"); (void)uv_os_setenv("UV_TCP_SINGLE_ACCEPT", "1");
} }
static void transDestroyEnv() { static void transDestroyEnv() {
transCloseRefMgt(refMgt); transCloseRefMgt(refMgt);
@ -734,7 +734,7 @@ int32_t transOpenRefMgt(int size, void (*func)(void*)) {
} }
void transCloseRefMgt(int32_t mgt) { void transCloseRefMgt(int32_t mgt) {
// close ref // close ref
taosCloseRef(mgt); (void)taosCloseRef(mgt);
} }
int64_t transAddExHandle(int32_t refMgt, void* p) { int64_t transAddExHandle(int32_t refMgt, void* p) {
// acquire extern handle // acquire extern handle
@ -769,7 +769,7 @@ void transDestroySyncMsg(void* msg) {
if (msg == NULL) return; if (msg == NULL) return;
STransSyncMsg* pSyncMsg = msg; STransSyncMsg* pSyncMsg = msg;
tsem2_destroy(pSyncMsg->pSem); (void)tsem2_destroy(pSyncMsg->pSem);
taosMemoryFree(pSyncMsg->pSem); taosMemoryFree(pSyncMsg->pSem);
transFreeMsg(pSyncMsg->pRsp->pCont); transFreeMsg(pSyncMsg->pRsp->pCont);
taosMemoryFree(pSyncMsg->pRsp); taosMemoryFree(pSyncMsg->pRsp);

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

@ -186,9 +186,9 @@ static int32_t addHandleToAcceptloop(void* arg);
#define SRV_RELEASE_UV(loop) \ #define SRV_RELEASE_UV(loop) \
do { \ do { \
uv_walk(loop, uvWalkCb, NULL); \ (void)uv_walk(loop, uvWalkCb, NULL); \
uv_run(loop, UV_RUN_DEFAULT); \ (void)uv_run(loop, UV_RUN_DEFAULT); \
uv_loop_close(loop); \ (void)uv_loop_close(loop); \
} while (0); } while (0);
#define ASYNC_ERR_JRET(thrd) \ #define ASYNC_ERR_JRET(thrd) \
@ -484,7 +484,7 @@ static bool uvHandleReq(SSvrConn* pConn) {
pConnInfo->clientPort = pConn->port; pConnInfo->clientPort = pConn->port;
tstrncpy(pConnInfo->user, pConn->user, sizeof(pConnInfo->user)); tstrncpy(pConnInfo->user, pConn->user, sizeof(pConnInfo->user));
transReleaseExHandle(transGetRefMgt(), pConn->refId); (void)transReleaseExHandle(transGetRefMgt(), pConn->refId);
(*pTransInst->cfp)(pTransInst->parent, &transMsg, NULL); (*pTransInst->cfp)(pTransInst->parent, &transMsg, NULL);
return true; return true;
@ -578,7 +578,7 @@ void uvOnSendCb(uv_write_t* req, int status) {
(pTransInst->cfp)(pTransInst->parent, &(conn->regArg.msg), NULL); (pTransInst->cfp)(pTransInst->parent, &(conn->regArg.msg), NULL);
memset(&conn->regArg, 0, sizeof(conn->regArg)); memset(&conn->regArg, 0, sizeof(conn->regArg));
} }
transQueuePop(&conn->srvMsgs); (void)transQueuePop(&conn->srvMsgs);
taosMemoryFree(msg); taosMemoryFree(msg);
msg = (SSvrMsg*)transQueueGet(&conn->srvMsgs, 0); msg = (SSvrMsg*)transQueueGet(&conn->srvMsgs, 0);
@ -634,7 +634,7 @@ static int uvPrepareSendData(SSvrMsg* smsg, uv_buf_t* wb) {
// handle invalid drop_task resp, TD-20098 // handle invalid drop_task resp, TD-20098
if (pConn->inType == TDMT_SCH_DROP_TASK && pMsg->code == TSDB_CODE_VND_INVALID_VGROUP_ID) { if (pConn->inType == TDMT_SCH_DROP_TASK && pMsg->code == TSDB_CODE_VND_INVALID_VGROUP_ID) {
transQueuePop(&pConn->srvMsgs); (void)transQueuePop(&pConn->srvMsgs);
destroySmsg(smsg); destroySmsg(smsg);
return TSDB_CODE_INVALID_MSG; return TSDB_CODE_INVALID_MSG;
} }
@ -690,7 +690,7 @@ static FORCE_INLINE void uvStartSendRespImpl(SSvrMsg* smsg) {
transRefSrvHandle(pConn); transRefSrvHandle(pConn);
uv_write_t* req = transReqQueuePush(&pConn->wreqQueue); uv_write_t* req = transReqQueuePush(&pConn->wreqQueue);
uv_write(req, (uv_stream_t*)pConn->pTcp, &wb, 1, uvOnSendCb); (void)uv_write(req, (uv_stream_t*)pConn->pTcp, &wb, 1, uvOnSendCb);
} }
static void uvStartSendResp(SSvrMsg* smsg) { static void uvStartSendResp(SSvrMsg* smsg) {
// impl // impl
@ -742,9 +742,9 @@ void uvWorkerAsyncCb(uv_async_t* handle) {
queue wq; queue wq;
// batch process to avoid to lock/unlock frequently // batch process to avoid to lock/unlock frequently
taosThreadMutexLock(&item->mtx); (void)taosThreadMutexLock(&item->mtx);
QUEUE_MOVE(&item->qmsg, &wq); QUEUE_MOVE(&item->qmsg, &wq);
taosThreadMutexUnlock(&item->mtx); (void)taosThreadMutexUnlock(&item->mtx);
while (!QUEUE_IS_EMPTY(&wq)) { while (!QUEUE_IS_EMPTY(&wq)) {
queue* head = QUEUE_HEAD(&wq); queue* head = QUEUE_HEAD(&wq);
@ -767,12 +767,12 @@ void uvWorkerAsyncCb(uv_async_t* handle) {
SExHandle* exh2 = transAcquireExHandle(transGetRefMgt(), refId); SExHandle* exh2 = transAcquireExHandle(transGetRefMgt(), refId);
if (exh2 == NULL || exh1 != exh2) { if (exh2 == NULL || exh1 != exh2) {
tTrace("handle except msg %p, ignore it", exh1); tTrace("handle except msg %p, ignore it", exh1);
transReleaseExHandle(transGetRefMgt(), refId); (void)transReleaseExHandle(transGetRefMgt(), refId);
destroySmsg(msg); destroySmsg(msg);
continue; continue;
} }
msg->pConn = exh1->handle; msg->pConn = exh1->handle;
transReleaseExHandle(transGetRefMgt(), refId); (void)transReleaseExHandle(transGetRefMgt(), refId);
(*transAsyncHandle[msg->type])(msg, pThrd); (*transAsyncHandle[msg->type])(msg, pThrd);
} }
} }
@ -810,7 +810,7 @@ static bool uvRecvReleaseReq(SSvrConn* pConn, STransMsgHead* pHead) {
tTrace("conn %p received release request", pConn); tTrace("conn %p received release request", pConn);
STraceId traceId = pHead->traceId; STraceId traceId = pHead->traceId;
transClearBuffer(&pConn->readBuf); (void)transClearBuffer(&pConn->readBuf);
transFreeMsg(transContFromHead((char*)pHead)); transFreeMsg(transContFromHead((char*)pHead));
if (pConn->status != ConnAcquire) { if (pConn->status != ConnAcquire) {
return true; return true;
@ -846,9 +846,9 @@ static void uvPrepareCb(uv_prepare_t* handle) {
SAsyncItem* item = async->data; SAsyncItem* item = async->data;
queue wq; queue wq;
taosThreadMutexLock(&item->mtx); (void)taosThreadMutexLock(&item->mtx);
QUEUE_MOVE(&item->qmsg, &wq); QUEUE_MOVE(&item->qmsg, &wq);
taosThreadMutexUnlock(&item->mtx); (void)taosThreadMutexUnlock(&item->mtx);
while (!QUEUE_IS_EMPTY(&wq)) { while (!QUEUE_IS_EMPTY(&wq)) {
queue* head = QUEUE_HEAD(&wq); queue* head = QUEUE_HEAD(&wq);
@ -871,12 +871,12 @@ static void uvPrepareCb(uv_prepare_t* handle) {
SExHandle* exh2 = transAcquireExHandle(transGetRefMgt(), refId); SExHandle* exh2 = transAcquireExHandle(transGetRefMgt(), refId);
if (exh2 == NULL || exh1 != exh2) { if (exh2 == NULL || exh1 != exh2) {
tTrace("handle except msg %p, ignore it", exh1); tTrace("handle except msg %p, ignore it", exh1);
transReleaseExHandle(transGetRefMgt(), refId); (void)transReleaseExHandle(transGetRefMgt(), refId);
destroySmsg(msg); destroySmsg(msg);
continue; continue;
} }
msg->pConn = exh1->handle; msg->pConn = exh1->handle;
transReleaseExHandle(transGetRefMgt(), refId); (void)transReleaseExHandle(transGetRefMgt(), refId);
(*transAsyncHandle[msg->type])(msg, pThrd); (*transAsyncHandle[msg->type])(msg, pThrd);
} }
} }
@ -935,7 +935,7 @@ void uvOnAcceptCb(uv_stream_t* stream, int status) {
tTrace("new connection accepted by main server, dispatch to %dth worker-thread", pObj->workerIdx); tTrace("new connection accepted by main server, dispatch to %dth worker-thread", pObj->workerIdx);
uv_write2(wr, (uv_stream_t*)&(pObj->pipe[pObj->workerIdx][0]), &buf, 1, (uv_stream_t*)cli, uvOnPipeWriteCb); (void)uv_write2(wr, (uv_stream_t*)&(pObj->pipe[pObj->workerIdx][0]), &buf, 1, (uv_stream_t*)cli, uvOnPipeWriteCb);
} else { } else {
if (!uv_is_closing((uv_handle_t*)cli)) { if (!uv_is_closing((uv_handle_t*)cli)) {
tError("failed to accept tcp: %s", uv_err_name(err)); tError("failed to accept tcp: %s", uv_err_name(err));
@ -995,7 +995,7 @@ void uvOnConnectionCb(uv_stream_t* q, ssize_t nread, const uv_buf_t* buf) {
if (uv_accept(q, (uv_stream_t*)(pConn->pTcp)) == 0) { if (uv_accept(q, (uv_stream_t*)(pConn->pTcp)) == 0) {
uv_os_fd_t fd; uv_os_fd_t fd;
uv_fileno((const uv_handle_t*)pConn->pTcp, &fd); (void)uv_fileno((const uv_handle_t*)pConn->pTcp, &fd);
tTrace("conn %p created, fd:%d", pConn, fd); tTrace("conn %p created, fd:%d", pConn, fd);
struct sockaddr peername, sockname; struct sockaddr peername, sockname;
@ -1005,7 +1005,7 @@ void uvOnConnectionCb(uv_stream_t* q, ssize_t nread, const uv_buf_t* buf) {
transUnrefSrvHandle(pConn); transUnrefSrvHandle(pConn);
return; return;
} }
transSockInfo2Str(&peername, pConn->dst); (void)transSockInfo2Str(&peername, pConn->dst);
addrlen = sizeof(sockname); addrlen = sizeof(sockname);
if (0 != uv_tcp_getsockname(pConn->pTcp, (struct sockaddr*)&sockname, &addrlen)) { if (0 != uv_tcp_getsockname(pConn->pTcp, (struct sockaddr*)&sockname, &addrlen)) {
@ -1013,7 +1013,7 @@ void uvOnConnectionCb(uv_stream_t* q, ssize_t nread, const uv_buf_t* buf) {
transUnrefSrvHandle(pConn); transUnrefSrvHandle(pConn);
return; return;
} }
transSockInfo2Str(&sockname, pConn->src); (void)transSockInfo2Str(&sockname, pConn->src);
struct sockaddr_in addr = *(struct sockaddr_in*)&peername; struct sockaddr_in addr = *(struct sockaddr_in*)&peername;
struct sockaddr_in saddr = *(struct sockaddr_in*)&sockname; struct sockaddr_in saddr = *(struct sockaddr_in*)&sockname;
@ -1022,7 +1022,7 @@ void uvOnConnectionCb(uv_stream_t* q, ssize_t nread, const uv_buf_t* buf) {
pConn->serverIp = saddr.sin_addr.s_addr; pConn->serverIp = saddr.sin_addr.s_addr;
pConn->port = ntohs(addr.sin_port); pConn->port = ntohs(addr.sin_port);
uv_read_start((uv_stream_t*)(pConn->pTcp), uvAllocRecvBufferCb, uvOnRecvCb); (void)uv_read_start((uv_stream_t*)(pConn->pTcp), uvAllocRecvBufferCb, uvOnRecvCb);
} else { } else {
tDebug("failed to create new connection"); tDebug("failed to create new connection");
@ -1034,7 +1034,7 @@ void* transAcceptThread(void* arg) {
// opt // opt
setThreadName("trans-accept"); setThreadName("trans-accept");
SServerObj* srv = (SServerObj*)arg; SServerObj* srv = (SServerObj*)arg;
uv_run(srv->loop, UV_RUN_DEFAULT); (void)uv_run(srv->loop, UV_RUN_DEFAULT);
return NULL; return NULL;
} }
@ -1043,7 +1043,7 @@ void uvOnPipeConnectionCb(uv_connect_t* connect, int status) {
return; return;
} }
SWorkThrd* pThrd = container_of(connect, SWorkThrd, connect_req); SWorkThrd* pThrd = container_of(connect, SWorkThrd, connect_req);
uv_read_start((uv_stream_t*)pThrd->pipe, uvAllocConnBufferCb, uvOnConnectionCb); (void)uv_read_start((uv_stream_t*)pThrd->pipe, uvAllocConnBufferCb, uvOnConnectionCb);
} }
static int32_t addHandleToWorkloop(SWorkThrd* pThrd, char* pipeName) { static int32_t addHandleToWorkloop(SWorkThrd* pThrd, char* pipeName) {
int32_t code = 0; int32_t code = 0;
@ -1165,7 +1165,7 @@ static int32_t addHandleToAcceptloop(void* arg) {
void* transWorkerThread(void* arg) { void* transWorkerThread(void* arg) {
setThreadName("trans-svr-work"); setThreadName("trans-svr-work");
SWorkThrd* pThrd = (SWorkThrd*)arg; SWorkThrd* pThrd = (SWorkThrd*)arg;
uv_run(pThrd->loop, UV_RUN_DEFAULT); (void)uv_run(pThrd->loop, UV_RUN_DEFAULT);
return NULL; return NULL;
} }
@ -1242,7 +1242,7 @@ static FORCE_INLINE SSvrConn* createConn(void* hThrd) {
_end: _end:
if (pConn) { if (pConn) {
transQueueDestroy(&pConn->srvMsgs); transQueueDestroy(&pConn->srvMsgs);
transDestroyBuffer(&pConn->readBuf); (void)transDestroyBuffer(&pConn->readBuf);
taosMemoryFree(pConn->pTcp); taosMemoryFree(pConn->pTcp);
taosMemoryFree(pConn); taosMemoryFree(pConn);
pConn = NULL; pConn = NULL;
@ -1271,8 +1271,8 @@ static FORCE_INLINE void destroyConnRegArg(SSvrConn* conn) {
} }
static int32_t reallocConnRef(SSvrConn* conn) { static int32_t reallocConnRef(SSvrConn* conn) {
if (conn->refId > 0) { if (conn->refId > 0) {
transReleaseExHandle(transGetRefMgt(), conn->refId); (void)transReleaseExHandle(transGetRefMgt(), conn->refId);
transRemoveExHandle(transGetRefMgt(), conn->refId); (void)transRemoveExHandle(transGetRefMgt(), conn->refId);
} }
// avoid app continue to send msg on invalid handle // avoid app continue to send msg on invalid handle
SExHandle* exh = taosMemoryMalloc(sizeof(SExHandle)); SExHandle* exh = taosMemoryMalloc(sizeof(SExHandle));
@ -1308,8 +1308,8 @@ static void uvDestroyConn(uv_handle_t* handle) {
} }
SWorkThrd* thrd = conn->hostThrd; SWorkThrd* thrd = conn->hostThrd;
transReleaseExHandle(transGetRefMgt(), conn->refId); (void)transReleaseExHandle(transGetRefMgt(), conn->refId);
transRemoveExHandle(transGetRefMgt(), conn->refId); (void)transRemoveExHandle(transGetRefMgt(), conn->refId);
STrans* pTransInst = thrd->pTransInst; STrans* pTransInst = thrd->pTransInst;
tDebug("%s conn %p destroy", transLabel(pTransInst), conn); tDebug("%s conn %p destroy", transLabel(pTransInst), conn);
@ -1324,7 +1324,7 @@ static void uvDestroyConn(uv_handle_t* handle) {
QUEUE_REMOVE(&conn->queue); QUEUE_REMOVE(&conn->queue);
taosMemoryFree(conn->pTcp); taosMemoryFree(conn->pTcp);
destroyConnRegArg(conn); destroyConnRegArg(conn);
transDestroyBuffer(&conn->readBuf); (void)transDestroyBuffer(&conn->readBuf);
taosMemoryFree(conn); taosMemoryFree(conn);
if (thrd->quit && QUEUE_IS_EMPTY(&thrd->conn)) { if (thrd->quit && QUEUE_IS_EMPTY(&thrd->conn)) {
@ -1578,7 +1578,7 @@ void uvHandleRegister(SSvrMsg* msg, SWorkThrd* thrd) {
if (!transQueuePush(&conn->srvMsgs, msg)) { if (!transQueuePush(&conn->srvMsgs, msg)) {
return; return;
} }
transQueuePop(&conn->srvMsgs); (void)transQueuePop(&conn->srvMsgs);
if (conn->regArg.init) { if (conn->regArg.init) {
transFreeMsg(conn->regArg.msg.pCont); transFreeMsg(conn->regArg.msg.pCont);
@ -1640,7 +1640,7 @@ void destroyWorkThrd(SWorkThrd* pThrd) {
if (pThrd == NULL) { if (pThrd == NULL) {
return; return;
} }
taosThreadJoin(pThrd->thread, NULL); (void)taosThreadJoin(pThrd->thread, NULL);
SRV_RELEASE_UV(pThrd->loop); SRV_RELEASE_UV(pThrd->loop);
TRANS_DESTROY_ASYNC_POOL_MSG(pThrd->asyncPool, SSvrMsg, destroySmsgWrapper, NULL); TRANS_DESTROY_ASYNC_POOL_MSG(pThrd->asyncPool, SSvrMsg, destroySmsgWrapper, NULL);
transAsyncPoolDestroy(pThrd->asyncPool); transAsyncPoolDestroy(pThrd->asyncPool);
@ -1655,7 +1655,7 @@ void sendQuitToWorkThrd(SWorkThrd* pThrd) {
SSvrMsg* msg = taosMemoryCalloc(1, sizeof(SSvrMsg)); SSvrMsg* msg = taosMemoryCalloc(1, sizeof(SSvrMsg));
msg->type = Quit; msg->type = Quit;
tDebug("server send quit msg to work thread"); tDebug("server send quit msg to work thread");
transAsyncSend(pThrd->asyncPool, &msg->q); (void)transAsyncSend(pThrd->asyncPool, &msg->q);
} }
void transCloseServer(void* arg) { void transCloseServer(void* arg) {
@ -1664,8 +1664,8 @@ void transCloseServer(void* arg) {
if (srv->inited) { if (srv->inited) {
tDebug("send quit msg to accept thread"); tDebug("send quit msg to accept thread");
uv_async_send(srv->pAcceptAsync); (void)uv_async_send(srv->pAcceptAsync);
taosThreadJoin(srv->thread, NULL); (void)taosThreadJoin(srv->thread, NULL);
SRV_RELEASE_UV(srv->loop); SRV_RELEASE_UV(srv->loop);
for (int i = 0; i < srv->numOfThreads; i++) { for (int i = 0; i < srv->numOfThreads; i++) {
@ -1732,15 +1732,15 @@ int transReleaseSrvHandle(void* handle) {
tDebug("%s conn %p start to release", transLabel(pThrd->pTransInst), exh->handle); tDebug("%s conn %p start to release", transLabel(pThrd->pTransInst), exh->handle);
if ((code = transAsyncSend(pThrd->asyncPool, &m->q)) != 0) { if ((code = transAsyncSend(pThrd->asyncPool, &m->q)) != 0) {
destroySmsg(m); destroySmsg(m);
transReleaseExHandle(transGetRefMgt(), refId); (void)transReleaseExHandle(transGetRefMgt(), refId);
return code; return code;
} }
transReleaseExHandle(transGetRefMgt(), refId); (void)transReleaseExHandle(transGetRefMgt(), refId);
return 0; return 0;
_return1: _return1:
tDebug("handle %p failed to send to release handle", exh); tDebug("handle %p failed to send to release handle", exh);
transReleaseExHandle(transGetRefMgt(), refId); (void)transReleaseExHandle(transGetRefMgt(), refId);
return code; return code;
_return2: _return2:
tDebug("handle %p failed to send to release handle", exh); tDebug("handle %p failed to send to release handle", exh);
@ -1783,17 +1783,17 @@ int transSendResponse(const STransMsg* msg) {
tGDebug("conn %p start to send resp (1/2)", exh->handle); tGDebug("conn %p start to send resp (1/2)", exh->handle);
if ((code = transAsyncSend(pThrd->asyncPool, &m->q)) != 0) { if ((code = transAsyncSend(pThrd->asyncPool, &m->q)) != 0) {
destroySmsg(m); destroySmsg(m);
transReleaseExHandle(transGetRefMgt(), refId); (void)transReleaseExHandle(transGetRefMgt(), refId);
return code; return code;
} }
transReleaseExHandle(transGetRefMgt(), refId); (void)transReleaseExHandle(transGetRefMgt(), refId);
return 0; return 0;
_return1: _return1:
tDebug("handle %p failed to send resp", exh); tDebug("handle %p failed to send resp", exh);
rpcFreeCont(msg->pCont); rpcFreeCont(msg->pCont);
transReleaseExHandle(transGetRefMgt(), refId); (void)transReleaseExHandle(transGetRefMgt(), refId);
return code; return code;
_return2: _return2:
tDebug("handle %p failed to send resp", exh); tDebug("handle %p failed to send resp", exh);
@ -1828,17 +1828,17 @@ int transRegisterMsg(const STransMsg* msg) {
tDebug("%s conn %p start to register brokenlink callback", transLabel(pTransInst), exh->handle); tDebug("%s conn %p start to register brokenlink callback", transLabel(pTransInst), exh->handle);
if ((code = transAsyncSend(pThrd->asyncPool, &m->q)) != 0) { if ((code = transAsyncSend(pThrd->asyncPool, &m->q)) != 0) {
destroySmsg(m); destroySmsg(m);
transReleaseExHandle(transGetRefMgt(), refId); (void)transReleaseExHandle(transGetRefMgt(), refId);
return code; return code;
} }
transReleaseExHandle(transGetRefMgt(), refId); (void)transReleaseExHandle(transGetRefMgt(), refId);
return 0; return 0;
_return1: _return1:
tDebug("handle %p failed to register brokenlink", exh); tDebug("handle %p failed to register brokenlink", exh);
rpcFreeCont(msg->pCont); rpcFreeCont(msg->pCont);
transReleaseExHandle(transGetRefMgt(), refId); (void)transReleaseExHandle(transGetRefMgt(), refId);
return code; return code;
_return2: _return2:
tDebug("handle %p failed to register brokenlink", exh); tDebug("handle %p failed to register brokenlink", exh);
@ -1883,7 +1883,7 @@ int32_t transSetIpWhiteList(void* thandle, void* arg, FilteFunc* func) {
break; break;
} }
} }
transReleaseExHandle(transGetInstMgt(), (int64_t)thandle); (void)transReleaseExHandle(transGetInstMgt(), (int64_t)thandle);
if (code != 0) { if (code != 0) {
tError("ip-white-list update failed since %s", tstrerror(code)); tError("ip-white-list update failed since %s", tstrerror(code));

2
source/os/src/osSocket.c
View File

@ -972,7 +972,7 @@ int32_t taosGetIpv4FromFqdn(const char *fqdn, uint32_t* ip) {
return terrno; return terrno;
} }
terrno = TAOS_SYSTEM_ERROR(ret); terrno = TAOS_SYSTEM_ERROR(errno);
return terrno; return terrno;
} }

2
source/util/src/tarray.c
View File

@ -293,7 +293,7 @@ void taosArrayRemove(SArray* pArray, size_t index) {
ASSERT(index < pArray->size); ASSERT(index < pArray->size);
if (index == pArray->size - 1) { if (index == pArray->size - 1) {
taosArrayPop(pArray); (void)taosArrayPop(pArray);
return; return;
} }

Some files were not shown because too many files have changed in this diff Show More