#4986

Committed 15 Mar 2026 08:32AM UTC coverage: 37.305% (-31.3%) from 68.601%

Build # #4986

Build Type

push

travis-ci

Committed by

tomchon

Commit Message

test: keep docs and unit test

Coverage Stats

125478 of 336361 relevant lines covered (37.3%)

1134847.06 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

45.6

/source/dnode/mgmt/mgmt_vnode/src/vmWorker.c

/*
 * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
 *
 * This program is free software: you can use, redistribute, and/or modify
 * it under the terms of the GNU Affero General Public License, version 3
 * or later ("AGPL"), as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program. If not, see <http:www.gnu.org/licenses/>.
 */

#define _DEFAULT_SOURCE
#include "vmInt.h"
#include "vnodeInt.h"

static inline void vmSendRsp(SRpcMsg *pMsg, int32_t code) {
  if (pMsg->info.handle == NULL) return;
  SRpcMsg rsp = {
      .code = code,
      .pCont = pMsg->info.rsp,
      .contLen = pMsg->info.rspLen,
      .info = pMsg->info,
  };
  tmsgSendRsp(&rsp);
}

static void vmProcessMultiMgmtQueue(SQueueInfo *pInfo, SRpcMsg *pMsg) {
  SVnodeMgmt     *pMgmt = pInfo->ahandle;
  int32_t         code = -1;
  const STraceId *trace = &pMsg->info.traceId;

  dGTrace("msg:%p, get from vnode-multi-mgmt queue", pMsg);
  switch (pMsg->msgType) {
    case TDMT_DND_CREATE_VNODE:
      code = vmProcessCreateVnodeReq(pMgmt, pMsg);
      break;
#ifdef USE_MOUNT
    case TDMT_DND_RETRIEVE_MOUNT_PATH:
      code = vmProcessRetrieveMountPathReq(pMgmt, pMsg);
      break;
    case TDMT_DND_MOUNT_VNODE:
      code = vmProcessMountVnodeReq(pMgmt, pMsg);
      break;
#endif
  }

  if (IsReq(pMsg)) {
    if (code != 0) {
      if (terrno != 0) code = terrno;
      dGError("msg:%p, failed to process since %s, type:%s", pMsg, tstrerror(code), TMSG_INFO(pMsg->msgType));
    }
    vmSendRsp(pMsg, code);
  }

  dGTrace("msg:%p, is freed, code:0x%x", pMsg, code);
  rpcFreeCont(pMsg->pCont);
  taosFreeQitem(pMsg);
}

static void vmProcessMgmtQueue(SQueueInfo *pInfo, SRpcMsg *pMsg) {
  SVnodeMgmt     *pMgmt = pInfo->ahandle;
  int32_t         code = -1;
  const STraceId *trace = &pMsg->info.traceId;

  dGTrace("msg:%p, get from vnode-mgmt queue", pMsg);
  switch (pMsg->msgType) {
    case TDMT_DND_CREATE_VNODE:
      code = vmProcessCreateVnodeReq(pMgmt, pMsg);
      break;
    case TDMT_DND_DROP_VNODE:
      code = vmProcessDropVnodeReq(pMgmt, pMsg);
      break;
    case TDMT_VND_ALTER_REPLICA:
      code = vmProcessAlterVnodeReplicaReq(pMgmt, pMsg);
      break;
    case TDMT_VND_DISABLE_WRITE:
      code = vmProcessDisableVnodeWriteReq(pMgmt, pMsg);
      break;
    case TDMT_VND_SET_KEEP_VERSION:
      code = vmProcessSetKeepVersionReq(pMgmt, pMsg);
      break;
    case TDMT_VND_ALTER_HASHRANGE:
      code = vmProcessAlterHashRangeReq(pMgmt, pMsg);
      break;
    case TDMT_DND_ALTER_VNODE_TYPE:
      code = vmProcessAlterVnodeTypeReq(pMgmt, pMsg);
      break;
    case TDMT_DND_CHECK_VNODE_LEARNER_CATCHUP:
      code = vmProcessCheckLearnCatchupReq(pMgmt, pMsg);
      break;
    case TDMT_VND_ARB_HEARTBEAT:
      code = vmProcessArbHeartBeatReq(pMgmt, pMsg);
      break;
    case TDMT_VND_ALTER_ELECTBASELINE:
      code = vmProcessAlterVnodeElectBaselineReq(pMgmt, pMsg);
      break;
    default:
      terrno = TSDB_CODE_MSG_NOT_PROCESSED;
      dGError("msg:%p, not processed in vnode-mgmt queue", pMsg);
  }

  if (IsReq(pMsg)) {
    if (code != 0) {
      if (terrno != 0) code = terrno;
      dGError("msg:%p, failed to process since %s, type:%s", pMsg, tstrerror(code), TMSG_INFO(pMsg->msgType));
    }
    vmSendRsp(pMsg, code);
  }

  dGTrace("msg:%p, is freed, code:0x%x", pMsg, code);
  rpcFreeCont(pMsg->pCont);
  taosFreeQitem(pMsg);
}

static void vmProcessQueryQueue(SQueueInfo *pInfo, SRpcMsg *pMsg) {
  SVnodeObj      *pVnode = pInfo->ahandle;
  const STraceId *trace = &pMsg->info.traceId;

  dGTrace("vgId:%d, msg:%p, get from vnode-query queue", pVnode->vgId, pMsg);
  int32_t code = vnodeProcessQueryMsg(pVnode->pImpl, pMsg, pInfo);
  if (code != 0) {
    if (terrno != 0) code = terrno;
    dGError("vgId:%d, msg:%p, failed to query since %s", pVnode->vgId, pMsg, tstrerror(code));
    vmSendRsp(pMsg, code);
  }

  dGTrace("vgId:%d, msg:%p, is freed, code:0x%x", pVnode->vgId, pMsg, code);
  rpcFreeCont(pMsg->pCont);
  taosFreeQitem(pMsg);
}

static void vmProcessFetchQueue(SQueueInfo *pInfo, STaosQall *qall, int32_t numOfMsgs) {
  SVnodeObj *pVnode = pInfo->ahandle;
  SRpcMsg   *pMsg = NULL;

  for (int32_t i = 0; i < numOfMsgs; ++i) {
    if (taosGetQitem(qall, (void **)&pMsg) == 0) continue;
    const STraceId *trace = &pMsg->info.traceId;
    dGTrace("vgId:%d, msg:%p, get from vnode-fetch queue", pVnode->vgId, pMsg);

    terrno = 0;
    int32_t code = vnodeProcessFetchMsg(pVnode->pImpl, pMsg, pInfo);
    if (code != 0) {
      if (code == -1 && terrno != 0) {
        code = terrno;
      }

      if (code == TSDB_CODE_WAL_LOG_NOT_EXIST) {
        dGDebug("vgId:%d, msg:%p, failed to fetch since %s [vnodeProcessFetchMsg]", pVnode->vgId, pMsg, terrstr());
      } else {
        dGError("vgId:%d, msg:%p, failed to fetch since %s [vnodeProcessFetchMsg]", pVnode->vgId, pMsg, terrstr());
      }

      vmSendRsp(pMsg, code);
    }

    dGTrace("vgId:%d, msg:%p, is freed, code:0x%x [vnodeProcessFetchMsg]", pVnode->vgId, pMsg, code);
    rpcFreeCont(pMsg->pCont);
    taosFreeQitem(pMsg);
  }
}

static void vmProcessStreamReaderQueue(SQueueInfo *pInfo, SRpcMsg *pMsg) {
  SVnodeObj *pVnode = pInfo->ahandle;
  const STraceId *trace = &pMsg->info.traceId;
  dGTrace("vgId:%d, msg:%p, get from vnode-fetch queue", pVnode->vgId, pMsg);

  terrno = 0;
  int32_t code = vnodeProcessStreamReaderMsg(pVnode->pImpl, pMsg);
  if (code != 0) {
    if (code == -1 && terrno != 0) {
      code = terrno;
    }

    if (code == 0) {
      dGDebug("vgId:%d, msg:%p, success to stream reader since %s [vmProcessStreamReaderQueue]", pVnode->vgId, pMsg, terrstr());
    } else {
      dGError("vgId:%d, msg:%p, failed to stream reader since %s [vmProcessStreamReaderQueue]", pVnode->vgId, pMsg, terrstr());
    }
  }

  dGTrace("vgId:%d, msg:%p, is freed, code:0x%x [vmProcessStreamReaderQueue]", pVnode->vgId, pMsg, code);
  rpcFreeCont(pMsg->pCont);
  taosFreeQitem(pMsg);
}

static void vmProcessSyncQueue(SQueueInfo *pInfo, STaosQall *qall, int32_t numOfMsgs) {
  SVnodeObj *pVnode = pInfo->ahandle;
  SRpcMsg   *pMsg = NULL;

  for (int32_t i = 0; i < numOfMsgs; ++i) {
    if (taosGetQitem(qall, (void **)&pMsg) == 0) continue;
    const STraceId *trace = &pMsg->info.traceId;
    dGTrace("vgId:%d, msg:%p, get from vnode-sync queue", pVnode->vgId, pMsg);

    int32_t code = vnodeProcessSyncMsg(pVnode->pImpl, pMsg, NULL);  // no response here
    dGTrace("vgId:%d, msg:%p, is freed, code:0x%x", pVnode->vgId, pMsg, code);
    rpcFreeCont(pMsg->pCont);
    taosFreeQitem(pMsg);
  }
}

static void vmSendResponse(SRpcMsg *pMsg) {
  if (pMsg->info.handle) {
    SRpcMsg rsp = {.info = pMsg->info, .code = terrno};
    if (rpcSendResponse(&rsp) != 0) {
      dError("failed to send response since %s", terrstr());
    }
  }
}

static bool vmDataSpaceSufficient(SVnodeObj *pVnode) {
  STfs *pTfs = pVnode->pImpl->pTfs;
  if (pTfs) {
    return tfsDiskSpaceSufficient(pTfs, 0, pVnode->diskPrimary);
  } else {
    return osDataSpaceSufficient();
  }
}

static int32_t vmAcquireVnodeWrapper(SVnodeMgmt *pMgt, int32_t vgId, SVnodeObj **pNode) {
  *pNode = vmAcquireVnode(pMgt, vgId);
  if (*pNode == NULL) {
    return terrno;
  }
  return 0;
}
static int32_t vmPutMsgToQueue(SVnodeMgmt *pMgmt, SRpcMsg *pMsg, EQueueType qtype) {
  int32_t         code = 0;
  SMsgHead *      pHead = pMsg->pCont;
  SVnodeObj *     pVnode = NULL;
  const STraceId *trace = &pMsg->info.traceId;

  if (pMsg->contLen < sizeof(SMsgHead)) {
    dGError("invalid rpc msg with no msg head at pCont. pMsg:%p, type:%s, contLen:%d", pMsg, TMSG_INFO(pMsg->msgType),
            pMsg->contLen);
    return TSDB_CODE_INVALID_MSG;
  }

  pHead->contLen = ntohl(pHead->contLen);
  pHead->vgId = ntohl(pHead->vgId);
  
  code = vmAcquireVnodeWrapper(pMgmt, pHead->vgId, &pVnode);
  if (code != 0) {
    dGDebug("vgId:%d, msg:%p, failed to put into vnode queue since %s, type:%s qtype:%d contLen:%d", pHead->vgId, pMsg,
            tstrerror(code), TMSG_INFO(pMsg->msgType), qtype, pHead->contLen);
    return code;
  }

  switch (qtype) {
    case QUERY_QUEUE:
      // let's put into different query processing queue. The query type is extracted during preprocessing procedure,
      // mquery-queue for meta info query, and query-queue for ordinary users' queries.
      code = vnodePreprocessQueryMsg(pVnode->pImpl, pMsg);
      if (code) {
        dError("vgId:%d, msg:%p, preprocess query msg failed since %s", pVnode->vgId, pMsg, tstrerror(code));
      } else {
        dGTrace("vgId:%d, msg:%p, put into vnode-query queue, type:%s", pVnode->vgId, pMsg, TMSG_INFO(pMsg->msgType));
        code = taosWriteQitem(pVnode->pQueryQ, pMsg);
      }
      break;
    case FETCH_QUEUE:
      dGTrace("vgId:%d, msg:%p, put into vnode-fetch queue, type:%s", pVnode->vgId, pMsg, TMSG_INFO(pMsg->msgType));
      code = taosWriteQitem(pVnode->pFetchQ, pMsg);
      break;
    case WRITE_QUEUE:
      if (!vmDataSpaceSufficient(pVnode)) {
        code = TSDB_CODE_NO_ENOUGH_DISKSPACE;
        dError("vgId:%d, msg:%p, failed to put into vnode-write queue since %s, type:%s", pVnode->vgId, pMsg,
               tstrerror(code), TMSG_INFO(pMsg->msgType));
        break;
      }
#if 0
      if (pMsg->msgType == TDMT_VND_SUBMIT && (grantCheck(TSDB_GRANT_STORAGE) != TSDB_CODE_SUCCESS)) {
        code = TSDB_CODE_VND_NO_WRITE_AUTH;
        dDebug("vgId:%d, msg:%p, failed to put into vnode-write queue since %s, type:%s", pVnode->vgId, pMsg,
               tstrerror(code), TMSG_INFO(pMsg->msgType));
        break;
      }
#endif
      if (pMsg->msgType != TDMT_VND_ALTER_CONFIRM && pVnode->disable) {
        dDebug("vgId:%d, msg:%p, failed to put into vnode-write queue since its disable, type:%s", pVnode->vgId, pMsg,
               TMSG_INFO(pMsg->msgType));
        code = TSDB_CODE_VND_STOPPED;
        break;
      }
      dGDebug("vgId:%d, msg:%p, put into vnode-write queue, type:%s", pVnode->vgId, pMsg, TMSG_INFO(pMsg->msgType));
      code = taosWriteQitem(pVnode->pWriteW.queue, pMsg);
      break;
    case SYNC_QUEUE:
      dGDebug("vgId:%d, msg:%p, put into vnode-sync queue, type:%s", pVnode->vgId, pMsg, TMSG_INFO(pMsg->msgType));
      code = taosWriteQitem(pVnode->pSyncW.queue, pMsg);
      break;
    case SYNC_RD_QUEUE:
      if(tsSyncLogHeartbeat){
        dGInfo("vgId:%d, msg:%p, put into vnode-sync-rd queue, type:%s", pVnode->vgId, pMsg, TMSG_INFO(pMsg->msgType));
      }
      else{
        dGDebug("vgId:%d, msg:%p, put into vnode-sync-rd queue, type:%s", pVnode->vgId, pMsg, TMSG_INFO(pMsg->msgType));
      }
      code = taosWriteQitem(pVnode->pSyncRdW.queue, pMsg);
      break;
    case APPLY_QUEUE:
      dGDebug("vgId:%d, msg:%p, put into vnode-apply queue, type:%s", pVnode->vgId, pMsg, TMSG_INFO(pMsg->msgType));
      code = taosWriteQitem(pVnode->pApplyW.queue, pMsg);
      break;
    case STREAM_READER_QUEUE:
      dGDebug("vgId:%d, msg:%p, put into vnode-stream-reader queue, type:%s", pVnode->vgId, pMsg,
              TMSG_INFO(pMsg->msgType));
      code = taosWriteQitem(pVnode->pStreamReaderQ, pMsg);
      break;
    default:
      code = TSDB_CODE_INVALID_MSG;
      break;
  }

  vmReleaseVnode(pMgmt, pVnode);
  return code;
}

int32_t vmPutMsgToSyncRdQueue(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) { return vmPutMsgToQueue(pMgmt, pMsg, SYNC_RD_QUEUE); }

int32_t vmPutMsgToSyncQueue(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) { return vmPutMsgToQueue(pMgmt, pMsg, SYNC_QUEUE); }

int32_t vmPutMsgToWriteQueue(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) { return vmPutMsgToQueue(pMgmt, pMsg, WRITE_QUEUE); }

int32_t vmPutMsgToQueryQueue(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) { return vmPutMsgToQueue(pMgmt, pMsg, QUERY_QUEUE); }

int32_t vmPutMsgToFetchQueue(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) { return vmPutMsgToQueue(pMgmt, pMsg, FETCH_QUEUE); }

int32_t vmPutMsgToStreamReaderQueue(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) { return vmPutMsgToQueue(pMgmt, pMsg, STREAM_READER_QUEUE); }

int32_t vmPutMsgToMultiMgmtQueue(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
  const STraceId *trace = &pMsg->info.traceId;
  dGTrace("msg:%p, put into vnode-multi-mgmt queue", pMsg);
  return taosWriteQitem(pMgmt->mgmtMultiWorker.queue, pMsg);
}

int32_t vmPutMsgToMgmtQueue(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
  const STraceId *trace = &pMsg->info.traceId;
  dGTrace("msg:%p, put into vnode-mgmt queue", pMsg);
  return taosWriteQitem(pMgmt->mgmtWorker.queue, pMsg);
}

int32_t vmPutRpcMsgToQueue(SVnodeMgmt *pMgmt, EQueueType qtype, SRpcMsg *pRpc) {
  int32_t code;
  if (pRpc->contLen < sizeof(SMsgHead)) {
    dError("invalid rpc msg with no msg head at pCont. pRpc:%p, type:%s, len:%d", pRpc, TMSG_INFO(pRpc->msgType),
           pRpc->contLen);
    rpcFreeCont(pRpc->pCont);
    pRpc->pCont = NULL;
    return TSDB_CODE_INVALID_MSG;
  }

  EQItype  itype = APPLY_QUEUE == qtype ? APPLY_QITEM : RPC_QITEM;
  SRpcMsg *pMsg;
  code = taosAllocateQitem(sizeof(SRpcMsg), itype, pRpc->contLen, (void **)&pMsg);
  if (code) {
    rpcFreeCont(pRpc->pCont);
    pRpc->pCont = NULL;
    return code;
  }

  SMsgHead *pHead = pRpc->pCont;
  dTrace("vgId:%d, msg:%p, is created, type:%s len:%d", pHead->vgId, pMsg, TMSG_INFO(pRpc->msgType), pRpc->contLen);

  pHead->contLen = htonl(pHead->contLen);
  pHead->vgId = htonl(pHead->vgId);
  memcpy(pMsg, pRpc, sizeof(SRpcMsg));
  pRpc->pCont = NULL;

  code = vmPutMsgToQueue(pMgmt, pMsg, qtype);
  if (code != 0) {
    dTrace("msg:%p, is freed", pMsg);
    rpcFreeCont(pMsg->pCont);
    taosFreeQitem(pMsg);
  }

  return code;
}

int32_t vmGetQueueSize(SVnodeMgmt *pMgmt, int32_t vgId, EQueueType qtype) {
  int32_t    size = -1;
  SVnodeObj *pVnode = vmAcquireVnode(pMgmt, vgId);
  if (pVnode != NULL) {
    switch (qtype) {
      case WRITE_QUEUE:
        size = taosQueueItemSize(pVnode->pWriteW.queue);
        break;
      case SYNC_QUEUE:
        size = taosQueueItemSize(pVnode->pSyncW.queue);
        break;
      case APPLY_QUEUE:
        size = taosQueueItemSize(pVnode->pApplyW.queue);
        break;
      case QUERY_QUEUE:
        size = taosQueueItemSize(pVnode->pQueryQ);
        break;
      case FETCH_QUEUE:
        size = taosQueueItemSize(pVnode->pFetchQ);
        break;
      case STREAM_READER_QUEUE:
        size = taosQueueItemSize(pVnode->pStreamReaderQ);
        break;
      default:
        break;
    }
  }
  if (pVnode) vmReleaseVnode(pMgmt, pVnode);
  if (size < 0) {
    dTrace("vgId:%d, can't get size from queue since %s, qtype:%d", vgId, terrstr(), qtype);
    size = 0;
  }
  return size;
}

int32_t vmAllocQueue(SVnodeMgmt *pMgmt, SVnodeObj *pVnode) {
  int32_t         code = 0;
  SMultiWorkerCfg wcfg = {.max = 1, .name = "vnode-write", .fp = (FItems)vnodeProposeWriteMsg, .param = pVnode->pImpl};
  SMultiWorkerCfg scfg = {.max = 1, .name = "vnode-sync", .fp = (FItems)vmProcessSyncQueue, .param = pVnode};
  SMultiWorkerCfg sccfg = {.max = 1, .name = "vnode-sync-rd", .fp = (FItems)vmProcessSyncQueue, .param = pVnode};
  SMultiWorkerCfg acfg = {.max = 1, .name = "vnode-apply", .fp = (FItems)vnodeApplyWriteMsg, .param = pVnode->pImpl};
  code = tMultiWorkerInit(&pVnode->pWriteW, &wcfg);
  if (code) {
    return code;
  }
  code = tMultiWorkerInit(&pVnode->pSyncW, &scfg);
  if (code) {
    tMultiWorkerCleanup(&pVnode->pWriteW);
    return code;
  }
  code = tMultiWorkerInit(&pVnode->pSyncRdW, &sccfg);
  if (code) {
    tMultiWorkerCleanup(&pVnode->pWriteW);
    tMultiWorkerCleanup(&pVnode->pSyncW);
    return code;
  }
  code = tMultiWorkerInit(&pVnode->pApplyW, &acfg);
  if (code) {
    tMultiWorkerCleanup(&pVnode->pWriteW);
    tMultiWorkerCleanup(&pVnode->pSyncW);
    tMultiWorkerCleanup(&pVnode->pSyncRdW);
    return code;
  }

  pVnode->pQueryQ = tQueryAutoQWorkerAllocQueue(&pMgmt->queryPool, pVnode, (FItem)vmProcessQueryQueue);
  pVnode->pStreamReaderQ = tQueryAutoQWorkerAllocQueue(&pMgmt->streamReaderPool, pVnode, (FItem)vmProcessStreamReaderQueue);
  pVnode->pFetchQ = tWWorkerAllocQueue(&pMgmt->fetchPool, pVnode, (FItems)vmProcessFetchQueue);

  if (pVnode->pWriteW.queue == NULL || pVnode->pSyncW.queue == NULL || pVnode->pSyncRdW.queue == NULL ||
      pVnode->pApplyW.queue == NULL || pVnode->pQueryQ == NULL || pVnode->pFetchQ == NULL || !pVnode->pStreamReaderQ) {
    return TSDB_CODE_OUT_OF_MEMORY;
  }

  dInfo("vgId:%d, write-queue:%p is alloced, thread:%08" PRId64, pVnode->vgId, pVnode->pWriteW.queue,
        taosQueueGetThreadId(pVnode->pWriteW.queue));
  dInfo("vgId:%d, sync-queue:%p is alloced, thread:%08" PRId64, pVnode->vgId, pVnode->pSyncW.queue,
        taosQueueGetThreadId(pVnode->pSyncW.queue));
  dInfo("vgId:%d, sync-rd-queue:%p is alloced, thread:%08" PRId64, pVnode->vgId, pVnode->pSyncRdW.queue,
        taosQueueGetThreadId(pVnode->pSyncRdW.queue));
  dInfo("vgId:%d, apply-queue:%p is alloced, thread:%08" PRId64, pVnode->vgId, pVnode->pApplyW.queue,
        taosQueueGetThreadId(pVnode->pApplyW.queue));
  dInfo("vgId:%d, query-queue:%p is alloced", pVnode->vgId, pVnode->pQueryQ);
  dInfo("vgId:%d, stream-reader-queue:%p is alloced", pVnode->vgId, pVnode->pStreamReaderQ);
  dInfo("vgId:%d, fetch-queue:%p is alloced, thread:%08" PRId64, pVnode->vgId, pVnode->pFetchQ,
        taosQueueGetThreadId(pVnode->pFetchQ));
  return 0;
}

void vmFreeQueue(SVnodeMgmt *pMgmt, SVnodeObj *pVnode) {
  tQueryAutoQWorkerFreeQueue(&pMgmt->queryPool, pVnode->pQueryQ);
  tQueryAutoQWorkerFreeQueue(&pMgmt->streamReaderPool, pVnode->pStreamReaderQ);
  tWWorkerFreeQueue(&pMgmt->fetchPool, pVnode->pFetchQ);

  pVnode->pQueryQ = NULL;
  pVnode->pFetchQ = NULL;
  pVnode->pStreamReaderQ = NULL;
  dDebug("vgId:%d, queue is freed", pVnode->vgId);
}

int32_t vmStartWorker(SVnodeMgmt *pMgmt) {
  int32_t code = 0;

  SQueryAutoQWorkerPool *pQPool = &pMgmt->queryPool;
  pQPool->name = "vnode-query";
  pQPool->min = tsNumOfVnodeQueryThreads;
  pQPool->max = tsNumOfVnodeQueryThreads;
  if ((code = tQueryAutoQWorkerInit(pQPool)) != 0) return code;

  SQueryAutoQWorkerPool *pSPool = &pMgmt->streamReaderPool;
  pSPool->name = "vnode-st-reader";
  pSPool->min = tsNumOfVnodeStreamReaderThreads;
  pSPool->max = tsNumOfVnodeStreamReaderThreads;
  if ((code = tQueryAutoQWorkerInit(pSPool)) != 0) return code;

  tsNumOfQueryThreads += tsNumOfVnodeQueryThreads;

  SWWorkerPool *pFPool = &pMgmt->fetchPool;
  pFPool->name = "vnode-fetch";
  pFPool->max = tsNumOfVnodeFetchThreads;
  if ((code = tWWorkerInit(pFPool)) != 0) return code;

  SSingleWorkerCfg mgmtCfg = {
      .min = 1, .max = 1, .name = "vnode-mgmt", .fp = (FItem)vmProcessMgmtQueue, .param = pMgmt};

  if ((code = tSingleWorkerInit(&pMgmt->mgmtWorker, &mgmtCfg)) != 0) return code;

  int32_t threadNum = 0;
  if (tsNumOfCores == 1) {
    threadNum = 2;
  } else {
    threadNum = tsNumOfCores;
  }
  SSingleWorkerCfg multiMgmtCfg = {.min = threadNum,
                                   .max = threadNum,
                                   .name = "vnode-multi-mgmt",
                                   .fp = (FItem)vmProcessMultiMgmtQueue,
                                   .param = pMgmt};

  if ((code = tSingleWorkerInit(&pMgmt->mgmtMultiWorker, &multiMgmtCfg)) != 0) return code;
  dDebug("vnode workers are initialized");
  return 0;
}

void vmStopWorker(SVnodeMgmt *pMgmt) {
  tQueryAutoQWorkerCleanup(&pMgmt->queryPool);
  tWWorkerCleanup(&pMgmt->fetchPool);
  tQueryAutoQWorkerCleanup(&pMgmt->streamReaderPool);
  dDebug("vnode workers are closed");
}

1	/*
2	* Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
3	*
4	* This program is free software: you can use, redistribute, and/or modify
5	* it under the terms of the GNU Affero General Public License, version 3
6	* or later ("AGPL"), as published by the Free Software Foundation.
7	*
8	* This program is distributed in the hope that it will be useful, but WITHOUT
9	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10	* FITNESS FOR A PARTICULAR PURPOSE.
11	*
12	* You should have received a copy of the GNU Affero General Public License
13	* along with this program. If not, see <http:www.gnu.org/licenses/>.
14	*/
15
16	#define _DEFAULT_SOURCE
17	#include "vmInt.h"
18	#include "vnodeInt.h"
19
20	static inline void vmSendRsp(SRpcMsg *pMsg, int32_t code) {	72✔
21	if (pMsg->info.handle == NULL) return;	72✔
22	SRpcMsg rsp = {	72✔
23	.code = code,
24	.pCont = pMsg->info.rsp,	72✔
25	.contLen = pMsg->info.rspLen,	72✔
26	.info = pMsg->info,
27	};
28	tmsgSendRsp(&rsp);	72✔
29	}
30
31	static void vmProcessMultiMgmtQueue(SQueueInfo pInfo, SRpcMsg pMsg) {	40✔
32	SVnodeMgmt *pMgmt = pInfo->ahandle;	40✔
33	int32_t code = -1;	40✔
34	const STraceId *trace = &pMsg->info.traceId;	40✔
35
36	dGTrace("msg:%p, get from vnode-multi-mgmt queue", pMsg);	40✔
37	switch (pMsg->msgType) {	40✔
38	case TDMT_DND_CREATE_VNODE:	40✔
39	code = vmProcessCreateVnodeReq(pMgmt, pMsg);	40✔
40	break;	40✔
41	#ifdef USE_MOUNT
42	case TDMT_DND_RETRIEVE_MOUNT_PATH:	×
43	code = vmProcessRetrieveMountPathReq(pMgmt, pMsg);	×
44	break;	×
45	case TDMT_DND_MOUNT_VNODE:	×
46	code = vmProcessMountVnodeReq(pMgmt, pMsg);	×
47	break;	×
48	#endif
49	}
50
51	if (IsReq(pMsg)) {	40✔
52	if (code != 0) {	40✔
53	if (terrno != 0) code = terrno;	×
54	dGError("msg:%p, failed to process since %s, type:%s", pMsg, tstrerror(code), TMSG_INFO(pMsg->msgType));	×
55	}
56	vmSendRsp(pMsg, code);	40✔
57	}
58
59	dGTrace("msg:%p, is freed, code:0x%x", pMsg, code);	40✔
60	rpcFreeCont(pMsg->pCont);	40✔
61	taosFreeQitem(pMsg);	40✔
62	}	40✔
63
64	static void vmProcessMgmtQueue(SQueueInfo pInfo, SRpcMsg pMsg) {	32✔
65	SVnodeMgmt *pMgmt = pInfo->ahandle;	32✔
66	int32_t code = -1;	32✔
67	const STraceId *trace = &pMsg->info.traceId;	32✔
68
69	dGTrace("msg:%p, get from vnode-mgmt queue", pMsg);	32✔
70	switch (pMsg->msgType) {	32✔
71	case TDMT_DND_CREATE_VNODE:	×
72	code = vmProcessCreateVnodeReq(pMgmt, pMsg);	×
73	break;	×
74	case TDMT_DND_DROP_VNODE:	32✔
75	code = vmProcessDropVnodeReq(pMgmt, pMsg);	32✔
76	break;	32✔
77	case TDMT_VND_ALTER_REPLICA:	×
78	code = vmProcessAlterVnodeReplicaReq(pMgmt, pMsg);	×
79	break;	×
80	case TDMT_VND_DISABLE_WRITE:	×
81	code = vmProcessDisableVnodeWriteReq(pMgmt, pMsg);	×
82	break;	×
83	case TDMT_VND_SET_KEEP_VERSION:	×
84	code = vmProcessSetKeepVersionReq(pMgmt, pMsg);	×
85	break;	×
86	case TDMT_VND_ALTER_HASHRANGE:	×
87	code = vmProcessAlterHashRangeReq(pMgmt, pMsg);	×
88	break;	×
89	case TDMT_DND_ALTER_VNODE_TYPE:	×
90	code = vmProcessAlterVnodeTypeReq(pMgmt, pMsg);	×
91	break;	×
92	case TDMT_DND_CHECK_VNODE_LEARNER_CATCHUP:	×
93	code = vmProcessCheckLearnCatchupReq(pMgmt, pMsg);	×
94	break;	×
95	case TDMT_VND_ARB_HEARTBEAT:	×
96	code = vmProcessArbHeartBeatReq(pMgmt, pMsg);	×
97	break;	×
98	case TDMT_VND_ALTER_ELECTBASELINE:	×
99	code = vmProcessAlterVnodeElectBaselineReq(pMgmt, pMsg);	×
100	break;	×
101	default:	×
102	terrno = TSDB_CODE_MSG_NOT_PROCESSED;	×
103	dGError("msg:%p, not processed in vnode-mgmt queue", pMsg);	×
104	}
105
106	if (IsReq(pMsg)) {	32✔
107	if (code != 0) {	32✔
108	if (terrno != 0) code = terrno;	×
109	dGError("msg:%p, failed to process since %s, type:%s", pMsg, tstrerror(code), TMSG_INFO(pMsg->msgType));	×
110	}
111	vmSendRsp(pMsg, code);	32✔
112	}
113
114	dGTrace("msg:%p, is freed, code:0x%x", pMsg, code);	32✔
115	rpcFreeCont(pMsg->pCont);	32✔
116	taosFreeQitem(pMsg);	32✔
117	}	32✔
118
119	static void vmProcessQueryQueue(SQueueInfo pInfo, SRpcMsg pMsg) {	×
120	SVnodeObj *pVnode = pInfo->ahandle;	×
121	const STraceId *trace = &pMsg->info.traceId;	×
122
123	dGTrace("vgId:%d, msg:%p, get from vnode-query queue", pVnode->vgId, pMsg);	×
124	int32_t code = vnodeProcessQueryMsg(pVnode->pImpl, pMsg, pInfo);	×
125	if (code != 0) {	×
126	if (terrno != 0) code = terrno;	×
127	dGError("vgId:%d, msg:%p, failed to query since %s", pVnode->vgId, pMsg, tstrerror(code));	×
128	vmSendRsp(pMsg, code);	×
129	}
130
131	dGTrace("vgId:%d, msg:%p, is freed, code:0x%x", pVnode->vgId, pMsg, code);	×
132	rpcFreeCont(pMsg->pCont);	×
133	taosFreeQitem(pMsg);	×
134	}	×
135
136	static void vmProcessFetchQueue(SQueueInfo pInfo, STaosQall qall, int32_t numOfMsgs) {	×
137	SVnodeObj *pVnode = pInfo->ahandle;	×
138	SRpcMsg *pMsg = NULL;	×
139
140	for (int32_t i = 0; i < numOfMsgs; ++i) {	×
141	if (taosGetQitem(qall, (void **)&pMsg) == 0) continue;	×
142	const STraceId *trace = &pMsg->info.traceId;	×
143	dGTrace("vgId:%d, msg:%p, get from vnode-fetch queue", pVnode->vgId, pMsg);	×
144
145	terrno = 0;	×
146	int32_t code = vnodeProcessFetchMsg(pVnode->pImpl, pMsg, pInfo);	×
147	if (code != 0) {	×
148	if (code == -1 && terrno != 0) {	×
149	code = terrno;	×
150	}
151
152	if (code == TSDB_CODE_WAL_LOG_NOT_EXIST) {	×
153	dGDebug("vgId:%d, msg:%p, failed to fetch since %s [vnodeProcessFetchMsg]", pVnode->vgId, pMsg, terrstr());	×
154	} else {
155	dGError("vgId:%d, msg:%p, failed to fetch since %s [vnodeProcessFetchMsg]", pVnode->vgId, pMsg, terrstr());	×
156	}
157
158	vmSendRsp(pMsg, code);	×
159	}
160
161	dGTrace("vgId:%d, msg:%p, is freed, code:0x%x [vnodeProcessFetchMsg]", pVnode->vgId, pMsg, code);	×
162	rpcFreeCont(pMsg->pCont);	×
163	taosFreeQitem(pMsg);	×
164	}
165	}	×
166
167	static void vmProcessStreamReaderQueue(SQueueInfo pInfo, SRpcMsg pMsg) {	×
168	SVnodeObj *pVnode = pInfo->ahandle;	×
169	const STraceId *trace = &pMsg->info.traceId;	×
170	dGTrace("vgId:%d, msg:%p, get from vnode-fetch queue", pVnode->vgId, pMsg);	×
171
172	terrno = 0;	×
173	int32_t code = vnodeProcessStreamReaderMsg(pVnode->pImpl, pMsg);	×
174	if (code != 0) {	×
175	if (code == -1 && terrno != 0) {	×
176	code = terrno;	×
177	}
178
179	if (code == 0) {	×
180	dGDebug("vgId:%d, msg:%p, success to stream reader since %s [vmProcessStreamReaderQueue]", pVnode->vgId, pMsg, terrstr());	×
181	} else {
182	dGError("vgId:%d, msg:%p, failed to stream reader since %s [vmProcessStreamReaderQueue]", pVnode->vgId, pMsg, terrstr());	×
183	}
184	}
185
186	dGTrace("vgId:%d, msg:%p, is freed, code:0x%x [vmProcessStreamReaderQueue]", pVnode->vgId, pMsg, code);	×
187	rpcFreeCont(pMsg->pCont);	×
188	taosFreeQitem(pMsg);	×
189	}	×
190
191	static void vmProcessSyncQueue(SQueueInfo pInfo, STaosQall qall, int32_t numOfMsgs) {	×
192	SVnodeObj *pVnode = pInfo->ahandle;	×
193	SRpcMsg *pMsg = NULL;	×
194
195	for (int32_t i = 0; i < numOfMsgs; ++i) {	×
196	if (taosGetQitem(qall, (void **)&pMsg) == 0) continue;	×
197	const STraceId *trace = &pMsg->info.traceId;	×
198	dGTrace("vgId:%d, msg:%p, get from vnode-sync queue", pVnode->vgId, pMsg);	×
199
200	int32_t code = vnodeProcessSyncMsg(pVnode->pImpl, pMsg, NULL); // no response here	×
201	dGTrace("vgId:%d, msg:%p, is freed, code:0x%x", pVnode->vgId, pMsg, code);	×
202	rpcFreeCont(pMsg->pCont);	×
203	taosFreeQitem(pMsg);	×
204	}
205	}	×
206
207	static void vmSendResponse(SRpcMsg *pMsg) {	×
208	if (pMsg->info.handle) {	×
209	SRpcMsg rsp = {.info = pMsg->info, .code = terrno};	×
210	if (rpcSendResponse(&rsp) != 0) {	×
211	dError("failed to send response since %s", terrstr());	×
212	}
213	}
214	}	×
215
216	static bool vmDataSpaceSufficient(SVnodeObj *pVnode) {	81✔
217	STfs *pTfs = pVnode->pImpl->pTfs;	81✔
218	if (pTfs) {	81✔
219	return tfsDiskSpaceSufficient(pTfs, 0, pVnode->diskPrimary);	81✔
220	} else {
221	return osDataSpaceSufficient();	×
222	}
223	}
224
225	static int32_t vmAcquireVnodeWrapper(SVnodeMgmt pMgt, int32_t vgId, SVnodeObj *pNode) {	154✔
226	*pNode = vmAcquireVnode(pMgt, vgId);	154✔
227	if (*pNode == NULL) {	154✔
228	return terrno;	33✔
229	}
230	return 0;	121✔
231	}
232	static int32_t vmPutMsgToQueue(SVnodeMgmt pMgmt, SRpcMsg pMsg, EQueueType qtype) {	154✔
233	int32_t code = 0;	154✔
234	SMsgHead * pHead = pMsg->pCont;	154✔
235	SVnodeObj * pVnode = NULL;	154✔
236	const STraceId *trace = &pMsg->info.traceId;	154✔
237
238	if (pMsg->contLen < sizeof(SMsgHead)) {	154✔
239	dGError("invalid rpc msg with no msg head at pCont. pMsg:%p, type:%s, contLen:%d", pMsg, TMSG_INFO(pMsg->msgType),	×
240	pMsg->contLen);
241	return TSDB_CODE_INVALID_MSG;	×
242	}
243
244	pHead->contLen = ntohl(pHead->contLen);	154✔
245	pHead->vgId = ntohl(pHead->vgId);	154✔
246
247	code = vmAcquireVnodeWrapper(pMgmt, pHead->vgId, &pVnode);	154✔
248	if (code != 0) {	154✔
249	dGDebug("vgId:%d, msg:%p, failed to put into vnode queue since %s, type:%s qtype:%d contLen:%d", pHead->vgId, pMsg,	33✔
250	tstrerror(code), TMSG_INFO(pMsg->msgType), qtype, pHead->contLen);
251	return code;	33✔
252	}
253
254	switch (qtype) {	121✔
255	case QUERY_QUEUE:	×
256	// let's put into different query processing queue. The query type is extracted during preprocessing procedure,
257	// mquery-queue for meta info query, and query-queue for ordinary users' queries.
258	code = vnodePreprocessQueryMsg(pVnode->pImpl, pMsg);	×
259	if (code) {	×
260	dError("vgId:%d, msg:%p, preprocess query msg failed since %s", pVnode->vgId, pMsg, tstrerror(code));	×
261	} else {
262	dGTrace("vgId:%d, msg:%p, put into vnode-query queue, type:%s", pVnode->vgId, pMsg, TMSG_INFO(pMsg->msgType));	×
263	code = taosWriteQitem(pVnode->pQueryQ, pMsg);	×
264	}
265	break;	×
266	case FETCH_QUEUE:	×
267	dGTrace("vgId:%d, msg:%p, put into vnode-fetch queue, type:%s", pVnode->vgId, pMsg, TMSG_INFO(pMsg->msgType));	×
268	code = taosWriteQitem(pVnode->pFetchQ, pMsg);	×
269	break;	×
270	case WRITE_QUEUE:	81✔
271	if (!vmDataSpaceSufficient(pVnode)) {	81✔
272	code = TSDB_CODE_NO_ENOUGH_DISKSPACE;	×
273	dError("vgId:%d, msg:%p, failed to put into vnode-write queue since %s, type:%s", pVnode->vgId, pMsg,	×
274	tstrerror(code), TMSG_INFO(pMsg->msgType));
275	break;	×
276	}
277	#if 0
278	if (pMsg->msgType == TDMT_VND_SUBMIT && (grantCheck(TSDB_GRANT_STORAGE) != TSDB_CODE_SUCCESS)) {
279	code = TSDB_CODE_VND_NO_WRITE_AUTH;
280	dDebug("vgId:%d, msg:%p, failed to put into vnode-write queue since %s, type:%s", pVnode->vgId, pMsg,
281	tstrerror(code), TMSG_INFO(pMsg->msgType));
282	break;
283	}
284	#endif
285	if (pMsg->msgType != TDMT_VND_ALTER_CONFIRM && pVnode->disable) {	81✔
286	dDebug("vgId:%d, msg:%p, failed to put into vnode-write queue since its disable, type:%s", pVnode->vgId, pMsg,	×
287	TMSG_INFO(pMsg->msgType));
288	code = TSDB_CODE_VND_STOPPED;	×
289	break;	×
290	}
291	dGDebug("vgId:%d, msg:%p, put into vnode-write queue, type:%s", pVnode->vgId, pMsg, TMSG_INFO(pMsg->msgType));	81✔
292	code = taosWriteQitem(pVnode->pWriteW.queue, pMsg);	81✔
293	break;	81✔
294	case SYNC_QUEUE:	×
295	dGDebug("vgId:%d, msg:%p, put into vnode-sync queue, type:%s", pVnode->vgId, pMsg, TMSG_INFO(pMsg->msgType));	×
296	code = taosWriteQitem(pVnode->pSyncW.queue, pMsg);	×
297	break;	×
298	case SYNC_RD_QUEUE:	×
299	if(tsSyncLogHeartbeat){	×
300	dGInfo("vgId:%d, msg:%p, put into vnode-sync-rd queue, type:%s", pVnode->vgId, pMsg, TMSG_INFO(pMsg->msgType));	×
301	}
302	else{
303	dGDebug("vgId:%d, msg:%p, put into vnode-sync-rd queue, type:%s", pVnode->vgId, pMsg, TMSG_INFO(pMsg->msgType));	×
304	}
305	code = taosWriteQitem(pVnode->pSyncRdW.queue, pMsg);	×
306	break;	×
307	case APPLY_QUEUE:	40✔
308	dGDebug("vgId:%d, msg:%p, put into vnode-apply queue, type:%s", pVnode->vgId, pMsg, TMSG_INFO(pMsg->msgType));	40✔
309	code = taosWriteQitem(pVnode->pApplyW.queue, pMsg);	40✔
310	break;	40✔
311	case STREAM_READER_QUEUE:	×
312	dGDebug("vgId:%d, msg:%p, put into vnode-stream-reader queue, type:%s", pVnode->vgId, pMsg,	×
313	TMSG_INFO(pMsg->msgType));
314	code = taosWriteQitem(pVnode->pStreamReaderQ, pMsg);	×
315	break;	×
316	default:	×
317	code = TSDB_CODE_INVALID_MSG;	×
318	break;	×
319	}
320
321	vmReleaseVnode(pMgmt, pVnode);	121✔
322	return code;	121✔
323	}
324
325	int32_t vmPutMsgToSyncRdQueue(SVnodeMgmt pMgmt, SRpcMsg pMsg) { return vmPutMsgToQueue(pMgmt, pMsg, SYNC_RD_QUEUE); }	×
326
327	int32_t vmPutMsgToSyncQueue(SVnodeMgmt pMgmt, SRpcMsg pMsg) { return vmPutMsgToQueue(pMgmt, pMsg, SYNC_QUEUE); }	×
328
329	int32_t vmPutMsgToWriteQueue(SVnodeMgmt pMgmt, SRpcMsg pMsg) { return vmPutMsgToQueue(pMgmt, pMsg, WRITE_QUEUE); }	78✔
330
331	int32_t vmPutMsgToQueryQueue(SVnodeMgmt pMgmt, SRpcMsg pMsg) { return vmPutMsgToQueue(pMgmt, pMsg, QUERY_QUEUE); }	×
332
333	int32_t vmPutMsgToFetchQueue(SVnodeMgmt pMgmt, SRpcMsg pMsg) { return vmPutMsgToQueue(pMgmt, pMsg, FETCH_QUEUE); }	×
334
335	int32_t vmPutMsgToStreamReaderQueue(SVnodeMgmt pMgmt, SRpcMsg pMsg) { return vmPutMsgToQueue(pMgmt, pMsg, STREAM_READER_QUEUE); }	×
336
337	int32_t vmPutMsgToMultiMgmtQueue(SVnodeMgmt pMgmt, SRpcMsg pMsg) {	40✔
338	const STraceId *trace = &pMsg->info.traceId;	40✔
339	dGTrace("msg:%p, put into vnode-multi-mgmt queue", pMsg);	40✔
340	return taosWriteQitem(pMgmt->mgmtMultiWorker.queue, pMsg);	40✔
341	}
342
343	int32_t vmPutMsgToMgmtQueue(SVnodeMgmt pMgmt, SRpcMsg pMsg) {	32✔
344	const STraceId *trace = &pMsg->info.traceId;	32✔
345	dGTrace("msg:%p, put into vnode-mgmt queue", pMsg);	32✔
346	return taosWriteQitem(pMgmt->mgmtWorker.queue, pMsg);	32✔
347	}
348
349	int32_t vmPutRpcMsgToQueue(SVnodeMgmt pMgmt, EQueueType qtype, SRpcMsg pRpc) {	76✔
350	int32_t code;
351	if (pRpc->contLen < sizeof(SMsgHead)) {	76✔
352	dError("invalid rpc msg with no msg head at pCont. pRpc:%p, type:%s, len:%d", pRpc, TMSG_INFO(pRpc->msgType),	×
353	pRpc->contLen);
354	rpcFreeCont(pRpc->pCont);	×
355	pRpc->pCont = NULL;	×
356	return TSDB_CODE_INVALID_MSG;	×
357	}
358
359	EQItype itype = APPLY_QUEUE == qtype ? APPLY_QITEM : RPC_QITEM;	76✔
360	SRpcMsg *pMsg;
361	code = taosAllocateQitem(sizeof(SRpcMsg), itype, pRpc->contLen, (void **)&pMsg);	76✔
362	if (code) {	76✔
363	rpcFreeCont(pRpc->pCont);	×
364	pRpc->pCont = NULL;	×
365	return code;	×
366	}
367
368	SMsgHead *pHead = pRpc->pCont;	76✔
369	dTrace("vgId:%d, msg:%p, is created, type:%s len:%d", pHead->vgId, pMsg, TMSG_INFO(pRpc->msgType), pRpc->contLen);	76✔
370
371	pHead->contLen = htonl(pHead->contLen);	76✔
372	pHead->vgId = htonl(pHead->vgId);	76✔
373	memcpy(pMsg, pRpc, sizeof(SRpcMsg));	76✔
374	pRpc->pCont = NULL;	76✔
375
376	code = vmPutMsgToQueue(pMgmt, pMsg, qtype);	76✔
377	if (code != 0) {	76✔
378	dTrace("msg:%p, is freed", pMsg);	32✔
379	rpcFreeCont(pMsg->pCont);	32✔
380	taosFreeQitem(pMsg);	32✔
381	}
382
383	return code;	76✔
384	}
385
386	int32_t vmGetQueueSize(SVnodeMgmt *pMgmt, int32_t vgId, EQueueType qtype) {	×
387	int32_t size = -1;	×
388	SVnodeObj *pVnode = vmAcquireVnode(pMgmt, vgId);	×
389	if (pVnode != NULL) {	×
390	switch (qtype) {	×
391	case WRITE_QUEUE:	×
392	size = taosQueueItemSize(pVnode->pWriteW.queue);	×
393	break;	×
394	case SYNC_QUEUE:	×
395	size = taosQueueItemSize(pVnode->pSyncW.queue);	×
396	break;	×
397	case APPLY_QUEUE:	×
398	size = taosQueueItemSize(pVnode->pApplyW.queue);	×
399	break;	×
400	case QUERY_QUEUE:	×
401	size = taosQueueItemSize(pVnode->pQueryQ);	×
402	break;	×
403	case FETCH_QUEUE:	×
404	size = taosQueueItemSize(pVnode->pFetchQ);	×
405	break;	×
406	case STREAM_READER_QUEUE:	×
407	size = taosQueueItemSize(pVnode->pStreamReaderQ);	×
408	break;	×
409	default:	×
410	break;	×
411	}
412	}
413	if (pVnode) vmReleaseVnode(pMgmt, pVnode);	×
414	if (size < 0) {	×
415	dTrace("vgId:%d, can't get size from queue since %s, qtype:%d", vgId, terrstr(), qtype);	×
416	size = 0;	×
417	}
418	return size;	×
419	}
420
421	int32_t vmAllocQueue(SVnodeMgmt pMgmt, SVnodeObj pVnode) {	40✔
422	int32_t code = 0;	40✔
423	SMultiWorkerCfg wcfg = {.max = 1, .name = "vnode-write", .fp = (FItems)vnodeProposeWriteMsg, .param = pVnode->pImpl};	40✔
424	SMultiWorkerCfg scfg = {.max = 1, .name = "vnode-sync", .fp = (FItems)vmProcessSyncQueue, .param = pVnode};	40✔
425	SMultiWorkerCfg sccfg = {.max = 1, .name = "vnode-sync-rd", .fp = (FItems)vmProcessSyncQueue, .param = pVnode};	40✔
426	SMultiWorkerCfg acfg = {.max = 1, .name = "vnode-apply", .fp = (FItems)vnodeApplyWriteMsg, .param = pVnode->pImpl};	40✔
427	code = tMultiWorkerInit(&pVnode->pWriteW, &wcfg);	40✔
428	if (code) {	40✔
429	return code;	×
430	}
431	code = tMultiWorkerInit(&pVnode->pSyncW, &scfg);	40✔
432	if (code) {	40✔
433	tMultiWorkerCleanup(&pVnode->pWriteW);	×
434	return code;	×
435	}
436	code = tMultiWorkerInit(&pVnode->pSyncRdW, &sccfg);	40✔
437	if (code) {	40✔
438	tMultiWorkerCleanup(&pVnode->pWriteW);	×
439	tMultiWorkerCleanup(&pVnode->pSyncW);	×
440	return code;	×
441	}
442	code = tMultiWorkerInit(&pVnode->pApplyW, &acfg);	40✔
443	if (code) {	40✔
444	tMultiWorkerCleanup(&pVnode->pWriteW);	×
445	tMultiWorkerCleanup(&pVnode->pSyncW);	×
446	tMultiWorkerCleanup(&pVnode->pSyncRdW);	×
447	return code;	×
448	}
449
450	pVnode->pQueryQ = tQueryAutoQWorkerAllocQueue(&pMgmt->queryPool, pVnode, (FItem)vmProcessQueryQueue);	40✔
451	pVnode->pStreamReaderQ = tQueryAutoQWorkerAllocQueue(&pMgmt->streamReaderPool, pVnode, (FItem)vmProcessStreamReaderQueue);	40✔
452	pVnode->pFetchQ = tWWorkerAllocQueue(&pMgmt->fetchPool, pVnode, (FItems)vmProcessFetchQueue);	40✔
453
454	if (pVnode->pWriteW.queue == NULL \|\| pVnode->pSyncW.queue == NULL \|\| pVnode->pSyncRdW.queue == NULL \|\|	40✔
455	pVnode->pApplyW.queue == NULL \|\| pVnode->pQueryQ == NULL \|\| pVnode->pFetchQ == NULL \|\| !pVnode->pStreamReaderQ) {	40✔
456	return TSDB_CODE_OUT_OF_MEMORY;	×
457	}
458
459	dInfo("vgId:%d, write-queue:%p is alloced, thread:%08" PRId64, pVnode->vgId, pVnode->pWriteW.queue,	40✔
460	taosQueueGetThreadId(pVnode->pWriteW.queue));
461	dInfo("vgId:%d, sync-queue:%p is alloced, thread:%08" PRId64, pVnode->vgId, pVnode->pSyncW.queue,	40✔
462	taosQueueGetThreadId(pVnode->pSyncW.queue));
463	dInfo("vgId:%d, sync-rd-queue:%p is alloced, thread:%08" PRId64, pVnode->vgId, pVnode->pSyncRdW.queue,	40✔
464	taosQueueGetThreadId(pVnode->pSyncRdW.queue));
465	dInfo("vgId:%d, apply-queue:%p is alloced, thread:%08" PRId64, pVnode->vgId, pVnode->pApplyW.queue,	40✔
466	taosQueueGetThreadId(pVnode->pApplyW.queue));
467	dInfo("vgId:%d, query-queue:%p is alloced", pVnode->vgId, pVnode->pQueryQ);	40✔
468	dInfo("vgId:%d, stream-reader-queue:%p is alloced", pVnode->vgId, pVnode->pStreamReaderQ);	40✔
469	dInfo("vgId:%d, fetch-queue:%p is alloced, thread:%08" PRId64, pVnode->vgId, pVnode->pFetchQ,	40✔
470	taosQueueGetThreadId(pVnode->pFetchQ));
471	return 0;	40✔
472	}
473
474	void vmFreeQueue(SVnodeMgmt pMgmt, SVnodeObj pVnode) {	40✔
475	tQueryAutoQWorkerFreeQueue(&pMgmt->queryPool, pVnode->pQueryQ);	40✔
476	tQueryAutoQWorkerFreeQueue(&pMgmt->streamReaderPool, pVnode->pStreamReaderQ);	40✔
477	tWWorkerFreeQueue(&pMgmt->fetchPool, pVnode->pFetchQ);	40✔
478
479	pVnode->pQueryQ = NULL;	40✔
480	pVnode->pFetchQ = NULL;	40✔
481	pVnode->pStreamReaderQ = NULL;	40✔
482	dDebug("vgId:%d, queue is freed", pVnode->vgId);	40✔
483	}	40✔
484
485	int32_t vmStartWorker(SVnodeMgmt *pMgmt) {	16✔
486	int32_t code = 0;	16✔
487
488	SQueryAutoQWorkerPool *pQPool = &pMgmt->queryPool;	16✔
489	pQPool->name = "vnode-query";	16✔
490	pQPool->min = tsNumOfVnodeQueryThreads;	16✔
491	pQPool->max = tsNumOfVnodeQueryThreads;	16✔
492	if ((code = tQueryAutoQWorkerInit(pQPool)) != 0) return code;	16✔
493
494	SQueryAutoQWorkerPool *pSPool = &pMgmt->streamReaderPool;	16✔
495	pSPool->name = "vnode-st-reader";	16✔
496	pSPool->min = tsNumOfVnodeStreamReaderThreads;	16✔
497	pSPool->max = tsNumOfVnodeStreamReaderThreads;	16✔
498	if ((code = tQueryAutoQWorkerInit(pSPool)) != 0) return code;	16✔
499
500	tsNumOfQueryThreads += tsNumOfVnodeQueryThreads;	16✔
501
502	SWWorkerPool *pFPool = &pMgmt->fetchPool;	16✔
503	pFPool->name = "vnode-fetch";	16✔
504	pFPool->max = tsNumOfVnodeFetchThreads;	16✔
505	if ((code = tWWorkerInit(pFPool)) != 0) return code;	16✔
506
507	SSingleWorkerCfg mgmtCfg = {	16✔
508	.min = 1, .max = 1, .name = "vnode-mgmt", .fp = (FItem)vmProcessMgmtQueue, .param = pMgmt};
509
510	if ((code = tSingleWorkerInit(&pMgmt->mgmtWorker, &mgmtCfg)) != 0) return code;	16✔
511
512	int32_t threadNum = 0;	16✔
513	if (tsNumOfCores == 1) {	16✔
514	threadNum = 2;	×
515	} else {
516	threadNum = tsNumOfCores;	16✔
517	}
518	SSingleWorkerCfg multiMgmtCfg = {.min = threadNum,	16✔
519	.max = threadNum,
520	.name = "vnode-multi-mgmt",
521	.fp = (FItem)vmProcessMultiMgmtQueue,
522	.param = pMgmt};
523
524	if ((code = tSingleWorkerInit(&pMgmt->mgmtMultiWorker, &multiMgmtCfg)) != 0) return code;	16✔
525	dDebug("vnode workers are initialized");	16✔
526	return 0;	16✔
527	}
528
529	void vmStopWorker(SVnodeMgmt *pMgmt) {	16✔
530	tQueryAutoQWorkerCleanup(&pMgmt->queryPool);	16✔
531	tWWorkerCleanup(&pMgmt->fetchPool);	16✔
532	tQueryAutoQWorkerCleanup(&pMgmt->streamReaderPool);	16✔
533	dDebug("vnode workers are closed");	16✔
534	}	16✔

taosdata / TDengine / #4986

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous