x86内核中的键盘IRQ

Question

我希望通过编写一个非常简单的内核来学习。在阅读了大量关于PIC和x86架构中IRQ的文章后，我发现IRQ1是键盘处理程序。我正在使用以下代码打印所按下的键：

#include "port_io.h"

#define IDT_SIZE 256
#define PIC_1_CTRL 0x20
#define PIC_2_CTRL 0xA0
#define PIC_1_DATA 0x21
#define PIC_2_DATA 0xA1

void keyboard_handler();
void load_idt(void*);

struct idt_entry
{
    unsigned short int offset_lowerbits;
    unsigned short int selector;
    unsigned char zero;
    unsigned char flags;
    unsigned short int offset_higherbits;
};

struct idt_pointer
{
    unsigned short limit;
    unsigned int base;
};

struct idt_entry idt_table[IDT_SIZE];
struct idt_pointer idt_ptr;

void load_idt_entry(char isr_number, unsigned long base, short int selector, char flags)
{
    idt_table[isr_number].offset_lowerbits = base & 0xFFFF;
    idt_table[isr_number].offset_higherbits = (base >> 16) & 0xFFFF;
    idt_table[isr_number].selector = selector;
    idt_table[isr_number].flags = flags;
    idt_table[isr_number].zero = 0;
}

static void initialize_idt_pointer()
{
    idt_ptr.limit = (sizeof(struct idt_entry) * IDT_SIZE) - 1;
    idt_ptr.base = (unsigned int)&idt_table;
}

static void initialize_pic()
{
    /* ICW1 - begin initialization */
    write_port(PIC_1_CTRL, 0x11);
    write_port(PIC_2_CTRL, 0x11);

    /* ICW2 - remap offset address of idt_table */
    /*
    * In x86 protected mode, we have to remap the PICs beyond 0x20 because
    * Intel have designated the first 32 interrupts as "reserved" for cpu exceptions
    */
    write_port(PIC_1_DATA, 0x20);
    write_port(PIC_2_DATA, 0x28);

    /* ICW3 - setup cascading */
    write_port(PIC_1_DATA, 0x00);
    write_port(PIC_2_DATA, 0x00);

    /* ICW4 - environment info */
    write_port(PIC_1_DATA, 0x01);
    write_port(PIC_2_DATA, 0x01);
    /* Initialization finished */

    /* mask interrupts */
    write_port(0x21 , 0xff);
    write_port(0xA1 , 0xff);
}

void idt_init()
{
    initialize_pic();
    initialize_idt_pointer();
    load_idt(&idt_ptr);
}

load_idt只是使用了x86指令lidt。之后我加载了键盘处理程序:

void kmain(void)
{
    //Using grub bootloader..
    idt_init();
    kb_init();
    load_idt_entry(0x21, (unsigned long) keyboard_handler, 0x08, 0x8e);
}

这是实现代码：

#include "kprintf.h"
#include "port_io.h"
#include "keyboard_map.h"

void kb_init(void)
{
    /* 0xFD is 11111101 - enables only IRQ1 (keyboard)*/
    write_port(0x21 , 0xFD);
}

void keyboard_handler(void)
{
    unsigned char status;
    char keycode;
    char *vidptr = (char*)0xb8000;  //video mem begins here.
    /* Acknownlegment */

    int current_loc = 0;
    status = read_port(0x64);
    /* Lowest bit of status will be set if buffer is not empty */
    if (status & 0x01) {
        keycode = read_port(0x60);
        if(keycode < 0)
            return;
        vidptr[current_loc++] = keyboard_map[keycode];
        vidptr[current_loc++] = 0x07;
    }

    write_port(0x20, 0x20);
}

这是我使用的额外代码：

section .text

global load_idt
global keyboard_handler

extern kprintf
extern keyboard_handler_main

load_idt:
    sti
    mov edx, [esp + 4]
    lidt [edx]
    ret

global read_port
global write_port

; arg: int, port number.
read_port:
    mov edx, [esp + 4]
    in al, dx   
    ret

; arg: int, (dx)port number
;      int, (al)value to write
write_port:
    mov   edx, [esp + 4]    
    mov   al, [esp + 4 + 4]  
    out   dx, al  
    ret

这是我的入口点：

bits 32
section .text
;grub bootloader header
        align 4
        dd 0x1BADB002            ;magic
        dd 0x00                  ;flags
        dd - (0x1BADB002 + 0x00) ;checksum. m+f+c should be zero

global start
extern kmain            

start:
;  cli          ;block interrupts
  mov esp, stack_space  ;set stack pointer
  call kmain
  hlt           ;halt the CPU

section .bss
resb 8192       ;8KB for stack
stack_space:

我正在使用QEMU运行内核：

qemu-system-i386 -kernel kernel

问题是屏幕上没有显示任何字符。相反，我仍然得到相同的输出：

SeaBIOS (version Ubuntu-1.8.2-1-ubuntu1)
Booting from ROM...

我该如何解决这个问题？有什么建议吗？

- Delights

---

那么，哪部分代码没有按预期执行？keyboard_handler是否被执行过？read_port(0x64)是否表示缓冲区为空？从端口0x60读取的值是否为负数？ - Tsyvarev

QEMU可以通过GDB进行调试（使用远程调试）。在SO答案中，我提供了一些关于如何在_GDB下远程调试QEMU_的信息。 - Michael Petch

@MichaelPetch 是的，我认为我做了。在我的汇编入口点中使用了“sti”。 - Delights

@MichaelPetch，我添加了我使用的所有代码，那基本上就是我的整个“内核”。 - Delights

@MichaelPetch嗯，我做到了，但问题仍然存在。每当我点击一个键（任何键），打印的缓冲区就会突然“刷新”。有一个黑屏闪现一毫秒，然后通常的BIOS输出又回来了。也许这是个线索？此外，我可以使用自己的打印函数进行打印，并且它会阻止BIOS输出，直到我点击一个随机键。 - Delights

Answer 1

你的代码存在一些问题。以下是主要问题的逐个讨论。

---

HLT指令将停止当前CPU，等待下一个中断。此时已启用中断。在第一个中断(按键)之后，HLT后的代码将执行。它将开始执行内存中的任意随机数据。您可以修改kmain以使用HLT指令进行无限循环。类似这样的东西应该可以工作：

while(1) __asm__("hlt\n\t");

---

在这段代码中：

load_idt:
    sti
    mov edx, [esp + 4]
    lidt [edx]
    ret

通常情况下，在更新中断表之后再使用 STI 是更好的选择，而不是在更新之前。以下是更好的方式：

load_idt:
    mov edx, [esp + 4]
    lidt [edx]
    sti
    ret

---

Your interrupt handler需要执行iretd以正确从中断返回。您的函数keyboard_handler将执行ret以返回。要解决此问题，您可以创建一个汇编包装器，调用C keyboard_handler函数，然后执行IRETD。

在NASM汇编文件中，您可以定义一个名为keyboard_handler_int的全局函数，如下所示：

extern keyboard_handler
global keyboard_handler_int

keyboard_handler_int:
    call keyboard_handler
    iretd

设置IDT条目的代码如下：

load_idt_entry(0x21, (unsigned long) keyboard_handler_int, 0x08, 0x8e);

---

你的kb_init函数最终通过掩码启用了键盘中断。不幸的是，在启用该中断之后，你设置了键盘处理程序。在将条目放入IDT之前，可能会按下按键。一个快速的解决方法是在调用kb_init之前设置键盘处理程序，例如：

void kmain(void)
{
    //Using grub bootloader..
    idt_init();
    load_idt_entry(0x21, (unsigned long) keyboard_handler_int, 0x08, 0x8e);
    kb_init();
    while(1) __asm__("hlt\n\t");
}

---

导致内核三次故障（并有效地重新启动虚拟机）的最严重问题可能是您定义了idt_pointer结构的方式。您使用了：

struct idt_pointer
{
    unsigned short limit;
    unsigned int base;
};

问题在于默认对齐规则会在limit和base之间添加2个字节的填充，以使unsigned int在结构体内部以4字节的偏移量对齐。要更改此行为并在不填充数据的情况下打包数据，您可以在结构体上使用__attribute__((packed))。定义如下：

struct idt_pointer
{
    unsigned short limit;
    unsigned int base;
} __attribute__((packed));

这种方法的好处是在limit和base之间没有多余字节用于对齐。如果不能有效地处理对齐问题，则会导致base地址错误地放置在结构中。 IDT指针需要一个16位值来表示IDT的大小，紧随其后的是一个32位值，表示IDT的基地址。

有关结构对齐和填充的更多信息可以在Eric Raymond的blogs中找到。由于struct idt_entry成员的排列方式，没有额外的填充字节。如果您创建的结构体不希望填充，请使用__attribute__((packed));。当您将C数据结构与系统定义的结构进行映射时，通常情况下都是如此。考虑到这一点，我建议为了清晰起见，也要对struct idt_entry进行压缩。

---

其他考虑事项

在中断处理程序中，尽管我建议使用IRETD，但还有另一个问题。随着内核的增长和添加更多中断，你会发现另一个问题。你的内核可能会表现异常，并且寄存器的值可能会意外地改变。问题在于作为中断处理程序的C函数将破坏某些寄存器的内容，但我们没有保存和恢复它们。其次，根据32位ABI，在调用函数之前必须清除（CLD）方向标志。不能假定在进入中断例程时方向标志已被清除。ABI说：

EFLAGS 标志寄存器包含系统标志，例如方向标志和进位标志。在进入和退出函数时，必须将方向标志设置为“向前”（即零）。其他用户标志在标准调用序列中没有指定的角色，并且不会被保留。

你可以逐个推送所有易失寄存器，但为了简洁起见，你可以使用PUSHAD和POPAD指令。如果中断处理程序如下所示，则会更好：

keyboard_handler_int:
    pushad                 ; Push all general purpose registers
    cld                    ; Clear direction flag (forward movement)
    call keyboard_handler
    popad                  ; Restore all general purpose registers
    iretd                  ; IRET will restore required parts of EFLAGS
                           ;   including the direction flag

如果您手动保存和恢复所有易失性寄存器，您需要保存和恢复EAX、ECX和EDX，因为它们不需要在C函数调用之间保留。通常不建议在中断处理程序中使用x87 FPU指令（主要是为了性能），但如果您这样做，还需要保存和恢复x87 FPU状态。

---

样例代码

由于您没有提供完整的示例，因此我填补了一些空缺（包括简单的键盘映射）并对您的键盘处理程序进行了轻微修改。改进后的键盘处理程序仅显示按键按下事件，并跳过没有映射的字符。在所有情况下，代码都会掉入处理程序的末尾，以便向 PIC 发送一个 EOI（中断结束）。当前光标位置是一个静态整数，它将保留其值跨越中断调用。这允许位置在每个字符按下之间前进。

我的kprintd.h文件为空，我将所有汇编原型放入了您的port_io.h中。原型应该适当地分成多个标题。我只是这样做是为了减少文件数量。我的lowlevel.asm文件定义了所有低级汇编例程。最终代码如下：

kernel.asm:

bits 32
section .text
;grub bootloader header
        align 4
        dd 0x1BADB002            ;magic
        dd 0x00                  ;flags
        dd - (0x1BADB002 + 0x00) ;checksum. m+f+c should be zero

global start
extern kmain

start:
    lgdt [gdtr]                 ; Load our own GDT, the GDTR of Grub may be invalid

    jmp CODE32_SEL:.setcs       ; Set CS to our 32-bit flat code selector
.setcs:
    mov ax, DATA32_SEL          ; Setup the segment registers with our flat data selector
    mov ds, ax
    mov es, ax
    mov fs, ax
    mov gs, ax
    mov ss, ax
    mov esp, stack_space        ; set stack pointer

    call kmain

; If we get here just enter an infinite loop
endloop:
    hlt                         ; halt the CPU
    jmp endloop

; Macro to build a GDT descriptor entry
%define MAKE_GDT_DESC(base, limit, access, flags) \
    (((base & 0x00FFFFFF) << 16) | \
    ((base & 0xFF000000) << 32) | \
    (limit & 0x0000FFFF) | \
    ((limit & 0x000F0000) << 32) | \
    ((access & 0xFF) << 40) | \
    ((flags & 0x0F) << 52))

section .data
align 4
gdt_start:
    dq MAKE_GDT_DESC(0, 0, 0, 0); null descriptor
gdt32_code:
    dq MAKE_GDT_DESC(0, 0x00ffffff, 10011010b, 1100b)
                                ; 32-bit code, 4kb gran, limit 0xffffffff bytes, base=0
gdt32_data:
    dq MAKE_GDT_DESC(0, 0x00ffffff, 10010010b, 1100b)
                                ; 32-bit data, 4kb gran, limit 0xffffffff bytes, base=0
end_of_gdt:

gdtr:
    dw end_of_gdt - gdt_start - 1
                                ; limit (Size of GDT - 1)
    dd gdt_start                ; base of GDT

CODE32_SEL equ gdt32_code - gdt_start
DATA32_SEL equ gdt32_data - gdt_start

section .bss
resb 8192                       ; 8KB for stack
stack_space:

lowlevel.asm:

section .text

extern keyboard_handler
global read_port
global write_port
global load_idt
global keyboard_handler_int

keyboard_handler_int:
    pushad
    cld
    call keyboard_handler
    popad
    iretd

load_idt:
    mov edx, [esp + 4]
    lidt [edx]
    sti
    ret

; arg: int, port number.
read_port:
    mov edx, [esp + 4]
    in al, dx
    ret

; arg: int, (dx)port number
;      int, (al)value to write
write_port:
    mov   edx, [esp + 4]
    mov   al, [esp + 4 + 4]
    out   dx, al
    ret

port_io.h:

extern unsigned char read_port (int port);
extern void write_port (int port, unsigned char val);
extern void kb_init(void);

kprintf.h:

/* Empty file */

keyboard_map.h:

unsigned char keyboard_map[128] =
{
    0,  27, '1', '2', '3', '4', '5', '6', '7', '8',     /* 9 */
  '9', '0', '-', '=', '\b',     /* Backspace */
  '\t',                 /* Tab */
  'q', 'w', 'e', 'r',   /* 19 */
  't', 'y', 'u', 'i', 'o', 'p', '[', ']', '\n', /* Enter key */
    0,                  /* 29   - Control */
  'a', 's', 'd', 'f', 'g', 'h', 'j', 'k', 'l', ';',     /* 39 */
 '\'', '`',   0,                /* Left shift */
 '\\', 'z', 'x', 'c', 'v', 'b', 'n',                    /* 49 */
  'm', ',', '.', '/',   0,                              /* Right shift */
  '*',
    0,  /* Alt */
  ' ',  /* Space bar */
    0,  /* Caps lock */
    0,  /* 59 - F1 key ... > */
    0,   0,   0,   0,   0,   0,   0,   0,
    0,  /* < ... F10 */
    0,  /* 69 - Num lock*/
    0,  /* Scroll Lock */
    0,  /* Home key */
    0,  /* Up Arrow */
    0,  /* Page Up */
  '-',
    0,  /* Left Arrow */
    0,
    0,  /* Right Arrow */
  '+',
    0,  /* 79 - End key*/
    0,  /* Down Arrow */
    0,  /* Page Down */
    0,  /* Insert Key */
    0,  /* Delete Key */
    0,   0,   0,
    0,  /* F11 Key */
    0,  /* F12 Key */
    0,  /* All other keys are undefined */
};

keyb.c:

#include "kprintf.h"
#include "port_io.h"
#include "keyboard_map.h"

void kb_init(void)
{
    /* This is a very basic keyboard initialization. The assumption is we have a
     * PS/2 keyboard and it is already in a proper state. This may not be the case
     * on real hardware. We simply enable the keyboard interupt */

    /* Get current master PIC interrupt mask */
    unsigned char curmask_master = read_port (0x21);

    /* 0xFD is 11111101 - enables only IRQ1 (keyboard) on master pic
       by clearing bit 1. bit is clear for enabled and bit is set for disabled */
    write_port(0x21, curmask_master & 0xFD);
}

/* Maintain a global location for the current video memory to write to */
static int current_loc = 0;
/* Video memory starts at 0xb8000. Make it a constant pointer to
   characters as this can improve compiler optimization since it
   is a hint that the value of the pointer won't change */
static volatile char *const vidptr = (char*)0xb8000;

void keyboard_handler(void)
{
    signed char keycode;

    keycode = read_port(0x60);
    /* Only print characters on keydown event that have
     * a non-zero mapping */
    if(keycode >= 0 && keyboard_map[keycode]) {
        vidptr[current_loc++] = keyboard_map[keycode];
        /* Attribute 0x07 is white on black characters */
            vidptr[current_loc++] = 0x07;
    }

    /* Send End of Interrupt (EOI) to master PIC */
    write_port(0x20, 0x20);
}

main.c:

#include "port_io.h"

#define IDT_SIZE 256
#define PIC_1_CTRL 0x20
#define PIC_2_CTRL 0xA0
#define PIC_1_DATA 0x21
#define PIC_2_DATA 0xA1

void keyboard_handler_int();
void load_idt(void*);

struct idt_entry
{
    unsigned short int offset_lowerbits;
    unsigned short int selector;
    unsigned char zero;
    unsigned char flags;
    unsigned short int offset_higherbits;
} __attribute__((packed));

struct idt_pointer
{
    unsigned short limit;
    unsigned int base;
} __attribute__((packed));

struct idt_entry idt_table[IDT_SIZE];
struct idt_pointer idt_ptr;

void load_idt_entry(int isr_number, unsigned long base, short int selector, unsigned char flags)
{
    idt_table[isr_number].offset_lowerbits = base & 0xFFFF;
    idt_table[isr_number].offset_higherbits = (base >> 16) & 0xFFFF;
    idt_table[isr_number].selector = selector;
    idt_table[isr_number].flags = flags;
    idt_table[isr_number].zero = 0;
}

static void initialize_idt_pointer()
{
    idt_ptr.limit = (sizeof(struct idt_entry) * IDT_SIZE) - 1;
    idt_ptr.base = (unsigned int)&idt_table;
}

static void initialize_pic()
{
    /* ICW1 - begin initialization */
    write_port(PIC_1_CTRL, 0x11);
    write_port(PIC_2_CTRL, 0x11);

    /* ICW2 - remap offset address of idt_table */
    /*
    * In x86 protected mode, we have to remap the PICs beyond 0x20 because
    * Intel have designated the first 32 interrupts as "reserved" for cpu exceptions
    */
    write_port(PIC_1_DATA, 0x20);
    write_port(PIC_2_DATA, 0x28);

    /* ICW3 - setup cascading */
    write_port(PIC_1_DATA, 0x04);
    write_port(PIC_2_DATA, 0x02);

    /* ICW4 - environment info */
    write_port(PIC_1_DATA, 0x01);
    write_port(PIC_2_DATA, 0x01);
    /* Initialization finished */

    /* mask interrupts */
    write_port(0x21 , 0xff);
    write_port(0xA1 , 0xff);
}

void idt_init()
{
    initialize_pic();
    initialize_idt_pointer();
    load_idt(&idt_ptr);
}

void kmain(void)
{
    //Using grub bootloader..
    idt_init();
    load_idt_entry(0x21, (unsigned long) keyboard_handler_int, 0x08, 0x8e);
    kb_init();
    while(1) __asm__("hlt\n\t");
}

为了链接这个内核，我使用一个名为link.ld的文件进行定义：

/*
*  link.ld
*/
OUTPUT_FORMAT(elf32-i386)
ENTRY(start)
SECTIONS
 {
   . = 0x100000;
   .text : { *(.text) }
   .rodata : { *(.rodata) }
   .data : { *(.data) }
   .bss  : { *(.bss)  }
 }

我使用以下命令，使用 GCC i686 交叉编译器 编译和链接此代码：

nasm -f elf32 -g -F dwarf kernel.asm -o kernel.o
nasm -f elf32 -g -F dwarf lowlevel.asm -o lowlevel.o
i686-elf-gcc -g -m32  -c main.c -o main.o -ffreestanding -O3 -Wall -Wextra -pedantic
i686-elf-gcc -g -m32  -c keyb.c -o keyb.o -ffreestanding -O3 -Wall -Wextra -pedantic
i686-elf-gcc -g -m32  -Wl,--build-id=none -T link.ld -o kernel.elf -ffreestanding -nostdlib lowlevel.o main.o keyb.o kernel.o -lgcc

结果是一个名为kernel.elf的内核，带有调试信息。我更喜欢使用优化级别-O3，而不是默认的-O0。调试信息使得使用QEMU和GDB进行调试更加容易。可以使用以下命令调试内核：

qemu-system-i386 -kernel kernel.elf -S -s &

gdb kernel.elf \
        -ex 'target remote localhost:1234' \
        -ex 'layout src' \
        -ex 'layout regs' \
        -ex 'break kmain' \
        -ex 'continue'

如果您希望在汇编代码级别进行调试，请将 layout src 替换为 layout asm。当使用输入 the quick brown fox jumps over the lazy dog 01234567890 运行时，QEMU 显示如下内容：

- Michael Petch