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

static int xen_smp_intr_init(unsigned int cpu){	int rc;	const char *resched_name, *callfunc_name, *debug_name;	resched_name = kasprintf(GFP_KERNEL, "resched%d", cpu);	rc = bind_ipi_to_irqhandler(XEN_RESCHEDULE_VECTOR,				    cpu,				    xen_reschedule_interrupt,				    IRQF_DISABLED|IRQF_PERCPU|IRQF_NOBALANCING,				    resched_name,				    NULL);	if (rc < 0)		goto fail;	per_cpu(resched_irq, cpu) = rc;	callfunc_name = kasprintf(GFP_KERNEL, "callfunc%d", cpu);	rc = bind_ipi_to_irqhandler(XEN_CALL_FUNCTION_VECTOR,				    cpu,				    xen_call_function_interrupt,				    IRQF_DISABLED|IRQF_PERCPU|IRQF_NOBALANCING,				    callfunc_name,				    NULL);	if (rc < 0)		goto fail;	per_cpu(callfunc_irq, cpu) = rc;	debug_name = kasprintf(GFP_KERNEL, "debug%d", cpu);	rc = bind_virq_to_irqhandler(VIRQ_DEBUG, cpu, xen_debug_interrupt,				     IRQF_DISABLED | IRQF_PERCPU | IRQF_NOBALANCING,				     debug_name, NULL);	if (rc < 0)		goto fail;	per_cpu(debug_irq, cpu) = rc;	callfunc_name = kasprintf(GFP_KERNEL, "callfuncsingle%d", cpu);	rc = bind_ipi_to_irqhandler(XEN_CALL_FUNCTION_SINGLE_VECTOR,				    cpu,				    xen_call_function_single_interrupt,				    IRQF_DISABLED|IRQF_PERCPU|IRQF_NOBALANCING,				    callfunc_name,				    NULL);	if (rc < 0)		goto fail;	per_cpu(callfuncsingle_irq, cpu) = rc;	return 0; fail:	if (per_cpu(resched_irq, cpu) >= 0)		unbind_from_irqhandler(per_cpu(resched_irq, cpu), NULL);	if (per_cpu(callfunc_irq, cpu) >= 0)		unbind_from_irqhandler(per_cpu(callfunc_irq, cpu), NULL);	if (per_cpu(debug_irq, cpu) >= 0)		unbind_from_irqhandler(per_cpu(debug_irq, cpu), NULL);	if (per_cpu(callfuncsingle_irq, cpu) >= 0)		unbind_from_irqhandler(per_cpu(callfuncsingle_irq, cpu), NULL);	return rc;}

static void xen_cpu_die(unsigned int cpu){	while (HYPERVISOR_vcpu_op(VCPUOP_is_up, cpu, NULL)) {		current->state = TASK_UNINTERRUPTIBLE;		schedule_timeout(HZ/10);	}	unbind_from_irqhandler(per_cpu(xen_resched_irq, cpu), NULL);	unbind_from_irqhandler(per_cpu(xen_callfunc_irq, cpu), NULL);	unbind_from_irqhandler(per_cpu(xen_debug_irq, cpu), NULL);	unbind_from_irqhandler(per_cpu(xen_callfuncsingle_irq, cpu), NULL);	unbind_from_irqhandler(per_cpu(xen_irq_work, cpu), NULL);	xen_uninit_lock_cpu(cpu);	xen_teardown_timer(cpu);}

void xen_teardown_timer(int cpu){	struct clock_event_device *evt;	BUG_ON(cpu == 0);	evt = &per_cpu(xen_clock_events, cpu);	unbind_from_irqhandler(evt->irq, NULL);}

void xen_smp_intr_free_pv(unsigned int cpu){	if (per_cpu(xen_irq_work, cpu).irq >= 0) {		unbind_from_irqhandler(per_cpu(xen_irq_work, cpu).irq, NULL);		per_cpu(xen_irq_work, cpu).irq = -1;		kfree(per_cpu(xen_irq_work, cpu).name);		per_cpu(xen_irq_work, cpu).name = NULL;	}	if (per_cpu(xen_pmu_irq, cpu).irq >= 0) {		unbind_from_irqhandler(per_cpu(xen_pmu_irq, cpu).irq, NULL);		per_cpu(xen_pmu_irq, cpu).irq = -1;		kfree(per_cpu(xen_pmu_irq, cpu).name);		per_cpu(xen_pmu_irq, cpu).name = NULL;	}}

static void xen_pcibk_disconnect(struct xen_pcibk_device *pdev){	spin_lock(&pdev->dev_lock);	/* Ensure the guest can't trigger our handler before removing devices */	if (pdev->evtchn_irq != INVALID_EVTCHN_IRQ) {		unbind_from_irqhandler(pdev->evtchn_irq, pdev);		pdev->evtchn_irq = INVALID_EVTCHN_IRQ;	}	spin_unlock(&pdev->dev_lock);	/* If the driver domain started an op, make sure we complete it	 * before releasing the shared memory */	/* Note, the workqueue does not use spinlocks at all.*/	flush_workqueue(xen_pcibk_wq);	spin_lock(&pdev->dev_lock);	if (pdev->sh_info != NULL) {		xenbus_unmap_ring_vfree(pdev->xdev, pdev->sh_info);		pdev->sh_info = NULL;	}	spin_unlock(&pdev->dev_lock);}

static void xen_cpu_die(unsigned int cpu){	while (HYPERVISOR_vcpu_op(VCPUOP_is_up, cpu, NULL)) {		current->state = TASK_UNINTERRUPTIBLE;		schedule_timeout(HZ/10);	}	unbind_from_irqhandler(per_cpu(resched_irq, cpu), NULL);	unbind_from_irqhandler(per_cpu(callfunc_irq, cpu), NULL);	unbind_from_irqhandler(per_cpu(debug_irq, cpu), NULL);	unbind_from_irqhandler(per_cpu(callfuncsingle_irq, cpu), NULL);	xen_uninit_lock_cpu(cpu);	xen_teardown_timer(cpu);	if (num_online_cpus() == 1)		alternatives_smp_switch(0);}

int xencons_ring_init(void){	int irq;	if (xencons_irq)		unbind_from_irqhandler(xencons_irq, NULL);	xencons_irq = 0;	if (!is_running_on_xen() ||	    is_initial_xendomain() ||	    !xen_start_info->console.domU.evtchn)		return -ENODEV;	irq = bind_caller_port_to_irqhandler(		xen_start_info->console.domU.evtchn,		handle_input, 0, "xencons", NULL);	if (irq < 0) {		printk(KERN_ERR "XEN console request irq failed %i/n", irq);		return irq;	}	xencons_irq = irq;	/* In case we have in-flight data after save/restore... */	notify_daemon();	return 0;}

static void evtchn_unbind_from_user(struct per_user_data *u, int port){	int irq = irq_from_evtchn(port);	unbind_from_irqhandler(irq, (void *)(unsigned long)port);	set_port_user(port, NULL);}

void xencons_suspend(void){	if (!xen_start_info->console_evtchn)		return;	unbind_from_irqhandler(console_irq);}

static void xenkbd_disconnect_backend(struct xenkbd_info *info){	if (info->irq >= 0)		unbind_from_irqhandler(info->irq, info);	info->irq = -1;	if (info->gref >= 0)		gnttab_end_foreign_access_ref(info->gref, 0);	info->gref = -1;}

void xen_uninit_lock_cpu(int cpu){	if (!xen_pvspin)		return;	unbind_from_irqhandler(per_cpu(lock_kicker_irq, cpu), NULL);	per_cpu(lock_kicker_irq, cpu) = -1;	kfree(per_cpu(irq_name, cpu));	per_cpu(irq_name, cpu) = NULL;}

static void unbind_virq(void){	int i;	for_each_cpu(i) {		if (ovf_irq[i] >= 0) {			unbind_from_irqhandler(ovf_irq[i], NULL);			ovf_irq[i] = -1;		}	}}

static void evtchn_unbind_from_user(struct per_user_data *u, int port){	int irq = irq_from_evtchn(port);	unbind_from_irqhandler(irq, (void *)(unsigned long)port);	/* make sure we unbind the irq handler before clearing the port */	barrier();	port_user[port] = NULL;}

/** * Handles a backend disconnect. * * @param info The information structure for the device to be disconnected. */static void oxtkbd_disconnect_backend(struct openxt_kbd_info *info){    //If we had an input IRQ registered, tear it down.    if (info->irq >= 0)        unbind_from_irqhandler(info->irq, info);    info->irq = -1;    //... and if we have a shared page for our ring, tear it down.    if (info->gref >= 0)        gnttab_end_foreign_access(info->gref, 0, 0UL);    info->gref = -1;}

static void cleanup_vnic(struct netback_accel *bend){	struct xenbus_device *dev;	dev = (struct xenbus_device *)bend->hdev_data;	DPRINTK("%s: bend %p dev %p/n", __FUNCTION__, bend, dev);	DPRINTK("%s: Remove %p's mac from fwd table.../n", 		__FUNCTION__, bend);	netback_accel_fwd_remove(bend->mac, bend->fwd_priv);	/* Free buffer table allocations */	netback_accel_remove_buffers(bend);	DPRINTK("%s: Release hardware resources.../n", __FUNCTION__);	if (bend->accel_shutdown)		bend->accel_shutdown(bend);	if (bend->net_channel_irq) {		unbind_from_irqhandler(bend->net_channel_irq, dev);		bend->net_channel_irq = 0;	}	if (bend->msg_channel_irq) {		unbind_from_irqhandler(bend->msg_channel_irq, dev);		bend->msg_channel_irq = 0;	}	if (bend->sh_pages_unmap) {		DPRINTK("%s: Unmap grants %p/n", __FUNCTION__, 			bend->sh_pages_unmap);		net_accel_unmap_grants_contig(dev, bend->sh_pages_unmap);		bend->sh_pages_unmap = NULL;		bend->shared_page = NULL;	}}

static void free_blkif(void *arg){	blkif_t *blkif = (blkif_t *)arg;	if (blkif->irq)		unbind_from_irqhandler(blkif->irq, blkif);	if (blkif->blk_ring.sring) {		unmap_frontend_page(blkif);		free_vm_area(blkif->blk_ring_area);		blkif->blk_ring.sring = NULL;	}	kmem_cache_free(blkif_cachep, blkif);}

static void ring_free(struct tpm_private *priv){	if (!priv)		return;	if (priv->ring_ref)		gnttab_end_foreign_access(priv->ring_ref, 0,				(unsigned long)priv->shr);	else		free_page((unsigned long)priv->shr);	if (priv->irq)		unbind_from_irqhandler(priv->irq, priv);	kfree(priv);}

static void ixp_free(struct ixpfront_info *info, int suspend){	/* Prevent new requests being issued until we fix things up. */	info->connected = suspend ?	IXP_STATE_SUSPENDED : IXP_STATE_DISCONNECTED;		/* Free resources associated with old device channel. */	if (info->ring_ref != GRANT_INVALID_REF) {		gnttab_end_foreign_access(info->ring_ref, 0,					  (unsigned long)info->ring.sring);		info->ring_ref = GRANT_INVALID_REF;		info->ring.sring = NULL;	}	if (info->irq)		unbind_from_irqhandler(info->irq, info);	info->evtchn = info->irq = 0;}

static void netif_free(netif_t *netif){	atomic_dec(&netif->refcnt);	wait_event(netif->waiting_to_free, atomic_read(&netif->refcnt) == 0);	if (netif->irq)		unbind_from_irqhandler(netif->irq, netif);		unregister_netdev(netif->dev);	if (netif->tx.sring) {		unmap_frontend_pages(netif);		free_vm_area(netif->tx_comms_area);		free_vm_area(netif->rx_comms_area);	}	free_netdev(netif->dev);}

static void destroy_rings(struct usbfront_info *info){	if (info->irq)		unbind_from_irqhandler(info->irq, info);	info->irq = 0;	if (info->urb_ring_ref != GRANT_INVALID_REF) {		gnttab_end_foreign_access(info->urb_ring_ref,					  (unsigned long)info->urb_ring.sring);		info->urb_ring_ref = GRANT_INVALID_REF;	}	info->urb_ring.sring = NULL;	if (info->conn_ring_ref != GRANT_INVALID_REF) {		gnttab_end_foreign_access(info->conn_ring_ref,					  (unsigned long)info->conn_ring.sring);		info->conn_ring_ref = GRANT_INVALID_REF;	}	info->conn_ring.sring = NULL;}

static void free_pdev(struct pcifront_device *pdev){	dev_dbg(&pdev->xdev->dev, "freeing pdev @ 0x%p/n", pdev);	pcifront_free_roots(pdev);	/*For PCIE_AER error handling job*/	flush_scheduled_work();	unbind_from_irqhandler(pdev->evtchn, pdev);	if (pdev->evtchn != INVALID_EVTCHN)		xenbus_free_evtchn(pdev->xdev, pdev->evtchn);	if (pdev->gnt_ref != INVALID_GRANT_REF)		gnttab_end_foreign_access(pdev->gnt_ref,					  (unsigned long)pdev->sh_info);	dev_set_drvdata(&pdev->xdev->dev, NULL);	kfree(pdev);}

static int setup_suspend_evtchn(void){	static int irq;	int port;	char portstr[16];	if (irq > 0)		unbind_from_irqhandler(irq, NULL);	irq = bind_listening_port_to_irqhandler(0, suspend_int, 0, "suspend",						NULL);	if (irq <= 0)		return -1;	port = irq_to_evtchn_port(irq);	printk(KERN_INFO "suspend: event channel %d/n", port);	(void)snprintf(portstr,sizeof(portstr), "%d", port);	xenbus_write(XBT_NIL, "device/suspend", "event-channel", portstr);	return 0;}

void scsiback_disconnect(struct vscsibk_info *info){	if (info->kthread) {		kthread_stop(info->kthread);		info->kthread = NULL;	}	wait_event(info->waiting_to_free, 		atomic_read(&info->nr_unreplied_reqs) == 0);	if (info->irq) {		unbind_from_irqhandler(info->irq, info);		info->irq = 0;	}	if (info->ring.sring) {		unmap_frontend_page(info);		free_vm_area(info->ring_area);		info->ring.sring = NULL;	}}

static void xen_blkif_disconnect(struct xen_blkif *blkif){	if (blkif->xenblkd) {		kthread_stop(blkif->xenblkd);		blkif->xenblkd = NULL;	}	atomic_dec(&blkif->refcnt);	wait_event(blkif->waiting_to_free, atomic_read(&blkif->refcnt) == 0);	atomic_inc(&blkif->refcnt);	if (blkif->irq) {		unbind_from_irqhandler(blkif->irq, blkif);		blkif->irq = 0;	}	if (blkif->blk_rings.common.sring) {		xenbus_unmap_ring_vfree(blkif->be->dev, blkif->blk_ring);		blkif->blk_rings.common.sring = NULL;	}}

/** * cancel connection *      unbind irq *      unmap ring **/static void xen_chrif_disconnect(struct xen_chrif *chrif){	unmap_frontend_pages(chrif); 	xen_chrbk_unmap(chrif);	if(chrif->xenchrd){		kthread_stop(chrif->xenchrd);		chrif->xenchrd = NULL;	}		if(chrif->irq){        unbind_from_irqhandler(chrif->irq, chrif);        chrif->irq = 0;    }        if(chrif->chr_ring.sring){        xenbus_unmap_ring_vfree(chrif->be->dev, &chrif->chr_ring);        chrif->chr_ring.sring = NULL;    }	    printk("/nxen: dom0: xen chrif disconnrct finished");}

static int __devinitunbind_evtchn_callback(struct notifier_block *nfb,		       unsigned long action, void *hcpu){	unsigned int cpu = (unsigned long)hcpu;	if (action == CPU_DEAD) {		/* Unregister evtchn.  */		if (per_cpu(xen_cpep_irq, cpu) >= 0) {			unbind_from_irqhandler(per_cpu(xen_cpep_irq, cpu),					       NULL);			per_cpu(xen_cpep_irq, cpu) = -1;		}		if (per_cpu(xen_cmcp_irq, cpu) >= 0) {			unbind_from_irqhandler(per_cpu(xen_cmcp_irq, cpu),					       NULL);			per_cpu(xen_cmcp_irq, cpu) = -1;		}		if (per_cpu(xen_cmc_irq, cpu) >= 0) {			unbind_from_irqhandler(per_cpu(xen_cmc_irq, cpu), NULL);			per_cpu(xen_cmc_irq, cpu) = -1;		}		if (per_cpu(xen_ipi_irq, cpu) >= 0) {			unbind_from_irqhandler(per_cpu(xen_ipi_irq, cpu), NULL);			per_cpu(xen_ipi_irq, cpu) = -1;		}		if (per_cpu(xen_resched_irq, cpu) >= 0) {			unbind_from_irqhandler(per_cpu(xen_resched_irq, cpu),					       NULL);			per_cpu(xen_resched_irq, cpu) = -1;		}		if (per_cpu(xen_timer_irq, cpu) >= 0) {			unbind_from_irqhandler(per_cpu(xen_timer_irq, cpu),					       NULL);			per_cpu(xen_timer_irq, cpu) = -1;		}	}	return NOTIFY_OK;}