自学教程：C++ ESIF_ASSERT函数代码示例

static enum esif_rc esif_ccb_timer_obj_create(	const esif_ccb_timer_cb function_ptr,	/* Callback when timer fires */	void *context_ptr,			/* Callback context if any */	struct esif_timer_obj **timer_obj_ptr	){	enum esif_rc rc = ESIF_OK;	struct esif_timer_obj *new_timer_obj_ptr = NULL;	ESIF_ASSERT(function_ptr != NULL);	ESIF_ASSERT(timer_obj_ptr != NULL);	new_timer_obj_ptr = (struct esif_timer_obj *)esif_ccb_malloc(sizeof(*new_timer_obj_ptr));	if (NULL == new_timer_obj_ptr) {		rc = ESIF_E_NO_MEMORY;		goto exit;	}	rc = esif_ccb_timer_obj_create_timer(new_timer_obj_ptr);	if (rc != ESIF_OK)		goto exit;	new_timer_obj_ptr->function_ptr = function_ptr;	new_timer_obj_ptr->context_ptr = context_ptr;	*timer_obj_ptr = new_timer_obj_ptr;exit:	if (rc != ESIF_OK)		esif_ccb_timer_obj_destroy(new_timer_obj_ptr);	return rc;}

static struct esif_link_list_node * esif_find_node_in_ht_ll(    struct esif_link_list *ll_ptr,    u8 *key_ptr,    u32 key_length){    struct esif_link_list_node *cur_ptr = NULL;    struct esif_ht_node *ht_node = NULL;    ESIF_ASSERT(ll_ptr != NULL);    ESIF_ASSERT(key_ptr != NULL);    cur_ptr = ll_ptr->head_ptr;    while (cur_ptr) {        ht_node = (struct esif_ht_node *)cur_ptr->data_ptr;        if (ht_node != NULL) {            if (esif_cmp_keys(key_ptr, key_length,                              ht_node->key_ptr, ht_node->key_length)) {                break;            }        }        cur_ptr = cur_ptr->next_ptr;    }    return cur_ptr;}

/* Get link list corresponding to the hash index */struct esif_link_list * esif_ht_get_ll(    struct esif_ht *self,    u8 *key_ptr,    u32 key_length){    struct esif_link_list *ll_ptr = NULL;    u32 hash_index;    ESIF_ASSERT(key_ptr != NULL);    ESIF_ASSERT(self != NULL);    hash_index = esif_compute_hash(key_ptr, key_length) % self->size;    ll_ptr = self->table[hash_index];    ESIF_TRACE_DYN_VERB(        "Key %p, key size %d, table %p index %d ll %p/n",        key_ptr,        key_length,        self,        hash_index,        ll_ptr);    return ll_ptr;}

static struct esif_ht_node *esif_ht_get_ht_node(    struct esif_ht *self,    u8 *key_ptr,    u32 key_length){    struct esif_link_list *ll_ptr = NULL;    struct esif_link_list_node *ll_node = NULL;    struct esif_ht_node *ht_node = NULL;    ESIF_ASSERT(key_ptr != NULL);    ESIF_ASSERT(self != NULL);    ll_ptr = esif_ht_get_ll(self, key_ptr, key_length);    if (ll_ptr == NULL) {        ESIF_ASSERT(ESIF_FALSE); /* Should never happen */        ESIF_TRACE_DYN_VERB("LL NULL for passed in key/n");        goto exit;    }    ll_node = esif_find_node_in_ht_ll(ll_ptr, key_ptr, key_length);    if (ll_node == NULL) {        ESIF_TRACE_DYN_VERB("LL node not found for passed in key/n");        goto exit;    }    ht_node = (struct esif_ht_node *)ll_node->data_ptr;exit:    return ht_node;}

/*   Map upper participant metadata to upper particpant instance.  A participant   that is created from the upperframework will never have a lower framework   component.  These participants are to cover the case were we either have no   Kernel corresponding participant or in some cases we may not even have a   lower frame work present. */static void UpInitializeOriginUF(	const EsifUpPtr upPtr,	const void *upMetadataPtr	){	/* Upper Participant Metadata Format */	EsifParticipantIfacePtr metadata_ptr =		(EsifParticipantIfacePtr)upMetadataPtr;	ESIF_ASSERT(upPtr != NULL);	ESIF_ASSERT(metadata_ptr != NULL);	/* Store Lower Framework Instance */	upPtr->fLpInstance = 255;	/* Not Used */	/* Common */	upPtr->fMetadata.fVersion    = metadata_ptr->version;	upPtr->fMetadata.fEnumerator = (enum esif_participant_enum)metadata_ptr->enumerator;	upPtr->fMetadata.fFlags = metadata_ptr->flags;	esif_ccb_memcpy(&upPtr->fMetadata.fDriverType, &metadata_ptr->class_guid, ESIF_GUID_LEN);	esif_ccb_strcpy(upPtr->fMetadata.fName, metadata_ptr->name, ESIF_NAME_LEN);	esif_ccb_strcpy(upPtr->fMetadata.fDesc, metadata_ptr->desc, ESIF_DESC_LEN);	esif_ccb_strcpy(upPtr->fMetadata.fDriverName, metadata_ptr->driver_name, ESIF_NAME_LEN);	esif_ccb_strcpy(upPtr->fMetadata.fDeviceName, metadata_ptr->device_name, ESIF_NAME_LEN);	esif_ccb_strcpy(upPtr->fMetadata.fDevicePath, metadata_ptr->device_path, ESIF_PATH_LEN);	esif_ccb_strcpy(upPtr->fMetadata.fAcpiScope, metadata_ptr->object_id, ESIF_SCOPE_LEN);}

static void esif_ccb_tmrm_add_destroy_event(	struct esif_tmrm_item *self,	esif_ccb_event_t *event_ptr	){	ESIF_ASSERT(self != NULL);	ESIF_ASSERT(self->destroy_list_ptr != NULL);	if (event_ptr != NULL) {		esif_link_list_add_at_back(self->destroy_list_ptr, event_ptr);	}}

static eEsifError EsifActMgr_GetTypeFromPossAct_Locked(	EsifActMgrEntryPtr entryPtr,	enum esif_action_type *typePtr	){	eEsifError rc = ESIF_OK;	GetIfaceFuncPtr getIfacePtr = NULL;	EsifActIface iface = {0};	ESIF_ASSERT(entryPtr != NULL);	ESIF_ASSERT(typePtr != NULL);	/* If we already have the type from a previous search, return it */	if (entryPtr->type != 0) {		*typePtr = entryPtr->type;	}	/* If we don't already have the type; load the library and get the type */	rc = EsifActMgr_LoadAction(entryPtr, &getIfacePtr);	if (rc != ESIF_OK) {		goto exit;	}	iface.hdr.fIfaceType = eIfaceTypeAction;	iface.hdr.fIfaceVersion = ESIF_INTERFACE_VERSION;	iface.hdr.fIfaceSize = sizeof(iface);	rc = getIfacePtr(&iface);	if (ESIF_OK != rc) {		goto exit;	}	/* Check EsifActIface */	if (iface.hdr.fIfaceType != eIfaceTypeAction ||		iface.hdr.fIfaceVersion > ESIF_ACT_FACE_VER_MAX ||		iface.hdr.fIfaceSize != EsifActIface_Sizeof(iface.hdr.fIfaceVersion)) {		ESIF_TRACE_ERROR("The action interface does not meet requirements/n");		goto exit;	}	/* Check if this type is already available; we only allow one instance */	rc = EsifActIface_GetType(&iface, &entryPtr->type);	if (rc != ESIF_OK) {		goto exit;	}	*typePtr = entryPtr->type;exit:	if (rc != ESIF_OK) {		EsifActMgr_UnloadAction(entryPtr);	}	return rc;}

static void esif_ccb_timer_obj_call_cb(	struct esif_timer_obj *self	){	ESIF_ASSERT(self != NULL);	self->function_ptr(self->context_ptr);}

eEsifError EsifCopyIntToBufBySize(	size_t typeSize,	void *dstPtr,	u64 val	){	eEsifError rc = ESIF_OK;	ESIF_ASSERT(dstPtr != NULL);	switch(typeSize) {	case sizeof(u8):		*((u8 *)dstPtr) = (u8)val;		break;	case sizeof(u16):		*((u16 *)dstPtr) = (u16)val;		break;	case sizeof(u32):		*((u32 *)dstPtr) = (u32)val;		break;	case sizeof(u64):		*((u64 *)dstPtr) = (u64)val;		break;	default:		rc =  ESIF_E_UNSUPPORTED_RESULT_DATA_TYPE;		break;	}	return rc;}

static eEsifError EsifActIface_SendIfaceEvent(	EsifActIfacePtr self,	esif_context_t actCtx,	enum esif_event_type eventType,	UInt8 upInstance,	UInt16 domainId,	EsifDataPtr eventDataPtr	){	eEsifError rc = ESIF_OK;	ESIF_ASSERT(self != NULL);	switch (self->hdr.fIfaceVersion) {	case ESIF_ACT_IFACE_VER_V1:		if (NULL == self->actIfaceV1.rcvEventFuncPtr) {			rc = ESIF_E_NOT_SUPPORTED;			goto exit;		}		self->actIfaceV1.rcvEventFuncPtr(actCtx,			(esif_handle_t)(size_t)upInstance,			eventType,			domainId,			eventDataPtr			);		break;	case ESIF_ACT_IFACE_VER_STATIC:	default:		break;	}exit:	return rc;}

static eEsifError EsifApp_RegisterParticipantsWithApp(	EsifAppPtr self	){	eEsifError rc = ESIF_OK;	EsifUpPtr upPtr = NULL;	UInt8 i = 0;	ESIF_ASSERT(self != NULL);	/* Skip 0 ESIF treats this as a participant no one else does :) */	/* TODO:  Use iterator here.  This function shouldn't know the number of participants */	for (i = 1; i < MAX_PARTICIPANT_ENTRY; i++) {		upPtr = EsifUpPm_GetAvailableParticipantByInstance(i);		if (NULL == upPtr) {			continue;		}		rc = EsifAppCreateParticipant(self, upPtr);		EsifUp_PutRef(upPtr);		if (ESIF_OK != rc) {			break;		}	}	ESIF_TRACE_INFO("Register participants with App, status = %s/n", esif_rc_str(rc));	return rc;}

/* Allocate Event IPC */struct esif_ipc *esif_ipc_alloc_event(	struct esif_ipc_event **event_ptr_ptr,	u32 data_len	){	struct esif_ipc *ipc_ptr = NULL;	ESIF_ASSERT(event_ptr_ptr != NULL);	ipc_ptr = esif_ipc_alloc(ESIF_IPC_TYPE_EVENT,		data_len + sizeof(**event_ptr_ptr));	if (NULL == ipc_ptr) {		*event_ptr_ptr = NULL;	} else {		esif_ccb_time_t timestamp = {0};		struct esif_ipc_event *event_ptr = NULL;		event_ptr = (struct esif_ipc_event *)(ipc_ptr + 1);		event_ptr->version  = ESIF_EVENT_VERSION;		event_ptr->priority = ESIF_EVENT_PRIORITY_NORMAL;		event_ptr->data_len = data_len;		esif_ccb_system_time(&timestamp);		event_ptr->timestamp = (u64)timestamp;		*event_ptr_ptr          = event_ptr;	}	return ipc_ptr;}

// Resize an IString buffer (if dynamically allocated)ZString IString_Resize (	IStringPtr self,	u32 buf_len	){	ESIF_ASSERT(self);	// Allocate initial buffer if it has never been allocated	if (self->buf_ptr == 0) {		self->buf_ptr = esif_ccb_malloc(buf_len);		if (self->buf_ptr) {			self->buf_len  = buf_len;			self->data_len = 1;			return (ZString)self->buf_ptr;		}	}	// Resize buffer if it is not a static string	if (self->buf_len > 0) {		ZString buf_ptr = (ZString)esif_ccb_realloc(self->buf_ptr, buf_len);		if (buf_ptr) {			if (buf_len > self->buf_len) {				esif_ccb_memset(buf_ptr + self->buf_len, 0, buf_len - self->buf_len);			}			self->buf_ptr = buf_ptr;			self->buf_len = buf_len;			return (ZString)self->buf_ptr;		}	}	return 0;}

/* Get By Instance From ID */EsifUpPtr EsifUpManagerGetAvailableParticipantByInstance (	const UInt8 id	){	EsifUpPtr up_ptr = NULL;	ESIF_TRACE_DEBUG("%s: instance %d/n", ESIF_FUNC, id);	if (id >= MAX_PARTICIPANT_ENTRY) {		ESIF_TRACE_ERROR("Instance id %d is out of range/n", id);		ESIF_ASSERT(0);		goto exit;	}	/* Lock manager */	esif_ccb_read_lock(&g_uppMgr.fLock);	if (g_uppMgr.fEntries[id].fState > ESIF_PM_PARTICIPANT_REMOVED) {		up_ptr = g_uppMgr.fEntries[id].fUpPtr;	}	/* Unlock Manager */	esif_ccb_read_unlock(&g_uppMgr.fLock);exit:	if (NULL == up_ptr) {		ESIF_TRACE_DEBUG("%s: instance %d NOT found or OUT OF BOUNDS/n",						 ESIF_FUNC, id);	}	return up_ptr;}

/***  Map lower participant metadata to upper participant instance.  Every**  lower participant must have a corresponding upper particpant.  Here we**  intialize the data from the upper participant from the lower participant**  registration data.*/static void UpInitializeOriginLF(	const EsifUpPtr upPtr,	const UInt8 lpInstance,	const void *lpMetadataPtr	){	/* Lower Framework Participant Metadata Format */	struct esif_ipc_event_data_create_participant *metadata_ptr =		(struct esif_ipc_event_data_create_participant *)lpMetadataPtr;	ESIF_ASSERT(upPtr != NULL);	ESIF_ASSERT(metadata_ptr != NULL);	/* Store Lower Framework Instance. */	upPtr->fLpInstance = lpInstance;	/* Common */	upPtr->fMetadata.fVersion    = metadata_ptr->version;	upPtr->fMetadata.fEnumerator = (enum esif_participant_enum)metadata_ptr->enumerator;	upPtr->fMetadata.fFlags = metadata_ptr->flags;	esif_ccb_memcpy(&upPtr->fMetadata.fDriverType, &metadata_ptr->class_guid, ESIF_GUID_LEN);	esif_ccb_strcpy(upPtr->fMetadata.fName, metadata_ptr->name, ESIF_NAME_LEN);	esif_ccb_strcpy(upPtr->fMetadata.fDesc, metadata_ptr->desc, ESIF_DESC_LEN);	esif_ccb_strcpy(upPtr->fMetadata.fDriverName, metadata_ptr->driver_name, ESIF_NAME_LEN);	esif_ccb_strcpy(upPtr->fMetadata.fDeviceName, metadata_ptr->device_name, ESIF_NAME_LEN);	esif_ccb_strcpy(upPtr->fMetadata.fDevicePath, metadata_ptr->device_path, ESIF_PATH_LEN);	/* ACPI */	esif_ccb_strcpy(upPtr->fMetadata.fAcpiUID, metadata_ptr->acpi_uid, sizeof(upPtr->fMetadata.fAcpiUID));	upPtr->fMetadata.fAcpiType = metadata_ptr->acpi_type;	esif_ccb_strcpy(upPtr->fMetadata.fAcpiDevice, metadata_ptr->acpi_device, ESIF_NAME_LEN);	esif_ccb_strcpy(upPtr->fMetadata.fAcpiScope, metadata_ptr->acpi_scope, ESIF_SCOPE_LEN);	/* PCI */	upPtr->fMetadata.fPciVendor    = (u16)metadata_ptr->pci_vendor;	upPtr->fMetadata.fPciDevice    = (u16)metadata_ptr->pci_device;	upPtr->fMetadata.fPciBus       = metadata_ptr->pci_bus;	upPtr->fMetadata.fPciBusDevice = metadata_ptr->pci_bus_device;	upPtr->fMetadata.fPciFunction  = metadata_ptr->pci_function;	upPtr->fMetadata.fPciRevision  = metadata_ptr->pci_revision;	upPtr->fMetadata.fPciClass     = metadata_ptr->pci_class;	upPtr->fMetadata.fPciSubClass  = metadata_ptr->pci_sub_class;	upPtr->fMetadata.fPciProgIf    = metadata_ptr->pci_prog_if;}

void ESIF_INLINE IString_dtor (IStringPtr self){	ESIF_ASSERT(self);	if (self->buf_len) {		esif_ccb_free(self->buf_ptr);	}	WIPEPTR(self);}

// Truncate an IStringvoid IString_Truncate (IStringPtr self){	ESIF_ASSERT(self);	if (self->data_len) {		*((ZString)(self->buf_ptr)) = 0;		self->data_len = 1;	}}

static eEsifError EsifAct_RegisterEvents(	EsifActPtr self	){	ESIF_ASSERT(self != NULL);	return EsifActIface_RegisterEvents(&self->iface, (esif_handle_t)(size_t)self->type);}

enum esif_rc esif_ht_remove_item(    struct esif_ht *self,    u8 *key_ptr,    u32 key_length){    enum esif_rc rc = ESIF_OK;    struct esif_link_list *ll_ptr = NULL;    struct esif_link_list_node *ll_node = NULL;    struct esif_ht_node *ht_node = NULL;    if ((key_ptr == NULL) || (self == NULL)) {        ESIF_TRACE_ERROR("NULL ptr passed in/n");        rc = ESIF_E_PARAMETER_IS_NULL;        goto exit;    }    ll_ptr = esif_ht_get_ll(self, key_ptr, key_length);    if (ll_ptr == NULL) {        ESIF_ASSERT(ESIF_FALSE); /* Should never happen */        ESIF_TRACE_DYN_VERB("LL NULL for passed in key/n");        rc = ESIF_E_NOT_FOUND;        goto exit;    }    ll_node = esif_find_node_in_ht_ll(ll_ptr, key_ptr, key_length);    if (ll_node == NULL) {        ESIF_TRACE_DYN_VERB("LL node not found for passed in key/n");        rc = ESIF_E_NOT_FOUND;        goto exit;    }    ht_node = (struct esif_ht_node *)ll_node->data_ptr;    if (ht_node == NULL) {        ESIF_ASSERT(ESIF_FALSE);        ESIF_TRACE_DYN_VERB("ht_node NULL/n");        rc = ESIF_E_PARAMETER_IS_NULL;        goto exit;    }    esif_destroy_ht_node(ht_node);    esif_link_list_node_remove(ll_ptr, ll_node);exit:    return rc;}

static eEsifError EsifActMgr_CreateAction(	EsifActMgrEntryPtr entryPtr,	EsifActIfacePtr actIfacePtr	){	eEsifError rc = ESIF_OK;	enum esif_action_type actType = 0;	EsifActPtr actPtr = NULL;	ESIF_ASSERT(entryPtr != NULL);	ESIF_ASSERT(actIfacePtr != NULL);	/* Check EsifActIface */	if (actIfacePtr->hdr.fIfaceType != eIfaceTypeAction ||		actIfacePtr->hdr.fIfaceVersion > ESIF_ACT_FACE_VER_MAX ||		actIfacePtr->hdr.fIfaceSize != EsifActIface_Sizeof(actIfacePtr->hdr.fIfaceVersion)) {		ESIF_TRACE_ERROR("The action interface does not meet requirements/n");		goto exit;	}	/* Check if this type is already available; we only allow one instance */	rc = EsifActIface_GetType(actIfacePtr, &actType);	if (rc != ESIF_OK) {		goto exit;	}	actPtr = EsifActMgr_GetAction(actType, ACT_MGR_NO_UPINSTANCE);	if (actPtr != NULL) {		EsifAct_PutRef(actPtr);		rc = ESIF_E_ACTION_ALREADY_STARTED;		goto exit;	}	rc = EsifAct_CreateAction(actIfacePtr, entryPtr->upInstance, &actPtr);	if (rc != ESIF_OK) {		goto exit;	}	entryPtr->type = actPtr->type;	entryPtr->actCtx = actPtr->actCtx;	entryPtr->actPtr = actPtr;exit:	return rc;}

static enum esif_rc esif_ccb_tmrm_create_tmrm_item(	const esif_ccb_timer_cb function_ptr,	/* Callback when timer fires */	void *context_ptr,			/* Callback context if any */	struct esif_tmrm_item **tmrm_item_ptr	){	enum esif_rc rc = ESIF_E_NO_MEMORY;	struct esif_tmrm_item *new_item_ptr = NULL;	struct esif_timer_obj *timer_obj_ptr = NULL;	esif_ccb_timer_handle_t handle = 0;	ESIF_ASSERT(tmrm_item_ptr != NULL);	ESIF_ASSERT(function_ptr != NULL);	new_item_ptr = (struct esif_tmrm_item *)		esif_ccb_malloc(sizeof(*new_item_ptr));	if (NULL == new_item_ptr)		goto exit;	new_item_ptr->destroy_list_ptr = esif_link_list_create();	if (NULL == new_item_ptr->destroy_list_ptr)		goto exit;		rc = esif_ccb_timer_obj_create(function_ptr,		context_ptr,		&timer_obj_ptr);	if (rc != ESIF_OK)		goto exit;	new_item_ptr->timer_obj_ptr = timer_obj_ptr;	rc = esif_ccb_tmrm_get_next_handle(&handle);	if (rc != ESIF_OK)		goto exit;	new_item_ptr->timer_handle = handle;	*tmrm_item_ptr = new_item_ptr;exit:	if (rc != ESIF_OK)		esif_ccb_tmrm_destroy_tmrm_item(new_item_ptr);	return rc;}

/* * Handle ESIF Action "Get" Request */static eEsifError ESIF_CALLCONV ActionSystemGet(	const void *actionHandle,	EsifUpPtr upPtr,	const EsifFpcPrimitivePtr primitivePtr,	const EsifFpcActionPtr actionPtr,	const EsifDataPtr requestPtr,	const EsifDataPtr responsePtr	){	eEsifError esifStatus = ESIF_E_ACTION_NOT_IMPLEMENTED;	EsifData p1 = {0};	EsifString command = NULL;	UNREFERENCED_PARAMETER(actionHandle);	UNREFERENCED_PARAMETER(upPtr);	UNREFERENCED_PARAMETER(primitivePtr);	UNREFERENCED_PARAMETER(actionPtr);	UNREFERENCED_PARAMETER(requestPtr);	ESIF_ASSERT(NULL != responsePtr);	ESIF_ASSERT(NULL != responsePtr->buf_ptr);	esifStatus = EsifActionGetParamAsEsifData(actionPtr, 0, &p1);	if (ESIF_OK != esifStatus) {		goto exit;	}	ESIF_ASSERT(NULL != p1.buf_ptr);	ESIF_ASSERT(ESIF_DATA_STRING == p1.type);	command = (EsifString)p1.buf_ptr;	if (!strcmp("SYSTEM_GET_CDPNAME0", command)) {		esifStatus = system_get_ctdp_name(responsePtr, 0);	} else if (!strcmp("SYSTEM_GET_CDPNAME1", command)) {		esifStatus = system_get_ctdp_name(responsePtr, 1);	} else if (!strcmp("SYSTEM_GET_CDPNAME2", command)) {		esifStatus = system_get_ctdp_name(responsePtr, 2);	} exit:	return esifStatus;}