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

/* *  ======== cmm_get_handle ======== *  Purpose: *      Return the communication memory manager object for this device. *      This is typically called from the client process. */int cmm_get_handle(void *hprocessor, OUT struct cmm_object ** ph_cmm_mgr){	int status = 0;	struct dev_object *hdev_obj;	DBC_REQUIRE(refs > 0);	DBC_REQUIRE(ph_cmm_mgr != NULL);	if (hprocessor != NULL)		status = proc_get_dev_object(hprocessor, &hdev_obj);	else		hdev_obj = dev_get_first();	/* default */	if (DSP_SUCCEEDED(status))		status = dev_get_cmm_mgr(hdev_obj, ph_cmm_mgr);	return status;}

/* * ======== get_allocator ======== *  Purpose: *      Return the allocator for the given SM Segid. *      SegIds:  1,2,3..max. */static struct cmm_allocator *get_allocator(struct cmm_object *cmm_mgr_obj,					   u32 ul_seg_id){	struct cmm_allocator *allocator = NULL;	DBC_REQUIRE(cmm_mgr_obj != NULL);	DBC_REQUIRE((ul_seg_id > 0) && (ul_seg_id <= CMM_MAXGPPSEGS));	allocator = cmm_mgr_obj->pa_gppsm_seg_tab[ul_seg_id - 1];	if (allocator != NULL) {		/* make sure it's for real */		if (!allocator) {			allocator = NULL;			DBC_ASSERT(false);		}	}	return allocator;}

/* *  ======== cod_exit ======== *  Purpose: *      Discontinue usage of the COD module. * */void cod_exit(void){	DBC_REQUIRE(refs > 0);	refs--;	DBC_ENSURE(refs >= 0);}

/* *  ======== rmm_init ======== */bool rmm_init(void){	DBC_REQUIRE(refs >= 0);	refs++;	return true;}

/* *  ======== cmm_free_buf ======== *  Purpose: *      Free the given buffer. */int cmm_free_buf(struct cmm_object *hcmm_mgr, void *buf_pa,			u32 ul_seg_id){	struct cmm_object *cmm_mgr_obj = (struct cmm_object *)hcmm_mgr;	int status = -EFAULT;	struct cmm_mnode *mnode_obj = NULL;	struct cmm_allocator *allocator = NULL;	struct cmm_attrs *pattrs;	DBC_REQUIRE(refs > 0);	DBC_REQUIRE(buf_pa != NULL);	if (ul_seg_id == 0) {		pattrs = &cmm_dfltalctattrs;		ul_seg_id = pattrs->ul_seg_id;	}	if (!hcmm_mgr || !(ul_seg_id > 0)) {		status = -EFAULT;		return status;	}	/* get the allocator for this segment id */	allocator = get_allocator(cmm_mgr_obj, ul_seg_id);	if (allocator != NULL) {		mutex_lock(&cmm_mgr_obj->cmm_lock);		mnode_obj =		    (struct cmm_mnode *)lst_first(allocator->in_use_list_head);		while (mnode_obj) {			if ((u32) buf_pa == mnode_obj->dw_pa) {				/* Found it */				lst_remove_elem(allocator->in_use_list_head,						(struct list_head *)mnode_obj);				/* back to freelist */				add_to_free_list(allocator, mnode_obj);				status = 0;	/* all right! */				break;			}			/* next node. */			mnode_obj = (struct cmm_mnode *)			    lst_next(allocator->in_use_list_head,				     (struct list_head *)mnode_obj);		}		mutex_unlock(&cmm_mgr_obj->cmm_lock);	}	return status;}

/* *  ======== rmm_free ======== */bool rmm_free(struct rmm_target_obj *target, u32 segid, u32 addr, u32 size,	      bool reserved){	struct rmm_ovly_sect *sect;	bool ret = true;	DBC_REQUIRE(target);	DBC_REQUIRE(reserved || segid < target->num_segs);	DBC_REQUIRE(reserved || (addr >= target->seg_tab[segid].base &&				 (addr + size) <= (target->seg_tab[segid].base +						   target->seg_tab[segid].						   length)));	/*	 *  Free or unreserve memory.	 */	if (!reserved) {		ret = free_block(target, segid, addr, size);		if (ret)			target->seg_tab[segid].number--;	} else {		/* Unreserve memory */		sect = (struct rmm_ovly_sect *)lst_first(target->ovly_list);		while (sect != NULL) {			if (addr == sect->addr) {				DBC_ASSERT(size == sect->size);				/* Remove from list */				lst_remove_elem(target->ovly_list,						(struct list_head *)sect);				kfree(sect);				break;			}			sect =			    (struct rmm_ovly_sect *)lst_next(target->ovly_list,							     (struct list_head							      *)sect);		}		if (sect == NULL)			ret = false;	}	return ret;}

/* *  ========= dev_get_io_mgr ======== */int dev_get_io_mgr(struct dev_object *hdev_obj,			  struct io_mgr **io_man){	int status = 0;	DBC_REQUIRE(refs > 0);	DBC_REQUIRE(io_man != NULL);	DBC_REQUIRE(hdev_obj);	if (hdev_obj) {		*io_man = hdev_obj->hio_mgr;	} else {		*io_man = NULL;		status = -EFAULT;	}	return status;}

/* *  ======== dev_create2 ======== *  Purpose: *      After successful loading of the image from api_init_complete2 *      (PROC Auto_Start) or proc_load this fxn is called. This creates *      the Node Manager and updates the DEV Object. */int dev_create2(struct dev_object *hdev_obj){	int status = 0;	struct dev_object *dev_obj = hdev_obj;	DBC_REQUIRE(refs > 0);	DBC_REQUIRE(hdev_obj);	/* There can be only one Node Manager per DEV object */	DBC_ASSERT(!dev_obj->hnode_mgr);	status = node_create_mgr(&dev_obj->hnode_mgr, hdev_obj);	if (status)		dev_obj->hnode_mgr = NULL;	DBC_ENSURE((!status && dev_obj->hnode_mgr != NULL)		   || (status && dev_obj->hnode_mgr == NULL));	return status;}

/* *  ======== mgr_exit ======== *      Decrement reference count, and free resources when reference count is *      0. */void mgr_exit(void){	DBC_REQUIRE(refs > 0);	refs--;	if (refs == 0)		dcd_exit();	DBC_ENSURE(refs >= 0);}

/* *  ======== cod_delete ======== *  Purpose: *      Delete a code manager object. */void cod_delete(struct cod_manager *cod_mgr_obj){	DBC_REQUIRE(refs > 0);	DBC_REQUIRE(cod_mgr_obj);	if (cod_mgr_obj->base_lib) {		if (cod_mgr_obj->loaded)			cod_mgr_obj->fxns.unload_fxn(cod_mgr_obj->base_lib,							&cod_mgr_obj->attrs);		cod_mgr_obj->fxns.close_fxn(cod_mgr_obj->base_lib);	}	if (cod_mgr_obj->target) {		cod_mgr_obj->fxns.delete_fxn(cod_mgr_obj->target);		cod_mgr_obj->fxns.exit_fxn();	}	kfree(cod_mgr_obj);}

/* *  ========= dev_get_io_mgr ======== */int dev_get_io_mgr(struct dev_object *hdev_obj,			  OUT struct io_mgr **phIOMgr){	int status = 0;	DBC_REQUIRE(refs > 0);	DBC_REQUIRE(phIOMgr != NULL);	DBC_REQUIRE(hdev_obj);	if (hdev_obj) {		*phIOMgr = hdev_obj->hio_mgr;	} else {		*phIOMgr = NULL;		status = -EFAULT;	}	return status;}

/* *  ======== free_chirp_list ======== *  Purpose: *      Free the queue of Chirps. */static void free_chirp_list(struct lst_list *chirp_list){	DBC_REQUIRE(chirp_list != NULL);	while (!LST_IS_EMPTY(chirp_list))		kfree(lst_get_head(chirp_list));	kfree(chirp_list);}

/* *  ======== dev_get_cod_mgr ======== *  Purpose: *      Retrieve the COD manager create for this device. */int dev_get_cod_mgr(struct dev_object *hdev_obj,			   struct cod_manager **cod_mgr){	int status = 0;	struct dev_object *dev_obj = hdev_obj;	DBC_REQUIRE(refs > 0);	DBC_REQUIRE(cod_mgr != NULL);	if (hdev_obj) {		*cod_mgr = dev_obj->cod_mgr;	} else {		*cod_mgr = NULL;		status = -EFAULT;	}	DBC_ENSURE(!status || (cod_mgr != NULL && *cod_mgr == NULL));	return status;}

/* *  ======== dev_get_dmm_mgr ======== *  Purpose: *      Retrieve the handle to the dynamic memory manager created for this *      device. */int dev_get_dmm_mgr(struct dev_object *hdev_obj,			   struct dmm_object **mgr){	int status = 0;	struct dev_object *dev_obj = hdev_obj;	DBC_REQUIRE(refs > 0);	DBC_REQUIRE(mgr != NULL);	if (hdev_obj) {		*mgr = dev_obj->dmm_mgr;	} else {		*mgr = NULL;		status = -EFAULT;	}	DBC_ENSURE(!status || (mgr != NULL && *mgr == NULL));	return status;}

/* *  ======== dev_destroy2 ======== *  Purpose: *      Destroys the Node manager for this device. */int dev_destroy2(struct dev_object *hdev_obj){	int status = 0;	struct dev_object *dev_obj = hdev_obj;	DBC_REQUIRE(refs > 0);	DBC_REQUIRE(hdev_obj);	if (dev_obj->hnode_mgr) {		if (node_delete_mgr(dev_obj->hnode_mgr))			status = -EPERM;		else			dev_obj->hnode_mgr = NULL;	}	DBC_ENSURE((!status && dev_obj->hnode_mgr == NULL) || status);	return status;}

/* *  ======== dev_get_intf_fxns ======== *  Purpose: *      Retrieve the Bridge interface function structure for the loaded driver. *      if_fxns != NULL. */int dev_get_intf_fxns(struct dev_object *hdev_obj,			     struct bridge_drv_interface **if_fxns){	int status = 0;	struct dev_object *dev_obj = hdev_obj;	DBC_REQUIRE(refs > 0);	DBC_REQUIRE(if_fxns != NULL);	if (hdev_obj) {		*if_fxns = &dev_obj->bridge_interface;	} else {		*if_fxns = NULL;		status = -EFAULT;	}	DBC_ENSURE(!status || ((if_fxns != NULL) && (*if_fxns == NULL)));	return status;}

/* *  ======== dev_get_dev_node ======== *  Purpose: *      Retrieve the platform specific device ID for this device. */int dev_get_dev_node(struct dev_object *hdev_obj,			    struct cfg_devnode **dev_nde){	int status = 0;	struct dev_object *dev_obj = hdev_obj;	DBC_REQUIRE(refs > 0);	DBC_REQUIRE(dev_nde != NULL);	if (hdev_obj) {		*dev_nde = dev_obj->dev_node_obj;	} else {		*dev_nde = NULL;		status = -EFAULT;	}	DBC_ENSURE(!status || (dev_nde != NULL && *dev_nde == NULL));	return status;}

/* *  ======== msg_mod_init ======== */bool msg_mod_init(void){	DBC_REQUIRE(refs >= 0);	refs++;	DBC_ENSURE(refs >= 0);	return true;}

/* *  ======== mgr_get_dcd_handle ======== *      Retrieves the MGR handle. Accessor Function. */int mgr_get_dcd_handle(struct mgr_object *mgr_handle,			      u32 *dcd_handle){	int status = -EPERM;	struct mgr_object *pmgr_obj = (struct mgr_object *)mgr_handle;	DBC_REQUIRE(refs > 0);	DBC_REQUIRE(dcd_handle != NULL);	*dcd_handle = (u32) NULL;	if (pmgr_obj) {		*dcd_handle = (u32) pmgr_obj->dcd_mgr;		status = 0;	}	DBC_ENSURE((!status && *dcd_handle != (u32) NULL) ||		   (status && *dcd_handle == (u32) NULL));	return status;}

/* *  ======== dev_get_node_manager ======== *  Purpose: *      Retrieve the Node Manager Handle */int dev_get_node_manager(struct dev_object *hdev_obj,				struct node_mgr **node_man){	int status = 0;	struct dev_object *dev_obj = hdev_obj;	DBC_REQUIRE(refs > 0);	DBC_REQUIRE(node_man != NULL);	if (hdev_obj) {		*node_man = dev_obj->hnode_mgr;	} else {		*node_man = NULL;		status = -EFAULT;	}	DBC_ENSURE(!status || (node_man != NULL && *node_man == NULL));	return status;}

/* *  ======== dev_get_dev_node ======== *  Purpose: *      Retrieve the platform specific device ID for this device. */int dev_get_dev_node(struct dev_object *hdev_obj,			    OUT struct cfg_devnode **phDevNode){	int status = 0;	struct dev_object *dev_obj = hdev_obj;	DBC_REQUIRE(refs > 0);	DBC_REQUIRE(phDevNode != NULL);	if (hdev_obj) {		*phDevNode = dev_obj->dev_node_obj;	} else {		*phDevNode = NULL;		status = -EFAULT;	}	DBC_ENSURE(DSP_SUCCEEDED(status) || ((phDevNode != NULL) &&					     (*phDevNode == NULL)));	return status;}

/* *  ======== dbll_init ======== */bool dbll_init(void){	DBC_REQUIRE(refs >= 0);	if (refs == 0)		gh_init();	refs++;	return true;}

/* *  ======== dbll_exit ======== *  Discontinue usage of DBL module. */void dbll_exit(void){	DBC_REQUIRE(refs > 0);	refs--;	if (refs == 0)		gh_exit();	DBC_ENSURE(refs >= 0);}

/* *  ======== cod_read_section ======== *  Purpose: *      Retrieve the content of a code section given the section name. */int cod_read_section(struct cod_libraryobj *lib, char *str_sect,			    char *str_content, u32 content_size){	int status = 0;	DBC_REQUIRE(refs > 0);	DBC_REQUIRE(lib != NULL);	DBC_REQUIRE(lib->cod_mgr);	DBC_REQUIRE(str_sect != NULL);	DBC_REQUIRE(str_content != NULL);	if (lib != NULL)		status =		    lib->cod_mgr->fxns.read_sect_fxn(lib->dbll_lib, str_sect,						     str_content, content_size);	else		status = -ESPIPE;	return status;}

/* *  ======== dev_get_node_manager ======== *  Purpose: *      Retrieve the Node Manager Handle */int dev_get_node_manager(struct dev_object *hdev_obj,				OUT struct node_mgr **phNodeMgr){	int status = 0;	struct dev_object *dev_obj = hdev_obj;	DBC_REQUIRE(refs > 0);	DBC_REQUIRE(phNodeMgr != NULL);	if (hdev_obj) {		*phNodeMgr = dev_obj->hnode_mgr;	} else {		*phNodeMgr = NULL;		status = -EFAULT;	}	DBC_ENSURE(DSP_SUCCEEDED(status) || ((phNodeMgr != NULL) &&					     (*phNodeMgr == NULL)));	return status;}

/* *  ======== dev_get_wmd_context ======== *  Purpose: *      Retrieve the WMD Context handle, as returned by the WMD_Create fxn. */int dev_get_wmd_context(struct dev_object *hdev_obj,			       OUT struct wmd_dev_context **phWmdContext){	int status = 0;	struct dev_object *dev_obj = hdev_obj;	DBC_REQUIRE(refs > 0);	DBC_REQUIRE(phWmdContext != NULL);	if (hdev_obj) {		*phWmdContext = dev_obj->hwmd_context;	} else {		*phWmdContext = NULL;		status = -EFAULT;	}	DBC_ENSURE(DSP_SUCCEEDED(status) || ((phWmdContext != NULL) &&					     (*phWmdContext == NULL)));	return status;}

/* *  ======== cmm_destroy ======== *  Purpose: *      Release the communication memory manager resources. */int cmm_destroy(struct cmm_object *hcmm_mgr, bool bForce){	struct cmm_object *cmm_mgr_obj = (struct cmm_object *)hcmm_mgr;	struct cmm_info temp_info;	int status = 0;	s32 slot_seg;	struct cmm_mnode *pnode;	DBC_REQUIRE(refs > 0);	if (!hcmm_mgr) {		status = -EFAULT;		return status;	}	mutex_lock(&cmm_mgr_obj->cmm_lock);	/* If not force then fail if outstanding allocations exist */	if (!bForce) {		/* Check for outstanding memory allocations */		status = cmm_get_info(hcmm_mgr, &temp_info);		if (DSP_SUCCEEDED(status)) {			if (temp_info.ul_total_in_use_cnt > 0) {				/* outstanding allocations */				status = -EPERM;			}		}	}	if (DSP_SUCCEEDED(status)) {		/* UnRegister SM allocator */		for (slot_seg = 0; slot_seg < CMM_MAXGPPSEGS; slot_seg++) {			if (cmm_mgr_obj->pa_gppsm_seg_tab[slot_seg] != NULL) {				un_register_gppsm_seg				    (cmm_mgr_obj->pa_gppsm_seg_tab[slot_seg]);				/* Set slot to NULL for future reuse */				cmm_mgr_obj->pa_gppsm_seg_tab[slot_seg] = NULL;			}		}	}	if (cmm_mgr_obj->node_free_list_head != NULL) {		/* Free the free nodes */		while (!LST_IS_EMPTY(cmm_mgr_obj->node_free_list_head)) {			pnode = (struct cmm_mnode *)			    lst_get_head(cmm_mgr_obj->node_free_list_head);			kfree(pnode);		}		/* delete NodeFreeList list */		kfree(cmm_mgr_obj->node_free_list_head);	}	mutex_unlock(&cmm_mgr_obj->cmm_lock);	if (DSP_SUCCEEDED(status)) {		/* delete CS & cmm mgr object */		mutex_destroy(&cmm_mgr_obj->cmm_lock);		kfree(cmm_mgr_obj);	}	return status;}

/* *  ======== dev_get_bridge_context ======== *  Purpose: *      Retrieve the Bridge Context handle, as returned by the *      bridge_dev_create fxn. */int dev_get_bridge_context(struct dev_object *hdev_obj,			       struct bridge_dev_context **phbridge_context){	int status = 0;	struct dev_object *dev_obj = hdev_obj;	DBC_REQUIRE(refs > 0);	DBC_REQUIRE(phbridge_context != NULL);	if (hdev_obj) {		*phbridge_context = dev_obj->hbridge_context;	} else {		*phbridge_context = NULL;		status = -EFAULT;	}	DBC_ENSURE(!status || ((phbridge_context != NULL) &&					     (*phbridge_context == NULL)));	return status;}

/* *  ======== dev_get_symbol ======== */int dev_get_symbol(struct dev_object *hdev_obj,			  const char *str_sym, u32 * pul_value){	int status = 0;	struct cod_manager *cod_mgr;	DBC_REQUIRE(refs > 0);	DBC_REQUIRE(str_sym != NULL && pul_value != NULL);	if (hdev_obj) {		status = dev_get_cod_mgr(hdev_obj, &cod_mgr);		if (cod_mgr)			status = cod_get_sym_value(cod_mgr, (char *)str_sym,						   pul_value);		else			status = -EFAULT;	}	return status;}

/* *  ======== dev_get_intf_fxns ======== *  Purpose: *      Retrieve the WMD interface function structure for the loaded WMD. *      ppIntfFxns != NULL. */int dev_get_intf_fxns(struct dev_object *hdev_obj,			     OUT struct bridge_drv_interface **ppIntfFxns){	int status = 0;	struct dev_object *dev_obj = hdev_obj;	DBC_REQUIRE(refs > 0);	DBC_REQUIRE(ppIntfFxns != NULL);	if (hdev_obj) {		*ppIntfFxns = &dev_obj->wmd_interface;	} else {		*ppIntfFxns = NULL;		status = -EFAULT;	}	DBC_ENSURE(DSP_SUCCEEDED(status) || ((ppIntfFxns != NULL) &&					     (*ppIntfFxns == NULL)));	return status;}