From 45e00afad1954fd92fe3b79bac3f44d2fd37b0b9 Mon Sep 17 00:00:00 2001 From: Minglei Jin Date: Wed, 24 Jul 2024 14:20:59 +0800 Subject: [PATCH 01/12] tsdb/cache: remove unused block index cache --- source/dnode/vnode/src/tsdb/tsdbCache.c | 134 +----------------------- 1 file changed, 1 insertion(+), 133 deletions(-) diff --git a/source/dnode/vnode/src/tsdb/tsdbCache.c b/source/dnode/vnode/src/tsdb/tsdbCache.c index 8574ff85c3..9dfa3ea496 100644 --- a/source/dnode/vnode/src/tsdb/tsdbCache.c +++ b/source/dnode/vnode/src/tsdb/tsdbCache.c @@ -22,40 +22,6 @@ #define ROCKS_BATCH_SIZE (4096) -#if 0 -static int32_t tsdbOpenBICache(STsdb *pTsdb) { - int32_t code = 0; - SLRUCache *pCache = taosLRUCacheInit(10 * 1024 * 1024, 0, .5); - if (pCache == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _err; - } - - taosLRUCacheSetStrictCapacity(pCache, false); - - taosThreadMutexInit(&pTsdb->biMutex, NULL); - -_err: - pTsdb->biCache = pCache; - return code; -} - -static void tsdbCloseBICache(STsdb *pTsdb) { - SLRUCache *pCache = pTsdb->biCache; - if (pCache) { - int32_t elems = taosLRUCacheGetElems(pCache); - tsdbTrace("vgId:%d, elems: %d", TD_VID(pTsdb->pVnode), elems); - taosLRUCacheEraseUnrefEntries(pCache); - elems = taosLRUCacheGetElems(pCache); - tsdbTrace("vgId:%d, elems: %d", TD_VID(pTsdb->pVnode), elems); - - taosLRUCacheCleanup(pCache); - - taosThreadMutexDestroy(&pTsdb->biMutex); - } -} -#endif - static int32_t tsdbOpenBCache(STsdb *pTsdb) { int32_t code = 0; int32_t szPage = pTsdb->pVnode->config.tsdbPageSize; @@ -1760,14 +1726,6 @@ int32_t tsdbOpenCache(STsdb *pTsdb) { goto _err; } -#if 0 - code = tsdbOpenBICache(pTsdb); - if (code != TSDB_CODE_SUCCESS) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _err; - } -#endif - code = tsdbOpenBCache(pTsdb); if (code != TSDB_CODE_SUCCESS) { code = TSDB_CODE_OUT_OF_MEMORY; @@ -1808,9 +1766,6 @@ void tsdbCloseCache(STsdb *pTsdb) { taosThreadMutexDestroy(&pTsdb->lruMutex); } -#if 0 - tsdbCloseBICache(pTsdb); -#endif tsdbCloseBCache(pTsdb); tsdbClosePgCache(pTsdb); tsdbCloseRocksCache(pTsdb); @@ -3302,7 +3257,7 @@ static int32_t mergeLastCid(tb_uid_t uid, STsdb *pTsdb, SArray **ppLastArray, SC STsdbRowKey rowKey = {0}; tsdbRowGetKey(pRow, &rowKey); - if (lastRowKey.key.ts == TSKEY_MAX) { // first time + if (lastRowKey.key.ts == TSKEY_MAX) { // first time lastRowKey = rowKey; for (int16_t iCol = noneCol; iCol < nCols; ++iCol) { @@ -3591,93 +3546,6 @@ int32_t tsdbCacheGetElems(SVnode *pVnode) { return elems; } -#if 0 -static void getBICacheKey(int32_t fid, int64_t commitID, char *key, int *len) { - struct { - int32_t fid; - int64_t commitID; - } biKey = {0}; - - biKey.fid = fid; - biKey.commitID = commitID; - - *len = sizeof(biKey); - memcpy(key, &biKey, *len); -} - -static int32_t tsdbCacheLoadBlockIdx(SDataFReader *pFileReader, SArray **aBlockIdx) { - SArray *pArray = taosArrayInit(8, sizeof(SBlockIdx)); - int32_t code = tsdbReadBlockIdx(pFileReader, pArray); - - if (code != TSDB_CODE_SUCCESS) { - taosArrayDestroy(pArray); - code = TSDB_CODE_OUT_OF_MEMORY; - return code; - } - - *aBlockIdx = pArray; - - return code; -} - -static void deleteBICache(const void *key, size_t keyLen, void *value, void *ud) { - (void)ud; - SArray *pArray = (SArray *)value; - - taosArrayDestroy(pArray); -} - -int32_t tsdbCacheGetBlockIdx(SLRUCache *pCache, SDataFReader *pFileReader, LRUHandle **handle) { - int32_t code = 0; - char key[128] = {0}; - int keyLen = 0; - - getBICacheKey(pFileReader->pSet->fid, pFileReader->pSet->pHeadF->commitID, key, &keyLen); - LRUHandle *h = taosLRUCacheLookup(pCache, key, keyLen); - if (!h) { - STsdb *pTsdb = pFileReader->pTsdb; - taosThreadMutexLock(&pTsdb->biMutex); - - h = taosLRUCacheLookup(pCache, key, keyLen); - if (!h) { - SArray *pArray = NULL; - code = tsdbCacheLoadBlockIdx(pFileReader, &pArray); - // if table's empty or error, return code of -1 - if (code != TSDB_CODE_SUCCESS || pArray == NULL) { - taosThreadMutexUnlock(&pTsdb->biMutex); - - *handle = NULL; - return 0; - } - - size_t charge = pArray->capacity * pArray->elemSize + sizeof(*pArray); - _taos_lru_deleter_t deleter = deleteBICache; - LRUStatus status = - taosLRUCacheInsert(pCache, key, keyLen, pArray, charge, deleter, &h, TAOS_LRU_PRIORITY_LOW, NULL); - if (status != TAOS_LRU_STATUS_OK) { - code = -1; - } - } - - taosThreadMutexUnlock(&pTsdb->biMutex); - } - - tsdbTrace("bi cache:%p, ref", pCache); - *handle = h; - - return code; -} - -int32_t tsdbBICacheRelease(SLRUCache *pCache, LRUHandle *h) { - int32_t code = 0; - - taosLRUCacheRelease(pCache, h, false); - tsdbTrace("bi cache:%p, release", pCache); - - return code; -} -#endif - // block cache static void getBCacheKey(int32_t fid, int64_t commitID, int64_t blkno, char *key, int *len) { struct { From 45b1bbf0ed9cd44a10109785e4bc9a6dd4c97d1f Mon Sep 17 00:00:00 2001 From: Minglei Jin Date: Wed, 24 Jul 2024 14:34:27 +0800 Subject: [PATCH 02/12] use new macros from bcache & pgcache opening --- source/dnode/vnode/src/tsdb/tsdbCache.c | 25 ++++++++++++++++--------- 1 file changed, 16 insertions(+), 9 deletions(-) diff --git a/source/dnode/vnode/src/tsdb/tsdbCache.c b/source/dnode/vnode/src/tsdb/tsdbCache.c index 9dfa3ea496..6506daacbd 100644 --- a/source/dnode/vnode/src/tsdb/tsdbCache.c +++ b/source/dnode/vnode/src/tsdb/tsdbCache.c @@ -23,13 +23,12 @@ #define ROCKS_BATCH_SIZE (4096) static int32_t tsdbOpenBCache(STsdb *pTsdb) { - int32_t code = 0; + int32_t code = 0, lino = 0; int32_t szPage = pTsdb->pVnode->config.tsdbPageSize; int64_t szBlock = tsS3BlockSize <= 1024 ? 1024 : tsS3BlockSize; SLRUCache *pCache = taosLRUCacheInit((int64_t)tsS3BlockCacheSize * szBlock * szPage, 0, .5); if (pCache == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _err; + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _err); } taosLRUCacheSetStrictCapacity(pCache, false); @@ -39,7 +38,11 @@ static int32_t tsdbOpenBCache(STsdb *pTsdb) { pTsdb->bCache = pCache; _err: - return code; + if (code) { + tsdbError("tsdb/bcache: vgId:%d, open failed at line %d since %s.", TD_VID(pTsdb->pVnode), lino, tstrerror(code)); + } + + TAOS_RETURN(code); } static void tsdbCloseBCache(STsdb *pTsdb) { @@ -58,23 +61,27 @@ static void tsdbCloseBCache(STsdb *pTsdb) { } static int32_t tsdbOpenPgCache(STsdb *pTsdb) { - int32_t code = 0; + int32_t code = 0, lino = 0; // SLRUCache *pCache = taosLRUCacheInit(10 * 1024 * 1024, 0, .5); int32_t szPage = pTsdb->pVnode->config.tsdbPageSize; SLRUCache *pCache = taosLRUCacheInit((int64_t)tsS3PageCacheSize * szPage, 0, .5); if (pCache == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _err; + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _err); } taosLRUCacheSetStrictCapacity(pCache, false); taosThreadMutexInit(&pTsdb->pgMutex, NULL); -_err: pTsdb->pgCache = pCache; - return code; + +_err: + if (code) { + tsdbError("tsdb/pgcache: vgId:%d, open failed at line %d since %s.", TD_VID(pTsdb->pVnode), lino, tstrerror(code)); + } + + TAOS_RETURN(code); } static void tsdbClosePgCache(STsdb *pTsdb) { From e0cd502afe43ad1769c8251d56303fba623facd2 Mon Sep 17 00:00:00 2001 From: Minglei Jin Date: Wed, 24 Jul 2024 14:43:31 +0800 Subject: [PATCH 03/12] remove unused code --- source/dnode/vnode/src/tsdb/tsdbCache.c | 377 ------------------------ 1 file changed, 377 deletions(-) diff --git a/source/dnode/vnode/src/tsdb/tsdbCache.c b/source/dnode/vnode/src/tsdb/tsdbCache.c index 6506daacbd..91345bf001 100644 --- a/source/dnode/vnode/src/tsdb/tsdbCache.c +++ b/source/dnode/vnode/src/tsdb/tsdbCache.c @@ -1788,320 +1788,6 @@ static void getTableCacheKey(tb_uid_t uid, int cacheType, char *key, int *len) { *len = sizeof(uint64_t); } -#ifdef BUILD_NO_CALL -static void deleteTableCacheLast(const void *key, size_t keyLen, void *value, void *ud) { - (void)ud; - SArray *pLastArray = (SArray *)value; - int16_t nCol = taosArrayGetSize(pLastArray); - for (int16_t iCol = 0; iCol < nCol; ++iCol) { - SLastCol *pLastCol = (SLastCol *)taosArrayGet(pLastArray, iCol); - if (IS_VAR_DATA_TYPE(pLastCol->colVal.type) && pLastCol->colVal.value.nData > 0) { - taosMemoryFree(pLastCol->colVal.value.pData); - } - } - - taosArrayDestroy(value); -} - -int32_t tsdbCacheDeleteLastrow(SLRUCache *pCache, tb_uid_t uid, TSKEY eKey) { - int32_t code = 0; - - char key[32] = {0}; - int keyLen = 0; - - // getTableCacheKey(uid, "lr", key, &keyLen); - getTableCacheKey(uid, 0, key, &keyLen); - LRUHandle *h = taosLRUCacheLookup(pCache, key, keyLen); - if (h) { - SArray *pLast = (SArray *)taosLRUCacheValue(pCache, h); - bool invalidate = false; - int16_t nCol = taosArrayGetSize(pLast); - - for (int16_t iCol = 0; iCol < nCol; ++iCol) { - SLastCol *tTsVal = (SLastCol *)taosArrayGet(pLast, iCol); - if (eKey >= tTsVal->ts) { - invalidate = true; - break; - } - } - - taosLRUCacheRelease(pCache, h, invalidate); - if (invalidate) { - taosLRUCacheErase(pCache, key, keyLen); - } - } - - return code; -} - -int32_t tsdbCacheDeleteLast(SLRUCache *pCache, tb_uid_t uid, TSKEY eKey) { - int32_t code = 0; - - char key[32] = {0}; - int keyLen = 0; - - // getTableCacheKey(uid, "l", key, &keyLen); - getTableCacheKey(uid, 1, key, &keyLen); - LRUHandle *h = taosLRUCacheLookup(pCache, key, keyLen); - if (h) { - SArray *pLast = (SArray *)taosLRUCacheValue(pCache, h); - bool invalidate = false; - int16_t nCol = taosArrayGetSize(pLast); - - for (int16_t iCol = 0; iCol < nCol; ++iCol) { - SLastCol *tTsVal = (SLastCol *)taosArrayGet(pLast, iCol); - if (eKey >= tTsVal->ts) { - invalidate = true; - break; - } - } - - taosLRUCacheRelease(pCache, h, invalidate); - if (invalidate) { - taosLRUCacheErase(pCache, key, keyLen); - } - } - - return code; -} - -int32_t tsdbCacheInsertLastrow(SLRUCache *pCache, STsdb *pTsdb, tb_uid_t uid, TSDBROW *row, bool dup) { - int32_t code = 0; - STSRow *cacheRow = NULL; - char key[32] = {0}; - int keyLen = 0; - - // getTableCacheKey(uid, "lr", key, &keyLen); - getTableCacheKey(uid, 0, key, &keyLen); - LRUHandle *h = taosLRUCacheLookup(pCache, key, keyLen); - if (h) { - STSchema *pTSchema = metaGetTbTSchema(pTsdb->pVnode->pMeta, uid, -1, 1); - TSKEY keyTs = TSDBROW_TS(row); - bool invalidate = false; - - SArray *pLast = (SArray *)taosLRUCacheValue(pCache, h); - int16_t nCol = taosArrayGetSize(pLast); - int16_t iCol = 0; - - if (nCol <= 0) { - nCol = pTSchema->numOfCols; - - STColumn *pTColumn = &pTSchema->columns[0]; - SColVal tColVal = COL_VAL_VALUE(pTColumn->colId, pTColumn->type, (SValue){.val = keyTs}); - if (taosArrayPush(pLast, &(SLastCol){.ts = keyTs, .colVal = tColVal}) == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - code = TSDB_CODE_OUT_OF_MEMORY; - goto _invalidate; - } - - for (iCol = 1; iCol < nCol; ++iCol) { - SColVal colVal = {0}; - tsdbRowGetColVal(row, pTSchema, iCol, &colVal); - - SLastCol lastCol = {.ts = keyTs, .colVal = colVal}; - if (IS_VAR_DATA_TYPE(colVal.type) && colVal.value.nData > 0) { - lastCol.colVal.value.pData = taosMemoryMalloc(colVal.value.nData); - if (lastCol.colVal.value.pData == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - code = TSDB_CODE_OUT_OF_MEMORY; - goto _invalidate; - } - memcpy(lastCol.colVal.value.pData, colVal.value.pData, colVal.value.nData); - } - - if (taosArrayPush(pLast, &lastCol) == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _invalidate; - } - } - - goto _invalidate; - } - - if (nCol != pTSchema->numOfCols) { - invalidate = true; - goto _invalidate; - } - - SLastCol *tTsVal = (SLastCol *)taosArrayGet(pLast, iCol); - if (keyTs > tTsVal->ts) { - STColumn *pTColumn = &pTSchema->columns[0]; - SColVal tColVal = COL_VAL_VALUE(pTColumn->colId, pTColumn->type, (SValue){.val = keyTs}); - - taosArraySet(pLast, iCol, &(SLastCol){.ts = keyTs, .colVal = tColVal}); - } - - for (++iCol; iCol < nCol; ++iCol) { - SLastCol *tTsVal1 = (SLastCol *)taosArrayGet(pLast, iCol); - if (keyTs >= tTsVal1->ts) { - SColVal *tColVal = &tTsVal1->colVal; - - SColVal colVal = {0}; - tsdbRowGetColVal(row, pTSchema, iCol, &colVal); - - if (colVal.cid != tColVal->cid) { - invalidate = true; - goto _invalidate; - } - - if (!COL_VAL_IS_NONE(&colVal)) { - if (keyTs == tTsVal1->ts && !COL_VAL_IS_NONE(tColVal)) { - invalidate = true; - - break; - } else { // new inserting key is greater than cached, update cached entry - SLastCol lastCol = {.ts = keyTs, .colVal = colVal}; - if (IS_VAR_DATA_TYPE(colVal.type) && colVal.value.nData > 0) { - SLastCol *pLastCol = (SLastCol *)taosArrayGet(pLast, iCol); - if (pLastCol->colVal.value.nData > 0 && NULL != pLastCol->colVal.value.pData) - taosMemoryFree(pLastCol->colVal.value.pData); - - lastCol.colVal.value.pData = taosMemoryMalloc(colVal.value.nData); - if (lastCol.colVal.value.pData == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - code = TSDB_CODE_OUT_OF_MEMORY; - goto _invalidate; - } - memcpy(lastCol.colVal.value.pData, colVal.value.pData, colVal.value.nData); - } - - taosArraySet(pLast, iCol, &lastCol); - } - } - } - } - - _invalidate: - taosMemoryFreeClear(pTSchema); - - taosLRUCacheRelease(pCache, h, invalidate); - if (invalidate) { - taosLRUCacheErase(pCache, key, keyLen); - } - } - - return code; -} - -int32_t tsdbCacheInsertLast(SLRUCache *pCache, tb_uid_t uid, TSDBROW *row, STsdb *pTsdb) { - int32_t code = 0; - STSRow *cacheRow = NULL; - char key[32] = {0}; - int keyLen = 0; - - // getTableCacheKey(uid, "l", key, &keyLen); - getTableCacheKey(uid, 1, key, &keyLen); - LRUHandle *h = taosLRUCacheLookup(pCache, key, keyLen); - if (h) { - STSchema *pTSchema = metaGetTbTSchema(pTsdb->pVnode->pMeta, uid, -1, 1); - TSKEY keyTs = TSDBROW_TS(row); - bool invalidate = false; - - SArray *pLast = (SArray *)taosLRUCacheValue(pCache, h); - int16_t nCol = taosArrayGetSize(pLast); - int16_t iCol = 0; - - if (nCol <= 0) { - nCol = pTSchema->numOfCols; - - STColumn *pTColumn = &pTSchema->columns[0]; - SColVal tColVal = COL_VAL_VALUE(pTColumn->colId, pTColumn->type, (SValue){.val = keyTs}); - if (taosArrayPush(pLast, &(SLastCol){.ts = keyTs, .colVal = tColVal}) == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - code = TSDB_CODE_OUT_OF_MEMORY; - goto _invalidate; - } - - for (iCol = 1; iCol < nCol; ++iCol) { - SColVal colVal = {0}; - tsdbRowGetColVal(row, pTSchema, iCol, &colVal); - - SLastCol lastCol = {.ts = keyTs, .colVal = colVal}; - if (IS_VAR_DATA_TYPE(colVal.type) && colVal.value.nData > 0) { - lastCol.colVal.value.pData = taosMemoryMalloc(colVal.value.nData); - if (lastCol.colVal.value.pData == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - code = TSDB_CODE_OUT_OF_MEMORY; - goto _invalidate; - } - memcpy(lastCol.colVal.value.pData, colVal.value.pData, colVal.value.nData); - } - - if (taosArrayPush(pLast, &lastCol) == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _invalidate; - } - } - - goto _invalidate; - } - - if (nCol != pTSchema->numOfCols) { - invalidate = true; - goto _invalidate; - } - - SLastCol *tTsVal = (SLastCol *)taosArrayGet(pLast, iCol); - if (keyTs > tTsVal->ts) { - STColumn *pTColumn = &pTSchema->columns[0]; - SColVal tColVal = COL_VAL_VALUE(pTColumn->colId, pTColumn->type, (SValue){.val = keyTs}); - - taosArraySet(pLast, iCol, &(SLastCol){.ts = keyTs, .colVal = tColVal}); - } - - for (++iCol; iCol < nCol; ++iCol) { - SLastCol *tTsVal1 = (SLastCol *)taosArrayGet(pLast, iCol); - if (keyTs >= tTsVal1->ts) { - SColVal *tColVal = &tTsVal1->colVal; - - SColVal colVal = {0}; - tsdbRowGetColVal(row, pTSchema, iCol, &colVal); - - if (colVal.cid != tColVal->cid) { - invalidate = true; - goto _invalidate; - } - - if (COL_VAL_IS_VALUE(&colVal)) { - if (keyTs == tTsVal1->ts && COL_VAL_IS_VALUE(tColVal)) { - invalidate = true; - - break; - } else { - SLastCol lastCol = {.ts = keyTs, .colVal = colVal}; - if (IS_VAR_DATA_TYPE(colVal.type) && colVal.value.nData > 0) { - SLastCol *pLastCol = (SLastCol *)taosArrayGet(pLast, iCol); - if (pLastCol->colVal.value.nData > 0 && NULL != pLastCol->colVal.value.pData) - taosMemoryFree(pLastCol->colVal.value.pData); - - lastCol.colVal.value.pData = taosMemoryMalloc(colVal.value.nData); - if (lastCol.colVal.value.pData == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - code = TSDB_CODE_OUT_OF_MEMORY; - goto _invalidate; - } - memcpy(lastCol.colVal.value.pData, colVal.value.pData, colVal.value.nData); - } - - taosArraySet(pLast, iCol, &lastCol); - } - } - } - } - - _invalidate: - taosMemoryFreeClear(pTSchema); - - taosLRUCacheRelease(pCache, h, invalidate); - if (invalidate) { - taosLRUCacheErase(pCache, key, keyLen); - } - } - - return code; -} -#endif - static tb_uid_t getTableSuidByUid(tb_uid_t uid, STsdb *pTsdb) { tb_uid_t suid = 0; @@ -2146,53 +1832,6 @@ static int32_t getTableDelDataFromTbData(STbData *pTbData, SArray *aDelData) { return code; } -#ifdef BUILD_NO_CALL -static int32_t getTableDelData(STbData *pMem, STbData *pIMem, SDelFReader *pDelReader, SDelIdx *pDelIdx, - SArray *aDelData) { - int32_t code = 0; - - if (pDelIdx) { - code = getTableDelDataFromDelIdx(pDelReader, pDelIdx, aDelData); - if (code) goto _err; - } - - if (pMem) { - code = getTableDelDataFromTbData(pMem, aDelData); - if (code) goto _err; - } - - if (pIMem) { - code = getTableDelDataFromTbData(pIMem, aDelData); - if (code) goto _err; - } - -_err: - return code; -} - -static int32_t getTableDelSkyline(STbData *pMem, STbData *pIMem, SDelFReader *pDelReader, SDelIdx *pDelIdx, - SArray *aSkyline) { - int32_t code = 0; - SArray *aDelData = NULL; - - aDelData = taosArrayInit(32, sizeof(SDelData)); - code = getTableDelData(pMem, pIMem, pDelReader, pDelIdx, aDelData); - if (code) goto _err; - - size_t nDelData = taosArrayGetSize(aDelData); - if (nDelData > 0) { - code = tsdbBuildDeleteSkyline(aDelData, 0, (int32_t)(nDelData - 1), aSkyline); - if (code) goto _err; - } - -_err: - if (aDelData) { - taosArrayDestroy(aDelData); - } - return code; -} -#endif - static void freeTableInfoFunc(void *param) { void **p = (void **)param; taosMemoryFreeClear(*p); @@ -3154,22 +2793,6 @@ _err: return code; } -#ifdef BUILD_NO_CALL -static int32_t initLastColArray(STSchema *pTSchema, SArray **ppColArray) { - SArray *pColArray = taosArrayInit(pTSchema->numOfCols, sizeof(SLastCol)); - if (NULL == pColArray) { - return TSDB_CODE_OUT_OF_MEMORY; - } - - for (int32_t i = 0; i < pTSchema->numOfCols; ++i) { - SLastCol col = {.ts = 0, .colVal = COL_VAL_NULL(pTSchema->columns[i].colId, pTSchema->columns[i].type)}; - taosArrayPush(pColArray, &col); - } - *ppColArray = pColArray; - return TSDB_CODE_SUCCESS; -} -#endif - static int32_t initLastColArrayPartial(STSchema *pTSchema, SArray **ppColArray, int16_t *slotIds, int nCols) { SArray *pColArray = taosArrayInit(nCols, sizeof(SLastCol)); if (NULL == pColArray) { From 3c41b5a98c599e7d52a6a3e493d0ac4d6ff2c8fb Mon Sep 17 00:00:00 2001 From: Minglei Jin Date: Wed, 24 Jul 2024 17:22:00 +0800 Subject: [PATCH 04/12] use new macros --- source/dnode/vnode/src/tsdb/tsdbCache.c | 599 ++++++++++++------------ 1 file changed, 302 insertions(+), 297 deletions(-) diff --git a/source/dnode/vnode/src/tsdb/tsdbCache.c b/source/dnode/vnode/src/tsdb/tsdbCache.c index 91345bf001..459ad39819 100644 --- a/source/dnode/vnode/src/tsdb/tsdbCache.c +++ b/source/dnode/vnode/src/tsdb/tsdbCache.c @@ -39,7 +39,8 @@ static int32_t tsdbOpenBCache(STsdb *pTsdb) { _err: if (code) { - tsdbError("tsdb/bcache: vgId:%d, open failed at line %d since %s.", TD_VID(pTsdb->pVnode), lino, tstrerror(code)); + tsdbError("tsdb/bcache: vgId:%d, %s failed at line %d since %s.", TD_VID(pTsdb->pVnode), __func__, lino, + tstrerror(code)); } TAOS_RETURN(code); @@ -159,12 +160,11 @@ static int myCmp(void *state, const char *a, size_t alen, const char *b, size_t } static int32_t tsdbOpenRocksCache(STsdb *pTsdb) { - int32_t code = 0; + int32_t code = 0, lino = 0; rocksdb_comparator_t *cmp = rocksdb_comparator_create(NULL, myCmpDestroy, myCmp, myCmpName); if (NULL == cmp) { - code = TSDB_CODE_OUT_OF_MEMORY; - return code; + TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); } rocksdb_cache_t *cache = rocksdb_cache_create_lru(5 * 1024 * 1024); @@ -175,8 +175,7 @@ static int32_t tsdbOpenRocksCache(STsdb *pTsdb) { rocksdb_options_t *options = rocksdb_options_create(); if (NULL == options) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _err; + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _err); } rocksdb_options_set_create_if_missing(options, 1); @@ -189,15 +188,13 @@ static int32_t tsdbOpenRocksCache(STsdb *pTsdb) { rocksdb_writeoptions_t *writeoptions = rocksdb_writeoptions_create(); if (NULL == writeoptions) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _err2; + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _err2); } rocksdb_writeoptions_disable_WAL(writeoptions, 1); rocksdb_readoptions_t *readoptions = rocksdb_readoptions_create(); if (NULL == readoptions) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _err3; + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _err3); } char *err = NULL; @@ -209,14 +206,12 @@ static int32_t tsdbOpenRocksCache(STsdb *pTsdb) { tsdbError("vgId:%d, %s failed at line %d since %s", TD_VID(pTsdb->pVnode), __func__, __LINE__, err); rocksdb_free(err); - code = TSDB_CODE_OUT_OF_MEMORY; - goto _err4; + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _err4); } rocksdb_flushoptions_t *flushoptions = rocksdb_flushoptions_create(); if (NULL == flushoptions) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _err5; + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _err5); } rocksdb_writebatch_t *writebatch = rocksdb_writebatch_create(); @@ -235,7 +230,7 @@ static int32_t tsdbOpenRocksCache(STsdb *pTsdb) { pTsdb->rCache.pTSchema = NULL; - return code; + TAOS_RETURN(code); _err5: rocksdb_close(pTsdb->rCache.db); @@ -249,7 +244,8 @@ _err2: rocksdb_cache_destroy(cache); _err: rocksdb_comparator_destroy(cmp); - return code; + + TAOS_RETURN(code); } static void tsdbCloseRocksCache(STsdb *pTsdb) { @@ -344,24 +340,26 @@ static int32_t tsdbCacheDeserializeV0(char const *value, SLastCol *pLastCol) { } } -static SLastCol *tsdbCacheDeserialize(char const *value, size_t size) { +static int32_t tsdbCacheDeserialize(char const *value, size_t size, SLastCol **ppLastCol) { if (!value) { - return NULL; + return TSDB_CODE_INVALID_PARA; } SLastCol *pLastCol = taosMemoryCalloc(1, sizeof(SLastCol)); if (NULL == pLastCol) { - return NULL; + TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); } int32_t offset = tsdbCacheDeserializeV0(value, pLastCol); if (offset == size) { // version 0 - return pLastCol; + *ppLastCol = pLastCol; + + TAOS_RETURN(TSDB_CODE_SUCCESS); } else if (offset > size) { - terrno = TSDB_CODE_INVALID_DATA_FMT; taosMemoryFreeClear(pLastCol); - return NULL; + + TAOS_RETURN(TSDB_CODE_INVALID_DATA_FMT); } // version @@ -387,12 +385,14 @@ static SLastCol *tsdbCacheDeserialize(char const *value, size_t size) { } if (offset > size) { - terrno = TSDB_CODE_INVALID_DATA_FMT; taosMemoryFreeClear(pLastCol); - return NULL; + + TAOS_RETURN(TSDB_CODE_INVALID_DATA_FMT); } - return pLastCol; + *ppLastCol = pLastCol; + + TAOS_RETURN(TSDB_CODE_SUCCESS); } /* @@ -430,7 +430,7 @@ static int32_t tsdbCacheSerializeV0(char const *value, SLastCol *pLastCol) { return 0; } -static void tsdbCacheSerialize(SLastCol *pLastCol, char **value, size_t *size) { +static int32_t tsdbCacheSerialize(SLastCol *pLastCol, char **value, size_t *size) { *size = sizeof(SLastColV0); if (IS_VAR_DATA_TYPE(pLastCol->colVal.value.type)) { *size += pLastCol->colVal.value.nData; @@ -445,6 +445,9 @@ static void tsdbCacheSerialize(SLastCol *pLastCol, char **value, size_t *size) { } *value = taosMemoryMalloc(*size); + if (NULL == *value) { + TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); + } int32_t offset = tsdbCacheSerializeV0(*value, pLastCol); @@ -467,16 +470,22 @@ static void tsdbCacheSerialize(SLastCol *pLastCol, char **value, size_t *size) { offset += pLastCol->rowKey.pks[i].nData; } } + + TAOS_RETURN(TSDB_CODE_SUCCESS); } static void tsdbCachePutBatch(SLastCol *pLastCol, const void *key, size_t klen, SCacheFlushState *state) { + int32_t code = 0; STsdb *pTsdb = state->pTsdb; SRocksCache *rCache = &pTsdb->rCache; rocksdb_writebatch_t *wb = rCache->writebatch; char *rocks_value = NULL; size_t vlen = 0; - tsdbCacheSerialize(pLastCol, &rocks_value, &vlen); + code = tsdbCacheSerialize(pLastCol, &rocks_value, &vlen); + if (code) { + tsdbError("tsdb/cache: vgId:%d, serialize failed since %s.", TD_VID(pTsdb->pVnode), tstrerror(code)); + } taosThreadMutexLock(&rCache->rMutex); @@ -534,25 +543,31 @@ int32_t tsdbCacheCommit(STsdb *pTsdb) { if (NULL != err) { tsdbError("vgId:%d, %s failed at line %d since %s", TD_VID(pTsdb->pVnode), __func__, __LINE__, err); rocksdb_free(err); - code = -1; + code = TSDB_CODE_FAILED; } - return code; + TAOS_RETURN(code); } -static void reallocVarDataVal(SValue *pValue) { +static int32_t reallocVarDataVal(SValue *pValue) { if (IS_VAR_DATA_TYPE(pValue->type)) { uint8_t *pVal = pValue->pData; if (pValue->nData > 0) { - pValue->pData = taosMemoryMalloc(pValue->nData); + uint8_t *p = taosMemoryMalloc(pValue->nData); + if (!p) { + TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); + } + pValue->pData = p; memcpy(pValue->pData, pVal, pValue->nData); } else { pValue->pData = NULL; } } + + TAOS_RETURN(TSDB_CODE_SUCCESS); } -static void reallocVarData(SColVal *pColVal) { reallocVarDataVal(&pColVal->value); } +static int32_t reallocVarData(SColVal *pColVal) { return reallocVarDataVal(&pColVal->value); } static void tsdbCacheDeleter(const void *key, size_t klen, void *value, void *ud) { SLastCol *pLastCol = (SLastCol *)value; @@ -587,6 +602,9 @@ static int32_t tsdbCacheNewTableColumn(STsdb *pTsdb, int64_t uid, int16_t cid, i SLastCol *pLastCol = &noneCol; SLastCol *pTmpLastCol = taosMemoryCalloc(1, sizeof(SLastCol)); + if (!pTmpLastCol) { + TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); + } *pTmpLastCol = *pLastCol; pLastCol = pTmpLastCol; @@ -595,13 +613,13 @@ static int32_t tsdbCacheNewTableColumn(STsdb *pTsdb, int64_t uid, int16_t cid, i for (int8_t i = 0; i < pLastCol->rowKey.numOfPKs; i++) { SValue *pValue = &pLastCol->rowKey.pks[i]; if (IS_VAR_DATA_TYPE(pValue->type)) { - reallocVarDataVal(pValue); + TAOS_CHECK_RETURN(reallocVarDataVal(pValue)); charge += pValue->nData; } } if (IS_VAR_DATA_TYPE(pLastCol->colVal.value.type)) { - reallocVarData(&pLastCol->colVal); + TAOS_CHECK_RETURN(reallocVarData(&pLastCol->colVal)); charge += pLastCol->colVal.value.nData; } @@ -609,20 +627,10 @@ static int32_t tsdbCacheNewTableColumn(STsdb *pTsdb, int64_t uid, int16_t cid, i LRUStatus status = taosLRUCacheInsert(pCache, pLastKey, ROCKS_KEY_LEN, pLastCol, charge, tsdbCacheDeleter, NULL, TAOS_LRU_PRIORITY_LOW, &pTsdb->flushState); if (status != TAOS_LRU_STATUS_OK) { - code = -1; + // code = -1; } - /* - // store result back to rocks cache - char *value = NULL; - size_t vlen = 0; - tsdbCacheSerialize(pLastCol, &value, &vlen); - SLastKey *key = pLastKey; - size_t klen = ROCKS_KEY_LEN; - rocksdb_writebatch_put(wb, (char *)key, klen, value, vlen); - taosMemoryFree(value); - */ - return code; + TAOS_RETURN(code); } int32_t tsdbCacheCommitNoLock(STsdb *pTsdb) { @@ -641,10 +649,10 @@ int32_t tsdbCacheCommitNoLock(STsdb *pTsdb) { if (NULL != err) { tsdbError("vgId:%d, %s failed at line %d since %s", TD_VID(pTsdb->pVnode), __func__, __LINE__, err); rocksdb_free(err); - code = -1; + code = TSDB_CODE_FAILED; } - return code; + TAOS_RETURN(code); } static int32_t tsdbCacheDropTableColumn(STsdb *pTsdb, int64_t uid, int16_t cid, bool hasPrimaryKey) { @@ -681,13 +689,21 @@ static int32_t tsdbCacheDropTableColumn(STsdb *pTsdb, int64_t uid, int16_t cid, rocksdb_writebatch_t *wb = pTsdb->rCache.writebatch; { - SLastCol *pLastCol = tsdbCacheDeserialize(values_list[0], values_list_sizes[0]); + SLastCol *pLastCol = NULL; + code = tsdbCacheDeserialize(values_list[0], values_list_sizes[0], &pLastCol); + if (code) { + tsdbError("tsdb/cache: vgId:%d, deserialize failed since %s.", TD_VID(pTsdb->pVnode), tstrerror(code)); + } if (NULL != pLastCol) { rocksdb_writebatch_delete(wb, keys_list[0], klen); } taosMemoryFreeClear(pLastCol); - pLastCol = tsdbCacheDeserialize(values_list[1], values_list_sizes[1]); + pLastCol = NULL; + code = tsdbCacheDeserialize(values_list[1], values_list_sizes[1], &pLastCol); + if (code) { + tsdbError("tsdb/cache: vgId:%d, deserialize failed since %s.", TD_VID(pTsdb->pVnode), tstrerror(code)); + } if (NULL != pLastCol) { rocksdb_writebatch_delete(wb, keys_list[1], klen); } @@ -724,7 +740,7 @@ static int32_t tsdbCacheDropTableColumn(STsdb *pTsdb, int64_t uid, int16_t cid, taosMemoryFree(values_list); taosMemoryFree(values_list_sizes); - return code; + TAOS_RETURN(code); } int32_t tsdbCacheNewTable(STsdb *pTsdb, tb_uid_t uid, tb_uid_t suid, SSchemaWrapper *pSchemaRow) { @@ -745,8 +761,8 @@ int32_t tsdbCacheNewTable(STsdb *pTsdb, tb_uid_t uid, tb_uid_t suid, SSchemaWrap code = metaGetTbTSchemaEx(pTsdb->pVnode->pMeta, suid, uid, -1, &pTSchema); if (code != TSDB_CODE_SUCCESS) { taosThreadMutexUnlock(&pTsdb->lruMutex); - terrno = code; - return -1; + + TAOS_RETURN(code); } for (int i = 0; i < pTSchema->numOfCols; ++i) { @@ -762,7 +778,7 @@ int32_t tsdbCacheNewTable(STsdb *pTsdb, tb_uid_t uid, tb_uid_t suid, SSchemaWrap taosThreadMutexUnlock(&pTsdb->lruMutex); - return code; + TAOS_RETURN(code); } int32_t tsdbCacheDropTable(STsdb *pTsdb, tb_uid_t uid, tb_uid_t suid, SSchemaWrapper *pSchemaRow) { @@ -788,8 +804,9 @@ int32_t tsdbCacheDropTable(STsdb *pTsdb, tb_uid_t uid, tb_uid_t suid, SSchemaWra STSchema *pTSchema = NULL; code = metaGetTbTSchemaEx(pTsdb->pVnode->pMeta, suid, uid, -1, &pTSchema); if (code != TSDB_CODE_SUCCESS) { - terrno = code; - return -1; + taosThreadMutexUnlock(&pTsdb->lruMutex); + + TAOS_RETURN(code); } bool hasPrimayKey = false; @@ -811,7 +828,7 @@ int32_t tsdbCacheDropTable(STsdb *pTsdb, tb_uid_t uid, tb_uid_t suid, SSchemaWra taosThreadMutexUnlock(&pTsdb->lruMutex); - return code; + TAOS_RETURN(code); } int32_t tsdbCacheDropSubTables(STsdb *pTsdb, SArray *uids, tb_uid_t suid) { @@ -824,9 +841,11 @@ int32_t tsdbCacheDropSubTables(STsdb *pTsdb, SArray *uids, tb_uid_t suid) { STSchema *pTSchema = NULL; code = metaGetTbTSchemaEx(pTsdb->pVnode->pMeta, suid, suid, -1, &pTSchema); if (code != TSDB_CODE_SUCCESS) { - terrno = code; - return -1; + taosThreadMutexUnlock(&pTsdb->lruMutex); + + TAOS_RETURN(code); } + for (int i = 0; i < TARRAY_SIZE(uids); ++i) { int64_t uid = ((tb_uid_t *)TARRAY_DATA(uids))[i]; @@ -850,7 +869,7 @@ int32_t tsdbCacheDropSubTables(STsdb *pTsdb, SArray *uids, tb_uid_t suid) { taosThreadMutexUnlock(&pTsdb->lruMutex); - return code; + TAOS_RETURN(code); } int32_t tsdbCacheNewNTableColumn(STsdb *pTsdb, int64_t uid, int16_t cid, int8_t col_type) { @@ -865,7 +884,7 @@ int32_t tsdbCacheNewNTableColumn(STsdb *pTsdb, int64_t uid, int16_t cid, int8_t taosThreadMutexUnlock(&pTsdb->lruMutex); //(void)tsdbCacheCommit(pTsdb); - return code; + TAOS_RETURN(code); } int32_t tsdbCacheDropNTableColumn(STsdb *pTsdb, int64_t uid, int16_t cid, bool hasPrimayKey) { @@ -881,7 +900,7 @@ int32_t tsdbCacheDropNTableColumn(STsdb *pTsdb, int64_t uid, int16_t cid, bool h taosThreadMutexUnlock(&pTsdb->lruMutex); - return code; + TAOS_RETURN(code); } int32_t tsdbCacheNewSTableColumn(STsdb *pTsdb, SArray *uids, int16_t cid, int8_t col_type) { @@ -900,7 +919,7 @@ int32_t tsdbCacheNewSTableColumn(STsdb *pTsdb, SArray *uids, int16_t cid, int8_t taosThreadMutexUnlock(&pTsdb->lruMutex); //(void)tsdbCacheCommit(pTsdb); - return code; + TAOS_RETURN(code); } int32_t tsdbCacheDropSTableColumn(STsdb *pTsdb, SArray *uids, int16_t cid, bool hasPrimayKey) { @@ -920,7 +939,7 @@ int32_t tsdbCacheDropSTableColumn(STsdb *pTsdb, SArray *uids, int16_t cid, bool taosThreadMutexUnlock(&pTsdb->lruMutex); - return code; + TAOS_RETURN(code); } typedef struct { @@ -955,7 +974,8 @@ static int32_t tsdbCacheUpdateValue(SValue *pOld, SValue *pNew) { } taosMemoryFreeClear(pFree); - return 0; + + TAOS_RETURN(TSDB_CODE_SUCCESS); } static void tsdbCacheUpdateLastCol(SLastCol *pLastCol, SRowKey *pRowKey, SColVal *pColVal) { @@ -981,10 +1001,10 @@ static void tsdbCacheUpdateLastCol(SLastCol *pLastCol, SRowKey *pRowKey, SColVal static int32_t tsdbCacheUpdate(STsdb *pTsdb, tb_uid_t suid, tb_uid_t uid, SArray *updCtxArray) { if (!updCtxArray || TARRAY_SIZE(updCtxArray) == 0) { - return 0; + TAOS_RETURN(TSDB_CODE_SUCCESS); } - int32_t code = 0; + int32_t code = 0, lino = 0; int num_keys = TARRAY_SIZE(updCtxArray); SArray *remainCols = NULL; @@ -1049,7 +1069,11 @@ static int32_t tsdbCacheUpdate(STsdb *pTsdb, tb_uid_t suid, tb_uid_t uid, SArray SRowKey *pRowKey = &updCtx->tsdbRowKey.key; SColVal *pColVal = &updCtx->colVal; - SLastCol *pLastCol = tsdbCacheDeserialize(values_list[i], values_list_sizes[i]); + SLastCol *pLastCol = NULL; + code = tsdbCacheDeserialize(values_list[i], values_list_sizes[i], &pLastCol); + if (code) { + tsdbError("tsdb/cache: vgId:%d, deserialize failed since %s.", TD_VID(pTsdb->pVnode), tstrerror(code)); + } SLastCol *PToFree = pLastCol; if (IS_LAST_KEY(idxKey->key) && !COL_VAL_IS_VALUE(pColVal)) { @@ -1067,7 +1091,10 @@ static int32_t tsdbCacheUpdate(STsdb *pTsdb, tb_uid_t suid, tb_uid_t uid, SArray char *value = NULL; size_t vlen = 0; SLastCol lastColTmp = {.rowKey = *pRowKey, .colVal = *pColVal}; - tsdbCacheSerialize(&lastColTmp, &value, &vlen); + code = tsdbCacheSerialize(&lastColTmp, &value, &vlen); + if (code) { + tsdbError("tsdb/cache: vgId:%d, serialize failed since %s.", TD_VID(pTsdb->pVnode), tstrerror(code)); + } taosThreadMutexLock(&pTsdb->rCache.rMutex); @@ -1084,13 +1111,13 @@ static int32_t tsdbCacheUpdate(STsdb *pTsdb, tb_uid_t suid, tb_uid_t uid, SArray for (int8_t i = 0; i < pLastCol->rowKey.numOfPKs; i++) { SValue *pValue = &pLastCol->rowKey.pks[i]; if (IS_VAR_DATA_TYPE(pValue->type)) { - reallocVarDataVal(pValue); + TAOS_CHECK_GOTO(reallocVarDataVal(pValue), &lino, _exit); charge += pValue->nData; } } if (IS_VAR_DATA_TYPE(pLastCol->colVal.value.type)) { - reallocVarData(&pLastCol->colVal); + TAOS_CHECK_GOTO(reallocVarData(&pLastCol->colVal), &lino, _exit); charge += pLastCol->colVal.value.nData; } @@ -1117,15 +1144,19 @@ static int32_t tsdbCacheUpdate(STsdb *pTsdb, tb_uid_t suid, tb_uid_t uid, SArray taosArrayDestroy(remainCols); } +_exit: taosThreadMutexUnlock(&pTsdb->lruMutex); -_exit: - return code; + if (code) { + tsdbError("tsdb/cache: vgId:%d, update failed at line %d since %s.", TD_VID(pTsdb->pVnode), lino, tstrerror(code)); + } + + TAOS_RETURN(code); } int32_t tsdbCacheRowFormatUpdate(STsdb *pTsdb, tb_uid_t suid, tb_uid_t uid, int64_t version, int32_t nRow, SRow **aRow) { - int32_t code = 0; + int32_t code = 0, lino = 0; // 1. prepare last TSDBROW lRow = {.type = TSDBROW_ROW_FMT, .pTSRow = aRow[nRow - 1], .version = version}; @@ -1135,11 +1166,7 @@ int32_t tsdbCacheRowFormatUpdate(STsdb *pTsdb, tb_uid_t suid, tb_uid_t uid, int6 SArray *ctxArray = NULL; SSHashObj *iColHash = NULL; - code = metaGetTbTSchemaEx(pTsdb->pVnode->pMeta, suid, uid, sver, &pTSchema); - if (code != TSDB_CODE_SUCCESS) { - terrno = code; - goto _exit; - } + TAOS_CHECK_GOTO(metaGetTbTSchemaEx(pTsdb->pVnode->pMeta, suid, uid, sver, &pTSchema), &lino, _exit); TSDBROW tRow = {.type = TSDBROW_ROW_FMT, .version = version}; int32_t nCol = pTSchema->numOfCols; @@ -1200,7 +1227,8 @@ _exit: taosMemoryFreeClear(pTSchema); taosArrayDestroy(ctxArray); tSimpleHashCleanup(iColHash); - return code; + + TAOS_RETURN(code); } int32_t tsdbCacheColFormatUpdate(STsdb *pTsdb, tb_uid_t suid, tb_uid_t uid, SBlockData *pBlockData) { @@ -1212,11 +1240,7 @@ int32_t tsdbCacheColFormatUpdate(STsdb *pTsdb, tb_uid_t suid, tb_uid_t uid, SBlo int32_t sver = TSDBROW_SVERSION(&lRow); SArray *ctxArray = NULL; - code = metaGetTbTSchemaEx(pTsdb->pVnode->pMeta, suid, uid, sver, &pTSchema); - if (code != TSDB_CODE_SUCCESS) { - terrno = code; - goto _exit; - } + TAOS_CHECK_RETURN(metaGetTbTSchemaEx(pTsdb->pVnode->pMeta, suid, uid, sver, &pTSchema)); ctxArray = taosArrayInit(pBlockData->nColData, sizeof(SLastUpdateCtx)); @@ -1272,7 +1296,8 @@ int32_t tsdbCacheColFormatUpdate(STsdb *pTsdb, tb_uid_t suid, tb_uid_t uid, SBlo _exit: taosMemoryFreeClear(pTSchema); taosArrayDestroy(ctxArray); - return 0; + + TAOS_RETURN(code); } static int32_t mergeLastCid(tb_uid_t uid, STsdb *pTsdb, SArray **ppLastArray, SCacheRowsReader *pr, int16_t *aCols, @@ -1362,7 +1387,7 @@ static int32_t tsdbCacheLoadFromRaw(STsdb *pTsdb, tb_uid_t uid, SArray *pLastArr .colVal = COL_VAL_NONE(idxKey->key.cid, pr->pSchema->columns[slotIds[i]].type)}; if (!pLastCol) { pLastCol = &noneCol; - reallocVarData(&pLastCol->colVal); + TAOS_CHECK_RETURN(reallocVarData(&pLastCol->colVal)); } taosArraySet(pLastArray, idxKey->idx, pLastCol); @@ -1383,12 +1408,12 @@ static int32_t tsdbCacheLoadFromRaw(STsdb *pTsdb, tb_uid_t uid, SArray *pLastArr for (int8_t i = 0; i < pLastCol->rowKey.numOfPKs; i++) { SValue *pValue = &pLastCol->rowKey.pks[i]; if (IS_VAR_DATA_TYPE(pValue->type)) { - reallocVarDataVal(pValue); + TAOS_CHECK_RETURN(reallocVarDataVal(pValue)); charge += pValue->nData; } } if (IS_VAR_DATA_TYPE(pLastCol->colVal.value.type)) { - reallocVarData(&pLastCol->colVal); + TAOS_CHECK_RETURN(reallocVarData(&pLastCol->colVal)); charge += pLastCol->colVal.value.nData; } @@ -1402,7 +1427,10 @@ static int32_t tsdbCacheLoadFromRaw(STsdb *pTsdb, tb_uid_t uid, SArray *pLastArr wb = pTsdb->rCache.rwritebatch; char *value = NULL; size_t vlen = 0; - tsdbCacheSerialize(pLastCol, &value, &vlen); + code = tsdbCacheSerialize(pLastCol, &value, &vlen); + if (code) { + tsdbError("tsdb/cache: vgId:%d, serialize failed since %s.", TD_VID(pTsdb->pVnode), tstrerror(code)); + } SLastKey *key = &idxKey->key; size_t klen = ROCKS_KEY_LEN; @@ -1428,7 +1456,7 @@ static int32_t tsdbCacheLoadFromRaw(STsdb *pTsdb, tb_uid_t uid, SArray *pLastArr taosMemoryFree(slotIds); - return code; + TAOS_RETURN(code); } static int32_t tsdbCacheLoadFromRocks(STsdb *pTsdb, tb_uid_t uid, SArray *pLastArray, SArray *remainCols, @@ -1461,7 +1489,11 @@ static int32_t tsdbCacheLoadFromRocks(STsdb *pTsdb, tb_uid_t uid, SArray *pLastA SLRUCache *pCache = pTsdb->lruCache; for (int i = 0, j = 0; i < num_keys && j < TARRAY_SIZE(remainCols); ++i) { - SLastCol *pLastCol = tsdbCacheDeserialize(values_list[i], values_list_sizes[i]); + SLastCol *pLastCol = NULL; + code = tsdbCacheDeserialize(values_list[i], values_list_sizes[i], &pLastCol); + if (code) { + tsdbError("tsdb/cache: vgId:%d, deserialize failed since %s.", TD_VID(pTsdb->pVnode), tstrerror(code)); + } SLastCol *PToFree = pLastCol; SIdxKey *idxKey = &((SIdxKey *)TARRAY_DATA(remainCols))[j]; if (pLastCol) { @@ -1473,12 +1505,12 @@ static int32_t tsdbCacheLoadFromRocks(STsdb *pTsdb, tb_uid_t uid, SArray *pLastA for (int8_t i = 0; i < pLastCol->rowKey.numOfPKs; i++) { SValue *pValue = &pLastCol->rowKey.pks[i]; if (IS_VAR_DATA_TYPE(pValue->type)) { - reallocVarDataVal(pValue); + TAOS_CHECK_RETURN(reallocVarDataVal(pValue)); charge += pValue->nData; } } if (IS_VAR_DATA_TYPE(pLastCol->colVal.value.type)) { - reallocVarData(&pLastCol->colVal); + TAOS_CHECK_RETURN(reallocVarData(&pLastCol->colVal)); charge += pLastCol->colVal.value.nData; } @@ -1490,9 +1522,9 @@ static int32_t tsdbCacheLoadFromRocks(STsdb *pTsdb, tb_uid_t uid, SArray *pLastA SLastCol lastCol = *pLastCol; for (int8_t i = 0; i < lastCol.rowKey.numOfPKs; i++) { - reallocVarDataVal(&lastCol.rowKey.pks[i]); + TAOS_CHECK_RETURN(reallocVarDataVal(&lastCol.rowKey.pks[i])); } - reallocVarData(&lastCol.colVal); + TAOS_CHECK_RETURN(reallocVarData(&lastCol.colVal)); taosArraySet(pLastArray, idxKey->idx, &lastCol); taosArrayRemove(remainCols, j); @@ -1515,7 +1547,7 @@ static int32_t tsdbCacheLoadFromRocks(STsdb *pTsdb, tb_uid_t uid, SArray *pLastA code = tsdbCacheLoadFromRaw(pTsdb, uid, pLastArray, remainCols, pr, ltype); } - return code; + TAOS_RETURN(code); } int32_t tsdbCacheGetBatch(STsdb *pTsdb, tb_uid_t uid, SArray *pLastArray, SCacheRowsReader *pr, int8_t ltype) { @@ -1545,9 +1577,9 @@ int32_t tsdbCacheGetBatch(STsdb *pTsdb, tb_uid_t uid, SArray *pLastArray, SCache SLastCol lastCol = *pLastCol; for (int8_t j = 0; j < lastCol.rowKey.numOfPKs; j++) { - reallocVarDataVal(&lastCol.rowKey.pks[j]); + TAOS_CHECK_RETURN(reallocVarDataVal(&lastCol.rowKey.pks[j])); } - reallocVarData(&lastCol.colVal); + TAOS_CHECK_RETURN(reallocVarData(&lastCol.colVal)); taosArrayPush(pLastArray, &lastCol); taosLRUCacheRelease(pCache, h, false); @@ -1574,9 +1606,17 @@ int32_t tsdbCacheGetBatch(STsdb *pTsdb, tb_uid_t uid, SArray *pLastArray, SCache SLastCol lastCol = *pLastCol; for (int8_t j = 0; j < lastCol.rowKey.numOfPKs; j++) { - reallocVarDataVal(&lastCol.rowKey.pks[j]); + code = reallocVarDataVal(&lastCol.rowKey.pks[j]); + if (code) { + taosThreadMutexUnlock(&pTsdb->lruMutex); + TAOS_RETURN(code); + } + } + code = reallocVarData(&lastCol.colVal); + if (code) { + taosThreadMutexUnlock(&pTsdb->lruMutex); + TAOS_RETURN(code); } - reallocVarData(&lastCol.colVal); taosArraySet(pLastArray, idxKey->idx, &lastCol); taosLRUCacheRelease(pCache, h, false); @@ -1597,7 +1637,7 @@ int32_t tsdbCacheGetBatch(STsdb *pTsdb, tb_uid_t uid, SArray *pLastArray, SCache } } - return code; + TAOS_RETURN(code); } int32_t tsdbCacheDel(STsdb *pTsdb, tb_uid_t suid, tb_uid_t uid, TSKEY sKey, TSKEY eKey) { @@ -1605,11 +1645,8 @@ int32_t tsdbCacheDel(STsdb *pTsdb, tb_uid_t suid, tb_uid_t uid, TSKEY sKey, TSKE // fetch schema STSchema *pTSchema = NULL; int sver = -1; - code = metaGetTbTSchemaEx(pTsdb->pVnode->pMeta, suid, uid, sver, &pTSchema); - if (code != TSDB_CODE_SUCCESS) { - terrno = code; - return -1; - } + + TAOS_CHECK_RETURN(metaGetTbTSchemaEx(pTsdb->pVnode->pMeta, suid, uid, sver, &pTSchema)); // build keys & multi get from rocks int num_keys = pTSchema->numOfCols; @@ -1652,14 +1689,22 @@ int32_t tsdbCacheDel(STsdb *pTsdb, tb_uid_t suid, tb_uid_t uid, TSKEY sKey, TSKE rocksdb_writebatch_t *wb = pTsdb->rCache.writebatch; for (int i = 0; i < num_keys; ++i) { - SLastCol *pLastCol = tsdbCacheDeserialize(values_list[i], values_list_sizes[i]); + SLastCol *pLastCol = NULL; + code = tsdbCacheDeserialize(values_list[i], values_list_sizes[i], &pLastCol); + if (code) { + tsdbError("tsdb/cache: vgId:%d, deserialize failed since %s.", TD_VID(pTsdb->pVnode), tstrerror(code)); + } taosThreadMutexLock(&pTsdb->rCache.rMutex); if (NULL != pLastCol && (pLastCol->rowKey.ts <= eKey && pLastCol->rowKey.ts >= sKey)) { rocksdb_writebatch_delete(wb, keys_list[i], klen); } taosMemoryFreeClear(pLastCol); - pLastCol = tsdbCacheDeserialize(values_list[i + num_keys], values_list_sizes[i + num_keys]); + pLastCol = NULL; + code = tsdbCacheDeserialize(values_list[i + num_keys], values_list_sizes[i + num_keys], &pLastCol); + if (code) { + tsdbError("tsdb/cache: vgId:%d, deserialize failed since %s.", TD_VID(pTsdb->pVnode), tstrerror(code)); + } if (NULL != pLastCol && (pLastCol->rowKey.ts <= eKey && pLastCol->rowKey.ts >= sKey)) { rocksdb_writebatch_delete(wb, keys_list[num_keys + i], klen); } @@ -1719,37 +1764,24 @@ int32_t tsdbCacheDel(STsdb *pTsdb, tb_uid_t suid, tb_uid_t uid, TSKEY sKey, TSKE _exit: taosMemoryFree(pTSchema); - return code; + TAOS_RETURN(code); } int32_t tsdbOpenCache(STsdb *pTsdb) { - int32_t code = 0; + int32_t code = 0, lino = 0; SLRUCache *pCache = NULL; size_t cfgCapacity = pTsdb->pVnode->config.cacheLastSize * 1024 * 1024; pCache = taosLRUCacheInit(cfgCapacity, 0, .5); if (pCache == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _err; + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _err); } - code = tsdbOpenBCache(pTsdb); - if (code != TSDB_CODE_SUCCESS) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _err; - } + TAOS_CHECK_GOTO(tsdbOpenBCache(pTsdb), &lino, _err); - code = tsdbOpenPgCache(pTsdb); - if (code != TSDB_CODE_SUCCESS) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _err; - } + TAOS_CHECK_GOTO(tsdbOpenPgCache(pTsdb), &lino, _err); - code = tsdbOpenRocksCache(pTsdb); - if (code != TSDB_CODE_SUCCESS) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _err; - } + TAOS_CHECK_GOTO(tsdbOpenRocksCache(pTsdb), &lino, _err); taosLRUCacheSetStrictCapacity(pCache, false); @@ -1759,8 +1791,13 @@ int32_t tsdbOpenCache(STsdb *pTsdb) { pTsdb->flushState.flush_count = 0; _err: + if (code) { + tsdbError("tsdb/cache: vgId:%d, open failed at line %d since %s.", TD_VID(pTsdb->pVnode), lino, tstrerror(code)); + } + pTsdb->lruCache = pCache; - return code; + + TAOS_RETURN(code); } void tsdbCloseCache(STsdb *pTsdb) { @@ -1818,7 +1855,7 @@ static int32_t getTableDelDataFromDelIdx(SDelFReader *pDelReader, SDelIdx *pDelI code = tsdbReadDelDatav1(pDelReader, pDelIdx, aDelData, INT64_MAX); } - return code; + TAOS_RETURN(code); } static int32_t getTableDelDataFromTbData(STbData *pTbData, SArray *aDelData) { @@ -1895,7 +1932,7 @@ static int32_t loadTombFromBlk(const TTombBlkArray *pTombBlkArray, SCacheRowsRea code = isFile ? tsdbDataFileReadTombBlock(pFileReader, &pTombBlkArray->data[i], &block) : tsdbSttFileReadTombBlock(pFileReader, &pTombBlkArray->data[i], &block); if (code != TSDB_CODE_SUCCESS) { - return code; + TAOS_RETURN(code); } uint64_t uid = uidList[j]; @@ -1959,37 +1996,28 @@ static int32_t loadTombFromBlk(const TTombBlkArray *pTombBlkArray, SCacheRowsRea tTombBlockDestroy(&block); if (finished) { - return code; + TAOS_RETURN(code); } } - return TSDB_CODE_SUCCESS; + TAOS_RETURN(TSDB_CODE_SUCCESS); } static int32_t loadDataTomb(SCacheRowsReader *pReader, SDataFileReader *pFileReader) { - int32_t code = 0; - const TTombBlkArray *pBlkArray = NULL; - code = tsdbDataFileReadTombBlk(pFileReader, &pBlkArray); - if (code != TSDB_CODE_SUCCESS) { - return code; - } - return loadTombFromBlk(pBlkArray, pReader, pFileReader, true); + TAOS_CHECK_RETURN(tsdbDataFileReadTombBlk(pFileReader, &pBlkArray)); + + TAOS_RETURN(loadTombFromBlk(pBlkArray, pReader, pFileReader, true)); } static int32_t loadSttTomb(STsdbReader *pTsdbReader, SSttFileReader *pSttFileReader, SSttBlockLoadInfo *pLoadInfo) { - int32_t code = 0; - - SCacheRowsReader *pReader = (SCacheRowsReader *)pTsdbReader; - + SCacheRowsReader *pReader = (SCacheRowsReader *)pTsdbReader; const TTombBlkArray *pBlkArray = NULL; - code = tsdbSttFileReadTombBlk(pSttFileReader, &pBlkArray); - if (code != TSDB_CODE_SUCCESS) { - return code; - } - return loadTombFromBlk(pBlkArray, pReader, pSttFileReader, false); + TAOS_CHECK_RETURN(tsdbSttFileReadTombBlk(pSttFileReader, &pBlkArray)); + + TAOS_RETURN(loadTombFromBlk(pBlkArray, pReader, pSttFileReader, false)); } typedef struct { @@ -2022,14 +2050,11 @@ static int32_t lastIterOpen(SFSLastIter *iter, STFileSet *pFileSet, STsdb *pTsdb .pCurRowKey = &pr->rowKey, }; - code = tMergeTreeOpen2(&iter->mergeTree, &conf, NULL); - if (code != TSDB_CODE_SUCCESS) { - return -1; - } + TAOS_CHECK_RETURN(tMergeTreeOpen2(&iter->mergeTree, &conf, NULL)); iter->pMergeTree = &iter->mergeTree; - return code; + TAOS_RETURN(code); } static int32_t lastIterClose(SFSLastIter **iter) { @@ -2042,7 +2067,7 @@ static int32_t lastIterClose(SFSLastIter **iter) { *iter = NULL; - return code; + TAOS_RETURN(code); } static int32_t lastIterNext(SFSLastIter *iter, TSDBROW **ppRow) { @@ -2051,12 +2076,13 @@ static int32_t lastIterNext(SFSLastIter *iter, TSDBROW **ppRow) { bool hasVal = tMergeTreeNext(iter->pMergeTree); if (!hasVal) { *ppRow = NULL; - return code; + + TAOS_RETURN(code); } *ppRow = tMergeTreeGetRow(iter->pMergeTree); - return code; + TAOS_RETURN(code); } typedef enum SFSNEXTROWSTATES { @@ -2107,8 +2133,8 @@ static void clearLastFileSet(SFSNextRowIter *state); static int32_t getNextRowFromFS(void *iter, TSDBROW **ppRow, bool *pIgnoreEarlierTs, bool isLast, int16_t *aCols, int nCols) { + int32_t code = 0, lino = 0; SFSNextRowIter *state = (SFSNextRowIter *)iter; - int32_t code = 0; STsdb *pTsdb = state->pr->pTsdb; if (SFSNEXTROW_FS == state->state) { @@ -2123,7 +2149,8 @@ static int32_t getNextRowFromFS(void *iter, TSDBROW **ppRow, bool *pIgnoreEarlie if (--state->iFileSet < 0) { *ppRow = NULL; - return code; + + TAOS_RETURN(code); } else { state->pFileSet = TARRAY2_GET(state->aDFileSet, state->iFileSet); } @@ -2153,19 +2180,13 @@ static int32_t getNextRowFromFS(void *iter, TSDBROW **ppRow, bool *pIgnoreEarlie filesName[3] = pFileObj[3]->fname; } - code = tsdbDataFileReaderOpen(filesName, &conf, &state->pr->pFileReader); - if (code != TSDB_CODE_SUCCESS) { - goto _err; - } + TAOS_CHECK_GOTO(tsdbDataFileReaderOpen(filesName, &conf, &state->pr->pFileReader), &lino, _err); state->pr->pCurFileSet = state->pFileSet; loadDataTomb(state->pr, state->pr->pFileReader); - int32_t code = tsdbDataFileReadBrinBlk(state->pr->pFileReader, &state->pr->pBlkArray); - if (code != TSDB_CODE_SUCCESS) { - goto _err; - } + TAOS_CHECK_GOTO(tsdbDataFileReadBrinBlk(state->pr->pFileReader, &state->pr->pBlkArray), &lino, _err); } if (!state->pIndexList) { @@ -2202,16 +2223,11 @@ static int32_t getNextRowFromFS(void *iter, TSDBROW **ppRow, bool *pIgnoreEarlie state->pr->pCurFileSet = state->pFileSet; } - code = lastIterOpen(&state->lastIter, state->pFileSet, pTsdb, state->pTSchema, state->suid, state->uid, state->pr, - state->lastTs, aCols, nCols); - if (code != TSDB_CODE_SUCCESS) { - goto _err; - } + TAOS_CHECK_GOTO(lastIterOpen(&state->lastIter, state->pFileSet, pTsdb, state->pTSchema, state->suid, state->uid, + state->pr, state->lastTs, aCols, nCols), + &lino, _err); - code = lastIterNext(&state->lastIter, &state->pLastRow); - if (code != TSDB_CODE_SUCCESS) { - goto _err; - } + TAOS_CHECK_GOTO(lastIterNext(&state->lastIter, &state->pLastRow), &lino, _err); if (!state->pLastRow) { state->lastEmpty = 1; @@ -2228,7 +2244,8 @@ static int32_t getNextRowFromFS(void *iter, TSDBROW **ppRow, bool *pIgnoreEarlie *ppRow = state->pLastRow; state->pLastRow = NULL; - return code; + + TAOS_RETURN(code); } } @@ -2236,10 +2253,7 @@ static int32_t getNextRowFromFS(void *iter, TSDBROW **ppRow, bool *pIgnoreEarlie } if (SFSNEXTROW_NEXTSTTROW == state->state) { - code = lastIterNext(&state->lastIter, &state->pLastRow); - if (code != TSDB_CODE_SUCCESS) { - goto _err; - } + TAOS_CHECK_GOTO(lastIterNext(&state->lastIter, &state->pLastRow), &lino, _err); if (!state->pLastRow) { if (state->pLastIter) { @@ -2252,7 +2266,8 @@ static int32_t getNextRowFromFS(void *iter, TSDBROW **ppRow, bool *pIgnoreEarlie } else { *ppRow = state->pLastRow; state->pLastRow = NULL; - return code; + + TAOS_RETURN(code); } } @@ -2278,10 +2293,8 @@ static int32_t getNextRowFromFS(void *iter, TSDBROW **ppRow, bool *pIgnoreEarlie } else { tBrinBlockClear(&state->brinBlock); } - code = tsdbDataFileReadBrinBlock(state->pr->pFileReader, pBrinBlk, &state->brinBlock); - if (code != TSDB_CODE_SUCCESS) { - goto _err; - } + + TAOS_CHECK_GOTO(tsdbDataFileReadBrinBlock(state->pr->pFileReader, pBrinBlk, &state->brinBlock), &lino, _err); state->iBrinRecord = state->brinBlock.numOfRecords - 1; state->state = SFSNEXTROW_BRINBLOCK; @@ -2293,10 +2306,8 @@ static int32_t getNextRowFromFS(void *iter, TSDBROW **ppRow, bool *pIgnoreEarlie tBrinBlockClear(&state->brinBlock); goto _next_brinindex; } - code = tBrinBlockGet(&state->brinBlock, state->iBrinRecord, &state->brinRecord); - if (code != TSDB_CODE_SUCCESS) { - goto _err; - } + + TAOS_CHECK_GOTO(tBrinBlockGet(&state->brinBlock, state->iBrinRecord, &state->brinRecord), &lino, _err); SBrinRecord *pRecord = &state->brinRecord; if (pRecord->uid != state->uid) { @@ -2313,8 +2324,8 @@ static int32_t getNextRowFromFS(void *iter, TSDBROW **ppRow, bool *pIgnoreEarlie if (!state->pBlockData) { state->pBlockData = &state->blockData; - code = tBlockDataCreate(&state->blockData); - if (code) goto _err; + + TAOS_CHECK_GOTO(tBlockDataCreate(&state->blockData), &lino, _err); } else { tBlockDataReset(state->pBlockData); } @@ -2323,11 +2334,10 @@ static int32_t getNextRowFromFS(void *iter, TSDBROW **ppRow, bool *pIgnoreEarlie --nCols; ++aCols; } - code = tsdbDataFileReadBlockDataByColumn(state->pr->pFileReader, pRecord, state->pBlockData, state->pTSchema, aCols, - nCols); - if (code != TSDB_CODE_SUCCESS) { - goto _err; - } + + TAOS_CHECK_GOTO(tsdbDataFileReadBlockDataByColumn(state->pr->pFileReader, pRecord, state->pBlockData, + state->pTSchema, aCols, nCols), + &lino, _err); state->nRow = state->blockData.nRow; state->iRow = state->nRow - 1; @@ -2350,10 +2360,7 @@ static int32_t getNextRowFromFS(void *iter, TSDBROW **ppRow, bool *pIgnoreEarlie if (!state->pLastRow) { // get next row from fslast and process with fs row, --state->Row if select fs row - code = lastIterNext(&state->lastIter, &state->pLastRow); - if (code != TSDB_CODE_SUCCESS) { - goto _err; - } + TAOS_CHECK_GOTO(lastIterNext(&state->lastIter, &state->pLastRow), &lino, _err); } if (!state->pLastRow) { @@ -2372,34 +2379,27 @@ static int32_t getNextRowFromFS(void *iter, TSDBROW **ppRow, bool *pIgnoreEarlie if (lastRowTs > rowTs) { *ppRow = state->pLastRow; state->pLastRow = NULL; - return code; + + TAOS_RETURN(code); } else if (lastRowTs < rowTs) { *ppRow = &state->row; --state->iRow; - return code; + + TAOS_RETURN(code); } else { // TODO: merge rows and *ppRow = mergedRow SRowMerger *pMerger = &state->rowMerger; tsdbRowMergerInit(pMerger, state->pTSchema); - code = tsdbRowMergerAdd(pMerger, &state->row, state->pTSchema); - if (code != TSDB_CODE_SUCCESS) { - goto _err; - } - code = tsdbRowMergerAdd(pMerger, state->pLastRow, state->pTSchema); - if (code != TSDB_CODE_SUCCESS) { - goto _err; - } + TAOS_CHECK_GOTO(tsdbRowMergerAdd(pMerger, &state->row, state->pTSchema), &lino, _err); + TAOS_CHECK_GOTO(tsdbRowMergerAdd(pMerger, state->pLastRow, state->pTSchema), &lino, _err); if (state->pTSRow) { taosMemoryFree(state->pTSRow); state->pTSRow = NULL; } - code = tsdbRowMergerGetRow(pMerger, &state->pTSRow); - if (code != TSDB_CODE_SUCCESS) { - goto _err; - } + TAOS_CHECK_GOTO(tsdbRowMergerGetRow(pMerger, &state->pTSRow), &lino, _err); state->row = tsdbRowFromTSRow(TSDBROW_VERSION(&state->row), state->pTSRow); *ppRow = &state->row; @@ -2407,7 +2407,7 @@ static int32_t getNextRowFromFS(void *iter, TSDBROW **ppRow, bool *pIgnoreEarlie tsdbRowMergerClear(pMerger); - return code; + TAOS_RETURN(code); } } @@ -2416,7 +2416,12 @@ _err: *ppRow = NULL; - return code; + if (code) { + tsdbError("tsdb/cache: vgId:%d, %s failed at line %d since %s.", TD_VID(pTsdb->pVnode), __func__, lino, + tstrerror(code)); + } + + TAOS_RETURN(code); } typedef enum SMEMNEXTROWSTATES { @@ -2442,7 +2447,8 @@ static int32_t getNextRowFromMem(void *iter, TSDBROW **ppRow, bool *pIgnoreEarli if (state->pMem->maxKey <= state->lastTs) { *ppRow = NULL; *pIgnoreEarlierTs = true; - return code; + + TAOS_RETURN(code); } tsdbTbDataIterOpen(state->pMem, NULL, 1, &state->iter); @@ -2451,23 +2457,23 @@ static int32_t getNextRowFromMem(void *iter, TSDBROW **ppRow, bool *pIgnoreEarli *ppRow = pMemRow; state->state = SMEMNEXTROW_NEXT; - return code; + TAOS_RETURN(code); } } *ppRow = NULL; - return code; + TAOS_RETURN(code); } case SMEMNEXTROW_NEXT: if (tsdbTbDataIterNext(&state->iter)) { *ppRow = tsdbTbDataIterGet(&state->iter); - return code; + TAOS_RETURN(code); } else { *ppRow = NULL; - return code; + TAOS_RETURN(code); } default: ASSERT(0); @@ -2476,7 +2482,8 @@ static int32_t getNextRowFromMem(void *iter, TSDBROW **ppRow, bool *pIgnoreEarli _err: *ppRow = NULL; - return code; + + TAOS_RETURN(code); } static bool tsdbKeyDeleted(TSDBKEY *key, SArray *pSkyline, int64_t *iSkyline) { @@ -2543,7 +2550,7 @@ int32_t clearNextRowFromFS(void *iter) { SFSNextRowIter *state = (SFSNextRowIter *)iter; if (!state) { - return code; + TAOS_RETURN(code); } if (state->pLastIter) { @@ -2575,7 +2582,7 @@ int32_t clearNextRowFromFS(void *iter) { state->pRowIter->pSkyline = NULL; } - return code; + TAOS_RETURN(code); } static void clearLastFileSet(SFSNextRowIter *state) { @@ -2617,7 +2624,7 @@ static void clearLastFileSet(SFSNextRowIter *state) { static int32_t nextRowIterOpen(CacheNextRowIter *pIter, tb_uid_t uid, STsdb *pTsdb, STSchema *pTSchema, tb_uid_t suid, SArray *pLDataIterArray, STsdbReadSnap *pReadSnap, int64_t lastTs, SCacheRowsReader *pr) { - int code = 0; + int32_t code = 0, lino = 0; STbData *pMem = NULL; if (pReadSnap->pMem) { @@ -2633,10 +2640,7 @@ static int32_t nextRowIterOpen(CacheNextRowIter *pIter, tb_uid_t uid, STsdb *pTs pIter->pMemDelData = NULL; - code = loadMemTombData(&pIter->pMemDelData, pMem, pIMem, pr->info.verRange.maxVer); - if (code != TSDB_CODE_SUCCESS) { - goto _err; - } + TAOS_CHECK_GOTO(loadMemTombData(&pIter->pMemDelData, pMem, pIMem, pr->info.verRange.maxVer), &lino, _err); pIter->idx = (SBlockIdx){.suid = suid, .uid = uid}; @@ -2672,12 +2676,13 @@ static int32_t nextRowIterOpen(CacheNextRowIter *pIter, tb_uid_t uid, STsdb *pTs } pIter->pr = pr; + _err: - return code; + TAOS_RETURN(code); } static int32_t nextRowIterClose(CacheNextRowIter *pIter) { - int code = 0; + int32_t code = 0; for (int i = 0; i < 3; ++i) { if (pIter->input[i].nextRowClearFn) { @@ -2694,19 +2699,20 @@ static int32_t nextRowIterClose(CacheNextRowIter *pIter) { } _err: - return code; + TAOS_RETURN(code); } // iterate next row non deleted backward ts, version (from high to low) static int32_t nextRowIterGet(CacheNextRowIter *pIter, TSDBROW **ppRow, bool *pIgnoreEarlierTs, bool isLast, int16_t *aCols, int nCols) { - int code = 0; + int32_t code = 0, lino = 0; + for (;;) { for (int i = 0; i < 3; ++i) { if (pIter->input[i].next && !pIter->input[i].stop) { - code = pIter->input[i].nextRowFn(pIter->input[i].iter, &pIter->input[i].pRow, &pIter->input[i].ignoreEarlierTs, - isLast, aCols, nCols); - if (code) goto _err; + TAOS_CHECK_GOTO(pIter->input[i].nextRowFn(pIter->input[i].iter, &pIter->input[i].pRow, + &pIter->input[i].ignoreEarlierTs, isLast, aCols, nCols), + &lino, _err); if (pIter->input[i].pRow == NULL) { pIter->input[i].stop = true; @@ -2719,7 +2725,8 @@ static int32_t nextRowIterGet(CacheNextRowIter *pIter, TSDBROW **ppRow, bool *pI *ppRow = NULL; *pIgnoreEarlierTs = (pIter->input[0].ignoreEarlierTs || pIter->input[1].ignoreEarlierTs || pIter->input[2].ignoreEarlierTs); - return code; + + TAOS_RETURN(code); } // select maxpoint(s) from mem, imem, fs and last @@ -2785,18 +2792,24 @@ static int32_t nextRowIterGet(CacheNextRowIter *pIter, TSDBROW **ppRow, bool *pI pIter->input[iMerge[0]].next = true; *ppRow = merge[0]; - return code; + + TAOS_RETURN(code); } } _err: - return code; + + if (code) { + tsdbError("tsdb/cache: %s failed at line %d since %s.", __func__, lino, tstrerror(code)); + } + + TAOS_RETURN(code); } static int32_t initLastColArrayPartial(STSchema *pTSchema, SArray **ppColArray, int16_t *slotIds, int nCols) { SArray *pColArray = taosArrayInit(nCols, sizeof(SLastCol)); if (NULL == pColArray) { - return TSDB_CODE_OUT_OF_MEMORY; + TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); } for (int32_t i = 0; i < nCols; ++i) { @@ -2806,34 +2819,38 @@ static int32_t initLastColArrayPartial(STSchema *pTSchema, SArray **ppColArray, taosArrayPush(pColArray, &col); } *ppColArray = pColArray; - return TSDB_CODE_SUCCESS; + + TAOS_RETURN(TSDB_CODE_SUCCESS); } static int32_t cloneTSchema(STSchema *pSrc, STSchema **ppDst) { int32_t len = sizeof(STSchema) + sizeof(STColumn) * pSrc->numOfCols; *ppDst = taosMemoryMalloc(len); if (NULL == *ppDst) { - return TSDB_CODE_OUT_OF_MEMORY; + TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); } memcpy(*ppDst, pSrc, len); - return TSDB_CODE_SUCCESS; + + TAOS_RETURN(TSDB_CODE_SUCCESS); } static int32_t updateTSchema(int32_t sversion, SCacheRowsReader *pReader, uint64_t uid) { if (NULL == pReader->pCurrSchema && sversion == pReader->pSchema->version) { - return cloneTSchema(pReader->pSchema, &pReader->pCurrSchema); + TAOS_RETURN(cloneTSchema(pReader->pSchema, &pReader->pCurrSchema)); } if (NULL != pReader->pCurrSchema && sversion == pReader->pCurrSchema->version) { - return TSDB_CODE_SUCCESS; + TAOS_RETURN(TSDB_CODE_SUCCESS); } taosMemoryFreeClear(pReader->pCurrSchema); - return metaGetTbTSchemaEx(pReader->pTsdb->pVnode->pMeta, pReader->info.suid, uid, sversion, &pReader->pCurrSchema); + TAOS_RETURN( + metaGetTbTSchemaEx(pReader->pTsdb->pVnode->pMeta, pReader->info.suid, uid, sversion, &pReader->pCurrSchema)); } static int32_t mergeLastCid(tb_uid_t uid, STsdb *pTsdb, SArray **ppLastArray, SCacheRowsReader *pr, int16_t *aCols, int nCols, int16_t *slotIds) { + int32_t code = 0, lino = 0; STSchema *pTSchema = pr->pSchema; // metaGetTbTSchema(pTsdb->pVnode->pMeta, uid, -1, 1); int16_t nLastCol = nCols; int16_t noneCol = 0; @@ -2843,15 +2860,13 @@ static int32_t mergeLastCid(tb_uid_t uid, STsdb *pTsdb, SArray **ppLastArray, SC SArray *pColArray = NULL; SColVal *pColVal = &(SColVal){0}; - int32_t code = initLastColArrayPartial(pTSchema, &pColArray, slotIds, nCols); - if (TSDB_CODE_SUCCESS != code) { - return code; - } + TAOS_CHECK_RETURN(initLastColArrayPartial(pTSchema, &pColArray, slotIds, nCols)); + SArray *aColArray = taosArrayInit(nCols, sizeof(int16_t)); if (NULL == aColArray) { taosArrayDestroy(pColArray); - return TSDB_CODE_OUT_OF_MEMORY; + TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); } for (int i = 0; i < nCols; ++i) { @@ -2876,10 +2891,8 @@ static int32_t mergeLastCid(tb_uid_t uid, STsdb *pTsdb, SArray **ppLastArray, SC int32_t sversion = TSDBROW_SVERSION(pRow); if (sversion != -1) { - code = updateTSchema(sversion, pr, uid); - if (TSDB_CODE_SUCCESS != code) { - goto _err; - } + TAOS_CHECK_GOTO(updateTSchema(sversion, pr, uid), &lino, _err); + pTSchema = pr->pCurrSchema; } // int16_t nCol = pTSchema->numOfCols; @@ -2919,9 +2932,7 @@ static int32_t mergeLastCid(tb_uid_t uid, STsdb *pTsdb, SArray **ppLastArray, SC if (pColVal->value.nData > 0) { pCol->colVal.value.pData = taosMemoryMalloc(pCol->colVal.value.nData); if (pCol->colVal.value.pData == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - code = TSDB_CODE_OUT_OF_MEMORY; - goto _err; + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _err); } memcpy(pCol->colVal.value.pData, pColVal->value.pData, pColVal->value.nData); } else { @@ -2973,9 +2984,7 @@ static int32_t mergeLastCid(tb_uid_t uid, STsdb *pTsdb, SArray **ppLastArray, SC if (pColVal->value.nData > 0) { lastCol.colVal.value.pData = taosMemoryMalloc(lastCol.colVal.value.nData); if (lastCol.colVal.value.pData == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - code = TSDB_CODE_OUT_OF_MEMORY; - goto _err; + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _err); } memcpy(lastCol.colVal.value.pData, pColVal->value.pData, pColVal->value.nData); } else { @@ -3008,7 +3017,7 @@ static int32_t mergeLastCid(tb_uid_t uid, STsdb *pTsdb, SArray **ppLastArray, SC nextRowIterClose(&iter); taosArrayDestroy(aColArray); - return code; + TAOS_RETURN(code); _err: nextRowIterClose(&iter); @@ -3016,11 +3025,18 @@ _err: *ppLastArray = NULL; taosArrayDestroy(pColArray); taosArrayDestroy(aColArray); - return code; + + if (code) { + tsdbError("tsdb/cache: vgId:%d, %s failed at line %d since %s.", TD_VID(pTsdb->pVnode), __func__, lino, + tstrerror(code)); + } + + TAOS_RETURN(code); } static int32_t mergeLastRowCid(tb_uid_t uid, STsdb *pTsdb, SArray **ppLastArray, SCacheRowsReader *pr, int16_t *aCols, int nCols, int16_t *slotIds) { + int32_t code = 0, lino = 0; STSchema *pTSchema = pr->pSchema; // metaGetTbTSchema(pTsdb->pVnode->pMeta, uid, -1, 1); int16_t nLastCol = nCols; int16_t noneCol = 0; @@ -3030,15 +3046,13 @@ static int32_t mergeLastRowCid(tb_uid_t uid, STsdb *pTsdb, SArray **ppLastArray, SArray *pColArray = NULL; SColVal *pColVal = &(SColVal){0}; - int32_t code = initLastColArrayPartial(pTSchema, &pColArray, slotIds, nCols); - if (TSDB_CODE_SUCCESS != code) { - return code; - } + TAOS_CHECK_RETURN(initLastColArrayPartial(pTSchema, &pColArray, slotIds, nCols)); + SArray *aColArray = taosArrayInit(nCols, sizeof(int16_t)); if (NULL == aColArray) { taosArrayDestroy(pColArray); - return TSDB_CODE_OUT_OF_MEMORY; + TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); } for (int i = 0; i < nCols; ++i) { @@ -3061,10 +3075,8 @@ static int32_t mergeLastRowCid(tb_uid_t uid, STsdb *pTsdb, SArray **ppLastArray, int32_t sversion = TSDBROW_SVERSION(pRow); if (sversion != -1) { - code = updateTSchema(sversion, pr, uid); - if (TSDB_CODE_SUCCESS != code) { - goto _err; - } + TAOS_CHECK_GOTO(updateTSchema(sversion, pr, uid), &lino, _err); + pTSchema = pr->pCurrSchema; } // int16_t nCol = pTSchema->numOfCols; @@ -3097,9 +3109,7 @@ static int32_t mergeLastRowCid(tb_uid_t uid, STsdb *pTsdb, SArray **ppLastArray, if (pColVal->value.nData > 0) { pCol->colVal.value.pData = taosMemoryMalloc(pCol->colVal.value.nData); if (pCol->colVal.value.pData == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - code = TSDB_CODE_OUT_OF_MEMORY; - goto _err; + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _err); } if (pColVal->value.nData > 0) { memcpy(pCol->colVal.value.pData, pColVal->value.pData, pColVal->value.nData); @@ -3131,7 +3141,7 @@ static int32_t mergeLastRowCid(tb_uid_t uid, STsdb *pTsdb, SArray **ppLastArray, nextRowIterClose(&iter); taosArrayDestroy(aColArray); - return code; + TAOS_RETURN(code); _err: nextRowIterClose(&iter); @@ -3139,7 +3149,13 @@ _err: *ppLastArray = NULL; taosArrayDestroy(pColArray); taosArrayDestroy(aColArray); - return code; + + if (code) { + tsdbError("tsdb/cache: vgId:%d, %s failed at line %d since %s.", TD_VID(pTsdb->pVnode), __func__, lino, + tstrerror(code)); + } + + TAOS_RETURN(code); } int32_t tsdbCacheRelease(SLRUCache *pCache, LRUHandle *h) { @@ -3194,22 +3210,10 @@ static void getBCacheKey(int32_t fid, int64_t commitID, int64_t blkno, char *key static int32_t tsdbCacheLoadBlockS3(STsdbFD *pFD, uint8_t **ppBlock) { int32_t code = 0; - /* - uint8_t *pBlock = taosMemoryCalloc(1, tsS3BlockSize * pFD->szPage); - if (pBlock == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _exit; - } - */ - int64_t block_offset = (pFD->blkno - 1) * tsS3BlockSize * pFD->szPage; - code = s3GetObjectBlock(pFD->objName, block_offset, tsS3BlockSize * pFD->szPage, 0, ppBlock); - if (code != TSDB_CODE_SUCCESS) { - // taosMemoryFree(pBlock); - // code = TSDB_CODE_OUT_OF_MEMORY; - return code; - } - //*ppBlock = pBlock; + int64_t block_offset = (pFD->blkno - 1) * tsS3BlockSize * pFD->szPage; + + TAOS_CHECK_RETURN(s3GetObjectBlock(pFD->objName, block_offset, tsS3BlockSize * pFD->szPage, 0, ppBlock)); tsdbTrace("block:%p load from s3", *ppBlock); @@ -3247,7 +3251,8 @@ int32_t tsdbCacheGetBlockS3(SLRUCache *pCache, STsdbFD *pFD, LRUHandle **handle) if (code == TSDB_CODE_SUCCESS && !pBlock) { code = TSDB_CODE_OUT_OF_MEMORY; } - return code; + + TAOS_RETURN(code); } size_t charge = tsS3BlockSize * pFD->szPage; @@ -3255,7 +3260,7 @@ int32_t tsdbCacheGetBlockS3(SLRUCache *pCache, STsdbFD *pFD, LRUHandle **handle) LRUStatus status = taosLRUCacheInsert(pCache, key, keyLen, pBlock, charge, deleter, &h, TAOS_LRU_PRIORITY_LOW, NULL); if (status != TAOS_LRU_STATUS_OK) { - code = -1; + // code = -1; } } @@ -3264,7 +3269,7 @@ int32_t tsdbCacheGetBlockS3(SLRUCache *pCache, STsdbFD *pFD, LRUHandle **handle) *handle = h; - return code; + TAOS_RETURN(code); } int32_t tsdbCacheGetPageS3(SLRUCache *pCache, STsdbFD *pFD, int64_t pgno, LRUHandle **handle) { @@ -3304,5 +3309,5 @@ int32_t tsdbCacheSetPageS3(SLRUCache *pCache, STsdbFD *pFD, int64_t pgno, uint8_ tsdbCacheRelease(pFD->pTsdb->pgCache, handle); - return code; + TAOS_RETURN(code); } From d8649065d17d2957e90df06767c6b2a612efd383 Mon Sep 17 00:00:00 2001 From: dmchen Date: Thu, 25 Jul 2024 01:22:10 +0000 Subject: [PATCH 05/12] fix/TD-30989 --- source/dnode/mnode/impl/src/mndTrans.c | 148 +++++++++++++------------ 1 file changed, 78 insertions(+), 70 deletions(-) diff --git a/source/dnode/mnode/impl/src/mndTrans.c b/source/dnode/mnode/impl/src/mndTrans.c index 58dab20859..9b4379fb36 100644 --- a/source/dnode/mnode/impl/src/mndTrans.c +++ b/source/dnode/mnode/impl/src/mndTrans.c @@ -541,8 +541,7 @@ static int32_t mndTransActionUpdate(SSdb *pSdb, STrans *pOld, STrans *pNew) { pOld->id, pOld, mndTransStr(pOld->stage), pOld->createdTime, pNew, mndTransStr(pNew->stage), pNew->createdTime); // only occured while sync timeout - terrno = TSDB_CODE_MND_TRANS_SYNC_TIMEOUT; - return -1; + TAOS_RETURN(TSDB_CODE_MND_TRANS_SYNC_TIMEOUT); } mndTransUpdateActions(pOld->prepareActions, pNew->prepareActions); @@ -660,8 +659,7 @@ static int32_t mndTransAppendAction(SArray *pArray, STransAction *pAction) { void *ptr = taosArrayPush(pArray, pAction); if (ptr == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - return -1; + TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); } return 0; @@ -772,26 +770,29 @@ void mndTransSetChangeless(STrans *pTrans) { pTrans->changeless = true; } void mndTransSetOper(STrans *pTrans, EOperType oper) { pTrans->oper = oper; } static int32_t mndTransSync(SMnode *pMnode, STrans *pTrans) { + int32_t code = 0; SSdbRaw *pRaw = mndTransEncode(pTrans); if (pRaw == NULL) { - mError("trans:%d, failed to encode while sync trans since %s", pTrans->id, terrstr()); - return -1; + code = TSDB_CODE_MND_RETURN_VALUE_NULL; + if (terrno != 0) code = terrno; + mError("trans:%d, failed to encode while sync trans since %s", pTrans->id, tstrerror(code)); + TAOS_RETURN(code); } (void)sdbSetRawStatus(pRaw, SDB_STATUS_READY); mInfo("trans:%d, sync to other mnodes, stage:%s createTime:%" PRId64, pTrans->id, mndTransStr(pTrans->stage), pTrans->createdTime); - int32_t code = mndSyncPropose(pMnode, pRaw, pTrans->id); + code = mndSyncPropose(pMnode, pRaw, pTrans->id); if (code != 0) { - mError("trans:%d, failed to sync, errno:%s code:0x%x createTime:%" PRId64 " saved trans:%d", pTrans->id, terrstr(), - code, pTrans->createdTime, pMnode->syncMgmt.transId); + mError("trans:%d, failed to sync, errno:%s code:0x%x createTime:%" PRId64 " saved trans:%d", pTrans->id, + tstrerror(code), code, pTrans->createdTime, pMnode->syncMgmt.transId); sdbFreeRaw(pRaw); - return -1; + TAOS_RETURN(code); } sdbFreeRaw(pRaw); mInfo("trans:%d, sync finished, createTime:%" PRId64, pTrans->id, pTrans->createdTime); - return 0; + TAOS_RETURN(code); } static bool mndCheckDbConflict(const char *conflict, STrans *pTrans) { @@ -883,24 +884,26 @@ static bool mndCheckTransConflict(SMnode *pMnode, STrans *pNew) { } int32_t mndTransCheckConflict(SMnode *pMnode, STrans *pTrans) { + int32_t code = 0; if (pTrans->conflict == TRN_CONFLICT_DB || pTrans->conflict == TRN_CONFLICT_DB_INSIDE) { if (strlen(pTrans->dbname) == 0 && strlen(pTrans->stbname) == 0) { - terrno = TSDB_CODE_MND_TRANS_CONFLICT; + code = TSDB_CODE_MND_TRANS_CONFLICT; mError("trans:%d, failed to prepare conflict db not set", pTrans->id); - return -1; + TAOS_RETURN(code); } } if (mndCheckTransConflict(pMnode, pTrans)) { - terrno = TSDB_CODE_MND_TRANS_CONFLICT; - mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr()); - return terrno; + code = TSDB_CODE_MND_TRANS_CONFLICT; + mError("trans:%d, failed to prepare since %s", pTrans->id, tstrerror(code)); + TAOS_RETURN(code); } - return 0; + TAOS_RETURN(code); } int32_t mndTransCheckConflictWithCompact(SMnode *pMnode, STrans *pTrans) { + int32_t code = 0; void *pIter = NULL; bool conflict = false; SCompactObj *pCompact = NULL; @@ -927,12 +930,12 @@ int32_t mndTransCheckConflictWithCompact(SMnode *pMnode, STrans *pTrans) { } if (conflict) { - terrno = TSDB_CODE_MND_TRANS_CONFLICT_COMPACT; - mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr()); - return terrno; + code = TSDB_CODE_MND_TRANS_CONFLICT_COMPACT; + mError("trans:%d, failed to prepare since %s", pTrans->id, tstrerror(code)); + TAOS_RETURN(code); } - return 0; + TAOS_RETURN(code); } static bool mndTransActionsOfSameType(SArray *pActions) { @@ -953,66 +956,65 @@ static bool mndTransActionsOfSameType(SArray *pActions) { } static int32_t mndTransCheckParallelActions(SMnode *pMnode, STrans *pTrans) { + int32_t code = 0; if (pTrans->exec == TRN_EXEC_PARALLEL) { if (mndTransActionsOfSameType(pTrans->redoActions) == false) { - terrno = TSDB_CODE_MND_TRANS_INVALID_STAGE; + code = TSDB_CODE_MND_TRANS_INVALID_STAGE; mError("trans:%d, types of parallel redo actions are not the same", pTrans->id); - return -1; + TAOS_RETURN(code); } if (pTrans->policy == TRN_POLICY_ROLLBACK) { if (mndTransActionsOfSameType(pTrans->undoActions) == false) { - terrno = TSDB_CODE_MND_TRANS_INVALID_STAGE; + code = TSDB_CODE_MND_TRANS_INVALID_STAGE; mError("trans:%d, types of parallel undo actions are not the same", pTrans->id); - return -1; + TAOS_RETURN(code); } } } - return 0; + TAOS_RETURN(code); } static int32_t mndTransCheckCommitActions(SMnode *pMnode, STrans *pTrans) { + int32_t code = 0; if (!pTrans->changeless && taosArrayGetSize(pTrans->commitActions) <= 0) { - terrno = TSDB_CODE_MND_TRANS_CLOG_IS_NULL; + code = TSDB_CODE_MND_TRANS_CLOG_IS_NULL; mError("trans:%d, commit actions of non-changeless trans are empty", pTrans->id); - return -1; + TAOS_RETURN(code); } if (mndTransActionsOfSameType(pTrans->commitActions) == false) { - terrno = TSDB_CODE_MND_TRANS_INVALID_STAGE; + code = TSDB_CODE_MND_TRANS_INVALID_STAGE; mError("trans:%d, types of commit actions are not the same", pTrans->id); - return -1; + TAOS_RETURN(code); } - return 0; + TAOS_RETURN(code); } int32_t mndTransPrepare(SMnode *pMnode, STrans *pTrans) { + int32_t code = 0; if (pTrans == NULL) return -1; - if (mndTransCheckConflict(pMnode, pTrans) != 0) { - return -1; - } + TAOS_CHECK_RETURN(mndTransCheckConflict(pMnode, pTrans)); - if (mndTransCheckParallelActions(pMnode, pTrans) != 0) { - return -1; - } + TAOS_CHECK_RETURN(mndTransCheckParallelActions(pMnode, pTrans)); - if (mndTransCheckCommitActions(pMnode, pTrans) != 0) { - return -1; - } + TAOS_CHECK_RETURN(mndTransCheckCommitActions(pMnode, pTrans)); mInfo("trans:%d, prepare transaction", pTrans->id); - if (mndTransSync(pMnode, pTrans) != 0) { - mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr()); - return -1; + if ((code = mndTransSync(pMnode, pTrans)) != 0) { + mError("trans:%d, failed to prepare since %s", pTrans->id, tstrerror(code)); + TAOS_RETURN(code); } mInfo("trans:%d, prepare finished", pTrans->id); STrans *pNew = mndAcquireTrans(pMnode, pTrans->id); if (pNew == NULL) { - mError("trans:%d, failed to read from sdb since %s", pTrans->id, terrstr()); - return -1; + code = TSDB_CODE_MND_RETURN_VALUE_NULL; + if (terrno != 0) code = terrno; + mError("trans:%d, failed to read from sdb since %s", pTrans->id, tstrerror(code)); + TAOS_RETURN(code); } pNew->pRpcArray = pTrans->pRpcArray; @@ -1025,37 +1027,41 @@ int32_t mndTransPrepare(SMnode *pMnode, STrans *pTrans) { mndTransExecute(pMnode, pNew); mndReleaseTrans(pMnode, pNew); + // TDOD change to TAOS_RETURN(code); return 0; } static int32_t mndTransCommit(SMnode *pMnode, STrans *pTrans) { + int32_t code = 0; mInfo("trans:%d, commit transaction", pTrans->id); - if (mndTransSync(pMnode, pTrans) != 0) { - mError("trans:%d, failed to commit since %s", pTrans->id, terrstr()); - return -1; + if ((code = mndTransSync(pMnode, pTrans)) != 0) { + mError("trans:%d, failed to commit since %s", pTrans->id, tstrerror(code)); + TAOS_RETURN(code); } mInfo("trans:%d, commit finished", pTrans->id); - return 0; + TAOS_RETURN(code); } static int32_t mndTransRollback(SMnode *pMnode, STrans *pTrans) { + int32_t code = 0; mInfo("trans:%d, rollback transaction", pTrans->id); - if (mndTransSync(pMnode, pTrans) != 0) { - mError("trans:%d, failed to rollback since %s", pTrans->id, terrstr()); - return -1; + if ((code = mndTransSync(pMnode, pTrans)) != 0) { + mError("trans:%d, failed to rollback since %s", pTrans->id, tstrerror(code)); + TAOS_RETURN(code); } mInfo("trans:%d, rollback finished", pTrans->id); - return 0; + TAOS_RETURN(code); } static int32_t mndTransPreFinish(SMnode *pMnode, STrans *pTrans) { + int32_t code = 0; mInfo("trans:%d, pre-finish transaction", pTrans->id); - if (mndTransSync(pMnode, pTrans) != 0) { - mError("trans:%d, failed to pre-finish since %s", pTrans->id, terrstr()); - return -1; + if ((code = mndTransSync(pMnode, pTrans)) != 0) { + mError("trans:%d, failed to pre-finish since %s", pTrans->id, tstrerror(code)); + TAOS_RETURN(code); } mInfo("trans:%d, pre-finish finished", pTrans->id); - return 0; + TAOS_RETURN(code); } static void mndTransSendRpcRsp(SMnode *pMnode, STrans *pTrans) { @@ -1161,6 +1167,7 @@ static void mndTransSendRpcRsp(SMnode *pMnode, STrans *pTrans) { } int32_t mndTransProcessRsp(SRpcMsg *pRsp) { + int32_t code = 0; SMnode *pMnode = pRsp->info.node; int64_t signature = (int64_t)(pRsp->info.ahandle); int32_t transId = (int32_t)(signature >> 32); @@ -1168,7 +1175,9 @@ int32_t mndTransProcessRsp(SRpcMsg *pRsp) { STrans *pTrans = mndAcquireTrans(pMnode, transId); if (pTrans == NULL) { - mError("trans:%d, failed to get transId from vnode rsp since %s", transId, terrstr()); + code = TSDB_CODE_MND_RETURN_VALUE_NULL; + if (terrno != 0) code = terrno; + mError("trans:%d, failed to get transId from vnode rsp since %s", transId, tstrerror(code)); goto _OVER; } @@ -1209,7 +1218,7 @@ int32_t mndTransProcessRsp(SRpcMsg *pRsp) { _OVER: mndReleaseTrans(pMnode, pTrans); - return 0; + TAOS_RETURN(code); } static void mndTransResetAction(SMnode *pMnode, STrans *pTrans, STransAction *pAction) { @@ -1245,8 +1254,7 @@ static void mndTransResetActions(SMnode *pMnode, STrans *pTrans, SArray *pArray) static int32_t mndTransWriteSingleLog(SMnode *pMnode, STrans *pTrans, STransAction *pAction, bool topHalf) { if (pAction->rawWritten) return 0; if (topHalf) { - terrno = TSDB_CODE_MND_TRANS_CTX_SWITCH; - return TSDB_CODE_MND_TRANS_CTX_SWITCH; + TAOS_RETURN(TSDB_CODE_MND_TRANS_CTX_SWITCH); } int32_t code = sdbWriteWithoutFree(pMnode->pSdb, pAction->pRaw); @@ -1265,15 +1273,14 @@ static int32_t mndTransWriteSingleLog(SMnode *pMnode, STrans *pTrans, STransActi mndSetTransLastAction(pTrans, pAction); } - return code; + TAOS_RETURN(code); } // execute at top half static int32_t mndTransSendSingleMsg(SMnode *pMnode, STrans *pTrans, STransAction *pAction, bool topHalf) { if (pAction->msgSent) return 0; if (mndCannotExecuteTransAction(pMnode, topHalf)) { - terrno = TSDB_CODE_MND_TRANS_CTX_SWITCH; - return TSDB_CODE_MND_TRANS_CTX_SWITCH; + TAOS_RETURN(TSDB_CODE_MND_TRANS_CTX_SWITCH); } int64_t signature = pTrans->id; @@ -1317,7 +1324,7 @@ static int32_t mndTransSendSingleMsg(SMnode *pMnode, STrans *pTrans, STransActio mndSetTransLastAction(pTrans, pAction); } - return code; + TAOS_RETURN(code); } static int32_t mndTransExecNullMsg(SMnode *pMnode, STrans *pTrans, STransAction *pAction, bool topHalf) { @@ -1815,8 +1822,7 @@ int32_t mndKillTrans(SMnode *pMnode, STrans *pTrans) { } else if (pTrans->stage == TRN_STAGE_UNDO_ACTION) { pArray = pTrans->undoActions; } else { - terrno = TSDB_CODE_MND_TRANS_INVALID_STAGE; - return -1; + TAOS_RETURN(TSDB_CODE_MND_TRANS_INVALID_STAGE); } for (int32_t i = 0; i < taosArrayGetSize(pArray); ++i) { @@ -1839,17 +1845,19 @@ static int32_t mndProcessKillTransReq(SRpcMsg *pReq) { STrans *pTrans = NULL; if (tDeserializeSKillTransReq(pReq->pCont, pReq->contLen, &killReq) != 0) { - terrno = TSDB_CODE_INVALID_MSG; + code = TSDB_CODE_INVALID_MSG; goto _OVER; } mInfo("trans:%d, start to kill", killReq.transId); - if (mndCheckOperPrivilege(pMnode, pReq->info.conn.user, MND_OPER_KILL_TRANS) != 0) { + if ((code = mndCheckOperPrivilege(pMnode, pReq->info.conn.user, MND_OPER_KILL_TRANS)) != 0) { goto _OVER; } pTrans = mndAcquireTrans(pMnode, killReq.transId); if (pTrans == NULL) { + code = TSDB_CODE_MND_RETURN_VALUE_NULL; + if (terrno != 0) code = terrno; goto _OVER; } @@ -1861,7 +1869,7 @@ _OVER: } mndReleaseTrans(pMnode, pTrans); - return code; + TAOS_RETURN(code); } static int32_t mndCompareTransId(int32_t *pTransId1, int32_t *pTransId2) { return *pTransId1 >= *pTransId2 ? 1 : 0; } From ea7eebc8a9be8d7bede8bc008f0fab1f99efab6b Mon Sep 17 00:00:00 2001 From: Minglei Jin Date: Thu, 25 Jul 2024 10:32:56 +0800 Subject: [PATCH 06/12] check memory alloc return values --- source/dnode/vnode/src/tsdb/tsdbCache.c | 182 ++++++++++++++++++++---- 1 file changed, 157 insertions(+), 25 deletions(-) diff --git a/source/dnode/vnode/src/tsdb/tsdbCache.c b/source/dnode/vnode/src/tsdb/tsdbCache.c index 459ad39819..b6c389842e 100644 --- a/source/dnode/vnode/src/tsdb/tsdbCache.c +++ b/source/dnode/vnode/src/tsdb/tsdbCache.c @@ -63,7 +63,6 @@ static void tsdbCloseBCache(STsdb *pTsdb) { static int32_t tsdbOpenPgCache(STsdb *pTsdb) { int32_t code = 0, lino = 0; - // SLRUCache *pCache = taosLRUCacheInit(10 * 1024 * 1024, 0, .5); int32_t szPage = pTsdb->pVnode->config.tsdbPageSize; SLRUCache *pCache = taosLRUCacheInit((int64_t)tsS3PageCacheSize * szPage, 0, .5); @@ -659,11 +658,23 @@ static int32_t tsdbCacheDropTableColumn(STsdb *pTsdb, int64_t uid, int16_t cid, int32_t code = 0; // build keys & multi get from rocks - char **keys_list = taosMemoryCalloc(2, sizeof(char *)); - size_t *keys_list_sizes = taosMemoryCalloc(2, sizeof(size_t)); + char **keys_list = taosMemoryCalloc(2, sizeof(char *)); + if (!keys_list) { + TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); + } + size_t *keys_list_sizes = taosMemoryCalloc(2, sizeof(size_t)); + if (!keys_list_sizes) { + taosMemoryFree(keys_list); + TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); + } const size_t klen = ROCKS_KEY_LEN; char *keys = taosMemoryCalloc(2, sizeof(SLastKey)); + if (!keys) { + taosMemoryFree(keys_list); + taosMemoryFree(keys_list_sizes); + TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); + } ((SLastKey *)keys)[0] = (SLastKey){.lflag = LFLAG_LAST, .uid = uid, .cid = cid}; ((SLastKey *)keys)[1] = (SLastKey){.lflag = LFLAG_LAST_ROW, .uid = uid, .cid = cid}; @@ -672,9 +683,30 @@ static int32_t tsdbCacheDropTableColumn(STsdb *pTsdb, int64_t uid, int16_t cid, keys_list_sizes[0] = klen; keys_list_sizes[1] = klen; - char **values_list = taosMemoryCalloc(2, sizeof(char *)); + char **values_list = taosMemoryCalloc(2, sizeof(char *)); + if (!values_list) { + taosMemoryFree(keys_list); + taosMemoryFree(keys_list_sizes); + taosMemoryFree(keys_list[0]); + TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); + } size_t *values_list_sizes = taosMemoryCalloc(2, sizeof(size_t)); - char **errs = taosMemoryCalloc(2, sizeof(char *)); + if (!values_list_sizes) { + taosMemoryFree(keys_list); + taosMemoryFree(keys_list_sizes); + taosMemoryFree(keys_list[0]); + taosMemoryFree(values_list); + TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); + } + char **errs = taosMemoryCalloc(2, sizeof(char *)); + if (!errs) { + taosMemoryFree(keys_list); + taosMemoryFree(keys_list_sizes); + taosMemoryFree(keys_list[0]); + taosMemoryFree(values_list); + taosMemoryFree(values_list_sizes); + TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); + } // rocksMayWrite(pTsdb, true, false, false); rocksdb_multi_get(pTsdb->rCache.db, pTsdb->rCache.readoptions, 2, (const char *const *)keys_list, keys_list_sizes, @@ -960,6 +992,9 @@ static int32_t tsdbCacheUpdateValue(SValue *pOld, SValue *pNew) { if (IS_VAR_DATA_TYPE(pNew->type)) { if (nData < pNew->nData) { pOld->pData = taosMemoryCalloc(1, pNew->nData); + if (!pOld->pData) { + TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); + } } else { pOld->pData = pFree; pFree = NULL; @@ -1044,17 +1079,35 @@ static int32_t tsdbCacheUpdate(STsdb *pTsdb, tb_uid_t suid, tb_uid_t uid, SArray num_keys = TARRAY_SIZE(remainCols); } if (remainCols && num_keys > 0) { - char **keys_list = taosMemoryCalloc(num_keys, sizeof(char *)); - size_t *keys_list_sizes = taosMemoryCalloc(num_keys, sizeof(size_t)); + char **keys_list = NULL; + size_t *keys_list_sizes = NULL; + char **values_list = NULL; + size_t *values_list_sizes = NULL; + char **errs = NULL; + keys_list = taosMemoryCalloc(num_keys, sizeof(char *)); + keys_list_sizes = taosMemoryCalloc(num_keys, sizeof(size_t)); + if (!keys_list || !keys_list_sizes) { + taosMemoryFree(keys_list); + taosThreadMutexUnlock(&pTsdb->lruMutex); + TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); + } for (int i = 0; i < num_keys; ++i) { SIdxKey *idxKey = &((SIdxKey *)TARRAY_DATA(remainCols))[i]; keys_list[i] = (char *)&idxKey->key; keys_list_sizes[i] = ROCKS_KEY_LEN; } - char **values_list = taosMemoryCalloc(num_keys, sizeof(char *)); - size_t *values_list_sizes = taosMemoryCalloc(num_keys, sizeof(size_t)); - char **errs = taosMemoryCalloc(num_keys, sizeof(char *)); + values_list = taosMemoryCalloc(num_keys, sizeof(char *)); + values_list_sizes = taosMemoryCalloc(num_keys, sizeof(size_t)); + errs = taosMemoryCalloc(num_keys, sizeof(char *)); + if (!values_list || !values_list_sizes || !errs) { + taosMemoryFree(keys_list); + taosMemoryFree(keys_list_sizes); + taosMemoryFree(values_list); + taosMemoryFree(values_list_sizes); + taosThreadMutexUnlock(&pTsdb->lruMutex); + TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); + } rocksdb_multi_get(pTsdb->rCache.db, pTsdb->rCache.readoptions, num_keys, (const char *const *)keys_list, keys_list_sizes, values_list, values_list_sizes, errs); for (int i = 0; i < num_keys; ++i) { @@ -1104,6 +1157,16 @@ static int32_t tsdbCacheUpdate(STsdb *pTsdb, tb_uid_t suid, tb_uid_t uid, SArray pLastCol = &lastColTmp; SLastCol *pTmpLastCol = taosMemoryCalloc(1, sizeof(SLastCol)); + if (!pTmpLastCol) { + taosMemoryFree(keys_list); + taosMemoryFree(keys_list_sizes); + taosMemoryFree(values_list); + taosMemoryFree(values_list_sizes); + + taosArrayDestroy(remainCols); + taosThreadMutexUnlock(&pTsdb->lruMutex); + TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); + } *pTmpLastCol = *pLastCol; pLastCol = pTmpLastCol; @@ -1322,18 +1385,30 @@ static int32_t tsdbCacheLoadFromRaw(STsdb *pTsdb, tb_uid_t uid, SArray *pLastArr int num_keys = TARRAY_SIZE(remainCols); int16_t *slotIds = taosMemoryMalloc(num_keys * sizeof(int16_t)); - int16_t *lastColIds = taosMemoryMalloc(num_keys * sizeof(int16_t)); - int16_t *lastSlotIds = taosMemoryMalloc(num_keys * sizeof(int16_t)); - int16_t *lastrowColIds = taosMemoryMalloc(num_keys * sizeof(int16_t)); - int16_t *lastrowSlotIds = taosMemoryMalloc(num_keys * sizeof(int16_t)); - SArray *lastTmpColArray = NULL; - SArray *lastTmpIndexArray = NULL; - SArray *lastrowTmpColArray = NULL; - SArray *lastrowTmpIndexArray = NULL; + int16_t *lastColIds = NULL; + int16_t *lastSlotIds = NULL; + int16_t *lastrowColIds = NULL; + int16_t *lastrowSlotIds = NULL; + lastColIds = taosMemoryMalloc(num_keys * sizeof(int16_t)); + lastSlotIds = taosMemoryMalloc(num_keys * sizeof(int16_t)); + lastrowColIds = taosMemoryMalloc(num_keys * sizeof(int16_t)); + lastrowSlotIds = taosMemoryMalloc(num_keys * sizeof(int16_t)); + SArray *lastTmpColArray = NULL; + SArray *lastTmpIndexArray = NULL; + SArray *lastrowTmpColArray = NULL; + SArray *lastrowTmpIndexArray = NULL; int lastIndex = 0; int lastrowIndex = 0; + if (!slotIds || !lastColIds || !lastSlotIds || !lastrowColIds || !lastrowSlotIds) { + taosMemoryFree(slotIds); + taosMemoryFree(lastColIds); + taosMemoryFree(lastSlotIds); + taosMemoryFree(lastrowColIds); + TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); + } + for (int i = 0; i < num_keys; ++i) { SIdxKey *idxKey = taosArrayGet(remainCols, i); slotIds[i] = pr->pSlotIds[idxKey->idx]; @@ -1401,6 +1476,14 @@ static int32_t tsdbCacheLoadFromRaw(STsdb *pTsdb, tb_uid_t uid, SArray *pLastArr } SLastCol *pTmpLastCol = taosMemoryCalloc(1, sizeof(SLastCol)); + if (!pTmpLastCol) { + taosMemoryFree(slotIds); + taosMemoryFree(lastColIds); + taosMemoryFree(lastSlotIds); + taosMemoryFree(lastrowColIds); + taosMemoryFree(lastrowSlotIds); + TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); + } *pTmpLastCol = *pLastCol; pLastCol = pTmpLastCol; @@ -1420,7 +1503,7 @@ static int32_t tsdbCacheLoadFromRaw(STsdb *pTsdb, tb_uid_t uid, SArray *pLastArr LRUStatus status = taosLRUCacheInsert(pCache, &idxKey->key, ROCKS_KEY_LEN, pLastCol, charge, tsdbCacheDeleter, NULL, TAOS_LRU_PRIORITY_LOW, &pTsdb->flushState); if (status != TAOS_LRU_STATUS_OK) { - code = -1; + // code = -1; } // store result back to rocks cache @@ -1466,6 +1549,11 @@ static int32_t tsdbCacheLoadFromRocks(STsdb *pTsdb, tb_uid_t uid, SArray *pLastA char **keys_list = taosMemoryMalloc(num_keys * sizeof(char *)); size_t *keys_list_sizes = taosMemoryMalloc(num_keys * sizeof(size_t)); char *key_list = taosMemoryMalloc(num_keys * ROCKS_KEY_LEN); + if (!keys_list || !keys_list_sizes || !key_list) { + taosMemoryFree(keys_list); + taosMemoryFree(keys_list_sizes); + TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); + } for (int i = 0; i < num_keys; ++i) { int16_t cid = *(int16_t *)taosArrayGet(remainCols, i); @@ -1477,6 +1565,13 @@ static int32_t tsdbCacheLoadFromRocks(STsdb *pTsdb, tb_uid_t uid, SArray *pLastA char **values_list = taosMemoryCalloc(num_keys, sizeof(char *)); size_t *values_list_sizes = taosMemoryCalloc(num_keys, sizeof(size_t)); char **errs = taosMemoryMalloc(num_keys * sizeof(char *)); + if (!values_list || !values_list_sizes || !errs) { + taosMemoryFree(keys_list); + taosMemoryFree(keys_list_sizes); + taosMemoryFree(values_list); + taosMemoryFree(values_list_sizes); + TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); + } rocksdb_multi_get(pTsdb->rCache.db, pTsdb->rCache.readoptions, num_keys, (const char *const *)keys_list, keys_list_sizes, values_list, values_list_sizes, errs); for (int i = 0; i < num_keys; ++i) { @@ -1486,6 +1581,7 @@ static int32_t tsdbCacheLoadFromRocks(STsdb *pTsdb, tb_uid_t uid, SArray *pLastA rocksdb_free(errs[i]); } } + taosMemoryFree(errs); SLRUCache *pCache = pTsdb->lruCache; for (int i = 0, j = 0; i < num_keys && j < TARRAY_SIZE(remainCols); ++i) { @@ -1498,6 +1594,13 @@ static int32_t tsdbCacheLoadFromRocks(STsdb *pTsdb, tb_uid_t uid, SArray *pLastA SIdxKey *idxKey = &((SIdxKey *)TARRAY_DATA(remainCols))[j]; if (pLastCol) { SLastCol *pTmpLastCol = taosMemoryCalloc(1, sizeof(SLastCol)); + if (!pTmpLastCol) { + taosMemoryFree(keys_list); + taosMemoryFree(keys_list_sizes); + taosMemoryFree(values_list); + taosMemoryFree(values_list_sizes); + TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); + } *pTmpLastCol = *pLastCol; pLastCol = pTmpLastCol; @@ -1535,7 +1638,6 @@ static int32_t tsdbCacheLoadFromRocks(STsdb *pTsdb, tb_uid_t uid, SArray *pLastA } } - taosMemoryFree(errs); taosMemoryFree(key_list); taosMemoryFree(keys_list); taosMemoryFree(keys_list_sizes); @@ -1649,15 +1751,24 @@ int32_t tsdbCacheDel(STsdb *pTsdb, tb_uid_t suid, tb_uid_t uid, TSKEY sKey, TSKE TAOS_CHECK_RETURN(metaGetTbTSchemaEx(pTsdb->pVnode->pMeta, suid, uid, sver, &pTSchema)); // build keys & multi get from rocks - int num_keys = pTSchema->numOfCols; - char **keys_list = taosMemoryCalloc(num_keys * 2, sizeof(char *)); - size_t *keys_list_sizes = taosMemoryCalloc(num_keys * 2, sizeof(size_t)); + int num_keys = pTSchema->numOfCols; + char **keys_list = taosMemoryCalloc(num_keys * 2, sizeof(char *)); + size_t *keys_list_sizes = taosMemoryCalloc(num_keys * 2, sizeof(size_t)); + if (!keys_list || !keys_list_sizes) { + taosMemoryFree(keys_list); + TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); + } const size_t klen = ROCKS_KEY_LEN; for (int i = 0; i < num_keys; ++i) { int16_t cid = pTSchema->columns[i].colId; char *keys = taosMemoryCalloc(2, sizeof(SLastKey)); + if (!keys) { + taosMemoryFree(keys_list); + taosMemoryFree(keys_list_sizes); + TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); + } ((SLastKey *)keys)[0] = (SLastKey){.lflag = LFLAG_LAST, .uid = uid, .cid = cid}; ((SLastKey *)keys)[1] = (SLastKey){.lflag = LFLAG_LAST_ROW, .uid = uid, .cid = cid}; @@ -1669,6 +1780,15 @@ int32_t tsdbCacheDel(STsdb *pTsdb, tb_uid_t suid, tb_uid_t uid, TSKEY sKey, TSKE char **values_list = taosMemoryCalloc(num_keys * 2, sizeof(char *)); size_t *values_list_sizes = taosMemoryCalloc(num_keys * 2, sizeof(size_t)); char **errs = taosMemoryCalloc(num_keys * 2, sizeof(char *)); + if (!values_list_sizes || !values_list) { + taosMemoryFree(keys_list); + taosMemoryFree(keys_list_sizes); + taosMemoryFree(values_list); + for (int i = 0; i < num_keys; ++i) { + taosMemoryFree(keys_list[i]); + } + TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); + } (void)tsdbCacheCommit(pTsdb); @@ -1885,7 +2005,9 @@ static STableLoadInfo *getTableLoadInfo(SCacheRowsReader *pReader, uint64_t uid) STableLoadInfo **ppInfo = tSimpleHashGet(pReader->pTableMap, &uid, sizeof(uid)); if (!ppInfo) { pInfo = taosMemoryCalloc(1, sizeof(STableLoadInfo)); - tSimpleHashPut(pReader->pTableMap, &uid, sizeof(uint64_t), &pInfo, POINTER_BYTES); + if (pInfo) { + tSimpleHashPut(pReader->pTableMap, &uid, sizeof(uint64_t), &pInfo, POINTER_BYTES); + } return pInfo; } @@ -1898,6 +2020,9 @@ static uint64_t *getUidList(SCacheRowsReader *pReader) { int32_t numOfTables = pReader->numOfTables; pReader->uidList = taosMemoryMalloc(numOfTables * sizeof(uint64_t)); + if (!pReader->uidList) { + return NULL; + } for (int32_t i = 0; i < numOfTables; ++i) { uint64_t uid = pReader->pTableList[i].uid; @@ -1913,9 +2038,13 @@ static uint64_t *getUidList(SCacheRowsReader *pReader) { static int32_t loadTombFromBlk(const TTombBlkArray *pTombBlkArray, SCacheRowsReader *pReader, void *pFileReader, bool isFile) { int32_t code = 0; - uint64_t *uidList = getUidList(pReader); int32_t numOfTables = pReader->numOfTables; int64_t suid = pReader->info.suid; + uint64_t *uidList = getUidList(pReader); + + if (!uidList) { + TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); + } for (int i = 0, j = 0; i < pTombBlkArray->size && j < numOfTables; ++i) { STombBlk *pTombBlk = &pTombBlkArray->data[i]; @@ -3296,6 +3425,9 @@ int32_t tsdbCacheSetPageS3(SLRUCache *pCache, STsdbFD *pFD, int64_t pgno, uint8_ size_t charge = pFD->szPage; _taos_lru_deleter_t deleter = deleteBCache; uint8_t *pPg = taosMemoryMalloc(charge); + if (!pPg) { + TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); + } memcpy(pPg, pPage, charge); LRUStatus status = From aa921c987097d936db8438fde74498eb5b6d88ed Mon Sep 17 00:00:00 2001 From: Minglei Jin Date: Thu, 25 Jul 2024 11:13:04 +0800 Subject: [PATCH 07/12] update sync raft log --- source/dnode/vnode/src/tsdb/tsdbCache.c | 7 ++- source/libs/sync/src/syncRaftLog.c | 61 ++++++++++++++++--------- source/util/src/tlrucache.c | 19 ++++---- 3 files changed, 50 insertions(+), 37 deletions(-) diff --git a/source/dnode/vnode/src/tsdb/tsdbCache.c b/source/dnode/vnode/src/tsdb/tsdbCache.c index b6c389842e..1726d8696b 100644 --- a/source/dnode/vnode/src/tsdb/tsdbCache.c +++ b/source/dnode/vnode/src/tsdb/tsdbCache.c @@ -1888,11 +1888,10 @@ _exit: } int32_t tsdbOpenCache(STsdb *pTsdb) { - int32_t code = 0, lino = 0; - SLRUCache *pCache = NULL; - size_t cfgCapacity = pTsdb->pVnode->config.cacheLastSize * 1024 * 1024; + int32_t code = 0, lino = 0; + size_t cfgCapacity = pTsdb->pVnode->config.cacheLastSize * 1024 * 1024; - pCache = taosLRUCacheInit(cfgCapacity, 0, .5); + SLRUCache *pCache = taosLRUCacheInit(cfgCapacity, 0, .5); if (pCache == NULL) { TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _err); } diff --git a/source/libs/sync/src/syncRaftLog.c b/source/libs/sync/src/syncRaftLog.c index 19c8837d83..57c70d8df1 100644 --- a/source/libs/sync/src/syncRaftLog.c +++ b/source/libs/sync/src/syncRaftLog.c @@ -51,7 +51,12 @@ SSyncLogStore* logStoreCreate(SSyncNode* pSyncNode) { taosLRUCacheSetStrictCapacity(pLogStore->pCache, false); pLogStore->data = taosMemoryMalloc(sizeof(SSyncLogStoreData)); - ASSERT(pLogStore->data != NULL); + if (!pLogStore->data) { + taosMemoryFree(pLogStore); + taosLRUCacheCleanup(pLogStore->pCache); + terrno = TSDB_CODE_OUT_OF_MEMORY; + return NULL; + } SSyncLogStoreData* pData = pLogStore->data; pData->pSyncNode = pSyncNode; @@ -60,7 +65,13 @@ SSyncLogStore* logStoreCreate(SSyncNode* pSyncNode) { taosThreadMutexInit(&(pData->mutex), NULL); pData->pWalHandle = walOpenReader(pData->pWal, NULL, 0); - ASSERT(pData->pWalHandle != NULL); + if (!pData->pWalHandle) { + taosMemoryFree(pLogStore); + taosLRUCacheCleanup(pLogStore->pCache); + taosThreadMutexDestroy(&(pData->mutex)); + terrno = TSDB_CODE_OUT_OF_MEMORY; + return NULL; + } pLogStore->syncLogUpdateCommitIndex = raftLogUpdateCommitIndex; pLogStore->syncLogCommitIndex = raftlogCommitIndex; @@ -110,7 +121,7 @@ static int32_t raftLogRestoreFromSnapshot(struct SSyncLogStore* pLogStore, SyncI SWal* pWal = pData->pWal; int32_t code = walRestoreFromSnapshot(pWal, snapshotIndex); if (code != 0) { - int32_t err = terrno; + int32_t err = code; const char* errStr = tstrerror(err); int32_t sysErr = errno; const char* sysErrStr = strerror(errno); @@ -118,10 +129,10 @@ static int32_t raftLogRestoreFromSnapshot(struct SSyncLogStore* pLogStore, SyncI sNError(pData->pSyncNode, "wal restore from snapshot error, index:%" PRId64 ", err:0x%x, msg:%s, syserr:%d, sysmsg:%s", snapshotIndex, err, errStr, sysErr, sysErrStr); - return -1; + TAOS_RETURN(err); } - return 0; + TAOS_RETURN(TSDB_CODE_SUCCESS); } SyncIndex raftLogBeginIndex(struct SSyncLogStore* pLogStore) { @@ -224,7 +235,8 @@ static int32_t raftLogAppendEntry(struct SSyncLogStore* pLogStore, SSyncRaftEntr sNError(pData->pSyncNode, "wal write error, index:%" PRId64 ", err:0x%x, msg:%s, syserr:%d, sysmsg:%s", pEntry->index, err, errStr, sysErr, sysErrStr); - return -1; + + TAOS_RETURN(err); } code = walFsync(pWal, forceSync); @@ -235,7 +247,7 @@ static int32_t raftLogAppendEntry(struct SSyncLogStore* pLogStore, SSyncRaftEntr sNTrace(pData->pSyncNode, "write index:%" PRId64 ", type:%s, origin type:%s, elapsed:%" PRId64, pEntry->index, TMSG_INFO(pEntry->msgType), TMSG_INFO(pEntry->originalRpcType), tsElapsed); - return 0; + TAOS_RETURN(TSDB_CODE_SUCCESS); } // entry found, return 0 @@ -253,10 +265,10 @@ int32_t raftLogGetEntry(struct SSyncLogStore* pLogStore, SyncIndex index, SSyncR SWalReader* pWalHandle = pData->pWalHandle; if (pWalHandle == NULL) { - terrno = TSDB_CODE_SYN_INTERNAL_ERROR; sError("vgId:%d, wal handle is NULL", pData->pSyncNode->vgId); taosThreadMutexUnlock(&(pData->mutex)); - return -1; + + TAOS_RETURN(TSDB_CODE_SYN_INTERNAL_ERROR); } int64_t ts2 = taosGetTimestampNs(); @@ -266,7 +278,7 @@ int32_t raftLogGetEntry(struct SSyncLogStore* pLogStore, SyncIndex index, SSyncR // code = walReadVerCached(pWalHandle, index); if (code != 0) { - int32_t err = terrno; + int32_t err = code; const char* errStr = tstrerror(err); int32_t sysErr = errno; const char* sysErrStr = strerror(errno); @@ -286,7 +298,8 @@ int32_t raftLogGetEntry(struct SSyncLogStore* pLogStore, SyncIndex index, SSyncR */ taosThreadMutexUnlock(&(pData->mutex)); - return code; + + TAOS_RETURN(code); } *ppEntry = syncEntryBuild(pWalHandle->pHead->head.bodyLen); @@ -319,7 +332,7 @@ int32_t raftLogGetEntry(struct SSyncLogStore* pLogStore, SyncIndex index, SSyncR ", elapsed-build:%" PRId64, index, tsElapsed, tsElapsedLock, tsElapsedRead, tsElapsedBuild); - return code; + TAOS_RETURN(code); } // truncate semantic @@ -329,7 +342,7 @@ static int32_t raftLogTruncate(struct SSyncLogStore* pLogStore, SyncIndex fromIn int32_t code = walRollback(pWal, fromIndex); if (code != 0) { - int32_t err = terrno; + int32_t err = code; const char* errStr = tstrerror(err); int32_t sysErr = errno; const char* sysErrStr = strerror(errno); @@ -339,7 +352,8 @@ static int32_t raftLogTruncate(struct SSyncLogStore* pLogStore, SyncIndex fromIn // event log sNTrace(pData->pSyncNode, "log truncate, from-index:%" PRId64, fromIndex); - return code; + + TAOS_RETURN(code); } // entry found, return 0 @@ -352,16 +366,16 @@ static int32_t raftLogGetLastEntry(SSyncLogStore* pLogStore, SSyncRaftEntry** pp *ppLastEntry = NULL; if (walIsEmpty(pWal)) { - terrno = TSDB_CODE_WAL_LOG_NOT_EXIST; - return -1; + TAOS_RETURN(TSDB_CODE_WAL_LOG_NOT_EXIST); } else { SyncIndex lastIndex = raftLogLastIndex(pLogStore); ASSERT(lastIndex >= SYNC_INDEX_BEGIN); int32_t code = raftLogGetEntry(pLogStore, lastIndex, ppLastEntry); - return code; + + TAOS_RETURN(code); } - return -1; + TAOS_RETURN(TSDB_CODE_FAILED); } int32_t raftLogUpdateCommitIndex(SSyncLogStore* pLogStore, SyncIndex index) { @@ -375,20 +389,22 @@ int32_t raftLogUpdateCommitIndex(SSyncLogStore* pLogStore, SyncIndex index) { if (index < snapshotVer || index > wallastVer) { // ignore - return 0; + TAOS_RETURN(TSDB_CODE_SUCCESS); } int32_t code = walCommit(pWal, index); if (code != 0) { - int32_t err = terrno; + int32_t err = code; const char* errStr = tstrerror(err); int32_t sysErr = errno; const char* sysErrStr = strerror(errno); sError("vgId:%d, wal update commit index error, index:%" PRId64 ", err:0x%x, msg:%s, syserr:%d, sysmsg:%s", pData->pSyncNode->vgId, index, err, errStr, sysErr, sysErrStr); - return -1; + + TAOS_RETURN(code); } - return 0; + + TAOS_RETURN(TSDB_CODE_SUCCESS); } SyncIndex raftlogCommitIndex(SSyncLogStore* pLogStore) { @@ -405,5 +421,6 @@ SyncIndex logStoreFirstIndex(SSyncLogStore* pLogStore) { SyncIndex logStoreWalCommitVer(SSyncLogStore* pLogStore) { SSyncLogStoreData* pData = pLogStore->data; SWal* pWal = pData->pWal; + return walGetCommittedVer(pWal); } diff --git a/source/util/src/tlrucache.c b/source/util/src/tlrucache.c index 3de159797f..4f8e96c4c7 100644 --- a/source/util/src/tlrucache.c +++ b/source/util/src/tlrucache.c @@ -20,6 +20,7 @@ #include "tarray.h" #include "tdef.h" #include "tlog.h" +#include "tutil.h" typedef struct SLRUEntry SLRUEntry; typedef struct SLRUEntryTable SLRUEntryTable; @@ -114,13 +115,13 @@ static int taosLRUEntryTableInit(SLRUEntryTable *table, int maxUpperHashBits) { table->lengthBits = 4; table->list = taosMemoryCalloc(1 << table->lengthBits, sizeof(SLRUEntry *)); if (!table->list) { - return -1; + TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); } table->elems = 0; table->maxLengthBits = maxUpperHashBits; - return 0; + TAOS_RETURN(TSDB_CODE_SUCCESS); } static void taosLRUEntryTableApply(SLRUEntryTable *table, _taos_lru_table_func_t func, uint32_t begin, uint32_t end) { @@ -349,9 +350,7 @@ static void taosLRUCacheShardSetCapacity(SLRUCacheShard *shard, size_t capacity) static int taosLRUCacheShardInit(SLRUCacheShard *shard, size_t capacity, bool strict, double highPriPoolRatio, int maxUpperHashBits) { - if (taosLRUEntryTableInit(&shard->table, maxUpperHashBits) < 0) { - return -1; - } + TAOS_CHECK_RETURN(taosLRUEntryTableInit(&shard->table, maxUpperHashBits)); taosThreadMutexInit(&shard->mutex, NULL); @@ -372,7 +371,7 @@ static int taosLRUCacheShardInit(SLRUCacheShard *shard, size_t capacity, bool st taosLRUCacheShardSetCapacity(shard, capacity); - return 0; + TAOS_RETURN(TSDB_CODE_SUCCESS); } static void taosLRUCacheShardCleanup(SLRUCacheShard *shard) { @@ -671,16 +670,13 @@ static int getDefaultCacheShardBits(size_t capacity) { SLRUCache *taosLRUCacheInit(size_t capacity, int numShardBits, double highPriPoolRatio) { if (numShardBits >= 20) { - terrno = TSDB_CODE_INVALID_PARA; return NULL; } if (highPriPoolRatio < 0.0 || highPriPoolRatio > 1.0) { - terrno = TSDB_CODE_INVALID_PARA; return NULL; } SLRUCache *cache = taosMemoryCalloc(1, sizeof(SLRUCache)); if (!cache) { - terrno = TSDB_CODE_OUT_OF_MEMORY; return NULL; } @@ -692,14 +688,15 @@ SLRUCache *taosLRUCacheInit(size_t capacity, int numShardBits, double highPriPoo cache->shards = taosMemoryCalloc(numShards, sizeof(SLRUCacheShard)); if (!cache->shards) { taosMemoryFree(cache); - terrno = TSDB_CODE_OUT_OF_MEMORY; return NULL; } bool strictCapacity = 1; size_t perShard = (capacity + (numShards - 1)) / numShards; for (int i = 0; i < numShards; ++i) { - taosLRUCacheShardInit(&cache->shards[i], perShard, strictCapacity, highPriPoolRatio, 32 - numShardBits); + if (TSDB_CODE_SUCCESS != + taosLRUCacheShardInit(&cache->shards[i], perShard, strictCapacity, highPriPoolRatio, 32 - numShardBits)) + return NULL; } cache->numShards = numShards; From c55db1d8f7ed865689fae8eb7f100f972e0ae7b5 Mon Sep 17 00:00:00 2001 From: Hongze Cheng Date: Thu, 25 Jul 2024 11:45:15 +0800 Subject: [PATCH 08/12] enh: refact return code --- source/dnode/vnode/src/meta/metaQuery.c | 28 +-- source/dnode/vnode/src/meta/metaSma.c | 23 +- source/dnode/vnode/src/meta/metaSnapshot.c | 18 +- source/dnode/vnode/src/meta/metaTable.c | 148 ++++++------ source/dnode/vnode/src/vnd/vnodeOpen.c | 10 +- source/dnode/vnode/src/vnd/vnodeSvr.c | 106 +++++---- source/libs/tdb/src/db/tdbBtree.c | 250 +++++++++++---------- source/libs/tdb/src/db/tdbPager.c | 16 +- 8 files changed, 300 insertions(+), 299 deletions(-) diff --git a/source/dnode/vnode/src/meta/metaQuery.c b/source/dnode/vnode/src/meta/metaQuery.c index 062c019d48..e4a04047f1 100644 --- a/source/dnode/vnode/src/meta/metaQuery.c +++ b/source/dnode/vnode/src/meta/metaQuery.c @@ -48,27 +48,23 @@ void metaReaderClear(SMetaReader *pReader) { } int metaGetTableEntryByVersion(SMetaReader *pReader, int64_t version, tb_uid_t uid) { + int32_t code = 0; SMeta *pMeta = pReader->pMeta; STbDbKey tbDbKey = {.version = version, .uid = uid}; // query table.db if (tdbTbGet(pMeta->pTbDb, &tbDbKey, sizeof(tbDbKey), &pReader->pBuf, &pReader->szBuf) < 0) { - terrno = TSDB_CODE_PAR_TABLE_NOT_EXIST; - goto _err; + return terrno = TSDB_CODE_PAR_TABLE_NOT_EXIST; } // decode the entry tDecoderInit(&pReader->coder, pReader->pBuf, pReader->szBuf); - if (metaDecodeEntry(&pReader->coder, &pReader->me) < 0) { - goto _err; - } + code = metaDecodeEntry(&pReader->coder, &pReader->me); + if (code) return code; // taosMemoryFreeClear(pReader->me.colCmpr.pColCmpr); return 0; - -_err: - return -1; } bool metaIsTableExist(void *pVnode, tb_uid_t uid) { @@ -90,8 +86,7 @@ int metaReaderGetTableEntryByUid(SMetaReader *pReader, tb_uid_t uid) { // query uid.idx if (tdbTbGet(pMeta->pUidIdx, &uid, sizeof(uid), &pReader->pBuf, &pReader->szBuf) < 0) { - terrno = TSDB_CODE_PAR_TABLE_NOT_EXIST; - return -1; + return terrno = TSDB_CODE_PAR_TABLE_NOT_EXIST; } version1 = ((SUidIdxVal *)pReader->pBuf)[0].version; @@ -103,8 +98,7 @@ int metaReaderGetTableEntryByUidCache(SMetaReader *pReader, tb_uid_t uid) { SMetaInfo info; if (metaGetInfo(pMeta, uid, &info, pReader) == TSDB_CODE_NOT_FOUND) { - terrno = TSDB_CODE_PAR_TABLE_NOT_EXIST; - return -1; + return terrno = TSDB_CODE_PAR_TABLE_NOT_EXIST; } return metaGetTableEntryByVersion(pReader, info.version, uid); @@ -116,8 +110,7 @@ int metaGetTableEntryByName(SMetaReader *pReader, const char *name) { // query name.idx if (tdbTbGet(pMeta->pNameIdx, name, strlen(name) + 1, &pReader->pBuf, &pReader->szBuf) < 0) { - terrno = TSDB_CODE_PAR_TABLE_NOT_EXIST; - return -1; + return terrno = TSDB_CODE_PAR_TABLE_NOT_EXIST; } uid = *(tb_uid_t *)pReader->pBuf; @@ -148,7 +141,7 @@ int metaGetTableNameByUid(void *pVnode, uint64_t uid, char *tbName) { code = metaReaderGetTableEntryByUid(&mr, uid); if (code < 0) { metaReaderClear(&mr); - return -1; + return code; } STR_TO_VARSTR(tbName, mr.me.name); @@ -164,7 +157,7 @@ int metaGetTableSzNameByUid(void *meta, uint64_t uid, char *tbName) { code = metaReaderGetTableEntryByUid(&mr, uid); if (code < 0) { metaReaderClear(&mr); - return -1; + return code; } strncpy(tbName, mr.me.name, TSDB_TABLE_NAME_LEN); metaReaderClear(&mr); @@ -181,9 +174,8 @@ int metaGetTableUidByName(void *pVnode, char *tbName, uint64_t *uid) { // query name.idx if (tdbTbGet(((SMeta *)pReader->pMeta)->pNameIdx, tbName, strlen(tbName) + 1, &pReader->pBuf, &pReader->szBuf) < 0) { - terrno = TSDB_CODE_PAR_TABLE_NOT_EXIST; metaReaderClear(&mr); - return -1; + return terrno = TSDB_CODE_PAR_TABLE_NOT_EXIST; } *uid = *(tb_uid_t *)pReader->pBuf; diff --git a/source/dnode/vnode/src/meta/metaSma.c b/source/dnode/vnode/src/meta/metaSma.c index c61725e834..371cc6ff21 100644 --- a/source/dnode/vnode/src/meta/metaSma.c +++ b/source/dnode/vnode/src/meta/metaSma.c @@ -13,9 +13,8 @@ * along with this program. If not, see . */ -#include "vnodeInt.h" #include "meta.h" - +#include "vnodeInt.h" static int metaHandleSmaEntry(SMeta *pMeta, const SMetaEntry *pME); static int metaSaveSmaToDB(SMeta *pMeta, const SMetaEntry *pME); @@ -34,15 +33,15 @@ int32_t metaCreateTSma(SMeta *pMeta, int64_t version, SSmaCfg *pCfg) { int32_t szBuf = 0; void *p = NULL; SMetaReader mr = {0}; + int32_t code = 0; // validate req // save smaIndex metaReaderDoInit(&mr, pMeta, META_READER_LOCK); if (metaReaderGetTableEntryByUidCache(&mr, pCfg->indexUid) == 0) { #if 1 - terrno = TSDB_CODE_TSMA_ALREADY_EXIST; metaReaderClear(&mr); - return -1; // don't goto _err; + return terrno = TSDB_CODE_TSMA_ALREADY_EXIST; #else metaReaderClear(&mr); return 0; @@ -57,7 +56,8 @@ int32_t metaCreateTSma(SMeta *pMeta, int64_t version, SSmaCfg *pCfg) { me.name = pCfg->indexName; me.smaEntry.tsma = pCfg; - if (metaHandleSmaEntry(pMeta, &me) < 0) goto _err; + code = metaHandleSmaEntry(pMeta, &me); + if (code) goto _err; metaDebug("vgId:%d, tsma is created, name:%s uid:%" PRId64, TD_VID(pMeta->pVnode), pCfg->indexName, pCfg->indexUid); @@ -66,7 +66,7 @@ int32_t metaCreateTSma(SMeta *pMeta, int64_t version, SSmaCfg *pCfg) { _err: metaError("vgId:%d, failed to create tsma:%s uid:%" PRId64 " since %s", TD_VID(pMeta->pVnode), pCfg->indexName, pCfg->indexUid, tstrerror(terrno)); - return -1; + return code; } int32_t metaDropTSma(SMeta *pMeta, int64_t indexUid) { @@ -147,24 +147,25 @@ static int metaUpdateSmaIdx(SMeta *pMeta, const SMetaEntry *pME) { } static int metaHandleSmaEntry(SMeta *pMeta, const SMetaEntry *pME) { + int32_t code = 0; metaWLock(pMeta); // save to table.db - if (metaSaveSmaToDB(pMeta, pME) < 0) goto _err; + if ((code = metaSaveSmaToDB(pMeta, pME)) < 0) goto _err; // update uid.idx - if (metaUpdateUidIdx(pMeta, pME) < 0) goto _err; + if ((code = metaUpdateUidIdx(pMeta, pME)) < 0) goto _err; // update name.idx - if (metaUpdateNameIdx(pMeta, pME) < 0) goto _err; + if ((code = metaUpdateNameIdx(pMeta, pME)) < 0) goto _err; // update sma.idx - if (metaUpdateSmaIdx(pMeta, pME) < 0) goto _err; + if ((code = metaUpdateSmaIdx(pMeta, pME)) < 0) goto _err; metaULock(pMeta); return 0; _err: metaULock(pMeta); - return -1; + return code; } diff --git a/source/dnode/vnode/src/meta/metaSnapshot.c b/source/dnode/vnode/src/meta/metaSnapshot.c index 95c65e5e80..87140cfa12 100644 --- a/source/dnode/vnode/src/meta/metaSnapshot.c +++ b/source/dnode/vnode/src/meta/metaSnapshot.c @@ -32,7 +32,7 @@ int32_t metaSnapReaderOpen(SMeta* pMeta, int64_t sver, int64_t ever, SMetaSnapRe // alloc pReader = (SMetaSnapReader*)taosMemoryCalloc(1, sizeof(*pReader)); if (pReader == NULL) { - TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit); + TSDB_CHECK_CODE(code = terrno, lino, _exit); } pReader->pMeta = pMeta; pReader->sver = sver; @@ -261,7 +261,9 @@ static void saveSuperTableInfoForChildTable(SMetaEntry* me, SHashObj* suidInfo) int32_t buildSnapContext(SVnode* pVnode, int64_t snapVersion, int64_t suid, int8_t subType, int8_t withMeta, SSnapContext** ctxRet) { SSnapContext* ctx = taosMemoryCalloc(1, sizeof(SSnapContext)); - if (ctx == NULL) return -1; + if (ctx == NULL) { + return terrno; + } *ctxRet = ctx; ctx->pMeta = pVnode->pMeta; ctx->snapVersion = snapVersion; @@ -271,12 +273,12 @@ int32_t buildSnapContext(SVnode* pVnode, int64_t snapVersion, int64_t suid, int8 ctx->withMeta = withMeta; ctx->idVersion = taosHashInit(100, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, HASH_NO_LOCK); if (ctx->idVersion == NULL) { - return -1; + return terrno; } ctx->suidInfo = taosHashInit(100, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, HASH_NO_LOCK); if (ctx->suidInfo == NULL) { - return -1; + return terrno; } taosHashSetFreeFp(ctx->suidInfo, destroySTableInfoForChildTable); @@ -426,21 +428,21 @@ static int32_t buildSuperTableInfo(SVCreateStbReq* req, void** pBuf, int32_t* co int32_t ret = 0; tEncodeSize(tEncodeSVCreateStbReq, req, *contLen, ret); if (ret < 0) { - return -1; + return ret; } *contLen += sizeof(SMsgHead); *pBuf = taosMemoryMalloc(*contLen); if (NULL == *pBuf) { - return -1; + return terrno; } SEncoder encoder = {0}; tEncoderInit(&encoder, POINTER_SHIFT(*pBuf, sizeof(SMsgHead)), *contLen); - if (tEncodeSVCreateStbReq(&encoder, req) < 0) { + if ((ret = tEncodeSVCreateStbReq(&encoder, req)) < 0) { taosMemoryFreeClear(*pBuf); tEncoderClear(&encoder); - return -1; + return ret; } tEncoderClear(&encoder); return 0; diff --git a/source/dnode/vnode/src/meta/metaTable.c b/source/dnode/vnode/src/meta/metaTable.c index e40478eec2..92e910dba3 100644 --- a/source/dnode/vnode/src/meta/metaTable.c +++ b/source/dnode/vnode/src/meta/metaTable.c @@ -36,11 +36,15 @@ static int metaDeleteBtimeIdx(SMeta *pMeta, const SMetaEntry *pME); static int metaUpdateNcolIdx(SMeta *pMeta, const SMetaEntry *pME); static int metaDeleteNcolIdx(SMeta *pMeta, const SMetaEntry *pME); -int8_t updataTableColCmpr(SColCmprWrapper *pWp, SSchema *pSchema, int8_t add, uint32_t compress) { +static int32_t updataTableColCmpr(SColCmprWrapper *pWp, SSchema *pSchema, int8_t add, uint32_t compress) { int32_t nCols = pWp->nCols; int32_t ver = pWp->version; if (add) { SColCmpr *p = taosMemoryCalloc(1, sizeof(SColCmpr) * (nCols + 1)); + if (p == NULL) { + return terrno; + } + memcpy(p, pWp->pColCmpr, sizeof(SColCmpr) * nCols); SColCmpr *pCol = p + nCols; @@ -64,7 +68,7 @@ int8_t updataTableColCmpr(SColCmprWrapper *pWp, SSchema *pSchema, int8_t add, ui pWp->nCols = nCols; pWp->version = ver; } - return 1; + return 0; } static void metaGetEntryInfo(const SMetaEntry *pEntry, SMetaInfo *pInfo) { pInfo->uid = pEntry->uid; @@ -87,8 +91,7 @@ static int metaUpdateMetaRsp(tb_uid_t uid, char *tbName, SSchemaWrapper *pSchema pMetaRsp->pSchemas = taosMemoryMalloc(pSchema->nCols * sizeof(SSchema)); if (NULL == pMetaRsp->pSchemas) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - return -1; + return terrno = TSDB_CODE_OUT_OF_MEMORY; } pMetaRsp->pSchemaExt = taosMemoryMalloc(pSchema->nCols * sizeof(SSchemaExt)); @@ -105,9 +108,11 @@ static int metaUpdateMetaRsp(tb_uid_t uid, char *tbName, SSchemaWrapper *pSchema } static int metaSaveJsonVarToIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry, const SSchema *pSchema) { + int32_t code = 0; + #ifdef USE_INVERTED_INDEX if (pMeta->pTagIvtIdx == NULL || pCtbEntry == NULL) { - return -1; + return TSDB_CODE_INVALID_PARA; } void *data = pCtbEntry->ctbEntry.pTags; const char *tagName = pSchema->name; @@ -118,8 +123,9 @@ static int metaSaveJsonVarToIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry, const int32_t nTagData = 0; SArray *pTagVals = NULL; - if (tTagToValArray((const STag *)data, &pTagVals) != 0) { - return -1; + code = tTagToValArray((const STag *)data, &pTagVals); + if (code) { + return code; } SIndexMultiTerm *terms = indexMultiTermCreate(); @@ -168,7 +174,7 @@ static int metaSaveJsonVarToIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry, const int metaDelJsonVarFromIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry, const SSchema *pSchema) { #ifdef USE_INVERTED_INDEX if (pMeta->pTagIvtIdx == NULL || pCtbEntry == NULL) { - return -1; + return TSDB_CODE_INVALID_PARA; } void *data = pCtbEntry->ctbEntry.pTags; const char *tagName = pSchema->name; @@ -179,8 +185,9 @@ int metaDelJsonVarFromIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry, const SSche int32_t nTagData = 0; SArray *pTagVals = NULL; - if (tTagToValArray((const STag *)data, &pTagVals) != 0) { - return -1; + code = tTagToValArray((const STag *)data, &pTagVals); + if (code) { + return code; } SIndexMultiTerm *terms = indexMultiTermCreate(); @@ -247,6 +254,7 @@ int metaCreateSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) { void *pBuf = NULL; int32_t szBuf = 0; void *p = NULL; + int32_t code = 0; // validate req void *pData = NULL; @@ -256,14 +264,12 @@ int metaCreateSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) { tdbFree(pData); SMetaInfo info; if (metaGetInfo(pMeta, uid, &info, NULL) == TSDB_CODE_NOT_FOUND) { - terrno = TSDB_CODE_PAR_TABLE_NOT_EXIST; - return -1; + return terrno = TSDB_CODE_PAR_TABLE_NOT_EXIST; } if (info.uid == info.suid) { return 0; } else { - terrno = TSDB_CODE_TDB_TABLE_ALREADY_EXIST; - return -1; + return terrno = TSDB_CODE_TDB_TABLE_ALREADY_EXIST; } } @@ -283,7 +289,8 @@ int metaCreateSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) { me.colCmpr = pReq->colCmpr; } - if (metaHandleEntry(pMeta, &me) < 0) goto _err; + code = metaHandleEntry(pMeta, &me); + if (code) goto _err; ++pMeta->pVnode->config.vndStats.numOfSTables; @@ -295,7 +302,7 @@ int metaCreateSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) { _err: metaError("vgId:%d, failed to create stb:%s uid:%" PRId64 " since %s", TD_VID(pMeta->pVnode), pReq->name, pReq->suid, tstrerror(terrno)); - return -1; + return code; } int metaDropSTable(SMeta *pMeta, int64_t verison, SVDropStbReq *pReq, SArray *tbUidList) { @@ -310,8 +317,7 @@ int metaDropSTable(SMeta *pMeta, int64_t verison, SVDropStbReq *pReq, SArray *tb rc = tdbTbGet(pMeta->pNameIdx, pReq->name, strlen(pReq->name) + 1, &pData, &nData); if (rc < 0 || *(tb_uid_t *)pData != pReq->suid) { tdbFree(pData); - terrno = TSDB_CODE_TDB_STB_NOT_EXIST; - return -1; + return terrno = TSDB_CODE_TDB_STB_NOT_EXIST; } // drop all child tables @@ -424,16 +430,14 @@ int metaAlterSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) { if (ret < 0 || c) { tdbTbcClose(pUidIdxc); - terrno = TSDB_CODE_TDB_STB_NOT_EXIST; - return -1; + return terrno = TSDB_CODE_TDB_STB_NOT_EXIST; } ret = tdbTbcGet(pUidIdxc, NULL, NULL, &pData, &nData); if (ret < 0) { tdbTbcClose(pUidIdxc); - terrno = TSDB_CODE_TDB_STB_NOT_EXIST; - return -1; + return terrno = TSDB_CODE_TDB_STB_NOT_EXIST; } oversion = ((SUidIdxVal *)pData)[0].version; @@ -444,9 +448,8 @@ int metaAlterSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) { tdbTbcClose(pUidIdxc); tdbTbcClose(pTbDbc); - terrno = TSDB_CODE_TDB_STB_NOT_EXIST; metaError("meta/table: invalide ret: %" PRId32 " or c: %" PRId32 "alter stb failed.", ret, c); - return -1; + return terrno = TSDB_CODE_TDB_STB_NOT_EXIST; } ret = tdbTbcGet(pTbDbc, NULL, NULL, &pData, &nData); @@ -454,8 +457,7 @@ int metaAlterSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) { tdbTbcClose(pUidIdxc); tdbTbcClose(pTbDbc); - terrno = TSDB_CODE_TDB_STB_NOT_EXIST; - return -1; + return terrno = TSDB_CODE_TDB_STB_NOT_EXIST; } oStbEntry.pBuf = taosMemoryMalloc(nData); @@ -870,8 +872,7 @@ int metaCreateTable(SMeta *pMeta, int64_t ver, SVCreateTbReq *pReq, STableMetaRs if (pReq->type == TSDB_CHILD_TABLE) { tb_uid_t suid = metaGetTableEntryUidByName(pMeta, pReq->ctb.stbName); if (suid != pReq->ctb.suid) { - terrno = TSDB_CODE_PAR_TABLE_NOT_EXIST; - return -1; + return terrno = TSDB_CODE_PAR_TABLE_NOT_EXIST; } } @@ -879,17 +880,15 @@ int metaCreateTable(SMeta *pMeta, int64_t ver, SVCreateTbReq *pReq, STableMetaRs metaReaderDoInit(&mr, pMeta, META_READER_LOCK); if (metaGetTableEntryByName(&mr, pReq->name) == 0) { if (pReq->type == TSDB_CHILD_TABLE && pReq->ctb.suid != mr.me.ctbEntry.suid) { - terrno = TSDB_CODE_TDB_TABLE_IN_OTHER_STABLE; metaReaderClear(&mr); - return -1; + return terrno = TSDB_CODE_TDB_TABLE_IN_OTHER_STABLE; } pReq->uid = mr.me.uid; if (pReq->type == TSDB_CHILD_TABLE) { pReq->ctb.suid = mr.me.ctbEntry.suid; } - terrno = TSDB_CODE_TDB_TABLE_ALREADY_EXIST; metaReaderClear(&mr); - return -1; + return terrno = TSDB_CODE_TDB_TABLE_ALREADY_EXIST; } else if (terrno == TSDB_CODE_PAR_TABLE_NOT_EXIST) { terrno = TSDB_CODE_SUCCESS; } @@ -1001,7 +1000,7 @@ int metaCreateTable(SMeta *pMeta, int64_t ver, SVCreateTbReq *pReq, STableMetaRs _err: metaError("vgId:%d, failed to create table:%s type:%s since %s", TD_VID(pMeta->pVnode), pReq->name, pReq->type == TSDB_CHILD_TABLE ? "child table" : "normal table", tstrerror(terrno)); - return -1; + return TSDB_CODE_FAILED; } int metaDropTable(SMeta *pMeta, int64_t version, SVDropTbReq *pReq, SArray *tbUids, tb_uid_t *tbUid) { @@ -1015,8 +1014,7 @@ int metaDropTable(SMeta *pMeta, int64_t version, SVDropTbReq *pReq, SArray *tbUi rc = tdbTbGet(pMeta->pNameIdx, pReq->name, strlen(pReq->name) + 1, &pData, &nData); if (rc < 0) { - terrno = TSDB_CODE_TDB_TABLE_NOT_EXIST; - return -1; + return terrno = TSDB_CODE_TDB_TABLE_NOT_EXIST; } uid = *(tb_uid_t *)pData; @@ -1154,7 +1152,7 @@ int32_t metaTrimTables(SMeta *pMeta) { SArray *tbUids = taosArrayInit(8, sizeof(int64_t)); if (tbUids == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } code = metaFilterTableByHash(pMeta, tbUids); @@ -1195,7 +1193,7 @@ static int metaBuildBtimeIdxKey(SBtimeIdxKey *btimeKey, const SMetaEntry *pME) { } else if (pME->type == TSDB_NORMAL_TABLE) { btime = pME->ntbEntry.btime; } else { - return -1; + return TSDB_CODE_FAILED; } btimeKey->btime = btime; @@ -1208,7 +1206,7 @@ static int metaBuildNColIdxKey(SNcolIdxKey *ncolKey, const SMetaEntry *pME) { ncolKey->ncol = pME->ntbEntry.schemaRow.nCols; ncolKey->uid = pME->uid; } else { - return -1; + return TSDB_CODE_FAILED; } return 0; } @@ -1235,7 +1233,7 @@ static int metaDropTableByUid(SMeta *pMeta, tb_uid_t uid, int *type, tb_uid_t *p rc = tdbTbGet(pMeta->pUidIdx, &uid, sizeof(uid), &pData, &nData); if (rc < 0) { - return -1; + return rc; } int64_t version = ((SUidIdxVal *)pData)[0].version; @@ -1245,7 +1243,7 @@ static int metaDropTableByUid(SMeta *pMeta, tb_uid_t uid, int *type, tb_uid_t *p rc = metaDecodeEntry(&dc, &e); if (rc < 0) { tDecoderClear(&dc); - return -1; + return rc; } if (type) *type = e.type; @@ -1408,16 +1406,14 @@ static int metaAlterTableColumn(SMeta *pMeta, int64_t version, SVAlterTbReq *pAl int c; bool freeColCmpr = false; if (pAlterTbReq->colName == NULL) { - terrno = TSDB_CODE_INVALID_MSG; metaError("meta/table: null pAlterTbReq->colName"); - return -1; + return terrno = TSDB_CODE_INVALID_MSG; } // search name index ret = tdbTbGet(pMeta->pNameIdx, pAlterTbReq->tbName, strlen(pAlterTbReq->tbName) + 1, &pVal, &nVal); if (ret < 0) { - terrno = TSDB_CODE_TDB_TABLE_NOT_EXIST; - return -1; + return terrno = TSDB_CODE_TDB_TABLE_NOT_EXIST; } uid = *(tb_uid_t *)pVal; @@ -1432,7 +1428,7 @@ static int metaAlterTableColumn(SMeta *pMeta, int64_t version, SVAlterTbReq *pAl if (c != 0) { tdbTbcClose(pUidIdxc); metaError("meta/table: invalide c: %" PRId32 " alt tb column failed.", c); - return -1; + return TSDB_CODE_FAILED; } tdbTbcGet(pUidIdxc, NULL, NULL, &pData, &nData); @@ -1447,7 +1443,7 @@ static int metaAlterTableColumn(SMeta *pMeta, int64_t version, SVAlterTbReq *pAl tdbTbcClose(pUidIdxc); tdbTbcClose(pTbDbc); metaError("meta/table: invalide c: %" PRId32 " alt tb column failed.", c); - return -1; + return TSDB_CODE_FAILED; } tdbTbcGet(pTbDbc, NULL, NULL, &pData, &nData); @@ -1463,7 +1459,7 @@ static int metaAlterTableColumn(SMeta *pMeta, int64_t version, SVAlterTbReq *pAl tdbTbcClose(pTbDbc); tDecoderClear(&dc); metaError("meta/table: invalide ret: %" PRId32 " alt tb column failed.", ret); - return -1; + return ret; } if (entry.type != TSDB_NORMAL_TABLE) { @@ -1660,7 +1656,7 @@ _err: tdbTbcClose(pUidIdxc); tDecoderClear(&dc); - return -1; + return TSDB_CODE_FAILED; } static int metaUpdateTableTagVal(SMeta *pMeta, int64_t version, SVAlterTbReq *pAlterTbReq) { @@ -1676,15 +1672,13 @@ static int metaUpdateTableTagVal(SMeta *pMeta, int64_t version, SVAlterTbReq *pA int nData = 0; if (pAlterTbReq->tagName == NULL) { - terrno = TSDB_CODE_INVALID_MSG; - return -1; + return terrno = TSDB_CODE_INVALID_MSG; } // search name index ret = tdbTbGet(pMeta->pNameIdx, pAlterTbReq->tbName, strlen(pAlterTbReq->tbName) + 1, &pVal, &nVal); if (ret < 0) { - terrno = TSDB_CODE_TDB_TABLE_NOT_EXIST; - return -1; + return terrno = TSDB_CODE_TDB_TABLE_NOT_EXIST; } uid = *(tb_uid_t *)pVal; @@ -1698,9 +1692,8 @@ static int metaUpdateTableTagVal(SMeta *pMeta, int64_t version, SVAlterTbReq *pA tdbTbcMoveTo(pUidIdxc, &uid, sizeof(uid), &c); if (c != 0) { tdbTbcClose(pUidIdxc); - terrno = TSDB_CODE_TDB_TABLE_NOT_EXIST; metaError("meta/table: invalide c: %" PRId32 " update tb tag val failed.", c); - return -1; + return terrno = TSDB_CODE_TDB_TABLE_NOT_EXIST; } tdbTbcGet(pUidIdxc, NULL, NULL, &pData, &nData); @@ -1717,9 +1710,8 @@ static int metaUpdateTableTagVal(SMeta *pMeta, int64_t version, SVAlterTbReq *pA if (c != 0) { tdbTbcClose(pUidIdxc); tdbTbcClose(pTbDbc); - terrno = TSDB_CODE_TDB_TABLE_NOT_EXIST; metaError("meta/table: invalide c: %" PRId32 " update tb tag val failed.", c); - return -1; + return terrno = TSDB_CODE_TDB_TABLE_NOT_EXIST; } tdbTbcGet(pTbDbc, NULL, NULL, &pData, &nData); @@ -1866,8 +1858,7 @@ static int metaUpdateTableOptions(SMeta *pMeta, int64_t version, SVAlterTbReq *p // search name index ret = tdbTbGet(pMeta->pNameIdx, pAlterTbReq->tbName, strlen(pAlterTbReq->tbName) + 1, &pVal, &nVal); if (ret < 0) { - terrno = TSDB_CODE_TDB_TABLE_NOT_EXIST; - return -1; + return terrno = TSDB_CODE_TDB_TABLE_NOT_EXIST; } uid = *(tb_uid_t *)pVal; @@ -1882,7 +1873,7 @@ static int metaUpdateTableOptions(SMeta *pMeta, int64_t version, SVAlterTbReq *p if (c != 0) { tdbTbcClose(pUidIdxc); metaError("meta/table: invalide c: %" PRId32 " update tb options failed.", c); - return -1; + return TSDB_CODE_FAILED; } tdbTbcGet(pUidIdxc, NULL, NULL, &pData, &nData); @@ -1897,7 +1888,7 @@ static int metaUpdateTableOptions(SMeta *pMeta, int64_t version, SVAlterTbReq *p tdbTbcClose(pUidIdxc); tdbTbcClose(pTbDbc); metaError("meta/table: invalide c: %" PRId32 " update tb options failed.", c); - return -1; + return TSDB_CODE_FAILED; } tdbTbcGet(pTbDbc, NULL, NULL, &pData, &nData); @@ -1913,7 +1904,7 @@ static int metaUpdateTableOptions(SMeta *pMeta, int64_t version, SVAlterTbReq *p tdbTbcClose(pUidIdxc); tdbTbcClose(pTbDbc); metaError("meta/table: invalide ret: %" PRId32 " alt tb options failed.", ret); - return -1; + return TSDB_CODE_FAILED; } entry.version = version; @@ -1968,15 +1959,13 @@ static int metaAddTagIndex(SMeta *pMeta, int64_t version, SVAlterTbReq *pAlterTb SDecoder dc = {0}; if (pAlterTbReq->tagName == NULL) { - terrno = TSDB_CODE_INVALID_MSG; - return -1; + return terrno = TSDB_CODE_INVALID_MSG; } // search name index ret = tdbTbGet(pMeta->pNameIdx, pAlterTbReq->tbName, strlen(pAlterTbReq->tbName) + 1, &pVal, &nVal); if (ret < 0) { - terrno = TSDB_CODE_TDB_TABLE_NOT_EXIST; - return -1; + return terrno = TSDB_CODE_TDB_TABLE_NOT_EXIST; } else { uid = *(tb_uid_t *)pVal; tdbFree(pVal); @@ -2085,7 +2074,7 @@ _err: // if (stbEntry.pBuf) tdbFree(stbEntry.pBuf); // tdbTbcClose(pTbDbc); // tdbTbcClose(pUidIdxc); - return -1; + return TSDB_CODE_FAILED; } typedef struct SMetaPair { @@ -2106,15 +2095,13 @@ static int metaDropTagIndex(SMeta *pMeta, int64_t version, SVAlterTbReq *pAlterT SDecoder dc = {0}; if (pAlterTbReq->tagName == NULL) { - terrno = TSDB_CODE_INVALID_MSG; - return -1; + return terrno = TSDB_CODE_INVALID_MSG; } // search name index ret = tdbTbGet(pMeta->pNameIdx, pAlterTbReq->tbName, strlen(pAlterTbReq->tbName) + 1, &pVal, &nVal); if (ret < 0) { - terrno = TSDB_CODE_TDB_TABLE_NOT_EXIST; - return -1; + return terrno = TSDB_CODE_TDB_TABLE_NOT_EXIST; } suid = *(tb_uid_t *)pVal; tdbFree(pVal); @@ -2200,7 +2187,7 @@ static int metaDropTagIndex(SMeta *pMeta, int64_t version, SVAlterTbReq *pAlterT // set pCol->flags; INDEX_ON return 0; _err: - return -1; + return TSDB_CODE_FAILED; } int32_t metaUpdateTableColCompress(SMeta *pMeta, int64_t version, SVAlterTbReq *pReq) { // impl later @@ -2216,8 +2203,7 @@ int32_t metaUpdateTableColCompress(SMeta *pMeta, int64_t version, SVAlterTbReq * SDecoder dc = {0}; ret = tdbTbGet(pMeta->pNameIdx, pReq->tbName, strlen(pReq->tbName) + 1, &pVal, &nVal); if (ret < 0) { - terrno = TSDB_CODE_TDB_TABLE_NOT_EXIST; - return -1; + return terrno = TSDB_CODE_TDB_TABLE_NOT_EXIST; } suid = *(tb_uid_t *)pVal; tdbFree(pVal); @@ -2290,7 +2276,7 @@ int32_t metaUpdateTableColCompress(SMeta *pMeta, int64_t version, SVAlterTbReq * return 0; _err: - return -1; + return TSDB_CODE_FAILED; } int metaAlterTable(SMeta *pMeta, int64_t version, SVAlterTbReq *pReq, STableMetaRsp *pMetaRsp) { @@ -2313,8 +2299,7 @@ int metaAlterTable(SMeta *pMeta, int64_t version, SVAlterTbReq *pReq, STableMeta case TSDB_ALTER_TABLE_UPDATE_COLUMN_COMPRESS: return metaUpdateTableColCompress(pMeta, version, pReq); default: - terrno = TSDB_CODE_VND_INVALID_TABLE_ACTION; - return -1; + return terrno = TSDB_CODE_VND_INVALID_TABLE_ACTION; break; } } @@ -2370,7 +2355,7 @@ _err: pME->uid, tstrerror(terrno)); taosMemoryFree(pVal); - return -1; + return TSDB_CODE_FAILED; } static int metaUpdateUidIdx(SMeta *pMeta, const SMetaEntry *pME) { @@ -2446,8 +2431,7 @@ int metaCreateTagIdxKey(tb_uid_t suid, int32_t cid, const void *pTagData, int32_ *ppTagIdxKey = (STagIdxKey *)taosMemoryMalloc(*nTagIdxKey); if (*ppTagIdxKey == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - return -1; + return terrno = TSDB_CODE_OUT_OF_MEMORY; } (*ppTagIdxKey)->suid = suid; @@ -2667,7 +2651,7 @@ _err: metaULock(pMeta); metaError("vgId:%d, failed to handle meta entry since %s at line:%d, ver:%" PRId64 ", uid:%" PRId64 ", name:%s", TD_VID(pMeta->pVnode), terrstr(), line, pME->version, pME->uid, pME->name); - return -1; + return TSDB_CODE_FAILED; } int32_t colCompressDebug(SHashObj *pColCmprObj) { @@ -2703,7 +2687,7 @@ int32_t metaGetColCmpr(SMeta *pMeta, tb_uid_t uid, SHashObj **ppColCmprObj) { if (rc < 0) { taosHashClear(pColCmprObj); metaULock(pMeta); - return -1; + return TSDB_CODE_FAILED; } int64_t version = ((SUidIdxVal *)pData)[0].version; rc = tdbTbGet(pMeta->pTbDb, &(STbDbKey){.version = version, .uid = uid}, sizeof(STbDbKey), &pData, &nData); @@ -2721,7 +2705,7 @@ int32_t metaGetColCmpr(SMeta *pMeta, tb_uid_t uid, SHashObj **ppColCmprObj) { tdbFree(pData); metaULock(pMeta); taosHashClear(pColCmprObj); - return -1; + return rc; } if (useCompress(e.type)) { SColCmprWrapper *p = &e.colCmpr; diff --git a/source/dnode/vnode/src/vnd/vnodeOpen.c b/source/dnode/vnode/src/vnd/vnodeOpen.c index ea9209c6b4..5ef3e18058 100644 --- a/source/dnode/vnode/src/vnd/vnodeOpen.c +++ b/source/dnode/vnode/src/vnd/vnodeOpen.c @@ -280,12 +280,13 @@ int32_t vnodeRestoreVgroupId(const char *srcPath, const char *dstPath, int32_t s int32_t diskPrimary, STfs *pTfs) { SVnodeInfo info = {0}; char dir[TSDB_FILENAME_LEN] = {0}; + int32_t code = 0; vnodeGetPrimaryDir(dstPath, diskPrimary, pTfs, dir, TSDB_FILENAME_LEN); if (vnodeLoadInfo(dir, &info) == 0) { if (info.config.vgId != dstVgId) { vError("vgId:%d, unexpected vnode config.vgId:%d", dstVgId, info.config.vgId); - return -1; + return TSDB_CODE_FAILED; } return dstVgId; } @@ -301,13 +302,13 @@ int32_t vnodeRestoreVgroupId(const char *srcPath, const char *dstPath, int32_t s return srcVgId; } else if (info.config.vgId != dstVgId) { vError("vgId:%d, unexpected vnode config.vgId:%d", dstVgId, info.config.vgId); - return -1; + return TSDB_CODE_FAILED; } vInfo("vgId:%d, rename %s to %s", dstVgId, srcPath, dstPath); if (vnodeRenameVgroupId(srcPath, dstPath, srcVgId, dstVgId, diskPrimary, pTfs) < 0) { vError("vgId:%d, failed to rename vnode from %s to %s since %s", dstVgId, srcPath, dstPath, tstrerror(terrno)); - return -1; + return TSDB_CODE_FAILED; } return dstVgId; @@ -332,8 +333,7 @@ static int32_t vnodeCheckDisk(int32_t diskPrimary, STfs *pTfs) { } if (diskPrimary < 0 || diskPrimary >= ndisk) { vError("disk:%d is unavailable from the %d disks mounted at level 0", diskPrimary, ndisk); - terrno = TSDB_CODE_FS_INVLD_CFG; - return -1; + return terrno = TSDB_CODE_FS_INVLD_CFG; } return 0; } diff --git a/source/dnode/vnode/src/vnd/vnodeSvr.c b/source/dnode/vnode/src/vnd/vnodeSvr.c index fb09a46e75..45b2abeb24 100644 --- a/source/dnode/vnode/src/vnd/vnodeSvr.c +++ b/source/dnode/vnode/src/vnd/vnodeSvr.c @@ -513,6 +513,7 @@ int32_t vnodePreProcessWriteMsg(SVnode *pVnode, SRpcMsg *pMsg) { } int32_t vnodeProcessWriteMsg(SVnode *pVnode, SRpcMsg *pMsg, int64_t ver, SRpcMsg *pRsp) { + int32_t code = 0; void *ptr = NULL; void *pReq; int32_t len; @@ -520,8 +521,7 @@ int32_t vnodeProcessWriteMsg(SVnode *pVnode, SRpcMsg *pMsg, int64_t ver, SRpcMsg if (ver <= pVnode->state.applied) { vError("vgId:%d, duplicate write request. ver: %" PRId64 ", applied: %" PRId64 "", TD_VID(pVnode), ver, pVnode->state.applied); - terrno = TSDB_CODE_VND_DUP_REQUEST; - return -1; + return terrno = TSDB_CODE_VND_DUP_REQUEST; } vDebug("vgId:%d, start to process write request %s, index:%" PRId64 ", applied:%" PRId64 ", state.applyTerm:%" PRId64 @@ -693,7 +693,7 @@ int32_t vnodeProcessWriteMsg(SVnode *pVnode, SRpcMsg *pMsg, int64_t ver, SRpcMsg break; default: vError("vgId:%d, unprocessed msg, %d", TD_VID(pVnode), pMsg->msgType); - return -1; + return TSDB_CODE_INVALID_MSG; } vTrace("vgId:%d, process %s request, code:0x%x index:%" PRId64, TD_VID(pVnode), TMSG_INFO(pMsg->msgType), pRsp->code, @@ -701,21 +701,24 @@ int32_t vnodeProcessWriteMsg(SVnode *pVnode, SRpcMsg *pMsg, int64_t ver, SRpcMsg walApplyVer(pVnode->pWal, ver); - if (tqPushMsg(pVnode->pTq, pMsg->msgType) < 0) { + code = tqPushMsg(pVnode->pTq, pMsg->msgType); + if (code) { vError("vgId:%d, failed to push msg to TQ since %s", TD_VID(pVnode), tstrerror(terrno)); - return -1; + return code; } // commit if need if (needCommit) { vInfo("vgId:%d, commit at version %" PRId64, TD_VID(pVnode), ver); - if (vnodeAsyncCommit(pVnode) < 0) { + code = vnodeAsyncCommit(pVnode); + if (code) { vError("vgId:%d, failed to vnode async commit since %s.", TD_VID(pVnode), tstrerror(terrno)); goto _err; } // start a new one - if (vnodeBegin(pVnode) < 0) { + code = vnodeBegin(pVnode); + if (code) { vError("vgId:%d, failed to begin vnode since %s.", TD_VID(pVnode), tstrerror(terrno)); goto _err; } @@ -727,7 +730,7 @@ _exit: _err: vError("vgId:%d, process %s request failed since %s, ver:%" PRId64, TD_VID(pVnode), TMSG_INFO(pMsg->msgType), tstrerror(terrno), ver); - return -1; + return code; } int32_t vnodePreprocessQueryMsg(SVnode *pVnode, SRpcMsg *pMsg) { @@ -987,11 +990,18 @@ static int32_t vnodeProcessFetchTtlExpiredTbs(SVnode *pVnode, int64_t ver, void if (terrno < 0) goto _end; strncpy(buf, mr.me.name, TSDB_TABLE_NAME_LEN); void *p = taosArrayPush(pNames, buf); + if (p == NULL) { + goto _end; + } + expiredTb.name = p; if (mr.me.type == TSDB_CHILD_TABLE) { expiredTb.suid = mr.me.ctbEntry.suid; } - taosArrayPush(rsp.pExpiredTbs, &expiredTb); + + if (taosArrayPush(rsp.pExpiredTbs, &expiredTb) == NULL) { + goto _end; + } } int32_t ret = 0; @@ -1017,6 +1027,7 @@ _end: } static int32_t vnodeProcessCreateStbReq(SVnode *pVnode, int64_t ver, void *pReq, int32_t len, SRpcMsg *pRsp) { + int32_t code = 0; SVCreateStbReq req = {0}; SDecoder coder; @@ -1028,18 +1039,20 @@ static int32_t vnodeProcessCreateStbReq(SVnode *pVnode, int64_t ver, void *pReq, // decode and process req tDecoderInit(&coder, pReq, len); - if (tDecodeSVCreateStbReq(&coder, &req) < 0) { - pRsp->code = terrno; + code = tDecodeSVCreateStbReq(&coder, &req); + if (code) { + pRsp->code = code; goto _err; } - if (metaCreateSTable(pVnode->pMeta, ver, &req) < 0) { - pRsp->code = terrno; + code = metaCreateSTable(pVnode->pMeta, ver, &req); + if (code) { + pRsp->code = code; goto _err; } - if (tdProcessRSmaCreate(pVnode->pSma, &req) < 0) { - pRsp->code = terrno; + if ((code = tdProcessRSmaCreate(pVnode->pSma, &req)) < 0) { + pRsp->code = code; goto _err; } @@ -1048,7 +1061,7 @@ static int32_t vnodeProcessCreateStbReq(SVnode *pVnode, int64_t ver, void *pReq, _err: tDecoderClear(&coder); - return -1; + return code; } static int32_t vnodeProcessCreateTbReq(SVnode *pVnode, int64_t ver, void *pReq, int32_t len, SRpcMsg *pRsp, @@ -1100,7 +1113,11 @@ static int32_t vnodeProcessCreateTbReq(SVnode *pVnode, int64_t ver, void *pReq, goto _exit; } strcpy(str, pCreateReq->name); - taosArrayPush(tbNames, &str); + if (taosArrayPush(tbNames, &str) == NULL) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + rcode = -1; + goto _exit; + } } // validate hash @@ -1185,6 +1202,7 @@ _exit: } static int32_t vnodeProcessAlterStbReq(SVnode *pVnode, int64_t ver, void *pReq, int32_t len, SRpcMsg *pRsp) { + int32_t code = 0; SVCreateStbReq req = {0}; SDecoder dc = {0}; @@ -1196,16 +1214,17 @@ static int32_t vnodeProcessAlterStbReq(SVnode *pVnode, int64_t ver, void *pReq, tDecoderInit(&dc, pReq, len); // decode req - if (tDecodeSVCreateStbReq(&dc, &req) < 0) { - terrno = TSDB_CODE_INVALID_MSG; + code = tDecodeSVCreateStbReq(&dc, &req); + if (code) { tDecoderClear(&dc); - return -1; + return code; } - if (metaAlterSTable(pVnode->pMeta, ver, &req) < 0) { - pRsp->code = terrno; + code = metaAlterSTable(pVnode->pMeta, ver, &req); + if (code) { + pRsp->code = code; tDecoderClear(&dc); - return -1; + return code; } tDecoderClear(&dc); @@ -2224,6 +2243,7 @@ _err: static int32_t vnodeProcessCreateIndexReq(SVnode *pVnode, int64_t ver, void *pReq, int32_t len, SRpcMsg *pRsp) { SVCreateStbReq req = {0}; SDecoder dc = {0}; + int32_t code = 0; pRsp->msgType = TDMT_VND_CREATE_INDEX_RSP; pRsp->code = TSDB_CODE_SUCCESS; @@ -2233,35 +2253,38 @@ static int32_t vnodeProcessCreateIndexReq(SVnode *pVnode, int64_t ver, void *pRe tDecoderInit(&dc, pReq, len); // decode req if (tDecodeSVCreateStbReq(&dc, &req) < 0) { - terrno = TSDB_CODE_INVALID_MSG; tDecoderClear(&dc); - return -1; + return terrno = TSDB_CODE_INVALID_MSG; } - if (metaAddIndexToSTable(pVnode->pMeta, ver, &req) < 0) { - pRsp->code = terrno; + + code = metaAddIndexToSTable(pVnode->pMeta, ver, &req); + if (code) { + pRsp->code = code; goto _err; } tDecoderClear(&dc); return 0; + _err: tDecoderClear(&dc); - return -1; + return code; } static int32_t vnodeProcessDropIndexReq(SVnode *pVnode, int64_t ver, void *pReq, int32_t len, SRpcMsg *pRsp) { SDropIndexReq req = {0}; + int32_t code = 0; pRsp->msgType = TDMT_VND_DROP_INDEX_RSP; pRsp->code = TSDB_CODE_SUCCESS; pRsp->pCont = NULL; pRsp->contLen = 0; - if (tDeserializeSDropIdxReq(pReq, len, &req)) { - terrno = TSDB_CODE_INVALID_MSG; - return -1; + if ((code = tDeserializeSDropIdxReq(pReq, len, &req))) { + return code; } - if (metaDropIndexFromSTable(pVnode->pMeta, ver, &req) < 0) { - pRsp->code = terrno; - return -1; + code = metaDropIndexFromSTable(pVnode->pMeta, ver, &req); + if (code) { + pRsp->code = code; + return code; } return TSDB_CODE_SUCCESS; } @@ -2290,20 +2313,17 @@ static int32_t vnodeProcessConfigChangeReq(SVnode *pVnode, int64_t ver, void *pR static int32_t vnodePreCheckAssignedLogSyncd(SVnode *pVnode, char *member0Token, char *member1Token) { SSyncState syncState = syncGetState(pVnode->sync); if (syncState.state != TAOS_SYNC_STATE_LEADER) { - terrno = TSDB_CODE_SYN_NOT_LEADER; - return -1; + return terrno = TSDB_CODE_SYN_NOT_LEADER; } char token[TSDB_ARB_TOKEN_SIZE] = {0}; if (vnodeGetArbToken(pVnode, token) != 0) { - terrno = TSDB_CODE_NOT_FOUND; - return -1; + return terrno = TSDB_CODE_NOT_FOUND; } if (strncmp(token, member0Token, TSDB_ARB_TOKEN_SIZE) != 0 && strncmp(token, member1Token, TSDB_ARB_TOKEN_SIZE) != 0) { - terrno = TSDB_CODE_MND_ARB_TOKEN_MISMATCH; - return -1; + return terrno = TSDB_CODE_MND_ARB_TOKEN_MISMATCH; } terrno = TSDB_CODE_SUCCESS; @@ -2324,9 +2344,9 @@ static int32_t vnodeProcessArbCheckSyncReq(SVnode *pVnode, void *pReq, int32_t l SVArbCheckSyncReq syncReq = {0}; - if (tDeserializeSVArbCheckSyncReq(pReq, len, &syncReq) != 0) { - terrno = TSDB_CODE_INVALID_MSG; - return -1; + code = tDeserializeSVArbCheckSyncReq(pReq, len, &syncReq); + if (code) { + return terrno = code; } pRsp->msgType = TDMT_VND_ARB_CHECK_SYNC_RSP; diff --git a/source/libs/tdb/src/db/tdbBtree.c b/source/libs/tdb/src/db/tdbBtree.c index 4dd3d3298c..187d65d975 100644 --- a/source/libs/tdb/src/db/tdbBtree.c +++ b/source/libs/tdb/src/db/tdbBtree.c @@ -114,7 +114,7 @@ int tdbBtreeOpen(int keyLen, int valLen, SPager *pPager, char const *tbname, SPg ret = tdbBegin(pEnv, &txn, tdbDefaultMalloc, tdbDefaultFree, NULL, TDB_TXN_WRITE | TDB_TXN_READ_UNCOMMITTED); if (ret < 0) { tdbOsFree(pBt); - return -1; + return ret; } SBtreeInitPageArg zArg; @@ -124,7 +124,7 @@ int tdbBtreeOpen(int keyLen, int valLen, SPager *pPager, char const *tbname, SPg if (ret < 0) { tdbAbort(pEnv, txn); tdbOsFree(pBt); - return -1; + return ret; } ret = tdbPagerWrite(pPager, pPage); @@ -132,7 +132,7 @@ int tdbBtreeOpen(int keyLen, int valLen, SPager *pPager, char const *tbname, SPg tdbError("failed to write page since %s", terrstr()); tdbAbort(pEnv, txn); tdbOsFree(pBt); - return -1; + return ret; } if (strcmp(TDB_MAINDB_NAME, tbname)) { @@ -145,20 +145,23 @@ int tdbBtreeOpen(int keyLen, int valLen, SPager *pPager, char const *tbname, SPg if (ret < 0) { tdbAbort(pEnv, txn); tdbOsFree(pBt); - return -1; + return ret; } } tdbPCacheRelease(pPager->pCache, pPage, txn); - tdbCommit(pPager->pEnv, txn); - tdbPostCommit(pPager->pEnv, txn); + ret = tdbCommit(pPager->pEnv, txn); + if (ret) return ret; + + ret = tdbPostCommit(pPager->pEnv, txn); + if (ret) return ret; } if (pgno == 0) { tdbError("tdb/btree-open: pgno cannot be zero."); tdbOsFree(pBt); - return -1; + ASSERT(0); } pBt->root = pgno; /* @@ -200,7 +203,7 @@ int tdbBtreeInsert(SBTree *pBt, const void *pKey, int kLen, const void *pVal, in if (ret < 0) { tdbBtcClose(&btc); tdbError("tdb/btree-insert: btc move to failed with ret: %d.", ret); - return -1; + return ret; } if (btc.idx == -1) { @@ -212,7 +215,7 @@ int tdbBtreeInsert(SBTree *pBt, const void *pKey, int kLen, const void *pVal, in // dup key not allowed with insert tdbBtcClose(&btc); tdbError("tdb/btree-insert: dup key. pKey: %p, kLen: %d, btc: %p, pTxn: %p", pKey, kLen, &btc, pTxn); - return -1; + return TSDB_CODE_DUP_KEY; } } @@ -220,7 +223,7 @@ int tdbBtreeInsert(SBTree *pBt, const void *pKey, int kLen, const void *pVal, in if (ret < 0) { tdbBtcClose(&btc); tdbError("tdb/btree-insert: btc upsert failed with ret: %d.", ret); - return -1; + return ret; } tdbBtcClose(&btc); @@ -245,18 +248,19 @@ int tdbBtreeDelete(SBTree *pBt, const void *pKey, int kLen, TXN *pTxn) { if (ret < 0) { tdbBtcClose(&btc); tdbError("tdb/btree-delete: btc move to failed with ret: %d.", ret); - return -1; + return ret; } if (btc.idx < 0 || c != 0) { tdbBtcClose(&btc); - return -1; + return TSDB_CODE_NOT_FOUND; } // delete the key - if (tdbBtcDelete(&btc) < 0) { + ret = tdbBtcDelete(&btc); + if (ret < 0) { tdbBtcClose(&btc); - return -1; + return ret; } /* SArray *ofps = btc.coder.ofps; @@ -341,13 +345,12 @@ int tdbBtreePGet(SBTree *pBt, const void *pKey, int kLen, void **ppKey, int *pkL if (ret < 0) { tdbBtcClose(&btc); tdbError("tdb/btree-pget: btc move to failed with ret: %d.", ret); - return -1; + return ret; } if (btc.idx < 0 || cret) { tdbBtcClose(&btc); - - return -1; + return TSDB_CODE_NOT_FOUND; } pCell = tdbPageGetCell(btc.pPage, btc.idx); @@ -355,7 +358,7 @@ int tdbBtreePGet(SBTree *pBt, const void *pKey, int kLen, void **ppKey, int *pkL if (ret < 0) { tdbBtcClose(&btc); tdbError("tdb/btree-pget: decode cell failed with ret: %d.", ret); - return -1; + return ret; } if (ppKey) { @@ -363,7 +366,7 @@ int tdbBtreePGet(SBTree *pBt, const void *pKey, int kLen, void **ppKey, int *pkL if (pTKey == NULL) { tdbBtcClose(&btc); tdbError("tdb/btree-pget: realloc pTKey failed."); - return -1; + return terrno; } *ppKey = pTKey; *pkLen = cd.kLen; @@ -375,7 +378,7 @@ int tdbBtreePGet(SBTree *pBt, const void *pKey, int kLen, void **ppKey, int *pkL if (pTVal == NULL) { tdbBtcClose(&btc); tdbError("tdb/btree-pget: realloc pTVal failed."); - return -1; + return terrno; } *ppVal = pTVal; *vLen = cd.vLen; @@ -495,7 +498,7 @@ static int tdbBtreeBalanceDeeper(SBTree *pBt, SPage *pRoot, SPage **ppChild, TXN zArg.pBt = pBt; ret = tdbPagerFetchPage(pPager, &pgnoChild, &pChild, tdbBtreeInitPage, &zArg, pTxn); if (ret < 0) { - return -1; + return ret; } if (!leaf) { @@ -505,7 +508,7 @@ static int tdbBtreeBalanceDeeper(SBTree *pBt, SPage *pRoot, SPage **ppChild, TXN ret = tdbPagerWrite(pPager, pChild); if (ret < 0) { tdbError("failed to write page since %s", terrstr()); - return -1; + return ret; } // Copy the root page content to the child page @@ -516,7 +519,7 @@ static int tdbBtreeBalanceDeeper(SBTree *pBt, SPage *pRoot, SPage **ppChild, TXN zArg.pBt = pBt; ret = tdbBtreeInitPage(pRoot, &zArg, 0); if (ret < 0) { - return -1; + return ret; } pIntHdr = (SIntHdr *)(pRoot->pData); @@ -557,13 +560,13 @@ static int tdbBtreeBalanceNonRoot(SBTree *pBt, SPage *pParent, int idx, TXN *pTx } for (int i = 0; i < nOlds; i++) { if (ASSERT(sIdx + i <= nCells)) { - return -1; + return TSDB_CODE_FAILED; } SPgno pgno; if (sIdx + i == nCells) { if (ASSERT(!TDB_BTREE_PAGE_IS_LEAF(pParent))) { - return -1; + return TSDB_CODE_FAILED; } pgno = ((SIntHdr *)(pParent->pData))->pgno; } else { @@ -575,13 +578,13 @@ static int tdbBtreeBalanceNonRoot(SBTree *pBt, SPage *pParent, int idx, TXN *pTx &((SBtreeInitPageArg){.pBt = pBt, .flags = 0}), pTxn); if (ret < 0) { tdbError("tdb/btree-balance: fetch page failed with ret: %d.", ret); - return -1; + return TSDB_CODE_FAILED; } ret = tdbPagerWrite(pBt->pPager, pOlds[i]); if (ret < 0) { tdbError("failed to write page since %s", terrstr()); - return -1; + return TSDB_CODE_FAILED; } } // copy the parent key out if child pages are not leaf page @@ -608,7 +611,7 @@ static int tdbBtreeBalanceNonRoot(SBTree *pBt, SPage *pParent, int idx, TXN *pTx ret = tdbPagerWrite(pBt->pPager, pParent); if (ret < 0) { tdbError("failed to write page since %s", terrstr()); - return -1; + return ret; } // drop the cells on parent page @@ -718,7 +721,7 @@ static int tdbBtreeBalanceNonRoot(SBTree *pBt, SPage *pParent, int idx, TXN *pTx } if (ASSERT(infoNews[iNew - 1].cnt > 0)) { - return -1; + return TSDB_CODE_FAILED; } if (infoNews[iNew].size + szRCell >= infoNews[iNew - 1].size - szRCell) { @@ -763,13 +766,13 @@ static int tdbBtreeBalanceNonRoot(SBTree *pBt, SPage *pParent, int idx, TXN *pTx ret = tdbPagerFetchPage(pBt->pPager, &pgno, pNews + iNew, tdbBtreeInitPage, &iarg, pTxn); if (ret < 0) { tdbError("tdb/btree-balance: fetch page failed with ret: %d.", ret); - return -1; + return ret; } ret = tdbPagerWrite(pBt->pPager, pNews[iNew]); if (ret < 0) { tdbError("failed to write page since %s", terrstr()); - return -1; + return ret; } } } @@ -808,10 +811,10 @@ static int tdbBtreeBalanceNonRoot(SBTree *pBt, SPage *pParent, int idx, TXN *pTx szCell = tdbBtreeCellSize(pPage, pCell, 0, NULL, NULL); if (ASSERT(nNewCells <= infoNews[iNew].cnt)) { - return -1; + return TSDB_CODE_FAILED; } if (ASSERT(iNew < nNews)) { - return -1; + return TSDB_CODE_FAILED; } if (nNewCells < infoNews[iNew].cnt) { @@ -852,10 +855,10 @@ static int tdbBtreeBalanceNonRoot(SBTree *pBt, SPage *pParent, int idx, TXN *pTx } } else { if (ASSERT(childNotLeaf)) { - return -1; + return TSDB_CODE_FAILED; } if (ASSERT(iNew < nNews - 1)) { - return -1; + return TSDB_CODE_FAILED; } // set current new page right-most child @@ -863,7 +866,7 @@ static int tdbBtreeBalanceNonRoot(SBTree *pBt, SPage *pParent, int idx, TXN *pTx // insert to parent as divider cell if (ASSERT(iNew < nNews - 1)) { - return -1; + return TSDB_CODE_FAILED; } ((SPgno *)pCell)[0] = TDB_PAGE_PGNO(pNews[iNew]); tdbPageInsertCell(pParent, sIdx++, pCell, szCell, 0); @@ -880,7 +883,7 @@ static int tdbBtreeBalanceNonRoot(SBTree *pBt, SPage *pParent, int idx, TXN *pTx if (childNotLeaf) { if (ASSERT(TDB_PAGE_TOTAL_CELLS(pNews[nNews - 1]) == infoNews[nNews - 1].cnt)) { - return -1; + return TSDB_CODE_FAILED; } ((SIntHdr *)(pNews[nNews - 1]->pData))->pgno = rPgno; @@ -961,7 +964,7 @@ static int tdbBtreeBalance(SBTC *pBtc) { ret = tdbBtreeBalanceDeeper(pBtc->pBt, pPage, &(pBtc->pgStack[1]), pBtc->pTxn); if (ret < 0) { - return -1; + return ret; } pBtc->idx = 0; @@ -975,7 +978,7 @@ static int tdbBtreeBalance(SBTC *pBtc) { ret = tdbBtreeBalanceNonRoot(pBtc->pBt, pParent, pBtc->idxStack[pBtc->iPage - 1], pBtc->pTxn); if (ret < 0) { - return -1; + return ret; } tdbPagerReturnPage(pBtc->pBt->pPager, pBtc->pPage, pBtc->pTxn); @@ -998,14 +1001,14 @@ static int tdbFetchOvflPage(SPgno *pPgno, SPage **ppOfp, TXN *pTxn, SBTree *pBt) iArg.flags = TDB_FLAG_ADD(0, TDB_BTREE_OVFL); ret = tdbPagerFetchPage(pBt->pPager, pPgno, ppOfp, tdbBtreeInitPage, &iArg, pTxn); if (ret < 0) { - return -1; + return ret; } // mark dirty ret = tdbPagerWrite(pBt->pPager, *ppOfp); if (ret < 0) { tdbError("failed to write page since %s", terrstr()); - return -1; + return ret; } tdbPCacheRelease(pBt->pPager->pCache, *ppOfp, pTxn); @@ -1021,7 +1024,7 @@ static int tdbLoadOvflPage(SPgno *pPgno, SPage **ppOfp, TXN *pTxn, SBTree *pBt) iArg.flags = TDB_FLAG_ADD(0, TDB_BTREE_OVFL); ret = tdbPagerFetchPage(pBt->pPager, pPgno, ppOfp, tdbBtreeInitPage, &iArg, pTxn); if (ret < 0) { - return -1; + return ret; } return ret; @@ -1058,13 +1061,13 @@ static int tdbBtreeEncodePayload(SPage *pPage, SCell *pCell, int nHeader, const ret = tdbFetchOvflPage(&pgno, &ofp, pTxn, pBt); if (ret < 0) { - return -1; + return ret; } // local buffer for cell SCell *pBuf = tdbRealloc(NULL, pBt->pageSize); if (pBuf == NULL) { - return -1; + return ret; } int nLeft = nPayload; @@ -1078,7 +1081,7 @@ static int tdbBtreeEncodePayload(SPage *pPage, SCell *pCell, int nHeader, const if (nLocal > nHeader + kLen + sizeof(SPgno)) { if (ASSERT(pVal != NULL && vLen != 0)) { tdbFree(pBuf); - return -1; + return TSDB_CODE_FAILED; } memcpy(pCell + nHeader + kLen, pVal, nLocal - nHeader - kLen - sizeof(SPgno)); nLeft -= nLocal - nHeader - kLen - sizeof(SPgno); @@ -1103,7 +1106,7 @@ static int tdbBtreeEncodePayload(SPage *pPage, SCell *pCell, int nHeader, const ret = tdbFetchOvflPage(&pgno, &nextOfp, pTxn, pBt); if (ret < 0) { tdbFree(pBuf); - return -1; + return ret; } } else { pgno = 0; @@ -1115,7 +1118,7 @@ static int tdbBtreeEncodePayload(SPage *pPage, SCell *pCell, int nHeader, const ret = tdbPageInsertCell(ofp, 0, pBuf, bytes + sizeof(pgno), 0); if (ret < 0) { tdbFree(pBuf); - return -1; + return ret; } ofp = nextOfp; @@ -1163,7 +1166,7 @@ static int tdbBtreeEncodePayload(SPage *pPage, SCell *pCell, int nHeader, const ret = tdbFetchOvflPage(&pgno, &nextOfp, pTxn, pBt); if (ret < 0) { tdbFree(pBuf); - return -1; + return ret; } } } else { @@ -1171,7 +1174,7 @@ static int tdbBtreeEncodePayload(SPage *pPage, SCell *pCell, int nHeader, const ret = tdbFetchOvflPage(&pgno, &nextOfp, pTxn, pBt); if (ret < 0) { tdbFree(pBuf); - return -1; + return ret; } } @@ -1179,7 +1182,7 @@ static int tdbBtreeEncodePayload(SPage *pPage, SCell *pCell, int nHeader, const ret = tdbPageInsertCell(ofp, 0, pBuf, bytes + sizeof(pgno), 0); if (ret < 0) { - return -1; + return ret; } ofp = nextOfp; @@ -1203,7 +1206,7 @@ static int tdbBtreeEncodePayload(SPage *pPage, SCell *pCell, int nHeader, const ret = tdbFetchOvflPage(&pgno, &nextOfp, pTxn, pBt); if (ret < 0) { tdbFree(pBuf); - return -1; + return ret; } } else { pgno = 0; @@ -1214,13 +1217,13 @@ static int tdbBtreeEncodePayload(SPage *pPage, SCell *pCell, int nHeader, const if (ofp == NULL) { tdbFree(pBuf); - return -1; + return ret; } ret = tdbPageInsertCell(ofp, 0, pBuf, bytes + sizeof(pgno), 0); if (ret < 0) { tdbFree(pBuf); - return -1; + return ret; } ofp = nextOfp; @@ -1245,13 +1248,13 @@ static int tdbBtreeEncodeCell(SPage *pPage, const void *pKey, int kLen, const vo int ret; if (ASSERT(pPage->kLen == TDB_VARIANT_LEN || pPage->kLen == kLen)) { - return -1; + return TSDB_CODE_FAILED; } if (ASSERT(pPage->vLen == TDB_VARIANT_LEN || pPage->vLen == vLen)) { - return -1; + return TSDB_CODE_FAILED; } if (ASSERT(pKey != NULL && kLen > 0)) { - return -1; + return TSDB_CODE_FAILED; } nPayload = 0; @@ -1263,7 +1266,7 @@ static int tdbBtreeEncodeCell(SPage *pPage, const void *pKey, int kLen, const vo if (!leaf) { if (pPage->vLen != sizeof(SPgno)) { tdbError("tdb/btree-encode-cell: invalid cell."); - return -1; + return TSDB_CODE_INVALID_PARA; } ((SPgno *)(pCell + nHeader))[0] = ((SPgno *)pVal)[0]; @@ -1290,7 +1293,7 @@ static int tdbBtreeEncodeCell(SPage *pPage, const void *pKey, int kLen, const vo if (ret < 0) { // TODO tdbError("tdb/btree-encode-cell: encode payload failed with ret: %d.", ret); - return -1; + return ret; } *szCell = nHeader + nPayload; @@ -1309,7 +1312,7 @@ static int tdbBtreeDecodePayload(SPage *pPage, const SCell *pCell, int nHeader, if (pDecoder->pVal) { if (TDB_BTREE_PAGE_IS_LEAF(pPage)) { tdbError("tdb/btree-decode-payload: leaf page with non-null pVal."); - return -1; + return TSDB_CODE_INVALID_DATA_FMT; } nPayload = pDecoder->kLen; } else { @@ -1344,7 +1347,7 @@ static int tdbBtreeDecodePayload(SPage *pPage, const SCell *pCell, int nHeader, // read partial val to local pDecoder->pVal = tdbRealloc(pDecoder->pVal, vLen); if (pDecoder->pVal == NULL) { - return -1; + return terrno; } TDB_CELLDECODER_SET_FREE_VAL(pDecoder); @@ -1361,7 +1364,7 @@ static int tdbBtreeDecodePayload(SPage *pPage, const SCell *pCell, int nHeader, while (pgno != 0) { ret = tdbLoadOvflPage(&pgno, &ofp, pTxn, pBt); if (ret < 0) { - return -1; + return ret; } /* if (pDecoder->ofps) { @@ -1389,7 +1392,7 @@ static int tdbBtreeDecodePayload(SPage *pPage, const SCell *pCell, int nHeader, // load partial key and nextPgno pDecoder->pKey = tdbRealloc(pDecoder->pKey, kLen); if (pDecoder->pKey == NULL) { - return -1; + return terrno; } TDB_CELLDECODER_SET_FREE_KEY(pDecoder); @@ -1406,7 +1409,7 @@ static int tdbBtreeDecodePayload(SPage *pPage, const SCell *pCell, int nHeader, // printf("tdb decode-ofp, pTxn: %p, pgno:%u by cell:%p\n", pTxn, pgno, pCell); ret = tdbLoadOvflPage(&pgno, &ofp, pTxn, pBt); if (ret < 0) { - return -1; + return ret; } /* if (pDecoder->ofps) { @@ -1439,7 +1442,7 @@ static int tdbBtreeDecodePayload(SPage *pPage, const SCell *pCell, int nHeader, // read partial val to local pDecoder->pVal = tdbRealloc(pDecoder->pVal, vLen); if (pDecoder->pVal == NULL) { - return -1; + return terrno; } TDB_CELLDECODER_SET_FREE_VAL(pDecoder); @@ -1459,7 +1462,7 @@ static int tdbBtreeDecodePayload(SPage *pPage, const SCell *pCell, int nHeader, while (nLeft > 0) { ret = tdbLoadOvflPage(&pgno, &ofp, pTxn, pBt); if (ret < 0) { - return -1; + return ret; } ofpCell = tdbPageGetCell(ofp, 0); @@ -1480,7 +1483,7 @@ static int tdbBtreeDecodePayload(SPage *pPage, const SCell *pCell, int nHeader, if (!pDecoder->pVal) { pDecoder->pVal = tdbRealloc(pDecoder->pVal, vLen); if (pDecoder->pVal == NULL) { - return -1; + return terrno; } TDB_CELLDECODER_SET_FREE_VAL(pDecoder); } @@ -1529,7 +1532,7 @@ static int tdbBtreeDecodeCell(SPage *pPage, const SCell *pCell, SCellDecoder *pD if (!leaf) { if (pPage->vLen != sizeof(SPgno)) { tdbError("tdb/btree-decode-cell: invalid cell."); - return -1; + return TSDB_CODE_INVALID_DATA_FMT; } pDecoder->pgno = ((SPgno *)(pCell + nHeader))[0]; @@ -1546,7 +1549,7 @@ static int tdbBtreeDecodeCell(SPage *pPage, const SCell *pCell, SCellDecoder *pD if (pPage->vLen == TDB_VARIANT_LEN) { if (!leaf) { tdbError("tdb/btree-decode-cell: not a leaf page."); - return -1; + return TSDB_CODE_INVALID_DATA_FMT; } nHeader += tdbGetVarInt(pCell + nHeader, &(pDecoder->vLen)); } else { @@ -1556,7 +1559,7 @@ static int tdbBtreeDecodeCell(SPage *pPage, const SCell *pCell, SCellDecoder *pD // 2. Decode payload part ret = tdbBtreeDecodePayload(pPage, pCell, nHeader, pDecoder, pTxn, pBt); if (ret < 0) { - return -1; + return ret; } return 0; @@ -1610,7 +1613,7 @@ static int tdbBtreeCellSize(const SPage *pPage, SCell *pCell, int dropOfp, TXN * while (pgno != 0) { ret = tdbLoadOvflPage(&pgno, &ofp, pTxn, pBt); if (ret < 0) { - return -1; + return ret; } SCell *ofpCell = tdbPageGetCell(ofp, 0); @@ -1627,7 +1630,7 @@ static int tdbBtreeCellSize(const SPage *pPage, SCell *pCell, int dropOfp, TXN * ret = tdbPagerWrite(pBt->pPager, ofp); if (ret < 0) { tdbError("failed to write page since %s", terrstr()); - return -1; + return ret; } /* tdbPageDropCell(ofp, 0, pTxn, pBt); @@ -1664,12 +1667,13 @@ int tdbBtcOpen(SBTC *pBtc, SBTree *pBt, TXN *pTxn) { if (pTxn == NULL) { TXN *pTxn = tdbOsCalloc(1, sizeof(*pTxn)); if (!pTxn) { - return -1; + return terrno; } - if (tdbTxnOpen(pTxn, 0, tdbDefaultMalloc, tdbDefaultFree, NULL, 0) < 0) { + int32_t ret = tdbTxnOpen(pTxn, 0, tdbDefaultMalloc, tdbDefaultFree, NULL, 0); + if (ret < 0) { tdbOsFree(pTxn); - return -1; + return ret; } pBtc->pTxn = pTxn; @@ -1698,12 +1702,12 @@ int tdbBtcMoveToFirst(SBTC *pBtc) { &((SBtreeInitPageArg){.pBt = pBt, .flags = TDB_BTREE_ROOT | TDB_BTREE_LEAF}), pBtc->pTxn); if (ret < 0) { tdbError("tdb/btc-move-tofirst: fetch page failed with ret: %d.", ret); - return -1; + return ret; } if (!TDB_BTREE_PAGE_IS_ROOT(pBtc->pPage)) { tdbError("tdb/btc-move-tofirst: not a root page"); - return -1; + return ret; } pBtc->iPage = 0; @@ -1713,7 +1717,7 @@ int tdbBtcMoveToFirst(SBTC *pBtc) { // no any data, point to an invalid position if (!TDB_BTREE_PAGE_IS_LEAF(pBtc->pPage)) { tdbError("tdb/btc-move-to-first: not a leaf page."); - return -1; + return TSDB_CODE_FAILED; } pBtc->idx = -1; @@ -1722,7 +1726,7 @@ int tdbBtcMoveToFirst(SBTC *pBtc) { } else { // TODO tdbError("tdb/btc-move-to-first: move from a dirty cursor."); - return -1; + return TSDB_CODE_FAILED; #if 0 // move from a position int iPage = 0; @@ -1755,7 +1759,7 @@ int tdbBtcMoveToFirst(SBTC *pBtc) { ret = tdbBtcMoveDownward(pBtc); if (ret < 0) { tdbError("tdb/btc-move-tofirst: btc move downward failed with ret: %d.", ret); - return -1; + return ret; } pBtc->idx = 0; @@ -1780,7 +1784,7 @@ int tdbBtcMoveToLast(SBTC *pBtc) { &((SBtreeInitPageArg){.pBt = pBt, .flags = TDB_BTREE_ROOT | TDB_BTREE_LEAF}), pBtc->pTxn); if (ret < 0) { tdbError("tdb/btc-move-tolast: fetch page failed with ret: %d.", ret); - return -1; + return ret; } nCells = TDB_PAGE_TOTAL_CELLS(pBtc->pPage); @@ -1791,7 +1795,7 @@ int tdbBtcMoveToLast(SBTC *pBtc) { // no data at all, point to an invalid position if (!TDB_BTREE_PAGE_IS_LEAF(pBtc->pPage)) { tdbError("tdb/btc-move-to-last: not a leaf page."); - return -1; + return TSDB_CODE_FAILED; } pBtc->idx = -1; @@ -1800,7 +1804,7 @@ int tdbBtcMoveToLast(SBTC *pBtc) { } else { // TODO tdbError("tdb/btc-move-to-last: move from a dirty cursor."); - return -1; + return TSDB_CODE_FAILED; #if 0 int iPage = 0; @@ -1838,7 +1842,7 @@ int tdbBtcMoveToLast(SBTC *pBtc) { ret = tdbBtcMoveDownward(pBtc); if (ret < 0) { tdbError("tdb/btc-move-tolast: btc move downward failed with ret: %d.", ret); - return -1; + return ret; } nCells = TDB_PAGE_TOTAL_CELLS(pBtc->pPage); @@ -1860,7 +1864,7 @@ int tdbBtreeNext(SBTC *pBtc, void **ppKey, int *kLen, void **ppVal, int *vLen) { // current cursor points to an invalid position if (pBtc->idx < 0) { - return -1; + return TSDB_CODE_FAILED; } pCell = tdbPageGetCell(pBtc->pPage, pBtc->idx); @@ -1868,12 +1872,12 @@ int tdbBtreeNext(SBTC *pBtc, void **ppKey, int *kLen, void **ppVal, int *vLen) { ret = tdbBtreeDecodeCell(pBtc->pPage, pCell, &cd, pBtc->pTxn, pBtc->pBt); if (ret < 0) { tdbError("tdb/btree-next: decode cell failed with ret: %d.", ret); - return -1; + return ret; } pKey = tdbRealloc(*ppKey, cd.kLen); if (pKey == NULL) { - return -1; + return terrno; } *ppKey = pKey; @@ -1885,7 +1889,7 @@ int tdbBtreeNext(SBTC *pBtc, void **ppKey, int *kLen, void **ppVal, int *vLen) { pVal = tdbRealloc(*ppVal, cd.vLen); if (pVal == NULL) { tdbFree(pKey); - return -1; + return terrno; } memcpy(pVal, cd.pVal, cd.vLen); @@ -1909,7 +1913,7 @@ int tdbBtreeNext(SBTC *pBtc, void **ppKey, int *kLen, void **ppVal, int *vLen) { ret = tdbBtcMoveToNext(pBtc); if (ret < 0) { tdbError("tdb/btree-next: btc move to next failed with ret: %d.", ret); - return -1; + return ret; } return 0; @@ -1923,7 +1927,7 @@ int tdbBtreePrev(SBTC *pBtc, void **ppKey, int *kLen, void **ppVal, int *vLen) { // current cursor points to an invalid position if (pBtc->idx < 0) { - return -1; + return TSDB_CODE_FAILED; } pCell = tdbPageGetCell(pBtc->pPage, pBtc->idx); @@ -1931,12 +1935,12 @@ int tdbBtreePrev(SBTC *pBtc, void **ppKey, int *kLen, void **ppVal, int *vLen) { ret = tdbBtreeDecodeCell(pBtc->pPage, pCell, &cd, pBtc->pTxn, pBtc->pBt); if (ret < 0) { tdbError("tdb/btree-prev: decode cell failed with ret: %d.", ret); - return -1; + return ret; } pKey = tdbRealloc(*ppKey, cd.kLen); if (pKey == NULL) { - return -1; + return terrno; } *ppKey = pKey; @@ -1948,7 +1952,7 @@ int tdbBtreePrev(SBTC *pBtc, void **ppKey, int *kLen, void **ppVal, int *vLen) { pVal = tdbRealloc(*ppVal, cd.vLen); if (pVal == NULL) { tdbFree(pKey); - return -1; + return terrno; } *ppVal = pVal; @@ -1959,7 +1963,7 @@ int tdbBtreePrev(SBTC *pBtc, void **ppKey, int *kLen, void **ppVal, int *vLen) { ret = tdbBtcMoveToPrev(pBtc); if (ret < 0) { tdbError("tdb/btree-prev: btc move to prev failed with ret: %d.", ret); - return -1; + return ret; } return 0; @@ -1972,10 +1976,10 @@ int tdbBtcMoveToNext(SBTC *pBtc) { if (!TDB_BTREE_PAGE_IS_LEAF(pBtc->pPage)) { tdbError("tdb/btc-move-to-next: not a leaf page."); - return -1; + return TSDB_CODE_FAILED; } - if (pBtc->idx < 0) return -1; + if (pBtc->idx < 0) return TSDB_CODE_FAILED; pBtc->idx++; if (pBtc->idx < TDB_PAGE_TOTAL_CELLS(pBtc->pPage)) { @@ -1994,7 +1998,7 @@ int tdbBtcMoveToNext(SBTC *pBtc) { if (TDB_BTREE_PAGE_IS_LEAF(pBtc->pPage)) { tdbError("tdb/btree-decode-cell: should not be a leaf page here."); - return -1; + return TSDB_CODE_FAILED; } if (pBtc->idx <= TDB_PAGE_TOTAL_CELLS(pBtc->pPage)) { break; @@ -2008,7 +2012,7 @@ int tdbBtcMoveToNext(SBTC *pBtc) { ret = tdbBtcMoveDownward(pBtc); if (ret < 0) { tdbError("tdb/btc-move-tonext: btc move downward failed with ret: %d.", ret); - return -1; + return ret; } pBtc->idx = 0; @@ -2018,7 +2022,7 @@ int tdbBtcMoveToNext(SBTC *pBtc) { } int tdbBtcMoveToPrev(SBTC *pBtc) { - if (pBtc->idx < 0) return -1; + if (pBtc->idx < 0) return TSDB_CODE_FAILED; pBtc->idx--; if (pBtc->idx >= 0) { @@ -2061,17 +2065,17 @@ static int tdbBtcMoveDownward(SBTC *pBtc) { if (pBtc->idx < 0) { tdbError("tdb/btc-move-downward: invalid idx: %d.", pBtc->idx); - return -1; + return TSDB_CODE_FAILED; } if (TDB_BTREE_PAGE_IS_LEAF(pBtc->pPage)) { tdbError("tdb/btc-move-downward: should not be a leaf page here."); - return -1; + return TSDB_CODE_FAILED; } if (TDB_BTREE_PAGE_IS_OVFL(pBtc->pPage)) { tdbError("tdb/btc-move-downward: should not be a ovfl page here."); - return -1; + return TSDB_CODE_FAILED; } if (pBtc->idx < TDB_PAGE_TOTAL_CELLS(pBtc->pPage)) { @@ -2083,7 +2087,7 @@ static int tdbBtcMoveDownward(SBTC *pBtc) { if (!pgno) { tdbError("tdb/btc-move-downward: invalid pgno."); - return -1; + return TSDB_CODE_FAILED; } pBtc->pgStack[pBtc->iPage] = pBtc->pPage; @@ -2096,14 +2100,14 @@ static int tdbBtcMoveDownward(SBTC *pBtc) { &((SBtreeInitPageArg){.pBt = pBtc->pBt, .flags = 0}), pBtc->pTxn); if (ret < 0) { tdbError("tdb/btc-move-downward: fetch page failed with ret: %d.", ret); - return -1; + return TSDB_CODE_FAILED; } return 0; } static int tdbBtcMoveUpward(SBTC *pBtc) { - if (pBtc->iPage == 0) return -1; + if (pBtc->iPage == 0) return TSDB_CODE_FAILED; tdbPagerReturnPage(pBtc->pBt->pPager, pBtc->pPage, pBtc->pTxn); @@ -2118,7 +2122,7 @@ int tdbBtcGet(SBTC *pBtc, const void **ppKey, int *kLen, const void **ppVal, int SCell *pCell; if (pBtc->idx < 0 || pBtc->idx >= TDB_PAGE_TOTAL_CELLS(pBtc->pPage)) { - return -1; + return TSDB_CODE_FAILED; } pCell = tdbPageGetCell(pBtc->pPage, pBtc->idx); @@ -2152,14 +2156,14 @@ int tdbBtcDelete(SBTC *pBtc) { if (idx < 0 || idx >= nCells) { tdbError("tdb/btc-delete: idx: %d out of range[%d, %d).", idx, 0, nCells); - return -1; + return TSDB_CODE_FAILED; } // drop the cell on the leaf ret = tdbPagerWrite(pPager, pBtc->pPage); if (ret < 0) { tdbError("failed to write page since %s", terrstr()); - return -1; + return ret; } bool destroyOfps = false; @@ -2200,7 +2204,7 @@ int tdbBtcDelete(SBTC *pBtc) { ret = tdbPagerWrite(pPager, pPage); if (ret < 0) { tdbError("failed to write page since %s", terrstr()); - return -1; + return ret; } // update the cell with new key @@ -2211,7 +2215,7 @@ int tdbBtcDelete(SBTC *pBtc) { if (ret < 0) { tdbOsFree(pCell); tdbError("tdb/btc-delete: page update cell failed with ret: %d.", ret); - return -1; + return ret; } tdbOsFree(pCell); @@ -2229,7 +2233,7 @@ int tdbBtcDelete(SBTC *pBtc) { ret = tdbBtreeBalance(pBtc); if (ret < 0) { tdbError("tdb/btc-delete: btree balance failed with ret: %d.", ret); - return -1; + return ret; } } @@ -2242,7 +2246,7 @@ int tdbBtcDelete(SBTC *pBtc) { // delete the leaf page and do balance if (TDB_PAGE_TOTAL_CELLS(pBtc->pPage) != 0) { tdbError("tdb/btc-delete: page to be deleted should be empty."); - return -1; + return TSDB_CODE_FAILED; } // printf("tdb/btc-delete: btree balance delete pgno: %d.\n", TDB_PAGE_PGNO(pBtc->pPage)); @@ -2250,7 +2254,7 @@ int tdbBtcDelete(SBTC *pBtc) { ret = tdbBtreeBalance(pBtc); if (ret < 0) { tdbError("tdb/btc-delete: btree balance failed with ret: %d.", ret); - return -1; + return ret; } } } @@ -2268,7 +2272,7 @@ int tdbBtcUpsert(SBTC *pBtc, const void *pKey, int kLen, const void *pData, int if (pBtc->idx < 0) { tdbError("tdb/btc-upsert: invalid idx: %d.", pBtc->idx); - return -1; + return TSDB_CODE_FAILED; } // alloc space @@ -2276,7 +2280,7 @@ int tdbBtcUpsert(SBTC *pBtc, const void *pKey, int kLen, const void *pData, int pBuf = tdbRealloc(pBtc->pBt->pBuf, pBtc->pBt->pageSize > szBuf ? szBuf : pBtc->pBt->pageSize); if (pBuf == NULL) { tdbError("tdb/btc-upsert: realloc pBuf failed."); - return -1; + return terrno; } pBtc->pBt->pBuf = pBuf; pCell = (SCell *)pBtc->pBt->pBuf; @@ -2285,35 +2289,35 @@ int tdbBtcUpsert(SBTC *pBtc, const void *pKey, int kLen, const void *pData, int ret = tdbBtreeEncodeCell(pBtc->pPage, pKey, kLen, pData, nData, pCell, &szCell, pBtc->pTxn, pBtc->pBt); if (ret < 0) { tdbError("tdb/btc-upsert: btree encode cell failed with ret: %d.", ret); - return -1; + return ret; } // mark dirty ret = tdbPagerWrite(pBtc->pBt->pPager, pBtc->pPage); if (ret < 0) { tdbError("failed to write page since %s", terrstr()); - return -1; + return ret; } // insert or update if (insert) { if (pBtc->idx > nCells) { tdbError("tdb/btc-upsert: invalid idx: %d, nCells: %d.", pBtc->idx, nCells); - return -1; + return TSDB_CODE_FAILED; } ret = tdbPageInsertCell(pBtc->pPage, pBtc->idx, pCell, szCell, 0); } else { if (pBtc->idx >= nCells) { tdbError("tdb/btc-upsert: invalid idx: %d, nCells: %d.", pBtc->idx, nCells); - return -1; + return TSDB_CODE_FAILED; } ret = tdbPageUpdateCell(pBtc->pPage, pBtc->idx, pCell, szCell, pBtc->pTxn, pBtc->pBt); } if (ret < 0) { tdbError("tdb/btc-upsert: page insert/update cell failed with ret: %d.", ret); - return -1; + return ret; } /* bool destroyOfps = false; @@ -2327,7 +2331,7 @@ int tdbBtcUpsert(SBTC *pBtc, const void *pKey, int kLen, const void *pData, int ret = tdbBtreeBalance(pBtc); if (ret < 0) { tdbError("tdb/btc-upsert: btree balance failed with ret: %d.", ret); - return -1; + return ret; } } /* @@ -2365,7 +2369,7 @@ int tdbBtcMoveTo(SBTC *pBtc, const void *pKey, int kLen, int *pCRst) { if (ret < 0) { // TODO tdbError("tdb/btc-move-to: fetch page failed with ret: %d.", ret); - return -1; + return ret; } pBtc->iPage = 0; @@ -2375,7 +2379,7 @@ int tdbBtcMoveTo(SBTC *pBtc, const void *pKey, int kLen, int *pCRst) { } else { // TODO tdbError("tdb/btc-move-to: move from a dirty cursor."); - return -1; + return TSDB_CODE_FAILED; #if 0 SPage *pPage; int idx; @@ -2499,7 +2503,7 @@ int tdbBtcClose(SBTC *pBtc) { for (;;) { if (NULL == pBtc->pPage) { tdbError("tdb/btc-close: null ptr pPage."); - return -1; + return TSDB_CODE_FAILED; } tdbPagerReturnPage(pBtc->pBt->pPager, pBtc->pPage, pBtc->pTxn); diff --git a/source/libs/tdb/src/db/tdbPager.c b/source/libs/tdb/src/db/tdbPager.c index 5d8b05ffcf..414ca42a02 100644 --- a/source/libs/tdb/src/db/tdbPager.c +++ b/source/libs/tdb/src/db/tdbPager.c @@ -862,7 +862,7 @@ static int tdbPagerAllocPage(SPager *pPager, SPgno *ppgno, TXN *pTxn) { // Try to allocate from the free list of the pager ret = tdbPagerAllocFreePage(pPager, ppgno, pTxn); if (ret < 0) { - return -1; + return ret; } if (*ppgno != 0) return 0; @@ -875,7 +875,7 @@ static int tdbPagerAllocPage(SPager *pPager, SPgno *ppgno, TXN *pTxn) { if (*ppgno == 0) { tdbError("tdb/pager:%p, alloc new page failed.", pPager); - return -1; + return TSDB_CODE_FAILED; } return 0; } @@ -907,7 +907,7 @@ static int tdbPagerInitPage(SPager *pPager, SPage *pPage, int (*initPage)(SPage if (nRead < pPage->pageSize) { tdbError("tdb/pager:%p, pgno:%d, nRead:%" PRId64 "pgSize:%" PRId32, pPager, pgno, nRead, pPage->pageSize); TDB_UNLOCK_PAGE(pPage); - return -1; + return TAOS_SYSTEM_ERROR(errno); } int32_t encryptAlgorithm = pPager->pEnv->encryptAlgorithm; @@ -954,7 +954,7 @@ static int tdbPagerInitPage(SPager *pPager, SPage *pPage, int (*initPage)(SPage tdbError("tdb/pager:%p, pgno:%d, nRead:%" PRId64 "pgSize:%" PRId32 " init page failed.", pPager, pgno, nRead, pPage->pageSize); TDB_UNLOCK_PAGE(pPage); - return -1; + return ret; } tmemory_barrier(); @@ -975,7 +975,7 @@ static int tdbPagerInitPage(SPager *pPager, SPage *pPage, int (*initPage)(SPage } else { tdbError("tdb/pager:%p, pgno:%d, nRead:%" PRId64 "pgSize:%" PRId32 " lock page failed.", pPager, pgno, nRead, pPage->pageSize); - return -1; + return TSDB_CODE_FAILED; } return 0; @@ -1127,14 +1127,12 @@ static int tdbPagerRestore(SPager *pPager, const char *jFileName) { if (tdbOsClose(jfd) < 0) { tdbError("failed to close jfd due to %s. jFileName:%s", strerror(errno), pPager->jFileName); - terrno = TAOS_SYSTEM_ERROR(errno); - return -1; + return terrno = TAOS_SYSTEM_ERROR(errno); } if (tdbOsRemove(jFileName) < 0 && errno != ENOENT) { tdbError("failed to remove file due to %s. jFileName:%s", strerror(errno), pPager->jFileName); - terrno = TAOS_SYSTEM_ERROR(errno); - return -1; + return terrno = TAOS_SYSTEM_ERROR(errno); } return 0; From a5cd3444d1c09320d7027f6c054d072e3b676efd Mon Sep 17 00:00:00 2001 From: Minglei Jin Date: Thu, 25 Jul 2024 12:05:38 +0800 Subject: [PATCH 09/12] update sync raft store --- source/libs/sync/src/syncRaftStore.c | 64 ++++++++++++++-------------- 1 file changed, 31 insertions(+), 33 deletions(-) diff --git a/source/libs/sync/src/syncRaftStore.c b/source/libs/sync/src/syncRaftStore.c index c200c6cb4b..7f702c3766 100644 --- a/source/libs/sync/src/syncRaftStore.c +++ b/source/libs/sync/src/syncRaftStore.c @@ -25,17 +25,17 @@ static int32_t raftStoreDecode(const SJson *pJson, SRaftStore *pStore) { int32_t code = 0; tjsonGetNumberValue(pJson, "current_term", pStore->currentTerm, code); - if (code < 0) return -1; + if (code < 0) TAOS_RETURN(TSDB_CODE_FAILED); tjsonGetNumberValue(pJson, "vote_for_addr", pStore->voteFor.addr, code); - if (code < 0) return -1; + if (code < 0) TAOS_RETURN(TSDB_CODE_FAILED); tjsonGetInt32ValueFromDouble(pJson, "vote_for_vgid", pStore->voteFor.vgId, code); - if (code < 0) return -1; + if (code < 0) TAOS_RETURN(TSDB_CODE_FAILED); - return 0; + TAOS_RETURN(TSDB_CODE_SUCCESS); } int32_t raftStoreReadFile(SSyncNode *pNode) { - int32_t code = -1; + int32_t code = -1, lino = 0; TdFilePtr pFile = NULL; char *pData = NULL; SJson *pJson = NULL; @@ -52,41 +52,38 @@ int32_t raftStoreReadFile(SSyncNode *pNode) { pFile = taosOpenFile(file, TD_FILE_READ); if (pFile == NULL) { - terrno = TAOS_SYSTEM_ERROR(errno); sError("vgId:%d, failed to open raft store file:%s since %s", pNode->vgId, file, terrstr()); - goto _OVER; + + TAOS_CHECK_GOTO(TAOS_SYSTEM_ERROR(errno), &lino, _OVER); } int64_t size = 0; if (taosFStatFile(pFile, &size, NULL) < 0) { - terrno = TAOS_SYSTEM_ERROR(errno); sError("vgId:%d, failed to fstat raft store file:%s since %s", pNode->vgId, file, terrstr()); - goto _OVER; + + TAOS_CHECK_GOTO(TAOS_SYSTEM_ERROR(errno), &lino, _OVER); } pData = taosMemoryMalloc(size + 1); if (pData == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - goto _OVER; + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); } if (taosReadFile(pFile, pData, size) != size) { - terrno = TAOS_SYSTEM_ERROR(errno); sError("vgId:%d, failed to read raft store file:%s since %s", pNode->vgId, file, terrstr()); - goto _OVER; + + TAOS_CHECK_GOTO(TAOS_SYSTEM_ERROR(errno), &lino, _OVER); } pData[size] = '\0'; pJson = tjsonParse(pData); if (pJson == NULL) { - terrno = TSDB_CODE_INVALID_JSON_FORMAT; - goto _OVER; + TAOS_CHECK_GOTO(TSDB_CODE_INVALID_JSON_FORMAT, &lino, _OVER); } if (raftStoreDecode(pJson, pStore) < 0) { - terrno = TSDB_CODE_INVALID_JSON_FORMAT; - goto _OVER; + TAOS_CHECK_GOTO(TSDB_CODE_INVALID_JSON_FORMAT, &lino, _OVER); } code = 0; @@ -100,18 +97,20 @@ _OVER: if (code != 0) { sError("vgId:%d, failed to read raft store file:%s since %s", pNode->vgId, file, terrstr()); } - return code; + + TAOS_RETURN(code); } static int32_t raftStoreEncode(SJson *pJson, SRaftStore *pStore) { - if (tjsonAddIntegerToObject(pJson, "current_term", pStore->currentTerm) < 0) return -1; - if (tjsonAddIntegerToObject(pJson, "vote_for_addr", pStore->voteFor.addr) < 0) return -1; - if (tjsonAddDoubleToObject(pJson, "vote_for_vgid", pStore->voteFor.vgId) < 0) return -1; - return 0; + if (tjsonAddIntegerToObject(pJson, "current_term", pStore->currentTerm) < 0) TAOS_RETURN(TSDB_CODE_FAILED); + if (tjsonAddIntegerToObject(pJson, "vote_for_addr", pStore->voteFor.addr) < 0) TAOS_RETURN(TSDB_CODE_FAILED); + if (tjsonAddDoubleToObject(pJson, "vote_for_vgid", pStore->voteFor.vgId) < 0) TAOS_RETURN(TSDB_CODE_FAILED); + + TAOS_RETURN(TSDB_CODE_SUCCESS); } int32_t raftStoreWriteFile(SSyncNode *pNode) { - int32_t code = -1; + int32_t code = -1, lino = 0; char *buffer = NULL; SJson *pJson = NULL; TdFilePtr pFile = NULL; @@ -120,23 +119,23 @@ int32_t raftStoreWriteFile(SSyncNode *pNode) { char file[PATH_MAX] = {0}; snprintf(file, sizeof(file), "%s.bak", realfile); - terrno = TSDB_CODE_OUT_OF_MEMORY; pJson = tjsonCreateObject(); - if (pJson == NULL) goto _OVER; - if (raftStoreEncode(pJson, pStore) != 0) goto _OVER; + if (pJson == NULL) TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); + if (raftStoreEncode(pJson, pStore) != 0) TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); + buffer = tjsonToString(pJson); - if (buffer == NULL) goto _OVER; - terrno = 0; + if (buffer == NULL) TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER); pFile = taosOpenFile(file, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_TRUNC | TD_FILE_WRITE_THROUGH); - if (pFile == NULL) goto _OVER; + if (pFile == NULL) TAOS_CHECK_GOTO(TAOS_SYSTEM_ERROR(errno), &lino, _OVER); int32_t len = strlen(buffer); - if (taosWriteFile(pFile, buffer, len) <= 0) goto _OVER; - if (taosFsyncFile(pFile) < 0) goto _OVER; + if (taosWriteFile(pFile, buffer, len) <= 0) TAOS_CHECK_GOTO(TAOS_SYSTEM_ERROR(errno), &lino, _OVER); + + if (taosFsyncFile(pFile) < 0) TAOS_CHECK_GOTO(TAOS_SYSTEM_ERROR(errno), &lino, _OVER); taosCloseFile(&pFile); - if (taosRenameFile(file, realfile) != 0) goto _OVER; + if (taosRenameFile(file, realfile) != 0) TAOS_CHECK_GOTO(TAOS_SYSTEM_ERROR(errno), &lino, _OVER); code = 0; sInfo("vgId:%d, succeed to write raft store file:%s, term:%" PRId64, pNode->vgId, realfile, pStore->currentTerm); @@ -147,7 +146,6 @@ _OVER: if (pFile != NULL) taosCloseFile(&pFile); if (code != 0) { - if (terrno == 0) terrno = TAOS_SYSTEM_ERROR(errno); sError("vgId:%d, failed to write raft store file:%s since %s", pNode->vgId, realfile, terrstr()); } return code; From 970a5f31a34a30b80e8c98904c732afe709de20f Mon Sep 17 00:00:00 2001 From: Minglei Jin Date: Thu, 25 Jul 2024 12:09:51 +0800 Subject: [PATCH 10/12] update sync replication --- source/libs/sync/src/syncReplication.c | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/source/libs/sync/src/syncReplication.c b/source/libs/sync/src/syncReplication.c index 9312719be7..dfe9f51af2 100644 --- a/source/libs/sync/src/syncReplication.c +++ b/source/libs/sync/src/syncReplication.c @@ -52,7 +52,8 @@ int32_t syncNodeReplicateReset(SSyncNode* pNode, SRaftId* pDestId) { SSyncLogReplMgr* pMgr = syncNodeGetLogReplMgr(pNode, pDestId); syncLogReplReset(pMgr); taosThreadMutexUnlock(&pBuf->mutex); - return 0; + + TAOS_RETURN(TSDB_CODE_SUCCESS); } int32_t syncNodeReplicate(SSyncNode* pNode) { @@ -60,13 +61,14 @@ int32_t syncNodeReplicate(SSyncNode* pNode) { taosThreadMutexLock(&pBuf->mutex); int32_t ret = syncNodeReplicateWithoutLock(pNode); taosThreadMutexUnlock(&pBuf->mutex); - return ret; + + TAOS_RETURN(ret); } int32_t syncNodeReplicateWithoutLock(SSyncNode* pNode) { if ((pNode->state != TAOS_SYNC_STATE_LEADER && pNode->state != TAOS_SYNC_STATE_ASSIGNED_LEADER) || pNode->raftCfg.cfg.totalReplicaNum == 1) { - return -1; + TAOS_RETURN(TSDB_CODE_FAILED); } for (int32_t i = 0; i < pNode->totalReplicaNum; i++) { if (syncUtilSameId(&pNode->replicasId[i], &pNode->myRaftId)) { @@ -75,14 +77,16 @@ int32_t syncNodeReplicateWithoutLock(SSyncNode* pNode) { SSyncLogReplMgr* pMgr = pNode->logReplMgrs[i]; (void)syncLogReplStart(pMgr, pNode); } - return 0; + + TAOS_RETURN(TSDB_CODE_SUCCESS); } int32_t syncNodeSendAppendEntries(SSyncNode* pSyncNode, const SRaftId* destRaftId, SRpcMsg* pRpcMsg) { SyncAppendEntries* pMsg = pRpcMsg->pCont; pMsg->destId = *destRaftId; syncNodeSendMsgById(destRaftId, pSyncNode, pRpcMsg); - return 0; + + TAOS_RETURN(TSDB_CODE_SUCCESS); } int32_t syncNodeSendHeartbeat(SSyncNode* pSyncNode, const SRaftId* destId, SRpcMsg* pMsg) { @@ -112,5 +116,5 @@ int32_t syncNodeHeartbeatPeers(SSyncNode* pSyncNode) { syncNodeSendHeartbeat(pSyncNode, &pSyncMsg->destId, &rpcMsg); } - return 0; + TAOS_RETURN(TSDB_CODE_SUCCESS); } From 5caa366464402ac0cb8c19e643a105924dffcb42 Mon Sep 17 00:00:00 2001 From: Minglei Jin Date: Thu, 25 Jul 2024 12:15:00 +0800 Subject: [PATCH 11/12] update sync vote & reply --- source/libs/sync/src/syncRequestVote.c | 11 ++++++----- source/libs/sync/src/syncRequestVoteReply.c | 14 +++++++++----- 2 files changed, 15 insertions(+), 10 deletions(-) diff --git a/source/libs/sync/src/syncRequestVote.c b/source/libs/sync/src/syncRequestVote.c index 77e5498127..0e50cca94c 100644 --- a/source/libs/sync/src/syncRequestVote.c +++ b/source/libs/sync/src/syncRequestVote.c @@ -20,7 +20,6 @@ #include "syncRaftStore.h" #include "syncUtil.h" #include "syncVoteMgr.h" -#include "syncUtil.h" // TLA+ Spec // HandleRequestVoteRequest(i, j, m) == @@ -95,7 +94,8 @@ int32_t syncNodeOnRequestVote(SSyncNode* ths, const SRpcMsg* pRpcMsg) { // if already drop replica, do not process if (!syncNodeInRaftGroup(ths, &pMsg->srcId)) { syncLogRecvRequestVote(ths, pMsg, -1, "not in my config"); - return -1; + + TAOS_RETURN(TSDB_CODE_FAILED); } bool logOK = syncNodeOnRequestVoteLogOK(ths, pMsg); @@ -122,8 +122,8 @@ int32_t syncNodeOnRequestVote(SSyncNode* ths, const SRpcMsg* pRpcMsg) { // send msg SRpcMsg rpcMsg = {0}; - ret = syncBuildRequestVoteReply(&rpcMsg, ths->vgId); - ASSERT(ret == 0); + + TAOS_CHECK_RETURN(syncBuildRequestVoteReply(&rpcMsg, ths->vgId)); SyncRequestVoteReply* pReply = rpcMsg.pCont; pReply->srcId = ths->myRaftId; @@ -138,5 +138,6 @@ int32_t syncNodeOnRequestVote(SSyncNode* ths, const SRpcMsg* pRpcMsg) { syncNodeSendMsgById(&pReply->destId, ths, &rpcMsg); if (resetElect) syncNodeResetElectTimer(ths); - return 0; + + TAOS_RETURN(TSDB_CODE_SUCCESS); } diff --git a/source/libs/sync/src/syncRequestVoteReply.c b/source/libs/sync/src/syncRequestVoteReply.c index 25c9f813a6..10d9a6c96b 100644 --- a/source/libs/sync/src/syncRequestVoteReply.c +++ b/source/libs/sync/src/syncRequestVoteReply.c @@ -45,19 +45,22 @@ int32_t syncNodeOnRequestVoteReply(SSyncNode* ths, const SRpcMsg* pRpcMsg) { // if already drop replica, do not process if (!syncNodeInRaftGroup(ths, &(pMsg->srcId))) { syncLogRecvRequestVoteReply(ths, pMsg, "not in my config"); - return -1; + + TAOS_RETURN(TSDB_CODE_FAILED); } SyncTerm currentTerm = raftStoreGetTerm(ths); // drop stale response if (pMsg->term < currentTerm) { syncLogRecvRequestVoteReply(ths, pMsg, "drop stale response"); - return -1; + + TAOS_RETURN(TSDB_CODE_FAILED); } if (pMsg->term > currentTerm) { syncLogRecvRequestVoteReply(ths, pMsg, "error term"); syncNodeStepDown(ths, pMsg->term); - return -1; + + TAOS_RETURN(TSDB_CODE_FAILED); } syncLogRecvRequestVoteReply(ths, pMsg, ""); @@ -69,7 +72,8 @@ int32_t syncNodeOnRequestVoteReply(SSyncNode* ths, const SRpcMsg* pRpcMsg) { if (ths->pVotesRespond->term != pMsg->term) { sNError(ths, "vote respond error vote-respond-mgr term:%" PRIu64 ", msg term:%" PRIu64 "", ths->pVotesRespond->term, pMsg->term); - return -1; + + TAOS_RETURN(TSDB_CODE_FAILED); } votesRespondAdd(ths->pVotesRespond, pMsg); @@ -93,5 +97,5 @@ int32_t syncNodeOnRequestVoteReply(SSyncNode* ths, const SRpcMsg* pRpcMsg) { } } - return 0; + TAOS_RETURN(TSDB_CODE_SUCCESS); } From f075b5293a9471491f1687cfbfcff287bfe6bff7 Mon Sep 17 00:00:00 2001 From: Hongze Cheng Date: Thu, 25 Jul 2024 13:19:07 +0800 Subject: [PATCH 12/12] make it compile --- source/dnode/vnode/src/meta/metaTable.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/dnode/vnode/src/meta/metaTable.c b/source/dnode/vnode/src/meta/metaTable.c index 92e910dba3..52151e76d6 100644 --- a/source/dnode/vnode/src/meta/metaTable.c +++ b/source/dnode/vnode/src/meta/metaTable.c @@ -185,7 +185,7 @@ int metaDelJsonVarFromIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry, const SSche int32_t nTagData = 0; SArray *pTagVals = NULL; - code = tTagToValArray((const STag *)data, &pTagVals); + int32_t code = tTagToValArray((const STag *)data, &pTagVals); if (code) { return code; }