Fact-checked by Grok 2 weeks ago

Interrupt vector table

An interrupt vector table (IVT) is a data structure in computer memory that maps interrupt requests from hardware or software to specific interrupt service routines (ISRs) responsible for handling them, enabling efficient response to asynchronous events in processor architectures.^[1] In early systems like the Intel 8086 microprocessor, the IVT is located at the base of memory from addresses 00000H to 003FFH, consisting of 256 entries, each 4 bytes long, where each entry stores a 16-bit segment address followed by a 16-bit offset pointing to the start of an ISR.^[2] The IVT plays a central role in interrupt handling by allowing the processor to quickly locate and execute the appropriate routine when an interrupt occurs, such as a non-maskable interrupt (NMI) on vector 2 or a maskable interrupt (INTR) vectored through an 8-bit type number supplied by the interrupting device.^[2] Upon interrupt recognition, the processor saves the current execution state on the stack, indexes the IVT using the interrupt type, fetches the target address, and jumps to the ISR, which must later restore the context to resume normal operation.^[3] The first 32 vectors are typically reserved for processor-defined exceptions and traps, with the remaining available for user or device-specific interrupts, supporting prioritization through mechanisms like programmable interrupt controllers (PICs).^[1] In modern architectures, such as ARM Cortex-M processors, the vector table evolves into a relocatable structure that includes not only interrupt handlers but also the initial main stack pointer and addresses for exceptions like reset, hard faults, and system ticks, often defined in startup code and offset via registers for flexibility in embedded systems.^[4] While the original IVT concept from the 8086 era persists in real-mode x86 environments, protected-mode systems replace it with an interrupt descriptor table (IDT) for enhanced security and segmentation, though the core principle of vectoring interrupts remains foundational to operating systems and device management.^[1]

Fundamentals

Definition and Purpose

An interrupt vector table (IVT) is a data structure in computer memory that associates specific interrupt types with their corresponding interrupt service routines (ISRs), typically consisting of an array of pointers or addresses that direct the processor to the appropriate handler code for each interrupt.^[3]^[5] This table serves as a centralized mapping mechanism, where each entry corresponds to a unique interrupt number or vector, enabling the processor to quickly locate and invoke the relevant routine without extensive searching.^[3] The primary purpose of the IVT is to facilitate an efficient CPU response to asynchronous events, such as hardware signals from timers, I/O device completions, or external peripherals, by allowing the processor to jump directly to predefined handler locations rather than relying on continuous polling of devices.^[5] This approach improves system responsiveness by minimizing idle CPU cycles that would otherwise be wasted in polling loops, thereby reducing overall latency in event handling.^[5] Key benefits include support for real-time systems through bounded response times, enabling multitasking via context switching in operating systems, and providing a framework for interrupt prioritization to manage concurrent events effectively.^[5] In operation, when an interrupt occurs, the processor completes its current instruction, saves the processor state (such as registers) to the stack, and uses the interrupt number as an index to consult the IVT for the address of the associated ISR.^[3]^[5] The processor then loads this address into the program counter, executes the handler to address the event, and upon completion, restores the saved state via an interrupt return instruction to resume normal execution.^[3]^[5] This flow ensures orderly and rapid interrupt management across diverse computing environments.^[5]

Historical Development

The concept of interrupt handling through structured memory locations for directing control to service routines originated in the 1960s with early minicomputers and mainframes, marking a shift from polling-based I/O to more efficient asynchronous event processing. In Digital Equipment Corporation's PDP-8, launched in 1965, interrupts utilized a single fixed entry point: upon an interrupt request, the processor disabled further interrupts, stored the program counter at memory location 0, and jumped to location 1, where the handler code would poll connected devices to determine the source, representing an early form of fixed addressing without a full vector table.^[6] Similarly, IBM's System/360 family, announced in 1964 and first delivered in 1965, implemented an interruption system with eight classes of interrupts (such as external, I/O, program, and supervisor call), each loading a new program status word (PSW)—containing the instruction address and status—from predefined fixed memory locations (e.g., 0x40 for external interrupts in certain models), effectively providing vectored jumps to handlers via indirect addressing through these PSW slots.^[7] The 1970s saw the standardization of interrupt vector tables in microprocessors, driven by the rise of affordable computing. Intel's 8080, released in April 1974, advanced interrupt support with dedicated instructions like RST for fixed restart locations (e.g., RST 0 at 0x0000, RST 7 at 0x0038) for software traps and a non-vectored external INT signal that jumped to a restart address after acknowledgment, often requiring software polling for device identification, thus building on fixed addressing schemes while introducing programmable interrupt controllers like the 8214 for prioritization.^[8] This culminated in the Intel 8086 microprocessor of 1978, which formalized the Interrupt Vector Table (IVT) as a dedicated 1 KB structure at memory address 0x0000 in real mode, comprising 256 entries of four bytes each (segment:offset pairs) to store handler addresses, supporting both hardware interrupts via the INTR pin and software interrupts, thereby enabling scalable vectored dispatching without fixed locations.^[9] Key milestones in the 1980s highlighted the IVT's integration into personal computing ecosystems. Microsoft's MS-DOS, introduced in 1981 for the IBM PC, heavily relied on the IVT for system services, reserving vectors like INT 10h for BIOS video functions and INT 21h for DOS file and program execution calls, allowing applications to invoke kernel routines through standardized software interrupts and fostering a modular software architecture.^[10] The Intel 80286, released in 1982, evolved this framework by introducing protected mode, where the fixed real-mode IVT was supplemented by a relocatable Interrupt Descriptor Table (IDT) loaded via the LIDT instruction, supporting 256 descriptors with segment selectors for enhanced memory protection and multitasking, while preserving real-mode compatibility for legacy software.^[11] Operating systems played a pivotal role in adapting the IVT for software-driven multitasking during this era. Gary Kildall's CP/M (1974 onward), an early OS for 8080/Z80-based systems, utilized the IVT by initializing multiple vectors to point to a common BIOS entry for interrupt handling, with BDOS calls implemented via a CALL to the fixed entry point at address 0005h to access disk and console services without direct polling.^[12] Unix variants, ported to x86 architectures in the early 1980s (e.g., Microsoft's Xenix), leveraged the INT instruction for system calls—such as INT 0x80 in early x86 Unix implementations—to trap into kernel mode via IVT entries, enabling efficient user-kernel transitions for file I/O and process management in multitasking environments.^[13] By the 1990s, the transition to fully dynamic tables accelerated with protected-mode dominance in processors like the Intel 80386 (1985), replacing fixed IVTs with configurable IDTs in modern OSes for virtual memory support, though the original IVT design endures in embedded systems and real-mode bootloaders for compatibility and simplicity.^[14]

Structure and Organization

Entries and Vectors

Each entry in an interrupt vector table is known as an interrupt vector, which serves as a pointer—typically a memory address or offset—to the starting location of the associated interrupt service routine (ISR). This design allows the processor to quickly locate and execute the appropriate handler code upon receiving an interrupt signal.^[1] The structure of an individual entry varies by system but generally consists of a fixed-size data element, such as a single 16-bit word or a 32-bit double word, containing the essential addressing information for the ISR. In architectures employing segmented memory, such as the x86 real mode, this may include both a segment and an offset to form the full handler address. These components ensure the vector provides all necessary details for correct ISR invocation without additional computation.^[2] The table maintains a fixed number of entries determined by the underlying architecture, accommodating a predefined range of interrupt types through unique indices. For instance, the x86 architecture supports 256 vectors, indexed from 0 to 255, with each index directly corresponding to a specific interrupt number provided by the interrupting source. This fixed capacity balances efficiency with the need to handle diverse interrupt sources in a standardized manner.^[2] Vector indexing occurs when the processor uses the interrupt type code—often an 8-bit value—as a direct array index to access the table and retrieve the target vector. This straightforward lookup mechanism minimizes latency, enabling near-instantaneous redirection to the ISR and supporting real-time responsiveness in interrupt-driven systems.^[1] In cases where a vector entry is invalid, uninitialized, or points to an inaccessible location, the processor will load the address and attempt to execute, potentially leading to runtime errors or exceptions depending on the system's memory protection features. Such scenarios may invoke a default handler or trigger system-level recovery procedures to prevent cascading failures.

Memory Layout Examples

The interrupt vector table (IVT) is typically implemented as a contiguous array residing in low physical memory to facilitate rapid access immediately following system reset. In many architectures, this placement begins at address 0x00000000, ensuring the processor can directly reference the table without additional configuration in the initial boot phase.^[15]^[16] In the x86 architecture operating in real mode, the IVT occupies a fixed 1 KB block from physical addresses 0x0000 to 0x03FF, comprising 256 entries to support a wide range of interrupts and exceptions. Each entry spans 4 bytes: the first 2 bytes store the 16-bit offset of the interrupt handler, followed by 2 bytes for the 16-bit code segment. This structure allows the processor to form a 20-bit linear address by combining the segment (shifted left by 4 bits) and offset during interrupt dispatch. For instance, the entry for interrupt vector 0x10 (BIOS video services) would reside at offset 0x40 in the table, with the offset bytes at 0x40-0x41 and segment bytes at 0x42-0x43.^[15]^[17] Embedded systems often employ a more sparse IVT layout with predefined fixed addresses rather than a dense contiguous array, tailored to the limited memory and interrupt sources of microcontrollers. In the 8051 family of 8-bit microcontrollers, interrupt vectors are located at specific 3-byte intervals starting from low memory, such as 0x0000 for the reset vector, 0x0003 for external interrupt 0, 0x000B for timer 0 overflow, and 0x0013 for external interrupt 1. These locations typically hold jump instructions to the actual handlers, enabling efficient branching in resource-constrained environments.^[18] IVT entries are generally aligned to word or double-word boundaries to optimize memory access and processor efficiency, with padding added if necessary to maintain this alignment across architectures. The overall table size is determined by the number of supported vectors multiplied by the entry width, which corresponds to the address bus size; for example, a system with 128 vectors and 32-bit addresses per entry results in a 512-byte table. In ARM Cortex-M processors, the table must align to a power-of-two boundary (e.g., 128-byte for smaller configurations or 512-byte for larger ones) to support vectored interrupt control.^[19]^[20] Initialization of the IVT occurs during system startup, where firmware such as the BIOS in x86 systems or bootloaders in embedded setups first populate it with default handlers for essential interrupts like reset and basic I/O. Operating system kernels then overwrite or extend these entries at boot time to install custom handlers, ensuring compatibility with the runtime environment while preserving critical vectors.^[21]^[22]

Interrupt Handling Mechanisms

Predefined Vector Assignment

In predefined vector assignment, interrupt sources are statically mapped to fixed indices in the interrupt vector table by hardware or firmware, allowing the processor to directly locate the corresponding handler without runtime negotiation or dynamic resolution. This method relies on predefined mappings where specific interrupt requests (IRQs) are assigned to particular vector numbers, such as IRQ 0 consistently mapping to vector 8 in early x86 real-mode configurations. Vectors 0 through 31 are architecturally reserved for predefined exceptions and non-maskable interrupts (NMIs), including divide errors (vector 0), debug exceptions (vector 1), and NMIs (vector 2), ensuring these critical events always trigger the same handlers. For external hardware interrupts, the mapping is established via programmable interrupt controllers that offset IRQ lines to user-defined vectors (32–255), providing a static association that simplifies interrupt dispatching. This approach offers key advantages, including streamlined hardware design by eliminating the need for complex vector negotiation protocols, which enables low and predictable interrupt latency—essential for legacy systems and real-time embedded applications where timing determinism is paramount. By fixing assignments at initialization, it reduces overhead during interrupt delivery, as the processor can immediately index the vector table upon receiving the vector number. Implementation typically begins with BIOS or firmware configuring the initial mappings during system startup, often using a Programmable Interrupt Controller (PIC) like the Intel 8259A to set a base vector offset. The 8259A's initialization command word 2 (ICW2) programs the base by setting the upper 5 bits (corresponding to address lines A11–A15) of the interrupt vector, to which the IRQ level is added to form the full 8-bit vector.^[23] For instance, in 8086 mode, the IRQ number occupies the lower bits while the base fills the upper bits. Operating systems may then remap these vectors post-boot to avoid conflicts with reserved exceptions, such as shifting the master PIC's base from 0x08 to 0x20 in protected mode, while preserving the relative IRQ-to-vector offsets. Representative examples from x86 systems illustrate these static assignments. In DOS-era configurations, the system timer (IRQ 0) is predefined at vector 0x08, while the keyboard interrupt (IRQ 1) maps to 0x09; the secondary PIC handles higher IRQs like the real-time clock (IRQ 8) at 0x70. These mappings remain fixed unless explicitly reprogrammed, demonstrating the method's reliance on static configuration for consistent behavior. A primary limitation of predefined vector assignment is its rigidity, which constrains flexibility in systems with numerous or hot-pluggable devices, as adding new interrupts requires manual remapping and risks vector exhaustion or conflicts without dynamic allocation support.

Vector Fetch Methods

Vector fetch methods refer to the techniques employed by processors to obtain the interrupt vector number that identifies the appropriate entry in the interrupt vector table (IVT) during an interrupt event. These methods vary depending on the architecture and the nature of the interrupt, whether it is hardware-generated, software-initiated, or resolved through an interrupt controller. The fetched vector is then used to index the IVT and dispatch the corresponding handler. In direct fetch methods, commonly used in simple processors or embedded systems with limited interrupt sources, the CPU directly uses a predefined interrupt type or line number to index the IVT without intermediary hardware arbitration. For example, each interrupt source may be wired to a specific vector offset, allowing the processor to immediately push the interrupt type onto the stack and retrieve the handler address from the IVT. This approach minimizes latency in systems with few devices, as no additional vector resolution is required.^[5] Indirect fetch methods involve an interrupt controller, such as the Advanced Programmable Interrupt Controller (APIC) in x86 architectures, which arbitrates among multiple sources and supplies the vector to the CPU after priority resolution. The controller evaluates pending interrupts based on configured priorities and delivers the selected vector via a dedicated mechanism, enabling scalable handling in complex multiprocessor environments. In the APIC, for instance, the I/O APIC routes interrupts to local APICs, which then provide the vector to the processor core. Software-initiated fetches occur for exceptions, where the CPU internally generates a fixed vector based on the exception type without external input. In x86 processors, exceptions like divide-by-zero are assigned predefined vectors (e.g., vector 0 for #DE), allowing immediate indexing of the IVT or Interrupt Descriptor Table (IDT) upon detection. This ensures predictable handling of synchronous events such as faults or traps. Priority resolution is often encoded in the vector itself, particularly in indirect methods, where higher vector values indicate greater urgency, enabling preemption of lower-priority interrupts. In the x86 APIC, vectors are grouped into 16 priority levels (derived by dividing the vector by 16), with higher levels (e.g., vectors 0xF0-0xFF) preempting lower ones during delivery. This allows the interrupt controller to select and fetch the highest-priority pending vector dynamically. Error cases during vector fetch, such as when no valid interrupt is pending after acknowledgment, result in spurious interrupts that are typically ignored or handled via a dedicated vector to prevent system disruption. In the x86 APIC, the Spurious Interrupt Vector Register (SVR) specifies a vector (often 0xFF) for such events, where the local APIC detects the absence of a valid delivery and dispatches the spurious handler instead of processing a non-existent interrupt.

Interrupt Acknowledge Cycle

The interrupt acknowledge cycle is a fundamental hardware protocol in interrupt handling systems, where the central processing unit (CPU) queries an interrupt controller for the vector associated with a pending interrupt. Upon detecting an active interrupt request via the INT signal, the CPU completes its current instruction and initiates the cycle by asserting the INTA (Interrupt Acknowledge) signal. The controller, such as the Intel 8259 Programmable Interrupt Controller (PIC), responds by placing one or more bytes of the interrupt vector onto the data bus, allowing the CPU to fetch the address of the corresponding interrupt service routine. This process ensures vectored interrupts, where the hardware directly provides the routine's location rather than relying on polling.^[23] In x86 architectures utilizing the 8259 PIC, the cycle consists of two INTA pulses for 8086-compatible processors. The first pulse triggers internal operations within the PIC, including resolution of the highest-priority interrupt from the Interrupt Request Register (IRR) while considering the Interrupt Mask Register (IMR) and In-Service Register (ISR). If multiple interrupts are pending, the PIC's priority resolver arbitrates among them according to the programmed mode, such as fully nested priority where input 0 holds the highest precedence. The second INTA pulse then drives the 8-bit vector onto the data bus, which the CPU latches to index into the interrupt vector table. In configurations without cascading, this completes the vector fetch atomically over these dedicated bus cycles.^[23]^[24] For systems requiring more than eight interrupt lines, such as in cascaded master-slave setups with the 8259 PIC, the acknowledge cycle extends to involve multiple controllers. The master PIC receives the first INTA and, if the highest-priority interrupt originates from a slave (connected via one of its IRR inputs), asserts a 3-bit slave identification code on the CAS0-2 lines to select the appropriate slave PIC. The selected slave then participates in the sequence, providing the 8-bit vector during the second INTA pulse while the master relinquishes the data bus. This optional slave involvement adds no extra pulses but ensures scalability, supporting up to 64 interrupts across one master and eight slaves, with prioritization maintained across the hierarchy.^[23]^[25] The cycle's timing is precisely synchronized to the CPU's clock, with each INTA pulse lasting one bus cycle (typically 4-5 CPU clocks in early x86) and setup/hold times of around 55 ns for the 8259A to ensure stable vector transfer. Bus hold signals and the special nature of INTA cycles grant the CPU exclusive bus ownership, preventing interference from direct memory access (DMA) devices or other masters, thus guaranteeing the atomicity of the vector delivery. This isolation is critical in shared-bus environments like the ISA bus.^[23]^[24] Over time, the interrupt acknowledge cycle has evolved in modern architectures to address limitations in scalability and wiring. In PCI-based systems, it has been supplanted by message-signaled interrupts (MSI), defined in the PCI 2.2 specification, where peripherals generate interrupts by writing a 32-bit message (including vector information) directly to a predefined APIC register in memory. This peer-to-peer approach eliminates the need for dedicated INTA wires and acknowledge cycles, reducing latency and hardware complexity while supporting multiple vectors per device.^[26]

Architectural Implementations

x86-Specific Features

In real mode, the x86 interrupt vector table (IVT) is located at a fixed physical address of 0x0000 and comprises 256 contiguous 4-byte entries, totaling 1 KB in size. Each entry stores a 16-bit segment selector followed by a 16-bit offset, forming a far pointer to the corresponding interrupt service routine (ISR). This layout ensures direct hardware access without additional indirection, facilitating compatibility with early x86 systems such as those running DOS and initial versions of Windows.^[27] Upon transitioning to protected mode, the IVT is superseded by the more flexible Interrupt Descriptor Table (IDT), which supports privilege levels, larger addresses, and gate descriptors for enhanced security and multitasking. However, to maintain backward compatibility, virtual-8086 (V86) mode emulates real-mode behavior, allowing 16-bit applications to execute while intercepting IVT-based interrupts and redirecting them through the IDT for proper handling in a protected environment. This mechanism enables legacy real-mode code, including DOS programs, to run under modern x86 operating systems without modification.^[28] The x86 architecture closely integrates the IVT with external interrupt controllers for efficient hardware event management. The legacy 8259A Programmable Interrupt Controller (PIC) connects up to eight interrupt requests (IRQs 0-7) from peripherals, programming them to generate vectors in the range 0x20 to 0x27 within the IVT; a secondary PIC can cascade for additional IRQs, typically offset to 0x28-0x2F. In multiprocessor configurations, the Advanced Programmable Interrupt Controller (APIC)—comprising local APICs per core and an I/O APIC—extends this by supporting up to 255 vectors (0x00-0xFF), enabling targeted interrupt delivery to specific processors, inter-processor interrupts (IPIs), and dynamic remapping to avoid conflicts with CPU exceptions.^[23]^[28] Software interrupts in x86 leverage the IVT directly via the INT n instruction, which specifies an 8-bit immediate vector n (ranging from 0x00 to 0xFF) to index the table and invoke the associated handler, mimicking hardware interrupts for system calls and debugging. In real mode, this performs a simple far call after saving the processor state; in protected mode, it consults the IDT but retains the vector indexing for compatibility. This design has been pivotal for operating system services, such as BIOS calls in early x86 environments.^[29] For debugging purposes, tools like SoftICE exploit the IVT's modifiability by overwriting handler entries with breakpoints, redirecting control to the debugger upon interrupt invocation; this technique, often combined with INT 3 (0xCC) opcodes for software breakpoints, allows real-time inspection of executing code in DOS-based or legacy environments.^[30]

Variations in Other Architectures

In ARM architectures, particularly in the widely used Cortex-M series for embedded systems, the exception vector table is positioned at a configurable base address, defaulting to 0x00000000 upon reset and relocatable via the Vector Table Offset Register (VTOR) to any 32-byte aligned address up to 0xFFFFFF80. This table typically includes 16 fixed entries for system exceptions (such as reset, non-maskable interrupt, and faults) plus additional slots for up to 240 device-specific interrupts, depending on the Nested Vectored Interrupt Controller (NVIC) configuration, with each entry storing a 32-bit handler address where the least significant bit is set to 1 to denote Thumb instruction set execution for efficient, direct branching without additional overhead.^[19] In contrast to more rigid CISC designs, this setup allows runtime relocation to support secure boot and memory protection in resource-constrained environments. The MIPS RISC architecture diverges by eschewing a conventional interrupt vector table in favor of fixed exception vector locations managed through Coprocessor 0 registers. General exceptions, including interrupts, vector to 0x80000180 in normal kernel mode or 0xBFC00180 in bootstrap mode (controlled by the BEV bit in the CP0 Status register), where the handler software examines the CP0 Cause register to demultiplex and dispatch to specific routines, mimicking vectoring via jumps rather than a pre-populated table.^[31] Reset and NMI exceptions always target the uncached address 0xBFC00000, ensuring reliable startup handling independent of memory mapping. RISC-V employs a flexible, relocatable trap vector table for interrupt handling, anchored by the machine trap vector base-address register (mtvec), which supports both direct and vectored modes. In vectored mode (indicated by mtvec[1:0] = 1), external and other machine-mode interrupts jump to addresses computed as mtvec base plus four times the exception cause code, resulting in direct jumps to handler code entry points at offsets of four times the exception cause code from the mtvec base, accommodating machine-mode and external interrupts via the Platform-Level Interrupt Controller (PLIC).^[32] The PLIC itself maps up to 1023 interrupt sources to unique IDs with configurable priorities, delivering them to cores for software-mediated vectoring, which enhances scalability in multi-hart systems. RISC architectures such as ARM, MIPS, and RISC-V generally prioritize indirect vectoring, relocatable tables, or fixed entry points over x86-style fixed tables to offer greater flexibility and reduced overhead in embedded and IoT applications, where memory constraints and real-time responsiveness are paramount. In hybrid ARM-based multi-core systems, the Generic Interrupt Controller (GIC) augments core vector tables by centralizing interrupt prioritization and routing from peripherals to processors, supporting shared and private interrupts without altering the underlying exception mechanism.^[33]

Modern Extensions and Alternatives

Interrupt Descriptor Table

The Interrupt Descriptor Table (IDT) represents an evolution from the real-mode Interrupt Vector Table (IVT), providing a more secure and flexible mechanism for interrupt and exception handling in x86 protected mode and long mode. Unlike the fixed 1 KB IVT in real mode, the IDT is a variable-sized array of up to 256 entries, each an 8-byte descriptor in protected mode (or 16 bytes in IA-32e mode), that replaces direct vector offsets with structured gate descriptors. These descriptors include a 32-bit (or 64-bit) offset to the handler code, a 16-bit segment selector referencing a code segment in the Global Descriptor Table (GDT) or Local Descriptor Table (LDT), and an 8-bit attributes field encompassing gate type, descriptor privilege level (DPL), and present bit (P). This design enables the processor to associate each interrupt vector (0-255) with a specific handler procedure or task, supporting protected-mode operations while maintaining compatibility with legacy interrupt semantics.^[28] The IDT is set up by the operating system kernel using the LIDT (Load Interrupt Descriptor Table Register) instruction, which loads the IDTR (Interrupt Descriptor Table Register) with the base linear address and 16-bit limit of the IDT in memory; this operation requires execution at current privilege level (CPL) 0 for security. In protected mode, the kernel configures individual entries as task gates (type 9; legacy and rarely used in modern systems), interrupt gates (type 14) that transfer control while clearing the interrupt flag (IF) to disable further interrupts, or trap gates (type 15) that preserve IF for non-masking behavior. In IA-32e (long) mode, only interrupt gates (type 14) and trap gates (type 15) are supported, as task gates are not permitted; modern operating systems have deprecated hardware task switching via task gates and Task State Segments (TSS) in favor of software-based context management. These gates are tailored to privilege levels, allowing the kernel to define handlers for hardware interrupts, software interrupts (e.g., INT n), and processor exceptions, with the IDT's limit determining the valid number of entries (typically 256 for full coverage).^[28] Key enhancements in the IDT provide robust security beyond the IVT's limitations, including ring protection to enforce privilege separation—where the DPL (0-3, with 0 most privileged) is checked against the CPL and requestor privilege level (RPL) to prevent lower-privilege code from invoking sensitive handlers, such as user-mode traps for debugging. The present bit (P) dynamically enables or disables entries (P=1 for valid, P=0 triggers a not-present fault #NP or general-protection fault #GP), allowing runtime management of interrupt availability without altering memory layouts. Additionally, the DPL field offers granular access control, ensuring that only code meeting the minimum privilege threshold can generate or service specific vectors, thereby mitigating unauthorized escalations. These features collectively enhance system integrity in multitasking environments.^[28] In practice, operating systems like Linux and Windows leverage the IDT to manage critical events; for instance, Linux configures IDT entries during boot to route legacy 32-bit system calls via INT 0x80 (vector 128, now largely superseded by the SYSENTER/SYSCALL instructions) and page faults via vector 14, with handlers in the kernel's trap initialization code.^[34] Similarly, Windows NT-based kernels populate the IDT at boot to dispatch interrupts and exceptions, including page faults (vector 14), to kernel-mode routines while using trap gates for user-mode interactions.^[35] The IDT supports up to 256 entries to cover all possible vectors, balancing comprehensive coverage with efficient memory use. For legacy compatibility, real-mode IVT functionality is emulated in virtual DOS machines through Virtual 8086 (V86) mode, where protected-mode code simulates the IVT's 1 KB structure at linear address 0x0000 for running 16-bit DOS applications without direct hardware access.^[28]

Handling in Virtualized Environments

In virtualized environments, the guest operating system's interrupt vector table—such as the x86 Interrupt Descriptor Table (IDT)—cannot directly interface with hardware interrupt controllers like the APIC, as this would compromise isolation between virtual machines (VMs). Instead, the hypervisor shadows the guest's IDT or intercepts modifications to it, typically via descriptor-table exiting controls in the Virtual Machine Control Structure (VMCS), to prevent unauthorized hardware access while emulating necessary behaviors. This shadowing maintains a hypervisor-controlled copy of the IDT, ensuring that interrupt vectors are resolved and delivered under VMM supervision without exposing physical resources.^[36] For Intel architectures employing VMX, virtual interrupts are injected during VM entries using the VMCS interruption-information field, which specifies the vector and type for delivery via the guest's shadowed IDT. The Virtual APIC page further enables hardware-assisted virtualization of interrupt state, including priority evaluation through registers like the Virtual Interrupt Status Register (VISR) and Virtual Priority (VPPR), allowing delivery without VM exits when the "virtual-interrupt delivery" control is enabled. In hypervisors such as KVM, Posted Interrupts—leveraging APICv—record pending interrupts in the Posted-Interrupt Descriptor and Virtual-APIC page, bypassing VM exits for low-latency delivery while the hypervisor manages nested interrupt priorities via Requesting Virtual Interrupt (RVI) and Servicing Virtual Interrupt (SVI) fields in the VMCS.^[36]^[37] Practical implementations illustrate these adaptations: VMware ESXi virtualizes the guest APIC through hardware-assisted emulation (e.g., via Intel VT-x), mapping host APIC operations to virtual vectors in the guest's interrupt controller to handle delivery efficiently. On ARM platforms, the GICv3 architecture supports virtualization via hardware-managed virtual CPU interfaces for interrupt signaling and prioritization, with the virtual distributor emulated in software by the hypervisor to route virtual interrupts to specific virtual Processing Elements (vPEs) without physical hardware exposure.^[38]^[39] These mechanisms enhance security by blocking guest attempts to escalate privileges through IVT manipulation, as all accesses trigger VM exits or are confined to shadowed structures; Extended Page Tables (EPT) provide additional isolation by enforcing second-stage memory translations that protect IDT pages and prevent cross-VM interference. In contemporary cloud infrastructures like AWS EC2, which employs the Nitro System for offloaded virtualization, optimized interrupt handling via such techniques supports high-performance, multi-tenant workloads with minimal overhead as of 2025.^[36]^[40]^[41]

References

[1]
Interrupt Vector Table - an overview | ScienceDirect Topics
The interrupt vector table is normally located in the first 1024 bytes of memory at addresses 000000H–0003FFH. It contains 256 different interrupt vectors. Each ...
[2]
[PDF] intel-8086_datasheet.pdf
A subroutine is vectored to via an interrupt vector lookup table located in system memory. It can be internally masked by software resetting the interrupt ...
[3]
Lecture 2 (January 19, 2000) - andrew.cmu.ed
The Interrupt Vector Table. The interrupt vector table maps interrupts to the service routines that handle them. This table has one entry for each interrupt.
[4]
Vector table - Arm Developer
In Arm Cortex-M processors, the vector table contains the starting addresses of each exception and interrupt.Missing: computer | Show results with:computer
[5]
Chapter 12: Interrupts
A vectored interrupt system employs separate connections for each device so that the computer can give automatic resolution. You can recognize a vectored ...
[6]
Sketch of PDP-8 Interrupts -- Mark Smotherman
Since there is only one entry point, the interrupt handler has to poll the I/O devices and clock to determine which one caused the interrupt. This was done by ...Missing: mechanism | Show results with:mechanism
[7]
[PDF] Systems Reference Library IBM System/360 Principles of Operation
The manual defines System/360 operating princi- ples, central processing unit, instructions, system con- trol panel, branching, status switching, interruption.Missing: vector | Show results with:vector
[8]
[PDF] Intel Microprocessors: 8008 to 8086 - SteveMorse.org
The 8080 has the identical interrupt mechanism the 8008 has, but in addition, it has instructions for enabling or disabling the interrupt mechanism. This ...
[9]
Reverse-engineering the interrupt circuitry in the Intel 8086 processor
Feb 21, 2023 · The diagram below shows how the vector table is implemented. Each of the 256 interrupt types has an entry holding the address of the interrupt ...
[10]
The MS-DOS Encyclopedia: Section V: System Calls - PCjs Machines
A vector in the interrupt vector table should never be changed directly. □ Before Function 25H is used to change an interrupt vector, the address of the ...
[11]
[PDF] 80286 - High-Performance Microprocessor with Memory ...
To prepare the 80286 for protected mode, the LIDT instruction is used to load the 24-bit interrupt table base and 16-bit limit for the protected mode interrupt ...
[12]
Interrupts — MSX Computer Magazine 51
In CP/M all 128 possible memory addresses are filled with the same value, so that all interrupts will end up at the same routine. Just to be sure, CP/M's ...
[13]
[PDF] Chapter 4 Introduction to UNIX Systems Programming
When an application program runs and invokes a system call like open() in user mode it generates a “software interrupt” to cross the user/kernel mode boundary.<|control11|><|separator|>
[14]
Intel® 64 and IA-32 Architectures Software Developer Manuals
Oct 29, 2025 · Overview. These manuals describe the architecture and programming environment of the Intel® 64 and IA-32 architectures.
[15]
[PDF] Intel® 64 and IA-32 Architectures Software Developer's Manual
NOTE: The Intel® 64 and IA-32 Architectures Software Developer's Manual consists of nine volumes: Basic Architecture, Order Number 253665; Instruction Set ...
[16]
https://developer.arm.com/documentation/ddi0403/d/System-Level-Architecture/System-Level-Programmers--Model/Exception-model/Vector-table
[17]
Documentation – Arm Developer
**Summary of ARM Vector Table (DDI0403)**
[18]
Interrupt Vector Table - OSDev Wiki
The Interrupt Vector Table (IVT) on x86 specifies addresses of 256 interrupt handlers, typically located at 0000:0000H, and is 400H bytes in size.
[19]
[PDF] 8051 Interrupt Vectors APNT_103 - Keil
Just look up the interrupt vector addresses specified in your data book and use the tables provided here to get the interrupt number to use in your interrupt ...
[20]
Vector table - Arm Cortex-M7 Devices Generic User Guide r1p2
For example, if you require 21 interrupts, the alignment must be on a 64-word boundary because the required table size is 37 words, and the next power of two ...
[21]
Proper Interrupt Vector Table Alignment in Synergy and SSP
Oct 21, 2020 · For example, if you require 21 interrupts, the alignment must be on a 64-word boundary because the required table size is 37 words, and the ...
[22]
https://wiki.osdev.org/Interrupts_Tutorial
[23]
Interrupts Tutorial - OSDev Wiki
In order to make use of interrupts, you need an IDT. When an interrupt is fired, the CPU uses the vector as an index into the IDT.
[24]
[PDF] 8259A PROGRAMMABLE INTERRUPT CONTROLLER ... - PDOS-MIT
INTA. 26. I. INTERRUPT ACKNOWLEDGE: This pin is used to enable 8259A interrupt-vector data onto the data bus by a sequence of interrupt acknowledge pulses ...
[25]
[PDF] 8259 is Programmable Interrupt Controller (PIC)
Then 8086 will send one more INTA pulse to 8259. • On this second interrupt acknowledge cycle, 8259 will send an interrupt vector byte of data to the CPU, which ...
[26]
[PDF] 8259A PROGRAMMABLE INTERRUPT CONTROLLER
In Non-Buffered Mode, this pin is used to specify whether 8259 is to act as a master or a slave. ... During the third interrupt acknowledge cycle, the ISR bit is ...
[27]
Introduction to Message-Signaled Interrupts - Windows drivers
Feb 21, 2025 · Message-signaled interrupts (MSIs) were introduced in the PCI 2.2 specification as an alternative to line-based interrupts.
[28]
[PDF] Intel® 64 and IA-32 Architectures Software Developer's Manual
... Interrupt Vector Table in Real-Address Mode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .15-7. Figure 15-3. Entering and Leaving Virtual ...
[29]
[PDF] Intel® 64 and IA-32 Architectures Software Developer's Manual
Intel technologies features and benefits depend on system configuration and may require enabled hardware, software, or service activation. Learn more at intel.
[30]
[PDF] Using SoftICE - Free
• Memory Breakpoints: SoftICE uses the x86 debug registers to break when a certain ... • Interrupt Breakpoints: SoftICE intercepts interrupts by modifying the IDT.
[31]
[PDF] 1 This section covers Exceptions. - MIPS
There is a bit in the status register called BEV (boot exception Vector) it is set by a power on, reset or NMI. Part of the boot process is to relocate the ...
[32]
[PDF] The RISC-V Instruction Set Manual - People @EECS
Nov 4, 2016 · 7 Platform-Level Interrupt Controller (PLIC). 65. 7.1 PLIC Overview ... A shift left can remove the interrupt bit and scale the exception codes to ...
[33]
Generic Interrupt Controller (GIC) - Arm Developer
A Generic Interrupt Controller (GIC) takes interrupts from peripherals, prioritizes them, and delivers them to the appropriate processor core.
[34]
!idt (WinDbg) - Windows drivers | Microsoft Learn
Apr 2, 2024 · The !idt extension displays the interrupt service routines (ISRs) for a specified interrupt dispatch table (IDT).Missing: kernel exceptions
[35]
[PDF] Intel® 64 and IA-32 Architectures Software Developer's Manual
NOTE: The Intel® 64 and IA-32 Architectures Software Developer's Manual consists of nine volumes: Basic Architecture, Order Number 253665; Instruction Set ...
[36]
[PDF] Enabling Optimized Interrupt/APIC Virtualization in KVM
• Process the virtual interrupts by recording them as pending on Virtual-APIC page. • Record virtual interrupts in Posted-Interrupt. Descriptor. − Clears ON ...
[37]
[PDF] Software and Hardware Techniques for x86 Virtualization - VMware
The virtual CPU has three features of interest: the virtual instruction set, the virtual memory management unit (MMU), and the virtual interrupt controller (PIC.
[38]
Learn the architecture - Generic Interrupt Controller v3 and v4 ...
This guide introduces the support for virtualization in the GICv3 and GICv4 architecture.
[39]
[PDF] Virtualization Technology for Directed I/O - Intel
Intel technologies may require enabled hardware, software or service activation. No product or component can be absolutely secure. Your costs and results may ...
[40]
AWS EC2 Virtualization 2017: Introducing Nitro - Brendan Gregg
Nov 29, 2017 · Improving interrupt performance has been described as the last battleground for hardware virtualization performance. As Anthony explained in ...