您的代码存在许多问题。下面分别讨论主要的。
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
您的中断处理程序需要执行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 指针需要一个代表 IDT 大小的 16 位值，后跟一个代表 IDT基地址的 32 位值>.
有关结构对齐和填充的更多信息可以在 Eric Raymond 的blogs 之一中找到。由于struct idt_entry 成员的放置方式，没有额外的填充字节。如果你正在创建你永远不想填充的结构，我建议使用__attribute__((packed));。当您将 C 数据结构与系统定义的结构进行映射时，通常会出现这种情况。考虑到这一点，为了清楚起见，我还会打包 struct idt_entry。
其他注意事项
在中断处理程序中，虽然我建议使用 IRETD，但还有另一个问题。随着内核的增长和添加更多中断，您会发现另一个问题。您的内核可能会出现异常行为，并且寄存器可能会意外更改值。问题是作为中断处理程序的 C 函数会破坏某些寄存器的内容，但我们不会保存和恢复它们。其次，在调用函数之前，需要清除方向标志（根据32-bit 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 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, 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);
}
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 cross compiler 使用以下命令编译并链接此代码：
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 运行时，显示如下：