more stuff

Author: DarkFire01

boot/bootdata/bootcd.ini

@@ -1,5 +1,5 @@
 [FREELOADER]
-DefaultOS=LiveImg_Debug_Net
+DefaultOS=LiveImg_Debug
 TimeOut=10
 
 [Display]

drivers/bus/acpi_new/uacpiosl.c

@@ -491,8 +491,11 @@ UacpiQueryAcpiRootFromRegistry(_Out_ PHYSICAL_ADDRESS *OutRootTable)
     if (!NT_SUCCESS(Status))
         goto Exit;
 
-    /* Allocate enough to hold the longest subkey name (+ terminator) */
-    Bytes = FullInfo->MaxNameLen + sizeof(WCHAR);
+    /* Allocate enough to hold the KEY_BASIC_INFORMATION header plus the longest
+     * subkey name (+ terminator). MaxNameLen counts only the name bytes, so the
+     * fixed header (LastWriteTime/TitleIndex/NameLength, i.e. up to Name[]) must
+     * be added; otherwise ZwEnumerateKey fails with STATUS_BUFFER_TOO_SMALL. */
+    Bytes = FIELD_OFFSET(KEY_BASIC_INFORMATION, Name) + FullInfo->MaxNameLen + sizeof(WCHAR);
     KeyInfo = ExAllocatePoolWithTag(PagedPool, Bytes, 'rAcu');
     if (!KeyInfo)
     {

drivers/bus/pci/pdo.c

@@ -2370,7 +2370,12 @@ PdoStartDevice(
                         PciDevice->SlotNumber.u.AsULONG,
                         PciDevice->BusNumber);
 
-                PciProgramInterruptResource(PciDevice);
+                /*
+                 * NB: do not program the capability here. An MSI-X table lives in
+                 * the device's BAR memory, so it can only be written once Memory
+                 * Space decoding is enabled below. Defer until after the command
+                 * register is set up.
+                 */
             }
             else if (RawPartialDesc->Type == CmResourceTypeInterrupt)
             {
@@ -2452,6 +2457,19 @@ PdoStartDevice(
         DBGPRINT("None\n");
     }
 
+    /*
+     * Now that Memory Space (and Bus Master) decoding is enabled, program the
+     * MSI/MSI-X capability. This must happen after the command register write:
+     * an MSI-X table is mapped from the device's BAR, and the message-address
+     * writes only reach the device once memory decoding is on. (MSI lives in
+     * config space and would work either way, but is harmless to defer too.)
+     */
+    if (DeviceExtension->PciDevice->InterruptResource.Type == PciInterruptTypeMsi ||
+        DeviceExtension->PciDevice->InterruptResource.Type == PciInterruptTypeMsiX)
+    {
+        PciProgramInterruptResource(DeviceExtension->PciDevice);
+    }
+
     return STATUS_SUCCESS;
 }
 

drivers/storage/ide/pciidex/chipset/ahci_generic.c

@@ -548,7 +548,19 @@ AtaAhciHbaFreeResouces(
 {
     PAGED_CODE();
 
-    if (Controller->InterruptObject)
+    if (Controller->InterruptMessageTable)
+    {
+        IO_DISCONNECT_INTERRUPT_PARAMETERS Params;
+
+        Params.Version = CONNECT_MESSAGE_BASED;
+        Params.ConnectionContext.InterruptMessageTable = Controller->InterruptMessageTable;
+        IoDisconnectInterruptEx(&Params);
+        Controller->InterruptMessageTable = NULL;
+
+        /* IoDisconnectInterruptEx freed the KINTERRUPT we aliased here */
+        Controller->InterruptObject = NULL;
+    }
+    else if (Controller->InterruptObject)
     {
         IoDisconnectInterrupt(Controller->InterruptObject);
         Controller->InterruptObject = NULL;
@@ -729,6 +741,52 @@ AhciGetControllerProperties(
     /* Clear HBA interrupts */
     AHCI_HBA_WRITE(Controller->IoBase, HbaInterruptStatus, 0xFFFFFFFF);
 
+    /*
+     * MSI/MSI-X interrupts must be connected through the message-based path.
+     * The legacy IoConnectInterrupt() does not arm message-signalled delivery,
+     * so the HBA would assert its interrupt but the ISR would never run.
+     * Try the message-based path first (it locates any assigned MSI resource
+     * from the PDO itself) and fall back to a line-based connection.
+     */
+    {
+        PFDO_DEVICE_EXTENSION FdoExt =
+            CONTAINING_RECORD(Controller, FDO_DEVICE_EXTENSION, Controller);
+        IO_CONNECT_INTERRUPT_PARAMETERS Params;
+
+        RtlZeroMemory(&Params, sizeof(Params));
+        Params.Version = CONNECT_MESSAGE_BASED;
+        Params.MessageBased.PhysicalDeviceObject = FdoExt->Pdo;
+        Params.MessageBased.ConnectionContext.InterruptMessageTable =
+            &Controller->InterruptMessageTable;
+        Params.MessageBased.MessageServiceRoutine = AtaAhciHbaMessageIsr;
+        Params.MessageBased.ServiceContext = Controller;
+        Params.MessageBased.SpinLock = NULL;
+        Params.MessageBased.SynchronizeIrql = 0;
+        Params.MessageBased.FloatingSave = FALSE;
+        Params.MessageBased.FallBackServiceRoutine = NULL;
+
+        Status = IoConnectInterruptEx(&Params);
+        if (NT_SUCCESS(Status))
+        {
+            /*
+             * Publish the message's KINTERRUPT as the controller interrupt object
+             * so the existing per-port/atapi synchronization (which calls
+             * KeAcquireInterruptSpinLock(Controller->InterruptObject)) keeps
+             * working with the message-based connection. The HBA uses a single
+             * MSI for all ports, so message 0's object covers the controller.
+             */
+            Controller->InterruptObject =
+                Controller->InterruptMessageTable->MessageInfo[0].InterruptObject;
+
+            INFO("Connected message-based interrupt: %lu message(s)\n",
+                 Controller->InterruptMessageTable->MessageCount);
+            return STATUS_SUCCESS;
+        }
+
+        WARN("Message-based connect failed (0x%lx), trying line-based\n", Status);
+        Controller->InterruptMessageTable = NULL;
+    }
+
     Status = IoConnectInterrupt(&Controller->InterruptObject,
                                 AtaAhciHbaIsr,
                                 Controller,

drivers/storage/ide/pciidex/chipset/ahci_io.c

@@ -427,3 +427,19 @@ AtaAhciHbaIsr(
 
     return TRUE;
 }
+
+/*
+ * Message-signalled (MSI/MSI-X) interrupt trampoline. The HBA shares a single
+ * MSI for all ports, so the message id is irrelevant - just run the HBA ISR.
+ */
+BOOLEAN
+NTAPI
+AtaAhciHbaMessageIsr(
+    _In_ PKINTERRUPT Interrupt,
+    _In_ PVOID ServiceContext,
+    _In_ ULONG MessageId)
+{
+    UNREFERENCED_PARAMETER(MessageId);
+
+    return AtaAhciHbaIsr(Interrupt, ServiceContext);
+}

drivers/storage/ide/pciidex/pciidex.h

@@ -170,6 +170,8 @@ typedef struct _ATA_CONTROLLER
 {
     CM_PARTIAL_RESOURCE_DESCRIPTOR InterruptDesc;
     PKINTERRUPT InterruptObject;
+    /* Set when the HBA interrupt is connected via the message-based (MSI/MSI-X) path. */
+    PIO_INTERRUPT_MESSAGE_INFO InterruptMessageTable;
     struct
     {
         USHORT VendorID;
@@ -627,6 +629,7 @@ CHANNEL_PREPARE_IO AtaAhciPrepareIo;
 CHANNEL_PREPARE_PRD_TABLE AtaAhciPreparePrdTable;
 CHANNEL_ALLOCATE_SLOT AtaAhciAllocateSlot;
 KSERVICE_ROUTINE AtaAhciHbaIsr;
+KMESSAGE_SERVICE_ROUTINE AtaAhciHbaMessageIsr;
 
 /* pata_generic.c *************************************************************/
 

ntoskrnl/io/iomgr/irq.c

@@ -169,25 +169,103 @@ IoDisconnectInterrupt(PKINTERRUPT InterruptObject)
     ExFreePoolWithTag(IoInterrupt, TAG_IO_INTERRUPT);
 }
 
+static PCM_PARTIAL_RESOURCE_DESCRIPTOR
+IopFindMessageInterruptDescriptor(
+    _In_ PDEVICE_OBJECT PhysicalDeviceObject);
+static PCM_PARTIAL_RESOURCE_DESCRIPTOR
+IopFindMessageInterruptDescriptorEx(
+    _In_ PDEVICE_OBJECT PhysicalDeviceObject,
+    _In_ BOOLEAN Translated);
+
 NTSTATUS
 IopConnectInterruptExFullySpecific(
     _Inout_ PIO_CONNECT_INTERRUPT_PARAMETERS Parameters)
 {
     NTSTATUS Status;
+    ULONG Vector = Parameters->FullySpecified.Vector;
+    KIRQL Irql = Parameters->FullySpecified.Irql;
+    KIRQL SynchronizeIrql = Parameters->FullySpecified.SynchronizeIrql;
+    KINTERRUPT_MODE Mode = Parameters->FullySpecified.InterruptMode;
+    KAFFINITY Affinity = Parameters->FullySpecified.ProcessorEnableMask;
+    PCM_PARTIAL_RESOURCE_DESCRIPTOR RawDesc;
 
     PAGED_CODE();
 
-    /* Fallback to standard IoConnectInterrupt */
+    /*
+     * If the device was granted a message-signalled interrupt (MSI/MSI-X), the
+     * caller passes the *translated* system vector, but the LAPIC actually
+     * delivers the *raw* message vector that the bus driver programmed into the
+     * device's MSI/MSI-X capability. IoConnectInterrupt() arms the IDT at the
+     * vector it is given, so without remapping the IDT entry would never match
+     * the delivered vector and the ISR would never run. Remap to the raw vector
+     * (with its message IRQL and edge-triggered mode) before connecting.
+     *
+     * Win8's IoConnectInterruptEx resolves the same thing via the device's
+     * interrupt connection data; we derive it from the raw/translated resource
+     * lists the PnP manager assigned.
+     */
+    RawDesc = IopFindMessageInterruptDescriptor(Parameters->FullySpecified.PhysicalDeviceObject);
+    if (RawDesc != NULL)
+    {
+        ULONG RawBase = RawDesc->u.MessageInterrupt.Raw.Vector;
+        ULONG Count = RawDesc->u.MessageInterrupt.Raw.MessageCount;
+        BOOLEAN Remap = FALSE;
+
+        if (Count == 0)
+            Count = 1;
+
+        if (Count == 1)
+        {
+            /*
+             * Single message: the device delivers exactly one vector - the raw
+             * message vector the bus driver programmed into the MSI/MSI-X
+             * capability. The caller's translated vector belongs to a different
+             * HAL domain and would arm the wrong IDT entry, so use the raw one.
+             */
+            Vector = RawBase;
+            Remap = TRUE;
+        }
+        else
+        {
+            /*
+             * Multiple messages: map the caller's translated vector to the raw
+             * message vector by its offset within the translated block.
+             */
+            PCM_PARTIAL_RESOURCE_DESCRIPTOR TransDesc =
+                IopFindMessageInterruptDescriptorEx(Parameters->FullySpecified.PhysicalDeviceObject, TRUE);
+            if (TransDesc != NULL)
+            {
+                ULONG TransBase = TransDesc->u.MessageInterrupt.Translated.Vector;
+                if (Vector >= TransBase && Vector < TransBase + Count)
+                {
+                    Vector = RawBase + (Vector - TransBase);
+                    Remap = TRUE;
+                }
+            }
+        }
+
+        if (Remap)
+        {
+            Irql = HalGetMessageVectorIrql((UCHAR)Vector);
+            Mode = Latched;       /* MSI/MSI-X are edge-triggered */
+            Affinity = RawDesc->u.MessageInterrupt.Raw.Affinity;
+        }
+    }
+
+    /* KeInitializeInterrupt requires SynchronizeIrql >= the interrupt IRQL */
+    if (SynchronizeIrql < Irql)
+        SynchronizeIrql = Irql;
+
     Status = IoConnectInterrupt(Parameters->FullySpecified.InterruptObject,
                                 Parameters->FullySpecified.ServiceRoutine,
                                 Parameters->FullySpecified.ServiceContext,
                                 Parameters->FullySpecified.SpinLock,
-                                Parameters->FullySpecified.Vector,
-                                Parameters->FullySpecified.Irql,
-                                Parameters->FullySpecified.SynchronizeIrql,
-                                Parameters->FullySpecified.InterruptMode,
+                                Vector,
+                                Irql,
+                                SynchronizeIrql,
+                                Mode,
                                 Parameters->FullySpecified.ShareVector,
-                                Parameters->FullySpecified.ProcessorEnableMask,
+                                Affinity,
                                 Parameters->FullySpecified.FloatingSave);
     if (!NT_SUCCESS(Status))
         DPRINT1("IopConnectInterruptExFullySpecific() failed: 0x%lx\n", Status);
@@ -249,20 +327,27 @@ IopFreeMsiInterrupts(
  */
 static
 PCM_PARTIAL_RESOURCE_DESCRIPTOR
-IopFindMessageInterruptDescriptor(
-    _In_ PDEVICE_OBJECT PhysicalDeviceObject)
+IopFindMessageInterruptDescriptorEx(
+    _In_ PDEVICE_OBJECT PhysicalDeviceObject,
+    _In_ BOOLEAN Translated)
 {
     PDEVICE_NODE DeviceNode;
     PCM_RESOURCE_LIST ResourceList;
     PCM_FULL_RESOURCE_DESCRIPTOR FullDescriptor;
     ULONG i, j;
 
     DeviceNode = IopGetDeviceNode(PhysicalDeviceObject);
-    if (!DeviceNode || !DeviceNode->ResourceList)
+    if (!DeviceNode)
+        return NULL;
+
+    /*
+     * The raw list carries the MessageInterrupt.Raw form (base vector + count);
+     * the translated list carries MessageInterrupt.Translated (system vector).
+     */
+    ResourceList = Translated ? DeviceNode->ResourceListTranslated : DeviceNode->ResourceList;
+    if (!ResourceList)
         return NULL;
 
-    /* The raw list carries the MessageInterrupt.Raw form (base vector + count) */
-    ResourceList = DeviceNode->ResourceList;
     FullDescriptor = &ResourceList->List[0];
 
     for (i = 0; i < ResourceList->Count; i++)
@@ -286,6 +371,14 @@ IopFindMessageInterruptDescriptor(
     return NULL;
 }
 
+static
+PCM_PARTIAL_RESOURCE_DESCRIPTOR
+IopFindMessageInterruptDescriptor(
+    _In_ PDEVICE_OBJECT PhysicalDeviceObject)
+{
+    return IopFindMessageInterruptDescriptorEx(PhysicalDeviceObject, FALSE);
+}
+
 NTSTATUS
 IopConnectInterruptExMessageBased(
     _Inout_ PIO_CONNECT_INTERRUPT_PARAMETERS Parameters)