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

enh: return error code

This commit is contained in:
kailixu 2024-07-19 18:10:43 +08:00
parent 41198c554b
commit b2c60945d7
7 changed files with 184 additions and 163 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
include/util/tutil.h
View File

@ -172,18 +172,6 @@ static FORCE_INLINE int32_t taosGetTbHashVal(const char *tbname, int32_t tblen,
} \ } \
} while (0) } while (0)
#define TAOS_CHECK_EXEC_GOTO(CMD, LINO, EXEC, LABEL) \
do { \
code = (CMD); \
if (code != TSDB_CODE_SUCCESS) { \
if (LINO) { \
*((int32_t *)(LINO)) = __LINE__; \
} \
(EXEC); \
goto LABEL; \
} \
} while (0)
#define TAOS_UNUSED(expr) (void)(expr) #define TAOS_UNUSED(expr) (void)(expr)
#ifdef __cplusplus #ifdef __cplusplus

28
source/dnode/mnode/impl/inc/mndUser.h
View File

@ -27,22 +27,22 @@ enum {
IP_WHITE_ADD, IP_WHITE_ADD,
IP_WHITE_DROP, IP_WHITE_DROP,
}; };
int32_t mndInitUser(SMnode *pMnode); int32_t mndInitUser(SMnode *pMnode);
void mndCleanupUser(SMnode *pMnode); void mndCleanupUser(SMnode *pMnode);
int32_t mndAcquireUser(SMnode *pMnode, const char *userName, SUserObj **ppUser); int32_t mndAcquireUser(SMnode *pMnode, const char *userName, SUserObj **ppUser);
void mndReleaseUser(SMnode *pMnode, SUserObj *pUser); void mndReleaseUser(SMnode *pMnode, SUserObj *pUser);
// for trans test // for trans test
SSdbRaw *mndUserActionEncode(SUserObj *pUser); SSdbRaw *mndUserActionEncode(SUserObj *pUser);
int32_t mndDupDbHash(SHashObj *pOld, SHashObj **ppNew); int32_t mndDupDbHash(SHashObj *pOld, SHashObj **ppNew);
int32_t mndDupTableHash(SHashObj *pOld, SHashObj **ppNew); int32_t mndDupTableHash(SHashObj *pOld, SHashObj **ppNew);
int32_t mndDupTopicHash(SHashObj *pOld, SHashObj **ppNew); int32_t mndDupTopicHash(SHashObj *pOld, SHashObj **ppNew);
int32_t mndValidateUserAuthInfo(SMnode *pMnode, SUserAuthVersion *pUsers, int32_t numOfUses, void **ppRsp, int32_t mndValidateUserAuthInfo(SMnode *pMnode, SUserAuthVersion *pUsers, int32_t numOfUses, void **ppRsp,
int32_t *pRspLen, int64_t ipWhiteListVer); int32_t *pRspLen, int64_t ipWhiteListVer);
int32_t mndUserRemoveDb(SMnode *pMnode, STrans *pTrans, char *db); int32_t mndUserRemoveDb(SMnode *pMnode, STrans *pTrans, char *db);
int32_t mndUserRemoveStb(SMnode *pMnode, STrans *pTrans, char *stb); int32_t mndUserRemoveStb(SMnode *pMnode, STrans *pTrans, char *stb);
int32_t mndUserRemoveView(SMnode *pMnode, STrans *pTrans, char *view); int32_t mndUserRemoveView(SMnode *pMnode, STrans *pTrans, char *view);
int32_t mndUserRemoveTopic(SMnode *pMnode, STrans *pTrans, char *topic); int32_t mndUserRemoveTopic(SMnode *pMnode, STrans *pTrans, char *topic);
int32_t mndUserDupObj(SUserObj *pUser, SUserObj *pNew); int32_t mndUserDupObj(SUserObj *pUser, SUserObj *pNew);
void mndUserFreeObj(SUserObj *pUser); void mndUserFreeObj(SUserObj *pUser);

169
source/dnode/mnode/impl/src/mndUser.c
View File

@ -95,11 +95,11 @@
#define ALTER_USER_DEL_SUBSCRIBE_TOPIC_PRIV(_type, _priv) \ #define ALTER_USER_DEL_SUBSCRIBE_TOPIC_PRIV(_type, _priv) \
(ALTER_USER_DEL_PRIVS(_type) && ALTER_USER_SUBSCRIBE_PRIV(_priv)) (ALTER_USER_DEL_PRIVS(_type) && ALTER_USER_SUBSCRIBE_PRIV(_priv))
static SIpWhiteList *createDefaultIpWhiteList(); static int32_t createDefaultIpWhiteList(SIpWhiteList **ppWhiteList);
SIpWhiteList *createIpWhiteList(void *buf, int32_t len); SIpWhiteList *createIpWhiteList(void *buf, int32_t len);
static bool updateIpWhiteList(SIpWhiteList *pOld, SIpWhiteList *pNew); static bool updateIpWhiteList(SIpWhiteList *pOld, SIpWhiteList *pNew);
static bool isIpWhiteListEqual(SIpWhiteList *a, SIpWhiteList *b); static bool isIpWhiteListEqual(SIpWhiteList *a, SIpWhiteList *b);
static bool isIpRangeEqual(SIpV4Range *a, SIpV4Range *b); static bool isIpRangeEqual(SIpV4Range *a, SIpV4Range *b);
void destroyIpWhiteTab(SHashObj *pIpWhiteTab); void destroyIpWhiteTab(SHashObj *pIpWhiteTab);
@ -645,20 +645,24 @@ SIpWhiteList *createIpWhiteList(void *buf, int32_t len) {
return p; return p;
} }
static SIpWhiteList *createDefaultIpWhiteList() { static int32_t createDefaultIpWhiteList(SIpWhiteList **ppWhiteList) {
SIpWhiteList *pWhiteList = taosMemoryCalloc(1, sizeof(SIpWhiteList) + sizeof(SIpV4Range) * 1); *ppWhiteList = taosMemoryCalloc(1, sizeof(SIpWhiteList) + sizeof(SIpV4Range) * 1);
pWhiteList->num = 1; if (*ppWhiteList == NULL) {
SIpV4Range *range = &(pWhiteList->pIpRange[0]); return TSDB_CODE_OUT_OF_MEMORY;
}
(*ppWhiteList)->num = 1;
SIpV4Range *range = &((*ppWhiteList)->pIpRange[0]);
struct in_addr addr; struct in_addr addr;
if (uv_inet_pton(AF_INET, "127.0.0.1", &addr) == 0) { if (uv_inet_pton(AF_INET, "127.0.0.1", &addr) == 0) {
range->ip = addr.s_addr; range->ip = addr.s_addr;
range->mask = 32; range->mask = 32;
} }
return pWhiteList; return 0;
} }
static int32_t mndCreateDefaultUser(SMnode *pMnode, char *acct, char *user, char *pass) { static int32_t mndCreateDefaultUser(SMnode *pMnode, char *acct, char *user, char *pass) {
int32_t code = 0;
SUserObj userObj = {0}; SUserObj userObj = {0};
taosEncryptPass_c((uint8_t *)pass, strlen(pass), userObj.pass); taosEncryptPass_c((uint8_t *)pass, strlen(pass), userObj.pass);
tstrncpy(userObj.user, user, TSDB_USER_LEN); tstrncpy(userObj.user, user, TSDB_USER_LEN);
@ -668,7 +672,7 @@ static int32_t mndCreateDefaultUser(SMnode *pMnode, char *acct, char *user, char
userObj.sysInfo = 1; userObj.sysInfo = 1;
userObj.enable = 1; userObj.enable = 1;
userObj.ipWhiteListVer = taosGetTimestampMs(); userObj.ipWhiteListVer = taosGetTimestampMs();
userObj.pIpWhiteList = createDefaultIpWhiteList(); TAOS_CHECK_RETURN(createDefaultIpWhiteList(&userObj.pIpWhiteList));
if (strcmp(user, TSDB_DEFAULT_USER) == 0) { if (strcmp(user, TSDB_DEFAULT_USER) == 0) {
userObj.superUser = 1; userObj.superUser = 1;
userObj.createdb = 1; userObj.createdb = 1;
@ -830,7 +834,10 @@ SSdbRaw *mndUserActionEncode(SUserObj *pUser) {
} }
SSdbRaw *pRaw = sdbAllocRaw(SDB_USER, USER_VER_NUMBER, size); SSdbRaw *pRaw = sdbAllocRaw(SDB_USER, USER_VER_NUMBER, size);
if (pRaw == NULL) goto _OVER; if (pRaw == NULL) {
terrno = TSDB_CODE_OUT_OF_MEMORY;
goto _OVER;
}
int32_t dataPos = 0; int32_t dataPos = 0;
SDB_SET_BINARY(pRaw, dataPos, pUser->user, TSDB_USER_LEN, _OVER) SDB_SET_BINARY(pRaw, dataPos, pUser->user, TSDB_USER_LEN, _OVER)
@ -973,6 +980,10 @@ SSdbRaw *mndUserActionEncode(SUserObj *pUser) {
int32_t num = pUser->pIpWhiteList->num; int32_t num = pUser->pIpWhiteList->num;
int32_t tlen = sizeof(SIpWhiteList) + num * sizeof(SIpV4Range) + 4; int32_t tlen = sizeof(SIpWhiteList) + num * sizeof(SIpV4Range) + 4;
char *buf = taosMemoryCalloc(1, tlen); char *buf = taosMemoryCalloc(1, tlen);
if (buf == NULL) {
terrno = TSDB_CODE_OUT_OF_MEMORY;
goto _OVER;
}
int32_t len = tSerializeIpWhiteList(buf, tlen, pUser->pIpWhiteList); int32_t len = tSerializeIpWhiteList(buf, tlen, pUser->pIpWhiteList);
SDB_SET_INT32(pRaw, dataPos, len, _OVER); SDB_SET_INT32(pRaw, dataPos, len, _OVER);
@ -1306,12 +1317,11 @@ static int32_t mndUserActionInsert(SSdb *pSdb, SUserObj *pUser) {
} }
int32_t mndDupTableHash(SHashObj *pOld, SHashObj **ppNew) { int32_t mndDupTableHash(SHashObj *pOld, SHashObj **ppNew) {
int32_t code = 0;
*ppNew = *ppNew =
taosHashInit(taosHashGetSize(pOld), taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK); taosHashInit(taosHashGetSize(pOld), taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
if (*ppNew == NULL) { if (*ppNew == NULL) {
terrno = TSDB_CODE_OUT_OF_MEMORY; TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
return NULL;
TAOS_CHECK_RETURN(NULL);
} }
char *tb = taosHashIterate(pOld, NULL); char *tb = taosHashIterate(pOld, NULL);
@ -1320,24 +1330,24 @@ int32_t mndDupTableHash(SHashObj *pOld, SHashObj **ppNew) {
char *key = taosHashGetKey(tb, &keyLen); char *key = taosHashGetKey(tb, &keyLen);
int32_t valueLen = strlen(tb) + 1; int32_t valueLen = strlen(tb) + 1;
if (taosHashPut(pNew, key, keyLen, tb, valueLen) != 0) { if ((code = taosHashPut(*ppNew, key, keyLen, tb, valueLen)) != 0) {
taosHashCancelIterate(pOld, tb); taosHashCancelIterate(pOld, tb);
taosHashCleanup(pNew); taosHashCleanup(*ppNew);
terrno = TSDB_CODE_OUT_OF_MEMORY; code = terrno ? terrno : TSDB_CODE_OUT_OF_MEMORY; // TODO: remove this line after terrno is removed
return NULL; TAOS_RETURN(code);
} }
tb = taosHashIterate(pOld, tb); tb = taosHashIterate(pOld, tb);
} }
return pNew; TAOS_RETURN(code);
} }
SHashObj *mndDupUseDbHash(SHashObj *pOld) { int32_t mndDupUseDbHash(SHashObj *pOld, SHashObj **ppNew) {
SHashObj *pNew = int32_t code = 0;
*ppNew =
taosHashInit(taosHashGetSize(pOld), taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK); taosHashInit(taosHashGetSize(pOld), taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
if (pNew == NULL) { if (*ppNew == NULL) {
terrno = TSDB_CODE_OUT_OF_MEMORY; TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
return NULL;
} }
int32_t *db = taosHashIterate(pOld, NULL); int32_t *db = taosHashIterate(pOld, NULL);
@ -1345,42 +1355,43 @@ SHashObj *mndDupUseDbHash(SHashObj *pOld) {
size_t keyLen = 0; size_t keyLen = 0;
char *key = taosHashGetKey(db, &keyLen); char *key = taosHashGetKey(db, &keyLen);
if (taosHashPut(pNew, key, keyLen, db, sizeof(*db)) != 0) { if ((code = taosHashPut(*ppNew, key, keyLen, db, sizeof(*db))) != 0) {
taosHashCancelIterate(pOld, db); taosHashCancelIterate(pOld, db);
taosHashCleanup(pNew); taosHashCleanup(*ppNew);
terrno = TSDB_CODE_OUT_OF_MEMORY; code = terrno ? terrno : TSDB_CODE_OUT_OF_MEMORY; // TODO: remove this line after terrno is removed
return NULL; TAOS_RETURN(code);
} }
db = taosHashIterate(pOld, db); db = taosHashIterate(pOld, db);
} }
return pNew; TAOS_RETURN(code);
} }
int32_t mndUserDupObj(SUserObj *pUser, SUserObj *pNew) { int32_t mndUserDupObj(SUserObj *pUser, SUserObj *pNew) {
int32_t code = 0;
memcpy(pNew, pUser, sizeof(SUserObj)); memcpy(pNew, pUser, sizeof(SUserObj));
pNew->authVersion++; pNew->authVersion++;
pNew->updateTime = taosGetTimestampMs(); pNew->updateTime = taosGetTimestampMs();
taosRLockLatch(&pUser->lock); taosRLockLatch(&pUser->lock);
pNew->readDbs = mndDupDbHash(pUser->readDbs); TAOS_CHECK_GOTO(mndDupDbHash(pUser->readDbs, &pNew->readDbs), NULL, _OVER);
pNew->writeDbs = mndDupDbHash(pUser->writeDbs); TAOS_CHECK_GOTO(mndDupDbHash(pUser->writeDbs, &pNew->writeDbs), NULL, _OVER);
pNew->readTbs = mndDupTableHash(pUser->readTbs); TAOS_CHECK_GOTO(mndDupTableHash(pUser->readTbs, &pNew->readTbs), NULL, _OVER);
pNew->writeTbs = mndDupTableHash(pUser->writeTbs); TAOS_CHECK_GOTO(mndDupTableHash(pUser->writeTbs, &pNew->writeTbs), NULL, _OVER);
pNew->alterTbs = mndDupTableHash(pUser->alterTbs); TAOS_CHECK_GOTO(mndDupTableHash(pUser->alterTbs, &pNew->alterTbs), NULL, _OVER);
pNew->readViews = mndDupTableHash(pUser->readViews); TAOS_CHECK_GOTO(mndDupTableHash(pUser->readViews, &pNew->readViews), NULL, _OVER);
pNew->writeViews = mndDupTableHash(pUser->writeViews); TAOS_CHECK_GOTO(mndDupTableHash(pUser->writeViews, &pNew->writeViews), NULL, _OVER);
pNew->alterViews = mndDupTableHash(pUser->alterViews); TAOS_CHECK_GOTO(mndDupTableHash(pUser->alterViews, &pNew->alterViews), NULL, _OVER);
pNew->topics = mndDupTopicHash(pUser->topics); TAOS_CHECK_GOTO(mndDupTopicHash(pUser->topics, &pNew->topics), NULL, _OVER);
pNew->useDbs = mndDupUseDbHash(pUser->useDbs); TAOS_CHECK_GOTO(mndDupUseDbHash(pUser->useDbs, &pNew->useDbs), NULL, _OVER);
pNew->pIpWhiteList = cloneIpWhiteList(pUser->pIpWhiteList); pNew->pIpWhiteList = cloneIpWhiteList(pUser->pIpWhiteList);
if (pNew->pIpWhiteList == NULL) {
taosRUnLockLatch(&pUser->lock); code = TSDB_CODE_OUT_OF_MEMORY;
if (pNew->readDbs == NULL || pNew->writeDbs == NULL || pNew->topics == NULL) {
return -1;
} }
return 0;
_OVER:
taosRUnLockLatch(&pUser->lock);
TAOS_RETURN(code);
} }
void mndUserFreeObj(SUserObj *pUser) { void mndUserFreeObj(SUserObj *pUser) {
@ -1436,6 +1447,10 @@ static int32_t mndUserActionUpdate(SSdb *pSdb, SUserObj *pOld, SUserObj *pNew) {
int32_t sz = sizeof(SIpWhiteList) + pNew->pIpWhiteList->num * sizeof(SIpV4Range); int32_t sz = sizeof(SIpWhiteList) + pNew->pIpWhiteList->num * sizeof(SIpV4Range);
pOld->pIpWhiteList = taosMemoryRealloc(pOld->pIpWhiteList, sz); pOld->pIpWhiteList = taosMemoryRealloc(pOld->pIpWhiteList, sz);
if (pOld->pIpWhiteList == NULL) {
taosWUnLockLatch(&pOld->lock);
return TSDB_CODE_OUT_OF_MEMORY;
}
memcpy(pOld->pIpWhiteList, pNew->pIpWhiteList, sz); memcpy(pOld->pIpWhiteList, pNew->pIpWhiteList, sz);
pOld->ipWhiteListVer = pNew->ipWhiteListVer; pOld->ipWhiteListVer = pNew->ipWhiteListVer;
@ -1464,6 +1479,7 @@ void mndReleaseUser(SMnode *pMnode, SUserObj *pUser) {
} }
static int32_t mndCreateUser(SMnode *pMnode, char *acct, SCreateUserReq *pCreate, SRpcMsg *pReq) { static int32_t mndCreateUser(SMnode *pMnode, char *acct, SCreateUserReq *pCreate, SRpcMsg *pReq) {
int32_t code = 0;
SUserObj userObj = {0}; SUserObj userObj = {0};
if (pCreate->isImport != 1) { if (pCreate->isImport != 1) {
taosEncryptPass_c((uint8_t *)pCreate->pass, strlen(pCreate->pass), userObj.pass); taosEncryptPass_c((uint8_t *)pCreate->pass, strlen(pCreate->pass), userObj.pass);
@ -1481,14 +1497,16 @@ static int32_t mndCreateUser(SMnode *pMnode, char *acct, SCreateUserReq *pCreate
userObj.createdb = pCreate->createDb; userObj.createdb = pCreate->createDb;
if (pCreate->numIpRanges == 0) { if (pCreate->numIpRanges == 0) {
userObj.pIpWhiteList = createDefaultIpWhiteList(); TAOS_CHECK_RETURN(createDefaultIpWhiteList(&userObj.pIpWhiteList));
} else { } else {
SHashObj *pUniqueTab = taosHashInit(64, MurmurHash3_32, false, HASH_NO_LOCK); SHashObj *pUniqueTab = taosHashInit(64, MurmurHash3_32, false, HASH_NO_LOCK);
if(pUniqueTab == NULL){
TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
}
int32_t dummpy = 0; int32_t dummpy = 0;
for (int i = 0; i < pCreate->numIpRanges; i++) { for (int i = 0; i < pCreate->numIpRanges; i++) {
SIpV4Range range = {.ip = pCreate->pIpRanges[i].ip, .mask = pCreate->pIpRanges[i].mask}; SIpV4Range range = {.ip = pCreate->pIpRanges[i].ip, .mask = pCreate->pIpRanges[i].mask};
taosHashPut(pUniqueTab, &range, sizeof(range), &dummpy, sizeof(dummpy)); if(code = taosHashPut(pUniqueTab, &range, sizeof(range), &dummpy, sizeof(dummpy));
} }
taosHashPut(pUniqueTab, &defaultIpRange, sizeof(defaultIpRange), &dummpy, sizeof(dummpy)); taosHashPut(pUniqueTab, &defaultIpRange, sizeof(defaultIpRange), &dummpy, sizeof(dummpy));
@ -2575,6 +2593,7 @@ static void mndLoopHash(SHashObj *hash, char *priType, SSDataBlock *pBlock, int3
} }
static int32_t mndRetrievePrivileges(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) { static int32_t mndRetrievePrivileges(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) {
int32_t code = 0;
SMnode *pMnode = pReq->info.node; SMnode *pMnode = pReq->info.node;
SSdb *pSdb = pMnode->pSdb; SSdb *pSdb = pMnode->pSdb;
int32_t numOfRows = 0; int32_t numOfRows = 0;
@ -2806,15 +2825,15 @@ int32_t mndValidateUserAuthInfo(SMnode *pMnode, SUserAuthVersion *pUsers, int32_
SUserAuthBatchRsp batchRsp = {0}; SUserAuthBatchRsp batchRsp = {0};
batchRsp.pArray = taosArrayInit(numOfUses, sizeof(SGetUserAuthRsp)); batchRsp.pArray = taosArrayInit(numOfUses, sizeof(SGetUserAuthRsp));
if (batchRsp.pArray == NULL) { if (batchRsp.pArray == NULL) {
terrno = TSDB_CODE_OUT_OF_MEMORY; TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
return -1;
} }
int32_t code = 0; int32_t code = 0;
for (int32_t i = 0; i < numOfUses; ++i) { for (int32_t i = 0; i < numOfUses; ++i) {
SUserObj *pUser = mndAcquireUser(pMnode, pUsers[i].user); SUserObj *pUser = NULL;
code = mndAcquireUser(pMnode, pUsers[i].user, &pUser);
if (pUser == NULL) { if (pUser == NULL) {
if (TSDB_CODE_MND_USER_NOT_EXIST == terrno) { if (TSDB_CODE_MND_USER_NOT_EXIST == code) {
SGetUserAuthRsp rsp = {.dropped = 1}; SGetUserAuthRsp rsp = {.dropped = 1};
memcpy(rsp.user, pUsers[i].user, TSDB_USER_LEN); memcpy(rsp.user, pUsers[i].user, TSDB_USER_LEN);
taosArrayPush(batchRsp.pArray, &rsp); taosArrayPush(batchRsp.pArray, &rsp);
@ -2837,7 +2856,7 @@ int32_t mndValidateUserAuthInfo(SMnode *pMnode, SUserAuthVersion *pUsers, int32_
goto _OVER; goto _OVER;
} }
taosArrayPush(batchRsp.pArray, &rsp); (void)taosArrayPush(batchRsp.pArray, &rsp);
mndReleaseUser(pMnode, pUser); mndReleaseUser(pMnode, pUser);
} }
@ -2852,9 +2871,7 @@ int32_t mndValidateUserAuthInfo(SMnode *pMnode, SUserAuthVersion *pUsers, int32_
int32_t rspLen = tSerializeSUserAuthBatchRsp(NULL, 0, &batchRsp); int32_t rspLen = tSerializeSUserAuthBatchRsp(NULL, 0, &batchRsp);
void *pRsp = taosMemoryMalloc(rspLen); void *pRsp = taosMemoryMalloc(rspLen);
if (pRsp == NULL) { if (pRsp == NULL) {
terrno = TSDB_CODE_OUT_OF_MEMORY; TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, NULL, _OVER);
tFreeSUserAuthBatchRsp(&batchRsp);
return -1;
} }
tSerializeSUserAuthBatchRsp(pRsp, rspLen, &batchRsp); tSerializeSUserAuthBatchRsp(pRsp, rspLen, &batchRsp);
@ -2870,7 +2887,7 @@ _OVER:
*pRspLen = 0; *pRspLen = 0;
tFreeSUserAuthBatchRsp(&batchRsp); tFreeSUserAuthBatchRsp(&batchRsp);
return code; TAOS_RETURN(code);
} }
int32_t mndUserRemoveDb(SMnode *pMnode, STrans *pTrans, char *db) { int32_t mndUserRemoveDb(SMnode *pMnode, STrans *pTrans, char *db) {
@ -2885,8 +2902,7 @@ int32_t mndUserRemoveDb(SMnode *pMnode, STrans *pTrans, char *db) {
pIter = sdbFetch(pSdb, SDB_USER, pIter, (void **)&pUser); pIter = sdbFetch(pSdb, SDB_USER, pIter, (void **)&pUser);
if (pIter == NULL) break; if (pIter == NULL) break;
code = -1; if ((code = mndUserDupObj(pUser, &newUser)) != 0) {
if (mndUserDupObj(pUser, &newUser) != 0) {
break; break;
} }
@ -2897,7 +2913,8 @@ int32_t mndUserRemoveDb(SMnode *pMnode, STrans *pTrans, char *db) {
(void)taosHashRemove(newUser.writeDbs, db, len); (void)taosHashRemove(newUser.writeDbs, db, len);
SSdbRaw *pCommitRaw = mndUserActionEncode(&newUser); SSdbRaw *pCommitRaw = mndUserActionEncode(&newUser);
if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) { if (pCommitRaw == NULL || (code = mndTransAppendCommitlog(pTrans, pCommitRaw)) != 0) {
code = terrno ? terrno : TSDB_CODE_OUT_OF_MEMORY; // TODO: remove this line when terrno is removed
break; break;
} }
(void)sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY); (void)sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY);
@ -2905,13 +2922,12 @@ int32_t mndUserRemoveDb(SMnode *pMnode, STrans *pTrans, char *db) {
mndUserFreeObj(&newUser); mndUserFreeObj(&newUser);
sdbRelease(pSdb, pUser); sdbRelease(pSdb, pUser);
code = 0;
} }
if (pUser != NULL) sdbRelease(pSdb, pUser); if (pUser != NULL) sdbRelease(pSdb, pUser);
if (pIter != NULL) sdbCancelFetch(pSdb, pIter); if (pIter != NULL) sdbCancelFetch(pSdb, pIter);
mndUserFreeObj(&newUser); mndUserFreeObj(&newUser);
return code; TAOS_RETURN(code);
} }
int32_t mndUserRemoveStb(SMnode *pMnode, STrans *pTrans, char *stb) { int32_t mndUserRemoveStb(SMnode *pMnode, STrans *pTrans, char *stb) {
@ -2926,8 +2942,7 @@ int32_t mndUserRemoveStb(SMnode *pMnode, STrans *pTrans, char *stb) {
pIter = sdbFetch(pSdb, SDB_USER, pIter, (void **)&pUser); pIter = sdbFetch(pSdb, SDB_USER, pIter, (void **)&pUser);
if (pIter == NULL) break; if (pIter == NULL) break;
code = -1; if ((code = mndUserDupObj(pUser, &newUser)) != 0) {
if (mndUserDupObj(pUser, &newUser) != 0) {
break; break;
} }
@ -2940,7 +2955,8 @@ int32_t mndUserRemoveStb(SMnode *pMnode, STrans *pTrans, char *stb) {
(void)taosHashRemove(newUser.alterTbs, stb, len); (void)taosHashRemove(newUser.alterTbs, stb, len);
SSdbRaw *pCommitRaw = mndUserActionEncode(&newUser); SSdbRaw *pCommitRaw = mndUserActionEncode(&newUser);
if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) { if (pCommitRaw == NULL || (code = mndTransAppendCommitlog(pTrans, pCommitRaw)) != 0) {
code = terrno ? terrno : TSDB_CODE_OUT_OF_MEMORY; // TODO: remove this line when terrno is removed
break; break;
} }
(void)sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY); (void)sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY);
@ -2948,13 +2964,12 @@ int32_t mndUserRemoveStb(SMnode *pMnode, STrans *pTrans, char *stb) {
mndUserFreeObj(&newUser); mndUserFreeObj(&newUser);
sdbRelease(pSdb, pUser); sdbRelease(pSdb, pUser);
code = 0;
} }
if (pUser != NULL) sdbRelease(pSdb, pUser); if (pUser != NULL) sdbRelease(pSdb, pUser);
if (pIter != NULL) sdbCancelFetch(pSdb, pIter); if (pIter != NULL) sdbCancelFetch(pSdb, pIter);
mndUserFreeObj(&newUser); mndUserFreeObj(&newUser);
return code; TAOS_RETURN(code);
} }
int32_t mndUserRemoveView(SMnode *pMnode, STrans *pTrans, char *view) { int32_t mndUserRemoveView(SMnode *pMnode, STrans *pTrans, char *view) {
@ -2969,8 +2984,7 @@ int32_t mndUserRemoveView(SMnode *pMnode, STrans *pTrans, char *view) {
pIter = sdbFetch(pSdb, SDB_USER, pIter, (void **)&pUser); pIter = sdbFetch(pSdb, SDB_USER, pIter, (void **)&pUser);
if (pIter == NULL) break; if (pIter == NULL) break;
code = -1; if ((code = mndUserDupObj(pUser, &newUser)) != 0) {
if (mndUserDupObj(pUser, &newUser) != 0) {
break; break;
} }
@ -2983,7 +2997,8 @@ int32_t mndUserRemoveView(SMnode *pMnode, STrans *pTrans, char *view) {
(void)taosHashRemove(newUser.alterViews, view, len); (void)taosHashRemove(newUser.alterViews, view, len);
SSdbRaw *pCommitRaw = mndUserActionEncode(&newUser); SSdbRaw *pCommitRaw = mndUserActionEncode(&newUser);
if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) { if (pCommitRaw == NULL || (code = mndTransAppendCommitlog(pTrans, pCommitRaw)) != 0) {
code = terrno ? terrno : TSDB_CODE_OUT_OF_MEMORY; // TODO: remove this line when terrno is removed
break; break;
} }
(void)sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY); (void)sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY);
@ -2991,13 +3006,12 @@ int32_t mndUserRemoveView(SMnode *pMnode, STrans *pTrans, char *view) {
mndUserFreeObj(&newUser); mndUserFreeObj(&newUser);
sdbRelease(pSdb, pUser); sdbRelease(pSdb, pUser);
code = 0;
} }
if (pUser != NULL) sdbRelease(pSdb, pUser); if (pUser != NULL) sdbRelease(pSdb, pUser);
if (pIter != NULL) sdbCancelFetch(pSdb, pIter); if (pIter != NULL) sdbCancelFetch(pSdb, pIter);
mndUserFreeObj(&newUser); mndUserFreeObj(&newUser);
return code; TAOS_RETURN(code);
} }
int32_t mndUserRemoveTopic(SMnode *pMnode, STrans *pTrans, char *topic) { int32_t mndUserRemoveTopic(SMnode *pMnode, STrans *pTrans, char *topic) {
@ -3014,8 +3028,7 @@ int32_t mndUserRemoveTopic(SMnode *pMnode, STrans *pTrans, char *topic) {
break; break;
} }
code = -1; if ((code = mndUserDupObj(pUser, &newUser)) != 0) {
if (mndUserDupObj(pUser, &newUser) != 0) {
break; break;
} }
@ -3023,7 +3036,8 @@ int32_t mndUserRemoveTopic(SMnode *pMnode, STrans *pTrans, char *topic) {
if (inTopic) { if (inTopic) {
(void)taosHashRemove(newUser.topics, topic, len); (void)taosHashRemove(newUser.topics, topic, len);
SSdbRaw *pCommitRaw = mndUserActionEncode(&newUser); SSdbRaw *pCommitRaw = mndUserActionEncode(&newUser);
if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) { if (pCommitRaw == NULL || (code = mndTransAppendCommitlog(pTrans, pCommitRaw)) != 0) {
code = terrno ? terrno : TSDB_CODE_OUT_OF_MEMORY; // TODO: remove this line when terrno is removed
break; break;
} }
(void)sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY); (void)sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY);
@ -3031,13 +3045,12 @@ int32_t mndUserRemoveTopic(SMnode *pMnode, STrans *pTrans, char *topic) {
mndUserFreeObj(&newUser); mndUserFreeObj(&newUser);
sdbRelease(pSdb, pUser); sdbRelease(pSdb, pUser);
code = 0;
} }
if (pUser != NULL) sdbRelease(pSdb, pUser); if (pUser != NULL) sdbRelease(pSdb, pUser);
if (pIter != NULL) sdbCancelFetch(pSdb, pIter); if (pIter != NULL) sdbCancelFetch(pSdb, pIter);
mndUserFreeObj(&newUser); mndUserFreeObj(&newUser);
return code; TAOS_RETURN(code);
} }
int64_t mndGetUserIpWhiteListVer(SMnode *pMnode, SUserObj *pUser) { int64_t mndGetUserIpWhiteListVer(SMnode *pMnode, SUserObj *pUser) {

14
source/libs/tfs/inc/tfsInt.h
View File

@ -74,16 +74,16 @@ typedef struct STfs {
SHashObj *hash; // name to did map SHashObj *hash; // name to did map
} STfs; } STfs;
STfsDisk *tfsNewDisk(int32_t level, int32_t id, int8_t disable, const char *dir); int32_t tfsNewDisk(int32_t level, int32_t id, int8_t disable, const char *dir, STfsDisk **ppDisk);
STfsDisk *tfsFreeDisk(STfsDisk *pDisk); STfsDisk *tfsFreeDisk(STfsDisk *pDisk);
int32_t tfsUpdateDiskSize(STfsDisk *pDisk); int32_t tfsUpdateDiskSize(STfsDisk *pDisk);
int32_t tfsInitTier(STfsTier *pTier, int32_t level); int32_t tfsInitTier(STfsTier *pTier, int32_t level);
void tfsDestroyTier(STfsTier *pTier); void tfsDestroyTier(STfsTier *pTier);
STfsDisk *tfsMountDiskToTier(STfsTier *pTier, SDiskCfg *pCfg); int32_t tfsMountDiskToTier(STfsTier *pTier, SDiskCfg *pCfg, STfsDisk **ppDisk);
void tfsUpdateTierSize(STfsTier *pTier); void tfsUpdateTierSize(STfsTier *pTier);
int32_t tfsAllocDiskOnTier(STfsTier *pTier); int32_t tfsAllocDiskOnTier(STfsTier *pTier);
void tfsPosNextId(STfsTier *pTier); void tfsPosNextId(STfsTier *pTier);
#define tfsLockTier(pTier) taosThreadSpinLock(&(pTier)->lock) #define tfsLockTier(pTier) taosThreadSpinLock(&(pTier)->lock)
#define tfsUnLockTier(pTier) taosThreadSpinUnlock(&(pTier)->lock) #define tfsUnLockTier(pTier) taosThreadSpinUnlock(&(pTier)->lock)

46
source/libs/tfs/src/tfs.c
View File

@ -495,7 +495,9 @@ static int32_t tfsMount(STfs *pTfs, SDiskCfg *pCfg) {
} }
SDiskID did = {.level = pCfg->level}; SDiskID did = {.level = pCfg->level};
STfsDisk *pDisk = tfsMountDiskToTier(TFS_TIER_AT(pTfs, did.level), pCfg); STfsDisk *pDisk = NULL;
tfsMountDiskToTier(TFS_TIER_AT(pTfs, did.level), pCfg, &pDisk);
if (pDisk == NULL) { if (pDisk == NULL) {
fError("failed to mount disk %s to level %d since %s", pCfg->dir, pCfg->level, terrstr()); fError("failed to mount disk %s to level %d since %s", pCfg->dir, pCfg->level, terrstr());
return -1; return -1;
@ -515,33 +517,28 @@ static int32_t tfsCheckAndFormatCfg(STfs *pTfs, SDiskCfg *pCfg) {
if (pCfg->level < 0 || pCfg->level >= TFS_MAX_TIERS) { if (pCfg->level < 0 || pCfg->level >= TFS_MAX_TIERS) {
fError("failed to mount %s to FS since invalid level %d", pCfg->dir, pCfg->level); fError("failed to mount %s to FS since invalid level %d", pCfg->dir, pCfg->level);
terrno = TSDB_CODE_FS_INVLD_CFG; TAOS_RETURN(TSDB_CODE_FS_INVLD_CFG);
return -1;
} }
if (pCfg->primary < 0 || pCfg->primary > 1) { if (pCfg->primary < 0 || pCfg->primary > 1) {
fError("failed to mount %s to FS since invalid primary %d", pCfg->dir, pCfg->primary); fError("failed to mount %s to FS since invalid primary %d", pCfg->dir, pCfg->primary);
terrno = TSDB_CODE_FS_INVLD_CFG; TAOS_RETURN(TSDB_CODE_FS_INVLD_CFG);
return -1;
} }
if (pCfg->disable < 0 || pCfg->disable > 1) { if (pCfg->disable < 0 || pCfg->disable > 1) {
fError("failed to mount %s to FS since invalid disable %" PRIi8, pCfg->dir, pCfg->disable); fError("failed to mount %s to FS since invalid disable %" PRIi8, pCfg->dir, pCfg->disable);
terrno = TSDB_CODE_FS_INVLD_CFG; TAOS_RETURN(TSDB_CODE_FS_INVLD_CFG);
return -1;
} }
if (pCfg->primary) { if (pCfg->primary) {
if (pCfg->level != 0) { if (pCfg->level != 0) {
fError("failed to mount %s to FS since disk is primary but level %d not 0", pCfg->dir, pCfg->level); fError("failed to mount %s to FS since disk is primary but level %d not 0", pCfg->dir, pCfg->level);
terrno = TSDB_CODE_FS_INVLD_CFG; TAOS_RETURN(TSDB_CODE_FS_INVLD_CFG);
return -1;
} }
if (TFS_PRIMARY_DISK(pTfs) != NULL) { if (TFS_PRIMARY_DISK(pTfs) != NULL) {
fError("failed to mount %s to FS since duplicate primary mount", pCfg->dir); fError("failed to mount %s to FS since duplicate primary mount", pCfg->dir);
terrno = TSDB_CODE_FS_DUP_PRIMARY; TAOS_RETURN(TSDB_CODE_FS_DUP_PRIMARY);
return -1;
} }
} }
@ -578,15 +575,14 @@ static int32_t tfsFormatDir(char *idir, char *odir) {
int32_t code = wordexp(idir, &wep, 0); int32_t code = wordexp(idir, &wep, 0);
if (code != 0) { if (code != 0) {
terrno = TAOS_SYSTEM_ERROR(code); TAOS_RETURN(TAOS_SYSTEM_ERROR(code));
return -1;
} }
char tmp[PATH_MAX] = {0}; char tmp[PATH_MAX] = {0};
if (taosRealPath(wep.we_wordv[0], tmp, PATH_MAX) != 0) { if (taosRealPath(wep.we_wordv[0], tmp, PATH_MAX) != 0) {
terrno = TAOS_SYSTEM_ERROR(errno); code = TAOS_SYSTEM_ERROR(errno);
wordfree(&wep); wordfree(&wep);
return -1; TAOS_RETURN(code);
} }
strcpy(odir, tmp); strcpy(odir, tmp);
@ -597,23 +593,20 @@ static int32_t tfsFormatDir(char *idir, char *odir) {
static int32_t tfsCheck(STfs *pTfs) { static int32_t tfsCheck(STfs *pTfs) {
if (TFS_PRIMARY_DISK(pTfs) == NULL) { if (TFS_PRIMARY_DISK(pTfs) == NULL) {
fError("no primary disk is set"); fError("no primary disk is set");
terrno = TSDB_CODE_FS_NO_PRIMARY_DISK; TAOS_RETURN(TSDB_CODE_FS_NO_PRIMARY_DISK);
return -1;
} }
for (int32_t level = 0; level < pTfs->nlevel; level++) { for (int32_t level = 0; level < pTfs->nlevel; level++) {
if (TFS_TIER_AT(pTfs, level)->ndisk == 0) { if (TFS_TIER_AT(pTfs, level)->ndisk == 0) {
fError("no disk at level %d", level); fError("no disk at level %d", level);
terrno = TSDB_CODE_FS_NO_MOUNT_AT_TIER; TAOS_RETURN(TSDB_CODE_FS_NO_MOUNT_AT_TIER);
return -1;
} }
if (level == 0) { if (level == 0) {
tfsUpdateTierSize(TFS_TIER_AT(pTfs, level)); tfsUpdateTierSize(TFS_TIER_AT(pTfs, level));
if (TFS_TIER_AT(pTfs, level)->nAvailDisks == 0) { if (TFS_TIER_AT(pTfs, level)->nAvailDisks == 0) {
fError("no disk to create new file at level %d", level); fError("no disk to create new file at level %d", level);
terrno = TSDB_CODE_FS_NO_VALID_DISK; TAOS_RETURN(TSDB_CODE_FS_NO_VALID_DISK);
return -1;
} }
} }
} }
@ -684,7 +677,9 @@ static STfsDisk *tfsNextDisk(STfs *pTfs, SDiskIter *pIter) {
int32_t tfsGetMonitorInfo(STfs *pTfs, SMonDiskInfo *pInfo) { int32_t tfsGetMonitorInfo(STfs *pTfs, SMonDiskInfo *pInfo) {
pInfo->datadirs = taosArrayInit(32, sizeof(SMonDiskDesc)); pInfo->datadirs = taosArrayInit(32, sizeof(SMonDiskDesc));
if (pInfo->datadirs == NULL) return -1; if (pInfo->datadirs == NULL) {
TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
}
tfsUpdateSize(pTfs); tfsUpdateSize(pTfs);
@ -697,7 +692,12 @@ int32_t tfsGetMonitorInfo(STfs *pTfs, SMonDiskInfo *pInfo) {
dinfo.size = pDisk->size; dinfo.size = pDisk->size;
dinfo.level = pDisk->level; dinfo.level = pDisk->level;
tstrncpy(dinfo.name, pDisk->path, sizeof(dinfo.name)); tstrncpy(dinfo.name, pDisk->path, sizeof(dinfo.name));
taosArrayPush(pInfo->datadirs, &dinfo); if (taosArrayPush(pInfo->datadirs, &dinfo) == NULL) {
tfsUnLock(pTfs);
taosArrayDestroy(pInfo->datadirs);
pInfo->datadirs = NULL;
TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
}
} }
} }
tfsUnLock(pTfs); tfsUnLock(pTfs);

40
source/libs/tfs/src/tfsDisk.c
View File

@ -16,25 +16,34 @@
#define _DEFAULT_SOURCE #define _DEFAULT_SOURCE
#include "tfsInt.h" #include "tfsInt.h"
STfsDisk *tfsNewDisk(int32_t level, int32_t id, int8_t disable, const char *path) { int32_t tfsNewDisk(int32_t level, int32_t id, int8_t disable, const char *path, STfsDisk **ppDisk) {
STfsDisk *pDisk = taosMemoryCalloc(1, sizeof(STfsDisk)); int32_t code = 0;
if (pDisk == NULL) { int32_t lino = 0;
terrno = TSDB_CODE_OUT_OF_MEMORY; STfsDisk *pDisk = NULL;
return NULL;
if ((pDisk = taosMemoryCalloc(1, sizeof(STfsDisk))) == NULL) {
TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER);
} }
pDisk->path = taosStrdup(path); if ((pDisk->path = taosStrdup(path)) == NULL) {
if (pDisk->path == NULL) { TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _OVER);
taosMemoryFree(pDisk);
terrno = TSDB_CODE_OUT_OF_MEMORY;
return NULL;
} }
pDisk->level = level; pDisk->level = level;
pDisk->id = id; pDisk->id = id;
pDisk->disable = disable; pDisk->disable = disable;
taosGetDiskSize(pDisk->path, &pDisk->size); if (taosGetDiskSize(pDisk->path, &pDisk->size) < 0) {
return pDisk; code = TAOS_SYSTEM_ERROR(errno); // TODO: refactor this line
TAOS_CHECK_GOTO(code, &lino, _OVER);
}
_OVER:
if (code != 0) {
pDisk = tfsFreeDisk(pDisk);
fError("%s failed at line %d since %s, disk:%s level:%d id:%d ", __func__, lino, tstrerror(code), path, level, id);
}
*ppDisk = pDisk;
TAOS_RETURN(code);
} }
STfsDisk *tfsFreeDisk(STfsDisk *pDisk) { STfsDisk *tfsFreeDisk(STfsDisk *pDisk) {
@ -48,9 +57,10 @@ STfsDisk *tfsFreeDisk(STfsDisk *pDisk) {
int32_t tfsUpdateDiskSize(STfsDisk *pDisk) { int32_t tfsUpdateDiskSize(STfsDisk *pDisk) {
if (taosGetDiskSize(pDisk->path, &pDisk->size) < 0) { if (taosGetDiskSize(pDisk->path, &pDisk->size) < 0) {
terrno = TAOS_SYSTEM_ERROR(errno); int32_t code = TAOS_SYSTEM_ERROR(errno); // TODO: refactor this line
fError("failed to get disk:%s size, level:%d id:%d since %s", pDisk->path, pDisk->level, pDisk->id, terrstr()); fError("failed to get disk:%s size, level:%d id:%d since %s", pDisk->path, pDisk->level, pDisk->id,
return -1; tstrerror(code));
TAOS_RETURN(code);
} }
return 0; return 0;

38
source/libs/tfs/src/tfsTier.c
View File

@ -22,8 +22,7 @@ int32_t tfsInitTier(STfsTier *pTier, int32_t level) {
memset(pTier, 0, sizeof(STfsTier)); memset(pTier, 0, sizeof(STfsTier));
if (taosThreadSpinInit(&pTier->lock, 0) != 0) { if (taosThreadSpinInit(&pTier->lock, 0) != 0) {
terrno = TAOS_SYSTEM_ERROR(errno); TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
return -1;
} }
pTier->level = level; pTier->level = level;
@ -39,10 +38,13 @@ void tfsDestroyTier(STfsTier *pTier) {
taosThreadSpinDestroy(&pTier->lock); taosThreadSpinDestroy(&pTier->lock);
} }
STfsDisk *tfsMountDiskToTier(STfsTier *pTier, SDiskCfg *pCfg) { int32_t tfsMountDiskToTier(STfsTier *pTier, SDiskCfg *pCfg, STfsDisk **ppDisk) {
int32_t code = 0;
int32_t lino = 0;
STfsDisk *pDisk = NULL;
if (pTier->ndisk >= TFS_MAX_DISKS_PER_TIER) { if (pTier->ndisk >= TFS_MAX_DISKS_PER_TIER) {
terrno = TSDB_CODE_FS_TOO_MANY_MOUNT; TAOS_CHECK_GOTO(TSDB_CODE_FS_TOO_MANY_MOUNT, &lino, _OVER);
return NULL;
} }
int32_t id = 0; int32_t id = 0;
@ -61,18 +63,25 @@ STfsDisk *tfsMountDiskToTier(STfsTier *pTier, SDiskCfg *pCfg) {
} }
if (id >= TFS_MAX_DISKS_PER_TIER) { if (id >= TFS_MAX_DISKS_PER_TIER) {
terrno = TSDB_CODE_FS_TOO_MANY_MOUNT; TAOS_CHECK_GOTO(TSDB_CODE_FS_TOO_MANY_MOUNT, &lino, _OVER);
return NULL;
} }
STfsDisk *pDisk = tfsNewDisk(pCfg->level, id, pCfg->disable, pCfg->dir); TAOS_CHECK_GOTO(tfsNewDisk(pCfg->level, id, pCfg->disable, pCfg->dir, &pDisk), &lino, _OVER);
if (pDisk == NULL) return NULL;
pTier->disks[id] = pDisk; pTier->disks[id] = pDisk;
pTier->ndisk++; pTier->ndisk++;
fDebug("disk %s is mounted to tier level %d id %d", pCfg->dir, pCfg->level, id); _OVER:
return pTier->disks[id]; if (code != 0) {
pDisk = tfsFreeDisk(pDisk);
fError("%s failed at line %d since %s, disk:%s level:%d id:%d", __func__, lino, tstrerror(code), pCfg->dir,
pCfg->level, id);
} else {
*ppDisk = pTier->disks[id];
fDebug("disk %s is mounted to tier level %d id %d", pCfg->dir, pCfg->level, id);
}
TAOS_RETURN(code);
} }
void tfsUpdateTierSize(STfsTier *pTier) { void tfsUpdateTierSize(STfsTier *pTier) {
@ -100,13 +109,11 @@ void tfsUpdateTierSize(STfsTier *pTier) {
// Round-Robin to allocate disk on a tier // Round-Robin to allocate disk on a tier
int32_t tfsAllocDiskOnTier(STfsTier *pTier) { int32_t tfsAllocDiskOnTier(STfsTier *pTier) {
terrno = TSDB_CODE_FS_NO_VALID_DISK;
tfsLockTier(pTier); tfsLockTier(pTier);
if (pTier->ndisk <= 0 || pTier->nAvailDisks <= 0) { if (pTier->ndisk <= 0 || pTier->nAvailDisks <= 0) {
tfsUnLockTier(pTier); tfsUnLockTier(pTier);
return -1; TAOS_RETURN(TSDB_CODE_FS_NO_VALID_DISK);
} }
int32_t retId = -1; int32_t retId = -1;
@ -149,6 +156,9 @@ int32_t tfsAllocDiskOnTier(STfsTier *pTier) {
} }
tfsUnLockTier(pTier); tfsUnLockTier(pTier);
if (retId < 0) {
TAOS_RETURN(TSDB_CODE_FS_NO_VALID_DISK);
}
return retId; return retId;
} }