/**************************************************************************** Name : avnd_mbx_create Description : This routine creates & attaches AvND mailbox. Arguments : cb - ptr to AvND control block Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE Notes : None ******************************************************************************/ uns32 avnd_mbx_create(AVND_CB *cb) { uns32 rc = NCSCC_RC_SUCCESS; TRACE_ENTER(); /* create the mail box */ rc = m_NCS_IPC_CREATE(&cb->mbx); if (NCSCC_RC_SUCCESS != rc) { LOG_CR("AvND Mailbox creation failed"); goto err; } TRACE("AvND mailbox creation success"); /* attach the mail box */ rc = m_NCS_IPC_ATTACH(&cb->mbx); if (NCSCC_RC_SUCCESS != rc) { LOG_CR("AvND mailbox attach failed"); goto err; } TRACE_LEAVE2("AvND mailbox attach success"); return rc; err: /* destroy the mailbox */ if (cb->mbx) avnd_mbx_destroy(cb); TRACE_LEAVE(); return rc; }
/** * This function initializes the DTMS_CB including the Patricia trees * * @param dtms_cb * * @return NCSCC_RC_SUCCESS * @return NCSCC_RC_FAILURE * */ uns32 dtm_cb_init(DTM_INTERNODE_CB * dtms_cb) { NCS_PATRICIA_PARAMS nodeid_param; NCS_PATRICIA_PARAMS comm_socket_param; NCS_PATRICIA_PARAMS ipaddr_param; TRACE_ENTER(); memset(&nodeid_param, 0, sizeof(NCS_PATRICIA_PARAMS)); memset(&comm_socket_param, 0, sizeof(NCS_PATRICIA_PARAMS)); memset(&ipaddr_param, 0, sizeof(NCS_PATRICIA_PARAMS)); nodeid_param.key_size = sizeof(uns32); comm_socket_param.key_size = sizeof(uns32); ipaddr_param.key_size = IPV6_ADDR_UNS8_CNT; /* Initialize patricia tree for nodeid list */ if (NCSCC_RC_SUCCESS != ncs_patricia_tree_init(&dtms_cb->nodeid_tree, &nodeid_param)) { LOG_ER("DTM: ncs_patricia_tree_init FAILED"); return NCSCC_RC_FAILURE; } /* Initialize comm_socket patricia tree */ if (NCSCC_RC_SUCCESS != ncs_patricia_tree_init(&dtms_cb->comm_sock_tree, &comm_socket_param)) { LOG_ER("DTM:ncs_patricia_tree_init FAILED"); return NCSCC_RC_FAILURE; } /* Initialize comm_socket patricia tree */ if (NCSCC_RC_SUCCESS != ncs_patricia_tree_init(&dtms_cb->ip_addr_tree, &ipaddr_param)) { LOG_ER("DTM:ncs_patricia_tree_init FAILED"); return NCSCC_RC_FAILURE; } if (m_NCS_IPC_CREATE(&dtms_cb->mbx) != NCSCC_RC_SUCCESS) { /* Mail box creation failed */ LOG_ER("DTM:IPC create FAILED"); return NCSCC_RC_FAILURE; } else { NCS_SEL_OBJ obj; if (NCSCC_RC_SUCCESS != m_NCS_IPC_ATTACH(&dtms_cb->mbx)) { m_NCS_IPC_RELEASE(&dtms_cb->mbx, NULL); LOG_ER("DTM: Internode Mailbox Attach failed"); return NCSCC_RC_FAILURE; } obj = m_NCS_IPC_GET_SEL_OBJ(&dtms_cb->mbx); /* retreive the corresponding fd for mailbox and fill it in cb */ dtms_cb->mbx_fd = m_GET_FD_FROM_SEL_OBJ(obj); /* extract and fill value needs to be extracted */ } TRACE_LEAVE(); return NCSCC_RC_SUCCESS; }
/** * Initialize smfnd * * @return uns32 */ static uns32 initialize_smfnd(void) { uns32 rc; TRACE_ENTER(); if (ncs_agents_startup() != NCSCC_RC_SUCCESS) { LOG_ER("ncs_agents_startup FAILED"); rc = NCSCC_RC_FAILURE; goto done; } /* Initialize smfnd control block */ if (smfnd_cb_init(smfnd_cb) != NCSCC_RC_SUCCESS) { TRACE("smfnd_cb_init FAILED"); rc = NCSCC_RC_FAILURE; goto done; } /* Create the mailbox used for communication with SMFD/SMFA */ if ((rc = m_NCS_IPC_CREATE(&smfnd_cb->mbx)) != NCSCC_RC_SUCCESS) { LOG_ER("m_NCS_IPC_CREATE FAILED %d", rc); goto done; } /* Attach mailbox to this thread */ if ((rc = m_NCS_IPC_ATTACH(&smfnd_cb->mbx) != NCSCC_RC_SUCCESS)) { LOG_ER("m_NCS_IPC_ATTACH FAILED %d", rc); goto done; } /* Create a selection object for USR1 signal handling */ if ((rc = ncs_sel_obj_create(&smfnd_cb->usr1_sel_obj)) != NCSCC_RC_SUCCESS) { LOG_ER("ncs_sel_obj_create failed"); goto done; } /* Initialize mds communication */ if ((rc = smfnd_mds_init(smfnd_cb)) != NCSCC_RC_SUCCESS) { TRACE("smfnd_mds_init FAILED %d", rc); return rc; } /* Check if AMF started */ if (smfnd_cb->nid_started == 0) { /* Started by AMF, so let's init AMF */ if ((rc = smfnd_amf_init(smfnd_cb)) != NCSCC_RC_SUCCESS) { LOG_ER("init amf failed"); goto done; } } done: TRACE_LEAVE(); return (rc); }
/**************************************************************************** Name : glsv_gla_callback_queue_init Description : This routine is used to initialize the queue for the callbacks. Arguments : client_info - pointer to the client info Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE Notes : None ******************************************************************************/ uns32 glsv_gla_callback_queue_init(GLA_CLIENT_INFO *client_info) { if (m_NCS_IPC_CREATE(&client_info->callbk_mbx) == NCSCC_RC_SUCCESS) { if (m_NCS_IPC_ATTACH(&client_info->callbk_mbx) == NCSCC_RC_SUCCESS) { return NCSCC_RC_SUCCESS; } m_NCS_IPC_RELEASE(&client_info->callbk_mbx, NULL); } m_LOG_GLA_SYS_CALL(GLA_GET_SEL_OBJ_FAIL, __FILE__, __LINE__, client_info->lock_handle_id); return NCSCC_RC_FAILURE; }
/*********************************************************************** * Name : plms_hrb_initialize * * Description : This function initializes the HRB control block * and creates plms_hrb thread, It registers to MDS * to receive requests from PLMS * * Arguments : * * Return Values : NCSCC_RC_SUCCESS * NCSCC_RC_FAILURE ***********************************************************************/ SaUint32T plms_hrb_initialize() { PLMS_HRB_CB *cb = hrb_cb; pthread_t thread_id; pthread_attr_t attr; struct sched_param thread_priority; SaUint32T policy; SaUint32T rc; TRACE_ENTER(); /* create the mail box and attach it */ if ((rc = m_NCS_IPC_CREATE(&cb->mbx)) != NCSCC_RC_SUCCESS){ LOG_ER("error creating mail box err val:%d",rc); return NCSCC_RC_FAILURE; } if ((rc = m_NCS_IPC_ATTACH(&cb->mbx)) != NCSCC_RC_SUCCESS){ LOG_ER("error attaching mail box err val:%d",rc); return NCSCC_RC_FAILURE; } /* Initialize with the MDS */ if(hrb_mds_initialize() != NCSCC_RC_SUCCESS){ LOG_ER("HRB: mds initialization failed"); return NCSCC_RC_FAILURE; } /* Initialize thread attribute */ pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); pthread_attr_setstacksize(&attr, PLMS_HRB_STACKSIZE); /* Create PLMS_HRB thread */ rc = pthread_create(&thread_id, &attr, plms_hrb, NULL); if(rc){ LOG_ER("pthread_create FAILED ret code:%d error:%s", rc,strerror(errno)); return NCSCC_RC_FAILURE; } /*scheduling parameters of the thread */ memset(&thread_priority, 0, sizeof(thread_priority)); thread_priority.sched_priority = PLMS_HRB_TASK_PRIORITY; policy = SCHED_OTHER; pthread_setschedparam(thread_id, policy, &thread_priority); TRACE_LEAVE(); return NCSCC_RC_SUCCESS; }
static uint32_t dtm_intranode_create_pid_info(int fd) { DTM_INTRANODE_PID_INFO *pid_node = NULL; TRACE_ENTER(); if (NULL == (pid_node = calloc(1, sizeof(DTM_INTRANODE_PID_INFO)))) { TRACE("\nMemory allocation failed for DTM_INTRANODE_PID_INFO"); return NCSCC_RC_FAILURE; } pid_node->accepted_fd = fd; pid_node->pid = 0; /* Yet to be filled from the PID Message which is yet to come */ pid_node->node_id = m_NCS_GET_NODE_ID; pid_node->fd_node.key_info = (uint8_t *)&pid_node->accepted_fd; if (m_NCS_IPC_CREATE(&pid_node->mbx) != NCSCC_RC_SUCCESS) { /* Mail box creation failed */ TRACE("Mailbox creation failed,dtm_accept msg"); free(pid_node); return NCSCC_RC_FAILURE; } else { NCS_SEL_OBJ obj; /* Code added for attaching the mailbox */ if (NCSCC_RC_SUCCESS != m_NCS_IPC_ATTACH(&pid_node->mbx)) { TRACE("\nMailbox attach failed,dtm_intranode_process_pid_msg"); m_NCS_IPC_RELEASE(&pid_node->mbx, NULL); free(pid_node); return NCSCC_RC_FAILURE; } obj = m_NCS_IPC_GET_SEL_OBJ(&pid_node->mbx); /* retreive the corresponding fd for mailbox */ pid_node->mbx_fd = m_GET_FD_FROM_SEL_OBJ(obj); /* extract and fill value needs to be extracted */ } ncs_patricia_tree_add(&dtm_intranode_cb->dtm_intranode_fd_list, (NCS_PATRICIA_NODE *)&pid_node->fd_node); TRACE_LEAVE(); return NCSCC_RC_SUCCESS; }
/*************************************************************************** @brief : saSmfInitialize. Even if no cbk is registered, we create MBX for the client as we have to return the sel obj later. @param[out] : smfHandle - Will have a valid handle if initialization is successful. @param[in] : smfCallbacks - Cbks to be registered. @param[in] : version - Supported smf-api version. @return : SA_AIS_OK if successful otherwise appropiate err code. *****************************************************************************/ SaAisErrorT saSmfInitialize(SaSmfHandleT *smfHandle, const SaSmfCallbacksT *smfCallbacks, SaVersionT *version) { SMFA_CB *cb = &_smfa_cb; SMFA_CLIENT_INFO *client_info; SaAisErrorT rc = SA_AIS_OK; TRACE_ENTER(); if (!smfHandle || !version){ LOG_ER("SMFA: smfHandle or version is NULL."); return SA_AIS_ERR_INVALID_PARAM; } if (!m_SMFA_VERSION_VALIDATE(version)){ LOG_ER("SMFA: Unsupported version. ReleaseCode: %c, MajorVersion: %x", version->releaseCode,version->majorVersion); version->releaseCode = SMF_RELEASE_CODE; version->majorVersion = SMF_MAJOR_VERSION; version->minorVersion = SMF_MINOR_VERSION; TRACE_LEAVE(); return SA_AIS_ERR_VERSION; } version->minorVersion = SMF_MINOR_VERSION; if (NCSCC_RC_SUCCESS != smfa_init()){ LOG_ER("smfa_init() FAILED."); ncs_agents_shutdown(); TRACE_LEAVE(); return SA_AIS_ERR_LIBRARY; } client_info = (SMFA_CLIENT_INFO *)calloc(1,sizeof(SMFA_CLIENT_INFO)); if (NULL == client_info){ LOG_ER("SMFA client info: calloc FAILED, error: %s",strerror(errno)); rc = SA_AIS_ERR_NO_MEMORY; goto smfa_init_failed; } /* Fill the handle.*/ if ( MAX_SMFA_HDL <= smfa_hdl){ smfa_hdl = 0; } smfa_hdl++; client_info->client_hdl = smfa_hdl; /* Fill the callback info. */ if (NULL != smfCallbacks) client_info->reg_cbk = *smfCallbacks; else TRACE_2("SMFA: No cbk registered."); /* Create MBX for this client.*/ if (NCSCC_RC_SUCCESS != m_NCS_IPC_CREATE(&client_info->cbk_mbx)){ LOG_ER("SMFA: MBX create FAILED."); rc = SA_AIS_ERR_LIBRARY; goto smfa_mbx_create_failed; }else { if (NCSCC_RC_SUCCESS != m_NCS_IPC_ATTACH(&client_info->cbk_mbx)){ LOG_ER("SMFA: MBX attach FAILED."); rc = SA_AIS_ERR_LIBRARY; goto smfa_mbx_attach_failed; } } /* Add the client info to the database. */ if (NCSCC_RC_SUCCESS != m_NCS_LOCK(&cb->cb_lock,NCS_LOCK_WRITE)){ LOG_ER("SMFA: Cb lock acquire FAILED."); rc = SA_AIS_ERR_NO_RESOURCES; goto smfa_take_lock_failed; } smfa_client_info_add(client_info); m_NCS_UNLOCK(&cb->cb_lock,NCS_LOCK_WRITE); /* Initialization is successful. Pass the handle to the application.*/ *smfHandle = client_info->client_hdl; TRACE_2("SMFA: Handle returned: %llu.",*smfHandle); TRACE_LEAVE(); return SA_AIS_OK; smfa_take_lock_failed: m_NCS_IPC_DETACH(&client_info->cbk_mbx,smfa_client_mbx_clnup,client_info); smfa_mbx_attach_failed: m_NCS_IPC_RELEASE(&client_info->cbk_mbx,NULL); smfa_mbx_create_failed: if (client_info){ free(client_info); client_info = NULL; } smfa_init_failed: smfa_finalize(); TRACE_LEAVE(); return rc; }
/** * Initialize immd * * @return uns32 */ static uns32 immd_initialize(void) { uns32 rc = NCSCC_RC_SUCCESS; TRACE_ENTER(); if (ncs_agents_startup() != NCSCC_RC_SUCCESS) { LOG_ER("ncs_agents_startup FAILED"); goto done; } if ((rc = rda_get_role(&immd_cb->ha_state)) != NCSCC_RC_SUCCESS) { LOG_ER("rda_get_role FAILED"); goto done; } if ((rc = rda_register_callback(0, rda_cb)) != NCSCC_RC_SUCCESS) { LOG_ER("rda_register_callback FAILED %u", rc); goto done; } /* Init the EDU Handle */ m_NCS_EDU_HDL_INIT(&immd_cb->edu_hdl); if ((rc = immd_cb_db_init(immd_cb)) != NCSCC_RC_SUCCESS) { LOG_ER("immd_cb_db_init FAILED"); goto done; } /* Create a mail box */ if ((rc = m_NCS_IPC_CREATE(&immd_cb->mbx)) != NCSCC_RC_SUCCESS) { LOG_ER("m_NCS_IPC_CREATE FAILED"); goto done; } /* Attach the IPC to mail box */ if ((rc = m_NCS_IPC_ATTACH(&immd_cb->mbx)) != NCSCC_RC_SUCCESS) { LOG_ER("m_NCS_IPC_ATTACH FAILED"); goto done; } if ((rc = immd_mds_register(immd_cb)) != NCSCC_RC_SUCCESS) { LOG_ER("immd_mds_register FAILED %d", rc); goto done; } /* Initialise with the MBCSV service */ if ((rc = immd_mbcsv_register(immd_cb)) != NCSCC_RC_SUCCESS) { LOG_ER("immd_mbcsv_register FAILED %d", rc); goto done; } if ((rc = immd_mbcsv_chgrole(immd_cb)) != NCSCC_RC_SUCCESS) { LOG_ER("immd_mbcsv_chgrole FAILED %d", rc); goto done; } /* Create a selection object */ if ((rc = ncs_sel_obj_create(&immd_cb->usr1_sel_obj)) != NCSCC_RC_SUCCESS) { LOG_ER("ncs_sel_obj_create failed"); goto done; } /* * Initialize a signal handler that will use the selection object. * The signal is sent from our script when AMF does instantiate. */ if ((signal(SIGUSR1, sigusr1_handler)) == SIG_ERR) { LOG_ER("signal USR1 failed: %s", strerror(errno)); rc = NCSCC_RC_FAILURE; goto done; } syslog(LOG_INFO, "Initialization Success, role %s", (immd_cb->ha_state == SA_AMF_HA_ACTIVE) ? "ACTIVE" : "STANDBY"); done: if (nid_notify("IMMD", rc, NULL) != NCSCC_RC_SUCCESS) { LOG_ER("nid_notify failed"); rc = NCSCC_RC_FAILURE; } TRACE_LEAVE(); return rc; }
/***************************************************************************** PROCEDURE NAME: main DESCRIPTION: Main routine for FM *****************************************************************************/ int main(int argc, char *argv[]) { NCS_SEL_OBJ mbx_sel_obj, pipe_sel_obj, highest_sel_obj; NCS_SEL_OBJ amf_sel_obj = {0, 0}; NCS_SEL_OBJ_SET sel_obj_set; FM_EVT *fm_mbx_evt = NULL; daemonize(argc, argv); if (fm_agents_startup() != NCSCC_RC_SUCCESS) { /* notify the NID */ fm_nid_notify((uns32)NCSCC_RC_FAILURE); goto fm_agents_startup_failed; } /* Allocate memory for FM_CB. */ fm_cb = m_MMGR_ALLOC_FM_CB; if (NULL == fm_cb) { /* notify the NID */ syslog(LOG_ERR, "CB Allocation failed."); fm_nid_notify((uns32)NCSCC_RC_FAILURE); goto fm_agents_startup_failed; } memset(fm_cb, 0, sizeof(FM_CB)); /* Create CB handle */ gl_fm_hdl = ncshm_create_hdl(NCS_HM_POOL_ID_COMMON, NCS_SERVICE_ID_GFM, (NCSCONTEXT)fm_cb); /* Take CB handle */ ncshm_take_hdl(NCS_SERVICE_ID_GFM, gl_fm_hdl); if (fm_get_args(fm_cb) != NCSCC_RC_SUCCESS) { /* notify the NID */ fm_nid_notify((uns32)NCSCC_RC_FAILURE); goto fm_get_args_failed; } /* Create MBX. */ if (m_NCS_IPC_CREATE(&fm_cb->mbx) != NCSCC_RC_SUCCESS) { syslog(LOG_ERR, "m_NCS_IPC_CREATE() failed."); fm_nid_notify((uns32)NCSCC_RC_FAILURE); goto fm_get_args_failed; } /* Attach MBX */ if (m_NCS_IPC_ATTACH(&fm_cb->mbx) != NCSCC_RC_SUCCESS) { syslog(LOG_ERR, "m_NCS_IPC_ATTACH() failed."); fm_nid_notify((uns32)NCSCC_RC_FAILURE); goto fm_mbx_attach_failure; } /* MDS initialization */ if (fm_mds_init(fm_cb) != NCSCC_RC_SUCCESS) { fm_nid_notify((uns32)NCSCC_RC_FAILURE); goto fm_mds_init_failed; } /* RDA initialization */ if (fm_rda_init(fm_cb) != NCSCC_RC_SUCCESS) { fm_nid_notify((uns32)NCSCC_RC_FAILURE); goto fm_rda_init_failed; } /* Open FM pipe for receiving AMF up intimation */ if (fm_amf_open(&fm_cb->fm_amf_cb) != NCSCC_RC_SUCCESS) { fm_nid_notify((uns32)NCSCC_RC_FAILURE); goto fm_hpl_lib_init_failed; } /* Get mailbox selection object */ mbx_sel_obj = m_NCS_IPC_GET_SEL_OBJ(&fm_cb->mbx); /* Get pipe selection object */ m_SET_FD_IN_SEL_OBJ(fm_cb->fm_amf_cb.pipe_fd, pipe_sel_obj); /* Give CB hdl */ ncshm_give_hdl(gl_fm_hdl); /* notify the NID */ fm_nid_notify(NCSCC_RC_SUCCESS); /* clear selection object set */ m_NCS_SEL_OBJ_ZERO(&sel_obj_set); /* Set only one pipe eelection object in set */ m_NCS_SEL_OBJ_SET(pipe_sel_obj, &sel_obj_set); highest_sel_obj = pipe_sel_obj; /* Wait for pipe selection object */ if (m_NCS_SEL_OBJ_SELECT(highest_sel_obj, &sel_obj_set, NULL, NULL, NULL) != -1) { /* following if will be true only first time */ if (m_NCS_SEL_OBJ_ISSET(pipe_sel_obj, &sel_obj_set)) { /* Take handle */ ncshm_take_hdl(NCS_SERVICE_ID_GFM, gl_fm_hdl); /* Process the message received on pipe */ if (fm_amf_pipe_process_msg(&fm_cb->fm_amf_cb) != NCSCC_RC_SUCCESS) goto done; /* Get amf selection object */ m_SET_FD_IN_SEL_OBJ(fm_cb->fm_amf_cb.amf_fd, amf_sel_obj); /* Release handle */ ncshm_give_hdl(gl_fm_hdl); } } /* clear selection object set */ m_NCS_SEL_OBJ_ZERO(&sel_obj_set); m_NCS_SEL_OBJ_SET(amf_sel_obj, &sel_obj_set); m_NCS_SEL_OBJ_SET(mbx_sel_obj, &sel_obj_set); highest_sel_obj = m_GET_HIGHER_SEL_OBJ(amf_sel_obj, mbx_sel_obj); /* Wait infinitely on */ while ((m_NCS_SEL_OBJ_SELECT(highest_sel_obj, &sel_obj_set, NULL, NULL, NULL) != -1)) { if (m_NCS_SEL_OBJ_ISSET(mbx_sel_obj, &sel_obj_set)) { /* Take handle */ ncshm_take_hdl(NCS_SERVICE_ID_GFM, gl_fm_hdl); fm_mbx_evt = (FM_EVT *)m_NCS_IPC_NON_BLK_RECEIVE(&fm_cb->mbx, msg); if (fm_mbx_evt) { fm_mbx_msg_handler(fm_cb, fm_mbx_evt); } /* Release handle */ ncshm_give_hdl(gl_fm_hdl); } if (m_NCS_SEL_OBJ_ISSET(amf_sel_obj, &sel_obj_set)) { /* Take handle */ ncshm_take_hdl(NCS_SERVICE_ID_GFM, gl_fm_hdl); /* Process the message received on amf selection object */ fm_amf_process_msg(&fm_cb->fm_amf_cb); /* Release handle */ ncshm_give_hdl(gl_fm_hdl); } m_NCS_SEL_OBJ_SET(amf_sel_obj, &sel_obj_set); m_NCS_SEL_OBJ_SET(mbx_sel_obj, &sel_obj_set); highest_sel_obj = m_GET_HIGHER_SEL_OBJ(amf_sel_obj, mbx_sel_obj); } fm_amf_close(&fm_cb->fm_amf_cb); fm_hpl_lib_init_failed: fm_rda_finalize(fm_cb); fm_rda_init_failed: fm_mds_finalize(fm_cb); fm_mds_init_failed: m_NCS_IPC_DETACH(&fm_cb->mbx, NULL, NULL); fm_mbx_attach_failure: m_NCS_IPC_RELEASE(&fm_cb->mbx, NULL); fm_get_args_failed: ncshm_destroy_hdl(NCS_SERVICE_ID_GFM, gl_fm_hdl); gl_fm_hdl = 0; m_MMGR_FREE_FM_CB(fm_cb); fm_agents_startup_failed: fm_agents_shutdown(); done: return 1; }
/** * Function to init the intranode processing * * * @return NCSCC_RC_SUCCESS * @return NCSCC_RC_FAILURE * */ uint32_t dtm_intra_processing_init(char *node_ip, DTM_IP_ADDR_TYPE i_addr_family) { int servlen, size = DTM_INTRANODE_SOCK_SIZE; /* For socket fd and server len */ struct sockaddr_un serv_addr; /* For Unix Sock address */ char server_ux_name[255]; NCS_PATRICIA_PARAMS pat_tree_params; struct sockaddr_in serveraddr; struct sockaddr_in6 serveraddr6; int flags; TRACE_ENTER(); /* UNIX is default transport for intranode */ dtm_socket_domain = AF_UNIX; if (NULL == (dtm_intranode_cb = calloc(1, sizeof(DTM_INTRANODE_CB)))) { LOG_ER("DTM: Memory allocation failed for dtm_intranode_cb"); return NCSCC_RC_FAILURE; } dtm_intranode_cb->sock_domain = dtm_socket_domain; /* Open a socket, If socket opens to fail return Error */ dtm_intranode_cb->server_sockfd = socket(dtm_socket_domain, SOCK_STREAM, 0); if (dtm_intranode_cb->server_sockfd < 0) { LOG_ER("DTM: Socket creation failed err :%s ", strerror(errno)); free(dtm_intranode_cb); return NCSCC_RC_FAILURE; } /*Make the socket Non-Blocking for accepting */ if ((flags = fcntl(dtm_intranode_cb->server_sockfd, F_GETFL, NULL)) < 0) { LOG_ER("DTM :fcntl(F_SETFL, O_NONBLOCK) err :%s ", strerror(errno)); return false; } flags |= O_NONBLOCK; if(fcntl(dtm_intranode_cb->server_sockfd, F_SETFL, flags) < 0) { /*Non-Blocking Options hasnt been set, what shall we do now */ LOG_ER("DTM: Socket NON Block set failed err :%s ", strerror(errno)); close(dtm_intranode_cb->server_sockfd); free(dtm_intranode_cb); return NCSCC_RC_FAILURE; } /* Increase the socket buffer size */ if (setsockopt(dtm_intranode_cb->server_sockfd, SOL_SOCKET, SO_RCVBUF, &size, sizeof(size)) != 0) { LOG_ER("DTM: Unable to set the SO_RCVBUF err :%s ", strerror(errno)); close(dtm_intranode_cb->server_sockfd); free(dtm_intranode_cb); return NCSCC_RC_FAILURE; } if (setsockopt(dtm_intranode_cb->server_sockfd, SOL_SOCKET, SO_SNDBUF, &size, sizeof(size)) != 0) { LOG_ER("DTM: Unable to set the SO_SNDBUF err :%s ", strerror(errno)); close(dtm_intranode_cb->server_sockfd); free(dtm_intranode_cb); return NCSCC_RC_FAILURE; } dtm_intranode_cb->nodeid = m_NCS_GET_NODE_ID; bzero((char *)&serv_addr, sizeof(serv_addr)); if (dtm_socket_domain == AF_UNIX) { #define UX_SOCK_NAME_PREFIX PKGLOCALSTATEDIR "/osaf_dtm_intra_server" sprintf(server_ux_name, "%s", UX_SOCK_NAME_PREFIX); serv_addr.sun_family = AF_UNIX; strcpy(serv_addr.sun_path, server_ux_name); unlink(serv_addr.sun_path); servlen = strlen(serv_addr.sun_path) + sizeof(serv_addr.sun_family); /* Bind the created socket here with the address NODEID, * if bind fails return error by the closing the * created socket*/ if (bind(dtm_intranode_cb->server_sockfd, (struct sockaddr *)&serv_addr, servlen) < 0) { LOG_ER("DTM: Bind failed err :%s ", strerror(errno)); close(dtm_intranode_cb->server_sockfd); free(dtm_intranode_cb); return NCSCC_RC_FAILURE; } if (chmod(UX_SOCK_NAME_PREFIX, (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH)) < 0) { LOG_ER("chmod %s failed - %s", UX_SOCK_NAME_PREFIX, strerror(errno)); close(dtm_intranode_cb->server_sockfd); free(dtm_intranode_cb); return NCSCC_RC_FAILURE; } } else { if (dtm_socket_domain == AF_INET) { memset(&serveraddr, 0, sizeof(serveraddr)); serveraddr.sin_family = AF_INET; serveraddr.sin_port = htons(DTM_INTRA_SERVER_PORT); serveraddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); if (bind(dtm_intranode_cb->server_sockfd, (struct sockaddr *)&serveraddr, sizeof(serveraddr) ) < 0) { LOG_ER("DTM: Bind failed err :%s ", strerror(errno)); close(dtm_intranode_cb->server_sockfd); free(dtm_intranode_cb); return NCSCC_RC_FAILURE; } } else { memset(&serveraddr6, 0, sizeof(serveraddr6)); serveraddr6.sin6_family = AF_INET6; serveraddr.sin_port = htons(DTM_INTRA_SERVER_PORT); inet_pton(AF_INET6, "localhost", &serveraddr6.sin6_addr); if (bind(dtm_intranode_cb->server_sockfd, (struct sockaddr *)&serveraddr6, sizeof(serveraddr6) ) < 0) { LOG_ER("DTM_INTRA: Bind failed"); close(dtm_intranode_cb->server_sockfd); free(dtm_intranode_cb); return NCSCC_RC_FAILURE; } } } listen(dtm_intranode_cb->server_sockfd, 20); memset(&pat_tree_params, 0, sizeof(pat_tree_params)); pat_tree_params.key_size = sizeof(uint32_t); if (NCSCC_RC_SUCCESS != ncs_patricia_tree_init(&dtm_intranode_cb->dtm_intranode_pid_list, &pat_tree_params)) { LOG_ER("DTM: ncs_patricia_tree_init failed for dtm_intranode_pid_list"); close(dtm_intranode_cb->server_sockfd); free(dtm_intranode_cb); return NCSCC_RC_FAILURE; } pat_tree_params.key_size = sizeof(int); if (NCSCC_RC_SUCCESS != ncs_patricia_tree_init(&dtm_intranode_cb->dtm_intranode_fd_list, &pat_tree_params)) { LOG_ER("DTM: ncs_patricia_tree_init failed for dtm_intranode_pid_list"); close(dtm_intranode_cb->server_sockfd); free(dtm_intranode_cb); return NCSCC_RC_FAILURE; } pat_tree_params.key_size = sizeof(uint32_t); if (NCSCC_RC_SUCCESS != ncs_patricia_tree_init(&dtm_intranode_cb->dtm_svc_subscr_list, &pat_tree_params)) { LOG_ER("DTM: ncs_patricia_tree_init failed for dtm_intranode_pid_list"); close(dtm_intranode_cb->server_sockfd); free(dtm_intranode_cb); return NCSCC_RC_FAILURE; } pat_tree_params.key_size = sizeof(uint32_t); if (NCSCC_RC_SUCCESS != ncs_patricia_tree_init(&dtm_intranode_cb->dtm_svc_install_list, &pat_tree_params)) { LOG_ER("DTM: ncs_patricia_tree_init failed for dtm_intranode_pid_list"); close(dtm_intranode_cb->server_sockfd); free(dtm_intranode_cb); return NCSCC_RC_FAILURE; } dtm_intranode_add_self_node_to_node_db(dtm_intranode_cb->nodeid, node_ip, i_addr_family); if (m_NCS_IPC_CREATE(&dtm_intranode_cb->mbx) != NCSCC_RC_SUCCESS) { /* Mail box creation failed */ LOG_ER("DTM : Intranode Mailbox Creation failed"); close(dtm_intranode_cb->server_sockfd); free(dtm_intranode_cb); return NCSCC_RC_FAILURE; } else { NCS_SEL_OBJ obj; /* Code added for attaching the mailbox, to eliminate the DBG Print at sysf_ipc.c: 640 */ if (NCSCC_RC_SUCCESS != m_NCS_IPC_ATTACH(&dtm_intranode_cb->mbx)) { m_NCS_IPC_RELEASE(&dtm_intranode_cb->mbx, NULL); close(dtm_intranode_cb->server_sockfd); free(dtm_intranode_cb); LOG_ER("DTM: Intranode Mailbox Attach failed"); return NCSCC_RC_FAILURE; } obj = m_NCS_IPC_GET_SEL_OBJ(&dtm_intranode_cb->mbx); /* retreive the corresponding fd for mailbox and fill it in cb */ dtm_intranode_cb->mbx_fd = m_GET_FD_FROM_SEL_OBJ(obj); /* extract and fill value needs to be extracted */ } dtm_intranode_add_poll_fdlist(dtm_intranode_cb->server_sockfd, POLLIN); dtm_intranode_add_poll_fdlist(dtm_intranode_cb->mbx_fd, POLLIN); if (dtm_intranode_create_rcv_task(dtm_intranode_cb->task_hdl) != NCSCC_RC_SUCCESS) { LOG_ER("MDS:MDTM: Receive Task Creation Failed in MDTM_INIT\n"); close(dtm_intranode_cb->server_sockfd); free(dtm_intranode_cb); return NCSCC_RC_FAILURE; } TRACE_LEAVE(); return NCSCC_RC_SUCCESS; }
/**************************************************************************** * Name : gld_se_lib_init * * Description : Invoked to Initialize the GLD * * * Arguments : * Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE.. * * Notes : None. *****************************************************************************/ uns32 gld_se_lib_init(NCS_LIB_REQ_INFO *req_info) { GLSV_GLD_CB *gld_cb; SaAisErrorT amf_error; uns32 res = NCSCC_RC_SUCCESS; SaAmfHealthcheckKeyT Healthy; int8 *health_key; /* Register with Logging subsystem */ if (NCS_GLSV_LOG == 1) gld_flx_log_reg(); /* Allocate and initialize the control block */ gld_cb = m_MMGR_ALLOC_GLSV_GLD_CB; if (gld_cb == NULL) { m_LOG_GLD_MEMFAIL(GLD_CB_ALLOC_FAILED, __FILE__, __LINE__); return NCSCC_RC_FAILURE; } memset(gld_cb, 0, sizeof(GLSV_GLD_CB)); /* TBD- Pool id is to be set */ gl_gld_hdl = gld_cb->my_hdl = ncshm_create_hdl(gld_cb->hm_poolid, NCS_SERVICE_ID_GLD, (NCSCONTEXT)gld_cb); if (0 == gld_cb->my_hdl) { m_LOG_GLD_HEADLINE(GLD_CREATE_HANDLE_FAILED, NCSFL_SEV_ERROR, __FILE__, __LINE__, 0); m_MMGR_FREE_GLSV_GLD_CB(gld_cb); return NCSCC_RC_FAILURE; } /* Initialize the cb parameters */ if (gld_cb_init(gld_cb) != NCSCC_RC_SUCCESS) { m_MMGR_FREE_GLSV_GLD_CB(gld_cb); return NCSCC_RC_FAILURE; } /* Initialize amf framework */ if (gld_amf_init(gld_cb) != NCSCC_RC_SUCCESS) { m_LOG_GLD_SVC_PRVDR(GLD_AMF_INIT_ERROR, NCSFL_SEV_ERROR, __FILE__, __LINE__); m_MMGR_FREE_GLSV_GLD_CB(gld_cb); return NCSCC_RC_FAILURE; } m_LOG_GLD_SVC_PRVDR(GLD_AMF_INIT_SUCCESS, NCSFL_SEV_INFO, __FILE__, __LINE__); /* Bind to MDS */ if (gld_mds_init(gld_cb) != NCSCC_RC_SUCCESS) { saAmfFinalize(gld_cb->amf_hdl); m_MMGR_FREE_GLSV_GLD_CB(gld_cb); m_LOG_GLD_SVC_PRVDR(GLD_MDS_INSTALL_FAIL, NCSFL_SEV_ERROR, __FILE__, __LINE__); return NCSCC_RC_FAILURE; } else m_LOG_GLD_SVC_PRVDR(GLD_MDS_INSTALL_SUCCESS, NCSFL_SEV_INFO, __FILE__, __LINE__); /* Initialise with the MBCSV service */ if (glsv_gld_mbcsv_register(gld_cb) != NCSCC_RC_SUCCESS) { m_LOG_GLD_MBCSV(GLD_MBCSV_INIT_FAILED, NCSFL_SEV_ERROR, __FILE__, __LINE__); gld_mds_shut(gld_cb); saAmfFinalize(gld_cb->amf_hdl); m_MMGR_FREE_GLSV_GLD_CB(gld_cb); return NCSCC_RC_FAILURE; } else { m_LOG_GLD_MBCSV(GLD_MBCSV_INIT_SUCCESS, NCSFL_SEV_INFO, __FILE__, __LINE__); } /* register glsv with imm */ amf_error = gld_imm_init(gld_cb); if (amf_error != SA_AIS_OK) { glsv_gld_mbcsv_unregister(gld_cb); gld_mds_shut(gld_cb); saAmfFinalize(gld_cb->amf_hdl); m_MMGR_FREE_GLSV_GLD_CB(gld_cb); gld_log(NCSFL_SEV_ERROR, "Imm Init Failed %u\n", amf_error); return NCSCC_RC_FAILURE; } /* TASK CREATION AND INITIALIZING THE MAILBOX */ if ((m_NCS_IPC_CREATE(&gld_cb->mbx) != NCSCC_RC_SUCCESS) || (m_NCS_IPC_ATTACH(&gld_cb->mbx) != NCSCC_RC_SUCCESS) || (m_NCS_TASK_CREATE((NCS_OS_CB)gld_main_process, &gld_cb->mbx, "GLD", m_GLD_TASK_PRIORITY, m_GLD_STACKSIZE, &gld_cb->task_hdl) != NCSCC_RC_SUCCESS) || (m_NCS_TASK_START(gld_cb->task_hdl) != NCSCC_RC_SUCCESS)) { m_LOG_GLD_HEADLINE(GLD_IPC_TASK_INIT, NCSFL_SEV_ERROR, __FILE__, __LINE__, 0); saImmOiFinalize(gld_cb->immOiHandle); glsv_gld_mbcsv_unregister(gld_cb); gld_mds_shut(gld_cb); saAmfFinalize(gld_cb->amf_hdl); m_NCS_TASK_RELEASE(gld_cb->task_hdl); m_NCS_IPC_RELEASE(&gld_cb->mbx, NULL); m_MMGR_FREE_GLSV_GLD_CB(gld_cb); return (NCSCC_RC_FAILURE); } m_NCS_EDU_HDL_INIT(&gld_cb->edu_hdl); /* register GLD component with AvSv */ amf_error = saAmfComponentRegister(gld_cb->amf_hdl, &gld_cb->comp_name, (SaNameT *)NULL); if (amf_error != SA_AIS_OK) { m_LOG_GLD_SVC_PRVDR(GLD_AMF_REG_ERROR, NCSFL_SEV_ERROR, __FILE__, __LINE__); m_NCS_EDU_HDL_FLUSH(&gld_cb->edu_hdl); m_NCS_TASK_RELEASE(gld_cb->task_hdl); m_NCS_IPC_RELEASE(&gld_cb->mbx, NULL); saImmOiFinalize(gld_cb->immOiHandle); glsv_gld_mbcsv_unregister(gld_cb); gld_mds_shut(gld_cb); saAmfFinalize(gld_cb->amf_hdl); m_MMGR_FREE_GLSV_GLD_CB(gld_cb); return NCSCC_RC_FAILURE; } else m_LOG_GLD_SVC_PRVDR(GLD_AMF_REG_SUCCESS, NCSFL_SEV_INFO, __FILE__, __LINE__); /** start the AMF health check **/ memset(&Healthy, 0, sizeof(Healthy)); health_key = (int8 *)getenv("GLSV_ENV_HEALTHCHECK_KEY"); if (health_key == NULL) { if (strlen("A1B2") < sizeof(Healthy.key)) strncpy((char *)Healthy.key, "A1B2", sizeof(Healthy.key)); m_LOG_GLD_HEADLINE(GLD_HEALTH_KEY_DEFAULT_SET, NCSFL_SEV_INFO, __FILE__, __LINE__, 0); } else { if (strlen((char *)health_key) < sizeof(Healthy.key)) strncpy((char *)Healthy.key, (char *)health_key, SA_AMF_HEALTHCHECK_KEY_MAX - 1); } Healthy.keyLen = strlen((char *)Healthy.key); amf_error = saAmfHealthcheckStart(gld_cb->amf_hdl, &gld_cb->comp_name, &Healthy, SA_AMF_HEALTHCHECK_AMF_INVOKED, SA_AMF_COMPONENT_FAILOVER); if (amf_error != SA_AIS_OK) { m_LOG_GLD_SVC_PRVDR(GLD_AMF_HLTH_CHK_START_FAIL, NCSFL_SEV_ERROR, __FILE__, __LINE__); saAmfComponentUnregister(gld_cb->amf_hdl, &gld_cb->comp_name, (SaNameT *)NULL); m_NCS_EDU_HDL_FLUSH(&gld_cb->edu_hdl); m_NCS_TASK_RELEASE(gld_cb->task_hdl); m_NCS_IPC_RELEASE(&gld_cb->mbx, NULL); saImmOiFinalize(gld_cb->immOiHandle); glsv_gld_mbcsv_unregister(gld_cb); gld_mds_shut(gld_cb); saAmfFinalize(gld_cb->amf_hdl); m_MMGR_FREE_GLSV_GLD_CB(gld_cb); } else m_LOG_GLD_SVC_PRVDR(GLD_AMF_HLTH_CHK_START_DONE, NCSFL_SEV_INFO, __FILE__, __LINE__); return (res); }
/**************************************************************************** Name : ntfa_hdl_rec_add Description : This routine adds the handle record to the ntfa cb. Arguments : cb - ptr tot he NTFA control block reg_cbks - ptr to the set of registered callbacks client_id - obtained from NTFS. Return Values : ptr to the ntfa handle record Notes : None ******************************************************************************/ ntfa_client_hdl_rec_t *ntfa_hdl_rec_add(ntfa_cb_t *cb, const SaNtfCallbacksT *reg_cbks, uns32 client_id) { ntfa_client_hdl_rec_t *rec = calloc(1, sizeof(ntfa_client_hdl_rec_t)); if (rec == NULL) { TRACE("calloc failed"); goto done; } /* create the association with hdl-mngr */ if (0 == (rec->local_hdl = ncshm_create_hdl(NCS_HM_POOL_ID_COMMON, NCS_SERVICE_ID_NTFA, (NCSCONTEXT)rec))) { TRACE("ncshm_create_hdl failed"); goto err_free; } /* store the registered callbacks */ if (reg_cbks) memcpy((void *)&rec->reg_cbk, (void *)reg_cbks, sizeof(SaNtfCallbacksT)); /** Associate with the client_id obtained from NTFS **/ rec->ntfs_client_id = client_id; /** Initialize and attach the IPC/Priority queue **/ if (m_NCS_IPC_CREATE(&rec->mbx) != NCSCC_RC_SUCCESS) { TRACE("m_NCS_IPC_CREATE failed"); goto err_destroy_hdl; } if (m_NCS_IPC_ATTACH(&rec->mbx) != NCSCC_RC_SUCCESS) { TRACE("m_NCS_IPC_ATTACH failed"); goto err_ipc_release; } /** Add this to the Link List of ** CLIENT_HDL_RECORDS for this NTFA_CB **/ pthread_mutex_lock(&cb->cb_lock); /* add this to the start of the list */ rec->next = cb->client_list; cb->client_list = rec; pthread_mutex_unlock(&cb->cb_lock); goto done; err_ipc_release: (void)m_NCS_IPC_RELEASE(&rec->mbx, NULL); err_destroy_hdl: ncshm_destroy_hdl(NCS_SERVICE_ID_NTFA, rec->local_hdl); err_free: free(rec); rec = NULL; done: return rec; }
/**************************************************************************** * Name : dts_lib_init * * Description : This is the function which initalize the dts libarary. * This function creates an IPC mail Box and spawns DTS * thread. * This function initializes the CB, handle manager and MDS. * * Arguments : req_info - Request info. * * Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE. * * Notes : None. *****************************************************************************/ uns32 dts_lib_init(NCS_LIB_REQ_INFO *req_info) { NCSCONTEXT task_handle; DTS_CB *inst = &dts_cb; PCS_RDA_REQ pcs_rda_req; uns32 rc = NCSCC_RC_SUCCESS; memset(inst, 0, sizeof(DTS_CB)); #if (DTS_SIM_TEST_ENV == 1) if ('n' == ncs_util_get_char_option(req_info->info.create.argc, req_info->info.create.argv, "DTS_TEST=")) { inst->is_test = FALSE; } else inst->is_test = TRUE; #endif /* Initialize SAF stuff */ /* Fill in the Health check key */ strcpy((char *)inst->health_chk_key.key, DTS_AMF_HEALTH_CHECK_KEY); inst->health_chk_key.keyLen = strlen((char *)inst->health_chk_key.key); inst->invocationType = DTS_HB_INVOCATION_TYPE; /* Recommended recovery is to failover */ inst->recommendedRecovery = DTS_RECOVERY; /* RDA init */ memset(&pcs_rda_req, '\0', sizeof(pcs_rda_req)); pcs_rda_req.req_type = PCS_RDA_LIB_INIT; rc = pcs_rda_request(&pcs_rda_req); if (rc != PCSRDA_RC_SUCCESS) { return m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dts_lib_init: pcs_rda_request() failed for PCS_RDA_LIB_INIT"); } /* Get initial role from RDA */ memset(&pcs_rda_req, '\0', sizeof(pcs_rda_req)); pcs_rda_req.req_type = PCS_RDA_GET_ROLE; rc = pcs_rda_request(&pcs_rda_req); if (rc != PCSRDA_RC_SUCCESS) { return m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dts_lib_init: Failed to get initial role from RDA"); } /* Set initial role now */ switch (pcs_rda_req.info.io_role) { case PCS_RDA_ACTIVE: inst->ha_state = SA_AMF_HA_ACTIVE; m_DTS_DBG_SINK(NCSCC_RC_SUCCESS, "DTS init role is ACTIVE"); m_LOG_DTS_API(DTS_INIT_ROLE_ACTIVE); break; case PCS_RDA_STANDBY: inst->ha_state = SA_AMF_HA_STANDBY; m_DTS_DBG_SINK(NCSCC_RC_SUCCESS, "DTS init role is STANDBY"); m_LOG_DTS_API(DTS_INIT_ROLE_STANDBY); break; default: return m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dts_lib_init: Failed to get initial role from RDA"); } /* RDA finalize */ memset(&pcs_rda_req, '\0', sizeof(pcs_rda_req)); pcs_rda_req.req_type = PCS_RDA_LIB_DESTROY; rc = pcs_rda_request(&pcs_rda_req); if (rc != PCSRDA_RC_SUCCESS) { return m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dts_lib_init: Failed to perform lib destroy on RDA"); } inst->in_sync = TRUE; /* Attempt to open console device for logging */ inst->cons_fd = -1; if ((inst->cons_fd = dts_cons_open(O_RDWR | O_NOCTTY)) < 0) { /* Should we return frm here on failure?? I guess NOT */ m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dts_lib_init: Failed to open console"); } /* Create DTS mailbox */ if (m_NCS_IPC_CREATE(&gl_dts_mbx) != NCSCC_RC_SUCCESS) { return m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dts_lib_init: Failed to create DTS mail box"); } if (NCSCC_RC_SUCCESS != m_NCS_IPC_ATTACH(&gl_dts_mbx)) { m_NCS_IPC_RELEASE(&gl_dts_mbx, NULL); return m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dts_lib_init: IPC attach failed."); } #if (DTS_FLOW == 1) /* Keeping count of messages in DTS mailbox */ if (NCSCC_RC_SUCCESS != m_NCS_IPC_CONFIG_USR_COUNTERS(&gl_dts_mbx, NCS_IPC_PRIORITY_LOW, &inst->msg_count)) { m_NCS_IPC_DETACH(&gl_dts_mbx, dts_clear_mbx, inst); m_NCS_IPC_RELEASE(&gl_dts_mbx, NULL); return m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dts_lib_init: Failed to initialize DTS msg counters with LEAP"); } #endif /* Smik - initialize the signal handler */ if ((dts_app_signal_install(SIGUSR1, dts_amf_sigusr1_handler)) == -1) { m_NCS_IPC_DETACH(&gl_dts_mbx, dts_clear_mbx, inst); m_NCS_IPC_RELEASE(&gl_dts_mbx, NULL); return m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dts_lib_init: Failed to install signal handler"); } { DTS_LM_ARG arg; memset(&arg, 0, sizeof(DTS_LM_ARG)); arg.i_op = DTS_LM_OP_CREATE; arg.info.create.i_hmpool_id = NCS_HM_POOL_ID_COMMON; arg.info.create.i_vrid = 1; arg.info.create.task_handle = task_handle; /* Now create and initialize DTS control block */ if (dts_lm(&arg) != NCSCC_RC_SUCCESS) { m_NCS_IPC_DETACH(&gl_dts_mbx, dts_clear_mbx, inst); m_NCS_IPC_RELEASE(&gl_dts_mbx, NULL); return m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dts_lib_init: Failed to create and init DTS CB"); } } /* Create DTS's task */ if (m_NCS_TASK_CREATE((NCS_OS_CB)dts_do_evts, &gl_dts_mbx, NCS_DTS_TASKNAME, NCS_DTS_PRIORITY, NCS_DTS_STACKSIZE, &task_handle) != NCSCC_RC_SUCCESS) { m_NCS_IPC_DETACH(&gl_dts_mbx, dts_clear_mbx, inst); m_NCS_IPC_RELEASE(&gl_dts_mbx, NULL); return m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dts_lib_init: Failed to create DTS thread."); } /* Start DTS task */ if (m_NCS_TASK_START(task_handle) != NCSCC_RC_SUCCESS) { m_NCS_TASK_RELEASE(task_handle); m_NCS_IPC_DETACH(&gl_dts_mbx, dts_clear_mbx, inst); m_NCS_IPC_RELEASE(&gl_dts_mbx, NULL); return m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dts_lib_init: Failed to start DTS task"); } inst->task_handle = task_handle; if (dts_log_bind() != NCSCC_RC_SUCCESS) { m_DTS_LK(&inst->lock); m_LOG_DTS_LOCK(DTS_LK_LOCKED, &inst->lock); /* Do cleanup activities */ m_NCS_TASK_STOP(task_handle); m_NCS_TASK_RELEASE(task_handle); m_NCS_IPC_DETACH(&gl_dts_mbx, dts_clear_mbx, inst); m_NCS_IPC_RELEASE(&gl_dts_mbx, NULL); inst->created = FALSE; dtsv_mbcsv_deregister(inst); dts_mds_unreg(inst, TRUE); dtsv_clear_asciispec_tree(inst); dtsv_clear_libname_tree(inst); ncs_patricia_tree_destroy(&inst->svcid_asciispec_tree); ncs_patricia_tree_destroy(&inst->libname_asciispec_tree); ncs_patricia_tree_destroy(&inst->svc_tbl); ncs_patricia_tree_destroy(&inst->dta_list); m_DTS_UNLK(&inst->lock); m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &inst->lock); return m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dts_lib_init: Unable to bind DTS with DTSv"); } return NCSCC_RC_SUCCESS; }
/**************************************************************************** Name : eda_hdl_rec_add Description : This routine adds the handle record to the eda cb. Arguments : cb - ptr tot he EDA control block reg_cbks - ptr to the set of registered callbacks reg_id - obtained from EDS. version - version of the client. Return Values : ptr to the eda handle record Notes : None ******************************************************************************/ EDA_CLIENT_HDL_REC *eda_hdl_rec_add(EDA_CB **eda_cb, const SaEvtCallbacksT *reg_cbks, uns32 reg_id, SaVersionT version) { EDA_CLIENT_HDL_REC *rec = 0; /* allocate the hdl rec */ if (NULL == (rec = m_MMGR_ALLOC_EDA_CLIENT_HDL_REC)) { m_LOG_EDSV_A(EDA_MEMALLOC_FAILED, NCSFL_LC_EDSV_INIT, NCSFL_SEV_ERROR, 0, __FILE__, __LINE__, 0); goto error; } memset(rec, '\0', sizeof(EDA_CLIENT_HDL_REC)); /* create the association with hdl-mngr */ if (0 == (rec->local_hdl = ncshm_create_hdl((*eda_cb)->pool_id, NCS_SERVICE_ID_EDA, (NCSCONTEXT)rec))) { m_LOG_EDSV_A(EDA_FAILURE, NCSFL_LC_EDSV_INIT, NCSFL_SEV_ERROR, 0, __FILE__, __LINE__, 0); goto error; } /* store the registered callbacks */ if (reg_cbks) memcpy((void *)&rec->reg_cbk, (void *)reg_cbks, sizeof(SaEvtCallbacksT)); /** Associate with the reg_id obtained from EDS **/ rec->eds_reg_id = reg_id; rec->version.releaseCode = version.releaseCode; rec->version.majorVersion = version.majorVersion; rec->version.minorVersion = version.minorVersion; /** Initialize and attach the IPC/Priority queue **/ if (m_NCS_IPC_CREATE(&rec->mbx) != NCSCC_RC_SUCCESS) { m_LOG_EDSV_A(EDA_FAILURE, NCSFL_LC_EDSV_INIT, NCSFL_SEV_ERROR, 0, __FILE__, __LINE__, 0); goto error; } if (m_NCS_IPC_ATTACH(&rec->mbx) != NCSCC_RC_SUCCESS) { m_LOG_EDSV_A(EDA_FAILURE, NCSFL_LC_EDSV_INIT, NCSFL_SEV_ERROR, 0, __FILE__, __LINE__, 0); goto error; } /** Add this to the Link List of ** CLIENT_HDL_RECORDS for this EDA_CB **/ m_NCS_LOCK(&((*eda_cb)->cb_lock), NCS_LOCK_WRITE); /* add this to the start of the list */ rec->next = (*eda_cb)->eda_init_rec_list; (*eda_cb)->eda_init_rec_list = rec; m_NCS_UNLOCK(&((*eda_cb)->cb_lock), NCS_LOCK_WRITE); return rec; error: if (rec) { /* remove the association with hdl-mngr */ if (rec->local_hdl) ncshm_destroy_hdl(NCS_SERVICE_ID_EDA, rec->local_hdl); /** detach and release the IPC **/ m_NCS_IPC_DETACH(&rec->mbx, eda_clear_mbx, NULL); m_NCS_IPC_RELEASE(&rec->mbx, NULL); m_MMGR_FREE_EDA_CLIENT_HDL_REC(rec); } return NULL; }
/**************************************************************************** * Name : eds_se_lib_init * * Description : Invoked to Initialize the EDS * * * Arguments : * Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE.. * * Notes : None. *****************************************************************************/ static uint32_t eds_se_lib_init(NCS_LIB_REQ_INFO *req_info) { EDS_CB *eds_cb; uint32_t rc = NCSCC_RC_SUCCESS; TRACE_ENTER(); /* Allocate and initialize the control block */ if (NULL == (eds_cb = m_MMGR_ALLOC_EDS_CB)) { LOG_CR("malloc failed for control block"); TRACE_LEAVE(); return NCSCC_RC_FAILURE; } memset(eds_cb, '\0', sizeof(EDS_CB)); /* Obtain the hdl for EDS_CB from hdl-mgr */ gl_eds_hdl = eds_cb->my_hdl = ncshm_create_hdl(1, NCS_SERVICE_ID_EDS, (NCSCONTEXT)eds_cb); if (0 == eds_cb->my_hdl) { LOG_ER("Handle create failed for global eds handle"); ncshm_destroy_hdl(NCS_SERVICE_ID_EDS, gl_eds_hdl); gl_eds_hdl = 0; m_MMGR_FREE_EDS_CB(eds_cb); TRACE_LEAVE(); return NCSCC_RC_FAILURE; } /* initialize the eds cb lock */ m_NCS_LOCK_INIT(&eds_cb->cb_lock); /* Initialize eds control block */ if (NCSCC_RC_SUCCESS != (rc = eds_cb_init(eds_cb))) { /* Destroy the hdl for this CB */ ncshm_destroy_hdl(NCS_SERVICE_ID_EDS, gl_eds_hdl); gl_eds_hdl = 0; /* clean up the CB */ m_MMGR_FREE_EDS_CB(eds_cb); /* log the error */ TRACE_4("EDS control block init failed"); TRACE_LEAVE(); return rc; } m_NCS_EDU_HDL_INIT(&eds_cb->edu_hdl); /* Create the mbx to communicate with the EDS thread */ if (NCSCC_RC_SUCCESS != (rc = m_NCS_IPC_CREATE(&eds_cb->mbx))) { LOG_ER("EDS IPC mailbox create failed"); /* Release EDU handle */ m_NCS_EDU_HDL_FLUSH(&eds_cb->edu_hdl); /* Destroy the hdl for this CB */ ncshm_destroy_hdl(NCS_SERVICE_ID_EDS, gl_eds_hdl); gl_eds_hdl = 0; /* Free the control block */ m_MMGR_FREE_EDS_CB(eds_cb); TRACE_LEAVE(); return rc; } /* Attach the IPC to the created thread */ m_NCS_IPC_ATTACH(&eds_cb->mbx); /* Bind to MDS */ if (NCSCC_RC_SUCCESS != (rc = eds_mds_init(eds_cb))) { TRACE_4("eds mds init failed"); m_NCS_IPC_RELEASE(&eds_cb->mbx, NULL); /* Release EDU handle */ m_NCS_EDU_HDL_FLUSH(&eds_cb->edu_hdl); ncshm_destroy_hdl(NCS_SERVICE_ID_EDS, gl_eds_hdl); gl_eds_hdl = 0; m_MMGR_FREE_EDS_CB(eds_cb); TRACE_LEAVE(); return rc; } /* Initialize and Register with CLM */ rc = eds_clm_init(eds_cb); if (rc != SA_AIS_OK) { TRACE_4("CLM Init failed. Exiting"); exit(EXIT_FAILURE); } /* Initialize and Register with AMF */ rc = eds_amf_register(eds_cb); if (rc != NCSCC_RC_SUCCESS) { LOG_ER("AMF Init failed: Exiting."); exit(EXIT_FAILURE); } /* Initialize mbcsv interface */ if (NCSCC_RC_SUCCESS != (rc = eds_mbcsv_init(eds_cb))) { LOG_ER("eds mbcsv init failed"); /* Log it */ } TRACE("eds init done."); TRACE_LEAVE(); return (rc); }
/** * Initialize smfd * * @return uns32 */ static uns32 initialize_smfd(void) { uns32 rc; TRACE_ENTER(); /* Set the behaviour of SMF-IMM interactions */ immutilWrapperProfile.errorsAreFatal = 0; /* False, no reboot when fail */ immutilWrapperProfile.nTries = 500; /* Times */ immutilWrapperProfile.retryInterval = 400; /* MS */ if (ncs_agents_startup() != NCSCC_RC_SUCCESS) { LOG_ER("ncs_agents_startup FAILED"); rc = NCSCC_RC_FAILURE; goto done; } /* Initialize smfd control block */ if (smfd_cb_init(smfd_cb) != NCSCC_RC_SUCCESS) { TRACE("smfd_cb_init FAILED"); rc = NCSCC_RC_FAILURE; goto done; } /* Create the mailbox used for communication with SMFND */ if ((rc = m_NCS_IPC_CREATE(&smfd_cb->mbx)) != NCSCC_RC_SUCCESS) { LOG_ER("m_NCS_IPC_CREATE FAILED %d", rc); goto done; } /* Attach mailbox to this thread */ if ((rc = m_NCS_IPC_ATTACH(&smfd_cb->mbx) != NCSCC_RC_SUCCESS)) { LOG_ER("m_NCS_IPC_ATTACH FAILED %d", rc); goto done; } /* Create a selection object for USR1 signal handling */ if ((rc = ncs_sel_obj_create(&smfd_cb->usr1_sel_obj)) != NCSCC_RC_SUCCESS) { LOG_ER("ncs_sel_obj_create failed"); goto done; } /* Init mds communication */ if ((rc = smfd_mds_init(smfd_cb)) != NCSCC_RC_SUCCESS) { TRACE("smfd_mds_init FAILED %d", rc); return rc; } /* Init campaign OI */ if ((rc = campaign_oi_init(smfd_cb)) != NCSCC_RC_SUCCESS) { TRACE("campaign_oi_init FAILED %d", rc); return rc; } /* Check if AMF started */ if (smfd_cb->nid_started == 0) { /* Started by AMF, so let's init AMF */ if ((rc = smfd_amf_init(smfd_cb)) != NCSCC_RC_SUCCESS) { LOG_ER("init amf failed"); goto done; } } done: TRACE_LEAVE(); return (rc); }
/** * Initialize clm * * @return uns32 */ static uint32_t clms_init(void) { uint32_t rc = NCSCC_RC_FAILURE; TRACE_ENTER(); /* Determine how this process was started, by NID or AMF */ if (getenv("SA_AMF_COMPONENT_NAME") == NULL) clms_cb->nid_started = true; if (ncs_agents_startup() != NCSCC_RC_SUCCESS) { TRACE("ncs_core_agents_startup FAILED"); goto done; } /* Initialize clms control block */ if ((rc = clms_cb_init(clms_cb)) != NCSCC_RC_SUCCESS) { LOG_ER("clms_cb_init FAILED"); goto done; } if ((rc = rda_get_role(&clms_cb->ha_state)) != NCSCC_RC_SUCCESS) { LOG_ER("rda_get_role FAILED"); goto done; } TRACE("Current RDA Role %d", clms_cb->ha_state); if ((rc = rda_register_callback(0, rda_cb)) != NCSCC_RC_SUCCESS) { LOG_ER("rda_register_callback FAILED %u", rc); goto done; } /* Create the mailbox used for communication with CLMS */ if ((rc = m_NCS_IPC_CREATE(&clms_cb->mbx)) != NCSCC_RC_SUCCESS) { LOG_ER("m_NCS_IPC_CREATE FAILED %d", rc); goto done; } /* Attach mailbox to this thread */ if ((rc = m_NCS_IPC_ATTACH(&clms_cb->mbx) != NCSCC_RC_SUCCESS)) { LOG_ER("m_NCS_IPC_ATTACH FAILED %d", rc); goto done; } /*Initialize mds */ if ((rc = clms_mds_init(clms_cb)) != NCSCC_RC_SUCCESS) { LOG_ER("clms_mds_init FAILED %d", rc); goto done; } /* Initialize with MBCSV */ if ((rc = clms_mbcsv_init(clms_cb)) != NCSCC_RC_SUCCESS) { LOG_ER("clms_mbcsv_init FAILED"); goto done; } /* Initialize with IMMSv */ if ((rc = clms_imm_init(clms_cb)) != NCSCC_RC_SUCCESS) { LOG_ER("clms_imm_init FAILED"); goto done; } /* Declare as implementer && Read configuration data from IMM */ if ((rc = clms_imm_activate(clms_cb)) != SA_AIS_OK) { LOG_ER("clms_imm_activate FAILED"); goto done; } if ((rc = clms_ntf_init(clms_cb)) != SA_AIS_OK) { LOG_ER("clms_ntf_init FAILED"); goto done; } #ifdef ENABLE_AIS_PLM if ((rc = clms_plm_init(clms_cb)) != SA_AIS_OK) { LOG_ER("clms_plm_init FAILED"); goto done; } #endif /*Self Node update */ if ((rc = clms_self_node_info()) != NCSCC_RC_SUCCESS) goto done; /* Create a selection object */ if (clms_cb->nid_started && (rc = ncs_sel_obj_create(&usr1_sel_obj)) != NCSCC_RC_SUCCESS) { LOG_ER("ncs_sel_obj_create failed"); goto done; } /* ** Initialize a signal handler that will use the selection object. ** The signal is sent from our script when AMF does instantiate. */ if (clms_cb->nid_started && signal(SIGUSR1, sigusr1_handler) == SIG_ERR) { LOG_ER("signal USR1 failed: %s", strerror(errno)); goto done; } if (!clms_cb->nid_started && clms_amf_init(clms_cb) != NCSCC_RC_SUCCESS) { LOG_ER("AMF Initialization failed"); goto done; } /* Initialize with saflog. This is necessary to avoid * getting blocked by LOG during role change (switchover/failover) */ saflog_init(); rc = NCSCC_RC_SUCCESS; done: if (clms_cb->nid_started && nid_notify("CLMD", rc, NULL) != NCSCC_RC_SUCCESS) { LOG_ER("nid_notify failed"); rc = NCSCC_RC_FAILURE; } TRACE_LEAVE(); return rc; }
/**************************************************************************** * Name : glnd_cb_create * * Description : This will create the CB and create the internal structures * * Arguments : pool id - pool id for the handle manager * * Return Values : GLND CB Pointer * * Notes : None. *****************************************************************************/ GLND_CB *glnd_cb_create(uns32 pool_id) { GLND_CB *glnd_cb = NULL; NCS_PATRICIA_PARAMS params = { 0 }; SaAmfHealthcheckKeyT healthy; int8 *health_key = NULL; SaAisErrorT amf_error; /* register with the Log service */ glnd_flx_log_reg(); /* allocate the memory */ glnd_cb = m_MMGR_ALLOC_GLND_CB; if (!glnd_cb) { m_LOG_GLND_MEMFAIL(GLND_CB_ALLOC_FAILED, __FILE__, __LINE__); glnd_flx_log_dereg(); return NULL; } memset(glnd_cb, 0, sizeof(GLND_CB)); glnd_cb->pool_id = pool_id; /* create the handle */ glnd_cb->cb_hdl_id = ncshm_create_hdl((uns8)pool_id, NCS_SERVICE_ID_GLND, (NCSCONTEXT)glnd_cb); if (!glnd_cb->cb_hdl_id) { m_LOG_GLND_HEADLINE(GLND_CB_TAKE_HANDLE_FAILED, NCSFL_SEV_ERROR, __FILE__, __LINE__); goto hdl_err; } /* create the internal strucutures */ /* create the client Tree */ params.key_size = sizeof(SaLckHandleT); params.info_size = 0; if ((ncs_patricia_tree_init(&glnd_cb->glnd_client_tree, ¶ms)) != NCSCC_RC_SUCCESS) { m_LOG_GLND_HEADLINE(GLND_CLIENT_TREE_INIT_FAILED, NCSFL_SEV_ERROR, __FILE__, __LINE__); goto client_err; } /* create the agent tree */ params.key_size = sizeof(MDS_DEST); params.info_size = 0; if ((ncs_patricia_tree_init(&glnd_cb->glnd_agent_tree, ¶ms)) != NCSCC_RC_SUCCESS) { m_LOG_GLND_HEADLINE(GLND_AGENT_TREE_INIT_FAILED, NCSFL_SEV_ERROR, __FILE__, __LINE__); goto agent_err; } /* create the Resource tree */ params.key_size = sizeof(SaLckResourceIdT); params.info_size = 0; if ((ncs_patricia_tree_init(&glnd_cb->glnd_res_tree, ¶ms)) != NCSCC_RC_SUCCESS) { m_LOG_GLND_HEADLINE(GLND_RSC_TREE_INIT_FAILED, NCSFL_SEV_ERROR, __FILE__, __LINE__); goto res_err; } /* create the mail box and attach it */ if (m_NCS_IPC_CREATE(&glnd_cb->glnd_mbx) != NCSCC_RC_SUCCESS) { m_LOG_GLND_HEADLINE(GLND_IPC_CREATE_FAILED, NCSFL_SEV_ERROR, __FILE__, __LINE__); goto mbx_create_err; } if (m_NCS_IPC_ATTACH(&glnd_cb->glnd_mbx) != NCSCC_RC_SUCCESS) { m_LOG_GLND_HEADLINE(GLND_IPC_ATTACH_FAILED, NCSFL_SEV_ERROR, __FILE__, __LINE__); goto mbx_attach_err; } /* EDU initialisation */ m_NCS_EDU_HDL_INIT(&glnd_cb->glnd_edu_hdl); /* resigter with the MDS */ if (glnd_mds_register(glnd_cb) != NCSCC_RC_SUCCESS) { m_LOG_GLND_HEADLINE(GLND_MDS_REGISTER_FAILED, NCSFL_SEV_ERROR, __FILE__, __LINE__); goto mds_err; } else m_LOG_GLND_HEADLINE(GLND_MDS_REGISTER_SUCCESS, NCSFL_SEV_NOTICE, __FILE__, __LINE__); /* Initialise with the AMF service */ if (glnd_amf_init(glnd_cb) != NCSCC_RC_SUCCESS) { m_LOG_GLND_HEADLINE(GLND_AMF_INIT_FAILED, NCSFL_SEV_ERROR, __FILE__, __LINE__); goto amf_init_err; } else m_LOG_GLND_HEADLINE(GLND_AMF_INIT_SUCCESS, NCSFL_SEV_NOTICE, __FILE__, __LINE__); /* register with the AMF service */ if (glnd_amf_register(glnd_cb) != NCSCC_RC_SUCCESS) { m_LOG_GLND_HEADLINE(GLND_AMF_REGISTER_FAILED, NCSFL_SEV_ERROR, __FILE__, __LINE__); goto amf_reg_err; } else m_LOG_GLND_HEADLINE(GLND_AMF_REGISTER_SUCCESS, NCSFL_SEV_NOTICE, __FILE__, __LINE__); /* everything went off well.. store the hdl in the global variable */ gl_glnd_hdl = glnd_cb->cb_hdl_id; /* start the AMF Health Check */ memset(&healthy, 0, sizeof(healthy)); health_key = (int8 *)getenv("GLSV_ENV_HEALTHCHECK_KEY"); if (health_key == NULL) { if (strlen("A1B2") < sizeof(healthy.key)) strncpy((char *)healthy.key, "A1B2", sizeof(healthy.key)); /* TBD Log the info */ } else { if (strlen((char *)health_key) <= sizeof(healthy.key)) strncpy((char *)healthy.key, (char *)health_key, SA_AMF_HEALTHCHECK_KEY_MAX - 1); } healthy.keyLen = strlen((char *)healthy.key); amf_error = saAmfHealthcheckStart(glnd_cb->amf_hdl, &glnd_cb->comp_name, &healthy, SA_AMF_HEALTHCHECK_AMF_INVOKED, SA_AMF_COMPONENT_RESTART); if (amf_error != SA_AIS_OK) { m_LOG_GLND_HEADLINE(GLND_AMF_HEALTHCHECK_START_FAILED, NCSFL_SEV_ERROR, __FILE__, __LINE__); } else m_LOG_GLND_HEADLINE(GLND_AMF_HEALTHCHECK_START_SUCCESS, NCSFL_SEV_NOTICE, __FILE__, __LINE__); if (glnd_cb->node_state != GLND_CLIENT_INFO_GET_STATE) { TRACE("setting the state as GLND_OPERATIONAL_STATE"); /* GLND HAS STRTED */ glnd_cb->node_state = GLND_OPERATIONAL_STATE; } /*create a shared memory segment to Checkpint Resource info, lck_info & backup_event info */ if (glnd_shm_create(glnd_cb) != NCSCC_RC_SUCCESS) goto glnd_shm_create_fail; return glnd_cb; glnd_shm_create_fail: glnd_amf_deregister(glnd_cb); amf_reg_err: glnd_amf_de_init(glnd_cb); amf_init_err: glnd_mds_unregister(glnd_cb); mds_err: m_NCS_EDU_HDL_FLUSH(&glnd_cb->glnd_edu_hdl); m_NCS_IPC_DETACH(&glnd_cb->glnd_mbx, glnd_cleanup_mbx, glnd_cb); mbx_attach_err: m_NCS_IPC_RELEASE(&glnd_cb->glnd_mbx, NULL); mbx_create_err: ncs_patricia_tree_destroy(&glnd_cb->glnd_res_tree); res_err: ncs_patricia_tree_destroy(&glnd_cb->glnd_agent_tree); agent_err: ncs_patricia_tree_destroy(&glnd_cb->glnd_client_tree); client_err: ncshm_destroy_hdl(NCS_SERVICE_ID_GLND, glnd_cb->cb_hdl_id); hdl_err: glnd_flx_log_dereg(); /* free the control block */ m_MMGR_FREE_GLND_CB(glnd_cb); return NULL; }