Date: Sat, 7 Jan 2006 01:56:36 GMT From: Kip Macy <kmacy@FreeBSD.org> To: Perforce Change Reviews <perforce@freebsd.org> Subject: PERFORCE change 89314 for review Message-ID: <200601070156.k071uahr070222@repoman.freebsd.org>
next in thread | raw e-mail | index | archive | help
http://perforce.freebsd.org/chv.cgi?CH=89314 Change 89314 by kmacy@kmacy:freebsd7_xen3 on 2006/01/07 01:56:08 update to event channel management to handle physical irqs this another small piece for dom0 support Affected files ... .. //depot/projects/xen3/src/sys/i386-xen/i386-xen/evtchn.c#2 edit Differences ... ==== //depot/projects/xen3/src/sys/i386-xen/i386-xen/evtchn.c#2 (text+ko) ==== @@ -3,7 +3,8 @@ * * Communication via Xen event channels. * - * Copyright (c) 2002-2004, K A Fraser + * Copyright (c) 2002-2005, K A Fraser + * Copyright (c) 2005-2006 Kip Macy */ #include <sys/param.h> #include <sys/systm.h> @@ -24,6 +25,47 @@ +/* linux helper functions that got sucked in + * rename and move XXX + */ + + +#define BITS_PER_LONG 32 +#define NR_CPUS MAX_VIRT_CPUS + +#define BITS_TO_LONGS(bits) \ + (((bits)+BITS_PER_LONG-1)/BITS_PER_LONG) +#define DECLARE_BITMAP(name,bits) \ + unsigned long name[BITS_TO_LONGS(bits)] +typedef struct { DECLARE_BITMAP(bits, NR_CPUS); } xen_cpumask_t; +static inline int find_first_bit(const unsigned long *addr, unsigned size) +{ + int d0, d1; + int res; + + /* This looks at memory. Mark it volatile to tell gcc not to move it around */ + __asm__ __volatile__( + "xorl %%eax,%%eax\n\t" + "repe; scasl\n\t" + "jz 1f\n\t" + "leal -4(%%edi),%%edi\n\t" + "bsfl (%%edi),%%eax\n" + "1:\tsubl %%ebx,%%edi\n\t" + "shll $3,%%edi\n\t" + "addl %%edi,%%eax" + :"=a" (res), "=&c" (d0), "=&D" (d1) + :"1" ((size + 31) >> 5), "2" (addr), "b" (addr) : "memory"); + return res; +} + +#define min_t(type,x,y) \ + ({ type __x = (x); type __y = (y); __x < __y ? __x: __y; }) +#define first_cpu(src) __first_cpu(&(src), NR_CPUS) +static inline int __first_cpu(const xen_cpumask_t *srcp, int nbits) +{ + return min_t(int, nbits, find_first_bit(srcp->bits, nbits)); +} + static inline unsigned long __ffs(unsigned long word) { __asm__("bsfl %1,%0" @@ -33,7 +75,24 @@ } static struct mtx irq_mapping_update_lock; +static struct xenpic *xp; +struct xenpic_intsrc { + struct intsrc xp_intsrc; + uint8_t xp_vector; + boolean_t xp_masked; +}; + +struct xenpic { + struct pic *xp_dynirq_pic; + struct pic *xp_pirq_pic; + uint16_t xp_numintr; + struct xenpic_intsrc xp_pins[0]; +}; + + + + #define TODO printf("%s: not implemented!\n", __func__) /* IRQ <-> event-channel mappings. */ @@ -62,12 +121,13 @@ #endif DEFINE_PER_CPU(int, ipi_to_irq[NR_IPIS]); +/* Bitmap indicating which PIRQs require Xen to be notified on unmask. */ +static unsigned long pirq_needs_unmask_notify[NR_PIRQS/sizeof(unsigned long)]; + /* Reference counts for bindings to IRQs. */ static int irq_bindcount[NR_IRQS]; #define VALID_EVTCHN(_chn) ((_chn) != 0) -#define BITS_PER_LONG 32 -#define NR_CPUS MAX_VIRT_CPUS #ifdef CONFIG_SMP @@ -179,7 +239,7 @@ { int irq; - mtx_lock(&irq_mapping_update_lock); + mtx_lock_spin(&irq_mapping_update_lock); if ((irq = evtchn_to_irq[evtchn]) == -1) { irq = find_unbound_irq(); @@ -188,9 +248,10 @@ } irq_bindcount[irq]++; + intr_register_source(&xp->xp_pins[irq].xp_intsrc); + + mtx_unlock_spin(&irq_mapping_update_lock); - mtx_unlock(&irq_mapping_update_lock); - return irq; } @@ -200,7 +261,7 @@ evtchn_op_t op; int evtchn, irq; - mtx_lock(&irq_mapping_update_lock); + mtx_lock_spin(&irq_mapping_update_lock); if ((irq = per_cpu(virq_to_irq, cpu)[virq]) == -1) { op.cmd = EVTCHNOP_bind_virq; @@ -221,7 +282,7 @@ irq_bindcount[irq]++; - mtx_unlock(&irq_mapping_update_lock); + mtx_unlock_spin(&irq_mapping_update_lock); return irq; } @@ -232,7 +293,7 @@ evtchn_op_t op; int evtchn, irq; - mtx_lock(&irq_mapping_update_lock); + mtx_lock_spin(&irq_mapping_update_lock); if ((irq = per_cpu(ipi_to_irq, cpu)[ipi]) == -1) { op.u.bind_ipi.vcpu = cpu; @@ -251,7 +312,7 @@ irq_bindcount[irq]++; - mtx_unlock(&irq_mapping_update_lock); + mtx_unlock_spin(&irq_mapping_update_lock); return irq; } @@ -263,7 +324,7 @@ evtchn_op_t op = { .cmd = EVTCHNOP_close }; int evtchn = evtchn_from_irq(irq); - mtx_lock(&irq_mapping_update_lock); + mtx_lock_spin(&irq_mapping_update_lock); if ((--irq_bindcount[irq] == 0) && VALID_EVTCHN(evtchn)) { op.u.close.port = evtchn; @@ -287,12 +348,9 @@ irq_info[irq] = IRQ_UNBOUND; } - mtx_unlock(&irq_mapping_update_lock); + mtx_unlock_spin(&irq_mapping_update_lock); } - - - int bind_evtchn_to_irqhandler(unsigned int evtchn, const char *devname, @@ -304,6 +362,7 @@ int retval; irq = bind_evtchn_to_irq(evtchn); + intr_register_source(&xp->xp_pins[irq].xp_intsrc); retval = intr_add_handler(devname, irq, handler, arg, irqflags, NULL); if (retval != 0) { unbind_from_irq(irq); @@ -324,6 +383,7 @@ int retval; irq = bind_virq_to_irq(virq, cpu); + intr_register_source(&xp->xp_pins[irq].xp_intsrc); retval = intr_add_handler(devname, irq, handler, NULL, irqflags, NULL); if (retval != 0) { unbind_from_irq(irq); @@ -353,9 +413,6 @@ return irq; } - - - void unbind_from_irqhandler(unsigned int irq, void *dev_id) { #ifdef notyet @@ -371,11 +428,11 @@ evtchn_op_t op = { .cmd = EVTCHNOP_bind_vcpu }; int evtchn; - mtx_lock(&irq_mapping_update_lock); + mtx_lock_spin(&irq_mapping_update_lock); evtchn = evtchn_from_irq(irq); if (!VALID_EVTCHN(evtchn)) { - mtx_unlock(&irq_mapping_update_lock); + mtx_unlock_spin(&irq_mapping_update_lock); return; } @@ -391,30 +448,17 @@ if (HYPERVISOR_event_channel_op(&op) >= 0) bind_evtchn_to_cpu(evtchn, tcpu); - mtx_unlock(&irq_mapping_update_lock); + mtx_unlock_spin(&irq_mapping_update_lock); - /* - * Now send the new target processor a NOP IPI. When this returns, it - * will check for any pending interrupts, and so service any that got - * delivered to the wrong processor by mistake. - * - * XXX: The only time this is called with interrupts disabled is from - * the hotplug/hotunplug path. In that case, all cpus are stopped with - * interrupts disabled, and the missed interrupts will be picked up - * when they start again. This is kind of a hack. - */ -#if 0 - if (!irqs_disabled()) - smp_call_function(do_nothing_function, NULL, 0, 0); -#endif } -static void set_affinity_irq(unsigned irq, cpumask_t dest) +static void set_affinity_irq(unsigned irq, xen_cpumask_t dest) { unsigned tcpu = first_cpu(dest); rebind_irq_to_cpu(irq, tcpu); } #endif + /* * Interface to generic handling in intr_machdep.c */ @@ -423,114 +467,129 @@ /*------------ interrupt handling --------------------------------------*/ #define TODO printf("%s: not implemented!\n", __func__) - struct mtx xenpic_lock; + +static void xenpic_dynirq_enable_source(struct intsrc *isrc); +static void xenpic_dynirq_disable_source(struct intsrc *isrc, int); +static void xenpic_dynirq_eoi_source(struct intsrc *isrc); +static void xenpic_dynirq_enable_intr(struct intsrc *isrc); -struct xenpic_intsrc { - struct intsrc xp_intsrc; - uint8_t xp_vector; - boolean_t xp_masked; -}; +static void xenpic_pirq_enable_source(struct intsrc *isrc); +static void xenpic_pirq_disable_source(struct intsrc *isrc, int); +static void xenpic_pirq_eoi_source(struct intsrc *isrc); +static void xenpic_pirq_enable_intr(struct intsrc *isrc); -struct xenpic { - struct pic xp_pic; /* this MUST be first */ - uint16_t xp_numintr; - struct xenpic_intsrc xp_pins[0]; -}; -static void xenpic_enable_dynirq_source(struct intsrc *isrc); -static void xenpic_disable_dynirq_source(struct intsrc *isrc, int); -static void xenpic_eoi_source(struct intsrc *isrc); -static void xenpic_enable_dynirq_intr(struct intsrc *isrc); static int xenpic_vector(struct intsrc *isrc); static int xenpic_source_pending(struct intsrc *isrc); static void xenpic_suspend(struct intsrc *isrc); static void xenpic_resume(struct intsrc *isrc); -struct pic xenpic_template = { - xenpic_enable_dynirq_source, - xenpic_disable_dynirq_source, - xenpic_eoi_source, - xenpic_enable_dynirq_intr, - xenpic_vector, - xenpic_source_pending, - xenpic_suspend, - xenpic_resume +struct pic xenpic_dynirq_template = { + xenpic_dynirq_enable_source, + xenpic_dynirq_disable_source, + xenpic_dynirq_eoi_source, + xenpic_dynirq_enable_intr, + xenpic_vector, + xenpic_source_pending, + xenpic_suspend, + xenpic_resume +}; + +struct pic xenpic_pirq_template = { + xenpic_pirq_enable_source, + xenpic_pirq_disable_source, + xenpic_pirq_eoi_source, + xenpic_pirq_enable_intr, + xenpic_vector, + xenpic_source_pending, + xenpic_suspend, + xenpic_resume }; void -xenpic_enable_dynirq_source(struct intsrc *isrc) +xenpic_dynirq_enable_source(struct intsrc *isrc) { unsigned int irq; struct xenpic_intsrc *xp; xp = (struct xenpic_intsrc *)isrc; - + + mtx_lock_spin(&irq_mapping_update_lock); if (xp->xp_masked) { irq = xenpic_vector(isrc); unmask_evtchn(evtchn_from_irq(irq)); xp->xp_masked = FALSE; } + mtx_unlock_spin(&irq_mapping_update_lock); } static void -xenpic_disable_dynirq_source(struct intsrc *isrc, int foo) +xenpic_dynirq_disable_source(struct intsrc *isrc, int foo) { unsigned int irq; struct xenpic_intsrc *xp; xp = (struct xenpic_intsrc *)isrc; + mtx_lock_spin(&irq_mapping_update_lock); if (!xp->xp_masked) { irq = xenpic_vector(isrc); mask_evtchn(evtchn_from_irq(irq)); - clear_evtchn(evtchn_from_irq(irq)); xp->xp_masked = TRUE; - } - + } + mtx_unlock_spin(&irq_mapping_update_lock); } static void -xenpic_enable_dynirq_intr(struct intsrc *isrc) +xenpic_dynirq_enable_intr(struct intsrc *isrc) { unsigned int irq; - + mtx_lock_spin(&irq_mapping_update_lock); irq = xenpic_vector(isrc); unmask_evtchn(evtchn_from_irq(irq)); + mtx_unlock_spin(&irq_mapping_update_lock); } static void -xenpic_eoi_source(struct intsrc *isrc) +xenpic_dynirq_eoi_source(struct intsrc *isrc) { - unsigned int irq = xenpic_vector(isrc); + unsigned int irq; + + mtx_lock_spin(&irq_mapping_update_lock); + irq = xenpic_vector(isrc); unmask_evtchn(evtchn_from_irq(irq)); + mtx_unlock_spin(&irq_mapping_update_lock); } static int xenpic_vector(struct intsrc *isrc) { - struct xenpic_intsrc *pin = (struct xenpic_intsrc *)isrc; + struct xenpic_intsrc *pin; + + pin = (struct xenpic_intsrc *)isrc; + return (pin->xp_vector); } static int xenpic_source_pending(struct intsrc *isrc) { - TODO; - return 0; + TODO; + return 0; } static void xenpic_suspend(struct intsrc *isrc) { - TODO; + TODO; } static void xenpic_resume(struct intsrc *isrc) { - TODO; + TODO; } @@ -541,143 +600,160 @@ if (VALID_EVTCHN(evtchn)) notify_remote_via_evtchn(evtchn); } -#ifdef CONFIG_PHYSDEV + /* required for support of physical devices */ static inline void pirq_unmask_notify(int pirq) { - physdev_op_t op; - if ( unlikely(test_bit(pirq, &pirq_needs_unmask_notify[0])) ) - { - op.cmd = PHYSDEVOP_IRQ_UNMASK_NOTIFY; - (void)HYPERVISOR_physdev_op(&op); - } + physdev_op_t op; + if (unlikely(test_bit(pirq, &pirq_needs_unmask_notify[0]))) { + op.cmd = PHYSDEVOP_IRQ_UNMASK_NOTIFY; + (void)HYPERVISOR_physdev_op(&op); + } } static inline void pirq_query_unmask(int pirq) { - physdev_op_t op; - op.cmd = PHYSDEVOP_IRQ_STATUS_QUERY; - op.u.irq_status_query.irq = pirq; - (void)HYPERVISOR_physdev_op(&op); - clear_bit(pirq, &pirq_needs_unmask_notify[0]); - if ( op.u.irq_status_query.flags & PHYSDEVOP_IRQ_NEEDS_UNMASK_NOTIFY ) - set_bit(pirq, &pirq_needs_unmask_notify[0]); + physdev_op_t op; + op.cmd = PHYSDEVOP_IRQ_STATUS_QUERY; + op.u.irq_status_query.irq = pirq; + (void)HYPERVISOR_physdev_op(&op); + clear_bit(pirq, &pirq_needs_unmask_notify[0]); + if ( op.u.irq_status_query.flags & PHYSDEVOP_IRQ_NEEDS_UNMASK_NOTIFY ) + set_bit(pirq, &pirq_needs_unmask_notify[0]); } /* * On startup, if there is no action associated with the IRQ then we are * probing. In this case we should not share with others as it will confuse us. */ -#define probing_irq(_irq) (irq_desc[(_irq)].action == NULL) +#define probing_irq(_irq) (intr_lookup_source(irq) == NULL) -static unsigned int startup_pirq(unsigned int irq) +static void +xenpic_pirq_enable_intr(struct intsrc *isrc) { - evtchn_op_t op; - int evtchn; + evtchn_op_t op; + int evtchn; + unsigned int irq; + + mtx_lock_spin(&irq_mapping_update_lock); + irq = xenpic_vector(isrc); + evtchn = evtchn_from_irq(irq); - op.cmd = EVTCHNOP_bind_pirq; - op.u.bind_pirq.pirq = irq; - /* NB. We are happy to share unless we are probing. */ - op.u.bind_pirq.flags = probing_irq(irq) ? 0 : BIND_PIRQ__WILL_SHARE; - if ( HYPERVISOR_event_channel_op(&op) != 0 ) - { - if ( !probing_irq(irq) ) /* Some failures are expected when probing. */ - printk(KERN_INFO "Failed to obtain physical IRQ %d\n", irq); - return 0; - } - evtchn = op.u.bind_pirq.port; + if (VALID_EVTCHN(evtchn)) + goto out; - pirq_query_unmask(irq_to_pirq(irq)); + op.cmd = EVTCHNOP_bind_pirq; + op.u.bind_pirq.pirq = irq; + /* NB. We are happy to share unless we are probing. */ + op.u.bind_pirq.flags = probing_irq(irq) ? 0 : BIND_PIRQ__WILL_SHARE; + + if (HYPERVISOR_event_channel_op(&op) != 0) { + if (!probing_irq(irq)) /* Some failures are expected when probing. */ + printf("Failed to obtain physical IRQ %d\n", irq); + mtx_unlock_spin(&irq_mapping_update_lock); + return; + } + evtchn = op.u.bind_pirq.port; - evtchn_to_irq[evtchn] = irq; - evtchn_from_irq(irq) = evtchn; + pirq_query_unmask(irq_to_pirq(irq)); - unmask_evtchn(evtchn); - pirq_unmask_notify(irq_to_pirq(irq)); + bind_evtchn_to_cpu(evtchn, 0); + evtchn_to_irq[evtchn] = irq; + irq_info[irq] = mk_irq_info(IRQT_PIRQ, irq, evtchn); - return 0; + out: + unmask_evtchn(evtchn); + pirq_unmask_notify(irq_to_pirq(irq)); + mtx_unlock_spin(&irq_mapping_update_lock); } -static void shutdown_pirq(unsigned int irq) +#if 0 +static void +xenpic_pirq_disable_intr(struct intsrc *isrc) { - evtchn_op_t op; - int evtchn = evtchn_from_irq(irq); + evtchn_op_t op; + unsigned int irq; + int evtchn; + + mtx_lock_spin(&irq_mapping_update_lock); + irq = xenpic_vector(isrc); + evtchn = evtchn_from_irq(irq); - if ( !VALID_EVTCHN(evtchn) ) - return; + if (!VALID_EVTCHN(evtchn)) + goto done; + + mask_evtchn(evtchn); - mask_evtchn(evtchn); + op.cmd = EVTCHNOP_close; + op.u.close.port = evtchn; + PANIC_IF(HYPERVISOR_event_channel_op(&op) != 0); - op.cmd = EVTCHNOP_close; - op.u.close.dom = DOMID_SELF; - op.u.close.port = evtchn; - if ( HYPERVISOR_event_channel_op(&op) != 0 ) - panic("Failed to unbind physical IRQ %d\n", irq); - - evtchn_to_irq[evtchn] = -1; - evtchn_from_irq(irq) = -1; + bind_evtchn_to_cpu(evtchn, 0); + evtchn_to_irq[evtchn] = -1; + irq_info[irq] = IRQ_UNBOUND; + done: + mtx_unlock_spin(&irq_mapping_update_lock); } +#endif -static void enable_pirq(unsigned int irq) +static void +xenpic_pirq_enable_source(struct intsrc *isrc) { - int evtchn = evtchn_from_irq(irq); - if ( !VALID_EVTCHN(evtchn) ) - return; - unmask_evtchn(evtchn); - pirq_unmask_notify(irq_to_pirq(irq)); + int evtchn; + unsigned int irq; + + mtx_lock_spin(&irq_mapping_update_lock); + irq = xenpic_vector(isrc); + evtchn = evtchn_from_irq(irq); + + if (!VALID_EVTCHN(evtchn)) + goto done; + + unmask_evtchn(evtchn); + pirq_unmask_notify(irq_to_pirq(irq)); + done: + mtx_unlock_spin(&irq_mapping_update_lock); } -static void disable_pirq(unsigned int irq) +static void +xenpic_pirq_disable_source(struct intsrc *isrc, int eoi) { - int evtchn = evtchn_from_irq(irq); - if ( !VALID_EVTCHN(evtchn) ) - return; - mask_evtchn(evtchn); -} + int evtchn; + unsigned int irq; + + mtx_lock_spin(&irq_mapping_update_lock); + irq = xenpic_vector(isrc); + evtchn = evtchn_from_irq(irq); -static void ack_pirq(unsigned int irq) -{ - int evtchn = evtchn_from_irq(irq); - if ( !VALID_EVTCHN(evtchn) ) - return; - mask_evtchn(evtchn); - clear_evtchn(evtchn); -} + if (!VALID_EVTCHN(evtchn)) + goto done; -static void end_pirq(unsigned int irq) -{ - int evtchn = evtchn_from_irq(irq); - if ( !VALID_EVTCHN(evtchn) ) - return; - if ( !(irq_desc[irq].status & IRQ_DISABLED) ) - { - unmask_evtchn(evtchn); - pirq_unmask_notify(irq_to_pirq(irq)); - } + mask_evtchn(evtchn); + done: + mtx_unlock_spin(&irq_mapping_update_lock); } -static struct hw_interrupt_type pirq_type = { - "Phys-irq", - startup_pirq, - shutdown_pirq, - enable_pirq, - disable_pirq, - ack_pirq, - end_pirq, - NULL -}; -#endif -#if 0 static void -misdirect_interrupt(void *sc) +xenpic_pirq_eoi_source(struct intsrc *isrc) { -} + int evtchn; + unsigned int irq; + + mtx_lock_spin(&irq_mapping_update_lock); + irq = xenpic_vector(isrc); + evtchn = evtchn_from_irq(irq); + if (!VALID_EVTCHN(evtchn)) + goto done; -#endif + unmask_evtchn(evtchn); + pirq_unmask_notify(irq_to_pirq(irq)); + done: + mtx_unlock_spin(&irq_mapping_update_lock); +} void mask_evtchn(int port) @@ -717,8 +793,6 @@ } } - - void irq_resume(void) { evtchn_op_t op; @@ -798,8 +872,7 @@ evtchn_init(void *dummy __unused) { int i, cpu; - struct xenpic *xp; - struct xenpic_intsrc *pin; + struct xenpic_intsrc *pin, *tpin; /* No VIRQ or IPI bindings. */ for (cpu = 0; cpu < NR_CPUS; cpu++) { @@ -819,27 +892,27 @@ for (i = 0; i < NR_IRQS; i++) irq_info[i] = IRQ_UNBOUND; - xp = malloc(sizeof(struct xenpic) + NR_DYNIRQS*sizeof(struct xenpic_intsrc), M_DEVBUF, M_WAITOK); - xp->xp_pic = xenpic_template; - xp->xp_numintr = NR_DYNIRQS; - bzero(xp->xp_pins, sizeof(struct xenpic_intsrc) * NR_DYNIRQS); + xp = malloc(sizeof(struct xenpic) + NR_IRQS*sizeof(struct xenpic_intsrc), + M_DEVBUF, M_WAITOK); + + xp->xp_dynirq_pic = &xenpic_dynirq_template; + xp->xp_pirq_pic = &xenpic_pirq_template; + xp->xp_numintr = NR_IRQS; + bzero(xp->xp_pins, sizeof(struct xenpic_intsrc) * NR_IRQS); - for (i = 0, pin = xp->xp_pins; i < NR_DYNIRQS; i++, pin++) { + for (i = 0,pin = xp->xp_pins; i < NR_DYNIRQS; i++) { /* Dynamic IRQ space is currently unbound. Zero the refcnts. */ irq_bindcount[dynirq_to_irq(i)] = 0; - - pin->xp_intsrc.is_pic = (struct pic *)xp; - pin->xp_vector = i; - intr_register_source(&pin->xp_intsrc); + + tpin = &pin[dynirq_to_irq(i)]; + tpin->xp_intsrc.is_pic = xp->xp_dynirq_pic; + tpin->xp_vector = dynirq_to_irq(i); } - /* We don't currently have any support for physical devices in XenoFreeBSD - * so leaving this out for the moment for the sake of expediency. - */ -#ifdef notyet - /* Phys IRQ space is statically bound (1:1 mapping). Nail refcnts. */ - for (i = 0; i < NR_PIRQS; i++) - { - irq_bindcount[pirq_to_irq(i)] = 1; + + + for (i = 0, pin = xp->xp_pins; i < NR_PIRQS; i++) { + /* Dynamic IRQ space is currently unbound. Zero the refcnts. */ + irq_bindcount[pirq_to_irq(i)] = 0; #ifdef RTC_IRQ /* If not domain 0, force our RTC driver to fail its probe. */ @@ -847,21 +920,18 @@ !(xen_start_info->flags & SIF_INITDOMAIN)) continue; #endif - - irq_desc[pirq_to_irq(i)].status = IRQ_DISABLED; - irq_desc[pirq_to_irq(i)].action = NULL; - irq_desc[pirq_to_irq(i)].depth = 1; - irq_desc[pirq_to_irq(i)].handler = &pirq_type; + tpin = &pin[pirq_to_irq(i)]; + tpin->xp_intsrc.is_pic = xp->xp_pirq_pic; + tpin->xp_vector = pirq_to_irq(i); } -#endif } SYSINIT(evtchn_init, SI_SUB_INTR, SI_ORDER_ANY, evtchn_init, NULL); /* - * xenpic_lock: in order to allow an interrupt to occur in a critical + * irq_mapping_update_lock: in order to allow an interrupt to occur in a critical * section, to set pcpu->ipending (etc...) properly, we * must be able to get the icu lock, so it can't be * under witness. */ -MTX_SYSINIT(irq_mapping_update_lock, &irq_mapping_update_lock, "xp", MTX_DEF|MTX_NOWITNESS); +MTX_SYSINIT(irq_mapping_update_lock, &irq_mapping_update_lock, "xp", MTX_SPIN);
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?200601070156.k071uahr070222>