系统调用的实现

已于 2022-04-02 16:49:23 修改
阅读量195 收藏
点赞数
分类专栏： 操作系统
于 2021-11-28 11:37:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52484093/article/details/121588359
版权

任务调度 系统调用 中断处理 特权级转换 任务销毁
关键词由CSDN通过智能技术生成

问题

系统中的所有任务都是一直不停执行吗？任务入口函数结束后，返回到哪里？

再论当前任务执行解决方案

我们是通过修改 eip 寄存器的值来实现任务跳转的。 

结论

当前方案直接通过 iret 跳转到进程入口函数执行，并非函数调用，因此无法正确返回！！！

改进思路

Task 结构体中新增 void (*tmain)() 成员 (保存任务入口函数地址)

新增 void TaskEntry() 全局任务入口函数 (RegValue.eip = (uint)TaskEntry;)

改进任务执行方式

typedef struct
{
    RegValue   rv;
    Descriptor ldt[3];
    ushort     ldtSelector;
    ushort     tssSelector;
    void (*tmain)();
    uint       id;
    char       name[8]; 
    byte       stack[512];
} Task;

static void InitTask(Task* pt, void(*entry)())
{
	PrintIntHex(pt);
	PrintString("       ");
	PrintIntHex(entry);
	PrintChar('\n'); 

    pt->rv.cs = LDT_CODE32_SELECTOR;
    pt->rv.gs = LDT_VIDEO_SELECTOR;
    pt->rv.ds = LDT_DATA32_SELECTOR;
    pt->rv.es = LDT_DATA32_SELECTOR;
    pt->rv.fs = LDT_DATA32_SELECTOR;
    pt->rv.ss = LDT_DATA32_SELECTOR;
    
    pt->rv.esp = (uint)pt->stack + sizeof(pt->stack);
    pt->rv.eip = (uint)TaskEntry;
    pt->rv.eflags = 0x3202;
    
    pt->tmain = entry;
    
    gTSS.ss0 = GDT_DATA32_FLAT_SELECTOR;
    gTSS.esp0 = (uint)&pt->rv + sizeof(pt->rv);
    gTSS.iomb = sizeof(TSS);
    
    SetDescValue(AddrOff(pt->ldt, LDT_VIDEO_INDEX),  0xB8000, 0x07FFF, DA_DRWA + DA_32 + DA_DPL3);
    SetDescValue(AddrOff(pt->ldt, LDT_CODE32_INDEX), 0x00,    0xFFFFF, DA_C + DA_32 + DA_DPL3);
    SetDescValue(AddrOff(pt->ldt, LDT_DATA32_INDEX), 0x00,    0xFFFFF, DA_DRW + DA_32 + DA_DPL3);
    
    pt->ldtSelector = GDT_TASK_LDT_SELECTOR;
    pt->tssSelector = GDT_TASK_TSS_SELECTOR;
}

void TaskEntry()
{
	if(gCTaskAddr != NULL)
	{
		gCTaskAddr->tmain();
	}
	
	// to destory current task here
	
	while(1);    // TODO: schedule next task to run
}

我们修改或新增的代码如上。

首先我们在 Task 结构体中，新增了一个函数指针(tmain)，用来指向任务的入口地址，把 eip 指向全局任务函数入口地址 (TaskEntry)，这样在一个任务开始执行时，首先跳转到 TaskEntry 处，调用 tmain 函数；在任务结束时，就返回到 TaskEntry 处，之后就可以回收这个任务的系统资源了。

思考

什么时候销毁一个任务？如何销毁一个任务？

系统调用

任务与内核之间的交互接口

涉及特权级的转换 (DPL0 => DPL3)

执行内核中的代码

系统调用的实现

通过 0x80 号中断描述符实现系统调用 (软中断)

使用 ax 寄存器指定功能号 (如：ax == 0 => KillTask())

 

实现步骤

1. 实现 void SysCallHandler(ushort ax) 中断服务程序

2. 设置 IDT 中 0x80 号中断描述符的 ISR 入口地址

3. 当 ax == 0时，调用 KillTask() 销毁当前任务

实现系统调用

interrupt.c

#include "utility.h"
#include "interrupt.h"
#include "ihandler.h"

void (* const InitInterrupt)() = NULL;
void (* const EnableTimer)() = NULL;
void (* const SendEOI)(uint port) = NULL;

void IntModInit()
{
    SetIntHandler(AddrOff(gIdtInfo.entry, 0x20), (uint)TimerHandlerEntry);
    SetIntHandler(AddrOff(gIdtInfo.entry, 0x80), (uint)SysCallHandlerEntry);
    
    InitInterrupt();
}

int SetIntHandler(Gate* pGate, uint ifunc)
{
    int ret = 0;
    
    if( ret = (pGate != NULL) )
    {
        pGate->offset1  = ifunc & 0xFFFF;
        pGate->selector = GDT_CODE32_FLAT_SELECTOR;
        pGate->dcount   = 0;
        pGate->attr     = DA_386IGate + DA_DPL3;
        pGate->offset2  = (ifunc >> 16) & 0xFFFF;
    }
    
    return ret;
}

int GetIntHandler(Gate* pGate, uint* pIFunc)
{
    int ret = 0;
    
    if( ret = (pGate && pIFunc) )
    {
        *pIFunc = (pGate->offset2 << 16) | pGate->offset1;
    }
    
    return ret;
}

kentry.asm

%include "common.asm"

global _start
global TimerHandlerEntry
global SysCallHandlerEntry

extern TimerHandler
extern SysCallHandler

extern gCTaskAddr
extern gGdtInfo
extern gIdtInfo
extern InitInterrupt
extern EnableTimer
extern SendEOI
extern RunTask
extern LoadTask
extern KMain
extern ClearScreen

%macro BeginISR 0
    sub esp, 4
    
    pushad
    
    push ds
    push es
    push fs
    push gs
    
    mov dx, ss
    mov ds, dx
    mov es, dx
    
    mov esp, BaseOfLoader
%endmacro

%macro EndISR 0
    mov esp, [gCTaskAddr]
    
    pop gs
    pop fs
    pop es
    pop ds
    
    popad
    
    add esp, 4
    
    iret
%endmacro

[section .text]
[bits 32]
_start:
    mov ebp, 0
    
    call InitGlobal
    call ClearScreen
    call KMain
    
    jmp $
    
;
;    
InitGlobal:
    push ebp
    mov ebp, esp
    
    mov eax, dword [GdtEntry]
    mov [gGdtInfo], eax
    mov eax, dword [GdtSize]
    mov [gGdtInfo + 4], eax
    
    mov eax, dword [IdtEntry]
    mov [gIdtInfo], eax
    mov eax, dword [IdtSize]
    mov [gIdtInfo + 4], eax
    
    mov eax, dword [RunTaskEntry]
    mov dword [RunTask], eax
    
    mov eax, dword [InitInterruptEntry]
    mov dword [InitInterrupt], eax
    
    mov eax, dword [EnableTimerEntry]
    mov dword [EnableTimer], eax
    
    mov eax, dword [SendEOIEntry]
    mov dword [SendEOI], eax
    
    mov eax, dword [LoadTaskEntry]
    mov dword [LoadTask], eax
    
    leave
    
    ret
    
;
;
TimerHandlerEntry:
BeginISR 
    call TimerHandler
EndISR

;
;
SysCallHandlerEntry:
BeginISR
	push ax
    call SysCallHandler
    pop ax
EndISR

ihandler.h


#ifndef IHANDLER_H
#define IHANDLER_H

#define DeclHandler(name)    void name##Entry(); \
                             void name()
                             
DeclHandler(TimerHandler);
DeclHandler(SysCallHandler);

#endif

ihandler.c


#include "interrupt.h"

void TimerHandler()
{
    static uint i = 0;
    
    i = (i + 1) % 5;
    
    if( i == 0 )
    {
        Schedule();
    }
    
    SendEOI(MASTER_EOI_PORT);
}

void SysCallHandler(ushort ax)
{
	if(ax == 0)
	{
		KillTask();
	}
	else
	{
		
	}
}

task.c

#include "utility.h"
#include "task.h"

#define MAX_RUNNING_TASK  12

void (* const RunTask)(volatile Task* pt) = NULL;
void (* const LoadTask)(volatile Task* pt) = NULL;

volatile Task* gCTaskAddr = NULL;
static TaskNode gTaskBuff[MAX_RUNNING_TASK] = {0};
static TSS gTSS = {0};
static Queue gRunningTask = {0};

void TaskEntry()
{
	if(gCTaskAddr != NULL)
	{
		gCTaskAddr->tmain();
	}
	
	// to destory current task here
	asm volatile(
	    "movw $0, %ax \n"
	    "int $0x80 \n"
	);
	
	while(1);    // TODO: schedule next task to run
}

void TaskA()
{
    int i = 0;
    
    SetPrintPos(0, 12);
    
    PrintString(__FUNCTION__);
    
    while(i < 5)
    {
        SetPrintPos(8, 12);
        PrintChar('A' + i);
        i = (i + 1) % 26;
        Delay(1);
    }
    
    SetPrintPos(8, 12);
}

void TaskB()
{
    int i = 0;
    
    SetPrintPos(0, 13);
    
    PrintString(__FUNCTION__);
    
    while(1)
    {
        SetPrintPos(8, 13);
        PrintChar('0' + i);
        i = (i + 1) % 10;
        Delay(1);
    }
}

void TaskC()
{
    int i = 0;
    
    SetPrintPos(0, 14);
    
    PrintString(__FUNCTION__);
    
    while(1)
    {
        SetPrintPos(8, 14);
        PrintChar('a' + i);
        i = (i + 1) % 26;
        Delay(1);
    }
}

void TaskD()
{
    int i = 0;
    
    SetPrintPos(0, 15);
    
    PrintString(__FUNCTION__);
    
    while(1)
    {
        SetPrintPos(8, 15);
        PrintChar('!' + i);
        i = (i + 1) % 10;
        Delay(1);
    }
}

static void InitTask(Task* pt, void(*entry)())
{
	PrintIntHex(pt);
	PrintString("       ");
	PrintIntHex(entry);
	PrintChar('\n'); 

    pt->rv.cs = LDT_CODE32_SELECTOR;
    pt->rv.gs = LDT_VIDEO_SELECTOR;
    pt->rv.ds = LDT_DATA32_SELECTOR;
    pt->rv.es = LDT_DATA32_SELECTOR;
    pt->rv.fs = LDT_DATA32_SELECTOR;
    pt->rv.ss = LDT_DATA32_SELECTOR;
    
    pt->rv.esp = (uint)pt->stack + sizeof(pt->stack);
    pt->rv.eip = (uint)TaskEntry;
    pt->rv.eflags = 0x3202;
    
    pt->tmain = entry;
    
    gTSS.ss0 = GDT_DATA32_FLAT_SELECTOR;
    gTSS.esp0 = (uint)&pt->rv + sizeof(pt->rv);
    gTSS.iomb = sizeof(TSS);
    
    SetDescValue(AddrOff(pt->ldt, LDT_VIDEO_INDEX),  0xB8000, 0x07FFF, DA_DRWA + DA_32 + DA_DPL3);
    SetDescValue(AddrOff(pt->ldt, LDT_CODE32_INDEX), 0x00,    0xFFFFF, DA_C + DA_32 + DA_DPL3);
    SetDescValue(AddrOff(pt->ldt, LDT_DATA32_INDEX), 0x00,    0xFFFFF, DA_DRW + DA_32 + DA_DPL3);
    
    pt->ldtSelector = GDT_TASK_LDT_SELECTOR;
    pt->tssSelector = GDT_TASK_TSS_SELECTOR;
}

static void PrepareForRun(volatile Task* pt)
{
	gTSS.ss0 = GDT_DATA32_FLAT_SELECTOR;
    gTSS.esp0 = (uint)&pt->rv + sizeof(pt->rv);
    gTSS.iomb = sizeof(TSS);
    
    SetDescValue(AddrOff(gGdtInfo.entry, GDT_TASK_LDT_INDEX), (uint)&pt->ldt, sizeof(pt->ldt)-1, DA_LDT + DA_DPL0);
}

void TaskModInit()
{
    SetDescValue(AddrOff(gGdtInfo.entry, GDT_TASK_TSS_INDEX), (uint)&gTSS, sizeof(gTSS)-1, DA_386TSS + DA_DPL0);
    
    InitTask(&(((TaskNode*)AddrOff(gTaskBuff, 0))->task), TaskA);
    InitTask(&(((TaskNode*)AddrOff(gTaskBuff, 1))->task), TaskB);
    InitTask(&(((TaskNode*)AddrOff(gTaskBuff, 2))->task), TaskC);
    InitTask(&(((TaskNode*)AddrOff(gTaskBuff, 3))->task), TaskD);
    
    Queue_Init(&gRunningTask);
    
    Queue_Add(&gRunningTask, &((TaskNode*)AddrOff(gTaskBuff, 0))->head);
    Queue_Add(&gRunningTask, &((TaskNode*)AddrOff(gTaskBuff, 1))->head);
    Queue_Add(&gRunningTask, &((TaskNode*)AddrOff(gTaskBuff, 2))->head);
    Queue_Add(&gRunningTask, &((TaskNode*)AddrOff(gTaskBuff, 3))->head);
    
}

void LaunchTask()
{
    gCTaskAddr = &((TaskNode*)Queue_Front(&gRunningTask))->task;
    
    PrepareForRun(gCTaskAddr);
    
    RunTask(gCTaskAddr);
}

void Schedule()
{
	Queue_Rotate(&gRunningTask);
	
    gCTaskAddr = &((TaskNode*)Queue_Front(&gRunningTask))->task;
    
    PrepareForRun(gCTaskAddr);
    
    LoadTask(gCTaskAddr);
}

void KillTask()
{
	PrintString(__FUNCTION__);  // destroy current task
}

kmain.c

#include "task.h"
#include "interrupt.h"
#include "screen.h"

void KMain()
{
    int n = PrintString("D.T.OS\n");
    
    PrintString("GDT Entry: ");
    PrintIntHex((uint)gGdtInfo.entry);
    PrintChar('\n');
    
    PrintString("GDT Size: ");
    PrintIntDec((uint)gGdtInfo.size);
    PrintChar('\n');
    
    PrintString("IDT Entry: ");
    PrintIntHex((uint)gIdtInfo.entry);
    PrintChar('\n');
    
    PrintString("IDT Size: ");
    PrintIntDec((uint)gIdtInfo.size);
    PrintChar('\n');
    
    TaskModInit();
    
    IntModInit();
    
    LaunchTask();
    
}

因为在 TaskEntry 函数中，当一个任务结束返回到该函数时，当前运行在用户态，特权级为3，而释放任务结束后的系统资源需要内核来完成，所以我们需要从3特权级转移到0特权级，陷入内核态，让内核完成销毁任务的系统资源；所以我们就需要实现一个系统调用(软中断)。

首先我们需要设置 0x80 号中断对应的中断入口函数 (SysCallHandlerEntry)，注意：我们需要把 0x80 号中断描述符对应的特权级设置为3，否则无法从用户态跳转到内核态。

SysCallHandlerEntry 函数里我们调用了 SysCallHandler 函数，这个函数需要1个参数，并且是用C语言编写的，所以我们需要遵守调用约定，由调用者 SysCallHandlerEntry 手动 push ax 并且 pop ax。

在SysCallHandler 函数中，通过 ax 的值实现一系列的系统调用，当 ax 的值为0时，调用 KillTask 函数，销毁该任务的系统资源。

在 TaskEntry 函数中，当有任务结束时，我们通过内联汇编将 ax 的值设置为0，并调用 0x80号中断，让内核来销毁该任务的系统资源。

最后，又返回到 while(1)。

qq_52484093
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
系统调用实现
在雨一方
01-20 2880
当用户态的进程调用一个系统调用时，CPU从用户态切换到内核态并开始执行一个内核函数。Linux通过由向量为128（0x80）的编程异常实现CPU由用户态到内核态的转换。 因为内核实现了许多不同的系统调用，为了区别他们，进程必须传递一个系统调用号的参数来识别所需的系统调用。EAX寄存器是负责传递系统调用号的。 系统调用处理程序执行下列操作： （1）在内核栈保存大多数寄存器的内容（这个操作对所有
Linux系统调用的实现
ronhu的博客
04-06 520
在Linux系统中，系统调用基本上是应用程序与内核交互的唯一方式。而所有的外设驱动都由内核管理，因此系统调用基本上也是应用程序与外设交互的唯一方式。 Linux的系统调用有两个视角：应用程序和内核。从应用程序的角度，系统调用表现为库函数的形式，遵循POSIX标准，存放在多个库文件中，包括C标准库。从内核的角度，则表现为从中断处理程序开始的一系列处理。 应用程序和内核的切换 为了更好地保护系统...
系统调用如何实现?
weixin_46645613的博客
09-21 805
公号：Rand_cs SYSCALL 系统调用就是调用操作系统提供的一系列内核功能函数，因为内核总是对用户程序持不信任的态度，一些核心功能不能直接交由用户程序来实现执行。用户程序只能发出请求，然后内核调用相应的内核函数来帮着处理，将结果返回给应用程序。如此才能保证系统的稳定和安全。本文采用 xv6xv6xv6 的实例来讲解系统调用具体是如何实现的。 系统调用是给用户态下的程序使用的，但是用户程序并不直接使用系统调用，而是系统调用在用户态下的接口。这个用户接口就是操作系统提供的系统调用 APIAPIAPI.
linux 系统调用
menuconfig的专栏
07-23 1841
  系统调用  目 录 系统调用 系统调用简述 宏 系统调用表 系统调用入口函数
实现自己的系统调用(两种方式) 【转】
weixin_33797791的博客
06-21 192
转自：http://blog.163.com/zhe_wang_2009/blog/static/1722821212012328104325531/ 学习linux操作系统课，有一章讲“系统调用”，其中有个内容是在linux内核中添加一个自己的系统调用。我调试了两次终于将其调通了，第一次不知道是什么原因，编译生成的内核总是加载不上。第二次成功了。有点小成就感.   我现在将其过程记录下来。分享...
Linux的系统调用实现机制与系统调用实例分析-Jin-Yang.pdf
最新发布
08-24
"Linux 系统调用实现机制与系统调用实例分析" 一、系统调用概述 系统调用是操作系统中必不可少的一个组成部分，对于以该操作系统作为平台进行程序设计的程序员来说，系统调用提供了该系统面向用户的编程界面，程序...
华中科技大学操作系统课程设计——1.系统调用实现文件拷贝
06-13
1.1 利用系统调用实现文件拷贝（含代码和makefile） 1.2 多进程编程，实现三个子进程窗口（含代码和makefile） 2 自己的系统调用，只有系统调用实现的代码，系统调用需要自己编译内核 3 字符设备驱动的编写（含代码...
嵌入式实时操作系统中系统调用方法的设计与实现
04-18
在高安全性的实时操作系统中支持两种运行形态：系统态和用户态。...笔者在深入研究系统调用的基础上，设计并实现了一种系统调用方法。通过在某嵌入式实时操作系统中的实现，证明该方法是安全的、可行的、有效的。
nachos系统调用实现Write、Read、Exec、Join
zhao_yuting的博客
05-09 8199
了解nachos系统调用的原理： 1.要实现nachos的系统调用，首先查看syscall.h当中声明的系统调用函数 可以发现Nachos已经为我们在syscall.h中声明好了这些系统调用函数。 2.观察Start.s中的汇编代码，定义了系统调用函数的实现 我们可以观察到Halt函数的实现是将系统调用类型（type）SC_Halt放入了2号寄存器中，然后执行sysc...
操作系统实验五、实现系统调用
02-19
这是操作系统实验课上的一个实验内容，本次实验的主要内容为实现一些系统调用，并且设计一个C程序库，封闭getch(),gets(),putch(),puts(),scanf()和printf()等利用系统调用实现的细节，开发一个用户程序，测试这些函数功能。
哈工大操作系统实验（二）系统调用实现
K_Xin的博客
10-01 3669
目录实验背景1. 描述符表2. 特权级2. 中断过程3. 系统调用过程实验目的实验内容实验报告 实验背景 1. 描述符表 2. 特权级 处理器的段保护机制可以识别4个特权级 R0～R3，数值越大特权越小。环中心为核心态，最外层为用户态。处理器利用特权级防止运行在较低特权级的程序或人物访问具有较高特权级的一个段。 为了在各个代码段和数据段之间进行特权级检测处理，处理器可以识别以下三种类型的特权级： 当前特权级 CPL（Current Privilege Level）：CPL 存放在 CS 和 SS 段寄
Linux系统编程——Linux系统调用
秋叶原 && Mike || 麦克
04-17 9530
系统调用概述 系统调用，顾名思义，说的是操作系统提供给用户程序调用的一组“特殊”接口。用户程序可以通过这组“特殊”接口来获得操作系统内核提供的服务，比如用户可以通过文件系统相关的调用请求系统打开文件、关闭文件或读写文件，可以通过时钟相关的系统调用获得系统时间或设置定时器等。 从逻辑上来说，系统调用可被看成是一个内核与用户空间程序交互的接口——它好比一个中间人，把用户进程的请求传达给内核，待
系统调用如何实现
锄禾日当午
11-29 4570
系统调用的实现与一般过程调用的实现相比，两者间有很大差异。对于系统调用，控制是由原来的用户态转换为系统态，这是借助于中断和陷入机制来完成的，在该机制中包括中断和陷入硬件机构及中断与陷入处理程序两部分。 　　中断和陷入硬件机构 　　图1所示为中断的处理过程。中断可进一步分为外中断和内中断。外中断是指由于外部设备事件所引起的中断，如通常的磁盘中断、打印机中断等;而内中断则是指由于CPU内部事件所引
3.4系统调用的实现
libing的专栏
05-15 171
date comments categories tags permalink title description 2020/2/18 true 操作系统 操作系统 接口 调用 3.4 系统调用的实现 实现一个w...
Linux系统调用实现解析
"深入解析Linux系统调用的实现机制，包括系统调用的入口、调用过程、参数传递以及返回结果的处理。" 在Linux操作系统中，系统调用是用户空间程序与内核进行交互的主要途径。系统调用提供了安全且高效的服务，如文件...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值