修改Multiboot头魔术数为何导致内核无法启动？

你遇到的核心问题是Multiboot标准版本不兼容：

• 0x59F49148是Multiboot 2标准的魔术数（x86小端字节序下的存储值，官方魔术数为0xE85250D6），但你的代码实现的是Multiboot 1的头结构。
• Multiboot 1的头仅需要3个32位字段：魔术数、标志位、校验和；而Multiboot 2要求更复杂的头结构，必须包含头长度、架构类型、标签列表等额外字段。当你替换成Multiboot 2的魔术数后，Qemu中的Bootloader（如GRUB）会按照Multiboot 2的规范解析内核，但你的代码缺少Multiboot 2要求的必要字段，导致Bootloader无法识别这是有效内核镜像，因此不会加载执行。

你当前的代码是标准的Multiboot 1头实现，将魔术数改回Multiboot 1的官方值0x1BADB002即可恢复正常。如果想要迁移到Multiboot 2，需要完全按照其规范重构头部分，示例如下：

/* Multiboot 2 头示例 */
.set MAGIC,    0xE85250D6  /* Multiboot 2 官方魔术数 */
.set ARCH,     0           /* 0表示i386架构 */
.set HEADER_LEN, . - header_start
.set CHECKSUM, -(MAGIC + ARCH + HEADER_LEN)

.section .multiboot
header_start:
.align 8
.long MAGIC
.long ARCH
.long HEADER_LEN
.long CHECKSUM

/* 结束标签：Multiboot 2要求必须以该标签收尾 */
.short 0  /* 标签类型：0表示结束 */
.short 0  /* 标签标志 */
.long 8   /* 标签大小 */
header_end:

以下是你提供的原GAS代码：

/* Declare constants for the multiboot header. */
.set ALIGN,    1<<0             /* align loaded modules on page boundaries */
.set MEMINFO,  1<<1             /* provide memory map */
.set FLAGS,    ALIGN | MEMINFO  /* this is the Multiboot 'flag' field */
.set MAGIC,    0x59F49148       /* 'magic number' lets bootloader find the header */
.set CHECKSUM, -(MAGIC + FLAGS) /* checksum of above, to prove we are multiboot */
 
/* 
Declare a multiboot header that marks the program as a kernel. These are magic
values that are documented in the multiboot standard. The bootloader will
search for this signature in the first 8 KiB of the kernel file, aligned at a
32-bit boundary. The signature is in its own section so the header can be
forced to be within the first 8 KiB of the kernel file.
*/
.section .multiboot
.align 4
.long MAGIC
.long FLAGS
.long CHECKSUM
 
/*
The multiboot standard does not define the value of the stack pointer register
(esp) and it is up to the kernel to provide a stack. This allocates room for a
small stack by creating a symbol at the bottom of it, then allocating 16384
bytes for it, and finally creating a symbol at the top. The stack grows
downwards on x86. The stack is in its own section so it can be marked nobits,
which means the kernel file is smaller because it does not contain an
uninitialized stack. The stack on x86 must be 16-byte aligned according to the
System V ABI standard and de-facto extensions. The compiler will assume the
stack is properly aligned and failure to align the stack will result in
undefined behavior.
*/
.section .bss
.align 16
stack_bottom:
.skip 16384 # 16 KiB
stack_top:
 
/*
The linker script specifies _start as the entry point to the kernel and the
bootloader will jump to this position once the kernel has been loaded. It
doesn't make sense to return from this function as the bootloader is gone.
*/
.section .text
.global _start
.type _start, @function
_start:
    /*
    The bootloader has loaded us into 32-bit protected mode on a x86
    machine. Interrupts are disabled. Paging is disabled. The processor
    state is as defined in the multiboot standard. The kernel has full
    control of the CPU. The kernel can only make use of hardware features
    and any code it provides as part of itself. There's no printf
    function, unless the kernel provides its own <stdio.h> header and a
    printf implementation. There are no security restrictions, no
    safeguards, no debugging mechanisms, only what the kernel provides
    itself. It has absolute and complete power over the
    machine.
    */
 
    /*
    To set up a stack, we set the esp register to point to the top of the
    stack (as it grows downwards on x86 systems). This is necessarily done
    in assembly as languages such as C cannot function without a stack.
    */
    mov $stack_top, %esp
 
    /*
    This is a good place to initialize crucial processor state before the
    high-level kernel is entered. It's best to minimize the early
    environment where crucial features are offline. Note that the
    processor is not fully initialized yet: Features such as floating
    point instructions and instruction set extensions are not initialized
    yet. The GDT should be loaded here. Paging should be enabled here.
    C++ features such as global constructors and exceptions will require
    runtime support to work as well.
    */
 
    /*
    Enter the high-level kernel. The ABI requires the stack is 16-byte
    aligned at the time of the call instruction (which afterwards pushes
    the return pointer of size 4 bytes). The stack was originally 16-byte
    aligned above and we've pushed a multiple of 16 bytes to the
    stack since (pushed 0 bytes so far), so the alignment has thus been
    preserved and the call is well defined.
    */
    call kernel_main
 
    /*
    If the system has nothing more to do, put the computer into an
    infinite loop. To do that:
    1) Disable interrupts with cli (clear interrupt enable in eflags).
       They are already disabled by the bootloader, so this is not needed.
       Mind that you might later enable interrupts and return from
       kernel_main (which is sort of nonsensical to do).
    2) Wait for the next interrupt to arrive with hlt (halt instruction).
       Since they are disabled, this will lock up the computer.
    3) Jump to the hlt instruction if it ever wakes up due to a
       non-maskable interrupt occurring or due to system management mode.
    */
    cli
1:  hlt
    jmp 1b
 
/*
Set the size of the _start symbol to the current location '.' minus its start.
This is useful when debugging or when you implement call tracing.
*/
.size _start, . - _start

内容的提问来源于stack exchange，提问作者Isaac Cilia Attard