path: root/task_manager/server/src/tskm_svc.cpp

/*
 * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "system_service/tskm_svc.h"
#include <string.h>
#include <stdlib.h>
#include <sys/inotify.h>
#include <errno.h>

#include <native_service/ns_np_service_if.h>
#include <string>

#include "tskm_debug.h"
#include "tskm_util.h"
#include "tskm_port_pf.h"
#include "tskm_port_subsys.h"
#include "tskm_comm.h"


/*********************************************************
 *       Is the target event of the service handler?

 *********************************************************/
TSKM_STATIC TSKM_BOOL_t isSvcEvent(const TSKM_EVENT_INFO_t* p_ev) {
  switch (p_ev->event) {
    case TSKM_EV_PRI_REP_CONNECT:
    case TSKM_EV_PRI_REP_DISCONNECT:
    case TSKM_EV_PRI_RES_WAKEUP:
    case TSKM_EV_PRI_RES_DOWN:
    case TSKM_EV_PRI_RES_DEBUGDUMP:
    case TSKM_EV_PRI_REQ_EXIT:
    case TSKM_EV_SVC_REP_TERM:
      return TSKM_TRUE;
      break;
    default:
      break;
  }
  return TSKM_FALSE;
}

/*********************************************************
 *       Get service context
 *********************************************************/
TSKM_STATIC TSKM_SVC_CTX_t*
getSvcCtxBySvcId(TSKM_SVCS_CTX_t* p_svcs, TSKM_SVCID_t svcId) {
  uint32_t ii;

  for (ii = 0; ii < p_svcs->svcNum; ii++) {
    if (p_svcs->svcList[ii].attr->svcId == svcId) {
      return &p_svcs->svcList[ii];
    }
  }
  TSKM_ASSERT(0);
  return NULL;
}

/*********************************************************
 *       Get service context
 *********************************************************/
TSKM_STATIC TSKM_SVC_CTX_t*
getSvcCtxByPid(TSKM_SVCS_CTX_t* p_svcs, pid_t pid) {
  uint32_t ii;

  for (ii = 0; ii < p_svcs->svcNum; ii++) {
    if (p_svcs->svcList[ii].pid == pid) {
      return &p_svcs->svcList[ii];
    }
  }
  return NULL;
}

/*********************************************************
 *       Get service context
 *********************************************************/
TSKM_STATIC TSKM_SVC_CTX_t*
getSvcCtxByName(TSKM_SVCS_CTX_t* p_svcs, const char *p_name) {  // LCOV_EXCL_START 6: Because the condition cannot be set
  AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
  uint32_t ii;

  for (ii = 0; ii < p_svcs->svcNum; ii++) {
    if (0
        == strncmp(p_svcs->svcList[ii].attr->name, p_name,
                   strlen(p_svcs->svcList[ii].attr->name))) {
      return &p_svcs->svcList[ii];
    }
  }
  return NULL;
}
// LCOV_EXCL_STOP
/*********************************************************
 *      Issuing a start request to the service
 *********************************************************/
TSKM_STATIC TSKM_ERR_t wakeupRequest(TSKM_SVC_CTX_t* p_svc,
                                     TSKM_GSTEP_REQ_INFO_t* p_req) {
  TSKM_EVENT_INFO_t ev;
  int ret;
  bzero(&ev, sizeof(ev));

  ev.event = TSKM_EV_PRI_REQ_WAKEUP;
  ev.errCode = TSKM_E_OK;
  ev.prm.reqWakeup.svcId = p_svc->attr->svcId;
  ev.prm.reqWakeup.localStep = p_req->localStep;
  ev.prm.reqWakeup.isDynamic =
      (p_svc->attr->lifeCycle == TSKM_SVC_LC_DYNAMIC) ? TSKM_TRUE : TSKM_FALSE;
  // Since there is no startup in the P_CWORD72_ but only communication in the ALL/LAST,
  // the startup information is optimized including the startup information in the communication of the WakeupRequest.
  memcpy(&ev.prm.reqWakeup.bootInfo, &p_svc->bootInfo,
         sizeof(ev.prm.reqWakeup.bootInfo));
  memcpy(&ev.prm.reqWakeup.extBootInfo, &p_svc->extBootInfo,
         sizeof(ev.prm.reqWakeup.extBootInfo));

  ret = tskm_sockSend(p_svc->connFd, &ev);
  if (ret <= 0) {
    TSKM_ASSERT(0);
    goto ERROR;
  }
  p_svc->waitResCnt++;
  p_svc->state = TSKM_SVC_WAKEUP;

  return TSKM_E_OK;
  ERROR: return TSKM_E_NG;
}

/*********************************************************
 *       Touch services and extend EXIT timeouts
 *********************************************************/
TSKM_STATIC TSKM_ERR_t reqTouch(TSKM_SVC_CTX_t* p_svc) {
#define TSKM_BUF_LEN     ( 4 * ( sizeof(struct inotify_event) ) )  /* read size */
  TSKM_ERR_t funcRet = TSKM_E_NG;
  char touchFileName[32];
  BOOL isNeedRetry = FALSE;

  int iFd = p_svc->iFd;
  int wd = 0;

  TSKM_EVENT_INFO_t ev;
  int ret;
  bzero(&ev, sizeof(ev));

  // Create monitoring files
  tskm_pf_mkTouchFileName(p_svc->pid, touchFileName);
  if (0 != tskm_pf_touch(touchFileName)) {
    goto ERROR;
  }

  // Synchronize by iNortify
  wd = inotify_add_watch(iFd, touchFileName, IN_DELETE_SELF);
  if (wd == -1) {
    TSKM_ASSERT_ERRNO(0);
    goto ERROR;
  }

  // Send Touch request
  ev.event = TSKM_EV_PRI_REQ_TOUCH;
  ev.errCode = TSKM_E_OK;
  ret = tskm_sockSend(p_svc->connFd, &ev);
  if (ret <= 0) {
    // Immediately after the nonresident service process terminates, since the TaskManager service status is other than DORMANT
    // (mainly DOWN), the socket may be discarded and communication may fail, so retry
    funcRet = TSKM_E_RETRY;
    TSKM_PRINTF(TSKM_LOG_WARN, "ret = %d", ret);
    goto ERROR;
  }

  // Wait for Touch completion
  while (1) {
    int maxFd = 0;
    int ret;
    fd_set fds;
    FD_ZERO(&fds);
    struct timeval timeout = { 0 };
    timeout.tv_sec = TSKM_CFG_TOUCH_TIMEOUT;

    FD_SET(iFd, &fds);
    maxFd = iFd;

    ret = select(maxFd + 1, &fds, NULL, NULL, &timeout);
    if (ret == 0) {
      TSKM_ASSERT_PRINT(0, "TIMEOUT:%s", touchFileName);  // Timeout occurs
      isNeedRetry = TRUE;
      break;
    } else if (ret < 1) {
      if (errno == EINTR) {
        continue;
      } else {
        TSKM_ASSERT(0);
        goto ERROR;
      }
    }

    if (FD_ISSET(iFd, &fds)) {
      int length;
      uint8_t buf[TSKM_BUF_LEN];

      length = static_cast<int>(read(iFd, buf, TSKM_BUF_LEN));
      if (length < 0) {
        TSKM_ASSERT_ERRNO(0);
        goto ERROR;
      }
      struct inotify_event *event = (struct inotify_event *) buf;
      if (event->mask & IN_DELETE_SELF) {
        TSKM_PRINTF(TSKM_LOG_STATE, "TouchOK");
        wd = 0;
        // When a file is deleted, the association with the monitoring target is automatically released and inotify_rm_watch is no longer needed.
        break;
      } else {
        TSKM_ASSERT_PRINT(0, "%x", event->mask);
      }
    }
  }

  if (isNeedRetry) {
    funcRet = TSKM_E_RETRY;
  } else {
    funcRet = TSKM_E_OK;
  }

  ERROR: if (wd > 0) {
    TSKM_ASSERT_ERRNO(0 == inotify_rm_watch(iFd, wd))
  }

  if (access(touchFileName, F_OK) == 0) {
    // Timeout care
    unlink(touchFileName);
  }

  return funcRet;
}

/*********************************************************
 *       Availability Monitoring Callbacks for Services
 *********************************************************/
EFrameworkunifiedStatus OnSvcAvailability(HANDLE hApp) {  // LCOV_EXCL_START 6: Because the condition cannot be set
  AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
  PCSTR availabilityName;
  TSKM_MAIN_CTX_t* p_main = tskm_getMainCtx();
  TSKM_SVC_CTX_t* p_svc;

  availabilityName = FrameworkunifiedGetLastNotification(hApp);

  std::string str = availabilityName;

//  unsigned int position;
//  if (std::string::npos != (position = static_cast<unsigned int>(str.find("/Availability", 0)))) {
  ssize_t position;
  if (0 <= (position = str.find("/Availability", 0))) {
    str.erase(position, position + strlen("/Availability"));
  }

  p_svc = getSvcCtxByName(&p_main->svcs, str.c_str());
  if (p_svc) {
    p_svc->isAvailable = FrameworkunifiedIsServiceAvailable(hApp) ? TSKM_TRUE : TSKM_FALSE;
    TSKM_PRINTF(TSKM_LOG_SVCSTATE, "%s Availability %s", p_svc->attr->name,
                (p_svc->isAvailable == TSKM_TRUE) ? "TRUE" : "FALSE");
  }

  return eFrameworkunifiedStatusOK;
}
// LCOV_EXCL_STOP
/*********************************************************
 *       Starting Availability Monitoring of Services
 *********************************************************/
TSKM_STATIC TSKM_ERR_t startWatchAvailability(TSKM_SVC_CTX_t* p_svc) {
  TSKM_ERR_t funcRet = TSKM_E_OK;

  // LCOV_EXCL_BR_START 8: Since the condition is checked by the caller, it is not true.
  if (p_svc->attr->type == TSKM_SVC_TYPE_UNKNONW) {
  // LCOV_EXCL_BR_STOP
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    p_svc->isAvailable = TSKM_TRUE;  // LCOV_EXCL_LINE 8: Since the condition is checked by the caller, it is not true.
  } else {
    EFrameworkunifiedStatus taskmanagerStatus;
    TSKM_MAIN_CTX_t* p_main = tskm_getMainCtx();
    SS_String availabilityName = p_svc->attr->name;

    availabilityName.append("/Availability");

    taskmanagerStatus = FrameworkunifiedSubscribeNotificationWithCallback(p_main->hApp,
                                                     availabilityName.c_str(),
                                                     OnSvcAvailability);
    if (eFrameworkunifiedStatusOK != taskmanagerStatus) {
      TSKM_ASSERT(0);
      funcRet = TSKM_E_NG;
    }
  }

  return funcRet;
}

/*********************************************************
 *       Service startup sub
 *********************************************************/
void svcExec_Process(TSKM_SVC_CTX_t* p_svc) {
  TSKM_ERR_t funcRet;

  if (p_svc->attr->type == TSKM_SVC_TYPE_NATIVE) {
    p_svc->state = TSKM_SVC_WAITCONNECT;
    TSKM_PRINTF(TSKM_LOG_DEBUG, "[ST:%d] WAIT_EXEC", p_svc->pid);
    funcRet = startWatchAvailability(p_svc);
    if (TSKM_E_OK != funcRet) {
      TSKM_ASSERT(0);
      p_svc->isAvailable = TSKM_TRUE;
    }
  } else {
    p_svc->state = TSKM_SVC_RUNNING;
    TSKM_PRINTF(TSKM_LOG_SVCSTATE, "[ST:%d] RUN", p_svc->pid);
    p_svc->isAvailable = TSKM_TRUE;
  }
  return;
}

/*********************************************************
 *       Service startup main
 *********************************************************/
TSKM_STATIC TSKM_ERR_t svcExec(TSKM_SVC_CTX_t* p_svc) {
  TSKM_ERR_t funcRet = TSKM_E_NG;
  pid_t pid;

  if (p_svc == NULL) {  // LCOV_EXCL_BR_LINE 6:double check
    // LCOV_EXCL_START 6: double check
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    TSKM_ASSERT(0);
    goto ERROR;
    // LCOV_EXCL_STOP
  }

  if (p_svc->state == TSKM_SVC_DISABLE) {
    // Prohibited startup
    TSKM_ASSERT(0);
    return TSKM_E_STATE;
  } else if (p_svc->state == TSKM_SVC_WAITCONNECT) {
    return TSKM_E_OK;
  } else if (p_svc->state != TSKM_SVC_DORMANT) {
    // Already started
    funcRet = reqTouch(p_svc);
    if (TSKM_E_OK != funcRet) {
      TSKM_PRINTF(TSKM_LOG_WARN, "funcRet = %d", funcRet);
      goto ERROR;
    }
    return TSKM_E_OK;
  }

  pid = tskm_pf_createProc(p_svc->attr);
  if (pid <= 0) {
    TSKM_ASSERT(0);
    goto ERROR;
  }
  TSKM_PRINTF(TSKM_LOG_STATE, "EXEC %s:%d", p_svc->attr->name, pid);

  p_svc->pid = pid;
  p_svc->waitReqCnt = 0;

  // Startup service
  svcExec_Process(p_svc);

  funcRet = TSKM_E_OK;
  ERROR: return funcRet;
}

/*********************************************************
 *       Issuing a start request to the service
 *********************************************************/
TSKM_STATIC TSKM_ERR_t svcWakeupRequest(TSKM_SVC_CTX_t* p_svc,
                                        TSKM_GSTEP_REQ_INFO_t* p_req) {
  if (p_svc == NULL || p_svc->state == TSKM_SVC_DISABLE) {  // LCOV_EXCL_BR_LINE 6: Since this function has always been called after checking // NOLINT(whitespace/line_length)
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    return TSKM_E_STATE;  // LCOV_EXCL_LINE 6: Since this function has always been called after checking
  } else if (p_svc->state == TSKM_SVC_WAITCONNECT) {
    // Remember it once and issue a request when the CONNECT completes.
    p_svc->request[p_svc->waitReqCnt] = *p_req;
    p_svc->waitReqCnt++;
  } else {
    TSKM_ERR_t tskmRet;
    tskmRet = wakeupRequest(p_svc, p_req);
    TSKM_ERR_CHK_DFT;
  }

  return TSKM_E_OK;
  ERROR: return TSKM_E_NG;
}

/*********************************************************
 *      Service reboot processing
 *********************************************************/
TSKM_STATIC TSKM_ERR_t svcErrTermPost(TSKM_SVC_CTX_t* p_svc) {
  TSKM_MAIN_CTX_t* p_main = tskm_getMainCtx();

  TSKM_PRINTF(TSKM_LOG_SYSTEMDATA, "ERR TERM SVC(%s:%d)", p_svc->attr->name,
              p_svc->pid);

  if (p_svc->attr->lifeCycle == TSKM_SVC_LC_ALWAYS || (p_svc->errTermCnt > p_svc->attr->retryCnt && (uint32_t) -1 != p_svc->attr->retryCnt)) {  // NOLINT(whitespace/line_length)
    TSKM_ERROR_REBOOT_t rebootInfo;

    TSKM_ASSERT(0);
    memset(&rebootInfo, 0, sizeof(TSKM_ERROR_REBOOT_t));
    rebootInfo.type = TSKM_ERROR_REBOOT_NORMAL;
    snprintf(rebootInfo.log.messageStr, TSKM_LOGGING_MSG_STR_SIZE,
             "TaskManager:SVC ErrTerm");
    tskm_sub_reboot(&rebootInfo);
  } else {
    TSKM_LOGGING_INFO_t logInfo;
    logInfo.type = TSKM_LOGGING_TYPE_MODULE_LOGS;

    snprintf(logInfo.messageStr, TSKM_LOGGING_MSG_STR_SIZE,
             "TaskManager:SVC ErrTerm");
    tskm_sub_logging(&logInfo);

    if (p_svc->attr->lifeCycle == TSKM_SVC_LC_ALWAYS_RECOVERABLE) {
      TSKM_ERR_t ret;
      TSKM_GSTEP_REQ_INFO_t req = { 0 };

      ret = svcExec(p_svc);

      if (TSKM_E_OK != ret) {
        TSKM_ASSERT_PRINT(0, "ret = %d", ret);
        goto ERROR;
      } else if (p_svc->state == TSKM_SVC_WAITCONNECT) {
        // In the state waiting for execution
        req.svcId = p_svc->attr->svcId;
        req.localStep = TSKM_LSTEP_ALL;
        ret = svcWakeupRequest(p_svc, &req);
        if (TSKM_E_OK != ret) {
          TSKM_ASSERT_PRINT(0, "ret = %d", ret);
          goto ERROR;
        }
      }
    }
  }

  return TSKM_E_OK;
  ERROR: return TSKM_E_NG;
}

/*********************************************************
 *      Connection handler
 * ret:TRUE     SVC status changed
 * ret:FALSE    SVC status not changed
 *********************************************************/
TSKM_STATIC TSKM_BOOL_t connectHandle(TSKM_SVC_CTX_t* p_svc,
                                      const TSKM_EVENT_INFO_t* p_inEv) {
  uint32_t ii;

  TSKM_ASSERT(p_svc->state == TSKM_SVC_WAITCONNECT);

  p_svc->connFd = p_inEv->prm.repConnect.connFd;
  p_svc->state = TSKM_SVC_WAKEUP;
  TSKM_PRINTF(TSKM_LOG_DEBUG, "[ST:%d] WAKEUP", p_svc->pid);

  p_svc->waitResCnt = 0;

  if (p_svc->waitReqCnt) {
    for (ii = 0; ii < p_svc->waitReqCnt; ii++) {
      TSKM_ASSERT(TSKM_E_OK == wakeupRequest(p_svc, &p_svc->request[ii]));
    }
    p_svc->waitReqCnt = 0;
  }

  return TSKM_TRUE;
}

/*********************************************************
 *      Disconnection handler
 * ret:TRUE     SVC status changed
 * ret:FALSE    SVC status not changed
 *********************************************************/
TSKM_STATIC TSKM_BOOL_t disConnectHandle(TSKM_SVC_CTX_t* p_svc,
                                         const TSKM_EVENT_INFO_t* p_inEv) {
  // No status change

  return TSKM_TRUE;
}

/*********************************************************
 *      Response handler for the activation request
 * ret:TRUE     SVC status changed
 * ret:FALSE    SVC status not changed
 *********************************************************/
TSKM_STATIC TSKM_BOOL_t resWakeupHandle(TSKM_SVC_CTX_t* p_svc,
                                        const TSKM_EVENT_INFO_t* p_inEv) {
  TSKM_ASSERT(p_svc->state == TSKM_SVC_WAKEUP);
  TSKM_ASSERT(p_svc->waitResCnt > 0);
  TSKM_BOOL_t isStateChg = TSKM_FALSE;

  if (p_svc->isShmDone == TSKM_FALSE && p_inEv->prm.resWakeup.isShmDone) {
    p_svc->isShmDone = TSKM_TRUE;
    isStateChg = TSKM_TRUE;
    TSKM_PRINTF(TSKM_LOG_SVCSTATE, "%s:SHM DONE", p_svc->attr->name);
  }
  if (p_svc->isStepDone == TSKM_FALSE && p_inEv->prm.resWakeup.isStepDone) {
    p_svc->isStepDone = TSKM_TRUE;
    isStateChg = TSKM_TRUE;
    TSKM_PRINTF(TSKM_LOG_SVCSTATE, "%s:STEP DONE", p_svc->attr->name);
  }

  if (p_svc->waitResCnt > 0) {
    p_svc->waitResCnt--;
    if (p_svc->waitResCnt == 0) {  // Transition when the wait runs out
      if (p_inEv->prm.resWakeup.isLast) {
        p_svc->state = TSKM_SVC_RUNNING;  // Startup completed
        TSKM_PRINTF(TSKM_LOG_SVCSTATE, "[ST:%d] RUN", p_svc->pid);
      }
      isStateChg = TSKM_TRUE;
    }
  }
  return isStateChg;
}

/*********************************************************
 *      Response handler for the termination request
 * ret:TRUE     SVC state changed
 * ret:FALSE    SVC state not changed
 *********************************************************/
TSKM_STATIC TSKM_BOOL_t resDownHandle(TSKM_SVC_CTX_t* p_svc,
                                      const TSKM_EVENT_INFO_t* p_inEv) {
  TSKM_ASSERT(p_svc->state == TSKM_SVC_DOWN);
  TSKM_ASSERT(p_svc->waitResCnt > 0);
  TSKM_BOOL_t isStateChg = TSKM_FALSE;

  TSKM_PRINTF(TSKM_LOG_DEBUG, "pid:%d waitCnt:%d", p_svc->pid,
              p_svc->waitResCnt);
  if (p_svc->waitResCnt > 0) {
    p_svc->waitResCnt--;
    if (p_svc->waitResCnt == 0) {  // Transition when the wait runs out
      if (p_inEv->prm.resWakeup.isLast) {
        p_svc->state = TSKM_SVC_FINDOWN;   // Termination complete
        TSKM_PRINTF(TSKM_LOG_SVCSTATE, "[ST:%d] FIN_DOWN", p_svc->pid);
      }
      isStateChg = TSKM_TRUE;
    }
  }
  return isStateChg;
}

/*********************************************************
 *      Response Handlers for DebugDump Requests
 * ret:TRUE     SVC state changed
 * ret:FALSE    SVC state not changed
 *********************************************************/
TSKM_STATIC TSKM_BOOL_t resDebugDumpHandle(TSKM_SVC_CTX_t* p_svc,
                                           const TSKM_EVENT_INFO_t* p_inEv) {
  TSKM_BOOL_t isStateChg = TSKM_FALSE;
  TSKM_EV_PRI_EX_RES_DEBUGDUMP_PRM_t *p_prm;

  if (!p_inEv->hasExtend || !p_inEv->extendPrm) {
    TSKM_ASSERT(0);
    goto ERROR;
  }

  p_prm = (TSKM_EV_PRI_EX_RES_DEBUGDUMP_PRM_t *) p_inEv->extendPrm;  // NOLINT (readability/casting)

  // FALSE is specified here because the required service names have been added in the PrimaryLib.
  tskm_sub_debugDumpRes(FALSE, p_prm->dumpMsg);

  ERROR: return isStateChg;
}

/*********************************************************
 *      Service termination request
 * ret:TRUE     SVC state changed
 * ret:FALSE    SVC state not changed
 *********************************************************/
TSKM_STATIC TSKM_BOOL_t reqExit(TSKM_SVC_CTX_t* p_svc,
                                const TSKM_EVENT_INFO_t* p_inEv) {
  int ret;
  TSKM_ERR_t tskmRet;
  TSKM_ASSERT(p_svc->state == TSKM_SVC_RUNNING);
  TSKM_ASSERT(p_svc->waitResCnt == 0);
  TSKM_GSTEP_REQ_INFO_t req = { 0 };

  req.svcId = p_svc->attr->svcId;
  req.localStep = TSKM_LSTEP_ALL;
  tskmRet = tskm_svcDownRequest(p_svc, &req);
  TSKM_ERR_CHK_DFT;

  return TSKM_TRUE;

  // LCOV_EXCL_START 8: dead code
  AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
  ERROR: ret = tskm_pf_terminateProcGroup(static_cast<uint16_t>(p_svc->pid));
  if (ret != 0) {  // LCOV_EXCL_BR_LINE 8: dead code
    TSKM_PRINTF(TSKM_LOG_WARN, "ret = %d", ret);
  }

  return TSKM_TRUE;
  // LCOV_EXCL_STOP
}

/*********************************************************
 *      Service termination handler
 * ret:TRUE     SVC state changed
 * ret:FALSE    SVC state not changed
 *********************************************************/
TSKM_STATIC TSKM_BOOL_t repTermHandle(TSKM_SVC_CTX_t* p_svc,
                                      const TSKM_EVENT_INFO_t* p_inEv) {
  int ret;

  // Check error
  if (p_svc->attr->lifeCycle == TSKM_SVC_LC_DYNAMIC) {
    if (p_svc->state != TSKM_SVC_DOWN) {
      // A STATE other than DOWN does not terminate.
      TSKM_PRINTF(TSKM_LOG_ERROR, "ERR TERM %s(%d) waitCnt:%d",
                  p_svc->attr->name, p_svc->pid, p_svc->waitResCnt);
      TSKM_ASSERT(0);
    }
  } else {
    // The resident service terminated.
    TSKM_PRINTF(TSKM_LOG_ERROR, "ERR TERM %s(%d) waitCnt:%d", p_svc->attr->name,
                p_svc->pid, p_svc->waitResCnt);
    TSKM_ASSERT(0);
  }

  TSKM_PRINTF(TSKM_LOG_STATE, "[ST:%d] DORMANT", p_svc->pid);

  p_svc->state = TSKM_SVC_DORMANT;
  p_svc->waitResCnt = 0;
  p_svc->pid = 0;

  if (p_svc->attr->type == TSKM_SVC_TYPE_NATIVE) {
    EFrameworkunifiedStatus taskmanagerStatus;
    TSKM_MAIN_CTX_t* p_main = tskm_getMainCtx();
    SS_String availabilityName = p_svc->attr->name;
    availabilityName.append("/Availability");

    taskmanagerStatus = FrameworkunifiedUnsubscribeNotificationWithCallback(
        p_main->hApp, availabilityName.c_str());
    if (eFrameworkunifiedStatusOK != taskmanagerStatus) {
      TSKM_ASSERT(0);
    }

    p_svc->isAvailable = TSKM_FALSE;
    p_svc->watchCnt = 0;

    HANDLE hMq = McOpenSender(FRAMEWORKUNIFIED_NS_NPSERVICE);
    if (NULL == hMq) {   // LCOV_EXCL_BR_LINE 4: NSFW error case.
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      TSKM_ASSERT(0);  // LCOV_EXCL_LINE 4: NSFW error case.
    } else {
      ServiceAvailability availInfo = { };

      snprintf(availInfo.cServiceName, MAX_NAME_SIZE_APP, "%s",
               p_svc->attr->name);
      availInfo.eServiceAvailability = eFrameworkunifiedServiceNotAvailable;

      taskmanagerStatus = NPPublishNotification(hMq, p_svc->attr->name,
                                        availabilityName.c_str(), &availInfo,
                                        sizeof(availInfo));
      if (eFrameworkunifiedStatusOK != taskmanagerStatus) {
        TSKM_ASSERT(0);
      }

      taskmanagerStatus = McClose(hMq);
      if (eFrameworkunifiedStatusOK != taskmanagerStatus) {  // LCOV_EXCL_BR_LINE 4: NSFW error case.
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        TSKM_ASSERT(0);  // LCOV_EXCL_LINE 4: NSFW error case.
      }
    }
  }

  if (p_inEv->errCode != TSKM_E_OK) {
    p_svc->errTermCnt++;
    // Notify 'NG' at Relaunch after abnormal termination
    p_svc->bootInfo.resetStatus = e_SS_SM_RESET_STATUS_NG;

    ret = svcErrTermPost(p_svc);
    if (ret != TSKM_E_OK) {
      TSKM_ASSERT(0);
    }
  } else {
    // NONE is notified at Relaunch after normal completion.
    p_svc->bootInfo.resetStatus = e_SS_SM_RESET_STATUS_NONE;
  }

  return TSKM_TRUE;
}

/*********************************************************
 *       Get service context
 *********************************************************/
TSKM_SVC_CTX_t*
tskm_svcsGetSvcBySvcId(TSKM_SVCS_CTX_t* p_svcs, TSKM_SVCID_t svcId) {
  return getSvcCtxBySvcId(p_svcs, svcId);
}

/*********************************************************
 *       Get service context
 *********************************************************/
TSKM_SVC_CTX_t*
tskm_svcsGetSvcByPid(TSKM_SVCS_CTX_t* p_svcs, pid_t pid) {
  return getSvcCtxByPid(p_svcs, pid);
}

/*********************************************************
 *       Check for waiting services
 *********************************************************/
TSKM_BOOL_t tskm_svcsIsWaiting(TSKM_SVCS_CTX_t* p_svcs) {
  uint32_t ii;
  for (ii = 0; ii < p_svcs->svcNum; ii++) {
    if (p_svcs->svcList[ii].waitResCnt > 0
        || p_svcs->svcList[ii].state == TSKM_SVC_WAITCONNECT) {
      return TSKM_TRUE;
    }
  }
  return TSKM_FALSE;
}

/*********************************************************
 *       Check if ShutdownWait services are terminated
 *********************************************************/
TSKM_SVC_WAIT_STATE_t tskm_svcsGetSvcTermWaitState(TSKM_SVCS_CTX_t* p_svcs) {
  uint32_t ii;
  TSKM_SVC_WAIT_STATE_t waitState = TSKM_SVC_WAIT_NONE;

  for (ii = 0; ii < p_svcs->svcNum; ii++) {
    if (p_svcs->svcList[ii].attr->shotdownWait) {
      // Check shutdownWait SVC Only
      if (p_svcs->svcList[ii].state != TSKM_SVC_DORMANT) {
        // DORMANT is terminated or not started, so no checking is required
        if (TSKM_SVC_LC_DYNAMIC != p_svcs->svcList[ii].attr->lifeCycle
            && p_svcs->svcList[ii].state != TSKM_SVC_FINDOWN) {  // Check of termination of resident SVCs
          waitState = TSKM_SVC_WAIT_BOTH;
          break;
        } else if (TSKM_SVC_LC_DYNAMIC == p_svcs->svcList[ii].attr->lifeCycle) {  // Check of termination of non-resident SVCs
          waitState = TSKM_SVC_WAIT_TRANSIENT;
        }
      }
    }
  }
  return waitState;
}

/*********************************************************
 *       Update boot info of all services
 *********************************************************/
TSKM_ERR_t tskm_svcsSetBootInfo(TSKM_SVCS_CTX_t* p_svcs,
                                T_SS_SM_START_DataStructType* p_info,
                                T_SS_SM_START_ExtDataStructType *p_exInfo) {
  uint32_t ii = 0;

  for (ii = 0; ii < p_svcs->svcNum; ii++) {
    p_svcs->svcList[ii].bootInfo = *p_info;
    p_svcs->svcList[ii].extBootInfo = *p_exInfo;
  }
  return TSKM_E_OK;
}

/*********************************************************
 *       Terminates a running non-resident services
 *********************************************************/
TSKM_ERR_t tskm_svcsAvtiveSvcTerm(TSKM_SVCS_CTX_t* p_svcs) {
  uint32_t ii;

  for (ii = 0; ii < p_svcs->svcNum; ii++) {
    TSKM_SVC_CTX_t* p_svc = &p_svcs->svcList[ii];

    if (TSKM_SVC_LC_DYNAMIC == p_svc->attr->lifeCycle &&              // Non-resident SVC
        TSKM_SVC_RUNNING == p_svc->state && p_svc->waitResCnt == 0) {  // Running
      TSKM_ERR_t tskmRet;
      TSKM_GSTEP_REQ_INFO_t req = { 0 };

      req.svcId = p_svc->attr->svcId;
      req.localStep = TSKM_LSTEP_ALL;
      tskmRet = tskm_svcDownRequest(p_svc, &req);
      TSKM_ERR_CHK_DFT;
    }
  }

  return TSKM_E_OK;

  ERROR:
  return TSKM_E_NG;
}

/*********************************************************
 *   Calls back the DebugDump of the running services
 *********************************************************/
TSKM_ERR_t tskm_svcsCallDebugDump(TSKM_SVCS_CTX_t* p_svcs) {
  for (uint32_t ii = 0; ii < p_svcs->svcNum; ii++) {
    TSKM_SVC_CTX_t* p_svc = &p_svcs->svcList[ii];

    if (TSKM_SVC_RUNNING == p_svc->state) {  // Running
      TSKM_EVENT_INFO_t ev;
      bzero(&ev, sizeof(ev));

      // Send DebugDump request
      ev.event = TSKM_EV_PRI_REQ_DEBUGDUMP;
      ev.errCode = TSKM_E_OK;
      if (0 >= tskm_sockSend(p_svc->connFd, &ev)) {
        TSKM_ASSERT(0);
        goto ERROR;
      }
    }
  }

  return TSKM_E_OK;
  ERROR: return TSKM_E_NG;
}

/*********************************************************
 *   Calls back the LowMemory of the running services
 *********************************************************/
TSKM_ERR_t tskm_svcsCallLowMem(TSKM_SVCS_CTX_t* p_svcs) {
  for (uint32_t ii = 0; ii < p_svcs->svcNum; ii++) {
    TSKM_SVC_CTX_t* p_svc = &p_svcs->svcList[ii];
    if (TSKM_SVC_RUNNING == p_svc->state) {  // Running
      TSKM_EVENT_INFO_t ev;
      bzero(&ev, sizeof(ev));

      // Send LowMemory detection notification
      ev.event = TSKM_EV_PRI_REP_LOWMEM;
      ev.errCode = TSKM_E_OK;
      if (0 >= tskm_sockSend(p_svc->connFd, &ev)) {
        TSKM_ASSERT(0);
        goto ERROR;
      }
    }
  }

  return TSKM_E_OK;
  ERROR: return TSKM_E_NG;
}

/*********************************************************
 *      Event handler
 *********************************************************/
TSKM_ERR_t tskm_svcEventHandle(TSKM_SVC_CTX_t* p_svc, TSKM_EVENT_INFO_t* p_ev) {
  TSKM_FUNC_IN();
  TSKM_BOOL_t isStateChg = TSKM_FALSE;

  if (isSvcEvent(p_ev) == TSKM_FALSE) {
    // If it is not an event for the service, it will be sent as follows.
    TSKM_FUNC_OUT();
    return TSKM_E_OK;
  }

  switch (p_ev->event) {
    case TSKM_EV_PRI_REP_CONNECT:   // Connection Registration from Service
      isStateChg = connectHandle(p_svc, p_ev);
      break;
    case TSKM_EV_PRI_REP_DISCONNECT:   // Disconnection Registration from Service
      isStateChg = disConnectHandle(p_svc, p_ev);
      break;
    case TSKM_EV_PRI_RES_WAKEUP:    // Response to a startup request from a service
      isStateChg = resWakeupHandle(p_svc, p_ev);
      break;
    case TSKM_EV_PRI_RES_DOWN:
      isStateChg = resDownHandle(p_svc, p_ev);
      break;
    case TSKM_EV_PRI_RES_DEBUGDUMP:
      isStateChg = resDebugDumpHandle(p_svc, p_ev);
      break;
    case TSKM_EV_PRI_REQ_EXIT:
      isStateChg = reqExit(p_svc, p_ev);
      break;
    case TSKM_EV_SVC_REP_TERM:      // Service termination
      isStateChg = repTermHandle(p_svc, p_ev);
      break;
    default:
      break;
  }

  // Overwrite service state change
  if (isStateChg) {
    p_ev->event = TSKM_EV_LCL_CHG_SVC_STATE;
    p_ev->prm.chgSvc.svcId = p_svc->attr->svcId;
  } else {
    p_ev->event = TSKM_EV_NOP;
  }

  TSKM_FUNC_OUT();
  return TSKM_E_OK;
}
/*********************************************************
 *       Startup service
 *********************************************************/
TSKM_ERR_t tskm_svcExec(TSKM_SVC_CTX_t* p_svc) {
  return svcExec(p_svc);
}

/*********************************************************
 *       Issue a startup request to the service
 *********************************************************/
TSKM_ERR_t tskm_svcWakeupRequest(TSKM_SVC_CTX_t* p_svc,
                                 TSKM_GSTEP_REQ_INFO_t* p_req) {
  return svcWakeupRequest(p_svc, p_req);
}

/*********************************************************
 *       Issue a termination request to the service
 *********************************************************/
TSKM_ERR_t tskm_svcDownRequest(TSKM_SVC_CTX_t* p_svc,
                               TSKM_GSTEP_REQ_INFO_t* p_req) {
  int ret;
  TSKM_EVENT_INFO_t ev;

  bzero(&ev, sizeof(ev));

  if (tskm_svcIsCommunicatable(p_svc) == TSKM_FALSE) {
    return TSKM_E_OK;
  }

  ev.event = TSKM_EV_PRI_REQ_DOWN;
  ev.errCode = TSKM_E_OK;
  ev.prm.reqDown.localStep = p_req->localStep;

  ret = tskm_sockSend(p_svc->connFd, &ev);
  if (ret <= 0) {
    TSKM_ASSERT(0);
    goto ERROR;
  }
  p_svc->waitResCnt++;
  p_svc->state = TSKM_SVC_DOWN;

  return TSKM_E_OK;
  ERROR: return TSKM_E_NG;
}

/*********************************************************
 *       Prohibit starting service
 *********************************************************/
TSKM_ERR_t tskm_svcDisableRequest(TSKM_SVC_CTX_t* p_svc) {
  if (p_svc->state == TSKM_SVC_DORMANT || p_svc->state == TSKM_SVC_DISABLE) {
    p_svc->state = TSKM_SVC_DISABLE;
    return TSKM_E_OK;
  }
  return TSKM_E_STATE;
}

/*********************************************************
 *       Allow starting service
 *********************************************************/
TSKM_ERR_t tskm_svcEnableRequest(TSKM_SVC_CTX_t* p_svc) {
  if (p_svc->state == TSKM_SVC_DISABLE) {
    p_svc->state = TSKM_SVC_DORMANT;
  }
  return TSKM_E_OK;
}

/*********************************************************
 *      Queriy whether the service is ready for communication
 *********************************************************/
TSKM_BOOL_t tskm_svcIsCommunicatable(TSKM_SVC_CTX_t* p_svc) {
  TSKM_BOOL_t ret = TSKM_FALSE;
  if (p_svc == NULL || p_svc->attr->type == TSKM_SVC_TYPE_UNKNONW) {
  } else {
    switch (p_svc->state) {
      case TSKM_SVC_WAKEUP:
      case TSKM_SVC_RUNNING:
      case TSKM_SVC_DOWN:
        ret = TSKM_TRUE;
        break;
      default:
        break;
    }
  }
  return ret;
}  // LCOV_EXCL_BR_LINE 10: Final line