清华操作系统实验ucore_lab4

最新推荐文章于 2022-10-04 12:10:23 发布

JustinAustin

最新推荐文章于 2022-10-04 12:10:23 发布

阅读量1.9k

点赞数 2

分类专栏：操作系统文章标签： linux 运维服务器

本文链接：https://blog.csdn.net/JustinAustin/article/details/121884725

版权

操作系统专栏收录该内容

8 篇文章 12 订阅

订阅专栏

lab4

练习0：

kdebug.c、trap.c、default_pmm.c、pmm.c、swap_fifo.c vmm.c四个文件的相关代码，补全后进行下一练习

练习1：分配并初始化一个进程控制块（需要编码）

题目概述：

alloc_proc函数（位于kern/process/proc.c中）负责分配并返回一个新的struct proc_struct结构，用于存储新建立的内核线程的管理信息。ucore需要对这个结构进行最基本的初始化，你需要完成这个初始化过程。

实现思路：

struct proc_struct {
 enum proc_state state;          // 当前进程的状态
    int pid;                        // 进程ID
    int runs;                       // 当前进程被调度的次数
    uintptr_t kstack;               // 内核栈
    volatile bool need_resched;     // 是否需要被调度
    struct proc_struct *parent;     // 父进程ID
    struct mm_struct *mm;           // 当前进程所管理的虚拟内存页，包括其所属的页目录项PDT
    struct context context;         // 保存的上下文
    struct trapframe *tf;           // 中断所保存的上下文
    uintptr_t cr3;                  // 页目录表的地址
    uint32_t flags;                 // 当前进程的相关标志
    char name[PROC_NAME_LEN + 1];   // 进程名称（可执行文件名）
    list_entry_t list_link;         // 用于连接list
    list_entry_t hash_link;         // 用于连接hash list
};
enum proc_state {
    PROC_UNINIT = 0,  // 未初始化的     -- alloc_proc
    PROC_SLEEPING,    // 等待状态       -- try_free_pages, do_wait, do_sleep
    PROC_RUNNABLE,    // 就绪/运行状态   -- proc_init, wakeup_proc,
    PROC_ZOMBIE,      // 僵死状态       -- do_exit
};
struct context {  // 保存的上下文寄存器，注意没有eax寄存器和段寄存器
    uint32_t eip;
    uint32_t esp;
    uint32_t ebx;
    uint32_t ecx;
    uint32_t edx;
    uint32_t esi;
    uint32_t edi;
    uint32_t ebp;
};

我们需要初始化的就是proc_struct的一个对象，对其分配一个内核线程的PCB。我们需要做的就是对结构体中的成员进行初始化赋值。

代码实现：

// alloc_proc -负责创建并初始化一个新的proc_struct结构存储内核线程信息
static struct proc_struct *
alloc_proc(void) 
{
    //为创建的线程申请空间
    struct proc_struct *proc = kmalloc(sizeof(struct proc_struct));
    if (proc != NULL) 
    {
    //因为没有分配物理页，故将线程状态初始为初始状态
     proc->state=PROC_UNINIT;
     proc->pid=-1; //id初始化为-1
     proc->runs=0; //进程调度次数为为0
     proc->kstack=0; //内核栈位置，暂未分配，初始化为0
     proc->need_resched=0; //不需要释放CPU，因为还没有分配
     proc->parent=NULL;  //当前没有父进程，初始为null
     proc->mm=NULL;     //当前未分配内存，初始为null
     //用memset将context变量中的所有成员变量置为0
     memset(&(proc -> context), 0, sizeof(struct context)); 
     proc->tf=NULL;   		//当前没有中断帧,初始为null
     proc->cr3=boot_cr3;    //内核线程，默认初始化为boot_cr3
     proc->flags=0;//当前进程的相关标志，暂无，设为0
     memset(proc -> name, 0, PROC_NAME_LEN);
    }//内核线程（进程）的名称为空
    return proc;
}

思考题：

请说明proc_struct中struct context context和struct trapframe *tf成员变量含义和在本实验中的作用是啥？（提示通过看代码和编程调试可以判断出来）

由上文分析可知，context是与上下文切换相关的，用于进程切换时保存信息。

tf当前中断帧的指针。当进程从用户空间跳到内核空间时，中断帧记录了进程在被中断前的状态。当内核需要跳回用户空间时，需要调整中断帧以恢复让进程继续执行的各寄存器值。tf变量的作用在于在构造出了新的线程的时候，如果要将控制权交给这个线程，是使用中断返回的方式进行的，因此需要构造出一个伪造的中断返回现场，使得可以正确地将控制权转交给新的线程。

练习2：为新创建的内核线程分配资源（需要编码）

题目概述：

创建一个内核线程需要分配和设置好很多资源。kernel_thread函数通过调用do_fork函数完成具体内核线程的创建工作。do_kernel函数会调用alloc_proc函数来分配并初始化一个进程控制块，但alloc_proc只是找到了一小块内存用以记录进程的必要信息，并没有实际分配这些资源。ucore一般通过do_fork实际创建新的内核线程。do_fork的作用是，创建当前内核线程的一个副本，它们的执行上下文、代码、数据都一样，但是存储位置不同。在这个过程中，需要给新内核线程分配资源，并且复制原进程的状态。你需要完成在kern/process/proc.c中的do_fork函数中的处理过程。它的大致执行步骤包括：

调用alloc_proc，首先获得一块用户信息块。
为进程分配一个内核栈。
复制原进程的内存管理信息到新进程（但内核线程不必做此事）
复制原进程上下文到新进程
将新进程添加到进程列表
唤醒新进程
返回新进程号

实现思路：

题目概述中已经给出了清晰的思路，按照该思路实现即可。需要用到的几个函数：

//创建一个proc并初始化所有成员变量
void alloc_proc(void) 
//为一个内核线程分配物理页
static int setup_kstack(struct proc_struct *proc)
//复制父进程的内存信息到子进程
static int copy_mm(uint32_t clone_flags, struct proc_struct *proc)
//复制原进程上下文到新进程
static void copy_thread(struct proc_struct *proc, uintptr_t esp, struct trapframe *tf)
//返回一个pid
static int get_pid(void)
//将proc加入到hash_list
static void hash_proc(struct proc_struct *proc)
// 唤醒该线程，即将该线程的状态设置为可以运行
void wakeup_proc(struct proc_struct *proc);

代码实现：

int do_fork(uint32_t clone_flags, uintptr_t stack, struct trapframe *tf) {
 //已给出部分，不需要修改
    int ret = -E_NO_FREE_PROC;
    struct proc_struct *proc;
    if (nr_process >= MAX_PROCESS) {
        goto fork_out;
    }
    ret = -E_NO_MEM;
//修改部分
    //1.调用alloc_proc()函数申请内存块，将子进程的父节点设置为当前进程
    if((proc=alloc_proc())==NULL) 
        goto fork_out;
    proc->parent=current;
    // 2. 调用setup_stack()函数为进程分配一个内核栈
    if (setup_kstack(proc)!=0)
        goto bad_fork_cleanup_proc;
    // 3. 调用copy_mm()函数（proc.c253行）复制父进程的内存信息到子进程
    if(copy_mm(clone_flags, proc)!=0)
        goto bad_fork_cleanup_proc;
    // 4. 调用copy_thread()函数复制父进程的中断帧和上下文信息
    copy_thread(proc,stack,tf);  
    // 5. 将新进程添加到进程的（hash）列表中
    proc->pid = get_pid(); //创建一个id
    // 将线程放入使用hash组织的链表以及所有线程的链表中
    hash_proc(proc); //建立映射
    list_add(&proc_list, &proc->list_link); 
    nr_process ++;  // 将全局线程的数目加1
    // 6. 唤醒子进程
    wakeup_proc(proc);
    // 7. 返回子进程的pid
     ret = proc->pid; // 返回新线程的pid
fork_out:
    return ret;
//题目给出内容，不需要修改
bad_fork_cleanup_kstack:
    put_kstack(proc);
bad_fork_cleanup_proc:
    kfree(proc);
    goto fork_out;
}

运行验证：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yU3feX3p-1639279370341)(E:\Typore图片\1639276023383.png)]

思考题：

请说明ucore是否做到给每个新fork的线程一个唯一的id？请说明你的分析和理由。

找到id的建立函数get_pid，对其代码进行分析：

// get_pid - alloc a unique pid for process
static int
get_pid(void) {
    //定义了MAX_PID=2*MAX_PROCESS，意味着ID的总数目是大于PROCESS的总数目的,因此不会出现部分PROCESS无ID可分的情况
    static_assert(MAX_PID > MAX_PROCESS);
    struct proc_struct *proc;
    list_entry_t *list = &proc_list, *le;
    static int next_safe = MAX_PID, last_pid = MAX_PID;
    if (++ last_pid >= MAX_PID) 
    {
        last_pid = 1;
        goto inside;
    }
    if (last_pid >= next_safe) 
    {
    inside:
        next_safe = MAX_PID;
    repeat:
        //le等于线程的链表头
        le = list;      
        //循环扫描每一个当前进程：当一个现有的进程号和last_pid相等时，则将last_pid+1；
        while ((le = list_next(le)) != list) 
        { 
            proc = le2proc(le, list_link);
            //如果proc的pid与last_pid相等，则将last_pid加1
            //当然，如果last_pid>=MAX_PID,then 将其变为1
            //确保了没有一个进程的pid与last_pid重合
            if (proc->pid == last_pid) 
            {
                if (++ last_pid >= next_safe) 
                {
                    if (last_pid >= MAX_PID) 
                    {
                        last_pid = 1;
                    }
                    next_safe = MAX_PID;
                    goto repeat;
                }
            }
            else if (proc->pid > last_pid && next_safe > proc->pid) 
            {
                next_safe = proc->pid;
            }
        }
    }
    return last_pid;
}

get_id将为每个调用fock的线程返回不同的id

练习3：阅读代码，理解 proc_run 函数和它调用的函数如何完成进程切换的。（无编码工作）

调度函数schedule：

void
schedule(void) {
    bool intr_flag; //定义中断变量
    list_entry_t *le, *last; //当前list，下一list
    struct proc_struct *next = NULL; //下一进程
    //关闭中断
    local_intr_save(intr_flag); 
    {
        current->need_resched = 0; 
      //last是否是idle进程(第一个创建的进程),如果是，则从表头开始搜索  否则获取下一链表
        last = (current == idleproc) ? &proc_list : &(current->list_link);
        le = last; 
        //循环找到可调度的进程
        do 
        { 
            if ((le = list_next(le)) != &proc_list) 
            {
                //获取下一进程
                next = le2proc(le, list_link);
                //找到一个可以调度的进程，break
                if (next->state == PROC_RUNNABLE) 
					break;
            }
        } while (le != last);
        //如果没有找到可调度的进程
        if (next == NULL || next->state != PROC_RUNNABLE) 
        {
            next = idleproc; 
        }
        next->runs ++; //运行次数加一
//##########运行新进程,调用proc_run函数###########
        if (next != current)
        {
            proc_run(next); 
        }
    }
    //恢复中断
    local_intr_restore(intr_flag); 
}

schedule函数的执行逻辑：

1．设置当前内核线程current->need_resched为0；

2．在proc_list队列中查找下一个处于“就绪”态的线程或进程next；

3．找到这样的进程后，就调用proc_run函数，保存当前进程current的执行现场（进程上下文），恢复新进程的执行现场，完成进程切换

代码分析：

// proc_run - make process "proc" running on cpu
// NOTE: before call switch_to, should load  base addr of "proc"'s new PDT
void proc_run(struct proc_struct *proc) 
{  //判断一下要调度的进程是不是当前进程
    if (proc != current) 
    {
        bool intr_flag;
        struct proc_struct *prev = current, *next = proc;
        // 关闭中断,进行进程切换
        local_intr_save(intr_flag);
        {
            //当前进程设为待调度的进程
            current = proc;
            //加载待调度进程的内核栈基地址
            load_esp0(next->kstack + KSTACKSIZE);
            //将当前的cr3寄存器改为需要运行进程的页目录表
            lcr3(next->cr3);
            //进行上下文切换，保存原线程的寄存器并恢复待调度线程的寄存器
            switch_to(&(prev->context), &(next->context));
        }
        //恢复中断
        local_intr_restore(intr_flag);
    }
}

思考题：

在本实验的执行过程中，创建且运行了几个内核线程？

通过kernel_thread函数、proc_init函数以及具体的实现结果可知，本次实验共建立了两个内核线程。首先是idleproc内核线程，该线程是最初的内核线程，完成内核中各个子线程的创建以及初始化。之后循环执行调度，执行其他进程。还有一个是initproc内核线程，该线程主要是为了显示实验的完成而打印出字符串"hello world"的内核线程。
语句local_intr_save(intr_flag);…local_intr_restore(intr_flag);在这里有何作用?请说明理由

是保护进程切换不会被中断，以免进程切换时其他进程再进行调度，相当于互斥锁。之前在第六步添加进程到列表的时候也需要有这个操作，是因为进程进入列表的时候，可能会发生一系列的调度事件，比如我们所熟知的抢断等，加上这么一个保护机制可以确保进程执行不被打乱。

实验重点及需要补充的知识：

进程控制块：

进程控制块，Process Control Block, PCB。

进程控制块是操作系统管理控制进程运行所用的信息集合。操作系统用PCB来描述进程的基本情况以及运行变化的过程。
PCB是进程存在的唯一标志 ，每个进程都在操作系统中有一个对应的PCB。
进程控制块可以通过某个数据结构组织起来（例如链表）。同一状态进程的PCB连接成一个链表，多个状态对应多个不同的链表。各状态的进程形成不同的链表：就绪联链表，阻塞链表等等。

进程状态

进程的生命周期通常有6种情况：进程创建、进程执行、进程等待、进程抢占、进程唤醒、进程结束。

引起进程创建的情况：
- 系统初始化，创建idle进程。
- 用户或正在运行的进程请求创建新进程。
进程等待（阻塞）的情况：
- 进程请求并等待某个系统服务，无法马上完成。
- 启动某种操作，无法马上完成。
- 需要的数据没有到达。
只有该进程本身才能让自己进入休眠，但只有外部（例如操作系统）才能将该休眠的进程唤醒。
引起进程被抢占的情况
- 高优先级进程就绪
- 进程执行当前时间用完（时间片耗尽）
唤醒进程的情况：
- 被阻塞进程需要的资源可被满足。
- 被阻塞进程等待的事件到达。
进程只能被别的进程或操作系统唤醒。
进程结束的情况
- 正常或异常退出（自愿）
- 致命错误（强制性，例如SIGSEV）
- 被其他进程所kill（强制）

进程挂起

将处于挂起状态的进程映像在磁盘上，目的是减少进程占用的内存。

等待挂起（Blocked-suspend）：进程在外存并等待某事件的出现。
就绪挂起（Ready-suspend）：进程在外存，但只要进入内存，即可运行。
挂起（Suspend）：把一个进程从内存转到外存。
- 等待到等待挂起：没有进程处于就绪状态或就绪进程要求更多内存资源。
- 就绪到就绪挂起：当有高优先级进程处于等待状态（系统认为很快会就绪的），低优先级就绪进程会挂起，为高优先级进程提供更大的内存空间。
- 运行到就绪挂起：当有高优先级等待进程因事件出现而进入就绪挂起。
- 等待挂起到就绪挂起：当有等待挂起进程因相关事件出现而转换状态。
激活（Activate）：把一个进程从外存转到内存
- 就绪挂起到就绪：没有就绪进程或挂起就绪进程优先级高于就绪进程。
- 等待挂起到等待：当一个进程释放足够内存，并有高优先级等待挂起进程。

用户线程与内核线程

线程有三种实现方式

用户线程：在用户空间实现。(POSIX Pthread)
内核线程：在内核中实现。(Windows, Linux)
轻权进程：在内核中实现，支持用户线程。

a. 用户线程

用户线程是由一组用户级的线程库函数来完成线程的管理，包括线程的创建、终止、同步和调度等。

用户线程的特征
- 不依赖于操作系统内核，在用户空间实现线程机制。
  - 可用于不支持线程的多进程操作系统。
  - 线程控制模块（TCB）由线程库函数内部维护。
- 同一个进程内的用户线程切换速度块，无需用户态/核心态切换。
- 允许每个进程拥有自己的线程调度算法。
用户进程的缺点
- 线程发起系统调用而阻塞时，整个进程都会进入等待状态。
- 不支持基于线程的处理机抢占。
- 只能按进程分配CPU时间。

b. 内核线程

内核线程是由内核通过系统调用实现的线程机制，由内核完成线程的创建、终止和管理。

内核线程的特征

由内核自己维护PCB和TCB
线程执行系统调用而被阻塞不影响其他线程。
线程的创建、终止和切换消耗相对较大。
以线程为单位进行CPU时间分配。其中多线程进程可以获得更多的CPU时间。

c. 轻权进程

用户线程可以自定义调度算法，但存在部分缺点。而内核线程不存在用户线程的各种缺点。

所以轻权进程是用户线程与内核线程的结合产物。

内核支持的用户线程。一个进程可包含一个或多个轻权进程，每个轻权进程由一个单独的内核线程来支持。
过于复杂以至于优点没有体现出来，最后演化为单一的内核线程支持。

JustinAustin

关注

2
点赞
踩
19

收藏

觉得还不错? 一键收藏
0
评论
清华操作系统实验ucore_lab4

lab4练习0： kdebug.c、trap.c、default_pmm.c、pmm.c、swap_fifo.c vmm.c四个文件的相关代码，补全后进行下一练习练习1：分配并初始化一个进程控制块（需要编码）题目概述： alloc_proc函数（位于kern/process/proc.c中）负责分配并返回一个新的struct proc_struct结构，用于存储新建立的内核线程的管理信息。ucore需要对这个结构进行最基本的初始化，你需要完成这个初始化过程。实现思路：struct pro
复制链接

扫一扫