diff --git a/include/dnode/mnode/sdb/sdb.h b/include/dnode/mnode/sdb/sdb.h index c693f8e64a..dc2f52fac3 100644 --- a/include/dnode/mnode/sdb/sdb.h +++ b/include/dnode/mnode/sdb/sdb.h @@ -95,11 +95,21 @@ extern "C" { #define SDB_SET_DATALEN(pRaw, dataLen) \ { \ if (sdbSetRawDataLen(pRaw, dataLen) != 0) { \ - sdbFreeRaw(pRaw); \ + sdbFreeRaw(pRaw); \ return NULL; \ }; \ } +typedef struct SSdbRaw SSdbRaw; +typedef struct SSdbRow SSdbRow; +typedef enum { SDB_KEY_BINARY = 1, SDB_KEY_INT32 = 2, SDB_KEY_INT64 = 3 } EKeyType; +typedef enum { + SDB_STATUS_CREATING = 1, + SDB_STATUS_READY = 2, + SDB_STATUS_DROPPING = 3, + SDB_STATUS_DROPPED = 4 +} ESdbStatus; + typedef enum { SDB_START = 0, SDB_TRANS = 1, @@ -116,12 +126,6 @@ typedef enum { SDB_MAX = 12 } ESdbType; -typedef enum { SDB_ACTION_INSERT = 1, SDB_ACTION_UPDATE = 2, SDB_ACTION_DELETE = 3 } ESdbAction; -typedef enum { SDB_KEY_BINARY = 1, SDB_KEY_INT32 = 2, SDB_KEY_INT64 = 3 } EKeyType; -typedef enum { SDB_STATUS_CREATING = 1, SDB_STATUS_READY = 2, SDB_STATUS_DROPPING = 3 } ESdbStatus; -typedef struct SSdbRaw SSdbRaw; -typedef struct SSdbRow SSdbRow; - typedef int32_t (*SdbInsertFp)(void *pObj); typedef int32_t (*SdbUpdateFp)(void *pSrcObj, void *pDstObj); typedef int32_t (*SdbDeleteFp)(void *pObj); @@ -165,7 +169,6 @@ int32_t sdbSetRawInt64(SSdbRaw *pRaw, int32_t dataPos, int64_t val); int32_t sdbSetRawBinary(SSdbRaw *pRaw, int32_t dataPos, const char *pVal, int32_t valLen); int32_t sdbSetRawDataLen(SSdbRaw *pRaw, int32_t dataLen); int32_t sdbSetRawStatus(SSdbRaw *pRaw, ESdbStatus status); -int32_t sdbSetRawAction(SSdbRaw *pRaw, ESdbAction action); int32_t sdbGetRawInt8(SSdbRaw *pRaw, int32_t dataPos, int8_t *val); int32_t sdbGetRawInt32(SSdbRaw *pRaw, int32_t dataPos, int32_t *val); int32_t sdbGetRawInt64(SSdbRaw *pRaw, int32_t dataPos, int64_t *val); diff --git a/include/util/taoserror.h b/include/util/taoserror.h index dcd8b9a743..bcff095249 100644 --- a/include/util/taoserror.h +++ b/include/util/taoserror.h @@ -136,13 +136,15 @@ int32_t* taosGetErrno(); #define TSDB_CODE_SDB_APP_ERROR TAOS_DEF_ERROR_CODE(0, 0x0320) #define TSDB_CODE_SDB_OBJ_ALREADY_THERE TAOS_DEF_ERROR_CODE(0, 0x0321) #define TSDB_CODE_SDB_OBJ_NOT_THERE TAOS_DEF_ERROR_CODE(0, 0x0322) -#define TSDB_CODE_SDB_INVALID_TABLE_TYPE TAOS_DEF_ERROR_CODE(0, 0x0323) -#define TSDB_CODE_SDB_INVALID_KEY_TYPE TAOS_DEF_ERROR_CODE(0, 0x0324) -#define TSDB_CODE_SDB_INVALID_ACTION_TYPE TAOS_DEF_ERROR_CODE(0, 0x0325) -#define TSDB_CODE_SDB_INVALID_STATUS_TYPE TAOS_DEF_ERROR_CODE(0, 0x0326) -#define TSDB_CODE_SDB_INVALID_DATA_VER TAOS_DEF_ERROR_CODE(0, 0x0327) -#define TSDB_CODE_SDB_INVALID_DATA_LEN TAOS_DEF_ERROR_CODE(0, 0x0328) -#define TSDB_CODE_SDB_INVALID_DATA_CONTENT TAOS_DEF_ERROR_CODE(0, 0x0329) +#define TSDB_CODE_SDB_OBJ_CREATING TAOS_DEF_ERROR_CODE(0, 0x0323) +#define TSDB_CODE_SDB_OBJ_DROPPING TAOS_DEF_ERROR_CODE(0, 0x0324) +#define TSDB_CODE_SDB_INVALID_TABLE_TYPE TAOS_DEF_ERROR_CODE(0, 0x0325) +#define TSDB_CODE_SDB_INVALID_KEY_TYPE TAOS_DEF_ERROR_CODE(0, 0x0326) +#define TSDB_CODE_SDB_INVALID_ACTION_TYPE TAOS_DEF_ERROR_CODE(0, 0x0327) +#define TSDB_CODE_SDB_INVALID_STATUS_TYPE TAOS_DEF_ERROR_CODE(0, 0x0328) +#define TSDB_CODE_SDB_INVALID_DATA_VER TAOS_DEF_ERROR_CODE(0, 0x0329) +#define TSDB_CODE_SDB_INVALID_DATA_LEN TAOS_DEF_ERROR_CODE(0, 0x032A) +#define TSDB_CODE_SDB_INVALID_DATA_CONTENT TAOS_DEF_ERROR_CODE(0, 0x032B) #define TSDB_CODE_MND_DNODE_ALREADY_EXIST TAOS_DEF_ERROR_CODE(0, 0x0330) //"DNode already exists") #define TSDB_CODE_MND_DNODE_NOT_EXIST TAOS_DEF_ERROR_CODE(0, 0x0331) //"DNode does not exist") diff --git a/source/dnode/mnode/impl/src/mnodeAcct.c b/source/dnode/mnode/impl/src/mnodeAcct.c index cd9087ee30..79310e13aa 100644 --- a/source/dnode/mnode/impl/src/mnodeAcct.c +++ b/source/dnode/mnode/impl/src/mnodeAcct.c @@ -94,6 +94,7 @@ static int32_t mnodeCreateDefaultAcct() { SSdbRaw *pRaw = mnodeAcctActionEncode(&acctObj); if (pRaw == NULL) return -1; + sdbSetRawStatus(pRaw, SDB_STATUS_READY); return sdbWrite(pRaw); } diff --git a/source/dnode/mnode/impl/src/mnodeUser.c b/source/dnode/mnode/impl/src/mnodeUser.c index d74ba0f7cc..ac215932ed 100644 --- a/source/dnode/mnode/impl/src/mnodeUser.c +++ b/source/dnode/mnode/impl/src/mnodeUser.c @@ -110,6 +110,7 @@ static int32_t mnodeCreateDefaultUser(char *acct, char *user, char *pass) { SSdbRaw *pRaw = mnodeUserActionEncode(&userObj); if (pRaw == NULL) return -1; + sdbSetRawStatus(pRaw, SDB_STATUS_READY); return sdbWrite(pRaw); } @@ -149,15 +150,13 @@ static int32_t mnodeCreateUser(char *acct, char *user, char *pass, SMnodeMsg *pM return -1; } sdbSetRawStatus(pRedoRaw, SDB_STATUS_CREATING); - sdbSetRawAction(pRedoRaw, SDB_ACTION_INSERT); SSdbRaw *pUndoRaw = mnodeUserActionEncode(&userObj); if (pUndoRaw == NULL || trnAppendUndoLog(pTrans, pUndoRaw) != 0) { trnDrop(pTrans); return -1; } - sdbSetRawStatus(pUndoRaw, SDB_STATUS_DROPPING); - sdbSetRawAction(pUndoRaw, SDB_ACTION_DELETE); + sdbSetRawStatus(pUndoRaw, SDB_STATUS_DROPPED); SSdbRaw *pCommitRaw = mnodeUserActionEncode(&userObj); if (pCommitRaw == NULL || trnAppendCommitLog(pTrans, pCommitRaw) != 0) { @@ -165,7 +164,6 @@ static int32_t mnodeCreateUser(char *acct, char *user, char *pass, SMnodeMsg *pM return -1; } sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY); - sdbSetRawAction(pCommitRaw, SDB_ACTION_UPDATE); if (trnPrepare(pTrans, mnodeSyncPropose) != 0) { trnDrop(pTrans); diff --git a/source/dnode/mnode/sdb/inc/sdbInt.h b/source/dnode/mnode/sdb/inc/sdbInt.h index 5ff1c892a1..fbc06775ff 100644 --- a/source/dnode/mnode/sdb/inc/sdbInt.h +++ b/source/dnode/mnode/sdb/inc/sdbInt.h @@ -40,14 +40,14 @@ typedef struct SSdbRaw { int8_t sdb; int8_t sver; int8_t status; - int8_t action; - int8_t reserved[4]; + int8_t reserved; int32_t cksum; int32_t dataLen; char pData[]; } SSdbRaw; typedef struct SSdbRow { + ESdbType sdb; ESdbStatus status; int32_t refCount; char pObj[]; diff --git a/source/dnode/mnode/sdb/src/sdb.c b/source/dnode/mnode/sdb/src/sdb.c index d8121df5a2..88ef813428 100644 --- a/source/dnode/mnode/sdb/src/sdb.c +++ b/source/dnode/mnode/sdb/src/sdb.c @@ -45,7 +45,7 @@ int32_t sdbInit() { type = TSDB_DATA_TYPE_BINARY; } - SHashObj *hash = taosHashInit(128, taosGetDefaultHashFunction(type), true, HASH_NO_LOCK); + SHashObj *hash = taosHashInit(64, taosGetDefaultHashFunction(type), true, HASH_NO_LOCK); if (hash == NULL) { return TSDB_CODE_OUT_OF_MEMORY; } diff --git a/source/dnode/mnode/sdb/src/sdbFile.c b/source/dnode/mnode/sdb/src/sdbFile.c index 8358b9aad1..b01322217f 100644 --- a/source/dnode/mnode/sdb/src/sdbFile.c +++ b/source/dnode/mnode/sdb/src/sdbFile.c @@ -17,8 +17,9 @@ #include "sdbInt.h" #include "tglobal.h" - static int32_t sdbCreateDir() { + mDebug("start to create mnode at %s", tsMnodeDir); + if (!taosMkDir(tsSdb.currDir)) { terrno = TAOS_SYSTEM_ERROR(errno); mError("failed to create dir:%s since %s", tsSdb.currDir, terrstr()); @@ -41,6 +42,8 @@ static int32_t sdbCreateDir() { } static int32_t sdbRunDeployFp() { + mDebug("start to run deploy functions"); + for (int32_t i = SDB_START; i < SDB_MAX; ++i) { SdbDeployFp fp = tsSdb.deployFps[i]; if (fp == NULL) continue; @@ -58,25 +61,26 @@ static int32_t sdbWriteVersion(FileFd fd) { return 0; } static int32_t sdbReadVersion(FileFd fd) { return 0; } static int32_t sdbReadDataFile() { - int32_t code = 0; - SSdbRaw *pRaw = malloc(SDB_MAX_SIZE); if (pRaw == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + terrno = TSDB_CODE_OUT_OF_MEMORY; + return -1; } char file[PATH_MAX] = {0}; snprintf(file, sizeof(file), "%ssdb.data", tsSdb.currDir); FileFd fd = taosOpenFileCreateWrite(file); if (fd <= 0) { - code = TAOS_SYSTEM_ERROR(errno); - mError("failed to open file:%s for read since %s", file, tstrerror(code)); - return code; + terrno = TAOS_SYSTEM_ERROR(errno); + mError("failed to open file:%s for read since %s", file, terrstr()); + return -1; } int64_t offset = 0; + int32_t code = 0; + while (1) { - int32_t ret = (int32_t)taosReadFile(fd, pRaw, sizeof(SSdbRaw)); + int64_t ret = taosReadFile(fd, pRaw, sizeof(SSdbRaw)); if (ret == 0) break; if (ret < 0) { @@ -93,7 +97,7 @@ static int32_t sdbReadDataFile() { code = sdbWrite(pRaw); if (code != 0) { - mError("failed to read file:%s since %s", file, tstrerror(code)); + mError("failed to read file:%s since %s", file, terrstr()); goto PARSE_SDB_DATA_ERROR; } } @@ -102,32 +106,35 @@ static int32_t sdbReadDataFile() { PARSE_SDB_DATA_ERROR: taosCloseFile(fd); + terrno = code; return code; } static int32_t sdbWriteDataFile() { - int32_t code = 0; - char tmpfile[PATH_MAX] = {0}; snprintf(tmpfile, sizeof(tmpfile), "%ssdb.data", tsSdb.tmpDir); FileFd fd = taosOpenFileCreateWrite(tmpfile); if (fd <= 0) { - code = TAOS_SYSTEM_ERROR(errno); - mError("failed to open file:%s for write since %s", tmpfile, tstrerror(code)); - return code; + terrno = TAOS_SYSTEM_ERROR(errno); + mError("failed to open file:%s for write since %s", tmpfile, terrstr()); + return -1; } - for (int32_t i = SDB_MAX - 1; i > SDB_START; --i) { - SHashObj *hash = tsSdb.hashObjs[i]; - if (!hash) continue; + int32_t code = 0; + for (int32_t i = SDB_MAX - 1; i > SDB_START; --i) { SdbEncodeFp encodeFp = tsSdb.encodeFps[i]; - if (!encodeFp) continue; + if (encodeFp == NULL) continue; + + SHashObj *hash = tsSdb.hashObjs[i]; + SRWLatch *pLock = &tsSdb.locks[i]; + taosWLockLatch(pLock); SSdbRow *pRow = taosHashIterate(hash, NULL); while (pRow != NULL) { - if (pRow->status == SDB_STATUS_READY) continue; + if (pRow->status != SDB_STATUS_READY) continue; + SSdbRaw *pRaw = (*encodeFp)(pRow->pObj); if (pRaw != NULL) { taosWriteFile(fd, pRaw, sizeof(SSdbRaw) + pRaw->dataLen); @@ -139,6 +146,7 @@ static int32_t sdbWriteDataFile() { pRow = taosHashIterate(hash, pRow); } + taosWUnLockLatch(pLock); } if (code == 0) { @@ -151,41 +159,40 @@ static int32_t sdbWriteDataFile() { code = taosFsyncFile(fd); } - if (code != 0) { + if (code == 0) { char curfile[PATH_MAX] = {0}; snprintf(curfile, sizeof(curfile), "%ssdb.data", tsSdb.currDir); code = taosRenameFile(tmpfile, curfile); } if (code != 0) { - mError("failed to write sdb file since %s", tstrerror(code)); + terrno = code; + mError("failed to write sdb file since %s", terrstr()); } else { - mInfo("write sdb file successfully"); + mDebug("write sdb file successfully"); } return code; } int32_t sdbRead() { - int32_t code = sdbReadDataFile(); - if (code != 0) { - return code; - } + mDebug("start to read mnode file"); - mInfo("read sdb file successfully"); - return -1; -} - -int32_t sdbCommit() { - int32_t code = sdbWriteDataFile(); - if (code != 0) { - return code; + if (sdbReadDataFile() != 0) { + return -1; } return 0; } +int32_t sdbCommit() { + mDebug("start to commit mnode file"); + return sdbWriteDataFile(); +} + int32_t sdbDeploy() { + mDebug("start to deploy mnode"); + if (sdbCreateDir() != 0) { return -1; } @@ -201,4 +208,7 @@ int32_t sdbDeploy() { return 0; } -void sdbUnDeploy() {} +void sdbUnDeploy() { + mDebug("start to undeploy mnode"); + taosRemoveDir(tsMnodeDir); +} diff --git a/source/dnode/mnode/sdb/src/sdbHash.c b/source/dnode/mnode/sdb/src/sdbHash.c index dcadfdc4bc..7b1a68bba2 100644 --- a/source/dnode/mnode/sdb/src/sdbHash.c +++ b/source/dnode/mnode/sdb/src/sdbHash.c @@ -32,25 +32,49 @@ static SHashObj *sdbGetHash(int32_t sdb) { return hash; } +static int32_t sdbGetkeySize(ESdbType sdb, void *pKey) { + int32_t keySize; + EKeyType keyType = tsSdb.keyTypes[sdb]; + + if (keyType == SDB_KEY_INT32) { + keySize = sizeof(int32_t); + } else if (keyType == SDB_KEY_BINARY) { + keySize = strlen(pKey) + 1; + } else { + keySize = sizeof(int64_t); + } + + return keySize; +} + static int32_t sdbInsertRow(SHashObj *hash, SSdbRaw *pRaw, SSdbRow *pRow, int32_t keySize) { - SSdbRow *pDstRow = NULL; + SRWLatch *pLock = &tsSdb.locks[pRow->sdb]; + taosWLockLatch(pLock); + + SSdbRow *pDstRow = taosHashGet(hash, pRow->pObj, keySize); if (pDstRow != NULL) { terrno = TSDB_CODE_SDB_OBJ_ALREADY_THERE; + taosWUnLockLatch(pLock); return -1; } - pRow->refCount = 0; + pRow->refCount = 1; pRow->status = pRaw->status; if (taosHashPut(hash, pRow->pObj, keySize, &pRow, sizeof(void *)) != 0) { terrno = TSDB_CODE_OUT_OF_MEMORY; + taosWUnLockLatch(pLock); return -1; } - SdbInsertFp insertFp = tsSdb.insertFps[pRaw->sdb]; + taosWUnLockLatch(pLock); + + SdbInsertFp insertFp = tsSdb.insertFps[pRow->sdb]; if (insertFp != NULL) { if ((*insertFp)(pRow->pObj) != 0) { + taosWLockLatch(pLock); taosHashRemove(hash, pRow->pObj, keySize); + taosWUnLockLatch(pLock); return -1; } } @@ -59,13 +83,20 @@ static int32_t sdbInsertRow(SHashObj *hash, SSdbRaw *pRaw, SSdbRow *pRow, int32_ } static int32_t sdbUpdateRow(SHashObj *hash, SSdbRaw *pRaw, SSdbRow *pRow, int32_t keySize) { - SSdbRow *pDstRow = NULL; + SRWLatch *pLock = &tsSdb.locks[pRow->sdb]; + taosRLockLatch(pLock); + + SSdbRow *pDstRow = taosHashGet(hash, pRow->pObj, keySize); if (pDstRow == NULL) { terrno = TSDB_CODE_SDB_OBJ_NOT_THERE; + taosRUnLockLatch(pLock); return -1; } - SdbUpdateFp updateFp = tsSdb.updateFps[pRaw->sdb]; + pRow->status = pRaw->status; + taosRUnLockLatch(pLock); + + SdbUpdateFp updateFp = tsSdb.updateFps[pRow->sdb]; if (updateFp != NULL) { if ((*updateFp)(pRow->pObj, pDstRow->pObj) != 0) { return -1; @@ -76,20 +107,28 @@ static int32_t sdbUpdateRow(SHashObj *hash, SSdbRaw *pRaw, SSdbRow *pRow, int32_ } static int32_t sdbDeleteRow(SHashObj *hash, SSdbRaw *pRaw, SSdbRow *pRow, int32_t keySize) { - SSdbRow *pDstRow = NULL; + SRWLatch *pLock = &tsSdb.locks[pRow->sdb]; + taosWLockLatch(pLock); + + SSdbRow *pDstRow = taosHashGet(hash, pRow->pObj, keySize); if (pDstRow == NULL) { terrno = TSDB_CODE_SDB_OBJ_NOT_THERE; + taosWUnLockLatch(pLock); return -1; } - SdbDeleteFp deleteFp = tsSdb.deleteFps[pRaw->sdb]; + pRow->status = pRaw->status; + taosHashRemove(hash, pRow->pObj, keySize); + taosWUnLockLatch(pLock); + + SdbDeleteFp deleteFp = tsSdb.deleteFps[pRow->sdb]; if (deleteFp != NULL) { if ((*deleteFp)(pRow->pObj) != 0) { return -1; } } - taosHashRemove(hash, pRow->pObj, keySize); + sdbRelease(pRow->pObj); return 0; } @@ -104,73 +143,87 @@ int32_t sdbWrite(SSdbRaw *pRaw) { return -1; } - int32_t keySize; - EKeyType keyType = tsSdb.keyTypes[pRaw->sdb]; - if (keyType == SDB_KEY_INT32) { - keySize = sizeof(int32_t); - } else if (keyType == SDB_KEY_BINARY) { - keySize = strlen(pRow->pObj) + 1; - } else { - keySize = sizeof(int64_t); - } + pRow->sdb = pRaw->sdb; + int32_t keySize = sdbGetkeySize(pRow->sdb, pRow->pObj); int32_t code = -1; - if (pRaw->action == SDB_ACTION_INSERT) { - code = sdbInsertRow(hash, pRaw, pRow, keySize); - } else if (pRaw->action == SDB_ACTION_UPDATE) { - code = sdbUpdateRow(hash, pRaw, pRow, keySize); - } else if (pRaw->action == SDB_ACTION_DELETE) { - code = sdbDeleteRow(hash, pRaw, pRow, keySize); - } else { - terrno = TSDB_CODE_SDB_INVALID_ACTION_TYPE; + + switch (pRaw->status) { + case SDB_STATUS_CREATING: + code = sdbInsertRow(hash, pRaw, pRow, keySize); + break; + case SDB_STATUS_READY: + case SDB_STATUS_DROPPING: + code = sdbUpdateRow(hash, pRaw, pRow, keySize); + break; + case SDB_STATUS_DROPPED: + code = sdbDeleteRow(hash, pRaw, pRow, keySize); + break; + default: + terrno = TSDB_CODE_SDB_INVALID_ACTION_TYPE; + break; } if (code != 0) { sdbFreeRow(pRow); } + return 0; } void *sdbAcquire(ESdbType sdb, void *pKey) { - terrno = 0; - SHashObj *hash = sdbGetHash(sdb); - if (hash == NULL) { + if (hash == NULL) return NULL; + + void *pRet = NULL; + int32_t keySize = sdbGetkeySize(sdb, pKey); + + SRWLatch *pLock = &tsSdb.locks[sdb]; + taosRLockLatch(pLock); + + SSdbRow **ppRow = taosHashGet(hash, pKey, keySize); + if (ppRow == NULL || *ppRow) { + terrno = TSDB_CODE_SDB_OBJ_NOT_THERE; + taosRUnLockLatch(pLock); return NULL; } - int32_t keySize; - EKeyType keyType = tsSdb.keyTypes[sdb]; - - switch (keyType) { - case SDB_KEY_INT32: - keySize = sizeof(int32_t); + SSdbRow *pRow = *ppRow; + switch (pRow->status) { + case SDB_STATUS_READY: + atomic_add_fetch_32(&pRow->refCount, 1); + pRet = pRow->pObj; break; - case SDB_KEY_INT64: - keySize = sizeof(int64_t); + case SDB_STATUS_CREATING: + terrno = TSDB_CODE_SDB_OBJ_CREATING; break; - case SDB_KEY_BINARY: - keySize = strlen(pKey) + 1; + case SDB_STATUS_DROPPING: + terrno = TSDB_CODE_SDB_OBJ_DROPPING; break; default: - keySize = sizeof(int32_t); + terrno = TSDB_CODE_SDB_APP_ERROR; + break; } - SSdbRow *pRow = taosHashGet(hash, pKey, keySize); - if (pRow == NULL) return NULL; - - if (pRow->status == SDB_STATUS_READY) { - atomic_add_fetch_32(&pRow->refCount, 1); - return pRow->pObj; - } else { - terrno = -1; // todo - return NULL; - } + taosRUnLockLatch(pLock); + return pRet; } void sdbRelease(void *pObj) { + if (pObj == NULL) return; + SSdbRow *pRow = (SSdbRow *)((char *)pObj - sizeof(SSdbRow)); - atomic_sub_fetch_32(&pRow->refCount, 1); + if (pRow->sdb >= SDB_MAX || pRow->sdb <= SDB_START) return; + + SRWLatch *pLock = &tsSdb.locks[pRow->sdb]; + taosRLockLatch(pLock); + + int32_t ref = atomic_sub_fetch_32(&pRow->refCount, 1); + if (ref <= 0 && pRow->status == SDB_STATUS_DROPPED) { + sdbFreeRow(pRow); + } + + taosRUnLockLatch(pLock); } void *sdbFetchRow(ESdbType sdb, void *pIter) { @@ -179,7 +232,12 @@ void *sdbFetchRow(ESdbType sdb, void *pIter) { return NULL; } - return taosHashIterate(hash, pIter); + SRWLatch *pLock = &tsSdb.locks[sdb]; + taosRLockLatch(pLock); + void *pRet = taosHashIterate(hash, pIter); + taosRUnLockLatch(pLock); + + return pRet; } void sdbCancelFetch(ESdbType sdb, void *pIter) { @@ -187,7 +245,11 @@ void sdbCancelFetch(ESdbType sdb, void *pIter) { if (hash == NULL) { return; } + + SRWLatch *pLock = &tsSdb.locks[sdb]; + taosRLockLatch(pLock); taosHashCancelIterate(hash, pIter); + taosRUnLockLatch(pLock); } int32_t sdbGetSize(ESdbType sdb) { @@ -195,5 +257,11 @@ int32_t sdbGetSize(ESdbType sdb) { if (hash == NULL) { return 0; } - return taosHashGetSize(hash); + + SRWLatch *pLock = &tsSdb.locks[sdb]; + taosRLockLatch(pLock); + int32_t size = taosHashGetSize(hash); + taosRUnLockLatch(pLock); + + return size; } diff --git a/source/dnode/mnode/sdb/src/sdbRaw.c b/source/dnode/mnode/sdb/src/sdbRaw.c index 8c550394ed..68a0abc859 100644 --- a/source/dnode/mnode/sdb/src/sdbRaw.c +++ b/source/dnode/mnode/sdb/src/sdbRaw.c @@ -116,16 +116,6 @@ int32_t sdbSetRawStatus(SSdbRaw *pRaw, ESdbStatus status) { return 0; } -int32_t sdbSetRawAction(SSdbRaw *pRaw, ESdbAction action) { - if (pRaw == NULL) { - terrno = TSDB_CODE_INVALID_PTR; - return -1; - } - - pRaw->action = action; - return 0; -} - int32_t sdbGetRawInt8(SSdbRaw *pRaw, int32_t dataPos, int8_t *val) { if (pRaw == NULL) { terrno = TSDB_CODE_INVALID_PTR; diff --git a/source/util/src/terror.c b/source/util/src/terror.c index d6f2f78d8e..0abfc89725 100644 --- a/source/util/src/terror.c +++ b/source/util/src/terror.c @@ -147,6 +147,8 @@ TAOS_DEFINE_ERROR(TSDB_CODE_MND_FAILED_TO_INIT_STEP, "failed to init compon TAOS_DEFINE_ERROR(TSDB_CODE_SDB_APP_ERROR, "Unexpected generic error in sdb") TAOS_DEFINE_ERROR(TSDB_CODE_SDB_OBJ_ALREADY_THERE, "Object already there") TAOS_DEFINE_ERROR(TSDB_CODE_SDB_OBJ_NOT_THERE, "Object not there") +TAOS_DEFINE_ERROR(TSDB_CODE_SDB_OBJ_CREATING, "Object is creating") +TAOS_DEFINE_ERROR(TSDB_CODE_SDB_OBJ_DROPPING, "Object is dropping") TAOS_DEFINE_ERROR(TSDB_CODE_SDB_INVALID_TABLE_TYPE, "Invalid table type") TAOS_DEFINE_ERROR(TSDB_CODE_SDB_INVALID_KEY_TYPE, "Invalid key type") TAOS_DEFINE_ERROR(TSDB_CODE_SDB_INVALID_ACTION_TYPE, "Invalid action type")