PLACEHOLDER FOR ALT

THIS SHOULD NOT BE BROUGHT INTO FREEBSD.  This is simply a placeholder
to keep the previous commit in a handy state.  Mostly a demonstration of
a more minimal approach which doesn't emulate the existing quite as
closely.

Author: ehem

sys/x86/include/interrupt.h

@@ -43,6 +43,8 @@ typedef struct intsrc interrupt_t;
 
 DECLARE_CLASS(pic_base_class);
 
+typedef struct { device_t next, prev; } pic_base_softc_t;
+
 /*
  * Values used in determining the allocation of IRQ values among
  * different types of I/O interrupts.  These values are used as

sys/x86/isa/atpic.c

@@ -107,12 +107,15 @@ inthand_t
 	}
 
 struct atpic {
+	pic_base_softc_t	pic_base_softc;
 	device_t	at_pic;
 	int	at_ioaddr;
 	int	at_irqbase;
 	uint8_t	at_intbase;
 	uint8_t	at_imen;
 };
+_Static_assert(offsetof(struct atpic, pic_base_softc) == 0,
+    ".pic_base_softc misaligned from structure!");
 
 struct atpic_intsrc {
 	struct intsrc at_intsrc;
@@ -125,9 +128,10 @@ struct atpic_intsrc {
 
 static pic_register_sources_t		atpic_register_sources;
 static intr_event_post_ithread_t	atpic_enable_source;
-static intr_event_pre_ithread_t		atpic_disable_intr;
+static intr_event_pre_ithread_t		atpic_disable_source;
 static intr_event_post_filter_t		atpic_eoi;
 static pic_enable_intr_t		atpic_enable_intr;
+static pic_disable_intr_t		atpic_disable_intr;
 static pic_resume_t			atpic_resume;
 static pic_source_pending_t		atpic_source_pending;
 static pic_config_intr_t		atpic_config_intr;
@@ -149,7 +153,7 @@ static const device_method_t atpic_methods[] = {
 	/* Interrupt event interface */
 	DEVMETHOD(intr_event_post_filter,	atpic_eoi),
 	DEVMETHOD(intr_event_post_ithread,	atpic_enable_source),
-	DEVMETHOD(intr_event_pre_ithread,	atpic_disable_intr),
+	DEVMETHOD(intr_event_pre_ithread,	atpic_disable_source),
 
 	/* Interrupt controller interface */
 	DEVMETHOD(pic_register_sources,		atpic_register_sources),
@@ -273,7 +277,7 @@ atpic_enable_source(device_t pic, struct intsrc *isrc)
 }
 
 static void
-atpic_disable_intr(device_t pic, struct intsrc *isrc)
+atpic_disable_intr(device_t pic, struct intsrc *isrc, enum eoi_flag eoi)
 {
 	struct atpic_intsrc *ai = (struct atpic_intsrc *)isrc;
 	struct atpic *ap = device_get_softc(isrc->is_event.ie_pic);
@@ -289,18 +293,27 @@ atpic_disable_intr(device_t pic, struct intsrc *isrc)
 	 * a function pointer.  All of the referenced variables should
 	 * still be hot in the cache.
 	 */
-	if (isrc->is_event.ie_pic == atpics[MASTER].at_pic)
-		_atpic_eoi_master(isrc);
-	else
-		_atpic_eoi_slave(isrc);
+	if (eoi == PIC_EOI) {
+		if (isrc->is_event.ie_pic == atpics[MASTER].at_pic)
+			_atpic_eoi_master(isrc);
+		else
+			_atpic_eoi_slave(isrc);
+	}
 
 	spinlock_exit();
 }
 
+static void
+atpic_disable_source(device_t pic, struct intsrc *isrc)
+{
+
+	atpic_disable_intr(pic, isrc, PIC_EOI);
+}
+
 static void
 atpic_eoi(device_t pic, struct intsrc *isrc)
 {
-	/* Reference the above comment (atpic_disable_intr()) */
+	/* Reference the above comment (atpic_disable_source()) */
 	if (isrc->is_event.ie_pic == atpics[MASTER].at_pic) {
 #ifndef AUTO_EOI_1
 		spinlock_enter();

sys/x86/isa/clock.c

@@ -88,10 +88,11 @@ int	i8254_max_count;
 static int i8254_timecounter = 1;
 
 static	struct mtx clock_lock;
+static	struct intsrc *i8254_intsrc;
 static	uint16_t i8254_lastcount;
 static	uint16_t i8254_offset;
+static	pic_source_pending_t	*i8254_pending;
 static	int	i8254_ticked;
-static	struct intsrc *i8254_intsrc;
 
 struct attimer_softc {
 	int intr_en;
@@ -492,8 +493,8 @@ i8254_get_timecount(struct timecounter *tc)
 	    (!i8254_ticked && (clkintr_pending ||
 	    ((count < 20 || (!(flags & PSL_I) &&
 	    count < i8254_max_count / 2u)) &&
-	    i8254_intsrc != NULL &&
-	    PIC_SOURCE_PENDING(i8254_intsrc->is_event.ie_pic, i8254_intsrc))))) {
+	    i8254_pending != NULL &&
+	    i8254_pending(i8254_intsrc->is_event.ie_pic, i8254_intsrc))))) {
 		i8254_ticked = 1;
 		i8254_offset += i8254_max_count;
 	}
@@ -572,6 +573,8 @@ attimer_attach(device_t dev)
 	    &sc->port_rid, IO_TIMER1, IO_TIMER1 + 3, 4, RF_ACTIVE)))
 		device_printf(dev,"Warning: Couldn't map I/O.\n");
 	i8254_intsrc = intr_lookup_source(0);
+	if (i8254_intsrc != NULL)
+		i8254_pending = KOBJOPLOOKUP((kobj_t)(i8254_intsrc->is_event.ie_pic), pic_source_pending);
 	resource_int_value(device_get_name(dev), device_get_unit(dev),
 	    "timecounter", &i8254_timecounter);
 	set_i8254_freq(MODE_STOP, 0);

sys/x86/x86/intr_machdep.c

@@ -88,11 +88,7 @@ static struct timeout_task intrbalance_task;
 static struct sx intrsrc_lock;
 static struct mtx intrpic_lock;
 static struct mtx intrcnt_lock;
-struct pic_entr {
-	TAILQ_ENTRY(pic_entr) pics;
-	x86pic_t pic;
-};
-static TAILQ_HEAD(pics_head, pic_entr) pics = TAILQ_HEAD_INITIALIZER(pics);
+static pic_base_softc_t pics = { NULL, NULL };
 u_int num_io_irqs;
 
 #if defined(SMP) && !defined(EARLY_AP_STARTUP)
@@ -123,7 +119,7 @@ static void	intrcnt_register(struct intsrc *is);
 /*
  * SYSINIT levels for SI_SUB_INTR:
  *
- * SI_ORDER_FIRST: Initialize locks and pics TAILQ, xen_hvm_cpu_init
+ * SI_ORDER_FIRST: Initialize locks and pics list, xen_hvm_cpu_init
  * SI_ORDER_SECOND: Xen PICs
  * SI_ORDER_THIRD: Add I/O APIC PICs, alloc MSI and Xen IRQ ranges
  * SI_ORDER_FOURTH: Add 8259A PICs
@@ -135,11 +131,13 @@ static void	intrcnt_register(struct intsrc *is);
 static int
 intr_pic_registered(device_t pic)
 {
-	struct pic_entr *p;
+	device_t p = pics.next;
 
-	TAILQ_FOREACH(p, &pics, pics) {
-		if (p->pic == pic)
+/*	TAILQ_FOREACH(p, &pics, pics) { */
+	while (p) {
+		if (p == pic)
 			return (1);
+		p = ((pic_base_softc_t *)device_get_softc(p))->next;
 	}
 	return (0);
 }
@@ -176,9 +174,6 @@ intr_create_pic(const char *name, u_int unit, driver_t *driver)
 void
 intr_register_pic(device_t pic)
 {
-	struct pic_entr *entr = malloc(sizeof(*entr), M_INTR, M_WAITOK);
-
-	entr->pic = pic;
 
 	mtx_lock(&intrpic_lock);
 	if (__predict_false(intr_pic_registered(pic)))
@@ -189,8 +184,17 @@ intr_register_pic(device_t pic)
 #endif
 		    ("ERROR: %s: called with already registered PIC",
 		    __func__);
-	else
-		TAILQ_INSERT_TAIL(&pics, entr, pics);
+	else {
+		device_t p = pics.prev;
+		pic_base_softc_t *softc = device_get_softc(pic);
+		softc->next = NULL;
+		softc->prev = p;
+		if (p != NULL)
+			((pic_base_softc_t *)device_get_softc(p))->next = pic;
+		else
+			pics.next = pic;
+		pics.prev = pic;
+	}
 	mtx_unlock(&intrpic_lock);
 }
 
@@ -201,7 +205,7 @@ intr_register_pic(device_t pic)
 static void
 intr_init_sources(void *arg)
 {
-	struct pic_entr *pic;
+	device_t pic = pics.next;
 
 	MPASS(num_io_irqs > 0);
 
@@ -240,8 +244,10 @@ intr_init_sources(void *arg)
 	 * single-threaded at this point in startup so the list of
 	 * PICs shouldn't change.
 	 */
-	TAILQ_FOREACH(pic, &pics, pics)
-		PIC_REGISTER_SOURCES(pic->pic);
+	while (pic) {
+		PIC_REGISTER_SOURCES(pic);
+		pic = ((pic_base_softc_t *)device_get_softc(pic))->next;
+	}
 }
 SYSINIT(intr_init_sources, SI_SUB_INTR, SI_ORDER_FOURTH + 1, intr_init_sources,
     NULL);
@@ -290,7 +296,7 @@ intr_disable_all(void)
 		is = interrupt_sources[v];
 		if (is == NULL)
 			continue;
-		PIC_DISABLE_INTR(is->is_event.ie_pic, is);
+		PIC_DISABLE_INTR(is->is_event.ie_pic, is, PIC_EOI);
 	}
 }
 
@@ -338,7 +344,8 @@ intr_remove_handler(struct intsrc *isrc, struct intr_handler *handler)
 		sx_xlock(&intrsrc_lock);
 		isrc->is_handlers--;
 		if (isrc->is_handlers == 0)
-			PIC_DISABLE_INTR(isrc->is_event.ie_pic, isrc);
+			PIC_DISABLE_INTR(isrc->is_event.ie_pic, isrc,
+			    PIC_NO_EOI);
 		intrcnt_updatename(isrc);
 		sx_xunlock(&intrsrc_lock);
 	}
@@ -422,25 +429,29 @@ intr_execute_handlers(struct intsrc *isrc, struct trapframe *frame)
 void
 intr_resume(bool suspend_cancelled)
 {
-	struct pic_entr *pic;
+	device_t pic = pics.next;
 
 #ifndef DEV_ATPIC
 	atpic_reset();
 #endif
 	mtx_lock(&intrpic_lock);
-	TAILQ_FOREACH(pic, &pics, pics)
-		PIC_RESUME(pic->pic, suspend_cancelled);
+	while (pic) {
+		PIC_RESUME(pic, suspend_cancelled);
+		pic = ((pic_base_softc_t *)device_get_softc(pic))->next;
+	}
 	mtx_unlock(&intrpic_lock);
 }
 
 void
 intr_suspend(void)
 {
-	struct pic_entr *pic;
+	device_t pic = pics.prev;
 
 	mtx_lock(&intrpic_lock);
-	TAILQ_FOREACH_REVERSE(pic, &pics, pics_head, pics)
-		PIC_SUSPEND(pic->pic);
+	while (pic) {
+		PIC_SUSPEND(pic);
+		pic = ((pic_base_softc_t *)device_get_softc(pic))->prev;
+	}
 	mtx_unlock(&intrpic_lock);
 }
 
@@ -487,7 +498,8 @@ static device_method_t pic_base_methods[] = {
 	DEVMETHOD_END
 };
 
-PUBLIC_DEFINE_CLASSN(pic_base, pic_base_class, pic_base_methods, 0);
+PUBLIC_DEFINE_CLASSN(pic_base, pic_base_class, pic_base_methods,
+    sizeof(pic_base_softc_t));
 
 static void
 intrcnt_setname(const char *name, int index)

sys/x86/x86/io_apic.c

@@ -94,6 +94,7 @@ struct ioapic_intsrc {
 };
 
 struct ioapic {
+	pic_base_softc_t pic_base_softc;
 	u_int io_apic_id:8;		/* Id as enumerated by MADT */
 	u_int io_hw_apic_id:8;		/* Content of APIC ID register */
 	u_int io_intbase:8;		/* System Interrupt base */
@@ -105,8 +106,10 @@ struct ioapic {
 	device_t pci_dev;		/* matched pci device, if found */
 	struct resource *pci_wnd;	/* BAR 0, should be same or alias to
 					   io_paddr */
-	struct ioapic_intsrc io_pins[0];
+	struct ioapic_intsrc io_pins[];
 };
+_Static_assert(offsetof(struct ioapic, pic_base_softc) == 0,
+    ".pic_base_softc misaligned from struct ioapic!");
 
 static u_int	ioapic_read(volatile ioapic_t *apic, int reg);
 static void	ioapic_write(volatile ioapic_t *apic, int reg, u_int val);
@@ -514,12 +517,25 @@ ioapic_enable_intr(device_t pic, struct intsrc *isrc)
 }
 
 static void
-ioapic_disable_intr(x86pic_t pic, struct intsrc *isrc)
+ioapic_disable_intr(device_t pic, struct intsrc *isrc, enum eoi_flag eoi)
 {
 	struct ioapic_intsrc *intpin = (struct ioapic_intsrc *)isrc;
+	struct ioapic *io = device_get_softc(isrc->is_event.ie_pic);
+	uint32_t flags;
 	u_int vector;
 
-	ioapic_disable_source(pic, isrc);
+	mtx_lock_spin(&icu_lock);
+	if (!intpin->io_masked && !intpin->io_edgetrigger) {
+		flags = intpin->io_lowreg | IOART_INTMSET;
+		ioapic_write(io->io_addr,
+		    IOAPIC_REDTBL_LO(intpin->io_intpin), flags);
+		intpin->io_masked = 1;
+	}
+
+	if (eoi == PIC_EOI)
+		_ioapic_eoi_source(io, intpin);
+
+	mtx_unlock_spin(&icu_lock);
 
 	if (intpin->io_vector != 0) {
 		/* Mask this interrupt pin and free its APIC vector. */

sys/x86/x86/local_apic.c

@@ -474,7 +474,8 @@ static const device_method_t lapic_methods[] = {
 	DEVMETHOD_END
 };
 
-PRIVATE_DEFINE_CLASSN(lapic, lapic_class, lapic_methods, 0, pic_base_class);
+PRIVATE_DEFINE_CLASSN(lapic, lapic_class, lapic_methods,
+    sizeof(pic_base_softc_t), pic_base_class);
 
 static uint32_t
 lvt_mode_impl(struct lapic *la, struct lvt *lvt, u_int pin, uint32_t value)

sys/x86/x86/msi.c

@@ -150,7 +150,8 @@ static const device_method_t msi_methods[] = {
 	DEVMETHOD_END
 };
 
-PRIVATE_DEFINE_CLASSN(msi, msi_class, msi_methods, 0, pic_base_class);
+PRIVATE_DEFINE_CLASSN(msi, msi_class, msi_methods, sizeof(pic_base_softc_t),
+    pic_base_class);
 
 static device_t msi_pic;
 
@@ -208,7 +209,7 @@ msi_enable_intr(device_t pic, struct intsrc *isrc)
 }
 
 static void
-msi_disable_intr(device_t pic, struct intsrc *isrc)
+msi_disable_intr(device_t pic, struct intsrc *isrc, enum eoi_flag eoi)
 {
 	struct msi_intsrc *msi = (struct msi_intsrc *)isrc;
 
@@ -221,7 +222,8 @@ msi_disable_intr(device_t pic, struct intsrc *isrc)
 	if (msi == NULL)
 		return;
 
-	lapic_eoi();
+	if (eoi == PIC_EOI)
+		lapic_eoi();
 
 	msi->msi_enabled--;
 	if (msi->msi_enabled == 0) {

sys/x86/x86/pic_if.m

@@ -29,6 +29,12 @@
 	#include <machine/interrupt.h>
 
 	#include "intr_event_if.h"
+
+	/* Flags for pic_disable_intr() */
+	enum eoi_flag {
+		PIC_EOI,
+		PIC_NO_EOI,
+	};
 };
 
 CODE {
@@ -73,6 +79,7 @@
 METHOD void disable_intr {
 	device_t	pic;
 	struct intsrc	*isrc;
+	enum eoi_flag	eoi;
 };
 
 METHOD int source_pending {