《操作系统真象还原》从零开始自制操作系统自写源码实现（thread相关文件）

- 日理万妓 2022-09-04 14:53 83阅读 0赞

### 文章目录 ###

*   *  专栏博客链接
     *  thread相关文件
     *   *  编写完的switch.S
         *  编写完的sync.c
         *  编写完的sync.h
         *  编写完的thread.c
         *  编写完的thread.h

--------------------

## 专栏博客链接 ##

--------------------

**[《操作系统真象还原》从零开始自制操作系统 全章节博客链接][Link 1]**

--------------------

## thread相关文件 ##

--------------------

### 编写完的switch.S ###

--------------------

[bits 32]
    section .text
    global switch_to
    switch_to:
        push esi            ;这里是根据ABI原则保护四个寄存器 放到栈里面
        push edi
        push ebx
        push ebp
        
        mov eax,[esp+20]    ;esp+20的位置是cur cur的pcb赋值给eax
        mov [eax],esp       ;[eax]为pcb的内核栈指针变量 把当前环境的esp值记录下来
        
        mov eax,[esp+24]
        mov esp,[eax]       ;把要切换的线程的pcb 内核栈esp取出来
    
        pop ebp
        pop ebx
        pop edi
        pop esi
        ret                 ;这里的返回地址为 kernel_thread的地址

--------------------

### 编写完的sync.c ###

--------------------

#include "sync.h"
    #include "list.h"
    #include "stdint.h"
    #include "thread.h"
    #include "debug.h"
    #include "interrupt.h"
    
    void sema_init(struct semaphore* psema,uint32_t value)
    { 
        psema->value = value;
        list_init(&psema->waiters);
    }
    
    void lock_init(struct lock* plock)
    { 
        sema_init(&plock->semaphore,1);  //信号量初始值都设置成1 
        plock->holder = NULL;
        plock->holder_repeat_nr = 0;
    }
    
    void sema_down(struct semaphore* psema)
    { 
        //保证原子操作
        enum intr_status old_status = intr_disable();
        while(!psema->value)
        { 
        	//访问锁的不应该在锁的等待队列
        	ASSERT(!elem_find(&psema->waiters,&(running_thread()->general_tag)));
        	if(elem_find(&psema->waiters,&(running_thread()->general_tag)))
        	    PANIC("sema_down: seme_down thread already in ready_list\n");
        	list_append(&psema->waiters,&(running_thread()->general_tag));  //添加到等待队列
        	thread_block(TASK_BLOCKED);                                     //阻塞并切换线程
        }
        --psema->value;							  //占用信号量
        ASSERT(!psema->value);	
        intr_set_status(old_status);	
    }
    
    //信号量value增加
    void sema_up(struct semaphore* psema)
    { 
    
        enum intr_status old_status = intr_disable();
        ASSERT(!psema->value);
        if(!list_empty(&psema->waiters))
        { 
        	thread_unblock((struct task_struct*)((uint32_t)list_pop(&psema->waiters) & 0xfffff000));
        }
        ++psema->value;
        ASSERT(psema->value == 1);
        intr_set_status(old_status);
    }
    
    //获取锁资源
    void lock_acquire(struct lock* plock)
    { 
        if(plock->holder != running_thread())
        { 
        	sema_down(&plock->semaphore);		//如果已经被占用 则会被阻塞
        	plock->holder = running_thread();	//之前被阻塞的线程 继续执行 没被阻塞直接继续即可
        	ASSERT(!plock->holder_repeat_nr);
        	plock->holder_repeat_nr = 1;			//访问数为1
        }
        else	++plock->holder_repeat_nr;
    }
    
    //释放锁资源
    void lock_release(struct lock* plock)
    { 
        ASSERT(plock->holder == running_thread());	//释放锁的线程必须是其拥有者
        if(plock->holder_repeat_nr > 1)	//减少到的当前一个线程 次数只有一次访问这个锁时 才允许到下面
        { 
        	--plock->holder_repeat_nr;		
        	return;
        }
        ASSERT(plock->holder_repeat_nr == 1);	//举个例子 该线程在拥有锁时 两次获取锁 第二次肯定是无法获取到的
        						//但是必须同样也要有两次release才算彻底释放 不然只有第一次的relase
        						//第二次都不需要release 就直接释放了 肯定是不行的
        plock->holder = NULL;
        plock->holder_repeat_nr = 0;
        sema_up(&plock->semaphore);   
    }

--------------------

### 编写完的sync.h ###

--------------------

#ifndef __THREAD_SYNC_H
    #define __THREAD_SYNC_H
    #include "list.h"
    #include "stdint.h"
    #include "thread.h"
    
    struct semaphore
    { 
        uint8_t value;	    //信号量的值
        struct list waiters;   //等待队列
    };
    
    struct lock
    { 
        struct task_struct* holder;
        struct semaphore semaphore;
        uint32_t holder_repeat_nr;	//在释放的时候 通过这个值决定需要 释放锁几次
    };
    
    //揣测了一下 sema 前面加了个p 应该是ptr 指针的意思
    void sema_init(struct semaphore* psema,uint32_t value);
    void lock_init(struct lock* plock);
    void sema_down(struct semaphore* psema);
    void sema_up(struct semaphore* psema);
    void lock_acquire(struct lock* plock);
    void lock_release(struct lock* plock);
    #endif

--------------------

### 编写完的thread.c ###

--------------------

#include "thread.h" //函数声明 各种结构体
    #include "stdint.h" //前缀
    #include "string.h" //memset
    #include "global.h" //不清楚
    #include "memory.h" //分配页需要
    #include "debug.h"
    #include "interrupt.h"
    #include "print.h"
    #include "../userprog/process.h"
    #include "../thread/sync.h"
    #include "syscall.h"
    
    struct task_struct* main_thread;                        //主线程main_thread的pcb
    struct task_struct* idle_thread;			  //休眠线程
    struct list thread_ready_list;			  //就绪队列
    struct list thread_all_list;				  //总线程队列
    struct lock pid_lock;
    
    extern void switch_to(struct task_struct* cur,struct task_struct* next);
    extern void init(void);
    
    // 获取 pcb 指针
    // 这部分我可以来稍微解释一下
    // 我们线程所在的esp 肯定是在 我们get得到的那一页内存 pcb页上下浮动 但是我们的pcb的最起始位置是整数的 除去后面的12位
    // 那么我们对前面的取 & 则可以得到 我们的地址所在地
    
    pid_t allocate_pid(void)
    { 
        static pid_t next_pid = 0;			  //约等于全局变量 全局性+可修改性
        lock_acquire(&pid_lock);
        ++next_pid;
        lock_release(&pid_lock);
        return next_pid;
    }
    
    struct task_struct* running_thread(void)
    { 
        uint32_t esp;
        asm ("mov %%esp,%0" : "=g"(esp));
        return (struct task_struct*)(esp & 0xfffff000);
    }
    
    
    void kernel_thread(thread_func* function,void* func_arg)
    { 
        intr_enable();					    //开中断 防止后面的时间中断被屏蔽无法切换线程
        function(func_arg);
    }
    
    void thread_create(struct task_struct* pthread,thread_func function,void* func_arg)
    { 
        pthread->self_kstack -= sizeof(struct intr_stack);  //减去中断栈的空间
        pthread->self_kstack -= sizeof(struct thread_stack);
        struct thread_stack* kthread_stack = (struct thread_stack*)pthread->self_kstack; 
        kthread_stack->eip = kernel_thread;                 //地址为kernel_thread 由kernel_thread 执行function
        kthread_stack->function = function;
        kthread_stack->func_arg = func_arg;
        kthread_stack->ebp = kthread_stack->ebx = kthread_stack->ebx = kthread_stack->esi = 0; //初始化一下
        return;
    }
    
    void init_thread(struct task_struct* pthread,char* name,int prio)
    { 
        memset(pthread,0,sizeof(*pthread)); //pcb位置清0
        strcpy(pthread->name,name);
        
        if(pthread == main_thread)
        	pthread->status = TASK_RUNNING;                              //我们的主线程肯定是在运行的
        else
        	pthread->status = TASK_READY;					//放到就绪队列里面
        	
        pthread->self_kstack = (uint32_t*)((uint32_t)pthread + PG_SIZE); //刚开始的位置是最低位置 栈顶位置+一页得最顶部
                                                                         //后面还要对这个值进行修改
        pthread->pid = allocate_pid();                                   //提前分配pid 
        pthread->priority = prio;                                        
        pthread->ticks = prio;                                           //和特权级 相同的时间片
        pthread->elapsed_ticks = 0;
        pthread->pgdir = NULL;                                           //线程没有单独的地址
        pthread->fd_table[0] = 0;						
        pthread->fd_table[1] = 0;
        pthread->fd_table[2] = 0;
        
        uint8_t fd_idx = 3;
        while(fd_idx < MAX_FILES_OPEN_PER_PROC)
        	pthread->fd_table[fd_idx++] = -1;
        pthread->parent_pid   = -1;					//父进程的pid默认为-1
        pthread->cwd_inode_nr = 0;					//默认工作路径在根目录
        pthread->stack_magic = 0x23333333;                               //设置的魔数 检测是否越界限
    }
    
    struct task_struct* thread_start(char* name,int prio,thread_func function,void* func_arg)
    { 
        struct task_struct* thread = get_kernel_pages(1);
        init_thread(thread,name,prio);
        thread_create(thread,function,func_arg);
        ASSERT(!elem_find(&thread_ready_list,&thread->general_tag));     //之前不应该在就绪队列里面
        list_append(&thread_ready_list,&thread->general_tag);
        
        ASSERT(!elem_find(&thread_all_list,&thread->all_list_tag));
        list_append(&thread_all_list,&thread->all_list_tag);
         
        return thread;
    }
    
    
    //之前在loader.S的时候已经 mov esp,0xc0009f00
    //现在的esp已经就在预留的pcb位置上了
    void make_main_thread(void)
    { 		
        main_thread = running_thread();					//得到main_thread 的pcb指针
        init_thread(main_thread,"main",31);				
        
        ASSERT(!elem_find(&thread_all_list,&main_thread->all_list_tag));
        list_append(&thread_all_list,&main_thread->all_list_tag);
        
    }
    
    void schedule(void)
    { 
        ASSERT(intr_get_status() == INTR_OFF);
        
        struct task_struct* cur = running_thread();			//得到当前pcb的地址
        if(cur->status == TASK_RUNNING)
        { 
        	ASSERT(!elem_find(&thread_ready_list,&cur->general_tag));     //目前在运行的肯定ready_list是不在的
        	list_append(&thread_ready_list,&cur->general_tag);            //加入尾部
        	
        	cur->status = TASK_READY;
        	cur->ticks = cur->priority;
        }
        else
        { }
        
        if(list_empty(&thread_ready_list))
        	thread_unblock(idle_thread);
        
        struct task_struct* thread_tag = list_pop(&thread_ready_list);
        //书上面的有点难理解 代码我写了一个我能理解的
        struct task_struct* next = (struct task_struct*)((uint32_t)thread_tag & 0xfffff000);
        next->status = TASK_RUNNING;
        process_activate(next);	
        switch_to(cur,next);                                              //esp头顶的是 返回地址 +12是next +8是cur
    }
    
    void thread_block(enum task_status stat)
    { 
        //设置block状态的参数必须是下面三个以下的
        ASSERT(((stat == TASK_BLOCKED) || (stat == TASK_WAITING) || stat == TASK_HANGING));
        
        enum intr_status old_status = intr_disable();			 //关中断
        struct task_struct* cur_thread = running_thread();		 
        cur_thread->status = stat;					 //把状态重新设置
        
        //调度器切换其他进程了 而且由于status不是running 不会再被放到就绪队列中
        schedule();	
        				
        //被切换回来之后再进行的指令了
        intr_set_status(old_status);
    }
    
    //由锁拥有者来执行的 善良者把原来自我阻塞的线程重新放到队列中
    void thread_unblock(struct task_struct* pthread)
    { 
        enum intr_status old_status = intr_disable();
        ASSERT(((pthread->status == TASK_BLOCKED) || (pthread->status == TASK_WAITING) || (pthread->status == TASK_HANGING)));
        if(pthread->status != TASK_READY)
        { 
        	//被阻塞线程 不应该存在于就绪队列中）
        	ASSERT(!elem_find(&thread_ready_list,&pthread->general_tag));
        	if(elem_find(&thread_ready_list,&pthread->general_tag))
        	    PANIC("thread_unblock: blocked thread in ready_list\n"); //debug.h中定义过
        	
        	//让阻塞了很久的任务放在就绪队列最前面
        	list_push(&thread_ready_list,&pthread->general_tag);
        	
        	//状态改为就绪态
        	pthread->status = TASK_READY;
        }
        intr_set_status(old_status);
    }
    
    void idle(void)
    { 
        while(1)
        { 
        	thread_block(TASK_BLOCKED);	//先阻塞后 被唤醒之后即通过命令hlt 使cpu挂起 直到外部中断cpu恢复
        	asm volatile ("sti;hlt" : : :"memory");
        }
    }
    
    void thread_yield(void)
    { 
        struct task_struct* cur = running_thread();
        enum intr_status old_status = intr_disable();
        ASSERT(!elem_find(&thread_ready_list,&cur->general_tag));
        list_append(&thread_ready_list,&cur->general_tag);	//放到就绪队列末尾
        cur->status = TASK_READY;					//状态设置为READY 可被调度
        schedule();						
        intr_set_status(old_status);
    }
    
    pid_t fork_pid(void)
    { 
        return allocate_pid();
    }
    
    void pad_print(char* buf,int32_t buf_len,void* ptr,char format)
    { 
        memset(buf,0,buf_len);
        uint8_t out_pad_0idx = 0;
        switch(format)
        { 
            case 's':
                out_pad_0idx = sprintf(buf,"%s",ptr);
                break;
            case 'd':
                out_pad_0idx = sprintf(buf,"%d",*((int16_t*)ptr));
                break;
            case 'x':
                out_pad_0idx = sprintf(buf,"%x",*((uint32_t*)ptr));   
        }
        while(out_pad_0idx < buf_len)
        { 
            buf[out_pad_0idx] = ' ';
            out_pad_0idx++;
        }
        sys_write(stdout_no,buf,buf_len-1);
    }
    
    bool elem2thread_info(struct list_elem* pelem,int arg)
    { 
        struct task_struct* pthread = elem2entry(struct task_struct,all_list_tag,pelem);
        char out_pad[16] = { 0};
        pad_print(out_pad,16,&pthread->pid,'d');
        
        if(pthread->parent_pid == -1)
        	pad_print(out_pad,16,"NULL",'s');
        else
            pad_print(out_pad,16,&pthread->parent_pid,'d');
            
        switch(pthread->status)
        { 
            case 0:
                pad_print(out_pad,16,"RUNNING",'s');
                break;
            case 1:
                pad_print(out_pad,16,"READY",'s');
                break;
            case 2:
                pad_print(out_pad,16,"BLOCKED",'s');
                break;
            case 3:
                pad_print(out_pad,16,"WAITING",'s');
                break;
            case 4:
                pad_print(out_pad,16,"HANGING",'s');
                break;
            case 5:
                pad_print(out_pad,16,"DIED",'s');
                break;
        }
        pad_print(out_pad,16,&pthread->elapsed_ticks,'x');
        
        memset(out_pad,0,16);
        ASSERT(strlen(pthread->name) < 17);
        memcpy(out_pad,pthread->name,strlen(pthread->name));
        strcat(out_pad,"\n");
        sys_write(stdout_no,out_pad,strlen(out_pad));
        return false;
    }
    //打印任务列表
    void sys_ps(void)
    { 
        char* ps_title = "PID PPID STAT TICKS COMMAND\n";
        sys_write(stdout_no,ps_title,strlen(ps_title));
        list_traversal(&thread_all_list,elem2thread_info,0);
    }
    
    void thread_init(void)
    { 
        put_str("thread_init start!\n");
        list_init(&thread_ready_list);
        list_init(&thread_all_list);
        lock_init(&pid_lock);
        process_execute(init,"init");
        make_main_thread();
        idle_thread = thread_start("idle",10,idle,NULL);	//创建休眠进程
        put_str("thread_init done!\n");
    }

--------------------

### 编写完的thread.h ###

--------------------

#ifndef __THREAD_THREAD_H
    #define __THREAD_THREAD_H
    #include "stdint.h"
    #include "global.h"
    #include "list.h"
    #include "../kernel/memory.h"
    
    #define PG_SIZE 4096
    #define MAX_FILES_OPEN_PER_PROC 8 
    typedef int16_t pid_t;
    extern struct list thread_ready_list,thread_all_list;
    
    typedef void thread_func(void*); //这里有点不懂定义的什么意思 搜了搜博客 发现是函数声明 
                              
    enum task_status
    { 
        TASK_RUNNING, // 0
        TASK_READY,   // 1
        TASK_BLOCKED, // 2
        TASK_WAITING, // 3
        TASK_HANGING, // 4
        TASK_DIED     // 5
    };
    
    /* intr_stack 用于处理中断被切换的上下文环境储存 */
    /* 这里我又去查了一下 为什么是反着的 越在后面的参数 地址越高 */
    
    struct intr_stack
    { 
        uint32_t vec_no; //中断号
        uint32_t edi;
        uint32_t esi;
        uint32_t ebp;
        uint32_t esp_dummy;
        uint32_t ebx;
        uint32_t edx;
        uint32_t ecx;
        uint32_t eax;
        uint32_t gs;
        uint32_t fs;
        uint32_t es;
        uint32_t ds;
        
        uint32_t err_code;
        void (*eip) (void);        //这里声明了一个函数指针 
        uint32_t cs;
        uint32_t eflags;
        void* esp;
        uint32_t ss;
    };
    
    
    /* 线程栈 保护线程环境 */
    
    struct thread_stack
    { 
        uint32_t ebp;
        uint32_t ebx;
        uint32_t edi;
        uint32_t esi;
    
        void (*eip) (thread_func* func,void* func_arg); //和下面的相互照应 以ret 汇编代码进入kernel_thread函数调用
        
        void (*unused_retaddr);                         //占位数 在栈顶站住了返回地址的位置 因为是汇编ret 
        thread_func* function;                          //进入kernel_thread要调用的函数地址
        void* func_arg;				      //参数指针
    };
    
    struct task_struct
    { 
        uint32_t* self_kstack;                          //pcb中的 kernel_stack 内核栈
        pid_t pid;
        enum task_status status;                        //线程状态
        uint8_t priority;				      //特权级
        uint8_t ticks;				      //在cpu 运行的滴答数 看ticks 来判断是否用完了时间片
        uint32_t elapsed_ticks;                         //一共执行了多久
        char name[16];
        
        struct list_elem general_tag;                   //就绪队列中的连接节点
        struct list_elem all_list_tag;		      //总队列的连接节点
        int32_t fd_table[MAX_FILES_OPEN_PER_PROC];      //文件描述符数组
        
        uint32_t* pgdir;				      //进程自己页表的虚拟地址 线程没有 
        struct virtual_addr userprog_vaddr;	      //用户进程的虚拟空间 
        struct mem_block_desc u_block_desc[DESC_CNT];   //内存块描述符
        uint32_t cwd_inode_nr;			      //工作目录inode编号
        int16_t  parent_pid;			      //父进程的pid编号
        uint32_t stack_magic;			      //越界检查 因为我们pcb上面的就是我们要用的栈了 到时候还要越界检查
    };
    
    pid_t allocate_pid(void);
    struct task_struct* running_thread(void);
    void kernel_thread(thread_func* function,void* func_arg);
    void thread_create(struct task_struct* pthread,thread_func function,void* func_arg);
    void init_thread(struct task_struct* pthread,char* name,int prio);
    struct task_struct* thread_start(char* name,int prio,thread_func function,void* func_arg);
    void make_main_thread(void);
    void schedule(void);
    void thread_init(void);
    void thread_block(enum task_status stat);
    void thread_unblock(struct task_struct* pthread);
    void idle(void);
    void thread_yield(void);
    pid_t fork_pid(void);
    void pad_print(char* buf,int32_t buf_len,void* ptr,char format);
    bool elem2thread_info(struct list_elem* pelem,int arg);
    void sys_ps(void);
    
    #endif

[Link 1]: https://love6.blog.csdn.net/article/details/119133589