인터럽트와 트랩 이해

What are interrupts and traps? Think of them as urgent signals that tell your computer's CPU to pause what it's doing and pay attention to something more important.

These signals are crucial for how operating systems manage tasks, respond to hardware, and handle errors. Without them, your computer couldn't multitask or even react when you press a key!

Normally, the CPU executes instructions one after another in a steady flow. But what if the keyboard is pressed, or an error occurs?

Interrupts and traps are mechanisms that allow the CPU to temporarily halt its current task, handle the urgent event, and then resume its original work.

Hardware interrupts are external signals, generated by hardware devices, that demand the CPU's attention.

• They are asynchronous, meaning they can happen at any time, unrelated to the CPU's current instruction.
• Think of them as a doorbell ringing – the CPU stops what it's doing to answer.

These are everywhere! Here are a few common examples:

• Keyboard Press: When you type, the keyboard controller sends an interrupt.
• Mouse Movement: Moving your mouse triggers interrupts.
• Timer Interrupt: A special chip generates interrupts at regular intervals, allowing the OS to schedule tasks.
• Disk I/O: When data is ready from your hard drive, it signals the CPU.

Software interrupts are intentionally triggered by a running program using a special instruction (like INT in x86 assembly).

• They are synchronous, happening exactly when the instruction is executed.
• Programs use them to request services from the operating system, like reading a file or printing to the screen.

In x86 assembly, the INT instruction generates a software interrupt. Here, int 0x80 is used on Linux to call a system service (syscall) to exit the program.

Try running this simple assembly program:

Exceptions are another type of synchronous event, but they are triggered internally by the CPU itself when it detects an error or an unusual condition during instruction execution.

• They indicate that something went wrong with the current instruction or its data.
• Unlike hardware interrupts, they are directly tied to the execution flow.

Exceptions are categorized by how they affect program execution:

• Faults: An error that can often be corrected, allowing the program to restart the offending instruction (e.g., a page fault when trying to access memory not currently in RAM).
• Traps: An exception that is reported immediately after the instruction causing it has executed, allowing the program to continue (e.g., a debugger breakpoint).
• Aborts: Severe, unrecoverable errors that usually terminate the program (e.g., a critical hardware failure).

You've probably encountered these, even if you didn't know the name:

• Divide-by-Zero: Trying to divide a number by zero.
• Invalid Opcode: The CPU encounters an instruction it doesn't recognize.
• Page Fault: A program tries to access a memory address that isn't mapped or available.
• General Protection Fault (GPF): A program tries to access memory it doesn't have permission for, or performs a privileged operation incorrectly.

Let's clarify the main distinctions:

• Source: Hardware interrupts are external, software interrupts are program-initiated, exceptions are CPU-internal.
• Timing: Hardware interrupts are asynchronous; software interrupts and exceptions are synchronous.
• Purpose: Interrupts handle events (I/O, timers, OS calls); exceptions handle errors or special conditions.
• Correctability: Some exceptions (faults) are correctable, others (aborts) are not.

Which of the following scenarios describes a hardware interrupt?

In this lesson, we explored the critical mechanisms that allow a CPU to react to events and errors:

• Hardware Interrupts: External signals from devices (keyboard, timer).
• Software Interrupts: Program-initiated requests for OS services (e.g., INT instruction).
• Exceptions: Internal CPU errors or unusual conditions (e.g., divide-by-zero, page fault).

Understanding these helps you grasp how operating systems manage tasks and maintain stability at a low level.