操作系统 -- 哈工大-李治军-实验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 
   #include 
   #include 
   #include 
   
   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 
   /*
    * _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 
   
   /*
   	宏展开后
   	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 保存的系统调用函数返回值入栈
    //...