DOS编程：自定义中断程序的技术实现

1
2
3
4
5
6
7
8

#include <dos.h>

void interrupt my_service(union INTPACK far *regs) {
    // regs 里可以读到调用者传入的 AX/BX/CX/DX 等寄存器值
    if (regs->x.ax == 0x0001) {
        regs->x.bx = 12345;  // 通过修改寄存器返回结果
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

#include <dos.h>

void interrupt (*old_int_60h)();

void interrupt my_int_60h(union INTPACK far *regs) {
    switch (regs->x.ax) {
        case 0:
            printf("功能0被调用\n");
            break;
        case 1:
            regs->x.bx = 0x1234;  // 返回一个值
            break;
        default:
            // 不认识的功能号，转发给原处理程序（如果有的话）
            (*old_int_60h)();
    }
}

int main() {
    // INT 60h-66h 是 DOS 保留给用户程序自定义使用的中断号，不会跟系统冲突
    old_int_60h = getvect(0x60);
    setvect(0x60, my_int_60h);
    
    printf("自定义中断已安装，用 INT 60h 调用\n");
    
    // ...程序主体...
    
    setvect(0x60, old_int_60h);  // 退出前必须恢复
    return 0;
}

1
2
3

mov ax, 1        ; 功能号1
int 0x60         ; 调用自定义中断
mov result, bx   ; 读取返回值

1
2
3
4

union REGS regs;
regs.x.ax = 1;
int86(0x60, &regs, &regs);
int result = regs.x.bx;

1
2

主片：命令端口 0x20，数据端口 0x21
从片：命令端口 0xA0，数据端口 0xA1

1
2
3
4
5
6
7
8
9

#include <dos.h>

void interrupt my_irq_handler() {
    // 处理硬件事件（读端口、更新状态等）
    do_hardware_work();
    
    // 必须发送 EOI，否则后续中断被阻塞
    outportb(0x20, 0x20);  // 0x20 = 非特定 EOI 命令
}

1
2
3
4
5

void interrupt my_irq10_handler() {
    do_hardware_work();
    outportb(0xA0, 0x20);  // 先应答从片
    outportb(0x20, 0x20);  // 再应答主片
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

void enable_irq(int irq) {
    unsigned char mask;
    if (irq < 8) {
        mask = inportb(0x21);
        mask &= ~(1 << irq);  // 清零对应位=开启
        outportb(0x21, mask);
    } else {
        mask = inportb(0xA1);
        mask &= ~(1 << (irq - 8));
        outportb(0xA1, mask);
    }
}

void disable_irq(int irq) {
    unsigned char mask;
    if (irq < 8) {
        mask = inportb(0x21);
        mask |= (1 << irq);  // 置1对应位=屏蔽
        outportb(0x21, mask);
    } else {
        mask = inportb(0xA1);
        mask |= (1 << (irq - 8));
        outportb(0xA1, mask);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

#include <dos.h>

#define COM1_BASE 0x3F8
#define COM1_IER  (COM1_BASE + 1)  // 中断使能寄存器
#define COM1_LSR  (COM1_BASE + 5)  // 线路状态寄存器

void interrupt (*old_com1_handler)();

volatile unsigned char rx_buffer[256];
volatile unsigned char rx_head = 0, rx_tail = 0;

void interrupt com1_isr() {
    unsigned char data;
    
    // 检查是否有数据到达
    if (inportb(COM1_LSR) & 0x01) {
        data = inportb(COM1_BASE);  // 读取接收到的字节
        rx_buffer[rx_head++] = data;  // 存入环形缓冲区
    }
    
    outportb(0x20, 0x20);  // EOI
}

void init_com1_interrupt() {
    old_com1_handler = getvect(0x0C);  // IRQ4 = INT 0Ch
    setvect(0x0C, com1_isr);
    
    outportb(COM1_IER, 0x01);  // 使能"数据到达"中断
    enable_irq(4);              // 在 PIC 层面开启 IRQ4
}

void close_com1_interrupt() {
    disable_irq(4);
    outportb(COM1_IER, 0x00);
    setvect(0x0C, old_com1_handler);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

void interrupt my_handler() {
    // 1. 先做自己的事
    do_my_work();
    
    // 2. 再决定是否转发给原处理程序
    if (need_original_behavior) {
        (*old_handler)();   // 原处理程序里会自己处理 EOI
    } else {
        outportb(0x20, 0x20);  // 自己发 EOI（如果不转发）
    }
}

1
2
3

disable_irq(4);                 // 1. 先关闭硬件触发
outportb(COM1_IER, 0x00);       // 2. 关闭设备侧中断使能
setvect(0x0C, old_com1_handler); // 3. 最后恢复中断向量

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

#include <dpmi.h>
#include <go32.h>

_go32_dpmi_seginfo old_handler, new_handler;

void my_protected_handler() {
    // 保护模式下的处理逻辑
}

void install() {
    _go32_dpmi_get_protected_mode_interrupt_vector(0x0C, &old_handler);
    new_handler.pm_offset = (int)my_protected_handler;
    _go32_dpmi_chain_protected_mode_interrupt_vector(0x0C, &new_handler);
}