【操作系统真象还原系列】6.开启虚拟地址空间

骑猪看日落 2023-01-01 07:58 119阅读 0赞

### 目录 ###

*  逻辑地址、线性地址、物理地址和虚拟地址
 *  分页机制
 *   *  页表项
     *  一级页表
     *  二级页表
 *  启动分页机制
 *  虚拟地址空间划分
 *  页表内存布局
 *  代码实现
 *   *  页目录表清零
     *  创建页目录表
     *  创建页表
     *  创建其他内核目录项
     *  创建页表完整函数
     *  loader中调用setup\_page
 *  实验结果
 *   *  Virtualbox实验结果
     *  bochs实验结果
 *  查看并分析最终的页表
 *  完整实验代码
 *   *  mbr.s
     *  loader.s

# 逻辑地址、线性地址、物理地址和虚拟地址 #

首先我们限定这几个概念都是针对x86CPU来说的。  
对于x86CPU来说，内存分段机制是其骨子里的东西，是从娘胎里带出来的，改不掉的。所以x86的CPU想要访问内存，首先必须经过内存分段机制的处理。

无论是在实模式下，还是在保护模式下，我们将段内偏移地址称之为有效地址，或逻辑地址，这也是程序员可见的地址。而由段基址:段内偏移地址 在段部件的作用下得到的地址，我们称之为线性地址。

若未开启分页功能，则此时线性地址就是物理地址，可以直接用于内存访问。但如果开启了分页机制，则此时线性地址被称为虚拟地址。虚拟地址还要经过CPU的页部件转换为物理地址，之后才能用于内存访问。

# 分页机制 #

在开启CPU保护模式之后，CPU的寻址空间变为4GB，即线性地址空间变为4GB了。若再开启分页机制，则就可以使得连续的线性地址与任意物理地址相对应。需要强调的一点是，当开启分页机制后，我们称线性地址为虚拟地址。

对于分页机制，其主要作用有以下两点：

*  将线性地址转换为物理地址
 *  用大小相等的页来代替大小不等的段

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70_pic_center]

对于上图来说，每个进程都独享4GB的线性地址空间，即独享4GB的虚拟地址空间。而所有进程则共享物理地址空间。虚拟地址空间到物理地址空间的映射则是通过页表来完成的。

对于32位的虚拟地址来说，我们可以将其分为高低两个部分，低部分用来表示内存块的大小，而高部分则用来表示内存块的数量。我们使用一个滑块来表示这两个部分的分界点，如下图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70_pic_center 1]  
对于这里的内存块，其专业术语叫做页。而32位的x86CPU所采用的页大小是4KB，即0~11位表示页内地址。我们把虚拟地址空间和物理地址空间都按照4KB一页来分成若干页。

## 页表项 ##

对于32位CPU来说，每一个页表项的大小为4字节，即4B。但其内容并非全部是对应的物理页的基地址。因为页大小是4KB，所以只有高20位才是物理地址，低12位被用来存储对应的物理页的属性信息。具体内容如下图所示：  
![在这里插入图片描述][2021010114345681.jpg_pic_center]

*  P位  
    Present，即存在位。为1表示该页位于物理内存中，若为0则表示该页不在物理内存中。访问P为0的页则会出发PageFault异常。
 *  RW位  
    Read/Write，即读写位。为1表示可读可写，为0表示可读不可写。
 *  US位  
    User/Supervisor，即普通用户/超级用户位。为1表示处于User级，任意级别的程序都可以访问该页。若为0，则表示处于Supervisor级，特权级为3的程序无法访问该页，而特权级为2、1、0的程序则可以访问。
 *  PWT位  
    Page-level Write-Through，即页写通位，也称为页写透位。为1表示此项采用写通方式，这就意味着该页不仅是普通内存，还是高速缓存。
 *  PCD位  
    Page-level Cache Disable，即页级高速缓存禁止位。为1表示该页启用高速缓存，为0则表示该页禁止高速缓存
 *  A位  
    Accessed，即页访问位。为1表示该页被CPU访问过了。
 *  D位  
    Dirty，即脏位。为1表示CPU对该页进行了写操作。
 *  PAT位  
    Page Attribute Table，即页属性表位。暂不介绍。
 *  G位  
    Global，即全局位。为1则表示该页对应的转换关系一直保存在TLB中。
 *  AVL位  
    Available，即可用位。改为留给软件自定义，就像是段描述符中的第52位AVL位一样，都是留给软件自定义使用的。

## 一级页表 ##

现在我们知道32位地址的低12位被用来在该页面内寻址。如果我们将高20位用来直接定位一个页，那么此时对应的就是一级页表。

显然，一级页表的页表项有220=1M个。而每一个页表项大小为4字节。故一级页表的大小为4MB。当我们将一级页表的基地址加载进页表寄存器时，就意味着从此地址开始的4MB空间大小全部都是一级页表的范围。即使我们只用了1页，那剩余的1M-1项页表项对应的空间也必须分配好。

显然，在只使用少量页的前提下，使用一级页表太浪费内存空间了。

## 二级页表 ##

为了减少上述内存浪费的情况，我们来分析一下造成这种浪费的原因。对于一级页表来说，我们将1M个页表项放到了同一张页表中，而在将页表基地址加载到页表寄存器的时候，第一个页表必须要提前建立好。正因为如此，所以我们必须一次性占用掉4MB的物理内存。

现在我们知道了是由两个原因共同导致的这个结果：

1.  加载页表时第一级的页表必须提前建立好
2.  第一级的页表的大小太大了

由于加载页表时必须将页表建立好，所以我们只能想办法改变第一级页表的大小。  
因此，x86CPU采用了二级页表，即将原来的1M个页表项分成了两级，第一级页表1K个页表项，第二级页表1K个页表项。这样两级页表的大小都是4KB，正好都是一个页的大小。

我们把第一级页表叫做页目录表，第二级页表叫做页表。其结构如下表所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70_pic_center 2]  
需要注意的一点是，对于左边的页目录表和页表来说，每一个格子代表4字节；对于右边的物理内存来说，每一个格子代表4KB。  
一个页目录项中记录的是一个页表的物理基地址，一个页表项中记录的是一个页的物理基地址。

因此我们将32位的虚拟地址分成了三个部分，最高的10位用于索引页目录表中的一项PDE，中间的10位用于索引页表中的一项PTE，最低的12位用于物理页内寻址。

因此，一个页目录表项对应的地址空间大小为222=4MB。一个页表项对应的地址空间为212=4KB。

以上这些地址转换过程都是由CPU的页部件自动完成的，我们只需设置好两级页表即可。

这两级页表的页表项结构如下所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70_pic_center 3]

# 启动分页机制 #

启用分页机制，我们需要做三件事：

*  准备好页目录表及页表
 *  将页目录表的首地址写入控制寄存器cr3
 *  将寄存器cr0的PG位（第31位置1）

由于控制寄存器cr3用于存储页目录表的物理地址，因此cr3被称为页目录基址寄存器(Page Directory Base Register, PDBR)。其结构如下所示：  
![在这里插入图片描述][20210101220406244.jpg_pic_center]  
其中cr3的低12位中，除了第3位的PWT位和第4位的PCD位之外，其余位都没有使用。

# 虚拟地址空间划分 #

我们仿照linux的做法，将4GB的虚拟地址空间分为两个部分，即0~3GB为用户空间，3GB~4GB为内核空间。操作系统内核就运行在虚拟地址的3GB以上的内存空间中。

也就是说，所有进程的3GB~4GB的虚拟地址空间都指向同一片物理地址区域，这片物理地址区域上就是操作系统的代码。

3GB对应的虚拟地址为0xC0000000，即内核的虚拟地址空间为0xC0000000~0xFFFFFFFF。

# 页表内存布局 #

为简单起见，我们将页目录表放置于物理地址1MB处，即定义页目录表基地址为0x100000。同时，根据页表项结构定义如下宏：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70_pic_center 3]

PAGE_DIR_TABLE_POS equ 0x100000
    
    ;U为1表示处于User级
    PG_US_U equ (0x1 << 2)
    PG_US_S equ (0x0 << 2)
    
    ;RW为1表示该页可读可写
    PG_RW_W equ (0x1 << 1)
    PG_RW_R equ (0x0 << 1)
    
    PG_P equ (0x1 << 0)

由于最终的内核大小只有70KB左右，所以低1MB的地址空间已足够我们使用。所以我们只映射物理地址1MB以下的地址空间，将虚拟地址空间0~1MB映射到物理地址空间0~1MB上。也就是说，在低端1MB的地址空间上，虚拟地址等于物理地址。

同时，由于操作系统内核的虚拟地址空间为0xC0000000以上，我们也要讲从3GB开始的1MB地址空间映射到物理地址的低1MB地址空间上。

0xC0000000的高10位是0x300，即3GB对应页目录表的第0x300项，即第768项。所以我们还要设置第768项页目录表项，让其指向同样的二级页表。由于每个页目录表项大小为4B，所以第768项所对应的物理地址为PAGE\_DIR\_TABLE\_POS +768\*4=PAGE\_DIR\_TABLE\_POS + 0xC00

为了简单起见，我们将页目录表放置在了物理地址0x100000，即1MB起始处。

因为页目录表本身大小为4KB，所以页目录表的物理地址范围是0x100000~0x100FFF。

紧接着页目录表之上，我们放置第一个页表。故第一个页表的物理地址是0x101000。又因为页表的大小也是4KB，所以第一个页表的物理地址范围是0x101000~0x101FFF。

页目录表和所有页表的物理布局的示意图如下图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70_pic_center 4]

# 代码实现 #

## 页目录表清零 ##

我们首先将页目录表所在物理内存块清零：

mov ecx, 1024
    	mov esi, 0
    .clear_page_dir:
    	mov dword [esi + PAGE_DIR_TABLE_POS], 0
    	add esi, 4
    	loop .clear_page_dir

## 创建页目录表 ##

之后，开始创建页目录项，由于我们只想使用虚拟地址0x00000000开始的1MB的内存空间，和虚拟地址0xC0000000开始的1MB的内存空间，所以我们只需创建两个页目录项即可。

我们设置这两个页目录项（虚拟地址从0开始和从3GB开始）都指向同一个页表，该页表位于物理内存地址0x101000，紧挨着页目录表之上。

@create_pde:
    	mov eax, PAGE_DIR_TABLE_POS
    	;我们将第一个页表放在紧挨着页目录表存放
    	add eax, 0x1000
    	or eax, PG_US_U | PG_RW_W | PG_P
    	;在页目录表中第0项处写入第0个页表的起始地址及其属性
    	mov [PAGE_DIR_TABLE_POS + 0x0], eax
    	;我们将虚拟地址3GB处对应的页目录表项也指向同一个二级页表
    	mov [PAGE_DIR_TABLE_POS+0xC00], eax
    	
    	;为了可以通过虚拟地址访问页目录表和页表，我们将最后一个页目录表项指向页目录表的基地址
    	sub eax, 0x1000
    	mov [PAGE_DIR_TABLE_POS + (0x3FF*4)], eax

## 创建页表 ##

之后我们开始创建页表项，由于我们只使用了低1MB的物理地址空间，而每一个页表项对应4KB的页，所以二级页表我们只需设置前256项即可。

;下面开始创建页表
    	;由于我们只需要映射低1MB的地址空间，所以对于二级页表来说，我们只需设置前256项
    	mov ecx, 256
    	mov esi, 0
    	;edx指向的是要映射到的物理地址
    	mov edx, 0
    	or edx, PG_US_U | PG_RW_W | PG_P
    	mov eax, PAGE_DIR_TABLE_POS
    	add eax, 0x1000
    @create_pte:
    	mov [eax + esi*4], edx
    	add edx, 4096
    	inc esi
    	loop @create_pte

## 创建其他内核目录项 ##

为了方便后续所有进程共享整个高1GB的内核虚拟地址空间，最简单的方法就是我们提前将所有属于内核空间的页目录项提前映射到对应的二级页表。

;为了方便后续所有进程共享整个高1GB的内核虚拟地址空间，我们现在就将内核空间的页目录表项全部映射到二级页表
    	mov eax, PAGE_DIR_TABLE_POS
    	add eax, 0x2000
    	;此时eax指向的是第二个页表的物理基地址
    	or eax, PG_US_U | PG_RW_W | PG_P
    	
    	mov ebx, PAGE_DIR_TABLE_POS
    	;和内核相关的页目录表项共有256项
    	;其中第0项和最后一项都已经映射过了，所以现在处理中间的254项
    	mov ecx, 254
    	mov esi, 769
    @create_kernel_pde:
    	mov [ebx + esi*4], eax
    	;一个页表大小为4KB
    	add eax, 0x1000
    	inc esi
    	loop @create_kernel_pde

## 创建页表完整函数 ##

综上所述，整个创建页表的函数如下：

setup_page:
    	mov ecx, 1024
    	mov esi, 0
    .clear_page_dir:
    	mov dword [esi + PAGE_DIR_TABLE_POS], 0
    	add esi, 4
    	loop .clear_page_dir
    	
    @create_pde:
    	mov eax, PAGE_DIR_TABLE_POS
    	;我们将第一个页表放在紧挨着页目录表存放
    	add eax, 0x1000
    	or eax, PG_US_U | PG_RW_W | PG_P
    	;在页目录表中第0项处写入第0个页表的起始地址及其属性
    	mov [PAGE_DIR_TABLE_POS + 0x0], eax
    	;我们将虚拟地址3GB处对应的页目录表项也指向同一个二级页表
    	mov [PAGE_DIR_TABLE_POS+0xC00], eax
    	
    	;为了可以通过虚拟地址访问页目录表和页表，我们将最后一个页目录表项指向页目录表的基地址
    	sub eax, 0x1000
    	mov [PAGE_DIR_TABLE_POS + (0x3FF*4)], eax
    	
    	;下面开始创建页表
    	;由于我们只需要映射低1MB的地址空间，所以对于二级页表来说，我们只需设置前256项
    	mov ecx, 256
    	mov esi, 0
    	;edx指向的是要映射到的物理地址
    	mov edx, 0
    	or edx, PG_US_U | PG_RW_W | PG_P
    	mov eax, PAGE_DIR_TABLE_POS
    	add eax, 0x1000
    @create_pte:
    	mov [eax + esi*4], edx
    	add edx, 4096
    	inc esi
    	loop @create_pte
    	
    	;为了方便后续所有进程共享整个高1GB的内核虚拟地址空间，我们现在就将内核空间的页目录表项全部映射到二级页表
    	mov eax, PAGE_DIR_TABLE_POS
    	add eax, 0x2000
    	;此时eax指向的是第二个页表的物理基地址
    	or eax, PG_US_U | PG_RW_W | PG_P
    	
    	mov ebx, PAGE_DIR_TABLE_POS
    	;和内核相关的页目录表项共有256项
    	;其中第0项和最后一项都已经映射过了，所以现在处理中间的254项
    	mov ecx, 254
    	mov esi, 769
    @create_kernel_pde:
    	mov [ebx + esi*4], eax
    	;一个页表大小为4KB
    	add eax, 0x1000
    	inc esi
    	loop @create_kernel_pde
    	
    	ret

## loader中调用setup\_page ##

为验证虚拟地址是否生效，我们将GDT中显存的基地址移动到高3GB的内核空间中，同时将栈指针同样移动到内核区对应位置。

call setup_page
    	
    	;为验证虚拟地址是否生效，我们将GDT中显存的基地址移动到高3GB的内核空间中
    	sgdt [gdt_ptr]
    	;令eax指向GDT表的基地址
    	mov eax, [gdt_ptr + 2]
    	;令eax指向显存段描述符
    	add eax, 8*3
    	;将GDT中显存的基地址移动到高3GB的内核空间中
    	or dword [eax + 4], 0xC0000000
    	
    	;将栈指针同样移动到内核区对应位置
    	add esp, 0xC0000000
    	
    	;将页目录表地址赋给cr3
    	mov eax, PAGE_DIR_TABLE_POS
    	mov cr3, eax
    	
    	;set cr0 PG
    	mov eax, cr0
    	or eax, (0x1 << 31)
    	mov cr0, eax
    	
    	;将GDT的基地址移动到高3GB的内核空间中
    	or dword [gdt_ptr + 2], 0xC0000000
    	lgdt [gdt_ptr]
    	
    	;由于更改了显存段的基地址，所以需要重新加载gs段寄存器，从而更新gs段信息
    	mov eax, 0x18
    	mov gs, eax
    	
    	mov eax, MsgInVirtualAddr
    	call printString
    	
    	jmp $
    
    MsgInPE: db 'Now running in protection mode!', 0xA, 0xD, 0
    MsgInVirtualAddr: db 'Now running in virtual address space!', 0xA, 0xD, 0

# 实验结果 #

## Virtualbox实验结果 ##

virtualbox启动的动态效果图如下所示：  
![在这里插入图片描述][2021010217273199.gif_pic_center]

我们也可以通过调试模式启动virtualbox，来查看相应寄存器的值：

> $ VBoxManage startvm “OSLab” -E VBOX\_GUI\_DBG\_AUTO\_SHOW=true -E VBOX\_GUI\_DBG\_ENABLED=true  
> $ VBoxManage controlvm “OSLab” resume

我们使用VBoxDbg来查看控制寄存器cr3 cr0、栈指针寄存器esp、全局描述符表寄存器gdtr以及显存段基址的具体值如下所示：  
其中查看CPU寄存器的命令为：

> VBoxDbg> info cpumguest

查看全局描述符表的命令为：

> VBoxDbg> info gdt

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70_pic_center 5]

## bochs实验结果 ##

同样，我们使用bochs来查看实验结果。

1.  使用r|reg|regs|registers任意一个命令查看普通寄存器当前值

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70_pic_center 6]

1.  使用creg来查看控制寄存器的当前值  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70_pic_center 7]
2.  使用sreg来查看段寄存器的当前值  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70_pic_center 8]
3.  使用info gdt来查看全局段描述符表的当前内容  
    ![在这里插入图片描述][20210103113803419.jpg_pic_center]

# 查看并分析最终的页表 #

我们通过bochs来查看最终建立的页表内容，如下所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70_pic_center 9]  
我们可以看到最终生成的虚拟地址映射表中有5条内容。  
前两条映射关系很明了，就是将从虚拟地址0开始的1MB的内存空间映射到物理地址0开始的1MB内存空间上，将虚拟地址3GB开始的1MB的内存空间映射到物理地址0开始的1MB内存空间上。

# 完整实验代码 #

## mbr.s ##

VideoIndexPort equ 0x3D4
    VideoDataPort equ 0x3D5
    
    CursorPosHigh8Index equ 0xE
    CursorPosLow8Index equ 0xF
    
    video_ram_segment   equ  0xB800
    
    mbr_ram_segment equ 0x7C0
    
    LOADER_BASE_ADDR equ 0x500
    
    [bits 16]
    
    ;设置实模式下的堆栈
    segment mbrLoader align=16 vstart=0x7c00
    	xor ax, ax
    	mov ss, ax
    	mov ds, ax
    	mov sp, 0x7c00
    
    	
    ;关中断
    	cli
    	mov eax, loadLoaderMsg
    	call printString
    	
    	;从LBA扇区1开始读取6个扇区
    	mov ecx, 6
    	mov esi, 1
    	mov di, LOADER_BASE_ADDR
    
    @load_loader:	
    	push ecx
    	mov cx, 1
    	call readSectorFromDisk_m16
    	inc esi
    	add di, 512
    	pop ecx
    	loop @load_loader
    	
    	mov eax, LoaderDoneMsg
    	call printString
    	
    	jmp LOADER_BASE_ADDR
    	jmp $
    	
    ;返回值是光标索引，放在寄存器ax中           
    getCursorPosition:
    	push dx
    	mov dx, VideoIndexPort
    	mov al, CursorPosHigh8Index
    	out dx, al
    
    	mov dx, VideoDataPort
    	in al, dx
    	mov ah, al
    
    	mov dx, VideoIndexPort
    	mov al, CursorPosLow8Index
    	out dx, al
    
    	mov dx, VideoDataPort
    	in al, dx
    	
    	pop dx
    	ret
    	
    setCursorPosition:
    	push ax
    	push bx
    	push dx
    	
    	mov bx, ax
    	
    	mov dx, VideoIndexPort
    	mov al, CursorPosHigh8Index
    	out dx, al
    
    	mov dx, VideoDataPort
    	mov al, bh
    	out dx, al 
    
    	mov dx, VideoIndexPort
    	mov al, CursorPosLow8Index
    	out dx, al
    
    	mov dx, VideoDataPort
    	mov al, bl
    	out dx, al
    	
    	pop dx
    	pop bx
    	pop ax	
    	ret
    	
    
    
    ; 打印一个字符，入参存放在寄存器al中
    printCharacter:
    	push es
    	push ds
    	push eax
    	push edi
    	push ebx
    	push ecx
    	
    	; save character to register bl
    	mov bl, al
    	
    	;set video buffer
    	mov eax, video_ram_segment
       	mov es, eax
       	   		
    	;get cursor pos to ax
    	call getCursorPosition
    	;move current cursor pos to di
    	mov di, ax
    	;1 character consumes 2 bytes
    	shl di, 1
    
    	cmp di, 4000
    	;just return if the screen is full
    	je .doneWithPrintCharacter
    	
    	;before output, test if it is carriage return
    	cmp bl, 0xD
    	je .handleCarriageReturn
    	
    	cmp bl, 0xA
    	je .handleNewLine
    	
    	
    	mov byte [es:di], bl	
    	inc di
    	mov byte [es:di], 0x0f
    	inc di
    	jmp .doneWithPrintCharacter
    	
    .handleCarriageReturn:
    	;move cursor to the front of current line
    	xor eax, eax
    	mov ax, di
    	shr ax, 1
    	mov bh, 80
    	div bh
    	mul bh
    	shl ax, 1
    	mov di, ax
    	jmp .doneWithPrintCharacter
    	
    .handleNewLine:
    	xor eax, eax
    	mov ax, di
    	shr ax, 1
    	mov bh, 80
    	div bh
    	cmp al, 24
    	jl .addAnotherNewLine
    	
    	;roll the Screen
    	push edi
    	mov ax, video_ram_segment
    	mov ds, ax
    	mov es, ax
    	cld
    	mov ecx, 1920
    	mov edi, 0
    	mov esi, 160
    	rep movsw
    	;clear screen last line
    	mov ebx, 3840                     
    	mov ecx, 80
     .cls:
    	mov word [es:bx], 0x0720
    	add bx, 2
    	loop .cls
    	; keep the cursor in the same place of the last line
    	pop edi
    	jmp .doneWithPrintCharacter
    	
    .addAnotherNewLine:
    	;just add another new line if it is not the last line
    	add di, 160
    .doneWithPrintCharacter:	
    	;write new cursor pos to video card
    	xor eax, eax
    	mov ax, di
    	shr ax, 1
    	call setCursorPosition
    	
    	pop ecx
    	pop ebx
    	pop edi
    	pop eax
    	pop ds
    	pop es
    	ret
    	
    ;字符串打印函数，首地址存储在寄存器eax中
    printString:
    	push eax
    	push esi
    	
    	;save string start address to si
    	mov esi, eax
    	
    @1: mov al, [esi]
    	cmp al, 0
    	je @2
    	
    	call printCharacter
    	
    	inc esi
    	jmp @1
    	
    @2:
    	pop esi
    	pop eax
    	
    	ret	
    	
    readSectorFromDisk_m16:
    	;注意待读取的字节数不要让di寄存器溢出
    	;保护模式下从硬盘读取指定数量的逻辑扇区
    	;esi=起始逻辑扇区号LBA28
    	;ds:di=目标缓冲区地址
    	;cl中存放的是待读取的扇区数
    
    DataRegister equ 0x1F0
    FeatureRegister equ 0x1F1
    SectorRegister equ 0x1F2
    LBAlowRegister equ 0x1F3
    LBAmidRegister equ 0x1F4
    LBAhighRegister equ 0x1F5
    DeviceRegister equ 0x1F6
    CommandRegister equ 0x1F7
    
    ReadCMD	equ 0x20
    WriteCMD	equ 0x30
    IDCMD		equ 0xEC
    
    	push eax
    	push ebx
    	push ecx
    	push edx
    	push edi
    
    	mov eax, esi
    	
    	mov dx, LBAlowRegister
    	out dx, al
    
    	mov dx, LBAmidRegister
    	shr eax, 8
    	out dx, al
    
    	mov dx, LBAhighRegister
    	shr eax, 16
    	out dx, al
    	
    	mov dx, DeviceRegister
    	;LBA28 mode, master disk
    	and ah, 0x0F
    	mov al, 0xe0
    	or al, ah
    	out dx, al
    	
    	mov dx, SectorRegister
    	mov al, cl
    	out dx, al
    	
    	mov dx, CommandRegister 
    	mov al, ReadCMD
    	out dx, al
    	
    .wait4Ready:
    	in al, dx
    	and al, 0x88
    	cmp al, 0x08
    	jnz .wait4Ready
    	
    	;计算待循环的总次数
    	;一个扇区512字节，由于每次读取2个字节，所以一个扇区要读取256次
    	mov ax, 256
    	;如果是8位乘法，结果默认放在AX中
    	;如果是16位乘法，结果高位默认在DX中存放，低位在AX中存放
    	;乘以待读取的扇区数
    	mul cx
    	
    	;由于cl中存储的是待读取的扇区数，所以扇区数不超过255
    	;所以乘积不会超过65536，ax寄存器足以放得下乘积结果
    	mov cx, ax
    
    	mov dx, DataRegister
    .readSectorData:
    	in ax, dx
    	mov word [di], ax
    	add di, 2
    	loop .readSectorData
    
    	pop edi
    	pop edx
    	pop ecx
    	pop ebx
    	pop eax
    
    	ret
    	
    loadLoaderMsg: db 'Loading loader...', 0xA, 0xD, 0
    LoaderDoneMsg: db 'Now transfer control to loader...', 0xA, 0xD, 0
    
    times 510-($-$$) db 0
    db 0x55,0xaa

## loader.s ##

LOADER_BASE_ADDR equ 0x500
    
    PAGE_DIR_TABLE_POS equ 0x100000
    
    ;U为1表示处于User级
    PG_US_U equ (0x1 << 2)
    PG_US_S equ (0x0 << 2)
    
    ;RW为1表示该页可读可写
    PG_RW_W equ (0x1 << 1)
    
    PG_P equ (0x1 << 0)
    
    ;定义描述符表所用到的宏
    DESC_G_4K equ (0x1 << 23)
    DESC_G_1B equ (0x0 << 23)
    
    ;设置D/B为1，表示是32位
    DESC_D_32 equ (0x1 << 22)
    
    
    ;L位是64位代码段标志，设置为0
    DESC_L equ (0x0 << 21)
    
    
    ;AVL位是用户自定义位，通常由操作系统来使用，这里我们暂设置为0
    DESC_AVL equ (0x0 << 20)
    
    ;设置代码段的限长的最高4位
    DESC_LIMIT_CODE_High4 equ (0xF << 16)
    
    ;设置数据段的限长的最高4位
    DESC_LIMIT_DATA_High4 equ (0xF << 16)
    
    ;用于文本模式的显存地址范围是0xB8000~0xBFFFF，一共32KB(215)大小，故显存段界限为0x7FFF
    ;又由于段粒度为1B，所以段界限长度为0x7FFF，即最高的4位是0
    DESC_LIMIT_VIDEO_High4 equ (0x0 << 16)
    
    
    ;段存在位P用于指示描述符所对应的段是否存在。当P=1时，表示段位于内存中
    DESC_P equ (0x1 << 15)
    
    ;4个特权级
    DESC_DPL_0 equ (0x0 << 13)
    DESC_DPL_1 equ (0x1 << 13)
    DESC_DPL_2 equ (0x2 << 13)
    DESC_DPL_3 equ (0x3 << 13)
    
    ;S位用于表示描述符的类型。当S=0时，表示这是一个系统段；当S=1时，表示这是一个代码段或数据段
    DESC_S_CODE_OR_DATA equ (0x1 << 12)
    DESC_S_SYSTEM equ (0x0 << 12)
    
    ;设置代码段为可执行、不可读、非一致性，访问位清零
    DESC_TYPE_CODE equ (0x8 << 8)
    
    
    ;设置数据段为不可执行、可读可写、向上扩展，访问位清零
    DESC_TYPE_DATA equ (0x2 << 8)
    
    
    ;设置代码段和数据段映射整个4GB地址空间
    DESC_CODE_HIGH32 equ (0x00 << 24) + DESC_G_4K + DESC_D_32 + DESC_L + \
    DESC_AVL + DESC_LIMIT_CODE_High4 + DESC_P + DESC_DPL_0 + DESC_S_CODE_OR_DATA + \
    DESC_TYPE_CODE + 0x00
    
    DESC_DATA_HIGH32 equ (0x00 << 24) + DESC_G_4K + DESC_D_32 + DESC_L + \
    DESC_AVL + DESC_LIMIT_DATA_High4 + DESC_P + DESC_DPL_0 + DESC_S_CODE_OR_DATA + \
    DESC_TYPE_DATA + 0x00
    
    DESC_VIDEO_HIGH32 equ (0x00 << 24) + DESC_G_1B + DESC_D_32 + DESC_L + \
    DESC_AVL + DESC_LIMIT_VIDEO_High4 + DESC_P + DESC_DPL_0 + DESC_S_CODE_OR_DATA + \
    DESC_TYPE_DATA + 0x0B
    
    RPL0 equ (0x0)
    RPL1 equ (0x1)
    RPL2 equ (0x2)
    RPL3 equ (0x3)
    
    TI_GDT equ (0x0 << 2)
    TI_LDT equ (0x1 << 2)
    
    ;loader的入口
    ;构造全局描述符表
    section loader vstart=LOADER_BASE_ADDR
    ;栈底设置在0x7C00处，满减栈
    LOADER_STACK_TOP equ 0x7c00
    jmp loader_start
    
    GDT_BASE:
    	dd 0x0
    	dd 0x0
    CODE_DESC:
    	dd 0xFFFF
    	dd DESC_CODE_HIGH32
    DATA_STACK_DESC:
    	dd 0xFFFF
    	dd DESC_DATA_HIGH32 
    VIDEO_DESC:
    	;我们把显存段基址设置为0xB8000，由于显存范围是0xB8000-0xBFFFF
    	;故显存段的段限长为 0x7FFF
    	dd 0x80007FFF
    	dd DESC_VIDEO_HIGH32 
    
    GDT_SIZE equ $ - GDT_BASE
    GDT_LIMIT equ GDT_SIZE - 1
    ;此处预留60个描述符的空位，以备后续使用
    times 60 dq 0
    
    ;定义三个段描述符选择子
    SELECTOR_CODE equ (0x1 << 3) + TI_GDT + RPL0
    SELECTOR_DATA equ (0x2 << 3) + TI_GDT + RPL0
    SELECTOR_VIDEO equ (0x3 << 3) + TI_GDT + RPL0
    
    gdt_ptr:
    	dw GDT_LIMIT
    	dd GDT_BASE
    
    ;在使能保护模式之前，先调用BIOS获取物理内存容量
    ;为编程简单起见，我们先迭代获取所有的ARDS之后，再统一遍历
    ;我们先定义ARDS的缓冲区，每个ARDS大小为20字节，暂定为10个
    ARDS_BUFFER times 200 db 0
    ARDS_COUNT dw 0
    
    totalMemCapacity dd 0
    
    align 32
    
    loader_start:
    	cli
    
    	;第一次调用时，ebx必须为0
    	xor ebx, ebx
    	mov di, ARDS_BUFFER
    	;固定签名标记
    	mov edx, 0x534D4150
    e820_queryMemCapacityLoop:
    	;每次循环都要指定子功能号
    	mov eax, 0xE820
    	;指定ARDS字节大小
    	mov ecx, 20
    	int 0x15
    	jc e820_err
    	;指向用于存储下一个ARDS的缓冲区
    	add di, cx
    	;记录当前已经读取过的ARDS的数量
    	inc word [ARDS_COUNT]
    	cmp ebx, 0
    	jnz e820_queryMemCapacityLoop
    	;此时已成功获取所有ARDS
    	mov ecx, [ARDS_COUNT]
    	mov ebx, ARDS_BUFFER
    	xor edx, edx
    find_max_mem:
    	mov eax, [ebx]
    	add eax, [ebx+8]
    	add ebx, 20
    	cmp edx, eax
    	jge find_next_mem
    	mov edx, eax
    find_next_mem:
    	loop find_max_mem
    	mov [totalMemCapacity], edx
    	jmp enter_protection_mode
    e820_err:
    	mov ax, 0xb800
    	mov es, ax
    	mov byte [es:0x0], 'E'
    	mov byte [es:0x1], 0xF
    	
    	mov byte [es:0x2], 'r'
    	mov byte [es:0x3], 0xF
    	
    	mov byte [es:0x4], 'r'
    	mov byte [es:0x5], 0xF
    	
    	mov byte [es:0x6], 'o'
    	mov byte [es:0x7], 0xF
    	
    	mov byte [es:0x8], 'r'
    	mov byte [es:0x9], 0xF
    	jmp $ 
    
    enter_protection_mode:
    cli
    
    ;打开A20地址线
    in al, 0x92          ;南桥芯片内的端口 
    or al, 0x2
    out 0x92, al         ;打开A20
    
    ;加载GDTR
    lgdt  [gdt_ptr]
    
    ;使能CR0中的PE位
    mov eax, cr0
    or eax, 0x1
    mov cr0, eax
    
    ;之后，我们需要使用跳转指令来刷新流水线
    jmp SELECTOR_CODE : protectionMode_start
    [bits 32]
    protectionMode_start:
    	mov eax, SELECTOR_DATA
    	mov ds, eax
    	mov es, eax
    	mov ss, eax
    	mov esp, LOADER_STACK_TOP
    	mov eax, SELECTOR_VIDEO
    	mov gs, eax
    
    	mov eax, MsgInPE
    	call printString
    
    	mov eax, totalMemCapacity
    	mov ebx, 4
    	
    	call printByteInHex
    	
    	call setup_page
    	
    	;为验证虚拟地址是否生效，我们将GDT中显存的基地址移动到高3GB的内核空间中
    	sgdt [gdt_ptr]
    	;令eax指向GDT表的基地址
    	mov eax, [gdt_ptr + 2]
    	;令eax指向显存段描述符
    	add eax, 8*3
    	;将GDT中显存的基地址移动到高3GB的内核空间中
    	or dword [eax + 4], 0xC0000000
    	
    	;将栈指针同样移动到内核区对应位置
    	add esp, 0xC0000000
    	
    	;将页目录表地址赋给cr3
    	mov eax, PAGE_DIR_TABLE_POS
    	mov cr3, eax
    	
    	;set cr0 PG
    	mov eax, cr0
    	or eax, (0x1 << 31)
    	mov cr0, eax
    	
    	;将GDT的基地址移动到高3GB的内核空间中
    	or dword [gdt_ptr + 2], 0xC0000000
    	lgdt [gdt_ptr]
    	
    	;由于更改了显存段的基地址，所以需要重新加载gs段寄存器，从而更新gs段信息
    	mov eax, 0x18
    	mov gs, eax
    	
    	mov eax, MsgInVirtualAddr
    	call printString
    	
    	jmp $
    
    MsgInPE: db 'Now running in protection mode!', 0xA, 0xD, 0
    MsgInVirtualAddr: db 'Now running in virtual address space!', 0xA, 0xD, 0
    
    
    VideoIndexPort equ 0x3D4
    VideoDataPort equ 0x3D5
    
    CursorPosHigh8Index equ 0xE
    CursorPosLow8Index equ 0xF
    ;返回值是光标索引，放在寄存器ax中           
    getCursorPosition:
    	push dx
    	mov dx, VideoIndexPort
    	mov al, CursorPosHigh8Index
    	out dx, al
    
    	mov dx, VideoDataPort
    	in al, dx
    	mov ah, al
    
    	mov dx, VideoIndexPort
    	mov al, CursorPosLow8Index
    	out dx, al
    
    	mov dx, VideoDataPort
    	in al, dx
    	
    	pop dx
    	ret
    	
    setCursorPosition:
    	push ax
    	push bx
    	push dx
    	
    	mov bx, ax
    	
    	mov dx, VideoIndexPort
    	mov al, CursorPosHigh8Index
    	out dx, al
    
    	mov dx, VideoDataPort
    	mov al, bh
    	out dx, al 
    
    	mov dx, VideoIndexPort
    	mov al, CursorPosLow8Index
    	out dx, al
    
    	mov dx, VideoDataPort
    	mov al, bl
    	out dx, al
    	
    	pop dx
    	pop bx
    	pop ax	
    	ret
    	
    
    
    ; 打印一个字符，入参存放在寄存器al中
    printCharacter:
    	push es
    	push ds
    	push eax
    	push edi
    	push ebx
    	push ecx
    	
    	; save character to register bl
    	mov bl, al
    	
    	;set video buffer
    	mov eax, SELECTOR_VIDEO
       	mov es, eax
       	   		
    	;get cursor pos to ax
    	call getCursorPosition
    	;move current cursor pos to di
    	mov di, ax
    	;1 character consumes 2 bytes
    	shl di, 1
    
    	cmp di, 4000
    	;just return if the screen is full
    	je .doneWithPrintCharacter
    	
    	;before output, test if it is carriage return
    	cmp bl, 0xD
    	je .handleCarriageReturn
    	
    	cmp bl, 0xA
    	je .handleNewLine
    	
    	
    	mov byte [es:di], bl	
    	inc di
    	mov byte [es:di], 0x0f
    	inc di
    	jmp .doneWithPrintCharacter
    	
    .handleCarriageReturn:
    	;move cursor to the front of current line
    	xor eax, eax
    	mov ax, di
    	shr ax, 1
    	mov bh, 80
    	div bh
    	mul bh
    	shl ax, 1
    	mov di, ax
    	jmp .doneWithPrintCharacter
    	
    .handleNewLine:
    	xor eax, eax
    	mov ax, di
    	shr ax, 1
    	mov bh, 80
    	div bh
    	cmp al, 24
    	jl .addAnotherNewLine
    	
    	;roll the Screen
    	push edi
    	mov ax, SELECTOR_VIDEO
    	mov ds, ax
    	mov es, ax
    	cld
    	mov ecx, 1920
    	mov edi, 0
    	mov esi, 160
    	rep movsw
    	;clear screen last line
    	mov ebx, 3840                     
    	mov ecx, 80
     .cls:
    	mov word [es:bx], 0x0720
    	add bx, 2
    	loop .cls
    	; keep the cursor in the same place of the last line
    	pop edi
    	jmp .doneWithPrintCharacter
    	
    .addAnotherNewLine:
    	;just add another new line if it is not the last line
    	add di, 160
    .doneWithPrintCharacter:	
    	;write new cursor pos to video card
    	xor eax, eax
    	mov ax, di
    	shr ax, 1
    	call setCursorPosition
    	
    	pop ecx
    	pop ebx
    	pop edi
    	pop eax
    	pop ds
    	pop es
    	ret
    	
    ;字符串打印函数，首地址存储在寄存器eax中
    printString:
    	push eax
    	push esi
    	
    	;save string start address to si
    	mov esi, eax
    	
    @1: mov al, [esi]
    	cmp al, 0
    	je @2
    	
    	call printCharacter
    	
    	inc esi
    	jmp @1
    	
    @2:
    	pop esi
    	pop eax
    	
    	ret	
    
    ;ax start address
    ;bx bytes	
    printByteInHex:
    	;对本函数中使用到的寄存器入栈保存
    	push eax
    	push di
    	push cx
    	push es
    	push si
    	push bx
    	push dx
    	
    	;si寄存器用于保存当前待打印的字节所在的地址
    	mov si, ax
    	mov cx, bx
    	;dx寄存器用于计数，每行打印16个字符后换行
    	mov dx, 0
    
    	;初始化显存 段寄存器
    	mov eax, SELECTOR_VIDEO
    	mov es, eax
    
    	;di用于显存的索引
    	xor di, di
    	;begin with another line
    	;add di, 160
    myloop:
    	;取出待打印的当前字节到寄存器al中
    	mov al, [si]
    	inc si
    	;将al字节的高4位放到bl的低4位中
    	mov bl, 0xF0
    	and bl, al
    	shr bl, 4
    	;将高4位对应的数字转换为 数字字符形式
    	add bl, 0x30
    	;如果该数字超过10，则使用A~F来表示
    	cmp bl, 0x3A
    	jl @number0
    	add bl, 7
    @number0:
    	;将转换好的高4位以十六进制字符形式输出到显存上
    	mov [es:di], bl
    	inc di
    	mov byte [es:di], 0x07
    	inc di
    	;按照上述步骤 同样处理本字节的低4位
    	mov bl, 0xF
    	and bl, al
    	add bl, 0x30
    	cmp bl, 0x3A
    	jl @number1
    	add bl, 7
    @number1:
    	mov [es:di], bl
    	inc di
    	mov byte [es:di], 0x07
    	inc di
    	;之后添加空格
    	mov byte [es:di], 0x20
    	inc di
    	mov byte [es:di], 0x07
    	inc di
    	
    	;统计每行已打印的字节数，满16个字节换行
    	inc dx
    	cmp dx, 0x10
    	jne noNewLine
    	;因为文本模式每行可显示80个字符，而 一个字节对应两个十六进制的字符外加一个空格
    	;所以当打印完毕16个字节后，本行已打印的字符数为16*3=48，故本行还剩余的字符数为80-48=32
    	;又由于一个字符对应显存的两个字节位置，所以本行需要的偏移值为32*2=64
    	add di, 64
    	mov dx, 0
    noNewLine:	
    	loop myloop
    
    	;全部字节打印完毕，弹栈
    	pop dx
    	pop bx
    	pop si
    	pop es
    	pop cx
    	pop di
    	pop eax
    	ret	
    	
    	
    setup_page:
    	mov ecx, 1024
    	mov esi, 0
    .clear_page_dir:
    	mov dword [esi + PAGE_DIR_TABLE_POS], 0
    	add esi, 4
    	loop .clear_page_dir
    	
    @create_pde:
    	mov eax, PAGE_DIR_TABLE_POS
    	;我们将第一个页表放在紧挨着页目录表存放
    	add eax, 0x1000
    	or eax, PG_US_U | PG_RW_W | PG_P
    	;在页目录表中第0项处写入第0个页表的起始地址及其属性
    	mov [PAGE_DIR_TABLE_POS + 0x0], eax
    	;我们将虚拟地址3GB处对应的页目录表项也指向同一个二级页表
    	mov [PAGE_DIR_TABLE_POS+0xC00], eax
    	
    	;为了可以通过虚拟地址访问页目录表和页表，我们将最后一个页目录表项指向页目录表的基地址
    	sub eax, 0x1000
    	mov [PAGE_DIR_TABLE_POS + (0x3FF*4)], eax
    	
    	;下面开始创建页表
    	;由于我们只需要映射低1MB的地址空间，所以对于二级页表来说，我们只需设置前256项
    	mov ecx, 256
    	mov esi, 0
    	;edx指向的是要映射到的物理地址
    	mov edx, 0
    	or edx, PG_US_U | PG_RW_W | PG_P
    	mov eax, PAGE_DIR_TABLE_POS
    	add eax, 0x1000
    @create_pte:
    	mov [eax + esi*4], edx
    	add edx, 4096
    	inc esi
    	loop @create_pte
    	
    	;为了方便后续所有进程共享整个高1GB的内核虚拟地址空间，我们现在就将内核空间的页目录表项全部映射到二级页表
    	mov eax, PAGE_DIR_TABLE_POS
    	add eax, 0x2000
    	;此时eax指向的是第二个页表的物理基地址
    	or eax, PG_US_U | PG_RW_W | PG_P
    	
    	mov ebx, PAGE_DIR_TABLE_POS
    	;和内核相关的页目录表项共有256项
    	;其中第0项和最后一项都已经映射过了，所以现在处理中间的254项
    	mov ecx, 254
    	mov esi, 769
    @create_kernel_pde:
    	mov [ebx + esi*4], eax
    	;一个页表大小为4KB
    	add eax, 0x1000
    	inc esi
    	loop @create_kernel_pde
    	
    	ret

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/21aff7fed7fb4ae4b13c6766baea8ead.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221120/388a6282a5de44e7a939aca7124f248e.png
[2021010114345681.jpg_pic_center]: /images/20221120/0717d6e4f97643d08b3d05e3c8a93a78.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221120/8ce6751a1e1945f48f8e8cb8b7b194e3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221120/b844aac68e4243aab869764a16d220fa.png
[20210101220406244.jpg_pic_center]: /images/20221120/9ff34af35dc145b589ff67dc01dcb731.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221120/622f435801fa4514a274fa540f37d138.png
[2021010217273199.gif_pic_center]: /images/20221120/1fe2f8686be34347a9afb7a7b8af2ab1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221120/b856ec9ccef1407d9d28c9d7a02ef5c6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221120/5c93b40501e74e5bb53d251d5f439c48.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20221120/c222d7c740cb4153b65bbf5d4766a0db.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20221120/49acf56e348c4323b99ce4897e03ba6d.png
[20210103113803419.jpg_pic_center]: /images/20221120/8649ddf078fa407cacf03665d2d3fc51.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70_pic_center 9]: /images/20221120/372c0f38c80a4ea68c49890ecc93bc73.png