C++ TRACE_ENTER函数代码示例

/****************************************************************************
 * Name          : glnd_lib_req
 *
 * Description   : This is the NCS SE API which is used to init/destroy or 
 *                 Create/destroy PWE's. This will be called by SBOM.
 *
 * Arguments     : req_info  - This is the pointer to the input information 
 *                             which SBOM gives.  
 *
 * Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE..
 *
 * Notes         : None.
 *****************************************************************************/
uint32_t glnd_lib_req(NCS_LIB_REQ_INFO *req_info)
{
	uint32_t res = NCSCC_RC_FAILURE;
	TRACE_ENTER();
	
	switch (req_info->i_op) {
	case NCS_LIB_REQ_CREATE:
		if( (res = glnd_se_lib_create(NCS_HM_POOL_ID_COMMON))!= NCSCC_RC_SUCCESS )
			TRACE_2("GLND se lib create failed");	
		break;
	case NCS_LIB_REQ_DESTROY:
		if( (res = glnd_se_lib_destroy()) != NCSCC_RC_SUCCESS )
			TRACE_2("GLND se lib destroy failed");
		break;
	default:
		break;
	}
	TRACE_LEAVE2("%s return value %u", (res == NCSCC_RC_SUCCESS)?"SUCCESS":"FAILURE", res);
	return (res);
}

/*******************************************************************************************
 * Name                   : cpd_a2s_ckpt_dest_down
 * 
 * Description            : Function to delete the destination of the already existing 
 *                          checkpoint
 *
 * Arguments              : CPD_CKPT_INFO_NODE - CPD Checkpoint info node
 *
 * Return Values          : None , Error message is logged
 *
********************************************************************************************/
void cpd_a2s_ckpt_dest_down(CPD_CB *cb, CPD_CKPT_INFO_NODE *ckpt_node, MDS_DEST *dest)
{
	CPD_MBCSV_MSG cpd_msg;
	uint32_t rc = SA_AIS_OK;

	TRACE_ENTER();
	memset(&cpd_msg, '\0', sizeof(CPD_MBCSV_MSG));
	cpd_msg.type = CPD_A2S_MSG_CKPT_DEST_DOWN;
	cpd_msg.info.dest_down.ckpt_id = ckpt_node->ckpt_id;
	cpd_msg.info.dest_down.mds_dest = *dest;

	TRACE("CPND 1 IS IN RESTART NOW ");

	rc = cpd_mbcsv_async_update(cb, &cpd_msg);
	if (rc != SA_AIS_OK)
		TRACE_4("cpd A2S ckpt async update failed for ckptid:%llx,dest: %"PRIu64,cpd_msg.info.dest_down.ckpt_id, *dest);
	else
		TRACE_1("cpd A2S ckpt async update del success for ckptid:%llx,dest:%"PRIu64,cpd_msg.info.dest_down.ckpt_id, *dest);
	TRACE_LEAVE();
}

static void
Permedia2SubsequentHorVertLine(ScrnInfoPtr pScrn,int x,int y,int len,int dir)
{
    GLINTPtr pGlint = GLINTPTR(pScrn);
    
    TRACE_ENTER("Permedia2SubsequentHorVertLine");
    GLINT_WAIT(6);
    GLINT_WRITE_REG(x<<16, StartXDom);
    GLINT_WRITE_REG(y<<16, StartY);
    if (dir == DEGREES_0) {
	GLINT_WRITE_REG(1<<16, dXDom);
	GLINT_WRITE_REG(0<<16, dY);
    } else {
	GLINT_WRITE_REG(0<<16, dXDom);
	GLINT_WRITE_REG(1<<16, dY);
    }

    GLINT_WRITE_REG(len, GLINTCount);
    GLINT_WRITE_REG(PrimitiveLine, Render);
}

/**
 *   response to the lib on a saNtfNotificationSend request 
 *   @param error    error code sent back to the client
 *   @param notificationId
 *   @param mdsCtxt
 *   @param frDest
 *
 */
void notfication_result_lib(SaAisErrorT error,
			    SaNtfIdentifierT notificationId, MDS_SYNC_SND_CTXT *mdsCtxt, MDS_DEST frDest)
{
	uns32 rc;
	ntfsv_msg_t msg;
	TRACE_ENTER();

	msg.type = NTFSV_NTFA_API_RESP_MSG;
	msg.info.api_resp_info.type = NTFSV_SEND_NOT_RSP;
	msg.info.api_resp_info.rc = error;
	msg.info.api_resp_info.param.send_not_rsp.notificationId = notificationId;
	TRACE_4("not_id: %llu, rv: %u", notificationId, error);
	rc = ntfs_mds_msg_send(ntfs_cb, &msg, &frDest, mdsCtxt, MDS_SEND_PRIORITY_HIGH);

	if (rc != NCSCC_RC_SUCCESS) {
		TRACE("ntfs_mds_msg_send FAILED");
		/* TODO: what to do exit here? */
	}
	TRACE_LEAVE();
};

void saImmOmAdminOperationContinueAsync_01(void)
{
    TRACE_ENTER();
    const SaNameT objectName = {strlen("opensafImm=opensafImm,safApp=safImmService"), "opensafImm=opensafImm,safApp=safImmService"};
    const SaImmAdminOwnerNameT adminOwnerName = (SaImmAdminOwnerNameT) __FUNCTION__;
    SaImmAdminOwnerHandleT ownerHandle;
    SaInvocationT invocation=999;
    SaImmContinuationIdT continuationId = 666;
    safassert(saImmOmInitialize(&immOmHandle, &immOmCallbacks, &immVersion), SA_AIS_OK);
    safassert(saImmOmAdminOwnerInitialize(immOmHandle, adminOwnerName, SA_TRUE, &ownerHandle), SA_AIS_OK);
    test_validate(saImmOmAdminOperationContinueAsync(
                                                     ownerHandle,
                                                     invocation,
                                                     &objectName,
                                                     continuationId), 
        SA_AIS_ERR_NOT_SUPPORTED);
    safassert(saImmOmAdminOwnerFinalize(ownerHandle), SA_AIS_OK);
    safassert(saImmOmFinalize(immOmHandle), SA_AIS_OK);
    TRACE_LEAVE();
}

/**
 *   Response to the lib on a saNtfNotificationReadInitialize
 *   request
 *  
 *   @param error     error code sent back to the library
 *   @param readerId  out parameter, unique id for the new reader
 *                    set by admin to identify a reader.
 */
void new_reader_res_lib(SaAisErrorT error, unsigned int readerId, MDS_DEST mdsDest, MDS_SYNC_SND_CTXT *mdsCtxt)
{
	uns32 rc = NCSCC_RC_SUCCESS;
	ntfsv_msg_t msg;
	TRACE_ENTER();

	msg.type = NTFSV_NTFA_API_RESP_MSG;
	msg.info.api_resp_info.type = NTFSV_READER_INITIALIZE_RSP;
	msg.info.api_resp_info.rc = error;
	msg.info.api_resp_info.param.reader_init_rsp.readerId = readerId;
	TRACE_4("readerId: %u, rv: %u", readerId, error);

	rc = ntfs_mds_msg_send(ntfs_cb, &msg, &mdsDest, mdsCtxt, MDS_SEND_PRIORITY_HIGH);
	if (rc != NCSCC_RC_SUCCESS) {
		TRACE("ntfs_mds_msg_send FAILED");
		/* TODO: what to do exit here? */
	}

/* TODO: async update*/
};

/******************************************************************************************************************
 * Name                   :glsv_gld_mbcsv_chgrole 
 *
 * Description            : To assign  role for a component

 * Arguments              : GLSV_GLD_CB - cb pointer
 *
 * Return Values          : Success / Error
 *
 * Notes                  : This API is use for setting the role. Role Standby - initiate Cold Sync Request if it finds Active
                            Role Active - send ckpt data to multiple standby peers
 *********************************************************************************************************************/
uint32_t glsv_gld_mbcsv_chgrole(GLSV_GLD_CB *gld_cb)
{
	NCS_MBCSV_ARG arg;
	uint32_t rc = NCSCC_RC_SUCCESS;
	TRACE_ENTER();
	memset(&arg, '\0', sizeof(NCS_MBCSV_ARG));

	arg.i_op = NCS_MBCSV_OP_CHG_ROLE;
	arg.i_mbcsv_hdl = gld_cb->mbcsv_handle;
	arg.info.chg_role.i_ckpt_hdl = gld_cb->o_ckpt_hdl;
	arg.info.chg_role.i_ha_state = gld_cb->ha_state;	/*  ha_state is assigned at the time of amf_init where csi_set_callback will assign the state */

	LOG_IN("Setting the state HaState as :%d", gld_cb->ha_state);
	if (ncs_mbcsv_svc(&arg) != SA_AIS_OK) {
		LOG_ER("GLD mbcsv chgrole failed");
		rc = NCSCC_RC_FAILURE;
	}
 	TRACE_LEAVE();
	return rc;
}

/**
 *   Response to the lib after saNtfNotificationUnsubscribe request
 *
 *   @param error    error code sent back to the library
 *   @param subId    Subscribtion id for the canceled subscription
 */
void unsubscribe_res_lib(SaAisErrorT error, SaNtfSubscriptionIdT subId, MDS_DEST mdsDest, MDS_SYNC_SND_CTXT *mdsCtxt)
{
	uns32 rc = NCSCC_RC_SUCCESS;
	ntfsv_msg_t msg;
	TRACE_ENTER();

	msg.type = NTFSV_NTFA_API_RESP_MSG;
	msg.info.api_resp_info.type = NTFSV_UNSUBSCRIBE_RSP;
	msg.info.api_resp_info.rc = error;
	msg.info.api_resp_info.param.unsubscribe_rsp.subscriptionId = subId;
	TRACE_4("subscriptionId: %u, rv: %u", subId, error);

	rc = ntfs_mds_msg_send(ntfs_cb, &msg, &mdsDest, mdsCtxt, MDS_SEND_PRIORITY_HIGH);
	if (rc != NCSCC_RC_SUCCESS) {
		TRACE("ntfs_mds_msg_send FAILED");
		/* TODO: what to do exit here? */
	}

	TRACE_LEAVE();
};

/****************************************************************************
  Name          : avnd_pgdb_mem_rec_rmv
 
  Description   : This routine removes a PG member record from the PG record.
 
  Arguments     : cb            - ptr to the AvND control block
                  pg            - ptr to the pg rec
                  comp_name - ptr to the comp-name
 
  Return Values : ptr to the pg member rec, if successfully removed
                  0, otherwise
 
  Notes         : This routine only pops the cooresponding member record. It
                  doesn't delete it.
******************************************************************************/
AVND_PG_MEM *avnd_pgdb_mem_rec_rmv(AVND_CB *cb, AVND_PG *pg, SaNameT *comp_name)
{
	AVND_PG_MEM *pg_mem = 0;
	TRACE_ENTER();

	/* get the pg mem record */
	pg_mem = m_AVND_PGDB_MEM_REC_GET(*pg, *comp_name);
	if (!pg_mem)
		return 0;

	/* remove from the dll */
	ncs_db_link_list_remove(&pg->mem_list, (uns8 *)comp_name);

	/* update the params that are no longer valid */
	pg_mem->info.change = SA_AMF_PROTECTION_GROUP_REMOVED;
	pg_mem->info.member.haState = 0;

	TRACE_LEAVE();
	return pg_mem;
}

/****************************************************************************
 * Name          : cpnd_ckpt_sec_get_create
 *
 * Description   : Function to Find the section in a checkpoint before create.
 *
 * Arguments     : CPND_CKPT_NODE *cp_node - Check point node.
 *               : SaCkptSectionIdT id - Section Identifier
 *                 
 * Return Values :  NULL/CPND_CKPT_SECTION_INFO
 *
 * Notes         : None.
 *****************************************************************************/
CPND_CKPT_SECTION_INFO *cpnd_ckpt_sec_get_create(CPND_CKPT_NODE *cp_node, SaCkptSectionIdT *id)
{
	CPND_CKPT_SECTION_INFO *pSecPtr = NULL;
	TRACE_ENTER();
	if (cp_node->replica_info.n_secs == 0) {
		TRACE_2("cpnd replica has no sections for ckpt_id:%llx",cp_node->ckpt_id);
		TRACE_LEAVE();
		return NULL;
	}
	pSecPtr = cp_node->replica_info.section_info;
	while (pSecPtr != NULL) {
		if ((pSecPtr->sec_id.idLen == id->idLen) && (memcmp(pSecPtr->sec_id.id, id->id, id->idLen) == 0)) {
			TRACE_LEAVE();
			return pSecPtr;
		}
		pSecPtr = pSecPtr->next;
	}
	TRACE_LEAVE();
	return NULL;
}

/****************************************************************************
 * Name          : cpd_amf_register
 *
 * Description   : CPD registers with AMF for involking process.
 *
 * Arguments     : cpd_cb  - Ifsv control block pointer.
 *
 * Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE.
 *
 * Notes         : None.
 *****************************************************************************/
uint32_t cpd_amf_register(CPD_CB *cpd_cb)
{
	SaAisErrorT error;
	TRACE_ENTER();
	/* get the component name */
	error = saAmfComponentNameGet(cpd_cb->amf_hdl, &cpd_cb->comp_name);
	if (error != SA_AIS_OK) {
		LOG_ER("cpd amf compname get failed with Error: %u",error);
		TRACE_LEAVE();
		return NCSCC_RC_FAILURE;
	}

	if (saAmfComponentRegister(cpd_cb->amf_hdl, &cpd_cb->comp_name, (SaNameT *)NULL) == SA_AIS_OK) {
		TRACE_LEAVE2("cpd amf register success for %s",cpd_cb->comp_name.value);
		return NCSCC_RC_SUCCESS;
	} else {
		TRACE_LEAVE2("cpd Amf component register failed for %s",cpd_cb->comp_name.value);
		return NCSCC_RC_FAILURE;
	}
}

/*****************************************************************************
  PROCEDURE NAME : gld_process_send_non_master_status

  DESCRIPTION    : This function sends the nonmaster status to all the masters
                   corresponding to the resources opened by this node

  ARGUMENTS      :gld_cb      - ptr to the GLD control block
                  node_details
                  status

  RETURNS        :NCSCC_RC_FAILURE/NCSCC_RC_SUCCESS

  NOTES         : None
*****************************************************************************/
static uint32_t gld_process_send_non_master_status(GLSV_GLD_CB *gld_cb, GLSV_GLD_GLND_DETAILS *node_details, uint32_t status)
{
	GLSV_GLD_GLND_RSC_REF *glnd_rsc = NULL;
	GLSV_GLND_EVT glnd_evt;
	NCSMDS_INFO snd_mds;
	uint32_t res = NCSCC_RC_FAILURE;
	TRACE_ENTER();

	glnd_rsc = (GLSV_GLD_GLND_RSC_REF *)ncs_patricia_tree_getnext(&node_details->rsc_info_tree, (uint8_t *)0);
	while (glnd_rsc) {
		if (glnd_rsc->rsc_info->node_list->node_id != node_details->node_id) {
			memset(&glnd_evt, '\0', sizeof(GLSV_GLND_EVT));

			glnd_evt.type = GLSV_GLND_EVT_NON_MASTER_INFO;
			glnd_evt.info.non_master_info.dest_id = node_details->dest_id;
			glnd_evt.info.non_master_info.status = status;

			snd_mds.i_mds_hdl = gld_cb->mds_handle;
			snd_mds.i_svc_id = NCSMDS_SVC_ID_GLD;
			snd_mds.i_op = MDS_SEND;
			snd_mds.info.svc_send.i_msg = (NCSCONTEXT)&glnd_evt;
			snd_mds.info.svc_send.i_to_svc = NCSMDS_SVC_ID_GLND;
			snd_mds.info.svc_send.i_priority = MDS_SEND_PRIORITY_HIGH;
			snd_mds.info.svc_send.i_sendtype = MDS_SENDTYPE_SND;
			snd_mds.info.svc_send.info.snd.i_to_dest = glnd_rsc->rsc_info->node_list->dest_id;

			res = ncsmds_api(&snd_mds);
			if (res != NCSCC_RC_SUCCESS) {
				LOG_ER("MDS Send failed");
				goto end;
			}
		}
		glnd_rsc =
		    (GLSV_GLD_GLND_RSC_REF *)ncs_patricia_tree_getnext(&node_details->rsc_info_tree,
								       (uint8_t *)&glnd_rsc->rsc_id);
	}
 end:
	TRACE_LEAVE();
	return res;

}

/************************************************************
Start the unbind of a network driver from the protocol driver
************************************************************/
VOID NDIS_API
PacketUnbindAdapter( OUT PNDIS_STATUS	Status,
                     IN  NDIS_HANDLE	ProtocolBindingContext,
                     IN  NDIS_HANDLE	UnbindContext )
{
    POPEN_INSTANCE	Open;
    NDIS_STATUS		nsCloseStatus;

    TRACE_ENTER( "UnbindAdapter" );


    Open = (POPEN_INSTANCE)ProtocolBindingContext;
    Open->BindAdapterContext = UnbindContext;
    /*clean the pending requests*/
    PacketCleanUp( Status, Open );
    Open->Status = NDIS_STATUS_PENDING;
    /*Calls NDIS to close the selected adapter*/

    NdisCloseAdapter( &nsCloseStatus, Open->AdapterHandle );
    if ( nsCloseStatus == NDIS_STATUS_PENDING )
    {
        while ( Open->Status == NDIS_STATUS_PENDING )
            YieldExecution();
    }
    else
    {
        PacketUnbindAdapterComplete( Open, nsCloseStatus );
    }
    *Status = Open->Status;
    if ( *Status == NDIS_STATUS_SUCCESS )
    {
        NdisFreeMemory( Open, sizeof( OPEN_INSTANCE ) ,  0 );
    }
    else
    {
        IF_TRACE( "Unbind Operation FAILED!" );
    }
    TRACE_LEAVE( "CloseAdapter" );

    return;
}

/**
 * Thread start routine to register with AMF and start health check
 * Error handling: exits process at failure
 * @param __cb control block pointer
 */
static void* amf_init_start(void *notused)
{
	SaAisErrorT error;
	const char *health_key;
	SaAmfHealthcheckKeyT healthy;

	TRACE_ENTER();

	error = saAmfComponentRegister(immd_cb->amf_hdl, &immd_cb->comp_name, NULL);
	if (error != SA_AIS_OK) {
		LOG_ER("saAmfComponentRegister failed: %u, exiting", error);
		exit(1);
	}

	memset(&healthy, 0, sizeof(healthy));
	health_key = getenv("IMMSV_ENV_HEALTHCHECK_KEY");

	if (health_key == NULL) {
		strncpy((char *)healthy.key, "A1B2", sizeof(healthy.key));
		healthy.keyLen = (SaUint16T) strlen((char *)healthy.key);
	} else {
		healthy.keyLen = (SaUint16T) strlen((char *)health_key);
		if (healthy.keyLen < sizeof(healthy.key)) {
			strncpy((char *)healthy.key, health_key, sizeof(healthy.key));
		} else {
			LOG_ER("Health check key too long:%u, exiting", healthy.keyLen);
			exit(1);
		}
	}

	error = saAmfHealthcheckStart(immd_cb->amf_hdl, &immd_cb->comp_name,
		&healthy, SA_AMF_HEALTHCHECK_AMF_INVOKED, SA_AMF_COMPONENT_FAILOVER);

	if (error != SA_AIS_OK) {
		LOG_ER("saAmfHealthcheckStart failed: %u, exiting", error);
		exit(1);
	}

	TRACE_LEAVE();
	return NULL;
}

NTSTATUS
NTAPI
WSKCloseSocket(
	IN PWSK_SOCKET WskSocket
	)
{
	KEVENT          CompletionEvent = { 0 };
	PIRP            Irp = NULL;
	NTSTATUS        Status = STATUS_UNSUCCESSFUL;

	TRACE_ENTER();

	if (g_SocketsState != INITIALIZED || !WskSocket)
	{
		TRACE_EXIT();
		return STATUS_INVALID_PARAMETER;
	}

	Status = InitWskData(&Irp, &CompletionEvent);
	if (!NT_SUCCESS(Status))
	{
		TRACE_MESSAGE1(PACKET_DEBUG_LOUD, "WSKCloseSocket()::InitWskData() failed with status 0x%08X\n", Status);
		TRACE_EXIT();
		return Status;
	}

	Status = ((PWSK_PROVIDER_BASIC_DISPATCH)WskSocket->Dispatch)->WskCloseSocket(WskSocket, Irp);
	if (Status == STATUS_PENDING)
	{
		KeWaitForSingleObject(&CompletionEvent, Executive, KernelMode, FALSE, NULL);
		Status = Irp->IoStatus.Status;
	}
	else if (Status != STATUS_SUCCESS)
	{
		TRACE_MESSAGE1(PACKET_DEBUG_LOUD, "WSKCloseSocket()::Dispatch::WskSocket() failed with status 0x%08X\n", Status);
	}

	IoFreeIrp(Irp);
	TRACE_EXIT();
	return Status;
}