int指令深度解析：从CPU中断机制到DOS系统调用

1. 为什么学int指令，不是背指令表，而是重建CPU的“中断意识”

“汇编语言（王爽版）学习笔记 第十三章 int指令”——这个标题在初学者眼里可能只是教材目录里一个带编号的章节，但在我带过几十个从零起步的嵌入式和系统编程学员后，我越来越确信： 第十三章不是知识增量，而是思维断层修复的关键节点 。很多人卡在这里不是因为看不懂 int 21h 怎么调用DOS功能，而是根本没建立起“CPU在什么情况下会主动停下当前任务、跳去执行另一段代码”这个底层直觉。王爽老师把int指令放在第十三章，恰恰是经过教学验证的节奏：前十二章铺垫了寄存器、内存寻址、栈、转移指令这些“CPU能做什么”的能力；而int指令第一次引入“CPU被外部事件强制干预”的概念——它不是程序员写的顺序逻辑，而是硬件与软件之间的一次契约。

你手头那本《汇编语言》翻到第十三章，看到的是一串 int 10h 、 int 21h 、 int 9h 的调用示例，但真正要吃透的，是这背后三层嵌套的机制：最外层是 程序员发出的软中断请求 （比如 int 21h ），中间层是 CPU硬件响应中断的固定流程 （保存现场、查中断向量表、跳转），最内层是 操作系统或BIOS预装的中断处理程序 （比如DOS的21h服务程序）。这三层缺一不可，而初学者常犯的错误，就是只记住了最外层的“调用格式”，却对中间层的硬件动作和最内层的服务逻辑完全脱节。结果就是：能照着书敲出打印字符串的代码，但一旦要求改写成从键盘读入再原样输出，就卡在不知道该清哪个标志位、该恢复哪些寄存器、为什么 iret 不能换成 ret 。

我见过太多人反复重学这一章，问题不在于“没看懂”，而在于“没动手拆解”。比如，书上说 int n 会把 CS:IP 压栈，但你有没有真的在DEBUG里单步执行过一条 int 21h ，然后用 r 命令观察SP、SS、CS、IP在执行前后的变化？有没有手动计算过中断向量表中 n*4 地址处存放的究竟是哪两个字？这些不是为了考试，而是为了把抽象描述变成肌肉记忆。当你在DEBUG里亲眼看到 CS:IP 被压入栈顶，再看到CPU从 0000:0084 （即21h*4）读出新的 CS:IP 并跳转过去，那种“啊，原来CPU真是这么干的”的顿悟感，比背十遍指令格式都管用。这一章的价值，从来不是教会你调用多少个DOS功能，而是让你第一次真正“看见”CPU如何在用户程序和系统服务之间切换上下文——这是所有现代操作系统调度、驱动开发、甚至安全漏洞利用的底层基石。

2. int指令的硬件级执行流程：从一条指令到四次内存访问

2.1 CPU执行int n的精确步骤链（以int 21h为例）

很多教程把int指令简化为“触发中断→查表→跳转”，但这掩盖了CPU内部真实发生的精密时序。我们以 int 21h 为例，完整还原CPU在执行这条指令时的每一步动作，包括所有隐含的寄存器操作和内存访问：

1. 取指与译码阶段完成 ：CPU已从代码段取出 int 21h 指令（机器码 CD 21 ），并确认这是软中断指令。

2. 自动压栈保存现场（关键！共4次内存写入） ：

   • 首先将 标志寄存器FLAGS 压入当前栈顶（ pushf 效果），这是为了在中断返回时能恢复IF（中断允许）等状态位；
   • 然后将 当前代码段寄存器CS 压栈；
   • 接着将 当前指令指针IP 压栈；

   • 注意：这三步压栈顺序是固定的（FLAGS→CS→IP），且由CPU硬件自动完成，程序员无法干预。压栈后SP自动减6（每个16位寄存器占2字节）。

3. 清除IF和TF标志位 ：

   • CPU硬件自动将FLAGS中的 IF（中断允许位）清零 ，防止在中断处理过程中被其他可屏蔽中断打断；
   • 同时将 TF（陷阱标志）清零 ，避免单步调试模式干扰中断处理；
   • 这一步不涉及内存访问，但直接影响后续中断嵌套行为。

4. 计算中断向量地址并读取（关键！2次内存读取） ：

   • CPU计算中断向量表地址： n * 4 = 21h * 4 = 84h ，即物理地址 0000:0084 ；
   • 从该地址开始连续读取 4个字节 ：低地址2字节为新IP值，高地址2字节为新CS值；

   • 提示：这就是为什么中断向量表必须位于内存最低1KB（0000:0000~0000:03FF），因为 n*4 最大为 FFh*4=3FCh ，仍在1KB范围内。

5. 加载新CS:IP并开始执行中断处理程序 ：

   • 将读出的2字节IP值送入IP寄存器；
   • 将读出的2字节CS值送入CS寄存器；
   • CPU开始从新的CS:IP处取指执行——此时控制权已完全移交至中断处理程序。

整个过程看似简单，实则包含 6次寄存器操作（FLAGS/CS/IP压栈+CS/IP加载）和6次内存访问（3次写+2次读+1次取指） 。其中最易被忽略的是第2步的压栈顺序和第3步的标志位清除——这直接决定了为什么中断处理程序开头必须用 pushf / popf 来保护/恢复FLAGS，也解释了为什么自己写的中断处理程序末尾必须用 iret 而非 ret （ iret 会自动弹出IP、CS、FLAGS，而 ret 只弹出IP、CS）。

2.2 中断向量表的物理布局与手工验证方法

中断向量表（IVT）是理解int指令的核心地图。它固定位于内存物理地址 00000h 开始的1024字节（256个中断号×4字节），每个中断号n占据4字节： [n*4] 和 [n*4+1] 存IP， [n*4+2] 和 [n*4+3] 存CS。以 int 21h 为例，其向量地址为 0000:0084 ，我们可以在DEBUG中亲手验证：

-a 100
1397:0100 mov ax,0
1397:0103 mov es,ax        ; 将ES指向0段（中断向量表所在段）
1397:0105 mov bx,84        ; BX=84h，即21h*4
1397:0108 mov ax,[es:bx]   ; 读取IP值（低地址2字节）
1397:010B mov dx,[es:bx+2] ; 读取CS值（高地址2字节）
1397:010F
-g=100 10F
AX=1234  BX=0084  CX=0000  DX=5678  SP=FFEE  BP=0000  SI=0000  DI=0000
DS=1397  ES=0000  SS=1397  CS=1397  IP=010F   NV UP EI PL NZ NA PO NC

执行后，AX中即为 int 21h 的IP值，DX中为CS值。在我的测试环境中，通常得到类似 AX=0000, DX=F000 的结果，对应BIOS的ROM区域。这个操作的意义在于：它把教科书上的“查表”变成了你指尖可触的内存数据。你会发现， int 10h （视频服务）的向量往往指向 C000:XXXX ，而 int 13h （磁盘服务）指向 E000:XXXX ——这些地址段正是BIOS固化代码的物理位置。这种亲手“挖”出向量的过程，比任何图示都更能建立对内存布局的直觉。

2.3 iret指令的不可替代性：为什么return不能代替return-from-interrupt

初学者常混淆 ret 和 iret ，认为“都是返回”，但在中断上下文中，这是生死攸关的区别。 ret 指令仅执行一次 pop IP （若带立即数则 pop IP 后 SP 再加立即数），而 iret 指令执行三次 pop ： pop IP → pop CS → pop FLAGS 。这个差异源于int指令压栈的三要素（FLAGS、CS、IP），因此中断返回必须严格逆序弹出。

我们用DEBUG做一个破坏性实验来证明：

-a 100
1397:0100 cli              ; 关中断，避免干扰
1397:0101 pushf            ; 手动压FLAGS（模拟int的部分动作）
1397:0102 push cs          ; 压CS
1397:0103 push ip          ; 压IP（注意：此时IP是0104，即下一条指令地址）
1397:0104 ret              ; 错误！用ret代替iret
1397:0105 mov ax,4c00      ; 程序退出
1397:0108 int 21h
-g=100 108

执行到 ret 时，CPU只弹出IP（0104），然后继续执行 mov ax,4c00 ，程序看似正常退出。但如果你在 ret 后插入 pop ax （模拟试图手动弹出CS），再 pop ax （模拟弹出FLAGS），就会发现AX的值完全不可预测——因为 ret 已经破坏了栈平衡。而 iret 是原子操作，它确保三要素按正确顺序、正确数量弹出。更关键的是， iret 弹出FLAGS时会重新加载IF位，如果中断处理程序中曾用 sti 开中断， iret 能保证IF位被正确恢复；而 ret 完全忽略FLAGS，导致中断状态丢失。这就是为什么所有标准中断处理程序模板都以 iret 结尾，没有例外。

3. DOS功能调用（int 21h）的实战解析：从“Hello World”到文件操作

3.1 功能号体系与AH寄存器的核心地位

int 21h 是DOS提供的“系统调用总入口”，其功能多样性完全由 AH寄存器的值 决定。AH就像一个功能选择旋钮，不同的数值对应不同的服务。王爽版教材重点讲解了几个常用功能，但实际DOS 2.x支持超过100个功能号，我们聚焦最核心的6个，它们覆盖了90%的初学者需求：

AH值	功能描述	关键参数	典型用途
02h	显示单个字符	DL=字符ASCII码	调试输出、简单提示
09h	显示字符串	DS:DX=字符串首地址（以'$'结尾）	主程序输出、菜单显示
01h	从键盘读取字符（带回显）	无输入参数，AL=读入字符	用户交互、暂停等待
07h	从键盘读取字符（无回显）	无输入参数，AL=读入字符	密码输入、游戏按键
3Dh	打开文件	AL=打开方式，DS:DX=文件名	文件读写准备
40h	写文件	BX=文件句柄，CX=写入字节数，DS:DX=缓冲区地址	保存数据、日志记录

注意：所有 int 21h 调用前，必须确保 DS寄存器正确指向数据段 。这是初学者最高频的错误——忘记 mov ax, data mov ds, ax ，导致 int 21h 读取字符串时访问错误内存，程序崩溃或输出乱码。

3.2 “Hello World”的深度拆解：不止于抄代码

教材中的“Hello World”示例通常如下：

data segment
    msg db 'Hello, World!$'
data ends

code segment
    assume cs:code, ds:data
start:
    mov ax, data
    mov ds, ax
    mov dx, offset msg
    mov ah, 09h
    int 21h
    mov ah, 4ch
    int 21h
code ends
end start

这段代码能运行，但隐藏了三个关键细节：

1. 字符串结束符'$'的强制性 ： int 21h 功能09h要求字符串以 $ 结尾，而不是C语言的 \0 。这是因为DOS设计时采用 $ 作为字符串终止标记，硬件层面无 \0 概念。如果你写成 msg db 'Hello, World!',0 ，程序会一直输出直到遇到内存中偶然的 $ ，造成严重越界。

2. offset操作符的不可替代性 ： mov dx, offset msg 获取的是 msg 在数据段内的偏移地址。如果错误地写成 mov dx, msg ，汇编器会尝试将 msg 处的字节值（如'H'的ASCII 48h）当作地址载入DX，导致 int 21h 去读取 DS:48h 处的内存，必然失败。 offset 是获取地址的唯一安全方式。

3. 程序退出的双重保障 ： mov ah, 4ch int 21h 是DOS推荐的退出方式，它会清理程序占用的内存并返回控制权给DOS。相比之下，简单的 mov ax, 4c00h int 21h （AH=4Ch, AL=00h）是等效的，但明确分开AH和AL更清晰。切忌用 ret 或 jmp 退出，这会导致DOS环境混乱。

我建议初学者在DEBUG中单步执行这段代码，重点关注 int 21h 执行前后 DS 、 DX 、 AH 的值，以及 int 21h 内部是否真的从 DS:DX 开始读取到了 H 、 e 、 l ...直到 $ 。这种“跟踪到内存细胞”的习惯，是区分“会写”和“真懂”的分水岭。

3.3 文件操作的完整闭环：从创建、写入到关闭

int 21h 的文件操作功能（3Dh/40h/3Eh）是本章难度跃升点，它首次引入了“句柄（Handle）”概念——一个由DOS分配的16位整数，作为文件在内存中的唯一标识。我们以创建并写入一个文本文件为例，构建完整流程：

data segment
    filename db 'test.txt',0    ; 注意：DOS文件名必须是8.3格式，且用0结尾
    buffer db 'This is a test file.$'
    handle dw ?                 ; 存储文件句柄
data ends

code segment
    assume cs:code, ds:data
start:
    mov ax, data
    mov ds, ax
    
    ; 步骤1：打开/创建文件（AL=01h表示只写，若不存在则创建）
    mov ah, 3Dh
    mov al, 01h               ; 只写模式
    mov dx, offset filename
    int 21h
    jc error_open             ; 若CF=1，表示打开失败
    mov handle, ax            ; AX返回文件句柄
    
    ; 步骤2：写入数据（BX=句柄，CX=字节数，DS:DX=缓冲区）
    mov bx, handle
    mov cx, 22                ; buffer长度（含'$'）
    mov dx, offset buffer
    mov ah, 40h
    int 21h
    jc error_write
    
    ; 步骤3：关闭文件（BX=句柄）
    mov bx, handle
    mov ah, 3Eh
    int 21h
    jc error_close
    
    jmp exit
    
error_open:
    ; 处理打开错误（如磁盘满、路径错）
    mov dx, offset err_msg1
    mov ah, 09h
    int 21h
    jmp exit
    
error_write:
    mov dx, offset err_msg2
    mov ah, 09h
    int 21h
    jmp exit
    
error_close:
    mov dx, offset err_msg3
    mov ah, 09h
    int 21h
    
exit:
    mov ah, 4ch
    int 21h

err_msg1 db 'Open file error!$'
err_msg2 db 'Write file error!$'
err_msg3 db 'Close file error!$'
code ends
end start

这个例子揭示了文件操作的三个铁律：

• 句柄是生命线 ：所有后续操作（读、写、关闭）都依赖第一步返回的句柄值。如果忘记保存 ax 到 handle ，后续操作将使用垃圾值，必然失败。
• 长度计算必须精确 ： int 21h 功能40h的CX参数是 实际要写入的字节数 ，不是字符串长度。 buffer 中 $ 是DOS显示用的，写入文件时不应包含。因此 cx 应为21（"This is a test file."共21字符），而非22。我在实际调试中曾因多写一个字节，导致文件末尾出现乱码。
• 错误检查是刚需 ： int 21h 执行后， 必须检查CF（进位标志） 。CF=1表示操作失败，此时AX中会返回错误代码（如2=文件未找到，3=路径未找到，5=拒绝访问）。忽略CF检查是程序健壮性的最大漏洞。

4. 自定义中断处理程序：从理论到可运行的键盘监控Demo

4.1 中断向量的修改原理与风险控制

自定义中断处理程序是本章的巅峰实践，它要求你不仅理解int指令如何被CPU执行，还要掌握如何“劫持”这个流程。核心思想是：修改中断向量表中某个中断号（如 int 9h ，键盘中断）对应的CS:IP，使其指向你自己编写的处理程序。但这是高危操作，必须严格遵循三原则：

1. 备份原向量 ：修改前必须读取并保存原CS:IP值，以便恢复。否则系统将永久失灵。
2. 处理程序必须可重入 ：键盘中断可能在任何时刻发生，你的代码必须短小、不依赖全局变量、不调用不可重入的DOS函数（如 int 21h ）。
3. 最后必须调用原处理程序 ：你的代码处理完后，应跳转回原CS:IP，让DOS完成标准的键盘扫描码转换和缓冲区写入。否则键盘将“失声”。

我们以 int 9h （硬件键盘中断）为例，编写一个监控按键的Demo。首先，备份原向量：

; 备份int 9h原向量
mov ax, 0
mov es, ax
mov bx, 9*4          ; int 9h向量地址=0000:0024
cli                  ; 关中断，防止修改过程中被触发
mov ax, word ptr es:[bx]     ; 读取原IP
mov old_ip, ax
mov ax, word ptr es:[bx+2]   ; 读取原CS
mov old_cs, ax

提示： cli 在此处至关重要。如果在读取IP和CS之间恰好发生一次键盘中断，CPU会跳转到未知地址，导致死机。 cli 暂时禁止所有可屏蔽中断，确保原子性。

4.2 键盘中断处理程序的编写要点

int 9h 处理程序必须满足严苛条件：它运行在中断上下文中，没有DOS环境支持，所有操作必须基于硬件端口。核心步骤如下：

1. 读取键盘扫描码 ：从I/O端口 60h 读取8位扫描码（按下为通码，释放为断码）。
2. 发送EOI（End of Interrupt） ：向主PIC（可编程中断控制器）端口 20h 写入 20h ，通知其本次中断处理完毕，否则键盘将不再触发新中断。
3. 调用原处理程序 ：跳转回备份的CS:IP，让DOS完成后续工作。

一个精简可靠的处理程序框架如下：

; 自定义int 9h处理程序（必须放在代码段中，且不能有数据）
new_int9 proc far
    push ax
    push bx
    push cx
    push dx
    push ds
    push es
    
    ; 步骤1：读取扫描码
    in al, 60h           ; 从60h端口读取扫描码到AL
    
    ; 步骤2：发送EOI给PIC
    mov al, 20h
    out 20h, al
    
    ; 步骤3：此处可添加你的监控逻辑
    ; 例如：检测ESC键（扫描码01h）并计数
    cmp al, 01h
    jne skip_count
    inc key_count
    
skip_count:
    ; 步骤4：调用原int 9h处理程序
    pop es
    pop ds
    pop dx
    pop cx
    pop bx
    pop ax
    jmp dword ptr cs:old_int9_addr  ; 注意：必须用jmp far，不能用call
    
new_int9 endp

; 存储原向量的变量（必须在数据段）
old_ip dw ?
old_cs dw ?
key_count dw 0
old_int9_addr dw old_ip, old_cs  ; 构造far pointer

关键细节： jmp dword ptr cs:old_int9_addr 是调用原程序的正确方式。 cs:old_int9_addr 是一个双字（4字节）变量，前2字节是IP，后2字节是CS， jmp far 指令会一次性加载这两个值。如果错误地用 call ，会导致栈被污染，因为 call 会压入返回地址，而原处理程序末尾的 iret 会尝试弹出这个错误地址。

4.3 安装与卸载的完整流程及DEBUG验证

安装自定义中断处理程序需要三步：将处理程序代码复制到安全内存区（如 0000:0400 ）、修改中断向量表、开中断。卸载则需恢复原向量。以下为完整流程：

; 安装程序
install proc
    ; 将new_int9代码复制到0000:0400（安全的高端内存区）
    mov ax, 0
    mov es, ax
    mov di, 400h
    push cs
    pop ds
    mov si, offset new_int9
    mov cx, new_int9_end - new_int9
    cld
    rep movsb
    
    ; 修改int 9h向量指向0000:0400
    mov bx, 9*4
    mov word ptr es:[bx], 400h    ; 新IP = 400h
    mov word ptr es:[bx+2], 0     ; 新CS = 0
    
    sti                          ; 开中断，生效
    ret
install endp

; 卸载程序（恢复原向量）
uninstall proc
    cli
    mov ax, 0
    mov es, ax
    mov bx, 9*4
    mov word ptr es:[bx], old_ip
    mov word ptr es:[bx+2], old_cs
    sti
    ret
uninstall endp

在DEBUG中验证安装是否成功：

-d 0:24 0:27          ; 查看int 9h向量（0000:0024-0000:0027）
0000:0020                    00 00 00 00 00 00 00 00
; 初始状态：全0
-a 100
1397:0100 mov ax,0
1397:0103 mov es,ax
1397:0105 mov word ptr es:[24],400
1397:010A mov word ptr es:[26],0
1397:010F
-g=100 10F
-d 0:24 0:27          ; 再次查看
0000:0020                    00 04 00 00 00 00 00 00
; 已修改为0000:0400

此时按任意键，你的处理程序就会执行。你可以通过 d cs:offset key_count 随时查看计数值。这个过程让你彻底明白：所谓“中断”，就是CPU在特定硬件信号下，对内存中一个固定地址的无条件跳转——它不神秘，只是可编程的电路行为。

5. 常见问题与排查技巧实录：那些书上不会写的坑

5.1 “程序运行后黑屏/死机”的五大根源与定位法

黑屏或死机是int指令相关实验的最高频故障，原因往往不在代码逻辑，而在环境配置和硬件交互细节。根据我指导学员的实录，整理出五大根源及快速定位法：

现象	最可能原因	快速定位法	解决方案
刚执行int 21h就死机	DS寄存器未初始化	在 int 21h 前加 r ds ，检查DS值是否等于 data 段地址	严格添加 mov ax, data mov ds, ax
输出乱码或不显示	字符串未以 $ 结尾，或 $ 位置错误	用 d ds:dx 查看 DS:DX 指向的内存，确认 $ 在正确位置	检查 msg db 'xxx$' ，确保 $ 是最后一个字节
键盘无响应（int 9h失效）	未发送EOI（ out 20h, al ）	在处理程序中 in al,60h 后立即 out 20h,al ，再测试	EOI是强制要求，漏掉则PIC锁死
自定义中断后系统崩溃	修改向量时未 cli ，或恢复时未 sti	在修改向量前后加 r flags ，确认IF位在修改时为0	cli 修改， sti 恢复，形成原子操作
文件操作返回错误代码5	当前目录无写入权限，或磁盘写保护	在DOS下用 dir 确认当前路径，用 attrib -r filename 取消只读	确保目标路径可写，文件名符合8.3格式

实操心得：当遇到黑屏，第一时间在DEBUG中用 u cs:ip 反汇编当前IP处的指令，看是否跳转到了非法地址（如 FFFF:0000 ）。如果是，则问题出在中断向量被意外修改；如果不是，则问题在 int 21h 参数设置。

5.2 DEBUG单步调试int指令的黄金组合键

DEBUG是理解int指令的终极武器，但新手常不知如何高效使用。以下是针对int指令调试的黄金组合：

• t （Trace）单步执行 ：执行 int 21h 时， t 会进入 int 21h 内部，让你看到DOS服务程序的每一步。但DOS代码复杂，容易迷失， 慎用 。
• p （Proceed）步入 ：执行 int 21h 时， p 会将整个 int 21h 视为一个“原子操作”，执行完后停在下一条指令。这是 最推荐的方式 ，用于验证功能是否成功。
• r （Register）实时监控 ：在 int 21h 前后执行 r ，重点关注 AX （返回值）、 FLAGS （CF位）、 SP （栈顶变化）。例如， int 21h 后 AX=0000 且 CF=0 ，表示文件打开成功。
• d （Dump）内存窥探 ：用 d ds:dx 查看字符串内容，用 d 0:24 查看中断向量，用 d ss:sp 查看栈内容。这是验证“CPU到底读了什么”的唯一方法。
• a （Assemble）动态修补 ：如果发现某条指令写错（如 mov ah,02h 误写为 mov ah,03h ），可用 a 直接在内存中修改，无需重新汇编链接。

我建议初学者养成“三步调试法”： int 21h 前 r 看参数→ p 执行→ r 和 d 看结果。坚持一周，对寄存器和内存的敏感度会质变。

5.3 王爽版教材习题的典型误区解析

王爽版第十三章习题（如检测按键、修改中断向量）是检验理解深度的试金石，但常见误区极具迷惑性：

• 习题13.3（编写程序，按F1键显示字符串） ：
  误区：直接在 int 9h 处理程序中调用 int 21h 显示字符串。
  正解： int 9h 运行在中断上下文，DOS服务不可用。正确做法是设置一个标志位（如 f1_pressed db 0 ），在主程序循环中检测该标志，为1则调用 int 21h 显示。

• 习题13.5（安装自己的int 9h，实现按左Shift+右Shift退出） ：
  误区：认为只需检测扫描码 2A （左Shift）和 36 （右Shift），忽略它们的释放码 AA 和 B6 。
  正解：必须维护一个“Shift键状态寄存器”，在通码时置位，断码时清位，只有当两个位同时为1时才触发退出。

• 习题13.7（修改int 1ch，实现定时器监控） ：
  误区：在 int 1ch 处理程序中直接修改屏幕，导致画面撕裂。
  正解： int 1ch 是DOS空闲定时器，每秒18.2次，但它的处理程序必须极短。应只更新一个计数器变量，主程序在 int 21h 调用间隙读取该变量并刷新屏幕。

这些习题的设计意图，从来不是考察你能否写出代码，而是考察你是否真正理解了“中断上下文”与“用户上下文”的隔离边界。跨过这个边界，就是系统崩溃；守住这个边界，就是稳定运行。

6. 从DOS到现代：int指令思维在当代开发中的映射

6.1 系统调用（syscall）——int 21h在Linux/Windows中的继承

虽然现代操作系统早已弃用 int 21h ，但其核心思想—— 用户程序通过软中断请求内核服务 ——从未改变。在Linux中， int 0x80 （x86）或 syscall 指令（x64）扮演了 int 21h 的角色；在Windows中， int 0x2E （旧）或 syscall （新）是用户态进入内核态的桥梁。区别仅在于接口更复杂、保护更严格：

• 功能号迁移 ： int 21h 的AH=09h（显示字符串）在Linux x86中变为 eax=4 （sys_write），参数通过 ebx （文件描述符）、 ecx （缓冲区地址）、 edx （长度）传递。
• 内存保护强化 ：现代CPU有特权级（Ring 0/3），用户程序（Ring 3）无法直接访问硬件或内核内存， int 指令是唯一被允许的“降级”通道。
• 向量表进化 ：IDT（中断描述符表）取代了简单的IVT，每个表项包含段选择子、偏移、特权级等，安全性大幅提升。

我让学员用NASM重写一个Linux下的“Hello World”，对比DOS版本，他们立刻体会到： int 0x80 的调用约定（ eax 功能号、 ebx/edx/ecx 参数）与 int 21h （ ah 功能号、 dx/cx/bx 参数）如出一辙。这种跨越三十年的架构一致性，印证了王爽版教材的价值——它教的不是过时的DOS，而是操作系统最底层的通用范式。

6.2 驱动开发与安全研究中的中断思维

在更专业的领域，int指令的思维是基石：

• 设备驱动 ：编写USB或网卡驱动时，必须注册中断处理程序（ISR）。当硬件发出IRQ信号，CPU执行 int n ，跳转至你的ISR。这与 int 9h 监控键盘的逻辑完全一致，只是n由PCI配置空间决定。
• Rootkit技术 ：一些内核级木马通过Hook IDT，将`