操作系统实验一到实验九合集(哈工大李治军)

Posted 2023-04-04 Casten-Wang

操作系统实验

作者寄语

操作系统实验的学习是一个循序渐进的过程，初次看linux-0.11中的代码，看着满屏的汇编语言，确实头疼。但通过学习赵炯博士的Linux内核0.11完全注释，结合着王爽老师的汇编语言一书，我逐渐理解每段汇编语言的含义和作用。本文主要是通过对哈工大李治军配套实验的实现，着重解释每一段的汇编代码，使读者对实验的整体脉络有一个初步的认识，不再因为畏惧汇编而不放弃实验。本文只是抛砖引玉，希望读者可以深入研究我下文提供的参考资料，做到理论与实践兼具。

参考资料

• 视频:操作系统
• 书籍:现代操作系统
• 实验:操作系统原理与实践
• 书籍:王道操作系统
• 书籍:Linux内核完全注释
• 书籍:汇编语言(第3版) 王爽著

目录

文章目录

• 操作系统实验
• • 作者寄语
  • 参考资料
  • 目录
  • 实验一 熟悉实验环境
  • 实验二 操作系统的引导
  • • 汇编知识
    • • int 0x10
      • int 0x13
      • int 0x15
      • int 0x41
      • CF
      • jnc
      • jl
      • lds
      • DF标志和串传送指令
      • call
      • ret
    • 改写bootsect.s
    • bootsect.s读入setup.s
    • setup.s获取基本硬件参数
    • 天道酬勤
  • 实验三 系统调用
  • • 提醒
    • 实验目的
    • 应用程序如何调用系统调用
    • 从“int 0x80”进入内核函数
    • 实现 sys_iam() 和 sys_whoami()
    • 按照上述逻辑修改相应文件
    • 修改 Makefile
    • • （1）第一处
      • （2）第二处
    • 编写测试程序
    • 天道酬勤
  • 实验四 进程运行轨迹的跟踪与统计
  • • 实验目的
    • 实验内容
    • 编写process.c文件
    • • 提示
      • 文件主要作用
      • 关键函数解释
      • • fork()
        • struct tms 结构体
        • 数据类型 clock_t
      • 代码实现
      • 答疑
    • 尽早打开log文件
    • • 小结
    • 编写fprintk()函数
    • jiffies，滴答
    • 寻找状态切换点
    • • 例子 1：记录一个进程生命期的开始
      • 例子 2：记录进入睡眠态的时间
      • 修改fork.c文件
      • 修改sched.c文件
      • • 修改schedule函数
        • 修改sys_pause函数
        • 修改sleep_on函数
        • 修改interruptible_sleep_on函数
        • 修改wake_up函数
      • 修改exit.c文件
      • 小结
    • 编译
    • 编译运行process.c
    • process.log自动化分析
    • 修改时间片
    • 问题回答
    • • 问题1：单进程编程和多进程编程的区别？
      • 问题2：仅针对样本程序建立的进程，在修改时间片前后，log 文件的统计结果都是什么样？结合你的修改分析一下为什么会这样变化，或者为什么没变化？
    • 警示
    • 天道酬勤
  • 实验五 基于内核栈切换的进程切换
  • • 实验目的
    • 实验内容
    • TSS 切换
    • 本次实验的内容
    • 正式修改代码前小结
    • schedule 与 switch_to
    • 实现 switch_to
    • 修改fork()系统调用
    • 编译运行
    • 天道酬勤
  • 实验六 信号量的实现和应用
  • • 实验目的
    • 实验内容
    • • 用信号量解决生产者—消费者问题
      • 实现信号量
    • 什么是信号量？
    • 思路
    • 用户程序 pc.c
    • • 知识点
      • 信号量作用
      • 代码展示
    • 修改内核
    • • 编写 sem.h
      • 编写 sem.c
      • 添加系统调用号
      • 改写系统调用数
      • 添加系统调用的定义
      • 修改工程文件的编译规则
      • Debug
    • 挂载文件
    • 测试
    • 天道酬勤
  • 实验七 地址映射与共享
  • • 实验目的
    • 实验内容
    • • 1 跟踪地址翻译过程
      • 2 基于共享内存的生产者—消费者程序
      • 3 共享内存的实现
    • 创建test.c
    • 跟踪地址翻译过程
    • • 1.准备
      • 2.暂停
      • 3.段表
      • 4.段描述符
      • 5.段基址和线性地址
      • 6.页表
      • 7.物理地址
    • 添加系统调用号
    • 添加系统调用的定义
    • 改写系统调用数
    • 编写 shm.c
    • 修改工程文件的编译规则
    • 编写消费者和生产者程序
    • • 编写producer.c
      • 编写consumer.c
    • 运行验证
    • 天道酬勤
  • 实验八 终端设备的控制
  • • 实验目的
    • 实验内容
    • 实验思路
    • • 键盘中断初始化
      • 键盘中断发生
      • 字符输出流程
    • 添加`F12`功能键盘处理
    • 添加字符`*`显示处理
    • 编译运行
    • 实验问题
    • 天道酬勤
  • 实验九 proc文件系统的实现
  • • 实验目的
    • 实验内容
    • procfs介绍
    • 增加新文件类型
    • 让 `mknod()` 支持新的文件类型
    • `procfs` 的初始化工作
    • 让 `proc` 文件可读
    • 实现 `proc_read` 函数
    • 编译运行
    • 天道酬勤
  • 终章

实验一 熟悉实验环境

只是熟悉实验环境，我没有使用蓝桥云课的实验环境，而是通过阿里云服务器搭建了linux环境，有需要的可以看以下2篇文章

• 阿里云服务器Ubuntu14.04（64位）安装图形化界面_leoabcd12的博客-CSDN博客
• 阿里云ubuntu系统配置linux-0.11（哈工大 李治军）实验环境搭建_leoabcd12的博客-CSDN博客

实验二 操作系统的引导

Linux 0.11 文件夹中的 boot/bootsect.s、boot/setup.s 和 tools/build.c 是本实验会涉及到的源文件。它们的功能详见《Linux内核0.11完全注释》的 6.2、6.3 节和 16 章。

汇编知识

简要整理了一下这次实验所需的基础汇编知识，可以在下文阅读代码是碰到再回过头来看！

int 0x10

注意，这里ah要先有值，代表内部子程序的编号

功能号 $ah=0x03$​​​，作用是读取光标的位置

• 输入：bh = 页号
• 返回：ch = 扫描开始线；cl = 扫描结束线；dh = 行号；dl = 列号

功能号 $ah=0x13$，作用是显示字符串

• 输入：al = 放置光标的方式及规定属性，下文 al＝1，表示目标字符串仅仅包含字符，属性在BL中包含，光标停在字符串结尾处；es:bp = 字符串起始位置；cx = 显示的字符串字符数；bh = 页号；bl = 字符属性，下文 bl = 07H，表示正常的黑底白字；dh = 行号；dl = 列号

功能号 $ah=0x0e$​，作用是显示字符

• 输入：al = 字符

int 0x13

在DOS等实模式操作系统下，调用INT 13h会跳转到计算机的ROM-Bios代码中进行低级磁盘服务，对程序进行基于物理扇区的磁盘读写操作。

功能号 $ah=0x02$，作用是读磁盘扇区到内存

• 输入：

  寄存器	含义
  ah	读磁盘扇区到内存
  al	需要读出的扇区数量
  ch	磁道
  cl	扇区
  dh	磁头
  dl	驱动器
  es:bx	数据缓冲区的地址

• 返回：ah = 出错码（00H表示无错，01H表示非法命令，02H表示地址目标未发现…）；CF为进位标志位，如果没有出错 $CF=0$​

功能号 $ah=0x00$​，作用是磁盘系统复位

• 输入：dl = 驱动器
• 返回：如果操作成功———— $CF=0$​​，$ah=00H$​​

这里我只挑了下文需要的介绍，更多内容可以参考这篇博客BIOS系统服务 —— 直接磁盘服务（int 0x13）

int 0x15

功能号 $ah=0x88$，作用是获取系统所含扩展内存大小

• 输入：ah = 0x88
• 返回：ax = 从0x100000(1M)处开始的拓展内存大小(KB)。若出错则CF置位，ax = 出错码。

int 0x41

在PC机中BIOS设定的中断向量表中int 0x41的中断向量位置 ($4\ast 0x41=0x0000:0x0104$​​​)存放的并不是中断程序的地址,而是第一个硬盘的基本参数表。对于100%兼容的BIOS来说,这里存放着硬盘参数表阵列的首地址0xF000:0E401，第二个硬盘的基本参数表入口地址存于int 0x46中断向量位置处.每个硬盘参数表有16个字节大小.

位移	大小	说明
0x00	字	柱面数
0x02	字节	磁头数
…	…	…
0x0E	字节	每磁道扇区数
0x0F	字节	保留

CF

要了解CF，首先要知道寄存器中有一种特殊的寄存器————标志寄存器，其中存储的信息通常被称为程序状态字。以下简称为flag寄存器。

flag和其他寄存器不一样，其他寄存器是用来存放数据的，都是整个寄存器具有一个含义。而flag寄存器是按位起作用的，也就是说，它的每一位都有专门的含义，记录特定的信息。

flag的1、3、5、12、13、14、15位在8086CPU中没有使用，不具有任何含义。而0、2、4、6、7、8、9、10、11位都具有特殊的含义。

CF就是flag的第0位————进位标志位。在进行无符号数运算的时候，它记录了运算结果的最高有效位向更高位的进位值，或从更高位的借位值。

jnc

在 $CF=0$​​​ 的时候，进行跳转，即不进位则跳转，下文就是在读入没有出错时，跳转到ok_load_setup

jl

小于则跳转

lds

格式： LDS reg16，mem32

其意义是同时给一个段寄存器和一个16位通用寄存器同时赋值

举例：

地址	100H	101H	102H	103H
内容	00H	41H	02H	03H

LDS AX,[100H]
! 结果：AX=4100H  DS=0302H

可以把上述代码理解为这样一个过程，但实际上不能这么写

mov AX,[100H]
mov DS,[100H+2]

即把低字(2B)置为偏移地址，高字(2B)置为段地址

DF标志和串传送指令

flag的第10位是DF,方向标志位。在串处理指令中，控制每次操作后si、di的增减。

• df=0：每次操作后si、di递增
• df=1：每次操作后si、di递减

来看一个串传送指令

• 格式：movsb

• 功能：相当于执行了如下2步操作

  1. $((es)\ast 16+(di))=((ds)\ast 16+si)$

  2. 如果df=0：(si)=(si)+1,(di)=(di)+1

     如果df=1：(si)=(si)-1,(di)=(di)-1

可以看出，movsb的功能是将 $ds:si$ 指向的内存单元中的字节送入 $es:di$中，然后根据标志寄存器df位的值，将si和di递增或递减。

也可以传送一个字

• 格式：movsw

• 功能：相当于执行了如下2步操作

  1. $((es)\ast 16+(di))=((ds)\ast 16+si)$

  2. 如果df=0：(si)=(si)+2,(di)=(di)+2

     如果df=1：(si)=(si)-2,(di)=(di)-2

可以看出，movsw的功能是将 $ds:si$ 指向的内存单元中的字节送入 $es:di$​中，然后根据标志寄存器df位的值， 将si和di递增2或递减2。

movsb和movsw进行的是串传送操作的一个步骤，一般配合rep使用

格式如下：rep movsb

用汇编语法描述：

s:movsb
 loop s

可见rep的作用是根据cx的值，重复执行串传送指令。由于每执行一次movsb指令si和di都会递增或递减指向后面一个单元或前面一个单元，则 rep movsb就可以循环实现(cx)个字符的传送。

call

(1) 将当前IP或CS和IP压入栈中

(2) 转移

CPU执行“call 标号”时，相当于进行：

push IP
jmp near ptr 标号

ret

ret指令用栈中的数据，修改IP的内容，从而实现近转移

(1) $(IP)=((ss)\ast 16+(sp))$

(2) $(sp)=(sp)+2$​

CPU执行ret指令时，相当于进行：

pop IP

改写bootsect.s

打开 bootsect.s

Loading system ...就是开机时显示在屏幕上的字，共16字符，加上3个换行+回车，一共是24字符。我将要修改他为Hello OS world, my name is WCF，30字符，加上3个换行+回车，共36字符。所以图一代码修改为mov cx.#36。

将 .org 508 修改为 .org 510，是因为这里不需要 root_dev: .word ROOT_DEV，为了保证 boot_flag 一定在引导扇区最后两个字节，所以要修改 .org。.org 510 表示下面语句从地址510(0x1FE)开始，用来强制要求boot_flag一定在引导扇区的最后2个字节中（第511和512字节）。

完整的代码如下：

entry _start
_start:
    mov ah,#0x03        ! 设置功能号
    xor bh,bh           ! 将bh置0
    int 0x10            ! 返回行号和列号，供显示串用
    mov cx,#52          ！要显示的字符串长度
    mov bx,#0x0007      ! bh=0,bl=07(正常的黑底白字)
    mov bp,#msg1        ! es:bp 要显示的字符串物理地址
    mov ax,#0x07c0      ! 将es段寄存器置为#0x07c0
    mov es,ax           
    mov ax,#0x1301      ! ah=13(设置功能号),al=01(目标字符串仅仅包含字符，属性在BL中包含，光标停在字符串结尾处)
    int 0x10            ! 显示字符串

! 设置一个无限循环(纯粹为了能一直看到字符串显示)
inf_loop:
    jmp inf_loop

! 字符串信息
msg1:
    .byte   13,10           ! 换行+回车
    .ascii  "Welcome to the world without assembly language"
    .byte   13,10,13,10     ! 换行+回车

! 将
.org 510

! 启动盘具有有效引导扇区的标志。仅供BIOS中的程序加载引导扇区时识别使用。它必须位于引导扇区的最后两个字节中
boot_flag:
    .word   0xAA55

Ubuntu 上先从终端进入 ~/oslab/linux-0.11/boot/目录

执行下面两个命令编译和链接 bootsect.s：

$ as86 -0 -a -o bootsect.o bootsect.s
$ ld86 -0 -s -o bootsect bootsect.o

其中 bootsect.o 是中间文件。bootsect 是编译、链接后的目标文件。

需要留意的文件是 bootsect 的文件大小是 544 字节，而引导程序必须要正好占用一个磁盘扇区，即 512 个字节。造成多了 32 个字节的原因是 ld86 产生的是 Minix 可执行文件格式，这样的可执行文件处理文本段、数据段等部分以外，还包括一个 Minix 可执行文件头部，它的结构如下：

struct exec 
    unsigned char a_magic[2];  //执行文件魔数
    unsigned char a_flags;
    unsigned char a_cpu;       //CPU标识号
    unsigned char a_hdrlen;    //头部长度，32字节或48字节
    unsigned char a_unused;
    unsigned short a_version;
    long a_text; long a_data; long a_bss; //代码段长度、数据段长度、堆长度
    long a_entry;    //执行入口地址
    long a_total;    //分配的内存总量
    long a_syms;     //符号表大小
;

6 char（6 字节）+ 1 short（2 字节） + 6 long（24 字节）= 32，正好是 32 个字节，去掉这 32 个字节后就可以放入引导扇区了。

对于上面的 Minix 可执行文件，其 a_magic[0]=0x01，a_magic[1]=0x03，a_flags=0x10（可执行文件），a_cpu=0x04（表示 Intel i8086/8088，如果是 0x17 则表示 Sun 公司的 SPARC），所以 bootsect 文件的头几个字节应该是 01 03 10 04。为了验证一下，Ubuntu 下用命令hexdump -C bootsect可以看到：

去掉这 32 个字节的文件头部

$ dd bs=1 if=bootsect of=Image skip=32

生成的 Image 就是去掉文件头的 bootsect。

去掉这 32 个字节后，将生成的文件拷贝到 linux-0.11 目录下，并一定要命名为“Image”（注意大小写）。然后就“run”吧！

# 当前的工作路径为 /oslab/linux-0.11/boot/
# 将刚刚生成的 Image 复制到 linux-0.11 目录下
$ cp ./Image ../Image
# 执行 oslab 目录中的 run 脚本
$ ../../run

bootsect.s读入setup.s

首先编写一个 setup.s，该 setup.s 可以就直接拷贝前面的 bootsect.s（还需要简单的调整），然后将其中的显示的信息改为：“Now we are in SETUP”。

和前面基本一样，就不注释了。

entry _start
_start:
	mov ah,#0x03
	xor bh,bh
	int 0x10
	mov cx,#25
	mov bx,#0x0007
	mov bp,#msg2
	mov ax,cs				! 这里的cs其实就是这段代码的段地址
	mov es,ax
	mov ax,#0x1301
	int 0x10
inf_loop:
	jmp inf_loop
msg2:
	.byte	13,10
	.ascii	"Now we are in SETUP"
	.byte	13,10,13,10
.org 510
boot_flag:
	.word	0xAA55

接下来需要编写 bootsect.s 中载入 setup.s 的关键代码

所有需要的功能在原版 bootsect.s 中都是存在的，我们要做的仅仅是将这些代码添加到新的 bootsect.s 中去。

除了新增代码，我们还需要去掉在 bootsect.s 添加的无限循环。

SETUOLEN=2              ! 读入的扇区数
SETUPSEG=0x07e0         ! setup代码的段地址
entry _start
_start:
    mov ah,#0x03        ! 设置功能号
    xor bh,bh           ! 将bh置0
    int 0x10            ! 返回行号和列号，供显示串用
    mov cx,#52          ！要显示的字符串长度
    mov bx,#0x0007      ! bh=0,bl=07(正常的黑底白字)
    mov bp,#msg1        ! es:bp 要显示的字符串物理地址
    mov ax,#0x07c0      ! 将es段寄存器置为#0x07c0
    mov es,ax           
    mov ax,#0x1301      ! ah=13(设置功能号),al=01(目标字符串仅仅包含字符，属性在BL中包含，光标停在字符串结尾处)
    int 0x10            ! 显示字符串

! 将setup模块从磁盘的第二个扇区开始读到0x7e00
load_setup:
    mov dx,#0x0000                  ! 磁头=0；驱动器号=0
    mov cx,#0x0002                  ! 磁道=0；扇区=2
    mov bx,#0x0200                  ! 偏移地址
    mov ax,#0x0200+SETUPLEN         ! 设置功能号；需要读出的扇区数量
    int 0x13                        ! 读磁盘扇区到内存
    jnc ok_load_setup               ! CF=0(读入成功)跳转到ok_load_setup  
    mov dx,#0x0000                  ! 如果读入失败，使用功能号ah=0x00————磁盘系统复位
    mov ax,#0x0000
    int 0x13
    jmp load_setup                  ! 尝试重新读入

ok_load_setup:
    jmpi    0,SETUPSEG              ! 段间跳转指令，跳转到setup模块处(0x07e0:0000)

! 字符串信息
msg1:
    .byte   13,10           ! 换行+回车
    .ascii  "Welcome to the world without assembly language"
    .byte   13,10,13,10     ! 换行+回车

! 将
.org 510

! 启动盘具有有效引导扇区的标志。仅供BIOS中的程序加载引导扇区时识别使用。它必须位于引导扇区的最后两个字节中
boot_flag:
    .word   0xAA55

再次编译

$ make BootImage

有 Error！这是因为 make 根据 Makefile 的指引执行了 tools/build.c，它是为生成整个内核的镜像文件而设计的，没考虑我们只需要 bootsect.s 和 setup.s 的情况。它在向我们要 “系统” 的核心代码。为完成实验，接下来给它打个小补丁。c

build.c 从命令行参数得到 bootsect、setup 和 system 内核的文件名，将三者做简单的整理后一起写入 Image。其中 system 是第三个参数（argv[3]）。当 “make all” 或者 “makeall” 的时候，这个参数传过来的是正确的文件名，build.c 会打开它，将内容写入 Image。而 “make BootImage” 时，传过来的是字符串 “none”。所以，改造 build.c 的思路就是当 argv[3] 是"none"的时候，只写 bootsect 和 setup，忽略所有与 system 有关的工作，或者在该写 system 的位置都写上 “0”。

修改工作主要集中在 build.c 的尾部，可长度以参考下面的方式，将圈起来的部分注释掉。

重新编译

$ cd ~/oslab/linux-0.11
$ make BootImage
$ ../run

setup.s获取基本硬件参数

这里把一些难以理解的代码单独列出来

1. 获得磁盘参数

这里花了我很长时间，原因是概念没有搞清楚，我觉得老师在实验指导书上写的也不是很清楚，CSDN上都只是草草复制的代码，感觉他们可以压根没有理解这一段。

先来回顾一下上文的一个概念：int 0x41

在PC机中BIOS设定的中断向量表中int 0x41的中断向量位置 ($4\ast 0x41=0x0000:0x0104$​)存放的并不是中断程序的地址,而是第一个硬盘的基本参数表。对于100%兼容的BIOS来说,这里存放着硬盘参数表阵列的首地址0xF000:0E401，第二个硬盘的基本参数表入口地址存于int 0x46中断向量位置处.每个硬盘参数表有16个字节大小.

这段话是重点，我之前误理解为磁盘参数就存放在以0x0000:0x0104为首地址的单元中，总共占16个字节，但实际上，只存了4个字节，里面存放的是磁盘参数表的偏移地址和段地址，也就是上文所说这里存放着硬盘参数表阵列的首地址0xF000:0E401。

lds    si,[4*0x41]

再看这行代码就可以理解了，这里是把0x0000:0x0104单元存放的值（表示硬盘参数表阵列的首地址的偏移地址）赋给si寄存器，把0x0000:0x0106单元存放的值（表示硬盘参数表阵列的首地址的段地址）赋给ds寄存器。

2. 参数以十六进制方式显示

先说说浪费我很长时间的我的错误：我想的是一个ASCII码8位，为什么答案里是4位4位输出，这里是搞清楚显示的目的。显示的是存在内存单元里的16进制数，例如某个字(2个字节)中的数值为 $019A$​，我所要显示的不是01和9A表示的ASCII码，而是显示019A本身，所以要4位4位显示。

以十六进制方式显示比较简单。这是因为十六进制与二进制有很好的对应关系（每 4 位二进制数和 1 位十六进制数存在一一对应关系），显示时只需将原二进制数每 4 位划成一组，按组求对应的 ASCII 码送显示器即可。ASCII 码与十六进制数字的对应关系为：0x30 ～ 0x39 对应数字 0 ～ 9，0x41 ～ 0x46 对应数字 a ～ f。从数字 9 到 a，其 ASCII 码间隔了 7h，这一点在转换时要特别注意。为使一个十六进制数能按高位到低位依次显示，实际编程中，需对 bx 中的数每次循环左移一组（4 位二进制），然后屏蔽掉当前高 12 位，对当前余下的 4 位（即 1 位十六进制数）求其 ASCII 码，要判断它是 0 ～ 9 还是 a ～ f，是前者则加 0x30 得对应的 ASCII 码，后者则要加 0x37 才行，最后送显示器输出。以上步骤重复 4 次，就可以完成 bx 中数以 4 位十六进制的形式显示出来。

下面是提供的参考代码

INITSEG  = 0x9000                   ! 参数存放位置的段地址
entry _start
_start:
! 打印 "NOW we are in SETUP"
    mov ah,#0x03
    xor bh,bh
    int 0x10
    mov cx,#25
    mov bx,#0x0007
    mov bp,#msg2
    mov ax,cs
    mov es,ax
    mov ax,#0x1301
    int 0x10

! 获取光标位置
    mov ax,#INITSEG
    mov ds,ax
    mov ah,#0x03
    xor bh,bh
    int 0x10                        ! 返回：dh = 行号；dl = 列号
    mov [0],dx                      ! 存储到内存0x9000:0处

! 获取内存大小
    mov ah,#0x88
    int 0x15                        ! 返回：ax = 从0x100000(1M)处开始的扩展内存大小(KB)
    mov [2],ax                      ! 将扩展内存数值存放在0x90002处（1个字）

! 读第一个磁盘参数表复制到0x90004处
    mov ax,#0x0000
    mov ds,ax
    lds si,[4*0x41]                 ! 把低字(2B)置为偏移地址，高字(2B)置为段地址
    mov ax,#INITSEG
    mov es,ax
    mov di,#0x0004
    mov cx,#0x10                    ! 重复16次，即传送16B
    rep
    movsb                           ! 按字节传送

! 打印前的准备
    mov ax,cs
    mov es,ax
    mov ax,#INITSEG
    mov ds,ax

! 打印"Cursor position:"
    mov ah,#0x03
    xor bh,bh
    int 0x10
    mov cx,#18
    mov bx,#0x0007
    mov bp,#msg_cursor
    mov ax,#0x1301
    int 0x10

! 打印光标位置
    mov dx,[0]
    call    print_hex

! 打印"Memory Size:"
    mov ah,#0x03
    xor bh,bh
    int 0x10
    mov cx,#14
    mov bx,#0x0007
    mov bp,#msg_memory
    mov ax,#0x1301
    int 0x10

! 打印内存大小
    mov dx,[2]
    call    print_hex

! 打印"KB"
    mov ah,#0x03
    xor bh,bh
    int 0x10
    mov cx,#2
    mov bx,#0x0007
    mov bp,#msg_kb
    mov ax,#0x1301
    int 0x10

! 打印"Cyls:" 
    mov ah,#0x03
    xor bh,bh
    int 0x10
    mov cx,#7
    mov bx,#0x0007
    mov bp,#msg_cyles
    mov ax,#0x1301
    int 0x10

! 打印柱面数   
    mov dx,[4]
    call    print_hex

! 打印"Heads:"
    mov ah,#0x03
    xor bh,bh
    int 0x10
    mov cx,#8
    mov bx,#0x0007
    mov bp,#msg_heads
    mov ax,#0x1301
    int 0x10

! 打印磁头数
    mov dx,[6]
    call    print_hex

! 打印"Sectors:"
    mov ah,#0x03
    xor bh,bh
    int 0x10
    mov cx,#10
    mov bx,#0x0007
    mov bp,#msg_sectors
    mov ax,#0x1301
    int 0x10
    mov dx,[18]
    call    print_hex

inf_loop:
    jmp inf_loop

! 上面的call都转到这里
print_hex:
    mov    cx,#4                    ! dx(16位)可以显示4个十六进制数字
print_digit:
    rol    dx,#4                    ! 取 dx 的高4比特移到低4比特处
    mov    ax,#0xe0f                ! ah = 请求的功能值(显示单个字符)，al = 半字节(4个比特)掩码
    and    al,dl                    ! 前4位会被置为0
    add    al,#0x30                 ! 给 al 数字加上十六进制 0x30
    cmp    al,#0x3a                 ! 比较看是否大于数字十
    jl     outp                     ! 是一个不大于十的数字则跳转
    add    al,#0x07                 ! 否则就是a~f，要多加7
outp:
    int    0x10                     ! 显示单个字符
    loop   print_digit              ! 重复4次
    ret                             

! 打印换行回车
print_nl:
    mov    ax,#0xe0d     ! CR
    int    0x10
    mov    al,#0xa     ! LF
    int    0x10
    ret

msg2:
    .byte 13,10
    .ascii "NOW we are in SETUP"
    .byte 13,10,13,10
msg_cursor:
    .byte 13,10
    .ascii "Cursor position:"
msg_memory:
    .byte 13,10
    .ascii "Memory Size:"
msg_cyles:
    .byte 13,10
    .ascii "Cyls:"
msg_heads:
    .byte 13,10
    .ascii "Heads:"
msg_sectors:
    .byte 13,10
    .ascii "Sectors:"
msg_kb:
    .ascii "KB"

.org 510
boot_flag:
    .word 0xAA55

经过漫长的调试，得到如下结果

操作系统 -- 哈工大-李治军-实验2-系统调用实现（笔记）

文章目录

• • 系统调用函数的实现
  • 系统调用过程总结

系统调用函数的实现

注：

• C函数代码复制的这位大佬：https://blog.csdn.net/qq_42518941/article/details/119037501

• 实现思路参考的哈工大 - 李治军老师 - 操作系统原理与实践 - 系统调用

• 很多细节和原理都参考了《linux0.11内核完全注释》

  特别是第4章，第8章5节，和其它关于具体程序描述的章节。

1. 编写系统调用的处理函数，通常可以放置在 kernel/sys.c 程序中，我们这里选择在 kernel/ 下新建一个 who.c 程序来编写函数。

   

   #define __LIBRARY__
   #include <asm/segment.h>
   #include <unistd.h>
   #include <errno.h>
   #include <string.h>
   
   char msg[24]; //23个字符 +'\\0' = 24
   
   int sys_iam(const char * name)
   /***
   function：将name的内容拷贝到msg,name的长度不超过23个字符
   return：拷贝的字符数。如果name的字符个数超过了23,则返回“­-1”,并置errno为EINVAL。
   ****/
   
           int i;
           //临时存储 输入字符串 操作失败时不影响msg
           char tmp[30];
           for(i=0; i<30; i++)
   	   
                   //从用户态内存取得数据
                   tmp[i] = get_fs_byte(name+i);
                   if(tmp[i] == '\\0') break;  //字符串结束
           
           //printk(tmp);
           i=0;
           while(i<30&&tmp[i]!='\\0') i++;
           int len = i;
           // int len = strlen(tmp);
           //字符长度大于23个
           if(len > 23)
           
                    printk("String too long!\\n");
                   return -(EINVAL);  //置errno为EINVAL  返回“­-1”  具体见_syscalln宏展开
           
           strcpy(msg,tmp);
           //printk(tmp);
           return i;
   
   
   int sys_whoami(char* name, unsigned int size)
   /***
   function:将msg拷贝到name指向的用户地址空间中,确保不会对name越界访存(name的大小由size说明)
   return: 拷贝的字符数。如果size小于需要的空间,则返回“-1”,并置errno为EINVAL。
   ****/
   
           //msg的长度大于 size
           int len = 0;
           for(;msg[len]!='\\0';len++);
           if(len > size)
           
                   return -(EINVAL);
           
           int i = 0;
           //把msg 输出至 name
           for(i=0; i<size; i++)
           
                   put_fs_byte(msg[i],name+i);
                   if(msg[i] == '\\0') break; //字符串结束
           
           return i;
   
   

2. 在 include/unistd.h 文件中增加新系统调用功能号和函数原型定义，因为我是在 bochs 中运行linux0.11，需要现挂载 hdc，在 hdc/include/unistd.h 中添加系统功能号。

   备注：hdc/include/unistd.h 是标准头文件（它和 0.11 源码树中的 unistd.h 并不是同一个文件，虽然内容可能相同），没有 __NR_whoami 和 __NR_iam 两个宏，需要手工加上它们，也可以直接从修改过的 0.11 源码树中拷贝新的 unistd.h 过来。

   # 在linux0.11没有运行时
   cd ~/oslab   # 切换到实验环境的根目录下
   sudo ./mount-hdc  # 挂载内核的根文件系统镜像文件到ubuntu 
   cd /oslab/hdc/usr/root/include  # 切换到指定目录中编写用户态程序
   vim unistd.h    # 编写 unistd.h
   

   // unistd.h 头文件
   ...
   // 新系统调用功能号
   #define __NR_whoami   72
   #define __NR_iam          73
       
   ...
   // 新系统调用函数原型
   int sys_whoami(char* name, unsigned int size);
   int sys_iam(const char * name);
   

   修改完毕后先卸载 hdc

   cd ~/oslab
   sudo umount hdc
   

3. 在 include/linux/sys.h 中加入外部函数声明并在函数指针表 sys_call_table 末端插入新系统调用处理函数的名称，见如下所示。注意，一定要严格按照功能号顺序排列函数名。

   

4. 修改 /kernel/system_call.s 程序的第61行，将内核系统调用总数 nr_system_calls 增加2（因为新增加了2个系统调用处理函数） 。

5. 重新编译内核文件，要将 /kernal/who.c 与linux其它代码编译链接再一起，需要修改 /kernel/Makefile文件。

   Makefile 在代码树中有很多，分别负责不同模块的编译工作。我们要修改的是 kernel/Makefile。需要修改两处。

   第一处：

   OBJS  = sched.o system_call.o traps.o asm.o fork.o \\
          	      panic.o printk.o vsprintf.o sys.o exit.o \\
                 signal.o mktime.o
   

   修改为：

   OBJS  = sched.o system_call.o traps.o asm.o fork.o \\
           panic.o printk.o vsprintf.o sys.o exit.o \\
           signal.o mktime.o who.o
   # 末尾添加 who.o
   

   第二处：

   ### Dependencies:
   who.s who.o: who.c ../include/linux/kernel.h ../include/unistd.h
   
   # 添加如上的一行代码，在 ###Dependencies: 下
   

6. 修改Makefile后，切换到 oslab/linux0.11，输入make all，进行编译。正确的编译最后一行内容为sync。

   cd ~/oslab/linux0.11/
   make all
   

7. 挂载 hdc, 在 /oslab/hdc/usr/root/ 下编写用户程序，在其中调用系统调用函数。

   # 在linux0.11没有运行时
   cd ~/oslab   # 切换到实验环境的根目录下
   sudo ./mount-hdc  # 挂载内核的根文件系统镜像文件到ubuntu 
   cd /oslab/hdc/usr/root  # 切换到指定目录中编写用户态程序
   sudo vim iam.c			   # 编写用户程序 iam.c
   sudo vim whoami.c      # 编写用户程序 iam.c
   

   // iam.c
   #define __LIBRARY__
   #include <unistd.h>
   /*
    * _syscall1宏展开后为如下的函数，该函数会调用int 0x80 中断，进入内核调用我们编写的系统调用处理函数
    * 宏定义在 include/unistd.h 中，也就是添加系统调用号的文件中
    * int iam(const char* msg) 
    * 
    *      long __res;
    *      __asm__ volatile ("int $0x80"       // 调用系统中断 0x80
    *                        : "=a" (__res)              // 返回值: __res = %eax
    *                        : "0" (__NR_iam),        // 调用号：%eax = __NR_iam,  在unistd.h添加的数字
    *                          "b"((long)(msg)))     // 参数：    %ebx = msg
    *      if(__res >= 0) 
    *          return (const char*) __res;     // 成功，返回转换类型后的参数
    *       
    *      // 否则，设置错误码，并返回-1
    *      errno = _res;
    *      return -1;  
    *                       
    * 
    */
   _syscall1(int, iam, const char*, name);
   
   
   int main(int argc,char ** argv)
   
           int wlen = 0;
           if(argc<1)
           
                   printf("not enough arguments!\\n");
                   return -2;
           
           wlen = iam(argv[1]);
           return wlen;
   
   

   // whoami.c
   #define __LIBRARY__
   #include <unistd.h>
   
   /*
   	宏展开后
   	int whoami(char* name, unsigned int size) 
   	
   		long __res;
   		__asm__ volatile ("int $0x80"
   								     : "=a" (__res)  
   								     : "0" (__NR_whoami), "b" ((long)(name)), "c"((long)(size)));
   		if(__res >= 0) 
   			return (int) __res; 
   			errno = -__res;
   			return -1;
   	
   */
   _syscall2(int, whoami,char*,name,unsigned int,size);
   
   int main()
   
   	char s[30];
   	int rlen = 0;
   	rlen = whoami(s,30);//这里调用了_syscall2写的whoami函数
   	printf("%s\\n",s);
   	return rlen;
   
   

8. 编写完毕后退回实验环境根目录，卸载 hdc

   cd ~/oslab
   sudo umount hdc
   

9. 启动bochs，在bochs中编译链接我们编写的程序

   cd ~/oslab
   ./run
   gcc -o iam iam.c -Wall
   gcc -o whoami whoami.c -Wall
   

10. 测试
    

系统调用过程总结

详细内容参见 《linux0.11完全注释》8.5 节

• 用户程序调用接口函数（_system宏展开后的函数)，传递宏展开需要的系统调用功能号和参数。

• 系统调用函数中内联汇编触发 int 0x80 中断。

• 通过中断向量 0x80 在 IDT 表中查找对应到的门描述符表项，该表项的 DPL = 3 使得用户程序可以进入内核，门描述符中的段选字符字段为 0x08，偏移地址为 &system_call，当跳转到 IDT 表后，CS = 0x08，ip = &system_call，因为 CS 寄存器的低2位是CPL，所以此时的CPL = 0，完成了特权级的转换，那么后面就可以执行内核中其它的代码了。

• 接着通过段选择符 0x08 在 GDT 表中定位该表的第二个表项（内核代码段描述符），通过其中段基地址与门描述符表项的偏移值可以跳转到 system_call 函数，该函数为系统中断调用的入口。

• system_call 函数最终会调用系统调用处理函数（如我们自定义的 sys_iam.c sys_whoami.c），并将返回值返回给接口函数，接口函数再将返回值返回到我们的用户程序。

  

调度初始化

调度初始化，会初始化 int 0x80 中断的中断描述符，并存放到 IDT 表中，这是为什么可以从用户程序 -> int 0x80 -> system_call -> 系统调用处理函数的关键。

1. 内核初始化时，主函数（/init/main.c）调用了 sched_init();

   void main(void)
   
   //    ……
       time_init();
       sched_init();
       buffer_init(buffer_memory_end);
   //    ……
   
   

2. sched_init(); 定义在 kernel/sched.c 中，其中 set_system_gate 宏，就是给中断进行初始化。

   void sched_init(void)
   
   //    ……
       set_system_gate(0x80,&system_call);  // 初始化 int 0x80 中断
   
   

3. set_system_gate ，在 include/asm/system.h 中，定义为：

   #define set_system_gate(n,addr) \\
       _set_gate(&idt[n],15,3,addr)        
   
   // 展开后
   set_system_gate(0x80, &system_call)   				// 0x80：中断向量号，  &system_call：中断处理程序的地址（后面会讲）
       _set_gate(&idt[0x80], 15, 3, &system_call)     // 调用 _set_gate
   

4. _set_gate 定义也在 include/asm/system.h 中，作用是设置中断描述符，并将描述符放在 idt表的对应的表项中

   #define _set_gate(gate_addr,type,dpl,addr) \\
   __asm__ ("movw %%dx,%%ax\\n\\t" \\
           "movw %0,%%dx\\n\\t" \\
           "movl %%eax,%1\\n\\t" \\
           "movl %%edx,%2" \\
           : \\
           : "i" ((short) (0x8000+(dpl<<13)+(type<<8))), \\
           "o" (*((char *) (gate_addr))), \\
           "o" (*(4+(char *) (gate_addr))), \\
           "d" ((char *) (addr)),"a" (0x00080000))
   
   // 展开后（方便阅读格式不一定标准）
   /*
    参数：gate_addr = &idt[0x80]，中断描述符表idt中 0x80 表项的地址
       	   type = 15， 表示陷阱门（也就是中断描述符第8~11位全1 ）
              dpl = 3        表示这段描述符的特权级为 3，用户特权级，这也是为什么 int 0x80中断可以被用户程序调用的原因。	
              addr = &system_call，system_call 程序的地址
   */
   _set_gate(&idt[0x80], 15, 3, &system_call)
       _asm_( "movw %dx, %ax"    //   %dx 传递一个字的数据到 %ax 中 
                   "movw %0, %dx"     //    %0 的一个字的数据传递给 %dx )
                   "movl %eax, %1"     //    %eax中保存的双字数据传递给 %1
              		 "movl %edx, %2"    //    %edx中保存的双字数据传递给 %2
             		: :
             		 /* 代表 %0 项，输入项
             			0x8000    =  1000 0000 0000 0000b，段选择符（见下面的中断门描述符结构图）
             			3 << 13   =  0110 0000 0000 0000b
             			15 << 8   =  0000 1111 0000 0000b
             			结果为      =  1110 1111 0000 0000b
                   */
             		"i" ((short) (0x8000+(3 <<13)+(15 <<8))),    
             		"o" (*((char *) (&idt[0x80]))),     			 //  代表 %1 项，输出项：&idt[0x80] 低四位，
                   "o" (*(4+(char *) (&idt[0x80]))),			  //  代表 %2 项，输出项：&idt[0x80] 高四位
                   "d" ((char *) (&system_call)),                 //   %edx = &system_call（系统调用程序的地址）
                   "a" (0x00080000))) 								  //   %eax  = 0x00080000
       
    /*
    注释：
   1）% ：AT&T汇编在引用寄存器时要在前面加1个%，%%是因为GCC在编译时会将%视为特殊字符，拥有特殊意义，%%仅仅是为了汇编的%不被GCC全部转译掉。
   
   2）%0、%1、%2、%3：0、1、2、3可以看作变量，这些变量与 `:`  之后的每一项分别对应，程序的两个 `:`  是**定义输入**、**输出项**的。针对这段程序这些变量的前面都加了明确的限定，例如**"i"(输入项)、"o"(输出项)。"d"(edx的初始值)，"a"(eax的初始值)**。
   
   3）\\n\\t：这是嵌入式汇编一种书写格式，分割多条汇编指令
   */
   

   _set_gate内联汇编过程分析

   movw %dx, %ax /* %edx 本来保存的是 system_call 的地址，此时地址的低16位即 %dx 中的值赋给 %ax 寄存器，而 %eax 中本来保存的是0x00080000，传递之后，%eax高16位保存的是0x0008（段选择符） 低十六位保存的是 system_call 的地址 */
   
   movw %0, %dx /* 将 %0 表达式得到的结果传递给 %dx 寄存器，即上面的计算结果 1110 1111 0000 0000b 在 %dx 中保存，
   							  那么此时 %edx 寄存器中高16位保存的是 system_call 的高16位地址，低16位保存的是 1110 1111 0000 0000b
   							  低16位其实就是陷阱门描述符中二进制位32~47的状态，见下面陷阱门描述符结果图*/
   							  
   # 上面两步已经设置好了 int 0x80 的中断描述符，下面就是将该描述符存放在中段描述符表对应的地址中了
   movl %eax, %1 /* 将%eax寄存器中4个字节的数据传递给 %1 对应的地址，即地址 &idt[0x80]， */
   movl %edx, %2 /* 讲%edx寄存器中4个字节的数据传递给 %2 对应的地址，即地址 &idt[0x80] + 4*/
   # 至此总共 8 个字节的 int 0x80 中断描述符就被存放在了中断描述符表 idt 对应的表项中了。
   

   陷阱门描述符结构：

   

   通过上面分析可总结：

   • _set_gate 内联汇编用 %eax 存储 0~31 位共4字节的数据，其中 0~15 位保存的是 system_call 地址的低16位。15~31位保存的是段选择符 0x0008。
   • _set_gate 内联汇编用 %edx 存储 32~63 位共4字节的数据，其中 32~47 位保存的是陷阱门描述符的位状态，即1110 1111 0000 0000b。 48~63 位保存的是 system_call 的高16位地址。

   段选择符结构：

   

   • RPL（0~1位）：请求特权级。
   • TI（2位）：表索引字段，0表示到段描述符在GDT表中，1表示在LDT表中。
   • 描述符索引（3~15）：给出了段描述符在GDT/LDT中的索引。

   在上面 %eax 的高16位是 0x0008，二进制表示为 0000 0000 0000 1000b，那么其 RPL = 0 TI = 0 索引 = 0x01，也就是定位到 GDT 表中的第二个表项，该表项的段基地址为内核代码段，再通过偏移值可以定位到 system_call 程序。

5. 最后再看下 system_call 函数的功能，该函数是纯汇编指令，定义在 kernel/system_call.s 中，在这里我们主要关注于该程序调用系统调用处理函数的相关代码。

#……
# 这是系统调用总数。如果增删了系统调用，必须做相应修改
nr_system_calls = 72
#……

.globl system_call
.align 2
# int 0x80 中断系统调用入口点
system_call:

    cmpl $nr_system_calls-1,%eax      # 检查系统调用编号是否在合法范围内，%eax 中保存的是系统调用号
    ja bad_sys_call								  # 如果不合法跳转到 bad_sys_call 处，会将 %eax 置为 -1 并退出中断
    # 保存之后用到的寄存器中的值
    push %ds		
    push %es
    push %fs
    
	# push %ebx,%ecx,%edx，是传递给系统调用的参数，也就是 /include/unistd.h 中133~183行定义的系统调用宏 _syscall0、		 _syscall1、_syscall2、_syscall3，后面的数字代码传递的参数个数，默认%ebx存放第一个参数，%ecx存放第二个参数，%edx存放第三个参数。
	pushl %edx               
    pushl %ecx
    pushl %ebx
    
    movl $0x10,%edx    # 让ds, es指向GDT表，内核地址空间
    mov %dx,%ds 
    mov %dx,%es
    movl $0x17,%edx
    mov %dx,%fs			# 让fs指向LDT表，用户地址空间 
    
    # 
   /*查表操作，调用实际的系统调用处理函数 
   	 操作数 _sys_call_table(, %eax,4)的含义:
   	 	_sys_call_table 是定义再 include/linux/sys.h 中的一个函数指针数组。
   	 	%eax 是我们传入的系统调用编号
   	 	4 是指针变量的大小
   	 call 指令实际调用的地址是 [_sys_call_table + %eax * 4]，用c语言表单就是数组 _sys_call_table[%eax*4] 位置保存的地址， call 指令调用该地址处的函数，完成我们需要的功能。
       */ 
    call sys_call_table(,%eax,4)  
    pushl %eax						#  将 %eax 保存的系统调用函数返回值入栈
    //...