Release 4.7 drivers/xen/events/events_base.c

Directory: drivers/xen/events
/*
 * Xen event channels
 *
 * Xen models interrupts with abstract event channels.  Because each
 * domain gets 1024 event channels, but NR_IRQ is not that large, we
 * must dynamically map irqs<->event channels.  The event channels
 * interface with the rest of the kernel by defining a xen interrupt
 * chip.  When an event is received, it is mapped to an irq and sent
 * through the normal interrupt processing path.
 *
 * There are four kinds of events which can be mapped to an event
 * channel:
 *
 * 1. Inter-domain notifications.  This includes all the virtual
 *    device events, since they're driven by front-ends in another domain
 *    (typically dom0).
 * 2. VIRQs, typically used for timers.  These are per-cpu events.
 * 3. IPIs.
 * 4. PIRQs - Hardware interrupts.
 *
 * Jeremy Fitzhardinge <jeremy@xensource.com>, XenSource Inc, 2007
 */


#define pr_fmt(fmt) "xen:" KBUILD_MODNAME ": " fmt

#include <linux/linkage.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/moduleparam.h>
#include <linux/string.h>
#include <linux/bootmem.h>
#include <linux/slab.h>
#include <linux/irqnr.h>
#include <linux/pci.h>

#ifdef CONFIG_X86
#include <asm/desc.h>
#include <asm/ptrace.h>
#include <asm/irq.h>
#include <asm/idle.h>
#include <asm/io_apic.h>
#include <asm/i8259.h>
#include <asm/xen/pci.h>
#endif
#include <asm/sync_bitops.h>
#include <asm/xen/hypercall.h>
#include <asm/xen/hypervisor.h>
#include <xen/page.h>

#include <xen/xen.h>
#include <xen/hvm.h>
#include <xen/xen-ops.h>
#include <xen/events.h>
#include <xen/interface/xen.h>
#include <xen/interface/event_channel.h>
#include <xen/interface/hvm/hvm_op.h>
#include <xen/interface/hvm/params.h>
#include <xen/interface/physdev.h>
#include <xen/interface/sched.h>
#include <xen/interface/vcpu.h>
#include <asm/hw_irq.h>

#include "events_internal.h"


const struct evtchn_ops *evtchn_ops;

/*
 * This lock protects updates to the following mapping and reference-count
 * arrays. The lock does not need to be acquired to read the mapping tables.
 */
static DEFINE_MUTEX(irq_mapping_update_lock);

static LIST_HEAD(xen_irq_list_head);

/* IRQ <-> VIRQ mapping. */
static DEFINE_PER_CPU(int [NR_VIRQS], virq_to_irq) = {[0 ... NR_VIRQS-1] = -1};

/* IRQ <-> IPI mapping */
static DEFINE_PER_CPU(int [XEN_NR_IPIS], ipi_to_irq) = {[0 ... XEN_NR_IPIS-1] = -1};


int **evtchn_to_irq;
#ifdef CONFIG_X86

static unsigned long *pirq_eoi_map;
#endif

static bool (*pirq_needs_eoi)(unsigned irq);


#define EVTCHN_ROW(e)  (e / (PAGE_SIZE/sizeof(**evtchn_to_irq)))

#define EVTCHN_COL(e)  (e % (PAGE_SIZE/sizeof(**evtchn_to_irq)))

#define EVTCHN_PER_ROW (PAGE_SIZE / sizeof(**evtchn_to_irq))

/* Xen will never allocate port zero for any purpose. */

#define VALID_EVTCHN(chn)	((chn) != 0)


static struct irq_chip xen_dynamic_chip;

static struct irq_chip xen_percpu_chip;

static struct irq_chip xen_pirq_chip;
static void enable_dynirq(struct irq_data *data);
static void disable_dynirq(struct irq_data *data);



static void clear_evtchn_to_irq_row(unsigned row)
{
	unsigned col;

	for (col = 0; col < EVTCHN_PER_ROW; col++)
		evtchn_to_irq[row][col] = -1;
}

Contributors
Person Tokens Prop Commits CommitProp
david vrabel david vrabel 36 100.00% 1 100.00%
Total 36 100.00% 1 100.00%



static void clear_evtchn_to_irq_all(void)
{
	unsigned row;

	for (row = 0; row < EVTCHN_ROW(xen_evtchn_max_channels()); row++) {
		if (evtchn_to_irq[row] == NULL)
			continue;
		clear_evtchn_to_irq_row(row);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
david vrabel david vrabel 45 100.00% 1 100.00%
Total 45 100.00% 1 100.00%



static int set_evtchn_to_irq(unsigned evtchn, unsigned irq)
{
	unsigned row;
	unsigned col;

	if (evtchn >= xen_evtchn_max_channels())
		return -EINVAL;

	row = EVTCHN_ROW(evtchn);
	col = EVTCHN_COL(evtchn);

	if (evtchn_to_irq[row] == NULL) {
		/* Unallocated irq entries return -1 anyway */
		if (irq == -1)
			return 0;

		evtchn_to_irq[row] = (int *)get_zeroed_page(GFP_KERNEL);
		if (evtchn_to_irq[row] == NULL)
			return -ENOMEM;

		clear_evtchn_to_irq_row(row);
	}

	evtchn_to_irq[EVTCHN_ROW(evtchn)][EVTCHN_COL(evtchn)] = irq;
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
david vrabel david vrabel 116 100.00% 1 100.00%
Total 116 100.00% 1 100.00%



int get_evtchn_to_irq(unsigned evtchn)
{
	if (evtchn >= xen_evtchn_max_channels())
		return -1;
	if (evtchn_to_irq[EVTCHN_ROW(evtchn)] == NULL)
		return -1;
	return evtchn_to_irq[EVTCHN_ROW(evtchn)][EVTCHN_COL(evtchn)];
}

Contributors
Person Tokens Prop Commits CommitProp
david vrabel david vrabel 50 100.00% 1 100.00%
Total 50 100.00% 1 100.00%

/* Get info for IRQ */


struct irq_info *info_for_irq(unsigned irq)
{
	return irq_get_handler_data(irq);
}

Contributors
Person Tokens Prop Commits CommitProp
jeremy fitzhardinge jeremy fitzhardinge 8 50.00% 1 25.00%
ian campbell ian campbell 7 43.75% 2 50.00%
thomas gleixner thomas gleixner 1 6.25% 1 25.00%
Total 16 100.00% 4 100.00%

/* Constructors for packed IRQ information. */


static int xen_irq_info_common_setup(struct irq_info *info,
				     unsigned irq,
				     enum xen_irq_type type,
				     unsigned evtchn,
				     unsigned short cpu)
{
	int ret;

	BUG_ON(info->type != IRQT_UNBOUND && info->type != type);

	info->type = type;
	info->irq = irq;
	info->evtchn = evtchn;
	info->cpu = cpu;

	ret = set_evtchn_to_irq(evtchn, irq);
	if (ret < 0)
		return ret;

	irq_clear_status_flags(irq, IRQ_NOREQUEST|IRQ_NOAUTOEN);

	return xen_evtchn_port_setup(info);
}

Contributors
Person Tokens Prop Commits CommitProp
ian campbell ian campbell 52 52.00% 4 44.44%
david vrabel david vrabel 26 26.00% 3 33.33%
jeremy fitzhardinge jeremy fitzhardinge 13 13.00% 1 11.11%
julien grall julien grall 9 9.00% 1 11.11%
Total 100 100.00% 9 100.00%



static int xen_irq_info_evtchn_setup(unsigned irq,
				     unsigned evtchn)
{
	struct irq_info *info = info_for_irq(irq);

	return xen_irq_info_common_setup(info, irq, IRQT_EVTCHN, evtchn, 0);
}

Contributors
Person Tokens Prop Commits CommitProp
ian campbell ian campbell 21 58.33% 3 60.00%
jeremy fitzhardinge jeremy fitzhardinge 10 27.78% 1 20.00%
david vrabel david vrabel 5 13.89% 1 20.00%
Total 36 100.00% 5 100.00%



static int xen_irq_info_ipi_setup(unsigned cpu,
				  unsigned irq,
				  unsigned evtchn,
				  enum ipi_vector ipi)
{
	struct irq_info *info = info_for_irq(irq);

	info->u.ipi = ipi;

	per_cpu(ipi_to_irq, cpu)[ipi] = irq;

	return xen_irq_info_common_setup(info, irq, IRQT_IPI, evtchn, 0);
}

Contributors
Person Tokens Prop Commits CommitProp
ian campbell ian campbell 28 44.44% 3 60.00%
jeremy fitzhardinge jeremy fitzhardinge 19 30.16% 1 20.00%
david vrabel david vrabel 16 25.40% 1 20.00%
Total 63 100.00% 5 100.00%



static int xen_irq_info_virq_setup(unsigned cpu,
				   unsigned irq,
				   unsigned evtchn,
				   unsigned virq)
{
	struct irq_info *info = info_for_irq(irq);

	info->u.virq = virq;

	per_cpu(virq_to_irq, cpu)[virq] = irq;

	return xen_irq_info_common_setup(info, irq, IRQT_VIRQ, evtchn, 0);
}

Contributors
Person Tokens Prop Commits CommitProp
ian campbell ian campbell 30 48.39% 2 50.00%
jeremy fitzhardinge jeremy fitzhardinge 16 25.81% 1 25.00%
david vrabel david vrabel 16 25.81% 1 25.00%
Total 62 100.00% 4 100.00%



static int xen_irq_info_pirq_setup(unsigned irq,
				   unsigned evtchn,
				   unsigned pirq,
				   unsigned gsi,
				   uint16_t domid,
				   unsigned char flags)
{
	struct irq_info *info = info_for_irq(irq);

	info->u.pirq.pirq = pirq;
	info->u.pirq.gsi = gsi;
	info->u.pirq.domid = domid;
	info->u.pirq.flags = flags;

	return xen_irq_info_common_setup(info, irq, IRQT_PIRQ, evtchn, 0);
}

Contributors
Person Tokens Prop Commits CommitProp
ian campbell ian campbell 33 37.08% 1 20.00%
jeremy fitzhardinge jeremy fitzhardinge 20 22.47% 1 20.00%
david vrabel david vrabel 16 17.98% 1 20.00%
konrad rzeszutek wilk konrad rzeszutek wilk 13 14.61% 1 20.00%
stefano stabellini stefano stabellini 7 7.87% 1 20.00%
Total 89 100.00% 5 100.00%



static void xen_irq_info_cleanup(struct irq_info *info)
{
	set_evtchn_to_irq(info->evtchn, -1);
	info->evtchn = 0;
}

Contributors
Person Tokens Prop Commits CommitProp
david vrabel david vrabel 27 100.00% 1 100.00%
Total 27 100.00% 1 100.00%

/*
 * Accessors for packed IRQ information.
 */


unsigned int evtchn_from_irq(unsigned irq)
{
	if (unlikely(WARN(irq >= nr_irqs, "Invalid irq %d!\n", irq)))
		return 0;

	return info_for_irq(irq)->evtchn;
}

Contributors
Person Tokens Prop Commits CommitProp
joe jin joe jin 19 52.78% 1 50.00%
jeremy fitzhardinge jeremy fitzhardinge 17 47.22% 1 50.00%
Total 36 100.00% 2 100.00%



unsigned irq_from_evtchn(unsigned int evtchn)
{
	return get_evtchn_to_irq(evtchn);
}
Contributors
Person Tokens Prop Commits CommitProp
ian campbell ian campbell 12 80.00% 1 50.00%
david vrabel david vrabel 3 20.00% 1 50.00%
Total 15 100.00% 2 100.00%


EXPORT_SYMBOL_GPL(irq_from_evtchn);



int irq_from_virq(unsigned int cpu, unsigned int virq)
{
	return per_cpu(virq_to_irq, cpu)[virq];
}

Contributors
Person Tokens Prop Commits CommitProp
david vrabel david vrabel 24 100.00% 1 100.00%
Total 24 100.00% 1 100.00%



static enum ipi_vector ipi_from_irq(unsigned irq)
{
	struct irq_info *info = info_for_irq(irq);

	BUG_ON(info == NULL);
	BUG_ON(info->type != IRQT_IPI);

	return info->u.ipi;
}

Contributors
Person Tokens Prop Commits CommitProp
jeremy fitzhardinge jeremy fitzhardinge 43 100.00% 1 100.00%
Total 43 100.00% 1 100.00%



static unsigned virq_from_irq(unsigned irq)
{
	struct irq_info *info = info_for_irq(irq);

	BUG_ON(info == NULL);
	BUG_ON(info->type != IRQT_VIRQ);

	return info->u.virq;
}

Contributors
Person Tokens Prop Commits CommitProp
jeremy fitzhardinge jeremy fitzhardinge 42 100.00% 1 100.00%
Total 42 100.00% 1 100.00%



static unsigned pirq_from_irq(unsigned irq)
{
	struct irq_info *info = info_for_irq(irq);

	BUG_ON(info == NULL);
	BUG_ON(info->type != IRQT_PIRQ);

	return info->u.pirq.pirq;
}

Contributors
Person Tokens Prop Commits CommitProp
stefano stabellini stefano stabellini 44 100.00% 1 100.00%
Total 44 100.00% 1 100.00%



static enum xen_irq_type type_from_irq(unsigned irq)
{
	return info_for_irq(irq)->type;
}

Contributors
Person Tokens Prop Commits CommitProp
jeremy fitzhardinge jeremy fitzhardinge 18 100.00% 2 100.00%
Total 18 100.00% 2 100.00%



unsigned cpu_from_irq(unsigned irq)
{
	return info_for_irq(irq)->cpu;
}

Contributors
Person Tokens Prop Commits CommitProp
jeremy fitzhardinge jeremy fitzhardinge 16 100.00% 2 100.00%
Total 16 100.00% 2 100.00%



unsigned int cpu_from_evtchn(unsigned int evtchn)
{
	int irq = get_evtchn_to_irq(evtchn);
	unsigned ret = 0;

	if (irq != -1)
		ret = cpu_from_irq(irq);

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
jeremy fitzhardinge jeremy fitzhardinge 37 92.50% 2 66.67%
david vrabel david vrabel 3 7.50% 1 33.33%
Total 40 100.00% 3 100.00%

#ifdef CONFIG_X86


static bool pirq_check_eoi_map(unsigned irq)
{
	return test_bit(pirq_from_irq(irq), pirq_eoi_map);
}
Contributors
Person Tokens Prop Commits CommitProp
stefano stabellini stefano stabellini 18 90.00% 2 66.67%
jeremy fitzhardinge jeremy fitzhardinge 2 10.00% 1 33.33%
Total 20 100.00% 3 100.00%

#endif



static bool pirq_needs_eoi_flag(unsigned irq)
{
	struct irq_info *info = info_for_irq(irq);
	BUG_ON(info->type != IRQT_PIRQ);

	return info->u.pirq.flags & PIRQ_NEEDS_EOI;
}

Contributors
Person Tokens Prop Commits CommitProp
jeremy fitzhardinge jeremy fitzhardinge 36 92.31% 1 50.00%
stefano stabellini stefano stabellini 3 7.69% 1 50.00%
Total 39 100.00% 2 100.00%



static void bind_evtchn_to_cpu(unsigned int chn, unsigned int cpu)
{
	int irq = get_evtchn_to_irq(chn);
	struct irq_info *info = info_for_irq(irq);

	BUG_ON(irq == -1);
#ifdef CONFIG_SMP
	cpumask_copy(irq_get_affinity_mask(irq), cpumask_of(cpu));
#endif
	xen_evtchn_port_bind_to_cpu(info, cpu);

	info->cpu = cpu;
}

Contributors
Person Tokens Prop Commits CommitProp
jeremy fitzhardinge jeremy fitzhardinge 43 60.56% 2 20.00%
david vrabel david vrabel 16 22.54% 2 20.00%
mike travis mike travis 7 9.86% 2 20.00%
yinghai lu yinghai lu 2 2.82% 1 10.00%
ian campbell ian campbell 2 2.82% 2 20.00%
jiang liu jiang liu 1 1.41% 1 10.00%
Total 71 100.00% 10 100.00%



static void xen_evtchn_mask_all(void)
{
	unsigned int evtchn;

	for (evtchn = 0; evtchn < xen_evtchn_nr_channels(); evtchn++)
		mask_evtchn(evtchn);
}

Contributors
Person Tokens Prop Commits CommitProp
david vrabel david vrabel 31 100.00% 1 100.00%
Total 31 100.00% 1 100.00%

/**
 * notify_remote_via_irq - send event to remote end of event channel via irq
 * @irq: irq of event channel to send event to
 *
 * Unlike notify_remote_via_evtchn(), this is safe to use across
 * save/restore. Notifications on a broken connection are silently
 * dropped.
 */


void notify_remote_via_irq(int irq)
{
	int evtchn = evtchn_from_irq(irq);

	if (VALID_EVTCHN(evtchn))
		notify_remote_via_evtchn(evtchn);
}
Contributors
Person Tokens Prop Commits CommitProp
david vrabel david vrabel 16 57.14% 1 33.33%
jeremy fitzhardinge jeremy fitzhardinge 10 35.71% 1 33.33%
ian campbell ian campbell 2 7.14% 1 33.33%
Total 28 100.00% 3 100.00%


EXPORT_SYMBOL_GPL(notify_remote_via_irq);



static void xen_irq_init(unsigned irq)
{
	struct irq_info *info;
#ifdef CONFIG_SMP
	/* By default all event channels notify CPU#0. */
	cpumask_copy(irq_get_affinity_mask(irq), cpumask_of(0));
#endif

	info = kzalloc(sizeof(*info), GFP_KERNEL);
	if (info == NULL)
		panic("Unable to allocate metadata for IRQ%d\n", irq);

	info->type = IRQT_UNBOUND;
	info->refcnt = -1;

	irq_set_handler_data(irq, info);

	list_add_tail(&info->list, &xen_irq_list_head);
}

Contributors
Person Tokens Prop Commits CommitProp
david vrabel david vrabel 76 84.44% 1 20.00%
jeremy fitzhardinge jeremy fitzhardinge 8 8.89% 1 20.00%
thomas gleixner thomas gleixner 3 3.33% 1 20.00%
ian campbell ian campbell 2 2.22% 1 20.00%
jiang liu jiang liu 1 1.11% 1 20.00%
Total 90 100.00% 5 100.00%



static int __must_check xen_allocate_irqs_dynamic(int nvec)
{
	int i, irq = irq_alloc_descs(-1, 0, nvec, -1);

	if (irq >= 0) {
		for (i = 0; i < nvec; i++)
			xen_irq_init(irq + i);
	}

	return irq;
}

Contributors
Person Tokens Prop Commits CommitProp
roger pau monne roger pau monne 24 40.68% 1 20.00%
david vrabel david vrabel 17 28.81% 1 20.00%
jeremy fitzhardinge jeremy fitzhardinge 10 16.95% 1 20.00%
thomas gleixner thomas gleixner 7 11.86% 1 20.00%
ian campbell ian campbell 1 1.69% 1 20.00%
Total 59 100.00% 5 100.00%



static inline int __must_check xen_allocate_irq_dynamic(void)
{

	return xen_allocate_irqs_dynamic(1);
}

Contributors
Person Tokens Prop Commits CommitProp
roger pau monne roger pau monne 16 100.00% 1 100.00%
Total 16 100.00% 1 100.00%



static int __must_check xen_allocate_irq_gsi(unsigned gsi)
{
	int irq;

	/*
         * A PV guest has no concept of a GSI (since it has no ACPI
         * nor access to/knowledge of the physical APICs). Therefore
         * all IRQs are dynamically allocated from the entire IRQ
         * space.
         */
	if (xen_pv_domain() && !xen_initial_domain())
		return xen_allocate_irq_dynamic();

	/* Legacy IRQ descriptors are already allocated by the arch. */
	if (gsi < nr_legacy_irqs())
		irq = gsi;
	else
		irq = irq_alloc_desc_at(gsi, -1);

	xen_irq_init(irq);

	return irq;
}

Contributors
Person Tokens Prop Commits CommitProp
david vrabel david vrabel 43 74.14% 1 33.33%
wei liu wei liu 13 22.41% 1 33.33%
boris ostrovsky boris ostrovsky 2 3.45% 1 33.33%
Total 58 100.00% 3 100.00%



static void xen_free_irq(unsigned irq)
{
	struct irq_info *info = irq_get_handler_data(irq);

	if (WARN_ON(!info))
		return;

	list_del(&info->list);

	irq_set_handler_data(irq, NULL);

	WARN_ON(info->refcnt > 0);

	kfree(info);

	/* Legacy IRQ descriptors are managed by the arch. */
	if (irq < nr_legacy_irqs())
		return;

	irq_free_desc(irq);
}

Contributors
Person Tokens Prop Commits CommitProp
david vrabel david vrabel 51 71.83% 2 50.00%
jeremy fitzhardinge jeremy fitzhardinge 18 25.35% 1 25.00%
boris ostrovsky boris ostrovsky 2 2.82% 1 25.00%
Total 71 100.00% 4 100.00%



static void xen_evtchn_close(unsigned int port)
{
	struct evtchn_close close;

	close.port = port;
	if (HYPERVISOR_event_channel_op(EVTCHNOP_close, &close) != 0)
		BUG();
}

Contributors
Person Tokens Prop Commits CommitProp
david vrabel david vrabel 31 88.57% 2 66.67%
jeremy fitzhardinge jeremy fitzhardinge 4 11.43% 1 33.33%
Total 35 100.00% 3 100.00%



static void pirq_query_unmask(int irq)
{
	struct physdev_irq_status_query irq_status;
	struct irq_info *info = info_for_irq(irq);

	BUG_ON(info->type != IRQT_PIRQ);

	irq_status.irq = pirq_from_irq(irq);
	if (HYPERVISOR_physdev_op(PHYSDEVOP_irq_status_query, &irq_status))
		irq_status.flags = 0;

	info->u.pirq.flags &= ~PIRQ_NEEDS_EOI;
	if (irq_status.flags & XENIRQSTAT_needs_eoi)
		info->u.pirq.flags |= PIRQ_NEEDS_EOI;
}

Contributors
Person Tokens Prop Commits CommitProp
david vrabel david vrabel 58 67.44% 2 40.00%
jeremy fitzhardinge jeremy fitzhardinge 19 22.09% 1 20.00%
stefano stabellini stefano stabellini 7 8.14% 1 20.00%
ian campbell ian campbell 2 2.33% 1 20.00%
Total 86 100.00% 5 100.00%



static void eoi_pirq(struct irq_data *data)
{
	int evtchn = evtchn_from_irq(data->irq);
	struct physdev_eoi eoi = { .irq = pirq_from_irq(data->irq) };
	int rc = 0;

	if (!VALID_EVTCHN(evtchn))
		return;

	if (unlikely(irqd_is_setaffinity_pending(data)) &&
	    likely(!irqd_irq_disabled(data))) {
		int masked = test_and_set_mask(evtchn);

		clear_evtchn(evtchn);

		irq_move_masked_irq(data);

		if (!masked)
			unmask_evtchn(evtchn);
	} else
		clear_evtchn(evtchn);

	if (pirq_needs_eoi(data->irq)) {
		rc = HYPERVISOR_physdev_op(PHYSDEVOP_eoi, &eoi);
		WARN_ON(rc);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
david vrabel david vrabel 58 44.62% 1 11.11%
boris ostrovsky boris ostrovsky 41 31.54% 1 11.11%
ross lagerwall ross lagerwall 9 6.92% 1 11.11%
jeremy fitzhardinge jeremy fitzhardinge 8 6.15% 2 22.22%
ian campbell ian campbell 7 5.38% 1 11.11%
konrad rzeszutek wilk konrad rzeszutek wilk 6 4.62% 2 22.22%
thomas gleixner thomas gleixner 1 0.77% 1 11.11%
Total 130 100.00% 9 100.00%



static void mask_ack_pirq(struct irq_data *data)
{
	disable_dynirq(data);
	eoi_pirq(data);
}

Contributors
Person Tokens Prop Commits CommitProp
ian campbell ian campbell 11 52.38% 1 50.00%
david vrabel david vrabel 10 47.62% 1 50.00%
Total 21 100.00% 2 100.00%



static unsigned int __startup_pirq(unsigned int irq)
{
	struct evtchn_bind_pirq bind_pirq;
	struct irq_info *info = info_for_irq(irq);
	int evtchn = evtchn_from_irq(irq);
	int rc;

	BUG_ON(info->type != IRQT_PIRQ);

	if (VALID_EVTCHN(evtchn))
		goto out;

	bind_pirq.pirq = pirq_from_irq(irq);
	/* NB. We are happy to share unless we are probing. */
	bind_pirq.flags = info->u.pirq.flags & PIRQ_SHAREABLE ?
					BIND_PIRQ__WILL_SHARE : 0;
	rc = HYPERVISOR_event_channel_op(EVTCHNOP_bind_pirq, &bind_pirq);
	if (rc != 0) {
		pr_warn("Failed to obtain physical IRQ %d\n", irq);
		return 0;
	}
	evtchn = bind_pirq.port;

	pirq_query_unmask(irq);

	rc = set_evtchn_to_irq(evtchn, irq);
	if (rc)
		goto err;

	info->evtchn = evtchn;
	bind_evtchn_to_cpu(evtchn, 0);

	rc = xen_evtchn_port_setup(info);
	if (rc)
		goto err;

out:
	unmask_evtchn(evtchn);
	eoi_pirq(irq_get_irq_data(irq));

	return 0;

err:
	pr_err("irq%d: Failed to set port to irq mapping (%d)\n", irq, rc);
	xen_evtchn_close(evtchn);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
david vrabel david vrabel 109 53.96% 2 15.38%
juergen gross juergen gross 36 17.82% 1 7.69%
ian campbell ian campbell 31 15.35% 5 38.46%
jeremy fitzhardinge jeremy fitzhardinge 12 5.94% 1 7.69%
boris ostrovsky boris ostrovsky 6 2.97% 1 7.69%
daniel de graaf daniel de graaf 5 2.48% 1 7.69%
konrad rzeszutek wilk konrad rzeszutek wilk 2 0.99% 1 7.69%
thomas gleixner thomas gleixner 1 0.50% 1 7.69%
Total 202 100.00% 13 100.00%



static unsigned int startup_pirq(struct irq_data *data)
{
	return __startup_pirq(data->irq);
}

Contributors
Person Tokens Prop Commits CommitProp
david vrabel david vrabel 11 55.00% 1 50.00%
jeremy fitzhardinge jeremy fitzhardinge 9 45.00% 1 50.00%
Total 20 100.00% 2 100.00%



static void shutdown_pirq(struct irq_data *data)
{
	unsigned int irq = data->irq;
	struct irq_info *info = info_for_irq(irq);
	unsigned evtchn = evtchn_from_irq(irq);

	BUG_ON(info->type != IRQT_PIRQ);

	if (!VALID_EVTCHN(evtchn))
		return;

	mask_evtchn(evtchn);
	xen_evtchn_close(evtchn);
	xen_irq_info_cleanup(info);
}

Contributors
Person Tokens Prop Commits CommitProp
stefano stabellini stefano stabellini 40 57.14% 1 33.33%
david vrabel david vrabel 30 42.86% 2 66.67%
Total 70 100.00% 3 100.00%



static void enable_pirq(struct irq_data *data)
{
	startup_pirq(data);
}

Contributors
Person Tokens Prop Commits CommitProp
stefano stabellini stefano stabellini 13 81.25% 1 50.00%
david vrabel david vrabel 3 18.75% 1 50.00%
Total 16 100.00% 2 100.00%



static void disable_pirq(struct irq_data *data)
{
	disable_dynirq(data);
}

Contributors
Person Tokens Prop Commits CommitProp
david vrabel david vrabel 11 68.75% 1 50.00%
stefano stabellini stefano stabellini 5 31.25% 1 50.00%
Total 16 100.00% 2 100.00%



int xen_irq_from_gsi(unsigned gsi)
{
	struct irq_info *info;

	list_for_each_entry(info, &xen_irq_list_head, list) {
		if (info->type != IRQT_PIRQ)
			continue;

		if (info->u.pirq.gsi == gsi)
			return info->irq;
	}

	return -1;
}
Contributors
Person Tokens Prop Commits CommitProp
david vrabel david vrabel 28 52.83% 1 33.33%
jeremy fitzhardinge jeremy fitzhardinge 19 35.85% 1 33.33%
konrad rzeszutek wilk konrad rzeszutek wilk 6 11.32% 1 33.33%
Total 53 100.00% 3 100.00%


EXPORT_SYMBOL_GPL(xen_irq_from_gsi);



static void __unbind_from_irq(unsigned int irq)
{
	int evtchn = evtchn_from_irq(irq);
	struct irq_info *info = irq_get_handler_data(irq);

	if (info->refcnt > 0) {
		info->refcnt--;
		if (info->refcnt != 0)
			return;
	}

	if (VALID_EVTCHN(evtchn)) {
		unsigned int cpu = cpu_from_irq(irq);

		xen_evtchn_close(evtchn);

		switch (type_from_irq(irq)) {
		case IRQT_VIRQ:
			per_cpu(virq_to_irq, cpu)[virq_from_irq(irq)] = -1;
			break;
		case IRQT_IPI:
			per_cpu(ipi_to_irq, cpu)[ipi_from_irq(irq)] = -1;
			break;
		default:
			break;
		}

		xen_irq_info_cleanup(info);
	}

	BUG_ON(info_for_irq(irq)->type == IRQT_UNBOUND);

	xen_free_irq(irq);
}

Contributors
Person Tokens Prop Commits CommitProp
david vrabel david vrabel 148 100.00% 2 100.00%
Total 148 100.00% 2 100.00%

/*
 * Do not make any assumptions regarding the relationship between the
 * IRQ number returned here and the Xen pirq argument.
 *
 * Note: We don't assign an event channel until the irq actually started
 * up.  Return an existing irq if we've already got one for the gsi.
 *
 * Shareable implies level triggered, not shareable implies edge
 * triggered here.
 */


int xen_bind_pirq_gsi_to_irq(unsigned gsi,
			     unsigned pirq, int shareable, char *name)
{
	int irq = -1;
	struct physdev_irq irq_op;
	int ret;

	mutex_lock(&irq_mapping_update_lock);

	irq = xen_irq_from_gsi(gsi);
	if (irq != -1) {
		pr_info("%s: returning irq %d for gsi %u\n",
			__func__, irq, gsi);
		goto out;
	}

	irq = xen_allocate_irq_gsi(gsi);
	if (irq < 0)
		goto out;

	irq_op.irq = irq;
	irq_op.vector = 0;

	/* Only the privileged domain can do this. For non-priv, the pcifront
         * driver provides a PCI bus that does the call to do exactly
         * this in the priv domain. */
	if (xen_initial_domain() &&
	    HYPERVISOR_physdev_op(PHYSDEVOP_alloc_irq_vector, &irq_op)) {
		xen_free_irq(irq);
		irq = -ENOSPC;
		goto out;
	}

	ret = xen_irq_info_pirq_setup(irq, 0, pirq, gsi, DOMID_SELF,
			       shareable ? PIRQ_SHAREABLE : 0);
	if (ret < 0) {
		__unbind_from_irq(irq);
		irq = ret;
		goto out;
	}

	pirq_query_unmask(irq);
	/* We try to use the handler with the appropriate semantic for the
         * type of interrupt: if the interrupt is an edge triggered
         * interrupt we use handle_edge_irq.
         *
         * On the other hand if the interrupt is level triggered we use
         * handle_fasteoi_irq like the native code does for this kind of
         * interrupts.
         *
         * Depending on the Xen version, pirq_needs_eoi might return true
         * not only for level triggered interrupts but for edge triggered
         * interrupts too. In any case Xen always honors the eoi mechanism,
         * not injecting any more pirqs of the same kind if the first one
         * hasn't received an eoi yet. Therefore using the fasteoi handler
         * is the right choice either way.
         */
	if (shareable)
		irq_set_chip_and_handler_name(irq, &xen_pirq_chip,
				handle_fasteoi_irq, name);
	else
		irq_set_chip_and_handler_name(irq, &xen_pirq_chip,
				handle_edge_irq, name);

out:
	mutex_unlock(&irq_mapping_update_lock);

	return irq;
}

Contributors
Person Tokens Prop Commits CommitProp
david vrabel david vrabel 173 81.99% 2 33.33%
jeremy fitzhardinge jeremy fitzhardinge 30 14.22% 1 16.67%
konrad rzeszutek wilk konrad rzeszutek wilk 5 2.37% 1 16.67%
stefano stabellini stefano stabellini 2 0.95% 1 16.67%
joe perches joe perches 1 0.47% 1 16.67%
Total 211 100.00% 6 100.00%

#ifdef CONFIG_PCI_MSI


int xen_allocate_pirq_msi(struct pci_dev *dev, struct msi_desc *msidesc)
{
	int rc;
	struct physdev_get_free_pirq op_get_free_pirq;

	op_get_free_pirq.type = MAP_PIRQ_TYPE_MSI;
	rc = HYPERVISOR_physdev_op(PHYSDEVOP_get_free_pirq, &op_get_free_pirq);

	WARN_ONCE(rc == -ENOSYS,
		  "hypervisor does not support the PHYSDEVOP_get_free_pirq interface\n");

	return rc ? -1 : op_get_free_pirq.pirq;
}

Contributors
Person Tokens Prop Commits CommitProp
david vrabel david vrabel 31 53.45% 1 33.33%
jeremy fitzhardinge jeremy fitzhardinge 19 32.76% 1 33.33%
thomas gleixner thomas gleixner 8 13.79% 1 33.33%
Total 58 100.00% 3 100.00%



int xen_bind_pirq_msi_to_irq(struct pci_dev *dev, struct msi_desc *msidesc,
			     int pirq, int nvec, const char *name, domid_t domid)
{
	int i, irq, ret;

	mutex_lock(&irq_mapping_update_lock);

	irq = xen_allocate_irqs_dynamic(nvec);
	if (irq < 0)
		goto out;

	for (i = 0; i < nvec; i++) {
		irq_set_chip_and_handler_name(irq + i, &xen_pirq_chip, handle_edge_irq, name);

		ret = xen_irq_info_pirq_setup(irq + i, 0, pirq + i, 0, domid,
					      i == 0 ? 0 : PIRQ_MSI_GROUP);
		if (ret < 0)
			goto error_irq;
	}

	ret = irq_set_msi_desc(irq, msidesc);
	if (ret < 0)
		goto error_irq;
out:
	mutex_unlock(&irq_mapping_update_lock);
	return irq;
error_irq:
	for (; i >= 0; i--)
		__unbind_from_irq(irq + i);
	mutex_unlock(&irq_mapping_update_lock);
	return ret;
}
Contributors
Person Tokens Prop Commits CommitProp
david vrabel david vrabel 58 32.22% 2 12.50%
roger pau monne roger pau monne 48 26.67% 1 6.25%
stefano stabellini stefano stabellini 25 13.89% 3 18.75%
jeremy fitzhardinge jeremy fitzhardinge 23 12.78% 2 12.50%
ian campbell ian campbell 21 11.67% 3 18.75%
konrad rzeszutek wilk konrad rzeszutek wilk 5 2.78% 5 31.25%
Total 180 100.00% 16 100.00%

#endif



int xen_destroy_irq(int irq)
{
	struct physdev_unmap_pirq unmap_irq;
	struct irq_info *info = info_for_irq(irq);
	int rc = -ENOENT;

	mutex_lock(&irq_mapping_update_lock);

	/*
         * If trying to remove a vector in a MSI group different
         * than the first one skip the PIRQ unmap unless this vector
         * is the first one in the group.
         */
	if (xen_initial_domain() && !(info->u.pirq.flags & PIRQ_MSI_GROUP)) {
		unmap_irq.pirq = info->u.pirq.pirq;
		unmap_irq.domid = info->u.pirq.domid;
		rc = HYPERVISOR_physdev_op(PHYSDEVOP_unmap_pirq, &unmap_irq);
		/* If another domain quits without making the pci_disable_msix
                 * call, the Xen hypervisor takes care of freeing the PIRQs
                 * (free_domain_pirqs).
                 */
		if ((rc == -ESRCH && info->u.pirq.domid != DOMID_SELF))
			pr_info("domain %d does not have %d anymore\n",
				info->u.pirq.domid, info->u.pirq.pirq);
		else if (rc) {
			pr_warn("unmap irq failed %d\n", rc);
			goto out;
		}
	}

	xen_free_irq(irq);

out:
	mutex_unlock(&irq_mapping_update_lock);
	return rc;
}

Contributors
Person Tokens Prop Commits CommitProp
jeremy fitzhardinge jeremy fitzhardinge 60 36.81% 1 10.00%
konrad rzeszutek wilk konrad rzeszutek wilk 52 31.90% 5 50.00%
alex nixon alex nixon 34 20.86% 1 10.00%
roger pau monne roger pau monne 14 8.59% 1 10.00%
joe perches joe perches 2 1.23% 1 10.00%
ian campbell ian campbell 1 0.61% 1 10.00%
Total 163 100.00% 10 100.00%



int xen_irq_from_pirq(unsigned pirq)
{
	int irq;

	struct irq_info *info;

	mutex_lock(&irq_mapping_update_lock);

	list_for_each_entry(info, &xen_irq_list_head, list) {
		if (info->type != IRQT_PIRQ)
			continue;
		irq = info->irq;
		if (info->u.pirq.pirq == pirq)
			goto out;
	}
	irq = -1;
out:
	mutex_unlock(&irq_mapping_update_lock);

	return irq;
}


Contributors
Person Tokens Prop Commits CommitProp
ian campbell ian campbell 55 70.51% 1 20.00%
stefano stabellini stefano stabellini 12 15.38% 1 20.00%
jeremy fitzhardinge jeremy fitzhardinge 9 11.54% 2 40.00%
konrad rzeszutek wilk konrad rzeszutek wilk 2 2.56% 1 20.00%
Total 78 100.00% 5 100.00%



int xen_pirq_from_irq(unsigned irq)
{
	return pirq_from_irq(irq);
}
Contributors
Person Tokens Prop Commits CommitProp
konrad rzeszutek wilk konrad rzeszutek wilk 14 100.00% 1 100.00%
Total 14 100.00% 1 100.00%


EXPORT_SYMBOL_GPL(xen_pirq_from_irq);



int bind_evtchn_to_irq(unsigned int evtchn)
{
	int irq;
	int ret;

	if (evtchn >= xen_evtchn_max_channels())
		return -ENOMEM;

	mutex_lock(&irq_mapping_update_lock);

	irq = get_evtchn_to_irq(evtchn);

	if (irq == -1) {
		irq = xen_allocate_irq_dynamic();
		if (irq < 0)
			goto out;

		irq_set_chip_and_handler_name(irq, &xen_dynamic_chip,
					      handle_edge_irq, "event");

		ret = xen_irq_info_evtchn_setup(irq, evtchn);
		if (ret < 0) {
			__unbind_from_irq(irq);
			irq = ret;
			goto out;
		}
		/* New interdomain events are bound to VCPU 0. */
		bind_evtchn_to_cpu(evtchn, 0);
	} else {
		struct irq_info *info = info_for_irq(irq);
		WARN_ON(info == NULL || info->type != IRQT_EVTCHN);
	}

out:
	mutex_unlock(&irq_mapping_update_lock);

	return irq;
}
Contributors
Person Tokens Prop Commits CommitProp
jeremy fitzhardinge jeremy fitzhardinge 56 37.84% 1 8.33%
david vrabel david vrabel 48 32.43% 3 25.00%
konrad rzeszutek wilk konrad rzeszutek wilk 28 18.92% 2 16.67%
ian campbell ian campbell 12 8.11% 3 25.00%
wei liu wei liu 2 1.35% 1 8.33%
thomas gleixner thomas gleixner 1 0.68% 1 8.33%
stefano stabellini stefano stabellini 1 0.68% 1 8.33%
Total 148 100.00% 12 100.00%


EXPORT_SYMBOL_GPL(bind_evtchn_to_irq);



static int bind_ipi_to_irq(unsigned int ipi, unsigned int cpu)
{
	struct evtchn_bind_ipi bind_ipi;
	int evtchn, irq;
	int ret;

	mutex_lock(&irq_mapping_update_lock);

	irq = per_cpu(ipi_to_irq, cpu)[ipi];

	if (irq == -1) {
		irq = xen_allocate_irq_dynamic();
		if (irq < 0)
			goto out;

		irq_set_chip_and_handler_name(irq, &xen_percpu_chip,
					      handle_percpu_irq, "ipi");

		bind_ipi.vcpu = cpu;
		if (HYPERVISOR_event_channel_op(EVTCHNOP_bind_ipi,
						&bind_ipi) != 0)
			BUG();
		evtchn = bind_ipi.port;

		ret = xen_irq_info_ipi_setup(cpu, irq, evtchn, ipi);
		if (ret < 0) {
			__unbind_from_irq(irq);
			irq = ret;
			goto out;
		}
		bind_evtchn_to_cpu(evtchn, cpu);
	} else {
		struct irq_info *info = info_for_irq(irq);
		WARN_ON(info == NULL || info->type != IRQT_IPI);
	}

 out:
	mutex_unlock(&irq_mapping_update_lock);
	return irq;
}

Contributors
Person Tokens Prop Commits CommitProp
jeremy fitzhardinge jeremy fitzhardinge 123 67.21% 3 30.00%
konrad rzeszutek wilk konrad rzeszutek wilk 28 15.30% 2 20.00%
david vrabel david vrabel 26 14.21% 1 10.00%
ian campbell ian campbell 5 2.73% 3 30.00%
thomas gleixner thomas gleixner 1 0.55% 1 10.00%
Total 183 100.00% 10 100.00%



int bind_interdomain_evtchn_to_irq(unsigned int remote_domain,
				   unsigned int remote_port)
{
	struct evtchn_bind_interdomain bind_interdomain;
	int err;

	bind_interdomain.remote_dom  = remote_domain;
	bind_interdomain.remote_port = remote_port;

	err = HYPERVISOR_event_channel_op(EVTCHNOP_bind_interdomain,
					  &bind_interdomain);

	return err ? : bind_evtchn_to_irq(bind_interdomain.local_port);
}
Contributors
Person Tokens Prop Commits CommitProp
ian campbell ian campbell 53 100.00% 1 100.00%
Total 53 100.00% 1 100.00%


EXPORT_SYMBOL_GPL(bind_interdomain_evtchn_to_irq);



static int find_virq(unsigned int virq, unsigned int cpu)
{
	struct evtchn_status status;
	int port, rc = -ENOENT;

	memset(&status, 0, sizeof(status));
	for (port = 0; port < xen_evtchn_max_channels(); port++) {
		status.dom = DOMID_SELF;
		status.port = port;
		rc = HYPERVISOR_event_channel_op(EVTCHNOP_status, &status);
		if (rc < 0)
			continue;
		if (status.status != EVTCHNSTAT_virq)
			continue;
		if (status.u.virq == virq && status.vcpu == cpu) {
			rc = port;
			break;
		}
	}
	return rc;
}

Contributors
Person Tokens Prop Commits CommitProp
olaf hering olaf hering 116 97.48% 1 50.00%
david vrabel david vrabel 3 2.52% 1 50.00%
Total 119 100.00% 2 100.00%

/**
 * xen_evtchn_nr_channels - number of usable event channel ports
 *
 * This may be less than the maximum supported by the current
 * hypervisor ABI. Use xen_evtchn_max_channels() for the maximum
 * supported.
 */


unsigned xen_evtchn_nr_channels(void)
{
        return evtchn_ops->nr_channels();
}
Contributors
Person Tokens Prop Commits CommitProp
david vrabel david vrabel 13 100.00% 1 100.00%
Total 13 100.00% 1 100.00%


EXPORT_SYMBOL_GPL(xen_evtchn_nr_channels);



int bind_virq_to_irq(unsigned int virq, unsigned int cpu, bool percpu)
{
	struct evtchn_bind_virq bind_virq;
	int evtchn, irq, ret;

	mutex_lock(&irq_mapping_update_lock);

	irq = per_cpu(virq_to_irq, cpu)[virq];

	if (irq == -1) {
		irq = xen_allocate_irq_dynamic();
		if (irq < 0)
			goto out;

		if (percpu)
			irq_set_chip_and_handler_name(irq, &xen_percpu_chip,
						      handle_percpu_irq, "virq");
		else
			irq_set_chip_and_handler_name(irq, &xen_dynamic_chip,
						      handle_edge_irq, "virq");

		bind_virq.virq = virq;
		bind_virq.vcpu = cpu;
		ret = HYPERVISOR_event_channel_op(EVTCHNOP_bind_virq,
						&bind_virq);
		if (ret == 0)
			evtchn = bind_virq.port;
		else {
			if (ret == -EEXIST)
				ret = find_virq(virq, cpu);
			BUG_ON(ret < 0);
			evtchn = ret;
		}

		ret = xen_irq_info_virq_setup(cpu, irq, evtchn, virq);
		if (ret < 0) {
			__unbind_from_irq(irq);
			irq = ret;
			goto out;
		}

		bind_evtchn_to_cpu(evtchn, cpu);
	} else {
		struct irq_info *info = info_for_irq(irq);
		WARN_ON(info == NULL || info->type != IRQT_VIRQ);
	}

out:
	mutex_unlock(&irq_mapping_update_lock);

	return irq;
}

Contributors
Person Tokens Prop Commits CommitProp
jeremy fitzhardinge jeremy fitzhardinge 111 46.64% 3 21.43%
david vrabel david vrabel 43 18.07% 2 14.29%
olaf hering olaf hering 39 16.39% 1 7.14%
konrad rzeszutek wilk konrad rzeszutek wilk 28 11.76% 2 14.29%
ian campbell ian campbell 14 5.88% 4 28.57%
wei liu wei liu 2 0.84% 1 7.14%
thomas gleixner thomas gleixner 1 0.42% 1 7.14%
Total 238 100.00% 14 100.00%



static void unbind_from_irq(unsigned int irq)
{
	mutex_lock(&irq_mapping_update_lock);
	__unbind_from_irq(irq);
	mutex_unlock(&irq_mapping_update_lock);
}

Contributors
Person Tokens Prop Commits CommitProp
jeremy fitzhardinge jeremy fitzhardinge 24 88.89% 1 33.33%
konrad rzeszutek wilk konrad rzeszutek wilk 2 7.41% 1 33.33%
david vrabel david vrabel 1 3.70% 1 33.33%
Total 27 100.00% 3 100.00%



int bind_evtchn_to_irqhandler(unsigned int evtchn,
			      irq_handler_t handler,
			      unsigned long irqflags,
			      const char *devname, void *dev_id)
{
	int irq, retval;

	irq = bind_evtchn_to_irq(evtchn);
	if (irq < 0)
		return irq;
	retval = request_irq(irq, handler, irqflags, devname, dev_id);
	if (retval != 0) {
		unbind_from_irq(irq);
		return retval;
	}

	return irq;
}
Contributors
Person Tokens Prop Commits CommitProp
jeremy fitzhardinge jeremy fitzhardinge 69 86.25% 1 25.00%
ian campbell ian campbell 9 11.25% 1 25.00%
jeff garzik jeff garzik 1 1.25% 1 25.00%
nicolas kaiser nicolas kaiser 1 1.25% 1 25.00%
Total 80 100.00% 4 100.00%


EXPORT_SYMBOL_GPL(bind_evtchn_to_irqhandler);



int bind_interdomain_evtchn_to_irqhandler(unsigned int remote_domain,
					  unsigned int remote_port,
					  irq_handler_t handler,
					  unsigned long irqflags,
					  const char *devname,
					  void *dev_id)
{
	int irq, retval;

	irq = bind_interdomain_evtchn_to_irq(remote_domain, remote_port);
	if (irq < 0)
		return irq;

	retval = request_irq(irq, handler, irqflags, devname, dev_id);
	if (retval != 0) {
		unbind_from_irq(irq);
		return retval;
	}

	return irq;
}
Contributors
Person Tokens Prop Commits CommitProp
ian campbell ian campbell 86 100.00% 1 100.00%
Total 86 100.00% 1 100.00%


EXPORT_SYMBOL_GPL(bind_interdomain_evtchn_to_irqhandler);



int bind_virq_to_irqhandler(unsigned int virq, unsigned int cpu,
			    irq_handler_t handler,
			    unsigned long irqflags, const char *devname, void *dev_id)
{
	int irq, retval;

	irq = bind_virq_to_irq(virq, cpu, irqflags & IRQF_PERCPU);
	if (irq < 0)
		return irq;
	retval = request_irq(irq, handler, irqflags, devname, dev_id);
	if (retval != 0) {
		unbind_from_irq(irq);
		return retval;
	}

	return irq;
}
Contributors
Person Tokens Prop Commits CommitProp
jeremy fitzhardinge jeremy fitzhardinge 75 83.33% 1 20.00%
ian campbell ian campbell 9 10.00% 1 20.00%
david vrabel david vrabel 4 4.44% 1 20.00%
nicolas kaiser nicolas kaiser 1 1.11% 1 20.00%
jeff garzik jeff garzik 1 1.11% 1 20.00%
Total 90 100.00% 5 100.00%


EXPORT_SYMBOL_GPL(bind_virq_to_irqhandler);



int bind_ipi_to_irqhandler(enum ipi_vector ipi,
			   unsigned int cpu,
			   irq_handler_t handler,
			   unsigned long irqflags,
			   const char *devname,
			   void *dev_id)
{
	int irq, retval;

	irq = bind_ipi_to_irq(ipi, cpu);
	if (irq < 0)
		return irq;

	irqflags |= IRQF_NO_SUSPEND | IRQF_FORCE_RESUME | IRQF_EARLY_RESUME;
	retval = request_irq(irq, handler, irqflags, devname, dev_id);
	if (retval != 0) {
		unbind_from_irq(irq);
		return retval;
	}

	return irq;
}

Contributors
Person Tokens Prop Commits CommitProp
jeremy fitzhardinge jeremy fitzhardinge 86 91.49% 1 25.00%
ian campbell ian campbell 6 6.38% 2 50.00%
thomas gleixner thomas gleixner 2 2.13% 1 25.00%
Total 94 100.00% 4 100.00%



void unbind_from_irqhandler(unsigned int irq, void *dev_id)
{
	struct irq_info *info = irq_get_handler_data(irq);

	if (WARN_ON(!info))
		return;
	free_irq(irq, dev_id);
	unbind_from_irq(irq);
}
Contributors
Person Tokens Prop Commits CommitProp
jeremy fitzhardinge jeremy fitzhardinge 25 56.82% 1 50.00%
konrad rzeszutek wilk konrad rzeszutek wilk 19 43.18% 1 50.00%
Total 44 100.00% 2 100.00%


EXPORT_SYMBOL_GPL(unbind_from_irqhandler);

/**
 * xen_set_irq_priority() - set an event channel priority.
 * @irq:irq bound to an event channel.
 * @priority: priority between XEN_IRQ_PRIORITY_MAX and XEN_IRQ_PRIORITY_MIN.
 */


int xen_set_irq_priority(unsigned irq, unsigned priority)
{
	struct evtchn_set_priority set_priority;

	set_priority.port = evtchn_from_irq(irq);
	set_priority.priority = priority;

	return HYPERVISOR_event_channel_op(EVTCHNOP_set_priority,
					   &set_priority);
}
Contributors
Person Tokens Prop Commits CommitProp
david vrabel david vrabel 39 100.00% 1 100.00%
Total 39 100.00% 1 100.00%


EXPORT_SYMBOL_GPL(xen_set_irq_priority);



int evtchn_make_refcounted(unsigned int evtchn)
{
	int irq = get_evtchn_to_irq(evtchn);
	struct irq_info *info;

	if (irq == -1)
		return -ENOENT;

	info = irq_get_handler_data(irq);

	if (!info)
		return -ENOENT;

	WARN_ON(info->refcnt != -1);

	info->refcnt = 1;

	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
david vrabel david vrabel 32 47.06% 2 40.00%
daniel de graaf daniel de graaf 27 39.71% 1 20.00%
jeremy fitzhardinge jeremy fitzhardinge 8 11.76% 1 20.00%
ian campbell ian campbell 1 1.47% 1 20.00%
Total 68 100.00% 5 100.00%


EXPORT_SYMBOL_GPL(evtchn_make_refcounted);



int evtchn_get(unsigned int evtchn)
{
	int irq;
	struct irq_info *info;
	int err = -ENOENT;

	if (evtchn >= xen_evtchn_max_channels())
		return -EINVAL;

	mutex_lock(&irq_mapping_update_lock);

	irq = get_evtchn_to_irq(evtchn);
	if (irq == -1)
		goto done;

	info = irq_get_handler_data(irq);

	if (!info)
		goto done;

	err = -EINVAL;
	if (info->refcnt <= 0)
		goto done;

	info->refcnt++;
	err = 0;
 done:
	mutex_unlock(&irq_mapping_update_lock);

	return err;
}
Contributors
Person Tokens Prop Commits CommitProp
david vrabel david vrabel 63 58.33% 2 25.00%
keir fraser keir fraser 22 20.37% 3 37.50%
jeremy fitzhardinge jeremy fitzhardinge 13 12.04% 2 25.00%
scott rixner scott rixner 10 9.26% 1 12.50%
Total 108 100.00% 8 100.00%


EXPORT_SYMBOL_GPL(evtchn_get);



void evtchn_put(unsigned int evtchn)
{
	int irq = get_evtchn_to_irq(evtchn);
	if (WARN_ON(irq == -1))
		return;
	unbind_from_irq(irq);
}
Contributors
Person Tokens Prop Commits CommitProp
david vrabel david vrabel 29 87.88% 2 50.00%
keir fraser keir fraser 3 9.09% 1 25.00%
jeremy fitzhardinge jeremy fitzhardinge 1 3.03% 1 25.00%
Total 33 100.00% 4 100.00%


EXPORT_SYMBOL_GPL(evtchn_put);



void xen_send_IPI_one(unsigned int cpu, enum ipi_vector vector)
{
	int irq;

#ifdef CONFIG_X86
	if (unlikely(vector == XEN_NMI_VECTOR)) {
		int rc =  HYPERVISOR_vcpu_op(VCPUOP_send_nmi, cpu, NULL);
		if (rc < 0)
			printk(KERN_WARNING "Sending nmi to CPU%d failed (rc:%d)\n", cpu, rc);
		return;
	}
#endif
	irq = per_cpu(ipi_to_irq, cpu)[vector];
	BUG_ON(irq < 0);
	notify_remote_via_irq(irq);
}

Contributors
Person Tokens Prop Commits CommitProp
david vrabel david vrabel 54 63.53% 1 16.67%
jeremy fitzhardinge jeremy fitzhardinge 13 15.29% 1 16.67%
scott rixner scott rixner 9 10.59% 1 16.67%
keir fraser keir fraser 4 4.71% 1 16.67%
eric w. biederman eric w. biederman 4 4.71% 1 16.67%
isaku yamahata isaku yamahata 1 1.18% 1 16.67%
Total 85 100.00% 6 100.00%

static DEFINE_PER_CPU(unsigned, xed_nesting_count);



static void __xen_evtchn_do_upcall(void)
{
	struct vcpu_info *vcpu_info = __this_cpu_read(xen_vcpu);
	int cpu = get_cpu();
	unsigned count;

	do {
		vcpu_info->evtchn_upcall_pending = 0;

		if (__this_cpu_inc_return(xed_nesting_count) - 1)
			goto out;

		xen_evtchn_handle_events(cpu);

		BUG_ON(!irqs_disabled());

		count = __this_cpu_read(xed_nesting_count);
		__this_cpu_write(xed_nesting_count, 0);
	} while (count != 1 || vcpu_info->evtchn_upcall_pending);

out:

	put_cpu();
}

Contributors
Person Tokens Prop Commits CommitProp
david vrabel david vrabel 44 48.89% 1 10.00%
jeremy fitzhardinge jeremy fitzhardinge 26 28.89% 2 20.00%
sheng yang sheng yang 4 4.44% 1 10.00%
christoph lameter christoph lameter 4 4.44% 1 10.00%
stefano stabellini stefano stabellini 4 4.44% 1 10.00%
keir fraser keir fraser 2 2.22% 1 10.00%
tejun heo tejun heo 2 2.22% 1 10.00%
ian campbell ian campbell 2 2.22% 1 10.00%
scott rixner scott rixner 2 2.22% 1 10.00%
Total 90 100.00% 10 100.00%



void xen_evtchn_do_upcall(struct pt_regs *regs)
{
	struct pt_regs *old_regs = set_irq_regs(regs);

	irq_enter();
#ifdef CONFIG_X86
	exit_idle();
	inc_irq_stat(irq_hv_callback_count);
#endif

	__xen_evtchn_do_upcall();

	irq_exit();
	set_irq_regs(old_regs);
}

Contributors
Person Tokens Prop Commits CommitProp
sheng yang sheng yang 26 55.32% 1 16.67%
jeremy fitzhardinge jeremy fitzhardinge 8 17.02% 1 16.67%
thomas gleixner thomas gleixner 5 10.64% 1 16.67%
stefano stabellini stefano stabellini 3 6.38% 1 16.67%
mojiong qiu mojiong qiu 3 6.38% 1 16.67%
arnd bergmann arnd bergmann 2 4.26% 1 16.67%
Total 47 100.00% 6 100.00%



void xen_hvm_evtchn_do_upcall(void)
{
	__xen_evtchn_do_upcall();
}
Contributors
Person Tokens Prop Commits CommitProp
sheng yang sheng yang 7 70.00% 1 50.00%
jeremy fitzhardinge jeremy fitzhardinge 3 30.00% 1 50.00%
Total 10 100.00% 2 100.00%


EXPORT_SYMBOL_GPL(xen_hvm_evtchn_do_upcall);

/* Rebind a new event channel to an existing irq. */


void rebind_evtchn_irq(int evtchn, int irq)
{
	struct irq_info *info = info_for_irq(irq);

	if (WARN_ON(!info))
		return;

	/* Make sure the irq is masked, since the new event channel
           will also be masked. */
	disable_irq(irq);

	mutex_lock(&irq_mapping_update_lock);

	/* After resume the irq<->evtchn mappings are all cleared out */
	BUG_ON(get_evtchn_to_irq(evtchn) != -1);
	/* Expect irq to have been bound before,
           so there should be a proper type */
	BUG_ON(info->type == IRQT_UNBOUND);

	(void)xen_irq_info_evtchn_setup(irq, evtchn);

	mutex_unlock(&irq_mapping_update_lock);

        bind_evtchn_to_cpu(evtchn, info->cpu);
	/* This will be deferred until interrupt is processed */
	irq_set_affinity(irq, cpumask_of(info->cpu));

	/* Unmask the event channel. */
	enable_irq(irq);
}

Contributors
Person Tokens Prop Commits CommitProp
jeremy fitzhardinge jeremy fitzhardinge 74 68.52% 2 22.22%
boris ostrovsky boris ostrovsky 13 12.04% 1 11.11%
konrad rzeszutek wilk konrad rzeszutek wilk 11 10.19% 2 22.22%
david vrabel david vrabel 7 6.48% 2 22.22%
ian campbell ian campbell 2 1.85% 1 11.11%
rusty russell rusty russell 1 0.93% 1 11.11%
Total 108 100.00% 9 100.00%

/* Rebind an evtchn so that it gets delivered to a specific cpu */


static int rebind_irq_to_cpu(unsigned irq, unsigned tcpu)
{
	struct evtchn_bind_vcpu bind_vcpu;
	int evtchn = evtchn_from_irq(irq);
	int masked;

	if (!VALID_EVTCHN(evtchn))
		return -1;

	if (!xen_support_evtchn_rebind())
		return -1;

	/* Send future instances of this interrupt to other vcpu. */
	bind_vcpu.port = evtchn;
	bind_vcpu.vcpu = tcpu;

	/*
         * Mask the event while changing the VCPU binding to prevent
         * it being delivered on an unexpected VCPU.
         */
	masked = test_and_set_mask(evtchn);

	/*
         * If this fails, it usually just indicates that we're dealing with a
         * virq or IPI channel, which don't actually need to be rebound. Ignore
         * it, but don't do the xenlinux-level rebind in that case.
         */
	if (HYPERVISOR_event_channel_op(EVTCHNOP_bind_vcpu, &bind_vcpu) >= 0)
		bind_evtchn_to_cpu(evtchn, tcpu);

	if (!masked)
		unmask_evtchn(evtchn);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
jeremy fitzhardinge jeremy fitzhardinge 64 62.14% 1 14.29%
david vrabel david vrabel 20 19.42% 1 14.29%
yinghai lu yinghai lu 8 7.77% 1 14.29%
ian campbell ian campbell 7 6.80% 1 14.29%
julien grall julien grall 2 1.94% 1 14.29%
stefano stabellini stefano stabellini 1 0.97% 1 14.29%
wei liu wei liu 1 0.97% 1 14.29%
Total 103 100.00% 7 100.00%



static int set_affinity_irq(struct irq_data *data, const struct cpumask *dest,
			    bool force)
{
	unsigned tcpu = cpumask_first_and(dest, cpu_online_mask);

	return rebind_irq_to_cpu(data->irq, tcpu);
}

Contributors
Person Tokens Prop Commits CommitProp
jeremy fitzhardinge jeremy fitzhardinge 21 52.50% 1 20.00%
thomas gleixner thomas gleixner 12 30.00% 2 40.00%
rusty russell rusty russell 4 10.00% 1 20.00%
yinghai lu yinghai lu 3 7.50% 1 20.00%
Total 40 100.00% 5 100.00%



static void enable_dynirq(struct irq_data *data)
{
	int evtchn = evtchn_from_irq(data->irq);

	if (VALID_EVTCHN(evtchn))
		unmask_evtchn(evtchn);
}

Contributors
Person Tokens Prop Commits CommitProp
jeremy fitzhardinge jeremy fitzhardinge 27 81.82% 1 50.00%
thomas gleixner thomas gleixner 6 18.18% 1 50.00%
Total 33 100.00% 2 100.00%



static void disable_dynirq(struct irq_data *data)
{
	int evtchn = evtchn_from_irq(data->irq);

	if (VALID_EVTCHN(evtchn))
		mask_evtchn(evtchn);
}

Contributors
Person Tokens Prop Commits CommitProp
jeremy fitzhardinge jeremy fitzhardinge 27 81.82% 1 50.00%
thomas gleixner thomas gleixner 6 18.18% 1 50.00%
Total 33 100.00% 2 100.00%



static void ack_dynirq(struct irq_data *data)
{
	int evtchn = evtchn_from_irq(data->irq);

	if (!VALID_EVTCHN(evtchn))
		return;

	if (unlikely(irqd_is_setaffinity_pending(data)) &&
	    likely(!irqd_irq_disabled(data))) {
		int masked = test_and_set_mask(evtchn);

		clear_evtchn(evtchn);

		irq_move_masked_irq(data);

		if (!masked)
			unmask_evtchn(evtchn);
	} else
		clear_evtchn(evtchn);
}

Contributors
Person Tokens Prop Commits CommitProp
boris ostrovsky boris ostrovsky 41 48.24% 1 20.00%
jeremy fitzhardinge jeremy fitzhardinge 27 31.76% 1 20.00%
ross lagerwall ross lagerwall 9 10.59% 1 20.00%
thomas gleixner thomas gleixner 7 8.24% 1 20.00%
stefano stabellini stefano stabellini 1 1.18% 1 20.00%
Total 85 100.00% 5 100.00%



static void mask_ack_dynirq(struct irq_data *data)
{
	disable_dynirq(data);
	ack_dynirq(data);
}

Contributors
Person Tokens Prop Commits CommitProp
stefano stabellini stefano stabellini 21 100.00% 1 100.00%
Total 21 100.00% 1 100.00%



static int retrigger_dynirq(struct irq_data *data)
{
	unsigned int evtchn = evtchn_from_irq(data->irq);
	int masked;

	if (!VALID_EVTCHN(evtchn))
		return 0;

	masked = test_and_set_mask(evtchn);
	set_evtchn(evtchn);
	if (!masked)
		unmask_evtchn(evtchn);

	return 1;
}

Contributors
Person Tokens Prop Commits CommitProp
david vrabel david vrabel 42 68.85% 1 25.00%
jeremy fitzhardinge jeremy fitzhardinge 12 19.67% 1 25.00%
thomas gleixner thomas gleixner 6 9.84% 1 25.00%
ian campbell ian campbell 1 1.64% 1 25.00%
Total 61 100.00% 4 100.00%



static void restore_pirqs(void)
{
	int pirq, rc, irq, gsi;
	struct physdev_map_pirq map_irq;
	struct irq_info *info;

	list_for_each_entry(info, &xen_irq_list_head, list) {
		if (info->type != IRQT_PIRQ)
			continue;

		pirq = info->u.pirq.pirq;
		gsi = info->u.pirq.gsi;
		irq = info->irq;

		/* save/restore of PT devices doesn't work, so at this point the
                 * only devices present are GSI based emulated devices */
		if (!gsi)
			continue;

		map_irq.domid = DOMID_SELF;
		map_irq.type = MAP_PIRQ_TYPE_GSI;
		map_irq.index = gsi;
		map_irq.pirq = pirq;

		rc = HYPERVISOR_physdev_op(PHYSDEVOP_map_pirq, &map_irq);
		if (rc) {
			pr_warn("xen map irq failed gsi=%d irq=%d pirq=%d rc=%d\n",
				gsi, irq, pirq, rc);
			xen_free_irq(irq);
			continue;
		}

		printk(KERN_DEBUG "xen: --> irq=%d, pirq=%d\n", irq, map_irq.pirq);

		__startup_pirq(irq);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
stefano stabellini stefano stabellini 109 70.78% 1 16.67%
ian campbell ian campbell 43 27.92% 3 50.00%
thomas gleixner thomas gleixner 1 0.65% 1 16.67%
joe perches joe perches 1 0.65% 1 16.67%
Total 154 100.00% 6 100.00%



static void restore_cpu_virqs(unsigned int cpu)
{
	struct evtchn_bind_virq bind_virq;
	int virq, irq, evtchn;

	for (virq = 0; virq < NR_VIRQS; virq++) {
		if ((irq = per_cpu(virq_to_irq, cpu)[virq]) == -1)
			continue;

		BUG_ON(virq_from_irq(irq) != virq);

		/* Get a new binding from Xen. */
		bind_virq.virq = virq;
		bind_virq.vcpu = cpu;
		if (HYPERVISOR_event_channel_op(EVTCHNOP_bind_virq,
						&bind_virq) != 0)
			BUG();
		evtchn = bind_virq.port;

		/* Record the new mapping. */
		(void)xen_irq_info_virq_setup(cpu, irq, evtchn, virq);
		bind_evtchn_to_cpu(evtchn, cpu);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
jeremy fitzhardinge jeremy fitzhardinge 114 93.44% 2 40.00%
ian campbell ian campbell 4 3.28% 2 40.00%
david vrabel david vrabel 4 3.28% 1 20.00%
Total 122 100.00% 5 100.00%



static void restore_cpu_ipis(unsigned int cpu)
{
	struct evtchn_bind_ipi bind_ipi;
	int ipi, irq, evtchn;

	for (ipi = 0; ipi < XEN_NR_IPIS; ipi++) {
		if ((irq = per_cpu(ipi_to_irq, cpu)[ipi]) == -1)
			continue;

		BUG_ON(ipi_from_irq(irq) != ipi);

		/* Get a new binding from Xen. */
		bind_ipi.vcpu = cpu;
		if (HYPERVISOR_event_channel_op(EVTCHNOP_bind_ipi,
						&bind_ipi) != 0)
			BUG();
		evtchn = bind_ipi.port;

		/* Record the new mapping. */
		(void)xen_irq_info_ipi_setup(cpu, irq, evtchn, ipi);
		bind_evtchn_to_cpu(evtchn, cpu);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
jeremy fitzhardinge jeremy fitzhardinge 108 93.10% 2 40.00%
ian campbell ian campbell 4 3.45% 2 40.00%
david vrabel david vrabel 4 3.45% 1 20.00%
Total 116 100.00% 5 100.00%

/* Clear an irq's pending state, in preparation for polling on it */


void xen_clear_irq_pending(int irq)
{
	int evtchn = evtchn_from_irq(irq);

	if (VALID_EVTCHN(evtchn))
		clear_evtchn(evtchn);
}
Contributors
Person Tokens Prop Commits CommitProp
jeremy fitzhardinge jeremy fitzhardinge 28 100.00% 1 100.00%
Total 28 100.00% 1 100.00%


EXPORT_SYMBOL(xen_clear_irq_pending);


void xen_set_irq_pending(int irq)
{
	int evtchn = evtchn_from_irq(irq);

	if (VALID_EVTCHN(evtchn))
		set_evtchn(evtchn);
}

Contributors
Person Tokens Prop Commits CommitProp
jeremy fitzhardinge jeremy fitzhardinge 28 100.00% 1 100.00%
Total 28 100.00% 1 100.00%



bool xen_test_irq_pending(int irq)
{
	int evtchn = evtchn_from_irq(irq);
	bool ret = false;

	if (VALID_EVTCHN(evtchn))
		ret = test_evtchn(evtchn);

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
jeremy fitzhardinge jeremy fitzhardinge 38 100.00% 1 100.00%
Total 38 100.00% 1 100.00%

/* Poll waiting for an irq to become pending with timeout.  In the usual case,
 * the irq will be disabled so it won't deliver an interrupt. */


void xen_poll_irq_timeout(int irq, u64 timeout)
{
	evtchn_port_t evtchn = evtchn_from_irq(irq);

	if (VALID_EVTCHN(evtchn)) {
		struct sched_poll poll;

		poll.nr_ports = 1;
		poll.timeout = timeout;
		set_xen_guest_handle(poll.ports, &evtchn);

		if (HYPERVISOR_sched_op(SCHEDOP_poll, &poll) != 0)
			BUG();
	}
}
Contributors
Person Tokens Prop Commits CommitProp
jeremy fitzhardinge jeremy fitzhardinge 60 86.96% 1 33.33%
konrad rzeszutek wilk konrad rzeszutek wilk 5 7.25% 1 33.33%
isaku yamahata isaku yamahata 4 5.80% 1 33.33%
Total 69 100.00% 3 100.00%


EXPORT_SYMBOL(xen_poll_irq_timeout);
/* Poll waiting for an irq to become pending.  In the usual case, the
 * irq will be disabled so it won't deliver an interrupt. */


void xen_poll_irq(int irq)
{
	xen_poll_irq_timeout(irq, 0 /* no timeout */);
}

Contributors
Person Tokens Prop Commits CommitProp
konrad rzeszutek wilk konrad rzeszutek wilk 16 100.00% 1 100.00%
Total 16 100.00% 1 100.00%

/* Check whether the IRQ line is shared with other guests. */


int xen_test_irq_shared(int irq)
{
	struct irq_info *info = info_for_irq(irq);
	struct physdev_irq_status_query irq_status;

	if (WARN_ON(!info))
		return -ENOENT;

	irq_status.irq = info->u.pirq.pirq;

	if (HYPERVISOR_physdev_op(PHYSDEVOP_irq_status_query, &irq_status))
		return 0;
	return !(irq_status.flags & XENIRQSTAT_shared);
}
Contributors
Person Tokens Prop Commits CommitProp
konrad rzeszutek wilk konrad rzeszutek wilk 69 100.00% 2 100.00%
Total 69 100.00% 2 100.00%


EXPORT_SYMBOL_GPL(xen_test_irq_shared);



void xen_irq_resume(void)
{
	unsigned int cpu;
	struct irq_info *info;

	/* New event-channel space is not 'live' yet. */
	xen_evtchn_mask_all();
	xen_evtchn_resume();

	/* No IRQ <-> event-channel mappings. */
	list_for_each_entry(info, &xen_irq_list_head, list)
		info->evtchn = 0; /* zap event-channel binding */

	clear_evtchn_to_irq_all();

	for_each_possible_cpu(cpu) {
		restore_cpu_virqs(cpu);
		restore_cpu_ipis(cpu);
	}

	restore_pirqs();
}

Contributors
Person Tokens Prop Commits CommitProp
jeremy fitzhardinge jeremy fitzhardinge 36 59.02% 1 14.29%
ian campbell ian campbell 16 26.23% 2 28.57%
david vrabel david vrabel 7 11.48% 3 42.86%
stefano stabellini stefano stabellini 2 3.28% 1 14.29%
Total 61 100.00% 7 100.00%


static struct irq_chip xen_dynamic_chip __read_mostly = {
	.name			= "xen-dyn",

	.irq_disable		= disable_dynirq,
	.irq_mask		= disable_dynirq,
	.irq_unmask		= enable_dynirq,

	.irq_ack		= ack_dynirq,
	.irq_mask_ack		= mask_ack_dynirq,

	.irq_set_affinity	= set_affinity_irq,
	.irq_retrigger		= retrigger_dynirq,
};


static struct irq_chip xen_pirq_chip __read_mostly = {
	.name			= "xen-pirq",

	.irq_startup		= startup_pirq,
	.irq_shutdown		= shutdown_pirq,
	.irq_enable		= enable_pirq,
	.irq_disable		= disable_pirq,

	.irq_mask		= disable_dynirq,
	.irq_unmask		= enable_dynirq,

	.irq_ack		= eoi_pirq,
	.irq_eoi		= eoi_pirq,
	.irq_mask_ack		= mask_ack_pirq,

	.irq_set_affinity	= set_affinity_irq,

	.irq_retrigger		= retrigger_dynirq,
};


static struct irq_chip xen_percpu_chip __read_mostly = {
	.name			= "xen-percpu",

	.irq_disable		= disable_dynirq,
	.irq_mask		= disable_dynirq,
	.irq_unmask		= enable_dynirq,

	.irq_ack		= ack_dynirq,
};



int xen_set_callback_via(uint64_t via)
{
	struct xen_hvm_param a;
	a.domid = DOMID_SELF;
	a.index = HVM_PARAM_CALLBACK_IRQ;
	a.value = via;
	return HYPERVISOR_hvm_op(HVMOP_set_param, &a);
}
Contributors
Person Tokens Prop Commits CommitProp
sheng yang sheng yang 39 100.00% 1 100.00%
Total 39 100.00% 1 100.00%


EXPORT_SYMBOL_GPL(xen_set_callback_via);

#ifdef CONFIG_XEN_PVHVM
/* Vector callbacks are better than PCI interrupts to receive event
 * channel notifications because we can receive vector callbacks on any
 * vcpu and we don't need PCI support or APIC interactions. */


void xen_callback_vector(void)
{
	int rc;
	uint64_t callback_via;
	if (xen_have_vector_callback) {
		callback_via = HVM_CALLBACK_VECTOR(HYPERVISOR_CALLBACK_VECTOR);
		rc = xen_set_callback_via(callback_via);
		if (rc) {
			pr_err("Request for Xen HVM callback vector failed\n");
			xen_have_vector_callback = 0;
			return;
		}
		pr_info("Xen HVM callback vector for event delivery is enabled\n");
		/* in the restore case the vector has already been allocated */
		if (!test_bit(HYPERVISOR_CALLBACK_VECTOR, used_vectors))
			alloc_intr_gate(HYPERVISOR_CALLBACK_VECTOR,
					xen_hvm_callback_vector);
	}
}
Contributors
Person Tokens Prop Commits CommitProp
sheng yang sheng yang 65 90.28% 1 33.33%
joe perches joe perches 4 5.56% 1 33.33%
ky srinivasan ky srinivasan 3 4.17% 1 33.33%
Total 72 100.00% 3 100.00%

#else


void xen_callback_vector(void) {}
Contributors
Person Tokens Prop Commits CommitProp
stefano stabellini stefano stabellini 6 100.00% 1 100.00%
Total 6 100.00% 1 100.00%

#endif


#undef MODULE_PARAM_PREFIX

#define MODULE_PARAM_PREFIX "xen."


static bool fifo_events = true;
module_param(fifo_events, bool, 0);



void __init xen_init_IRQ(void)
{
	int ret = -EINVAL;

	if (fifo_events)
		ret = xen_evtchn_fifo_init();
	if (ret < 0)
		xen_evtchn_2l_init();

	evtchn_to_irq = kcalloc(EVTCHN_ROW(xen_evtchn_max_channels()),
				sizeof(*evtchn_to_irq), GFP_KERNEL);
	BUG_ON(!evtchn_to_irq);

	/* No event channels are 'live' right now. */
	xen_evtchn_mask_all();

	pirq_needs_eoi = pirq_needs_eoi_flag;

#ifdef CONFIG_X86
	if (xen_pv_domain()) {
		irq_ctx_init(smp_processor_id());
		if (xen_initial_domain())
			pci_xen_initial_domain();
	}
	if (xen_feature(XENFEAT_hvm_callback_vector))
		xen_callback_vector();

	if (xen_hvm_domain()) {
		native_init_IRQ();
		/* pci_xen_hvm_init must be called after native_init_IRQ so that
                 * __acpi_register_gsi can point at the right function */
		pci_xen_hvm_init();
	} else {
		int rc;
		struct physdev_pirq_eoi_gmfn eoi_gmfn;

		pirq_eoi_map = (void *)__get_free_page(GFP_KERNEL|__GFP_ZERO);
		eoi_gmfn.gmfn = virt_to_gfn(pirq_eoi_map);
		rc = HYPERVISOR_physdev_op(PHYSDEVOP_pirq_eoi_gmfn_v2, &eoi_gmfn);
		/* TODO: No PVH support for PIRQ EOI */
		if (rc != 0) {
			free_page((unsigned long) pirq_eoi_map);
			pirq_eoi_map = NULL;
		} else
			pirq_needs_eoi = pirq_check_eoi_map;
	}
#endif
}
Contributors
Person Tokens Prop Commits CommitProp
stefano stabellini stefano stabellini 78 42.39% 4 26.67%
david vrabel david vrabel 31 16.85% 4 26.67%
mukesh rathor mukesh rathor 30 16.30% 1 6.67%
jeremy fitzhardinge jeremy fitzhardinge 22 11.96% 2 13.33%
sheng yang sheng yang 15 8.15% 1 6.67%
konrad rzeszutek wilk konrad rzeszutek wilk 6 3.26% 1 6.67%
mike travis mike travis 1 0.54% 1 6.67%
julien grall julien grall 1 0.54% 1 6.67%
Total 184 100.00% 15 100.00%

Overall Contributors
Person Tokens Prop Commits CommitProp
jeremy fitzhardinge jeremy fitzhardinge 2177 32.88% 20 13.99%
david vrabel david vrabel 1996 30.14% 14 9.79%
ian campbell ian campbell 625 9.44% 21 14.69%
stefano stabellini stefano stabellini 493 7.44% 14 9.79%
konrad rzeszutek wilk konrad rzeszutek wilk 347 5.24% 15 10.49%
sheng yang sheng yang 177 2.67% 1 0.70%
olaf hering olaf hering 155 2.34% 1 0.70%
boris ostrovsky boris ostrovsky 108 1.63% 4 2.80%
roger pau monne roger pau monne 102 1.54% 1 0.70%
thomas gleixner thomas gleixner 86 1.30% 9 6.29%
juergen gross juergen gross 41 0.62% 2 1.40%
alex nixon alex nixon 34 0.51% 1 0.70%
daniel de graaf daniel de graaf 32 0.48% 1 0.70%
keir fraser keir fraser 32 0.48% 3 2.10%
mukesh rathor mukesh rathor 30 0.45% 1 0.70%
scott rixner scott rixner 22 0.33% 1 0.70%
joe jin joe jin 19 0.29% 1 0.70%
ross lagerwall ross lagerwall 18 0.27% 1 0.70%
wei liu wei liu 18 0.27% 2 1.40%
julien grall julien grall 16 0.24% 5 3.50%
joe perches joe perches 15 0.23% 1 0.70%
yinghai lu yinghai lu 13 0.20% 2 1.40%
isaku yamahata isaku yamahata 9 0.14% 3 2.10%
tejun heo tejun heo 9 0.14% 3 2.10%
mike travis mike travis 8 0.12% 2 1.40%
qing he qing he 5 0.08% 1 0.70%
rusty russell rusty russell 5 0.08% 1 0.70%
eric w. biederman eric w. biederman 4 0.06% 1 0.70%
christoph lameter christoph lameter 4 0.06% 1 0.70%
mojiong qiu mojiong qiu 3 0.05% 1 0.70%
ky srinivasan ky srinivasan 3 0.05% 1 0.70%
adrian bunk adrian bunk 3 0.05% 1 0.70%
christophe saout christophe saout 3 0.05% 1 0.70%
nicolas kaiser nicolas kaiser 2 0.03% 1 0.70%
jiang liu jiang liu 2 0.03% 1 0.70%
arnd bergmann arnd bergmann 2 0.03% 1 0.70%
jeff garzik jeff garzik 2 0.03% 1 0.70%
paul gortmaker paul gortmaker 1 0.02% 1 0.70%
lucas de marchi lucas de marchi 1 0.02% 1 0.70%
Total 6622 100.00% 143 100.00%
  Directory: drivers/xen/events

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
david vrabel	david vrabel	36	100.00%	1	100.00%
	Total	36	100.00%	1	100.00%
cregit-Linux how code gets into the kernel

Release 4.7 drivers/xen/events/events_base.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors
