--- /dev/null
+/*
+ * @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 "tskm_main.h"
+#include <stdio.h>
+#include <string.h>
+#include <sys/select.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <errno.h>
+#include <sys/inotify.h>
+#include <getopt.h>
+#include <system_service/ss_services.h>
+#include <native_service/ns_version_if.h>
+#include <native_service/ns_np_service_protocol.h>
+#include <system_service/ss_system_if.h>
+#include <system_service/ss_version.h>
+#include <system_service/ss_templates.h>
+#include <native_service/frameworkunified_dispatcher.h>
+#include <other_service/rpc.h>
+#include <system_service/resm.h>
+
+#include "tskm_data_init_local.h"
+#include "tskm_port_pf.h"
+#include "tskm_port_subsys.h"
+#include "tskm_debug.h"
+#include "tskm_util.h"
+#include "tskm_srvr.h"
+#include "tskm_comm.h"
+#include "tskm_watch.h"
+#include "system_service/tskm_local_type.h"
+#include "system_service/tskm_xml_data.h"
+#include "tskm_state.h"
+
+#define TSKM_DATA_KEY "TSKM_KEY"
+
+TSKM_STATIC TSKM_MAIN_CTX_t g_mainCtx; // Main context
+
+TSKM_STATIC BOOL s_isVupMode = FALSE;
+
+CFrameworkunifiedVersion g_FrameworkunifiedVersion(MAJORNO, MINORNO, REVISION);
+
+// For NsLog
+FRAMEWORKUNIFIEDLOGPARAM g_FrameworkunifiedLogParams = {
+FRAMEWORKUNIFIEDLOGOPTIONS, {
+ZONE_TEXT_10, ZONE_TEXT_11, ZONE_TEXT_12,
+ZONE_TEXT_13, ZONE_TEXT_14, ZONE_TEXT_15,
+ZONE_TEXT_16, ZONE_TEXT_17, ZONE_TEXT_18,
+ZONE_TEXT_19, ZONE_TEXT_20, ZONE_TEXT_21,
+ZONE_TEXT_22, ZONE_TEXT_23, ZONE_TEXT_24,
+ZONE_TEXT_25, ZONE_TEXT_26, ZONE_TEXT_27,
+ZONE_TEXT_28, ZONE_TEXT_29, ZONE_TEXT_30,
+ZONE_TEXT_31 }, FRAMEWORKUNIFIEDLOGZONES };
+
+EFrameworkunifiedStatus OnFinishLoadFile(HANDLE hApp) { // LCOV_EXCL_START 6: Because the condition cannot be set
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+
+ int ret;
+ TSKM_MAIN_CTX_t* p_main = &g_mainCtx;
+ TSKM_EVENT_INFO_t ev;
+
+ ret = tskm_pf_nvFileRead(hApp, &p_main->nvInfo);
+ if (ret != 0) {
+ TSKM_ASSERT(0);
+ }
+
+ // issure INI_INITCOMP_NVM_ACCESS
+ bzero(&ev, sizeof(ev));
+ ev.event = TSKM_EV_PRI_REP_WAKEUP_COMP;
+ ev.errCode = TSKM_E_OK;
+ ev.prm.repWakeupComp.compId = INI_INITCOMP_NVM_ACCESS;
+ tskm_handleEvent(p_main, &ev);
+
+ return l_eStatus;
+}
+// LCOV_EXCL_STOP
+
+EFrameworkunifiedStatus onDataInitRequest(HANDLE hApp) {
+ TSKM_ERR_t l_tskmRet = TSKM_E_OK;
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+ TSKM_MAIN_CTX_t* p_main = tskm_getMainCtx();
+
+ TSKM_PRINTF(TSKM_LOG_API, "%s()", __FUNCTION__)
+
+ if (p_main->bootInfo.startupReason == epswfINVALID) {
+ // Before issuing FrameworkunifiedOnStart = Requests before TaskManager became Availabile are not accepted
+ TSKM_ASSERT(0);
+ l_tskmRet = TSKM_E_STATE;
+ } else {
+ T_SS_SM_START_DataStructType bootInfo(epswfIGN_ACC, TRUE,
+ e_SS_SM_DATA_RESET_MODE_USER,
+ epsssUNLOCK, epsstWARMSTART,
+ e_SS_SM_DRAM_BACKUP_OK,
+ e_SS_SM_RESET_STATUS_NONE, 0);
+
+ T_SS_SM_START_ExtDataStructType extBootInfo;
+
+ memcpy(&extBootInfo, &p_main->extBootInfo, sizeof(extBootInfo));
+
+ // After updating the program,
+ // FALSE is notified here because it is notified when data initialization I/F is called at startup
+ extBootInfo.isProgUpdated = FALSE;
+
+ tskm_dataInitAll(&bootInfo, &extBootInfo);
+ }
+
+ PCSTR l_senderName = FrameworkunifiedGetMsgSrc(hApp);
+ if (NULL != l_senderName) {
+ HANDLE hSession = FrameworkunifiedMcOpenSender(hApp, l_senderName);
+ if (hSession == NULL) {
+ TSKM_ASSERT(0);
+ } else {
+ TSKM_ASSERT(
+ eFrameworkunifiedStatusOK
+ == FrameworkunifiedSendMsg(hSession, TSKM_DATAINIT_RESP, sizeof(l_tskmRet),
+ &l_tskmRet));
+ TSKM_ASSERT(eFrameworkunifiedStatusOK == FrameworkunifiedMcClose(hSession));
+ }
+ }
+
+ return l_eStatus;
+}
+
+EFrameworkunifiedStatus onTransStepRequest(HANDLE hApp) { // LCOV_EXCL_START 6:Because the condition cannot be set
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ TSKM_MAIN_CTX_t* p_main = &g_mainCtx;
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+
+ TSKM_EVENT_INFO_t ev;
+ bzero(&ev, sizeof(ev));
+
+ ev.event = TSKM_EV_LCL_REQ_TRANS_STEP;
+ ev.errCode = TSKM_E_OK;
+ tskm_handleEvent(p_main, &ev);
+
+ return l_eStatus;
+}
+// LCOV_EXCL_STOP
+
+EFrameworkunifiedStatus OnResmAvailability(HANDLE hApp) { // LCOV_EXCL_START 6: Because the condition cannot be set
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ TSKM_MAIN_CTX_t* p_main = &g_mainCtx;
+
+ if (0 != strcmp(NTFY_ResourceMgr_Availability, FrameworkunifiedGetLastNotification(hApp))) {
+ TSKM_ASSERT(0);
+ } else if (FrameworkunifiedIsServiceAvailable(hApp)) {
+ // Availability = TRUE
+
+ p_main->resmFd = tskm_sub_resmInit();
+ if (-1 == p_main->resmFd) {
+ TSKM_ASSERT(0);
+ }
+ }
+ return eFrameworkunifiedStatusOK;
+}
+// LCOV_EXCL_STOP
+
+//************ NS Framework Callback : must implemet ******************
+EFrameworkunifiedStatus FrameworkunifiedOnInitialization(HANDLE hApp) {
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+ TSKM_PRINTF(TSKM_LOG_STATE, "+");
+
+ l_eStatus = FrameworkunifiedRegisterServiceAvailabilityNotification(hApp, NTFY_SS_TaskManager_Availability);
+ if (eFrameworkunifiedStatusOK != l_eStatus) {
+ TSKM_ASSERT(0);
+ }
+
+ l_eStatus = FrameworkunifiedPublishServiceAvailability(hApp, FALSE);
+ if (eFrameworkunifiedStatusOK != l_eStatus) {
+ TSKM_ASSERT(0);
+ }
+
+ l_eStatus = FrameworkunifiedAttachCallbackToDispatcher(hApp, FRAMEWORKUNIFIED_NS_NPSERVICE,
+ NPS_GET_PERS_FILE_ACK,
+ OnFinishLoadFile);
+ if (eFrameworkunifiedStatusOK != l_eStatus) {
+ TSKM_ASSERT(0);
+ }
+
+ l_eStatus = FrameworkunifiedAttachCallbackToDispatcher(hApp, FRAMEWORKUNIFIED_ANY_SOURCE,
+ TSKM_DATAINIT_REQ,
+ onDataInitRequest);
+ if (eFrameworkunifiedStatusOK != l_eStatus) {
+ TSKM_ASSERT(0);
+ }
+
+ l_eStatus = FrameworkunifiedAttachCallbackToDispatcher(hApp, FrameworkunifiedGetAppName(hApp),
+ TSKM_TRANS_STEP_REQ,
+ onTransStepRequest);
+ if (eFrameworkunifiedStatusOK != l_eStatus) {
+ TSKM_ASSERT(0);
+ }
+
+ l_eStatus = FrameworkunifiedSubscribeNotificationWithCallback(hApp, NTFY_ResourceMgr_Availability, OnResmAvailability);
+ if (eFrameworkunifiedStatusOK != l_eStatus) {
+ TSKM_ASSERT(0);
+ }
+
+ TSKM_PRINTF(TSKM_LOG_STATE, "-");
+
+ return l_eStatus;
+}
+
+EFrameworkunifiedStatus FrameworkunifiedOnStart(HANDLE hApp) {
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+ TSKM_PRINTF(TSKM_LOG_STATE, "+");
+ l_eStatus = OnStart(hApp);
+ TSKM_PRINTF(TSKM_LOG_STATE, "-");
+ return l_eStatus;
+}
+
+EFrameworkunifiedStatus FrameworkunifiedOnPreStart(HANDLE hApp) {
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+ TSKM_PRINTF(TSKM_LOG_STATE, "+");
+ l_eStatus = OnStart(hApp);
+ TSKM_PRINTF(TSKM_LOG_STATE, "-");
+ return l_eStatus;
+}
+
+EFrameworkunifiedStatus FrameworkunifiedOnBackgroundStart(HANDLE hApp) {
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+ TSKM_PRINTF(TSKM_LOG_STATE, "+");
+ l_eStatus = OnStart(hApp);
+ TSKM_PRINTF(TSKM_LOG_STATE, "-");
+ return l_eStatus;
+}
+
+EFrameworkunifiedStatus FrameworkunifiedOnStop(HANDLE hApp) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ TSKM_MAIN_CTX_t* p_main = &g_mainCtx;
+ // Returns Fail to send asynchronous STOP reply to SM
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusFail;
+
+ TSKM_EVENT_INFO_t ev;
+ bzero(&ev, sizeof(ev));
+
+ ev.event = TSKM_EV_LCL_REQ_STOP;
+ ev.errCode = TSKM_E_OK;
+ tskm_handleEvent(p_main, &ev);
+
+ p_main->isOnStopDone = TSKM_TRUE;
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+}
+
+EFrameworkunifiedStatus FrameworkunifiedOnPreStop(HANDLE hApp) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return eFrameworkunifiedStatusOK;
+}
+
+EFrameworkunifiedStatus FrameworkunifiedOnBackgroundStop(HANDLE hApp) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return eFrameworkunifiedStatusOK;
+}
+
+EFrameworkunifiedStatus FrameworkunifiedOnDestroy(HANDLE hApp) {
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+}
+
+EFrameworkunifiedStatus FrameworkunifiedOnDebugDump(HANDLE hApp) {
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ TSKM_MAIN_CTX_t* p_main = &g_mainCtx;
+ TSKM_ERR_t l_tskmRet;
+
+ // Call DebugDump of all running SVCs
+ l_tskmRet = tskm_svcsCallDebugDump(&p_main->svcs);
+ if (TSKM_E_OK != l_tskmRet) {
+ TSKM_ASSERT(0);
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+}
+
+EFrameworkunifiedStatus FrameworkunifiedCreateStateMachine(HANDLE hApp) { // LCOV_EXCL_START 6: Because the condition cannot be set
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+}
+// LCOV_EXCL_STOP
+
+/*********************************************************
+ * System start process
+ *********************************************************/
+EFrameworkunifiedStatus OnStart(const HANDLE hApp) {
+ TSKM_PRINTF(TSKM_LOG_STATE, "+");
+ TSKM_MAIN_CTX_t* const p_main = &g_mainCtx;
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+
+ if (p_main->isOnStartDone == TSKM_FALSE) {
+ T_SS_SM_START_DataStructType startupInfo;
+ TSKM_EVENT_INFO_t ev;
+ l_eStatus = ReadMsg<T_SS_SM_START_DataStructType>(hApp, startupInfo);
+ if (l_eStatus != eFrameworkunifiedStatusOK) {
+ TSKM_ASSERT(0);
+ } else {
+ memcpy(&p_main->bootInfo, &startupInfo, sizeof(T_SS_SM_START_DataStructType));
+ }
+
+ if (0 != tskm_sub_getExtBootInfo(&p_main->extBootInfo)) {
+ TSKM_ASSERT(0);
+ }
+
+ tskm_dataInitAll(&p_main->bootInfo, &p_main->extBootInfo);
+
+ tskm_svcsSetBootInfo(&p_main->svcs, &p_main->bootInfo, &p_main->extBootInfo);
+ p_main->isOnStartDone = TSKM_TRUE;
+
+ l_eStatus = FrameworkunifiedPublishServiceAvailability(hApp, TRUE);
+ if (l_eStatus != eFrameworkunifiedStatusOK) {
+ TSKM_ASSERT(0);
+ } else {
+ TSKM_PRINTF(TSKM_LOG_STATE, "Availability TRUE");
+ }
+
+ // Issure INI_INITCOMP_ON_START
+ bzero(&ev, sizeof(ev));
+ ev.event = TSKM_EV_PRI_REP_WAKEUP_COMP;
+ ev.errCode = TSKM_E_OK;
+ ev.prm.repWakeupComp.compId = INI_INITCOMP_ON_START;
+ tskm_handleEvent(p_main, &ev);
+ }
+
+ TSKM_PRINTF(TSKM_LOG_STATE, "-");
+ return l_eStatus;
+}
+
+/*********************************************************
+ * Argument analysis process
+ *********************************************************/
+TSKM_STATIC EFrameworkunifiedStatus argParser(SI_32 argument, PCHAR argumentValue) { // LCOV_EXCL_START 6: for process initialization processing
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ if ('v' == argument) {
+ s_isVupMode = TRUE;
+ }
+
+ return eFrameworkunifiedStatusOK;
+}
+// LCOV_EXCL_STOP
+/*********************************************************
+ * Creating process for TSKM internal context
+ *********************************************************/
+TSKM_STATIC void ctxCreate(TSKM_MAIN_CTX_t* p_main, int argc, char* argv[]) {
+ int ret;
+ EFrameworkunifiedStatus taskmanagerRet;
+ TSKM_ERR_t tskmRet;
+ FrameworkunifiedDefaultCallbackHandler cbFuncs;
+ FRAMEWORKUNIFIED_MAKE_DEFAULT_CALLBACK(cbFuncs);
+ CustomCommandLineOptions cmdLineOpt = { "v", NULL, argParser };
+
+ p_main->state = TSKM_ST_ACCOFF;
+ p_main->isOnStartDone = TSKM_FALSE;
+
+ // Create dispatcher
+ taskmanagerRet = FrameworkunifiedCreateDispatcherWithoutLoop(SS_TASK_MANAGER, p_main->hApp, argc,
+ argv, &cbFuncs, TRUE, &cmdLineOpt);
+ if (eFrameworkunifiedStatusOK != taskmanagerRet) { // LCOV_EXCL_BR_LINE 6: For process initialization processing
+ // LCOV_EXCL_START 6: For process initialization processing
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ TSKM_ASSERT_PRINT(0, "%d", taskmanagerRet);
+ goto ERROR;
+ // LCOV_EXCL_STOP
+ }
+
+ TSKM_PRINTF(TSKM_LOG_STATE, "s_isVupMode :%s", s_isVupMode ? "TRUE" : "FALSE");
+
+ taskmanagerRet = FrameworkunifiedGetDispatcherFD(p_main->hApp, &p_main->nsFd);
+ if (taskmanagerRet != eFrameworkunifiedStatusOK) { // LCOV_EXCL_BR_LINE 6: For process initialization processing
+ // LCOV_EXCL_START 6: For process initialization processing
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ TSKM_ASSERT_PRINT(0, "%d", taskmanagerRet);
+ exit(EXIT_FAILURE);
+ // LCOV_EXCL_STOP
+ }
+
+ p_main->sigFd = tskm_pf_sysInit(); // Platform initialization
+ if (p_main->sigFd == -1) { // LCOV_EXCL_BR_LINE 6: For process initialization processing
+ // LCOV_EXCL_LINE 6: For process initialization processing
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ TSKM_ASSERT(0);
+ goto ERROR;
+ // LCOV_EXCL_STOP
+ }
+
+ p_main->iFd = inotify_init1(IN_CLOEXEC);
+ if (p_main->sigFd == -1) { // LCOV_EXCL_BR_LINE 6: For process initialization processing
+ // LCOV_EXCL_LINE 6: For process initialization processing
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ TSKM_ASSERT_ERRNO(0);
+ goto ERROR;
+ // LCOV_EXCL_STOP
+ }
+
+ // Obtain RESM FDs after waiting for Availability
+ p_main->resmFd = -1;
+
+ tskmRet = tskm_srvSockCreate(TSKM_SOCKET_NAME, &p_main->sock);
+ TSKM_ERR_CHK(tskmRet, TSKM_E_OK, ERROR); // LCOV_EXCL_BR_LINE 6: For process initialization processing
+
+ ret = tskm_pf_nvFileInit(p_main->hApp);
+ if (ret != 0) { // LCOV_EXCL_BR_LINE 6: For process initialization processing
+ // LCOV_EXCL_START 6: For process initialization processing
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ TSKM_ASSERT(0);
+ goto ERROR;
+ // LCOV_EXCL_STOP
+ }
+
+ ret = tskm_initServiceList(&p_main->svcs, p_main->iFd); // Service to be started
+ if (0 != ret) { // LCOV_EXCL_BR_LINE 6: For process initialization processing
+ // LCOV_EXCL_START 6: For For process initialization process
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ TSKM_ASSERT(0);
+ goto ERROR;
+ // LCOV_EXCL_STOP
+ }
+
+ tskm_initWakeupCtx(&p_main->wakeup, s_isVupMode); // Gradual startup info
+ tskm_initDownCtx(&p_main->down, s_isVupMode); // Gradual termination info
+ return;
+
+ // LCOV_EXCL_START 6: For process initialization processing
+ ERROR:
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ tskm_pf_exit(EXIT_FAILURE);
+ return;
+ // LCOV_EXCL_STOP
+}
+
+/*********************************************************
+ * Get main context
+ *********************************************************/
+TSKM_MAIN_CTX_t*
+tskm_getMainCtx(void) {
+ return &g_mainCtx;
+}
+
+/*********************************************************
+ * Process initialization process (MAIN function sub)
+ *********************************************************/
+int Init_Process(int* rpcFd, int* sockFd, int* maxFd, fd_set* fds, TSKM_MAIN_CTX_t* p_main) {
+ int ret;
+ uint32_t ii;
+
+ TSKM_SRV_CONNENT_LIST_t* p_connList = &p_main->sock.connList;
+
+ FD_ZERO(fds);
+
+ FD_SET(*rpcFd, fds);
+ *maxFd = TSKM_MAX(*rpcFd, *maxFd); // LCOV_EXCL_BR_LINE 6: For process initialization processing
+
+ FD_SET(*sockFd, fds);
+ *maxFd = TSKM_MAX(*sockFd, *maxFd); // LCOV_EXCL_BR_LINE 6: For process initialization processing
+
+ FD_SET(p_main->nsFd, fds);
+ *maxFd = TSKM_MAX(p_main->nsFd, *maxFd); // LCOV_EXCL_BR_LINE 6: For process initialization processing
+
+ FD_SET(p_main->sigFd, fds);
+ *maxFd = TSKM_MAX(p_main->sigFd, *maxFd); // LCOV_EXCL_BR_LINE 6: For process initialization processing
+
+ if (-1 != p_main->resmFd) { // LCOV_EXCL_BR_LINE 6: For process initialization processing
+ // LCOV_EXCL_START 6: For process initialization processing
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FD_SET(p_main->resmFd, fds);
+ *maxFd = TSKM_MAX(p_main->resmFd, *maxFd);
+ // LCOV_EXCL_STOP
+ }
+
+ for (ii = 0; ii < p_connList->num; ii++) { // LCOV_EXCL_BR_LINE 6: For process initialization processing
+ // LCOV_EXCL_START 6: For process initialization processing
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ TSKM_SRV_CONNENT_t* p_conn = &p_connList->conn[ii];
+ FD_SET(p_conn->connFd, fds);
+ *maxFd = TSKM_MAX(p_conn->connFd, *maxFd);
+ // LCOV_EXCL_STOP
+ }
+
+ TSKM_PRINTF(TSKM_LOG_FUNC, "SELECT IN");
+ ret = select(*maxFd + 1, fds, NULL, NULL, NULL);
+ if (ret < 1) {
+ if (errno != EINTR) {
+ TSKM_ASSERT(0);
+ }
+ return ret;
+ }
+ TSKM_PRINTF(TSKM_LOG_FUNC, "SELECT OUT");
+ return 0;
+}
+
+/*********************************************************
+ * Receiving Messages from CONNECT Clients (MAIN Functions Sub)
+ *********************************************************/
+void Recv_Msg_FromConnectClient(fd_set* fds, TSKM_MAIN_CTX_t* p_main) {
+ uint32_t ii;
+ TSKM_SRV_CONNENT_LIST_t* p_connList = &p_main->sock.connList;
+
+ // Messages from CONNECT clients
+ for (ii = 0; ii < p_connList->num; ii++) {
+ TSKM_SRV_CONNENT_t* p_conn = &p_connList->conn[ii];
+ if (FD_ISSET(p_conn->connFd, fds)) {
+ TSKM_PRINTF(TSKM_LOG_FUNC, "connFd IN");
+ TSKM_EVENT_INFO_t ev;
+ int ret;
+ ret = tskm_sockRcv(p_conn->connFd, &ev);
+
+ if (ret < 0) {
+ TSKM_ASSERT(0);
+ } else {
+ TSKM_SVC_CTX_t* p_svc;
+
+ if (ret == 0) {
+ // Closed Connection
+ TSKM_PRINTF(TSKM_LOG_STATE, "DISSCON pid:%d", p_conn->pid);
+ ev.event = TSKM_EV_PRI_REP_DISCONNECT;
+ ev.errCode = TSKM_E_OK;
+ ev.fromPid = p_conn->pid;
+ tskm_srvSockDisconnect(&p_main->sock, p_conn);
+ p_conn = NULL; // If the connection is lost, it cannot be referenced.
+ }
+
+ p_svc = tskm_svcsGetSvcByPid(&p_main->svcs, ev.fromPid);
+ if (p_svc) { // Events from service
+ TSKM_ERR_t tskmRet;
+ tskmRet = tskm_svcEventHandle(p_svc, &ev); // Service handler
+ if (tskmRet != TSKM_E_OK) {
+ TSKM_ASSERT(0);
+ }
+ }
+ if (ev.event != TSKM_EV_NOP) {
+ tskm_handleEvent(p_main, &ev); // Main handler
+ }
+ }
+ TSKM_PRINTF(TSKM_LOG_FUNC, "connFd OUT");
+ }
+ }
+}
+
+/*********************************************************
+ * CONNECT Requests (MAIN Functions Sub)
+ *********************************************************/
+void Recv_Req_Connect(fd_set* fds, TSKM_MAIN_CTX_t* p_main, int sockFd) {
+ // CONNECT requests
+ if (FD_ISSET(sockFd, fds)) {
+ TSKM_PRINTF(TSKM_LOG_FUNC, "sockFd IN");
+
+ TSKM_SRV_CONNENT_t* conn;
+ conn = tskm_srvSockConnect(&p_main->sock);
+ if (conn == NULL) {
+ TSKM_ASSERT(0);
+ } else {
+ TSKM_SVC_CTX_t* p_svc;
+ TSKM_PRINTF(TSKM_LOG_STATE, "CONNECT pid:%d", conn->pid);
+
+ p_svc = tskm_svcsGetSvcByPid(&p_main->svcs, conn->pid);
+ if (p_svc) {
+ TSKM_ERR_t tskmRet;
+ TSKM_EVENT_INFO_t ev;
+
+ ev.event = TSKM_EV_PRI_REP_CONNECT;
+ ev.errCode = TSKM_E_OK;
+ ev.fromPid = conn->pid;
+ ev.prm.repConnect.connFd = conn->connFd;
+
+ tskmRet = tskm_svcEventHandle(p_svc, &ev); // Service handler
+ if (tskmRet != TSKM_E_OK) {
+ TSKM_ASSERT(0);
+ } else if (ev.event != TSKM_EV_NOP) {
+ tskm_handleEvent(p_main, &ev); // Main hander
+ }
+ }
+ }
+ TSKM_PRINTF(TSKM_LOG_FUNC, "sockFd OUT");
+ }
+}
+
+/*********************************************************
+ * MAIN Function
+ *********************************************************/
+int main(int argc, char* argv[]) {
+ RPC_ID rpcId = TSKM_RPC_ID;
+ int rpcFd = 0;
+ int maxFd = 0;
+ int ret;
+ fd_set fds;
+ TSKM_MAIN_CTX_t* p_main = &g_mainCtx;
+
+ // Logging setting
+ FRAMEWORKUNIFIED_SET_ZONES();
+
+ ctxCreate(p_main, argc, argv); // Initialize context
+
+ tskm_sub_init(); // Initialize sub systems
+
+ RPC_START_SECURE_SERVER(rpcId);
+ RPC_get_fd(rpcId, &rpcFd);
+
+ uid_t uid[2];
+ gid_t gid[2];
+
+ uid[0] = 0;
+ gid[0] = 0;
+ uid[1] = getuid();
+ gid[1] = getgid();
+
+ if (RPC_OK != RPC_regist_credential(2, uid, 2, gid)) { // LCOV_EXCL_BR_LINE 6: For process initialization processing
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ TSKM_ASSERT(0); // LCOV_EXCL_LINE 6: For process initialization processing
+ }
+
+ // Start periodic timer thread
+ ret = tskm_watch_startTimer();
+ if (ret != 0) { // LCOV_EXCL_BR_LINE 6: For process initialization processing
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ TSKM_ASSERT(0); // LCOV_EXCL_LINE 6: For process initialization processing
+ }
+
+ tskm_stateTransit(p_main, TSKM_ST_ACCOFF, TSKM_ST_ACCON);
+
+ p_main->isExec = TSKM_TRUE;
+ while (p_main->isExec) { // LCOV_EXCL_BR_LINE 6: For process initialization processing
+ int sockFd = p_main->sock.sockFd;
+
+ // Initialization processing
+ if (Init_Process(&rpcFd, &sockFd, &maxFd, &fds, p_main) != 0) { // LCOV_EXCL_BR_LINE 6: For process initialization processing
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ continue; // LCOV_EXCL_LINE 6: For process initialization processing
+ }
+
+ // RPC API
+ if (FD_ISSET(rpcFd, &fds)) {
+ RPC_process_API_request(rpcId);
+ }
+
+ // Process termination signal
+ if (FD_ISSET(p_main->sigFd, &fds)) {
+ int count = 0;
+
+ do {
+ TSKM_EVENT_INFO_t ev;
+ ev.event = TSKM_EV_SVC_REP_TERM;
+
+ count++;
+
+ ret = tskm_pf_cleanupProc(p_main->sigFd, &ev.fromPid, &ev.errCode);
+ if (ret == -1) {
+ TSKM_ASSERT(0);
+ break;
+ }
+
+ TSKM_SVC_CTX_t* p_svc;
+
+ p_svc = tskm_svcsGetSvcByPid(&p_main->svcs, ev.fromPid);
+ if (p_svc) {
+ TSKM_ERR_t tskmRet;
+
+ tskmRet = tskm_svcEventHandle(p_svc, &ev); // Service handler
+ if (tskmRet != TSKM_E_OK) {
+ TSKM_ASSERT(0);
+ }
+ if (ev.event != TSKM_EV_NOP) {
+ tskm_handleEvent(p_main, &ev); // Main handler
+ }
+ }
+ } while (ret == 1 && count < 50);
+ }
+
+ if (FD_ISSET(p_main->nsFd, &fds)) {
+ FrameworkunifiedDispatchProcessWithoutLoop(p_main->hApp);
+ }
+
+ // EV from RESM
+ if (-1 != p_main->resmFd) {
+ if (FD_ISSET(p_main->resmFd, &fds)) {
+ TSKM_EVENT_INFO_t ev;
+ int ret;
+ ret = tskm_sub_resmRcv(&ev);
+
+ if (-1 == ret) {
+ TSKM_ASSERT(0);
+ } else {
+ tskm_handleEvent(p_main, &ev);
+ }
+ }
+ }
+
+ // Messages from connected clients
+ Recv_Msg_FromConnectClient(&fds, p_main);
+
+ // CONNECT request
+ Recv_Req_Connect(&fds, p_main, sockFd);
+ }
+
+ tskm_srvSockDestory(&p_main->sock);
+
+ RPC_end(rpcId);
+
+ FrameworkunifiedDestroyDispatcherWithoutLoop(p_main->hApp);
+ TSKM_PRINTF(TSKM_LOG_STATE, "tskm end");
+
+ sleep(TSKM_CFG_WAIT_SHUTDOWN);
+ return 0;
+} // LCOV_EXCL_BR_LINE 10: Final line
+
Code Review / staging / basesystem.git / blobdiff