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

/*ARGSUSED*/static	intippctl_open(	dev_t	*devp,	int	flag,	int	otyp,	cred_t	*credp){	minor_t	minor = getminor(*devp);#define	LIMIT	4	DBG0(DBG_CBOPS, "open/n");	/*	 * Only allow privileged users to open our device.	 */	if (secpolicy_net_config(credp, B_FALSE) != 0) {		DBG0(DBG_CBOPS, "not privileged user/n");		return (EPERM);	}	/*	 * Sanity check other arguments.	 */	if (minor != 0) {		DBG0(DBG_CBOPS, "bad minor/n");		return (ENXIO);	}	if (otyp != OTYP_CHR) {		DBG0(DBG_CBOPS, "bad device type/n");		return (EINVAL);	}	/*	 * This is also a single dev_t driver.	 */	mutex_enter(&ippctl_lock);	if (ippctl_busy) {		mutex_exit(&ippctl_lock);		return (EBUSY);	}	ippctl_busy = B_TRUE;	mutex_exit(&ippctl_lock);	/*	 * Allocate data buffer array (starting with length LIMIT, defined	 * at the start of this function).	 */	ippctl_alloc(LIMIT);	DBG0(DBG_CBOPS, "success/n");	return (0);#undef	LIMIT}

int get_rx_buffers(void *priv, void **pkt_priv, void **buffer, int size){	struct net_device *dev = (struct net_device *) priv;	struct sk_buff *skb = NULL;	void *ptr = NULL;	DBG0("[%s] dev:%s/n", __func__, dev->name);	skb = __dev_alloc_skb(size, GFP_ATOMIC);	if (skb == NULL) {		DBG0("%s: unable to alloc skb/n", __func__);		return -ENOMEM;	}	/* TODO skb_reserve(skb, NET_IP_ALIGN); for ethernet mode */	/* Populate some params now. */	skb->dev = dev;	ptr = skb_put(skb, size);	skb_set_network_header(skb, 0);	/* done with skb setup, return the buffer pointer. */	*pkt_priv = skb;	*buffer = ptr;	return 0;}

static int __rmnet_open(struct net_device *dev){	int r;	struct rmnet_private *p = netdev_priv(dev);	DBG0("[%s] __rmnet_open()/n", dev->name);	if (p->device_up == DEVICE_UNINITIALIZED) {		r = msm_bam_dmux_open(p->ch_id, dev, bam_notify);		if (r < 0) {			DBG0("%s: ch=%d failed with rc %d/n",					__func__, p->ch_id, r);			return -ENODEV;		}		r = platform_driver_register(p->bam_pdev);		if (r) {			pr_err("%s: bam pdev registration failed n=%d rc=%d/n",					__func__, p->ch_id, r);			msm_bam_dmux_close(p->ch_id);			return r;		}	}	p->device_up = DEVICE_ACTIVE;	return 0;}

/*ARGSUSED*/static	intippctl_close(	dev_t	dev,	int	flag,	int	otyp,	cred_t	*credp){	minor_t	minor = getminor(dev);	DBG0(DBG_CBOPS, "close/n");	ASSERT(minor == 0);	/*	 * Free the data buffer array.	 */	ippctl_free();	mutex_enter(&ippctl_lock);	ippctl_busy = B_FALSE;	mutex_exit(&ippctl_lock);	DBG0(DBG_CBOPS, "success/n");	return (0);}

static int bam_rmnet_probe(struct platform_device *pdev){	int i;	char name[BAM_DMUX_CH_NAME_MAX_LEN];	struct rmnet_private *p;	DBG0("[%s] bam_rmnet_probe()/n", pdev->name);	for (i = 0; i < RMNET_DEVICE_COUNT; ++i) {		scnprintf(name, BAM_DMUX_CH_NAME_MAX_LEN, "bam_dmux_ch_%d", i);		if (!strncmp(pdev->name, name, BAM_DMUX_CH_NAME_MAX_LEN))			break;	}	p = netdev_priv(netdevs[i]);	if (p->in_reset) {		DBG0("[%s] is reset/n", pdev->name);		p->in_reset = 0;		msm_bam_dmux_open(p->ch_id, netdevs[i], bam_notify);		netif_carrier_on(netdevs[i]);		netif_start_queue(netdevs[i]);	}	return 0;}

static void dissect_icep_request(tvbuff_t *tvb, guint32 offset,                                 packet_info *pinfo, proto_tree *icep_tree, proto_item* icep_item){    /*  p. 612, chapter 23.3.2:     *     *  struct RequestData {     *   int requestID;     *   Ice::Identity id;     *   Ice::StringSeq facet;     *   string operation;     *   byte mode;     *   Ice::Context context;     *   Encapsulation params;     *  }     */    proto_item *ti = NULL;    proto_tree *icep_sub_tree = NULL;    gint32 consumed = 0;    guint32 reqid = 0;    DBG0("dissect request/n");    /* check for req id */    if ( !tvb_bytes_exist(tvb, offset, 4) ) {        expert_add_info_format(pinfo, icep_item, &ei_icep_length, "too short header");        col_append_str(pinfo->cinfo, COL_INFO, " (too short header)");        return;    }    /* got at least 4 bytes */    /* create display subtree for this message type */    reqid = tvb_get_letohl(tvb, offset);    ti = proto_tree_add_text(icep_tree, tvb, offset, -1, "Request Message Body");    icep_sub_tree = proto_item_add_subtree(ti, ett_icep_msg);    proto_tree_add_item(icep_sub_tree, hf_icep_request_id, tvb, offset, 4, ENC_LITTLE_ENDIAN);    if ( reqid != 0 ) {        col_append_fstr(pinfo->cinfo, COL_INFO, "(%d):", tvb_get_letohl(tvb, offset));    } else        col_append_str(pinfo->cinfo, COL_INFO, "(oneway):");    offset += 4;    DBG0("consumed --> 4/n");    dissect_icep_request_common(tvb, offset, pinfo, icep_sub_tree, ti, &consumed);    if ( consumed == -1 )        return;    /*offset += consumed;*/    DBG1("consumed --> %d/n", consumed);}

static int rmnet_ioctl_extended(struct net_device *dev, struct ifreq *ifr){	struct rmnet_ioctl_extended_s ext_cmd;	int rc = 0;	struct usbnet *unet = netdev_priv(dev);	rc = copy_from_user(&ext_cmd, ifr->ifr_ifru.ifru_data,			    sizeof(struct rmnet_ioctl_extended_s));	if (rc) {		DBG0("%s(): copy_from_user() failed/n", __func__);		return rc;	}	switch (ext_cmd.extended_ioctl) {	case RMNET_IOCTL_GET_SUPPORTED_FEATURES:		ext_cmd.u.data = 0;		break;	case RMNET_IOCTL_SET_MRU:		if (test_bit(EVENT_DEV_OPEN, &unet->flags))			return -EBUSY;		/* 16K max */		if ((size_t)ext_cmd.u.data > 0x4000)			return -EINVAL;		unet->rx_urb_size = (size_t) ext_cmd.u.data;		DBG0("[%s] rmnet_ioctl(): SET MRU to %u/n", dev->name,				unet->rx_urb_size);		break;	case RMNET_IOCTL_GET_MRU:		ext_cmd.u.data = (uint32_t)unet->rx_urb_size;		break;	case RMNET_IOCTL_GET_DRIVER_NAME:		strlcpy(ext_cmd.u.if_name, unet->driver_name,			sizeof(ext_cmd.u.if_name));		break;	case RMNET_IOCTL_GET_EPID:		ext_cmd.u.data =			unet->intf->cur_altsetting->desc.bInterfaceNumber;		break;	case RMNET_IOCTL_SET_SLEEP_STATE:		rmnet_usb_disable_hsic_autosuspend(unet, ext_cmd.u.data);		break;	}	rc = copy_to_user(ifr->ifr_ifru.ifru_data, &ext_cmd,			  sizeof(struct rmnet_ioctl_extended_s));	if (rc)		DBG0("%s(): copy_to_user() failed/n", __func__);	return rc;}

static int __rmnet_open(struct net_device *dev){	struct rmnet_private *p = netdev_priv(dev);	DBG0("[%s] __rmnet_open()/n", dev->name);	if (p->device_state == DEVICE_ACTIVE) {		return 0;	} else {		DBG0("[%s] Platform inactive/n", dev->name);		return -ENODEV;	}}

/*ARGSUSED*/static	intippctl_detach(	dev_info_t		*dip,	ddi_detach_cmd_t	cmd){	switch (cmd) {	case DDI_DETACH:		break;	case DDI_PM_SUSPEND:		/*FALLTHRU*/	case DDI_SUSPEND:		/*FALLTHRU*/	default:		return (DDI_FAILURE);	}	DBG0(DBG_DEVOPS, "DDI_DETACH/n");	ASSERT(dip == ippctl_dip);	ddi_remove_minor_node(dip, NULL);	mutex_destroy(&ippctl_lock);	ippctl_dip = NULL;	return (DDI_SUCCESS);}

int_info(	struct modinfo	*modinfop){	DBG0(DBG_MODLINK, "calling mod_info/n");	return (mod_info(&modlinkage, modinfop));}

static int bam_rmnet_remove(struct platform_device *pdev){	int i;	char name[BAM_DMUX_CH_NAME_MAX_LEN];	struct rmnet_private *p;	DBG0("[%s] bam_rmnet_remove()/n", pdev->name);	for (i = 0; i < RMNET_DEVICE_COUNT; ++i) {		scnprintf(name, BAM_DMUX_CH_NAME_MAX_LEN, "bam_dmux_ch_%d", i);		if (!strncmp(pdev->name, name, BAM_DMUX_CH_NAME_MAX_LEN))			break;	}	p = netdev_priv(netdevs[i]);	p->in_reset = 1;	if (p->waiting_for_ul_skb != NULL) {		dev_kfree_skb_any(p->waiting_for_ul_skb);		p->waiting_for_ul_skb = NULL;	}	msm_bam_dmux_close(p->ch_id);	netif_carrier_off(netdevs[i]);	netif_stop_queue(netdevs[i]);	return 0;}

static void _rmnet_free_bam_later(struct work_struct *work){	struct rmnet_free_bam_work *fwork;	fwork = container_of(work, struct rmnet_free_bam_work, work);	DBG0("%s: unregister_netdev, done", __func__);	if (bam_rmnet_drivers[fwork->ch_id].remove) {		platform_driver_unregister(&bam_rmnet_drivers[fwork->ch_id]);		bam_rmnet_drivers[fwork->ch_id].remove = NULL;	}	DBG0("%s: free_netdev, done", __func__);	kfree(work);}

END_TESTSTART_TEST(test_bliss_fft_speed){	bliss_fft_t *fft;	struct timespec start, stop;	uint16_t n = bliss_fft_12289_512.n;	uint32_t x[n], X[n];	int i, m, count = 10000;	for (i = 0; i < n; i++)	{		x[i] = i;	}	fft = bliss_fft_create(&bliss_fft_12289_512);	clock_gettime(CLOCK_THREAD_CPUTIME_ID, &start);	for (m = 0; m < count; m++)	{		fft->transform(fft, x, X, FALSE);		fft->transform(fft, X, x, TRUE);	}	clock_gettime(CLOCK_THREAD_CPUTIME_ID, &stop);	DBG0(DBG_LIB, "%d FFT loops in %d ms/n", count,				  (stop.tv_nsec - start.tv_nsec) / 1000000 +				  (stop.tv_sec - start.tv_sec) * 1000);	for (i = 0; i < n; i++)	{		ck_assert(x[i] == i);	}	fft->destroy(fft);}

static void bam_write_done(void *dev, struct sk_buff *skb){	struct rmnet_private *p = netdev_priv(dev);	u32 opmode = p->operation_mode;	unsigned long flags;	DBG1("%s: write complete/n", __func__);	if (RMNET_IS_MODE_IP(opmode) ||				count_this_packet(skb->data, skb->len)) {		p->stats.tx_packets++;		p->stats.tx_bytes += skb->len;#ifdef CONFIG_MSM_RMNET_DEBUG		p->wakeups_xmit += rmnet_cause_wakeup(p);#endif	}	DBG1("[%s] Tx packet #%lu len=%d mark=0x%x/n",	    ((struct net_device *)(dev))->name, p->stats.tx_packets,	    skb->len, skb->mark);	dev_kfree_skb_any(skb);	spin_lock_irqsave(&p->tx_queue_lock, flags);	if (netif_queue_stopped(dev) &&	    msm_bam_dmux_is_ch_low(p->ch_id)) {		DBG0("%s: Low WM hit, waking queue=%p/n",		      __func__, skb);		netif_wake_queue(dev);	}	spin_unlock_irqrestore(&p->tx_queue_lock, flags);}

static int rmnet_stop(struct net_device *dev){	DBG0("[%s] rmnet_stop()/n", dev->name);	netif_stop_queue(dev);	return 0;}

static int __rmnet_open(struct net_device *dev){	int r;	struct rmnet_private *p = netdev_priv(dev);	DBG0("[%s] __rmnet_open()/n", dev->name);	if (p->device_up == DEVICE_UNINITIALIZED) {		r = msm_bam_dmux_open(p->ch_id, dev, bam_notify);		if (r < 0) {			DBG0("%s: ch=%d failed with rc %d/n",					__func__, p->ch_id, r);			return -ENODEV;		}	}	p->device_up = DEVICE_ACTIVE;	return 0;}

static int rmnet_stop(struct net_device *dev){    struct rmnet_private *p = netdev_priv(dev);    DBG0("[%s] rmnet_stop()/n", dev->name);    netif_stop_queue(dev);    tasklet_kill(&p->tsklt);    return 0;}

static int rmnet_open(struct net_device *dev){	int rc = 0;	DBG0("[%s] rmnet_open()/n", dev->name);	rc = __rmnet_open(dev);	if (rc == 0)		netif_start_queue(dev);	return rc;}

int_init(	void){	int	rc;	if ((rc = mod_install(&modlinkage)) != 0) {		DBG0(DBG_MODLINK, "mod_install failed/n");		return (rc);	}	return (rc);}

int_fini(	void){	int	rc;	if ((rc = mod_remove(&modlinkage)) == 0) {		return (rc);	}	DBG0(DBG_MODLINK, "mod_remove failed/n");	return (rc);}

static int __rmnet_close(struct net_device *dev){	struct rmnet_private *p = netdev_priv(dev);	int rc = 0;	DBG0("[%s] __rmnet_close()/n", dev->name);	if (p->device_up) {		/* do not close rmnet port once up,  this causes		   remote side to hang if tried to open again */		p->device_up = DEVICE_INACTIVE;		return rc;	} else		return -EBADF;}

static void smd_net_notify(void *_dev, unsigned event){	struct rmnet_private *p = netdev_priv((struct net_device *)_dev);	switch (event) {	case SMD_EVENT_DATA:		spin_lock(&p->lock);		if (p->skb && (smd_write_avail(p->ch) >= p->skb->len)) {			smd_disable_read_intr(p->ch);			tasklet_hi_schedule(&p->tsklt);		}		spin_unlock(&p->lock);		if (smd_read_avail(p->ch) &&			(smd_read_avail(p->ch) >= smd_cur_packet_size(p->ch))) {			smd_net_data_tasklet.data = (unsigned long) _dev;			tasklet_schedule(&smd_net_data_tasklet);		}		break;	case SMD_EVENT_OPEN:		DBG0("%s: opening SMD port/n", __func__);		netif_carrier_on(_dev);		if (netif_queue_stopped(_dev)) {			DBG0("%s: re-starting if queue/n", __func__);			netif_wake_queue(_dev);		}		break;	case SMD_EVENT_CLOSE:		DBG0("%s: closing SMD port/n", __func__);		netif_carrier_off(_dev);		break;	}}

static void smux_write_done(void *dev, const void *meta_data){	struct rmnet_private *p = netdev_priv(dev);	u32 opmode;	struct sk_buff *skb = NULL;	const struct smux_meta_write  *write_meta_info = meta_data;	unsigned long flags;	if (!dev || !write_meta_info) {		DBG1("%s: ERR:invalid WRITE_DONE callback recieved", __func__);		return;	}	skb = (struct sk_buff *) write_meta_info->pkt_priv;	if (!skb) {		DBG1("%s: ERR:skb pointer NULL in WRITE_DONE"		     " CALLBACK", __func__);		return;	}	spin_lock_irqsave(&p->lock, flags);	opmode = p->operation_mode;	spin_unlock_irqrestore(&p->lock, flags);	DBG1("%s: write complete/n", __func__);	if (RMNET_IS_MODE_IP(opmode) ||		count_this_packet(skb->data, skb->len)) {		p->stats.tx_packets++;		p->stats.tx_bytes += skb->len;#ifdef CONFIG_MSM_RMNET_DEBUG		p->wakeups_xmit += rmnet_cause_wakeup(p);#endif	}	DBG1("[%s] Tx packet #%lu len=%d mark=0x%x/n",		 ((struct net_device *)(dev))->name, p->stats.tx_packets,		 skb->len, skb->mark);	dev_kfree_skb_any(skb);	spin_lock_irqsave(&p->tx_queue_lock, flags);	if (netif_queue_stopped(dev) &&		msm_smux_is_ch_low(p->ch_id)) {		DBG0("%s: Low WM hit, waking queue=%p/n",			 __func__, skb);		netif_wake_queue(dev);	}	spin_unlock_irqrestore(&p->tx_queue_lock, flags);}

static intippctl_data(	char	**dbufp,	size_t	*dbuflenp,	size_t	*nextbuflenp){	int	i;	DBG0(DBG_CBOPS, "called/n");	/*	 * Get the next data buffer from the array by looking at the	 * 'read index'. If this is the same as the 'write index' then	 * there's no more buffers in the array.	 */	i = ippctl_rindex;	if (i == ippctl_windex)		return (ENOENT);	/*	 * Extract the buffer details. It is a pre-packed nvlist.	 */	*dbufp = ippctl_array[i].buf;	*dbuflenp = ippctl_array[i].buflen;	DBG2(DBG_CBOPS, "accessing nvlist[%d], length %lu/n", i, *dbuflenp);	ASSERT(*dbufp != NULL);	/*	 * Advance the 'read index' and check if there's another buffer.	 * If there is then we need to pass back its length to libipp so that	 * another data ioctl will be issued.	 */	i++;	if (i < ippctl_windex)		*nextbuflenp = ippctl_array[i].buflen;	else		*nextbuflenp = 0;	ippctl_rindex = i;	return (0);}

void messageToKeyHAL(BYTE *p,UINT length){	if (length > KEY_MESSAGE_BUFF_LENGTH - 1)	{		DBG0("/nKEY_MESSAGE_BUFF_LENGTH");		return;	}	down(&pGlobalHardwareInfo->semKeyMessage);	pGlobalHardwareInfo->keyMessageBuff[pGlobalHardwareInfo->keyMessageBuffHx][0] = length;	memcpy(&pGlobalHardwareInfo->keyMessageBuff[pGlobalHardwareInfo->keyMessageBuffHx][1],p,length);	pGlobalHardwareInfo->keyMessageBuffHx++;	if (pGlobalHardwareInfo->keyMessageBuffHx >= KEY_MESSAGE_BUFF_SIZE)	{		pGlobalHardwareInfo->keyMessageBuffHx = 0;	}	up(&pGlobalHardwareInfo->semKeyMessage);	wake_up_interruptible(&pGlobalHardwareInfo->read_wait);}

static int __rmnet_open(struct net_device *dev){	int r;	struct rmnet_private *p = netdev_priv(dev);	DBG0("[%s] __rmnet_open()/n", dev->name);	if (!p->device_up) {		r = msm_sdio_dmux_open(p->ch_id, dev,				       sdio_recv_notify, sdio_write_done);		if (r < 0)			return -ENODEV;	}	p->device_up = DEVICE_ACTIVE;	return 0;}

static	intippctl_attach(	dev_info_t		*dip,	ddi_attach_cmd_t	cmd){	switch (cmd) {	case DDI_ATTACH:		break;	case DDI_PM_RESUME:		/*FALLTHRU*/	case DDI_RESUME:		/*FALLTHRU*/	default:		return (DDI_FAILURE);	}	DBG0(DBG_DEVOPS, "DDI_ATTACH/n");	/*	 * This is strictly a single instance driver.	 */	if (ippctl_dip != NULL)		return (DDI_FAILURE);	/*	 * Create minor node.	 */	if (ddi_create_minor_node(dip, "ctl", S_IFCHR, 0,	    DDI_PSEUDO, 0) != DDI_SUCCESS)		return (DDI_FAILURE);	/*	 * No need for per-instance structure, just store vital data in	 * globals.	 */	ippctl_dip = dip;	mutex_init(&ippctl_lock, NULL, MUTEX_DRIVER, NULL);	ippctl_busy = B_FALSE;	return (DDI_SUCCESS);}

static int rmnet_xmit(struct sk_buff *skb, struct net_device *dev){	struct rmnet_private *p = netdev_priv(dev);	if (netif_queue_stopped(dev)) {		pr_err("[%s]fatal: rmnet_xmit called when "			"netif_queue is stopped", dev->name);		return 0;	}	_rmnet_xmit(skb, dev);	if (msm_sdio_dmux_is_ch_full(p->ch_id)) {		netif_stop_queue(dev);		DBG0("%s: High WM hit, stopping queue=%p/n",	__func__, skb);	}	return 0;}

void messageToServiceHAL(BYTE *p,UINT length){	if (length > SERVICE_MESSAGE_BUFF_LENGTH - 1)	{		DBG0("/nSERVICE_MESSAGE_BUFF_LENGTH");		return;	}	down(&pGlobalHardwareInfo->semServiceMessage);	pGlobalHardwareInfo->serviceMessageBuff[pGlobalHardwareInfo->serviceMessageBuffHx][0] = length;	memcpy(&pGlobalHardwareInfo->serviceMessageBuff[pGlobalHardwareInfo->serviceMessageBuffHx][1],p,length);	pGlobalHardwareInfo->serviceMessageBuffHx++;	if (pGlobalHardwareInfo->serviceMessageBuffHx >= SERVICE_MESSAGE_BUFF_SIZE)	{		pGlobalHardwareInfo->serviceMessageBuffHx = 0;	}	up(&pGlobalHardwareInfo->semServiceMessage);	wake_up_interruptible(&pGlobalHardwareInfo->read_wait);	DBG("qqqq1");}