操作系统ucore lab1实验报告

怼烎@ 2022-07-14 13:07 202阅读 0赞

# lab1 #

## Exercise1:理解通过make生成执行文件的过程。 ##

### Question1: ###

#### 操作系统镜像文件ucore.img是如何一步一步生成的？(需要比较详细地解释Makefile中每一条相关命令和命令参数的含义，以及说明命令导致的结果) ####

#### Answer： ####

在Makefile中生成ucore.img的代码是：

$(UCOREIMG): $(kernel) $(bootblock)
        $(V)dd if=/dev/zero of=$@ count=10000
        $(V)dd if=$(bootblock) of=$@ conv=notrunc
        $(V)dd if=$(kernel) of=$@ seek=1 conv=notrunc

在执行Makefile时对应的输出为：

dd if=/dev/zero of=bin/ucore.img count=10000
    10000+0 records in
    10000+0 records out
    5120000 bytes (5.1 MB) copied, 0.0540315 s, 94.8 MB/s
    dd if=bin/bootblock of=bin/ucore.img conv=notrunc
    1+0 records in
    1+0 records out
    512 bytes (512 B) copied, 0.000110706 s, 4.6 MB/s
    dd if=bin/kernel of=bin/ucore.img seek=1 conv=notrunc
    138+1 records in
    138+1 records out
    70775 bytes (71 kB) copied, 0.000472623 s, 150 MB/s

从Makefile中可以看出要生成ucore.img首先要拥有kernel和bootblock两个可执行文件

所以继续在Makefile中找到kernel的相关代码段

kernel = $(call totarget,kernel)
    
    $(kernel): tools/kernel.ld
    
    $(kernel): $(KOBJS)
        @echo + ld $@
        $(V)$(LD) $(LDFLAGS) -T tools/kernel.ld -o $@ $(KOBJS)
        @$(OBJDUMP) -S $@ > $(call asmfile,kernel)
        @$(OBJDUMP) -t $@ | $(SED) '1,/SYMBOL TABLE/d; s/ .* / /; /^$$/d' > $(call symfile,kernel)
    
    $(call create_target,kernel)

再结合前面的对kernel的一些声明:

# kernel
    
    KINCLUDE    += kern/debug/ \
                   kern/driver/ \
                   kern/trap/ \
                   kern/mm/
    
    KSRCDIR     += kern/init \
                   kern/libs \
                   kern/debug \
                   kern/driver \
                   kern/trap \
                   kern/mm
    
    KCFLAGS     += $(addprefix -I,$(KINCLUDE))
    
    $(call add_files_cc,$(call listf_cc,$(KSRCDIR)),kernel,$(KCFLAGS))
    
    KOBJS   = $(call read_packet,kernel libs)

查看文件中的文件得出，生成kernel需要以下文件：

kernel.ld    init.o  readline.o  stdio.o     kdebug.o   kmonitor.o panic.o clock.o console.o intr.o  picirq.o   trap.o  trapentry.o  vectors.o  pmm.o  printfmt.o   string.o

根据已有的文件，kernel.ld已经存在，其他的.o文件则需要.c和.s文件通过gcc编译生成

生成init.o需要的命令:

gcc -Ikern/init/ -fno-builtin -Wall -ggdb -m32 -gstabs -nostdinc  -fno-stack-protector -Ilibs/ -Ikern/debug/ -Ikern/driver/ -Ikern/trap/ -Ikern/mm/ -c kern/init/init.c -o obj/kern/init/init.o

生成其他.o文件的命令和init.o的方法类似。

生成这些.o文件后便可以生成kernel可执行文件

而除kernel外还需要生成bootblock

在Makefile中bootblock的相关代码：

# create bootblock
    bootfiles = $(call listf_cc,boot)
    $(foreach f,$(bootfiles),$(call cc_compile,$(f),$(CC),$(CFLAGS) -Os -nostdinc))
    
    bootblock = $(call totarget,bootblock)
    
    $(bootblock): $(call toobj,$(bootfiles)) | $(call totarget,sign)
        @echo + ld $@
        $(V)$(LD) $(LDFLAGS) -N -e start -Ttext 0x7C00 $^ -o $(call toobj,bootblock)
        @$(OBJDUMP) -S $(call objfile,bootblock) > $(call asmfile,bootblock)
        @$(OBJCOPY) -S -O binary $(call objfile,bootblock) $(call outfile,bootblock)
        @$(call totarget,sign) $(call outfile,bootblock) $(bootblock)
    
    $(call create_target,bootblock)

结合文件夹中的文件可以看出要生成bootblock需要bootasm.o、bootmain.o、sign三个文件

生成bootasm.o的相关代码为：

gcc -Iboot/ -fno-builtin -Wall -ggdb -m32 -gstabs -nostdinc  -fno-stack-protector -Ilibs/ -Os -nostdinc -c boot/bootasm.S -o obj/boot/bootasm.o

其中相关参数的含义为：

*  ggdb 生成可供gdb使用的调试信息
 *  \-m32生成适用于32位环境的代码
 *  \-gstabs 生成stabs格式的调试信息
 *  \-nostdinc 不使用标准库
 *  \-fno-stack-protector 不生成用于检测缓冲区溢出的代码
 *  \-0s 位减小代码长度进行优化

生成sign的相关代码为：

gcc -Itools/ -g -Wall -O2 -c tools/sign.c -o obj/sign/tools/sign.o
    gcc -g -Wall -O2 obj/sign/tools/sign.o -o bin/sign

这些都生成完毕之后就可以开始生成ucore.img

生成ucore.img过程中产生的信息：

生成一个有10000个块的文件，每个块默认512字节，用0填充

dd if=/dev/zero of=bin/ucore.img count=10000

把bootblock中的内容写到第一个块

dd if=bin/bootblock of=bin/ucore.img conv=notrunc

从第二个块开始写kernel中的内容

dd if=bin/kernel of=bin/ucore.img seek=1 conv=notrunc

### Question2： ###

#### 一个被系统认为是符合规范的硬盘主引导扇区的特征是什么？ ####

#### Answer： ####

从sign.c中的：

if (size != 512) {
            fprintf(stderr, "write '%s' error, size is %d.\n", argv[2], size);
            return -1;
        }

可以看出，要求硬盘主引导扇区的大小时512字节

buf[510] = 0x55;
    buf[511] = 0xAA;

可以看出，还需要第510个字节是0x55,第511个字节为0xAA,也就是说扇区的最后两个字节内容是0x55AA

## Exercise2:使用qemu执行并调试lab1中的软件。 ##

### Question1: ###

#### 从CPU加电后执行的第一条指令开始，单步跟踪BIOS的执行。 ####

#### Answer： ####

根据附录中的说明， 修改 lab1/tools/gdbinit,

set architecture i8086
    target remote :1234

在 lab1目录下，执行

make debug

这时GDB停在BIOS的第一条指令出，可能是由于不兼容的问题，无法正常显示出指令，只看得到地址为0xe05b，而指令码却显示为？？

然后输入si单步执行，也是只能看到地址，但指令显示为？？

所以使用

x/5i 0xffff0

来查看BIOS的代码，得到结果如下图所示

![BIOS][]

### Question2： ###

#### 在初始化位置0x7c00设置实地址断点,测试断点正常。 ####

#### Answer： ####

在gdbinit 中添加指令：

set architecture i8086
    b *0x7c00
    c
    x/5i $pc
    set architecture i386

然后运行Make debug可以得到：

![breakcheck][]  
所以断点正常

### Question3： ###

#### 从0x7c00开始跟踪代码运行,将单步跟踪反汇编得到的代码与bootasm.S和 bootblock.asm进行比较。 ####

#### Answer： ####

在0x7c00处break，然后使用si和 x/i $pc 指令一行一行的跟踪，将得到的反汇编代码为：

0x00007c01 in ?? ()
    (gdb) x/i $pc
    => 0x7c01:      cld    
    (gdb) si
    0x00007c02 in ?? ()
    (gdb) x/i $pc
    => 0x7c02:      xor    %eax,%eax
    (gdb) si
    0x00007c04 in ?? ()
    (gdb) x/i $pc
    => 0x7c04:      mov    %eax,%ds
    (gdb)

bootblock.asm 中的代码为：

.code16                                             # Assemble for 16-bit mode
        cli                                             # Disable interrupts
        7c00:   fa                      cli    
        cld                                             # String operations increment
        7c01:   fc                      cld    
    
        # Set up the important data segment registers (DS, ES, SS).
        xorw %ax, %ax                                   # Segment number zero
        7c02:   31 c0                   xor    %eax,%eax
        movw %ax, %ds                                   # -> Data Segment
        7c04:   8e d8                   mov    %eax,%ds
        movw %ax, %es                                   # -> Extra Segment
        7c06:   8e c0                   mov    %eax,%es
        movw %ax, %ss                                   # -> Stack Segment
        7c08:   8e d0                   mov    %eax,%ss

bootasm.s中的代码为：

.globl start
    start:
    .code16                                             # Assemble for 16-bit mode
        cli                                             # Disable interrupts
        cld                                             # String operations increment
    
        # Set up the important data segment registers (DS, ES, SS).
        xorw %ax, %ax                                   # Segment number zero
        movw %ax, %ds                                   # -> Data Segment
        movw %ax, %es                                   # -> Extra Segment
        movw %ax, %ss                                   # -> Stack Segment

以上列举了一小段，其他的部分类似。

根据比较可知，这三部分内容是一样的。

### Question4： ###

#### 自己找一个bootloader或内核中的代码位置，设置断点并进行测试 ####

#### Answer： ####

在init.c中会对gdt进行初始化，在初始化过程中，调用了gdt\_init()这个函数，我选择此处进行测试。

设置断点情况如图：

![break\_gdt\_init][break_gdt_init]

可见已经成功在gdt\_init处停止，

然后使用x/i $pc指令查询正在执行的汇编代码，与原文件中的c代码对照，测试结束。

## Exercise3:分析bootloader进入保护模式的过程。 ##

#### Answer: ####

从bootasm.s查看代码，并分析过程

cli 
    cld

1.  首先禁止中断，并且修改控制方向标志寄存器DF=0，使得内存地址从低到高增加
    
    \_注：\_stl为允许中断发生，std使DF置位即令DF=1
2.  然后对实模式下的段寄存器进行初始化

xorw %ax, %ax
        movw %ax, %ds
        movw %ax, %es
        movw %ax, %ss

xorw %ax, %ax 将ax寄存器置为0，然后，对ds（数据段寄存器），es（额外寄存器），ss（栈寄存器）

1.  然后将A20置为高位，这样32位的地址线就都可以用了，也就可以访问4G的内存空间
    
    相关代码：
    
        seta20.1:
           inb $0x64, %al                                 
           testb $0x2, %al
           jnz seta20.1
        
           movb $0xd1, %al                                 # 0xd1 -> port 0x64
           outb %al, $0x64                                 
        
        seta20.2:
           inb $0x64, %al                                  
           testb $0x2, %al
           jnz seta20.2
        
           movb $0xdf, %al                                 # 0xdf -> port 0x60
           outb %al, $0x60
2.  接下来初始化GDT表：
    
        lgdt gdtdesc
    
    GDT表已经在数据区声明：
    
        # Bootstrap GDT
        
        .p2align 2                                          # force 4 byte alignment
        gdt:
           SEG_NULLASM                                     # null seg
           SEG_ASM(STA_X|STA_R, 0x0, 0xffffffff)           # code seg for bootloader and kernel
           SEG_ASM(STA_W, 0x0, 0xffffffff)                 # data seg for bootloader and kernel
        
        gdtdesc:
           .word 0x17                                      # sizeof(gdt) - 1
           .long gdt                                       # address gdt
3.  然后将cr0置为1开启保护模式
    
        movl %cr0, %eax
           orl $CR0_PE_ON, %eax
           movl %eax, %cr0
    
    CR0\_PE\_ON已经在前面声明为0x1
    
        .set CR0_PE_ON,             0x1
4.  通过段间跳转指令ljmp改变cs的基址
    
        ljmp $PROT_MODE_CSEG, $protcseg
    
    PORT\_MODE\_CSGE已在数据段定义：
    
        .set PROT_MODE_CSEG,        0x8
5.  设置保护模式下的段寄存器
    
        movw $PROT_MODE_DSEG, %ax                       # Our data segment selector
           movw %ax, %ds                                   # -> DS: Data Segment
           movw %ax, %es                                   # -> ES: Extra Segment
           movw %ax, %fs                                   # -> FS
           movw %ax, %gs                                   # -> GS
           movw %ax, %ss                                   # -> SS: Stack Segment
    
    PROT\_MODE\_DSEG为0x10
6.  建立堆栈，并且调用bootmain.c
    
        movl $0x0, %ebp
           movl $start, %esp
           call bootmain
    
    栈的地址是从0到0x7c00

## Exercise4:分析bootloader加载ELF格式的OS的过程 ##

#### Answer： ####

bootloader首先读取ELF头表：

// read the 1st page off disk
        readseg((uintptr_t)ELFHDR, SECTSIZE * 8, 0);

ELFHDR是前面定义的一个临时空间：

#define ELFHDR ((struct elfhdr *)0x10000) // scratch space

而uintptr\_t是在defs.h中定义的：

typedef uint32_t uintptr_t;

这行代码的作用是，可以通过uintptr\_t来代替uint32\_t，而uint32\_t是前文中，unsigned in的替替代品

typedef unsigned int uint32_t;

所以一层层推导下来，uintptr\_t就是unsigned int。

这里是为了把ELF的头表读进去，传入readseg的三个参数分别表示，起始位置，大小，和偏移。

大小是SECTSIZE\*8，SETCSIZE的大小是512：

#define SECTSIZE 512

这里读入了512\*8个位，然而实际并不需要这么大，亲测只要一个SECTSIZE也就是512就足够，所以猜测可能是为了以后的扩展，所以在这里定义了这么大。

当头表读入完成后，就通过e\_magic检测是否是合法的ELF文件：

// is this a valid ELF?
        if (ELFHDR->e_magic != ELF_MAGIC) {
            goto bad;
        }

如不是就会跳入到bad执行指令，如果是就继续往下执行。

根据ELF头表中的描述，将ELF文件加载到内存中的相应位置保存到ph中;

ph = (struct proghdr *)((uintptr_t)ELFHDR + ELFHDR->e_phoff);

将结束位置加载到eph中：

eph = ph + ELFHDR->e_phnum;（e_phnum是程序中的条目数）

然后就将ELF文件中的数据通过循环加载到内存中：

for (; ph < eph; ph ++) {
            readseg(ph->p_va & 0xFFFFFF, ph->p_memsz, ph->p_offset);
        }

加载完成后根据ELF头表中存储的入口信息，找到内核的入口：

((void (*)(void))(ELFHDR->e_entry & 0xFFFFFF))();

## Exercise5：实现函数调用堆栈跟踪函数 ##

#### Answer： ####

代码如下：

uint32_t ebp = read_ebp();
        uint32_t eip = read_eip();
        int i,j;
        for(i = 0; ebp!=0 && i < STACKFRAME_DEPTH; i++) {
            cprintf("ebp:0x%08x eip:0x%08x ",ebp, eip);
            cprintf("args");
            uint32_t *args = (uint32_t *)ebp + 2;
            for(j = 0; j < 4; j++)
                cprintf("0x%08x ",args[j]); 
            cprintf("\n");
            print_debuginfo(eip-1);
            eip = *((uint32_t *)ebp+1);
                ebp = *((uint32_t *)ebp+0);
        }

详解：

调用read\_ebp()和read\_eip()函数得到ebp和eip当前的值：

uint32_t ebp = read_ebp();
        uint32_t eip = read_eip();

然后在循环中输出所有的ebp和eip的值，由于ebp指向的位置存储着caller的ebp，所以可以不断地向上找到所有函数的ebp，eip也同理，eip总是存储在caller的ebp+4的位置，直到到达栈底或者长度超过STACKFRAME\_DEPTH。

一开始由于注释中并没有提示到达栈底的情况，所以我是这样写的：

for(i = 0;  i < STACKFRAME_DEPTH; i++)

这样写的结果就是没有及时的停止，会把栈外的信息也输出出来：

ebp:0x00007b08 eip:0x001009a6 args0x00010094 0x00000000 0x00007b38 0x00100092 
        kern/debug/kdebug.c:306: print_stackframe+21
    ebp:0x00007b18 eip:0x00100c9b args0x00000000 0x00000000 0x00000000 0x00007b88 
        kern/debug/kmonitor.c:125: mon_backtrace+10
    ebp:0x00007b38 eip:0x00100092 args0x00000000 0x00007b60 0xffff0000 0x00007b64 
        kern/init/init.c:48: grade_backtrace2+33
    ebp:0x00007b58 eip:0x001000bb args0x00000000 0xffff0000 0x00007b84 0x00000029 
        kern/init/init.c:53: grade_backtrace1+38
    ebp:0x00007b78 eip:0x001000d9 args0x00000000 0x00100000 0xffff0000 0x0000001d 
        kern/init/init.c:58: grade_backtrace0+23
    ebp:0x00007b98 eip:0x001000fe args0x001032fc 0x001032e0 0x0000130a 0x00000000 
        kern/init/init.c:63: grade_backtrace+34
    ebp:0x00007bc8 eip:0x00100055 args0x00000000 0x00000000 0x00000000 0x00010094 
        kern/init/init.c:28: kern_init+84
    ebp:0x00007bf8 eip:0x00007d68 args0xc031fcfa 0xc08ed88e 0x64e4d08e 0xfa7502a8 
        <unknow>: -- 0x00007d67 --
    ebp:0x00000000 eip:0x00007c4f args0xf000e2c3 0xf000ff53 0xf000ff53 0xf000ff53 
        <unknow>: -- 0x00007c4e --
    ebp:0xf000ff53 eip:0xf000ff53 args0x00000000 0x00000000 0x00000000 0x00000000 
        <unknow>: -- 0xf000ff52 --
    ebp:0x00000000 eip:0x00000000 args0xf000e2c3 0xf000ff53 0xf000ff53 0xf000ff53 
        <unknow>: -- 0xffffffff --
    ebp:0xf000ff53 eip:0xf000ff53 args0x00000000 0x00000000 0x00000000 0x00000000 
        <unknow>: -- 0xf000ff52 --
    ebp:0x00000000 eip:0x00000000 args0xf000e2c3 0xf000ff53 0xf000ff53 0xf000ff53 
        <unknow>: -- 0xffffffff --
    ebp:0xf000ff53 eip:0xf000ff53 args0x00000000 0x00000000 0x00000000 0x00000000 
        <unknow>: -- 0xf000ff52 --
    ebp:0x00000000 eip:0x00000000 args0xf000e2c3 0xf000ff53 0xf000ff53 0xf000ff53 
        <unknow>: -- 0xffffffff --
    ebp:0xf000ff53 eip:0xf000ff53 args0x00000000 0x00000000 0x00000000 0x00000000 
        <unknow>: -- 0xf000ff52 --
    ebp:0x00000000 eip:0x00000000 args0xf000e2c3 0xf000ff53 0xf000ff53 0xf000ff53 
        <unknow>: -- 0xffffffff --
    ebp:0xf000ff53 eip:0xf000ff53 args0x00000000 0x00000000 0x00000000 0x00000000 
        <unknow>: -- 0xf000ff52 --
    ebp:0x00000000 eip:0x00000000 args0xf000e2c3 0xf000ff53 0xf000ff53 0xf000ff53 
        <unknow>: -- 0xffffffff --
    ebp:0xf000ff53 eip:0xf000ff53 args0x00000000 0x00000000 0x00000000 0x00000000 
        <unknow>: -- 0xf000ff52 --

发现问题后把代码改成了这样：

for(i = 0; ebp!=0 && i < STACKFRAME_DEPTH; i++)

这样就可以及时的停住：

ebp:0x00007b08 eip:0x001009a6 args0x00010094 0x00000000 0x00007b38 0x00100092 
        kern/debug/kdebug.c:306: print_stackframe+21
    ebp:0x00007b18 eip:0x00100ca1 args0x00000000 0x00000000 0x00000000 0x00007b88 
        kern/debug/kmonitor.c:125: mon_backtrace+10
    ebp:0x00007b38 eip:0x00100092 args0x00000000 0x00007b60 0xffff0000 0x00007b64 
        kern/init/init.c:48: grade_backtrace2+33
    ebp:0x00007b58 eip:0x001000bb args0x00000000 0xffff0000 0x00007b84 0x00000029 
        kern/init/init.c:53: grade_backtrace1+38
    ebp:0x00007b78 eip:0x001000d9 args0x00000000 0x00100000 0xffff0000 0x0000001d 
        kern/init/init.c:58: grade_backtrace0+23
    ebp:0x00007b98 eip:0x001000fe args0x001032fc 0x001032e0 0x0000130a 0x00000000 
        kern/init/init.c:63: grade_backtrace+34
    ebp:0x00007bc8 eip:0x00100055 args0x00000000 0x00000000 0x00000000 0x00010094 
        kern/init/init.c:28: kern_init+84
    ebp:0x00007bf8 eip:0x00007d68 args0xc031fcfa 0xc08ed88e 0x64e4d08e 0xfa7502a8 
        <unknow>: -- 0x00007d67 --

最后一行，位于堆栈的底部，所以对应着第一个调用的函数，也就是bootmain.c中的bootmain。同时由于BootLoader设置的堆栈从0x7c00开始，当 call bootmain时，进入bootmain函数，将call指令压栈，bootmain中的ebp是0x7bf8。

## Exercise6：完善中断初始化和处理 ##

### Question1： ###

#### 中断描述符表（也可简称为保护模式下的中断向量表）中一个表项占多少字节？其中哪几位代表中断处理代码的入口？ ####

#### Answer： ####

中断描述符表中一个表项占8个字节，其中每个位的作用如图：  
![中断描述符表][SouthEast]  
其中0~15和48~63分别为offset的低16位和高16位，16~31位是段选择子，通过段选择子得到段基址，再加上段内偏移量就可以得到中断处理代码的入口。

### Question2: ###

#### 请编程完善kern/trap/trap.c中对中断向量表进行初始化的函数idt\_init。在idt\_init函数中，依次对所有中断入口进行初始化。使用mmu.h中的SETGATE宏，填充idt数组内容。每个中断的入口由tools/vectors.c生成，使用trap.c中声明的vectors数组即可。 ####

#### Answer: ####

代码如下：

extern uintptr_t __vectors[];
        int i = 0;
        for(i = 0; i<sizeof(idt) / sizeof(struct gatedesc);i++) {
        SETGATE(idt[i], 0,KERNEL_CS, __vectors[i], DPL_KERNEL);
        }
         SETGATE(idt[T_SYSCALL], 0, KERNEL_CS, __vectors[T_SYSCALL], DPL_USER);
        lidt(&idt_pd);

代码详解：

extern uintptr_t __vectors[];

这里将在此文件外的kern/trap/vector.S中定义的数组\_\_vectors\[\]导入进来。那个数组的定义很长，在此不再细细描述。

for(i = 0; i<sizeof(idt) / sizeof(struct gatedesc);i++) {
            SETGATE(idt[i], 0,KERNEL_CS, __vectors[i], DPL_KERNEL);
        }

在这里对整个idt数组进行初始化。对SETGATE的定义在mmu.h中：

#define SETGATE(gate, istrap, sel, off, dpl) { \
        (gate).gd_off_15_0 = (uint32_t)(off) & 0xffff;        \
        (gate).gd_ss = (sel);                                \
        (gate).gd_args = 0;                                    \
        (gate).gd_rsv1 = 0;                                    \
        (gate).gd_type = (istrap) ? STS_TG32 : STS_IG32;    \
        (gate).gd_s = 0;                                    \
        (gate).gd_dpl = (dpl);                                \
        (gate).gd_p = 1;                                    \
        (gate).gd_off_31_16 = (uint32_t)(off) >> 16;        \
    }

*  传入的第一个参数gate是中断的描述符表
 *  传入的第二个参数istrap用来判断是中断还是trap
 *  传入的第三个参数sel的作用是进行段的选择
 *  传入的第四个参数off表示偏移
 *  传入的第五个参数dpl表示这个中断的优先级

在这里先把所有的中断都初始化为内核级的中断

SETGATE(idt[T_SYSCALL], 0, KERNEL_CS, __vectors[T_SYSCALL], DPL_USER);

然后再把系统调用的中断初始化为用户级的中断。

lidt(&idt_pd)

最后把idt的位置告诉CPU

### Question3: ###

#### 1.请编程完善trap.c中的中断处理函数trap，在对时钟中断进行处理的部分填写trap函数中处理时钟中断的部分，使操作系统每遇到100次时钟中断后，调用print\_ticks子程序，向屏幕上打印一行文字”100 ticks”。 ####

#### Answer: ####

代码如下：

ticks++;
        if(ticks%TICK_NUM == 0)
            print_ticks();
        break;

此处代码的意思就是在，每次时钟中断后ticks就加一，每次达到TICK\_NUM就会调用print\_ticks()语句，向屏幕上输出一句话。

运行结果截图：

![100ticks][]

[BIOS]: /images/20220714/203f701505084ed4b859846c9db205bf.png
[breakcheck]: /images/20220714/9be8da04bd7d40389e86c742caba08ce.png
[break_gdt_init]: /images/20220714/6a9150b4562b4acebe3c44f0ba614345.png
[SouthEast]: /images/20220714/a3d54527b4b941509e3bd79d34f2f09a.png
[100ticks]: /images/20220714/fec8ef92c9a74feca1d457a81170d2f1.png