操作系统学习


阅读数: 次   

学习路线

学习网站

https://objectkuan.gitbooks.io/ucore-docs/content/lab0.html

进行学习

实验步骤

  1. 启动操作系统的bootloader ，用于了解操作系统启动前的状态 和要做的准备工作，了解运行操作系统的 硬件支持 ，操作系统如何加载到内存中，理解两类中断–“外设中断”，“陷阱中断”等；
  2. 物理内存管理子系统，用于理解x86分段/分页模式，了解操作系统 如何管理物理内存；
  3. 虚拟内存管理子系统，通过页表机制 和 换入换出（swap）机制 ，以及 中断-“故障中断”、缺页故障处理等，实现基于页的内存替换算法；
  4. 内核线程子系统，用于了解如何创建相对与用户进程更加简单的内核态线程 ，如果对内核线程进行动态管理等；
  5. 用户进程管理子系统，用于了解用户态进程创建、执行、切换和结束的动态管理过程，了解在用户态通过系统调用得到内核态的内核服务的过程；
  6. 处理器调度子系统，用于理解操作系统的 调度过程 和 调度算法 ；
  7. 同步互斥与进程间通信子系统，了解进程间如何进行信息交换和共享，并了解同步互斥的具体实现以及对系统性能的影响，研究死锁产生的原因，以及如何避免死锁；
  8. 文件系统，了解文件系统的具体实现，与进程管理等的关系，了解缓存对操作系统IO访问的性能改进，了解虚拟文件系统（VFS）、buffer cache和disk driver之间的关系。

ucore系统结构图

项目下载地址

https://github.com/chyyuu/ucore_lab

实验环境

docker: 0xc4m3l/pwndocker

用到 qemu https://objectkuan.gitbooks.io/ucore-docs/content/lab0/lab0_2_4_2_1_qemu_runtime_arguments.html

Mac 键盘切出 qemu control + option + x

视频中的知识点

https://www.bilibili.com/video/BV1js411b7vg

计算机的启动

image-20200813115119885

  1. 内存加载硬盘的 bootloader

    Bootloader 放在硬盘的第一个主引导扇区（512字节）

  2. Bootloader 加载 OS（操作系统的代码，数据） 到内存

    这个时候 CPU 控制权给了 bootloader

    跳转到 操作系统运行

image-20200814150756482

十六进制对应 中断类型码

image-20200814164633990

应用程序无法直接访问磁盘设备 （利用磁盘读写的系统调用接口 -> 内核 -> 应用程序）

image-20200814163629986

操作系统 –> 外设 中断，IO

操作系统 –> 应用程序 系统调用，异常

  • 系统调用：(来源于应用程序)应用程序主动向操作系统发出服务请求。

  • 异常：(来源于不良的应用程序)非法指令或其它花的处理状态(e.g.内存出错)。

  • 中断：(来源于外设)来自不同的硬件设备的计时器和网络的中断。

产生的源头

  • 中断：外设(键盘/鼠标/网卡/声卡/显卡，可以产生各种事件)
  • 异常：应用程序意想不到的行为(e.g.异常，恶意程序，应用程序需要的资源未得到满足)
  • 系统调用(system call)：应用程序请求操作提供服务(e.g.打开/关闭/读写文件，发送网络包)

两个概念：用户态和内核态

  • 用户态：
    应用程序在执行的过程中，cpu所处于的一个特权级的状态，其特权级特别低，不能访问某些特殊的机器指令和io
  • 内核态：
    操作系统运行过程中cpu所处于的一个状态，cpu可以执行任何的一条特权指令和io，可以完全的控制这个计算机系统

操作系统是一个软件。

实现 程序重定位，分段，分页，虚拟内存，按需分页虚拟内存

其实现高度依赖于硬件，必须知道内存架构，MMU（内存管理单元）：硬件组件负责处理cpu的内存访问请求。

地址空间的定义

  1. 物理地址空间—与硬件直接对于（例如内存条所代表的主存）
  2. 逻辑地址空间—程序所看见的地址空间

逻辑地址空间 –> 落实到物理地址空间存在。程序分配一个 4G 虚拟内存，程序中的代码的位置，最终在 主存或者硬盘中通过操作系统规定

应用程序的生成

在这里插入图片描述

.o file – link –> .exe file（硬盘中）

.exe file – loader –> 运行 （放到内存中运行）逻辑地址

当cpu需要执行这条指令的过程如下：

在这里插入图片描述

  1. ALU运算器需要这条指令的内容

  2. cpu里面的mmu（内存管理单元）查找逻辑地址的映射表，找出逻辑地址和物理地址之间的映射

  3. cpu控制器会从总线发送物理地址的内存内容的请求（就是指令的内容）

  4. 主存会把总线拿到的物理地址内存的内容传给cpu

    其中，操作系统的作用是建立起逻辑地址和物理地址之间的映射。

压缩式（compression）碎片整理

利用拷贝 进行整合

内存拷贝前思考两个问题：

1）什么时候考虑内存的重定位是合适的

当程序处于等待的状态之中可以开始内存的重定位

2）考虑开销大不大

仅仅利用软件的移动实现开销是很大的

在这里插入图片描述

交换式（swap）碎片整理

当运行 p1 p2 p3 p4 时主存已经被装满。但是 p3运行中需要更多的内存，这个时候。我们可以将等待的程序数据放到磁盘中，然后扩充p3 需要的内存大小。这样保存程序的内存分配正常。

在这里插入图片描述

选择非连续内存分配

  • 一个程序的物理地址空间是非连续的
  • 更好的内存利用和管理 减少外碎片，内碎片的问题
  • 允许共享代码与数据（共享库等…）
  • 支持动态加载和动态链接

虚拟的逻辑地址空间是 连续的但是却分散在多个 物理地址空间中。

实现 数据隔离。动态库共享。 有效的管理分配，同时保证保护机制的实现

在这里插入图片描述

虚线左右通过 映射关系进行 映射

映射之后：位置不一样，大小也不一样

在这里插入图片描述

线性地址空间

操作系统的虚存管理之下每个运行的应用程序能访问的地址空间。

每个运行的应用程序都认为自己独享整个计算机系统的地址空间，这样可让多个运行的应用程序之间相互隔离。

逻辑地址空间

应用程序直接使用的地址空间

image-20200814113306178

lab0

基础知识

OS Kernel的特征：

  • 并发: 指一段时间内多个程序运行；而并行是指一个时间点上多个程序运行，要求多个CPU

  • 共享：“同时”访问 或 互斥共享

  • 虚拟：利用多道程序设计技术，让每一个用户都觉得有一个计算机专门为他服务

  • 异步：程序的执行不是一步到底的，而是走走停停，向前推进的速度不可预知

    但只要运行环境相同，OS要保证程序运行的结果也相同

在uCore内核使用了大量的双向循环链表结构来组织数据，包括空闲内存块列表、内存页链表、进程列表、设备链表、文件系统列表等的数据组织。

uCore的双向链表结构定义为：

1
2
3
struct list_entry {
    struct list_entry *prev, *next;
};

链表节点list_entry没有包含传统的data数据域

插入（__list_add_after）

1
2
3
4
5
6
static inline void
__list_add(list_entry_t *elm, list_entry_t *prev, list_entry_t *next) {
    prev->next = next->prev = elm;
    elm->next = next;
    elm->prev = prev;
}

*删除 list_del(list_entry_t listelm)

1
2
3
4
5
6
7
8
9
static inline void
list_del(list_entry_t *listelm) {
    __list_del(listelm->prev, listelm->next);
}
static inline void
__list_del(list_entry_t *prev, list_entry_t *next) {
    prev->next = next;
    next->prev = prev;
}

访问链表节点所在的宿主数据结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
//free_area是空闲块管理结构，free_area.free_list是空闲块链表头
free_area_t free_area;
list_entry_t * le = &free_area.free_list;  //le是空闲块链表头指针
while((le=list_next(le)) != &free_area.free_list) { //从第一个节点开始遍历
    struct Page *p = le2page(le, page_link); //获取节点所在基于Page数据结构的变量
    ……
}
// ---------------------------------------------
// convert list entry to page
#define le2page(le, member)                 \
to_struct((le), struct Page, member)

/* Return the offset of 'member' relative to the beginning of a struct type */
#define offsetof(type, member)                                      \
((size_t)(&((type *)0)->member))

/* *
 * to_struct - get the struct from a ptr
 * @ptr:    a struct pointer of member
 * @type:   the type of the struct this is embedded in
 * @member: the name of the member within the struct
 * */
#define to_struct(ptr, type, member)                               \
((type *)((char *)(ptr) - offsetof(type, member)))

lab1

实验

https://chyyuu.gitbooks.io/ucore_os_docs/content/lab1/lab1_1_goals.html

对于调试不能使用 pwndbg 只能使用 peda

知识点

初始化

image-20200813115119885

  1. BIOS 工作 ：初始化底层硬件 ，保证机器能进行之后工作

  2. 加载第一个扇区 （bootloader) —> 512字节 实际大小没有512

    Booloader 做的事情

    从实模式（16位寻址空间） 切换到 保护模式（32位寻址空间） 1MB -> 4GB

    读取 硬盘 中的 ucore 代码到 内存，控制权交给 ucore。（跳转过去执行 ucore ）的代码

  3. 执行 OS 代码

段机制管理

一种映射关系

通过 index 在段的表 Descriptor Table 中找到 对应起始位置和长度

起始位置 + offset（EIP） 得到对应的 地址

如果其实地址为 0 得到的地址就是物理地址

image-20200814204507350

  • 机制的建立 需要一个 大的数组（储存段描述符）全局描述符表 (GDT) 由 操作系统建立

    GDT 由 bootloader load GDT 是计算机得到 GDT 的描述

    计算机就能找到 GDT 的位置

    利用内部寄存器 GDTR 保存相应地址信息

  • 段表的 index (16位) CS

    高 13 位 对应 GDT 对应的索引 index

    低 2 位 0 1 2 3 对应 特权级 内核 0 程序 3

    倒数第 3 位 0（GDT 表）1（LDT表）

image-20200814210438457

x86 中断处理过程

每个中断 或者 异常都有一个 中断服务 例程 (ISR) 关联 关联储存在 中断描述符表 (IDT) 大数组

IDT 的表信息 起始地址 长度 保存在 寄存器 IDTR 中

软中断 （trap） 陷阱

更具中断号 中断门 (陷阱门 trap) –> 进一步获得 端的选择址

image-20200814220253257

取出 IDT 中的段选择址 （作为index） 从而在 GDT 找到对应的 段描述符 从而找到 中断服务例程 ISR

image-20200814220801654

发生 中断 打断正在执行的 程序 执行 中断服务例程（ISR） 执行完才继续运行程序

段描述符 CS 最低两位设置 特权级 0内核 3用户

  • 内核态 中断 栈地址还是在内核态 同一个 stack

  • 用户态 中断 栈地址跳转到内核态 stack1 -- 跳转--> stack2

iret 中断例程返回

​ 根据 cs eip 返回原来位置 还原 EFlAGS

ret + retf 函数返回

​ ret 只返回 EIP

​ retf 返回 EIP 恢复 cs 实现远程跳转

练习1：

题目

在此练习中，大家需要通过静态分析代码来了解：

  1. 操作系统镜像文件ucore.img是如何一步一步生成的？(需要比较详细地解释Makefile中每一条相关命令和命令参数的含义，以及说明命令导致的结果)
  2. 一个被系统认为是符合规范的硬盘主引导扇区的特征是什么？

问题1

这里利用 Make V=

对源代码进行了 编译 生成了 kernel bootblock sign tools ucore.img 镜像

  1. 利用 gcc 编译成 .o 的目标文件

  2. 然后利用 ld 将目标文件 转换成 执行程序 .out 文件

  3. 利用 dd 将bootblock 和 kernel 放到虚拟硬盘 ucore.img 中

    image-20200815105108026

问题2

  • 大小为 512 字节

  • 阅读源码lab1/tools/sign.c 发现 最后的 两个字节 为 0x55 , 0xAA

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    #include <stdio.h>
    #include <errno.h>
    #include <string.h>
    #include <sys/stat.h>

    int main(int argc, char *argv[]) {
        struct stat st;
        if (argc != 3) {
            fprintf(stderr, "Usage: <input filename> <output filename>\n");
            return -1;
        }
        if (stat(argv[1], &st) != 0) {
            fprintf(stderr, "Error opening file '%s': %s\n", argv[1], strerror(errno));
            return -1;
        }
        printf("'%s' size: %lld bytes\n", argv[1], (long long)st.st_size);
        if (st.st_size > 510) {
            fprintf(stderr, "%lld >> 510!!\n", (long long)st.st_size);
            return -1;
        }
        char buf[512];
        memset(buf, 0, sizeof(buf));
        FILE *ifp = fopen(argv[1], "rb");
        int size = fread(buf, 1, st.st_size, ifp);
        if (size != st.st_size) {
            fprintf(stderr, "read '%s' error, size is %d.\n", argv[1], size);
            return -1;
        }
        fclose(ifp);
        buf[510] = 0x55;
        buf[511] = 0xAA;
        FILE *ofp = fopen(argv[2], "wb+");
        size = fwrite(buf, 1, 512, ofp);
        if (size != 512) {
            fprintf(stderr, "write '%s' error, size is %d.\n", argv[2], size);
            return -1;
        }
        fclose(ofp);
        printf("build 512 bytes boot sector: '%s' success!\n", argv[2]);
        return 0;
    }

练习2

gdb 调试

这里我们 使用 gdb 进行调试

我们可以利用 gdb 插件 pwngdb + peda

1
2
3
cd ~/
git clone https://github.com/scwuaptx/Pwngdb.git 
cp ~/Pwngdb/.gdbinit ~/

题目

为了熟悉使用qemu和gdb进行的调试工作，我们进行如下的小练习：

  1. 从CPU加电后执行的第一条指令开始，单步跟踪BIOS的执行。
  2. 在初始化位置0x7c00设置实地址断点,测试断点正常。
  3. 从0x7c00开始跟踪代码运行,将单步跟踪反汇编得到的代码与bootasm.S和 bootblock.asm进行比较。
  4. 自己找一个bootloader或内核中的代码位置，设置断点并进行测试。

回答

我们查看 tools/gdbinit 的内容

image-20200815150956323

这里 我们如果直接 运行 make lab1-mon 我们就直接 断点在了 0x7c00 也就是 bootloader 的其实位置

根据汇编就能完成题目的 1.2

让比较 gdb 中的代码和 bootasm.S和 bootblock.asm 发现是基本一样的

发现程序 已经 运行到我们的 bootloader 了

说明我们的 qemu 已经加载了 对应的 bootloader

调试也就是简单的 gdb 调试就好

练习3

分析bootloader进入保护模式的过程。bootloader 实现的功能

BIOS将通过读取硬盘主引导扇区到内存，并转跳到对应内存中的位置执行bootloader。请分析bootloader是如何完成从实模式进入保护模式的。

  • bootloader 会开启 80386 的保护模式。进入32位寻址空间

  • 开启A20，开启A20

  • 初始化GDT表

  • 使能和进入保护模式

保护模式和分段机制

实模式

加载完 bootloader PC处于 实模式 （16位模式） 当前访问的空间 不能超过 1mb.

通过修改 A20地址线 可以完成从 实模式 –> 保护模式 的转换。

保护模式

  • （32位模式） 可寻址高达4G字节的线性地址空间和物理地址空间，可访问64TB（有2^14个段，每个段最大空间为2^32字节）的逻辑地址空间，可采用分段存储管理机制和分页存储管理机制。

  • 不仅为存储共享和保护提供了硬件支持，而且为实现虚拟存储提供了硬件支持。

  • 通过 4个特权级和完善的特权检查机制 实现 资源共享和代码安全

  • 保护模式下，有两个段表 ：GDT（Global Descriptor Table） 和 LDT（Local Descriptor Table），每一张段表可以包含8192 (2^13)个描述符[1]，因而最多可以同时存在2 * 2^13 = 2^14个段。

  • 逻辑地址空间看起来很大，但实际上段并不能扩展物理地址空间，很大程度上各个段的地址空间是相互重叠的。

分段存储管理机制

保护模式下启动 分段存储管理机制

  • 内存划分成以 起始地址 和 长度限制 这两个二维参数表示的内存块，这些内存块就称之为段（Segment）。

  • 分段机涉及4个关键内容：

    • 逻辑地址
    • 段描述符（描述段的属性）
    • 段描述符表（包含多个段描述符的“数组”）
    • 段选择子（段寄存器，用于定位段描述符表中表项的索引）。

逻辑地址（Logical Address,应用程序员看到的地址）到物理地址（Physical Address, 实际的物理内存地址）

  1. 分段地址转换 段描述符表 的索引，找到表中对应的段描述符，然后把段描述符中保存的段基址 加上段偏移值，形成线性地址（Linear Address）。

  2. 分页地址转换 线性地址转换为物理地址。 (这一步是可选的，由操作系统决定是否需要)

为了使得分段存储管理机制正常运行，需要建立好 段描述符 和 段描述符表

段描述符
  • 段基地址：规定线性地址空间中段的起始地址。
  • 段界限：规定段的大小。 段界限可以是以字节为单位或以4K字节（页表）为单位。
  • 段属性：确定段的各种性质。
保护模式下的特权级

在保护模式下，特权级总共有4个，编号从0（最高特权）到3（最低特权）。

x86 CPU都是在一个特定的特权级下运行的

关于A20 Gate

开启A20是为了能够在保护模式下正常访问超出1MB的内存且不会发生回卷，否则在保护模式下只能访问奇数位的内存

理论上讲，我们只要操作8042芯片的输出端口（64h）的bit 1，就可以控制A20 Gate，但实际上，当你准备向8042的输入缓冲区里写数据时，可能里面还有其它数据没有处理，所以，我们要首先禁止键盘操作，同时等待数据缓冲区中没有数据以后，才能真正地去操作8042打开或者关闭A20 Gate。

打开A20 Gate的具体步骤大致如下：

  1. 等待8042 Input buffer为空
  2. 发送Write 8042 Output Port （P2） 命令到8042 Input buffer
  3. 等待8042 Input buffer为空
  4. 将8042 Output Port（P2） 对应字节的第2位置1，然后写入8042 Input buffer

初始化 GDT 表

GDT初始化的代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#define SEG_NULLASM                                             \
    .word 0, 0;                                                 \
    .byte 0, 0, 0, 0

#define SEG_ASM(type,base,lim)                                  \
    .word (((lim) >> 12) & 0xffff), ((base) & 0xffff);          \
    .byte (((base) >> 16) & 0xff), (0x90 | (type)),             \
        (0xC0 | (((lim) >> 28) & 0xf)), (((base) >> 24) & 0xff)

gdt:
    /* 有一个特殊的选择子称为空(Null)选择子，它的Index=0，TI=0，而RP
    L字段可以为任意值。空选择子有特定的用途，当用空选择子进行存储访
    问时会引起异常。空选择子是特别定义的，它不对应于全局描述符表GDT
    中的第0个描述符，因此处理器中的第0个描述符总不被处理器访问，一
    般把它置成全0。*/
    SEG_NULLASM                                     # null seg
    
    /* 在Lab1中, code segment和data segment都可以访问整个内存空间 */
    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:
    /* lgdt 要先载入GDT的大小, 然后才是gdt的地址 */
    .word 0x17                                      # sizeof(gdt) - 1
    .long gdt                                       # address gdt

CPU通过lgdt指令读入GDT的地址，之后我们就可以使用GDT了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
.set PROT_MODE_CSEG,        0x8   
.set PROT_MODE_DSEG,        0x10

/* 载入GDT */
lgdt gdtdesc

/* 从实模式切换到保护模式*/
movl %cr0, %eax
orl $CR0_PE_ON, %eax
movl %eax, %cr0

# ljmp <imm1>, <imm2>
# %cs ← imm1
# %ip ← imm2
/* 将%cs(code segment)的值设置为0x8 */
ljmp $PROT_MODE_CSEG, $protcseg

...

protcseg:
    # Set up the protected-mode data segment registers
    /* 设置data segment 的值 */
    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

如何使能和进入保护模式

将cr0的最低为设置为1

1
2
3
4
5
movl %cr0, %eax
orl $CR0_PE_ON, %eax
movl %eax, %cr0

.set CR0_PE_ON,             0x1                     # protected mode enable flag

练习4

问题

分析bootloader加载ELF格式的OS的过程。

bootmain.c 了解bootloader如何加载ELF文件。

  • bootloader如何读取硬盘扇区的？
  • bootloader是如何加载ELF格式的OS？

硬盘访问概述

  • bootloader让CPU进入保护模式后，下一步的工作就是从硬盘上加载并运行OS。

  • bootloader的访问硬盘都是LBA模式的PIO（Program IO）方式，即所有的IO操作是通过CPU访问硬盘的IO地址寄存器完成。

当前 硬盘数据是储存到硬盘扇区中，一个扇区大小为512字节。读一个扇区的流程

（可参看boot/bootmain.c中的readsect函数实现）大致如下：

  1. 等待磁盘准备好
  2. 发出读取扇区的命令
  3. 等待磁盘准备好
  4. 把磁盘扇区数据读到指定内存

bootloader如何读取硬盘扇区

利用到 readsect 函数读取扇区 用到 outb 指令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/* waitdisk - wait for disk ready */
static void waitdisk(void) {
    // 获取并判断磁盘是否处于忙碌状态
    while ((inb(0x1F7) & 0xC0) != 0x40)
        /* do nothing */;
}

static void readsect(void *dst, uint32_t secno) {
    // wait for disk to be ready
    waitdisk();

    outb(0x1F2, 1);                         // 读取1个扇区
    outb(0x1F3, secno & 0xFF);              // 对应参数0x1F3-0x1F6寄存器中
    outb(0x1F4, (secno >> 8) & 0xFF);
    outb(0x1F5, (secno >> 16) & 0xFF);
    outb(0x1F6, ((secno >> 24) & 0xF) | 0xE0);
    outb(0x1F7, 0x20);                      // cmd 0x20 - read sectors

    // wait for disk to be ready
    waitdisk();

    // read a sector
    insl(0x1F0, dst, SECTSIZE / 4);   // 从0x1F0寄存器读数据，写到dst。同时，insl以4字节为单位，所以长度 /4
}

ELF文件格式概述

ELF 文件结构 elf.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
struct elfhdr {
  uint magic;  // must equal ELF_MAGIC
  uchar elf[12];
  ushort type;
  ushort machine;
  uint version;
  uint entry;  // 程序入口的虚拟地址
  uint phoff;  // program header 表的位置偏移
  uint shoff;
  uint flags;
  ushort ehsize;
  ushort phentsize;
  ushort phnum; //program header表中的入口数目
  ushort shentsize;
  ushort shnum;
  ushort shstrndx;
};

程序 头表结构 属于什么节，节在文件当中起始位置，虚拟地址，物理地址，文件长度，虚拟空间长度等。

1
2
3
4
5
6
7
8
9
10
11
struct proghdr {
  uint type;   // 段类型
  uint offset;  // 段相对文件头的偏移值
  uint va;     // 段的第一个字节将被放到内存中的虚拟地址
  uint pa;
  uint filesz;
  uint memsz;  // 段在内存映像中占用的字节数
  uint flags;
  uint align;
};

bootloader是如何加载ELF格式的OS

主要会利用到的代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
bootmain(void) {
    // 读取ELF头部 magic
    readseg((uintptr_t)ELFHDR, SECTSIZE * 8, 0);

    // 判断读取到的 ELFHDR的是否表明这个文件是ELF  magic是否是7f 45 4c 46
    if (ELFHDR->e_magic != ELF_MAGIC) {
        goto bad;
    }

    struct proghdr *ph, *eph;

    // 获取程序头表在在ELF文件结构中的偏移，获取程序头表表项的数量
    // 因为可执行文件需要将.init节，.text节，.radata节，.data节，.bss节映射到存储空间的相应的段里面（代码段，数据段）
    ph = (struct proghdr *)((uintptr_t)ELFHDR + ELFHDR->e_phoff);
    eph = ph + ELFHDR->e_phnum;
    
  	// 将ELF文件内数据载入内存
    for (; ph < eph; ph ++) {
        readseg(ph->p_va & 0xFFFFFF, ph->p_memsz, ph->p_offset);
    }

    // 根据程序起始位置，找到内核入口
    // 可执行目标文件中e_entry给出执行程序时第一条指令的地址（0x8048580)
    // 可重定位文件中e_entry为0
    ((void (*)(void))(ELFHDR->e_entry & 0xFFFFFF))();

bad:
  	// 如果错误 outw 读取
    outw(0x8A00, 0x8A00);
    outw(0x8A00, 0x8E00);

    /* do nothing */
    while (1);
}

练习5

问题

我们需要在lab1中完成 lab1/kern/debug/kdebug.c 中函数print_stackframe的实现，可以通过函数print_stackframe来跟踪函数调用堆栈中记录的返回地址。

显示结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
……
ebp:0x00007b28 eip:0x00100992 args:0x00010094 0x00010094 0x00007b58 0x00100096
    kern/debug/kdebug.c:305: print_stackframe+22
ebp:0x00007b38 eip:0x00100c79 args:0x00000000 0x00000000 0x00000000 0x00007ba8
    kern/debug/kmonitor.c:125: mon_backtrace+10
ebp:0x00007b58 eip:0x00100096 args:0x00000000 0x00007b80 0xffff0000 0x00007b84
    kern/init/init.c:48: grade_backtrace2+33
ebp:0x00007b78 eip:0x001000bf args:0x00000000 0xffff0000 0x00007ba4 0x00000029
    kern/init/init.c:53: grade_backtrace1+38
ebp:0x00007b98 eip:0x001000dd args:0x00000000 0x00100000 0xffff0000 0x0000001d
    kern/init/init.c:58: grade_backtrace0+23
ebp:0x00007bb8 eip:0x00100102 args:0x0010353c 0x00103520 0x00001308 0x00000000
    kern/init/init.c:63: grade_backtrace+34
ebp:0x00007be8 eip:0x00100059 args:0x00000000 0x00000000 0x00000000 0x00007c53
    kern/init/init.c:28: kern_init+88
ebp:0x00007bf8 eip:0x00007d73 args:0xc031fcfa 0xc08ed88e 0x64e4d08e 0xfa7502a8
<unknow>: -- 0x00007d72 –
……

布局图

1
2
3
4
5
6
7
8
9
+|  栈底方向        | 高位地址
 |    ...        |
 |    ...        |
 |  参数3        |
 |  参数2        |
 |  参数1        |
 |  返回地址        |
 |  上一层[ebp]    | <-------- [ebp]
 |  局部变量        |  低位地址

结果

根据代码的 注释 编写 print_stackframe(void) 函数

1
2
3
4
5
6
7
8
9
10
11
12
/* LAB1 YOUR CODE : STEP 1 */
     /* (1) call read_ebp() to get the value of ebp. the type is (uint32_t);
      * (2) call read_eip() to get the value of eip. the type is (uint32_t);
      * (3) from 0 .. STACKFRAME_DEPTH
      *    (3.1) printf value of ebp, eip
      *    (3.2) (uint32_t)calling arguments [0..4] = the contents in address (uint32_t)ebp +2 [0..4]
      *    (3.3) cprintf("\n");
      *    (3.4) call print_debuginfo(eip-1) to print the C calling function name and line number, etc.
      *    (3.5) popup a calling stackframe
      *           NOTICE: the calling funciton's return addr eip  = ss:[ebp+4]
      *                   the calling funciton's ebp = ss:[ebp]
      */

更具注释完成代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
void print_stackframe(void) {
     // 读取当前栈帧的ebp和eip
    // (1) call read_ebp() to get the value of ebp. the type is (uint32_t);
    uint32_t ebp = read_ebp();
    // (2) call read_eip() to get the value of eip. the type is (uint32_t);
    uint32_t eip = read_eip();

    for(uint32_t i = 0; ebp != 0 && i < STACKFRAME_DEPTH; i++)
    {
        // 读取
        // (3.1) printf value of ebp, eip
        cprintf("ebp:0x%08x eip:0x%08x args:", ebp, eip);
        // (3.2) (uint32_t)calling arguments [0..4] = the contents in address (uint32_t)ebp +2 [0..4]
        uint32_t* args = (uint32_t*)ebp + 2 ;
        for(uint32_t j = 0; j < 4; j++)
            cprintf("0x%08x ", args[j]);
        cprintf("\n");
        // eip指向异常指令的下一条指令，所以要减1
        // (3.4) call print_debuginfo(eip-1) to print the C calling function name and line number, etc.
        print_debuginfo(eip-1);
        // 将ebp 和eip设置为上一个栈帧的ebp和eip
        //  注意要先设置eip后设置ebp，否则当ebp被修改后，eip就无法找到正确的位置
        eip = ((uint32_t *)ebp)[1];
        ebp = ((uint32_t *)ebp)[0];
    }
}

练习6

问题

请完成编码工作和回答如下问题：

  1. 中断描述符表（也可简称为保护模式下的中断向量表）中一个表项占多少字节？其中哪几位代表中断处理代码的入口？
  2. 请编程完善kern/trap/trap.c中对中断向量表进行初始化的函数idt_init。在idt_init函数中，依次对所有中断入口进行初始化。使用mmu.h中的SETGATE宏，填充idt数组内容。每个中断的入口由tools/vectors.c生成，使用trap.c中声明的vectors数组即可。
  3. 请编程完善trap.c中的中断处理函数trap，在对时钟中断进行处理的部分填写trap函数中处理时钟中断的部分，使操作系统每遇到100次时钟中断后，调用print_ticks子程序，向屏幕上打印一行文字”100 ticks”。
问题1

表结构如下，中断描述符表一个表项占8个字节

1
2
3
4
5
6
7
8
9
10
11
struct gatedesc {
    unsigned gd_off_15_0 : 16;        // low 16 bits of offset in segment
    unsigned gd_ss : 16;            // segment selector
    unsigned gd_args : 5;            // # args, 0 for interrupt/trap gates
    unsigned gd_rsv1 : 3;            // reserved(should be zero I guess)
    unsigned gd_type : 4;            // type(STS_{TG,IG32,TG32})
    unsigned gd_s : 1;                // must be 0 (system)
    unsigned gd_dpl : 2;            // descriptor(meaning new) privilege level
    unsigned gd_p : 1;                // Present
    unsigned gd_off_31_16 : 16;        // high bits of offset in segment
};

16~31位为段选择子。通过段选择子获得段基址，加上段内偏移量即可得到中断处理代码的入口。

问题2

要求

1
2
3
4
5
6
7
8
9
10
11
12
13
/* LAB1 YOUR CODE : STEP 2 */
    /* (1) Where are the entry addrs of each Interrupt Service Routine (ISR)?
     *     All ISR's entry addrs are stored in __vectors. where is uintptr_t __vectors[] ?
     *     __vectors[] is in kern/trap/vector.S which is produced by tools/vector.c
     *     (try "make" command in lab1, then you will find vector.S in kern/trap DIR)
     *     You can use  "extern uintptr_t __vectors[];" to define this extern variable which will be used later.
     * (2) Now you should setup the entries of ISR in Interrupt Description Table (IDT).
     *     Can you see idt[256] in this file? Yes, it's IDT! you can use SETGATE macro to setup each item of IDT
     * (3) After setup the contents of IDT, you will let CPU know where is the IDT by using 'lidt' instruction.
     *     You don't know the meaning of this instruction? just google it! and check the libs/x86.h to know more.
     *     Notice: the argument of lidt is idt_pd. try to find it!
     */

实现代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
void idt_init(void) {
     /* LAB1 YOUR CODE : STEP 2 */
     /* (1) Where are the entry addrs of each Interrupt Service Routine (ISR)?
      *     All ISR's entry addrs are stored in __vectors. where is uintptr_t __vectors[] ?
      *     __vectors[] is in kern/trap/vector.S which is produced by tools/vector.c
      *     (try "make" command in lab1, then you will find vector.S in kern/trap DIR)
      *     You can use  "extern uintptr_t __vectors[];" to define this extern variable which will be used later.
      * (2) Now you should setup the entries of ISR in Interrupt Description Table (IDT).
      *     Can you see idt[256] in this file? Yes, it's IDT! you can use SETGATE macro to setup each item of IDT
      * (3) After setup the contents of IDT, you will let CPU know where is the IDT by using 'lidt' instruction.
      *     You don't know the meaning of this instruction? just google it! and check the libs/x86.h to know more.
      *     Notice: the argument of lidt is idt_pd. try to find it!
      */
    extern uintptr_t __vectors[]; 
    int i;
    for (i = 0; i < sizeof(idt) / sizeof(struct gatedesc); i ++) {
        // 第二个参数0代表中断门，
      	//第三个参数是中断处理例程的代码段GD_KTEXT
      	//第四个参数是对应的偏移量
      	//第五个参数是特权级
        SETGATE(idt[i], 0, GD_KTEXT, __vectors[i], DPL_KERNEL);
    }
    // 从用户态切换到内核态
    SETGATE(idt[T_SWITCH_TOK], 0, GD_KTEXT, __vectors[T_SWITCH_TOK], DPL_USER);
    // 将中断门描述符表的起始地址装入IDTR寄存器中
    lidt(&idt_pd);
}
问题3

实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
static uint16_t tick = 0;
/* trap_dispatch - dispatch based on what type of trap occurred */
static void trap_dispatch(struct trapframe *tf) {
    char c;

    switch (tf->tf_trapno) {
    case IRQ_OFFSET + IRQ_TIMER:
        /* LAB1 YOUR CODE : STEP 3 */
        /* handle the timer interrupt */
        /* (1) After a timer interrupt, you should record this event using a global variable (increase it), such as ticks in kern/driver/clock.c
         * (2) Every TICK_NUM cycle, you can print some info using a funciton, such as print_ticks().
         * (3) Too Simple? Yes, I think so!
         */
        if(tick == TICK_NUM){
            print_ticks();
            tick = 0;
        }
        tick++;
        break;
    case IRQ_OFFSET + IRQ_COM1:
        c = cons_getc();
        cprintf("serial [%03d] %c\n", c, c);
        break;
    case IRQ_OFFSET + IRQ_KBD:
        c = cons_getc();
        cprintf("kbd [%03d] %c\n", c, c);
        break;
    //LAB1 CHALLENGE 1 : YOUR CODE you should modify below codes.
    case T_SWITCH_TOU:
    case T_SWITCH_TOK:
        panic("T_SWITCH_** ??\n");
        break;
    case IRQ_OFFSET + IRQ_IDE1:
    case IRQ_OFFSET + IRQ_IDE2:
        /* do nothing */
        break;
    default:
        // in kernel, it must be a mistake
        if ((tf->tf_cs & 3) == 0) {
            print_trapframe(tf);
            panic("unexpected trap in kernel.\n");
        }
    }
}
赏

谢谢你请我吃糖果

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家