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

static void *sqn_dfs_perf_rx_seq_start(struct seq_file *seq, loff_t *pos){	u32 *idx = 0;	sqn_pr_enter();	if (0 == *pos) {		sqn_pr_dbg("zero pos/n");		idx = SEQ_START_TOKEN;		goto out;	} else if (SQN_DFS_PERF_STAT_SIZE <= *pos) {		/* indicate beyond end of file position */		sqn_pr_dbg("beyond end of file position %llu/n", *pos);		idx = 0;		goto out;	}	idx = kmalloc(sizeof(u32), GFP_KERNEL);	if (!idx) {		sqn_pr_dbg("failed to alloc seq_file iterator/n");		goto out;	}	*idx = *pos;	sqn_pr_dbg("start pos %u/n", *idx);out:	sqn_pr_leave();	return idx;}

int init_thp(struct net_device* dev){	sqn_pr_enter();#if THP_DEBUG	printk(KERN_WARNING "init_thp +/n");#endif	if (0 == this_device) {		if(init_procfs_handler()) {			return -1;		}		if(init_thp_devfile())			return -1;		/* Don't call init_thp_handler() here, it will be called from		 * probe() before interrupts are enabled, to ensure that we will		 * catch all THP packets as soon as they appear		 */		/* if (init_thp_handler(dev)) */			/* return -1; */		this_device = dev;		sqn_pr_info("KTHP initialized/n");	}#if THP_DEBUG	printk(KERN_WARNING "init_thp -/n");#endif	sqn_pr_leave();	return 0;}

static unsigned int thp_poll(struct file *filp, poll_table *wait){	unsigned int mask = 0;	sqn_pr_enter();#if THP_DEBUG	//printk(KERN_WARNING "thp_poll +/n");#endif	poll_wait(filp, &to_sqntool_wait, wait);	if (0 == this_device) {		printk(KERN_WARNING "thp_poll() device removed/n");		mask = POLLERR;	} else if(skb_queue_empty(&to_sqntool_queue)) {		mask = 0;	} else {		mask = (POLLIN | POLLRDNORM);	}#if THP_DEBUG	//printk(KERN_WARNING "thp_poll -/n");#endif	sqn_pr_leave();	return mask;}

int init_procfs_handler(void){	sqn_pr_enter();	kthp_proc_dir = proc_mkdir(procfs_dir, NULL);	if (kthp_proc_dir) {#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,30)		kthp_proc_dir->owner = THIS_MODULE;#endif	} else {		remove_proc_entry(PROC_DIR_NAME, NULL);		return 1;	}	if(install_entry(IFACE_FILENAME, ifacename_read) ||			install_entry(DRV_REVISION, drvrev_read))	{		return 1;	}#if THP_DEBUG	printk(KERN_WARNING "drvrev_read -/n");#endif	sqn_pr_leave();	return 0;}

int thp_handler(struct sk_buff *skb, struct net_device *pDev, struct packet_type *pPt)#endif{	struct sk_buff *skb_thp = 0;	struct ethhdr *eth = 0;	sqn_pr_enter();	/* We need only ETH_P_802_2 protocol packets with THP mac address */	eth = skb2ethhdr(skb);	if(ntohs(skb->protocol) != ETH_P_802_2 || !is_thp_packet(eth->h_dest)) {		//for DDTM, drop all NOT THP packets		if(drop_packet) {			sqn_pr_dbg("HTC CODE: drop packet for DDTM/n");			skb->pkt_type = PACKET_OTHERHOST;		}		goto not_thp_out;	}	skb_thp = skb_clone(skb, GFP_ATOMIC);    /* Bugz 22554: strip CRC at the end of packet */    skb_trim(skb_thp, skb_thp->len - 4);#if THP_TRACE	sqn_pr_info("%s: RX packet, len = %d/n", __func__, skb_thp->len);#endif	sqn_pr_dbg("RX THP packet, length %d/n", skb_thp->len);	skb_queue_tail(&to_sqntool_queue, skb_thp);	if(skb_queue_len(&to_sqntool_queue) == 256){		skb_thp = skb_dequeue(&to_sqntool_queue);		kfree_skb(skb_thp);	}	wake_up_interruptible(&to_sqntool_wait);	//Wake up wait queuethp_out:    dev_kfree_skb_any(skb); 	sqn_pr_leave();	return NET_RX_DROP;not_thp_out:	dev_kfree_skb_any(skb);	sqn_pr_leave();	return NET_RX_SUCCESS;}

/** sqn_load_firmware - loads firmware to card *  @func: SDIO function, used to transfer data via SDIO interface, *         also used to obtain pointer to device structure. * *  But now the only work it does - is loading of bootstrapper to card, *  because firmware is supposed to be loaded by a userspace program. */int sqn_load_firmware(struct sdio_func *func){	int rv = 0;	const struct firmware *fw = 0;//Create a local firmware_name with path to replace original global firmware_name -- Tony Wu.	const char *firmware_name = "../../../data/wimax/Boot.bin";	struct sqn_sdio_card *sqn_card = sdio_get_drvdata(func);	sqn_pr_enter();	sqn_pr_info("trying to find bootloader image: /"%s/"/n", firmware_name);	if ((rv = request_firmware(&fw, firmware_name, &func->dev)))		goto out;	if (SQN_1130 == sqn_card->version) {		sdio_claim_host(func);		/* properly setup registers for firmware loading */		sqn_pr_dbg("setting up SQN_H_SDRAM_NO_EMR register/n");		sdio_writeb(func, 0, SQN_H_SDRAM_NO_EMR, &rv);		if (rv) {			sdio_release_host(func);			goto out;		}		sqn_pr_dbg("setting up SQN_H_SDRAMCTL_RSTN register/n");		sdio_writeb(func, 1, SQN_H_SDRAMCTL_RSTN, &rv);		sdio_release_host(func);		if (rv)			goto out;	}	sqn_pr_info("loading bootloader to the card.../n");	if ((rv = sqn_load_bootstrapper(func, (u8*) fw->data, fw->size)))		goto out;	/* boot the card */	sqn_pr_info("bootting the card.../n");	sdio_claim_host(func); // by daniel	sdio_writeb(func, 1, SQN_H_CRSTN, &rv);	sdio_release_host(func); // by daniel	if (rv)		goto out;	sqn_pr_info("  done/n");out:	// To avoid kzalloc leakage in /drivers/base/firmware_class.c		if (fw) {		release_firmware(fw);		fw = NULL;	}	sqn_pr_leave();	return rv;}

void sqn_dfs_cleanup(void){	sqn_pr_enter();#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 27)	debugfs_remove_recursive(sqn_dfs_rootdir);#endif	sqn_dfs_rootdir = 0;	sqn_pr_leave();}

static int sqn_dfs_perf_rx_open(struct inode *i, struct file *f){	int rv = 0;	sqn_pr_enter();	rv = seq_open(f, &sqn_dfs_perf_rx_seq_ops);	sqn_pr_leave();	return rv;}

static size_t sqn_alloc_big_buffer(u8 **buf, size_t size, gfp_t gfp_flags){	size_t	real_size = size;	// int	retries   = 6;    // int	retries   = 3;	sqn_pr_enter();	/* Try to allocate buffer of requested size, if it failes try to	 * allocate a twice smaller buffer. Repeat this <retries> number of	 * times. */	/*	do	{		*buf = kmalloc(real_size, gfp_flags);		printk("%s: kmalloc %d in %x trial:%d/n", __func__, real_size, *buf, retries); 		if (!(*buf)) {            printk("%s: kmalloc %d failed, trial:%d/n", __func__, real_size, retries); 			// real_size /= 2;            real_size /= 4;			// adjust the size to be a multiple of 4			real_size += real_size % 4 ? 4 - real_size % 4 : 0;		}	} while (retries-- > 0 && !(*buf));    */	// If all retries failed, then allocate 4KB buffer	if (!(*buf)) {		real_size = 8 * 1024;		if (size >= real_size) {			*buf = kmalloc(real_size, gfp_flags);			// printk("%s: kmalloc %d in %x/n", __func__, real_size, *buf); 			// If it also failed, then just return 0, indicating			// that we failed to alloc buffer			if (!(*buf))				real_size = 0;		} else {			// We should _not_ return buffer bigger than requested			// real_size = 0;									// printk("%s: We should _not_ return buffer bigger than requested size:%d real_size:%d/n", __func__, size, real_size); 			*buf = kmalloc(size, gfp_flags);			real_size = size;					}	} 	sqn_pr_leave();	return real_size;}

static ssize_t thp_release(struct inode *inode, struct file *filp){	sqn_pr_enter();	once_open_flag = 0;	if(!skb_queue_empty(&to_sqntool_queue))		skb_queue_purge(&to_sqntool_queue);	sqn_pr_leave();	return 0;}