二、7.用户进程

TSS 是 x86CPU 的特定结构，被用来定义“任务”，它是内置到处理器原生支持的多任务的一种形式。

通过 call 指令＋TSS 选择子的形式进行任务切换，此过程大概分成 10 步，这还是直接用 TSS 选择子进行任务切换的步骤，这已经非常繁琐了，在每一次任务切换过程中， CPU 除了做特权级检查外，还要在 TSS 的加载、保存、设置 B位，以及设置标志寄存器 eflags 的 NT 位诸多方面消耗很多精力，这导致此种切换方式效能很低。

其次，常见的指令集有两大派系，复杂指令集 CISC 和精简指令集 RISC。x86 使用的指令集属于 CISC，虽然指令功能很强，但这只是开发效率上的提升，执行效率却下降了， CISC 的强大需要更多的时钟周期作为代价。

最后，一个任务需要单独关联一个 TSS, TSS 需要在 GDT 中注册， GDT 中最多支持 8192 个描述符，为了支持更多的任务，随着任务的增减，要及时修改 GDT，在其中增减 TSS 描述符，修改过后还要重新加载 GDT。这种频繁修改描述符表的操作还是很消耗 CPU 资源的。

但是因为CPU的限制，有一件工作必须且只能用 TSS 来完成，这就是 CPU 向更高特权级转移时所使用的栈地址，需要提前在 TSS 中写入 。导致转移到更高特权级的一种情况是在用户模式下发生中断， CPU 会由低特权级进入高特权级，这会发生堆梭的切换。当一个中断发生在用户模式（特权级 3 ），处理器从当前 TSS 的 ss0 和 esp0 成员中获取用于处理中断的堆枝。因此，我们必须创建一个 TSS ，并且至少初始化 TSS 中的这些字段 。

Linux 在 TSS 中只初始化了 ss0 、 esp0 和 1/0 位图字段，除此之外 TSS 便没用了，就是个空架子，不再做保存任务状态之用。

当 CPU 由低特权级进入高特权级时， CPU 会“自动”从 TSS 中获取对应高特权级的栈指针（ TSS 是 CPU 内部框架原生支持的嘛，当然是自动从中获取新的栈指针） 。 我们具体说一下， Linux 只用到了特权 3 级和特权 0 级，因此 CPU 从 3 特权级的用户态进入 0 特权级的内核态时（比如从用户进程进入中断）， CPU 自动从当前任务的 TSS 中获取 ss0 和 esp0 字段的值作为 0 特权级的栈，然后 Linux “手动”执行一系列的 push 指令将任务的状态的保存在 0 特权级栈中，也就是 TSS 中 ss0 和 esp0 所指向的栈。

要知道，人家 Intel 当初是打算让 TR 寄存器指向不同任务的 TSS 以实现任务切换的， Linux 这里只换了 TSS 中的部分内容，而 TR 本身没换，还是指向同一个 TSS ，这种“自欺欺人”的好处是任务切换的开销更小了，因为和修改 TSS 中的内容所带来的开销相比，在 TR 中加载 TSS 的开销要大得多 。

另外， Linux 中任务切换不使用 call 和 jmp 指令，这也避免了任务切换的低效

定义并初始化TSS

// ----------------  GDT描述符属性  ----------------#define	DESC_G_4K    1
#define	DESC_D_32    1
#define DESC_L	     0	// 64位代码标记，此处标记为0便可。
#define DESC_AVL     0	// cpu不用此位，暂置为0  
#define DESC_P	     1
#define DESC_DPL_0   0
#define DESC_DPL_1   1
#define DESC_DPL_2   2
#define DESC_DPL_3   3
/* 代码段和数据段属于存储段，tss和各种门描述符属于系统段s为1时表示存储段,为0时表示系统段.
*/
#define DESC_S_CODE	1
#define DESC_S_DATA	DESC_S_CODE
#define DESC_S_SYS	0
#define DESC_TYPE_CODE	8	// x=1,c=0,r=0,a=0 代码段是可执行的,非依从的,不可读的,已访问位a清0.  
#define DESC_TYPE_DATA  2	// x=0,e=0,w=1,a=0 数据段是不可执行的,向上扩展的,可写的,已访问位a清0.
#define DESC_TYPE_TSS   9	// B位为0,不忙...
#define SELECTOR_K_CODE	   ((1 << 3) + (TI_GDT << 2) + RPL0)
#define SELECTOR_K_DATA	   ((2 << 3) + (TI_GDT << 2) + RPL0)
#define SELECTOR_K_STACK   SELECTOR_K_DATA 
#define SELECTOR_K_GS	   ((3 << 3) + (TI_GDT << 2) + RPL0)
/* 第3个段描述符是显存,第4个是tss */
#define SELECTOR_U_CODE	   ((5 << 3) + (TI_GDT << 2) + RPL3)
#define SELECTOR_U_DATA	   ((6 << 3) + (TI_GDT << 2) + RPL3)
#define SELECTOR_U_STACK   SELECTOR_U_DATA#define GDT_ATTR_HIGH		 ((DESC_G_4K << 7) + (DESC_D_32 << 6) + (DESC_L << 5) + (DESC_AVL << 4))
#define GDT_CODE_ATTR_LOW_DPL3	 ((DESC_P << 7) + (DESC_DPL_3 << 5) + (DESC_S_CODE << 4) + DESC_TYPE_CODE)
#define GDT_DATA_ATTR_LOW_DPL3	 ((DESC_P << 7) + (DESC_DPL_3 << 5) + (DESC_S_DATA << 4) + DESC_TYPE_DATA)//---------------  TSS描述符属性  ------------
#define TSS_DESC_D  0 #define TSS_ATTR_HIGH ((DESC_G_4K << 7) + (TSS_DESC_D << 6) + (DESC_L << 5) + (DESC_AVL << 4) + 0x0)
#define TSS_ATTR_LOW ((DESC_P << 7) + (DESC_DPL_0 << 5) + (DESC_S_SYS << 4) + DESC_TYPE_TSS)
#define SELECTOR_TSS ((4 << 3) + (TI_GDT << 2 ) + RPL0)struct gdt_desc {uint16_t limit_low_word;uint16_t base_low_word;uint8_t  base_mid_byte;uint8_t  attr_low_byte;uint8_t  limit_high_attr_high;uint8_t  base_high_byte;
}; 

/* 任务状态段tss结构 */
//tss由程序员提供，CPU维护
struct tss {uint32_t backlink;uint32_t* esp0;uint32_t ss0;uint32_t* esp1;uint32_t ss1;uint32_t* esp2;uint32_t ss2;uint32_t cr3;uint32_t (*eip) (void);uint32_t eflags;uint32_t eax;uint32_t ecx;uint32_t edx;uint32_t ebx;uint32_t esp;uint32_t ebp;uint32_t esi;uint32_t edi;uint32_t es;uint32_t cs;uint32_t ss;uint32_t ds;uint32_t fs;uint32_t gs;uint32_t ldt;uint32_t trace;uint32_t io_base;
}; 
static struct tss tss;/* 更新tss中esp0字段的值为pthread的0级线，即线程pthread的PCB所在页的最顶端 */
void update_tss_esp(struct task_struct* pthread) {tss.esp0 = (uint32_t*)((uint32_t)pthread + PG_SIZE);
}/* 创建新的gdt描述符并返回（未安装） */
static struct gdt_desc make_gdt_desc(uint32_t* desc_addr, uint32_t limit, uint8_t attr_low, uint8_t attr_high) {uint32_t desc_base = (uint32_t)desc_addr;struct gdt_desc desc;desc.limit_low_word = limit & 0x0000ffff;desc.base_low_word = desc_base & 0x0000ffff;desc.base_mid_byte = ((desc_base & 0x00ff0000) >> 16);desc.attr_low_byte = (uint8_t)(attr_low);desc.limit_high_attr_high = (((limit & 0x000f0000) >> 16) + (uint8_t)(attr_high));desc.base_high_byte = desc_base >> 24;return desc;
}/* 在gdt中创建tss并重新加载gdt */
void tss_init() {put_str("tss_init start\n");uint32_t tss_size = sizeof(tss);memset(&tss, 0, tss_size);tss.ss0 = SELECTOR_K_STACK;//为其 ssO 字段赋 0 级技段的选择子tss.io_base = tss_size;//将tss的io base字段置为tss的大小tss size，这表示此TSS中并没有IO位图/* gdt段基址为0x900,把tss放到第4个位置,也就是0x900+0x20的位置 *//* 在gdt中添加特权级dpl为0的TSS描述符 *///在 GDT 中一个描述符8字节，第 0 个段描述符不可用，第 1 个为代码段，第 2 个为数据段和楠，第 3 个为显存段，因此把 tss 放到第 4 个位置，也就是 0xc0000900+4*8=0xc0000900+0x20 的位置。*((struct gdt_desc*)0xc0000920) = make_gdt_desc((uint32_t*)&tss, tss_size - 1, TSS_ATTR_LOW, TSS_ATTR_HIGH);/* 在gdt中添加dpl为3的数据段和代码段描述符 */*((struct gdt_desc*)0xc0000928) = make_gdt_desc((uint32_t*)0, 0xfffff, GDT_CODE_ATTR_LOW_DPL3, GDT_ATTR_HIGH);*((struct gdt_desc*)0xc0000930) = make_gdt_desc((uint32_t*)0, 0xfffff, GDT_DATA_ATTR_LOW_DPL3, GDT_ATTR_HIGH);/* gdt 16位的limit 32位的段基址 */uint64_t gdt_operand = ((8 * 7 - 1) | ((uint64_t)(uint32_t)0xc0000900 << 16));   // 7个描述符大小asm volatile ("lgdt %0" : : "m" (gdt_operand));asm volatile ("ltr %w0" : : "r" (SELECTOR_TSS));put_str("tss_init and ltr done\n");
}

实现用户进程

进程与内核线程最大的区别是进程有单独的 4GB 空间，这指的是虚拟地址，物理地址空间可未必有那么大，看似无限的虚拟地址经过分页机制之后，最终要落到有限的物理页中。

进程是基于线程实现的，因此它和线程一样使用相同的 pcb 结构，即 struct task_struct，我们要做的就是在此结构中增加一个成员，用它来跟踪用户空间虚拟地址的分配情况。

/* 进程或线程的pcb,程序控制块 */
struct task_struct {uint32_t* self_kstack;	 // 各内核线程都用自己的内核栈enum task_status status;char name[16];uint8_t priority;uint8_t ticks;	   // 每次在处理器上执行的时间嘀嗒数/* 此任务自上cpu运行后至今占用了多少cpu嘀嗒数,* 也就是此任务执行了多久*/uint32_t elapsed_ticks;/* general_tag的作用是用于线程在一般的队列中的结点 */struct list_elem general_tag;				    /* all_list_tag的作用是用于线程队列thread_all_list中的结点 */struct list_elem all_list_tag;uint32_t* pgdir;              // 进程自己页表的虚拟地址struct virtual_addr userprog_vaddr;   // 用户进程的虚拟地址池uint32_t stack_magic;	 // 用这串数字做栈的边界标记,用于检测栈的溢出
};

页表虽然用于管理内存，但它本身也要用内存来存储，所以要为每个进程单独申请存储页目录项及页表项的虚拟内存页。

除此之外，咱们之前创建的线程属于内核的线程，它们运行在特权级0。和它们相比，用户进程还多了个特权级 3，大多数情况下，用户进程在特权级 3 下工作，因此，我们还要为用户进程创建在 3 特权级的栈。栈也是内存区域，所以，咱们还得为进程分配内存（虚拟内存）作为 3 级栈空间

image-20230819093107935

/* 内存池结构,生成两个实例用于管理内核内存池和用户内存池 */
struct pool {struct bitmap pool_bitmap;	 // 本内存池用到的位图结构,用于管理物理内存uint32_t phy_addr_start;	 // 本内存池所管理物理内存的起始地址uint32_t pool_size;		 // 本内存池字节容量struct lock lock;		 // 申请内存时互斥
};/* 在pf表示的虚拟内存池中申请pg_cnt个虚拟页,* 成功则返回虚拟页的起始地址, 失败则返回NULL */
static void* vaddr_get(enum pool_flags pf, uint32_t pg_cnt) {int vaddr_start = 0, bit_idx_start = -1;uint32_t cnt = 0;if (pf == PF_KERNEL) {     // 内核内存池...} else {	     // 用户内存池struct task_struct* cur = running_thread();bit_idx_start  = bitmap_scan(&cur->userprog_vaddr.vaddr_bitmap, pg_cnt);if (bit_idx_start == -1) {return NULL;}while(cnt < pg_cnt) {bitmap_set(&cur->userprog_vaddr.vaddr_bitmap, bit_idx_start + cnt++, 1);}vaddr_start = cur->userprog_vaddr.vaddr_start + bit_idx_start * PG_SIZE;/* (0xc0000000 - PG_SIZE)做为用户3级栈已经在start_process被分配 */ASSERT((uint32_t)vaddr_start < (0xc0000000 - PG_SIZE));}return (void*)vaddr_start;
}/* 在用户空间中申请4k内存,并返回其虚拟地址 */
void* get_user_pages(uint32_t pg_cnt) {lock_acquire(&user_pool.lock);void* vaddr = malloc_page(PF_USER, pg_cnt);memset(vaddr, 0, pg_cnt * PG_SIZE);lock_release(&user_pool.lock);return vaddr;
}/* 将地址vaddr与pf池中的物理地址关联,仅支持一页空间分配 */
void* get_a_page(enum pool_flags pf, uint32_t vaddr) {struct pool* mem_pool = pf & PF_KERNEL ? &kernel_pool : &user_pool;lock_acquire(&mem_pool->lock);/* 先将虚拟地址对应的位图置1 */struct task_struct* cur = running_thread();int32_t bit_idx = -1;if (cur->pgdir != NULL && pf == PF_USER) {/* 若当前是用户进程申请用户内存,就修改用户进程自己的虚拟地址位图 */bit_idx = (vaddr - cur->userprog_vaddr.vaddr_start) / PG_SIZE;ASSERT(bit_idx > 0);bitmap_set(&cur->userprog_vaddr.vaddr_bitmap, bit_idx, 1);} else if (cur->pgdir == NULL && pf == PF_KERNEL){/* 如果是内核线程申请内核内存,就修改kernel_vaddr. */bit_idx = (vaddr - kernel_vaddr.vaddr_start) / PG_SIZE;ASSERT(bit_idx > 0);bitmap_set(&kernel_vaddr.vaddr_bitmap, bit_idx, 1);} else {PANIC("get_a_page:not allow kernel alloc userspace or user alloc kernelspace by get_a_page");}void* page_phyaddr = palloc(mem_pool);if (page_phyaddr == NULL) {return NULL;}page_table_add((void*)vaddr, page_phyaddr); lock_release(&mem_pool->lock);return (void*)vaddr;
}/* 得到虚拟地址映射到的物理地址 */
uint32_t addr_v2p(uint32_t vaddr) {uint32_t* pte = pte_ptr(vaddr);/* (*pte)的值是虚拟地址映射的页表所在的物理页框地址,* 去掉其低12位的页表项属性+虚拟地址vaddr的低12位 */return ((*pte & 0xfffff000) + (vaddr & 0x00000fff));
}/* 初始化内存池 */
static void mem_pool_init(uint32_t all_mem) {...lock_init(&kernel_pool.lock);//锁初始化lock_init(&user_pool.lock);...
}

CPU 不允许从高特权级转向低特权级，除非是从中断和调用门返回的情况下。咱们系统中不打算使用调用门，因此，咱们进入特权级 3 只能借助从中断返回的方式

关键点 1 ：从中断返回，必须要经过 intr_exit，即使是“假装”

关键点 2：必须提前准备好用户进程所用的栈结构，在里面填装好用户进程的上下文信息，借一系列 pop 出栈的机会，将用户进程的上下文信息载入CPU的寄存器，为用户进程的运行准备好环境。

关键点 3 ：我们要在栈中存储的 cs 选择子，其 RPL 必须为 3 。

关键点 4：栈中段寄存器的选择子必须指向 DPL 为 3 的内存段，因为在 RPL=CPL=3 的情况下，用户进程只能访问 DPL 为 3 的内存段，即代码段、数据段、栈段

关键点 5：必须使栈中 eflags 的 IF 位为 1，继续响应新的中断。

关键点 6：必须使栈中 eflags 的 IOPL 位为 0。不允许用户进程直接访问硬件

//eflags的属性位
#define EFLAGS_MBS		(1 << 1)	// 此项必须要设置
#define EFLAGS_IF_1		(1 << 9)	// if为1,开中断
#define EFLAGS_IF_0		0		    // if为0,关中断
#define EFLAGS_IOPL_3	(3 << 12)	// IOPL3,用于测试用户程序在非系统调用下进行IO
#define EFLAGS_IOPL_0	(0 << 12)	// IOPL0#define NULL ((void*)0)
#define DIV_ROUND_UP(X, STEP) ((X + STEP - 1) / (STEP))
#define bool int
#define true 1
#define false 0

bbs

C 程序的内存空间中，位于低处的三个段是代码段、数据段和 bss 段，它们由编译器和链接器规划地址空间，在程序被操作系统加载之前它们地址就固定了。而堆是位于 bss 段的上面，栈是位于堆的上面，它们共享 4GB 空间中除了代码段、数据段及顶端命令行参数和环境变量等以外的其余可用空间，它们的地址由操作系统来管理，在程序加载时为用户进程分配栈空间，运行过程中为进程从堆中分配内存。堆向上扩展，栈向下扩展，因此在程序的加载之初，操作系统必须为堆和栈分别指定起始地址。

堆是要安排在 bss 以上的，按理说我们只要找到 bss 的结束地址就可以自由规划堆的起始地址了。

大伙儿知道， C 程序大体上分为预处理、编译、汇编和链接四个阶段。根据语法规则，编译器会在汇编阶段将汇编程序源码中的关键字 section 或 segment 编译成节，也就是之前介绍的 section，此时只是生成了目标文件，目标文件中的这些节还不是程序空间中的独立的代码段或数据段，或者说仅仅是代码段或数据段的一部分。链接器将这些目标文件中属性相同的节（ section ）合并成段（segment），因此一个段是由多个节组成的，我们平时所说的 C 程序内存空间中的数据段、代码段就是指合并后的 segment。

为什么要将 section 合并成 segment？这么做的原因也很简单， 一是为了保护模式下的安全检查，二是为了操作系统在加载程序时省事。因为在操作系统的视角中，它只关心程序中这些节的属性是什么，以便加载程序时为其分配不同的段选择子，从而使程序内存指向不同的段描述符，起到保护内存的作用。因此最好是链接器把目标文件中属性相同的节合井到一起，这样操作系统便可统一为其分配内存了。

照属性来划分节，大致上有三种类型。

  1. 可读写的数据，如数据节.data 和未初始化节.bss 。
  2. 只读可执行的代码，如代码节 .text 和初始化代码节 .init 。
  3. 只读数据，如只读数据节 .rodata，一般情况下字符串就存储在此节。
    经过这样的划分，所有节都可归并到以上三种之一，这样方便了操作系统加载程序时的内存分配。由链接器把目标文件中相同属性的节归井之后的节的集合，便称为 segment，它存在于二进制可执行文件中，也就是 C 程序运行时内存空间中分布的代码段、数据段等段

未运行之前或运行之初，程序中 bss 中的内容都是未初始化的数据，它们也是变量，只不过这些变量的值在最初时是多少都无所谓，它们的意义是在运行过程中才产生的，故程序文件中无需存在 bss 实体，因此不占用文件大小。在程序运行后那些位于 bss 中的未初始化数据便被赋予了有意义的值，那时 bss 开始变得有意义，故 bss 仅存在于内存中。您看，既然 bss 中的数据也是变量，就肯定要占用内存空间，需要把空间预留出来，但它们并不在文件中存在，对于这种只占内存又不占文件系统空间的数据，链接器采取了合理的做法：由于 bss 中的内容是变量，其属性为可读写，这和数据段属性一致，故链接器将 bss 占用的内存空间大小合并到数据段占用的内存中，这样便在数据段中预留出 bss 的空间以供程序在将来运行时使用。

bss 的作用就是为程序运行过程中使用的未初始化数据变量提前预留了内存空间。程序的 bss 段（数据段的一部分）会由该加载器填充为 0。由此可见，为生成在某操作系统下运行的用户程序，编译器和操作系统需要相互配合。

在 C 语言中，函数 malloc 用来动态申请内存，所谓的动态内存申请，是指程序在运行中申请的 内存，并不是在程序加载时由操作系统加载器为程序段分配的“固定、静态”内存，这种动态申请的内存就是操作系统从申请者自己的堆中分配的。既然将来要支持malloc，那么必须有堆内存管理。

既然 bss 已经被归并到数据段了，数据段的类型是可加载的 LOAD 型，程序将来加载运行时，操作系统的程序加载器会为该程序的数据段分配内存，也就是 bss 段的内存区域也会顺便被分配，因此我们不需要单独知道 bss 的结束地址，只要知道数据段的起始地址及大小，便可以确定堆的起始地址了。

extern void intr_exit(void);/* 构建用户进程初始上下文信息 */
void start_process(void* filename_) {void* function = filename_;struct task_struct* cur = running_thread();cur->self_kstack += sizeof(struct thread_stack);//使指针 self_kstack 跨过 struct thread_stack 栈，指向 struct intr_stack 梭的最低处struct intr_stack* proc_stack = (struct intr_stack*)cur->self_kstack;// 8个通用寄存器初始化proc_stack->edi = proc_stack->esi = proc_stack->ebp = proc_stack->esp_dummy = 0;proc_stack->ebx = proc_stack->edx = proc_stack->ecx = proc_stack->eax = 0;proc_stack->gs = 0;		 // 用户态用不上,直接初始为0proc_stack->ds = proc_stack->es = proc_stack->fs = SELECTOR_U_DATA;proc_stack->eip = function;	 // 待执行的用户程序地址proc_stack->cs = SELECTOR_U_CODE;proc_stack->eflags = (EFLAGS_IOPL_0 | EFLAGS_MBS | EFLAGS_IF_1);proc_stack->esp = (void*)((uint32_t)get_a_page(PF_USER, USER_STACK3_VADDR) + PG_SIZE) ;proc_stack->ss = SELECTOR_U_DATA; asm volatile ("movl %0, %%esp; jmp intr_exit" : : "g" (proc_stack) : "memory");/*将栈esp替换为我们刚刚填充好的proc_stack，然后通过 jmp intr_exit 使程序流程跳转到中断出口地址 intr_exit，通过那里的一系列 pop 指令和 iretd 指令，将 proc_stack 中的数据载入CPU 的寄存器，从而使程序“假装”退出中断，进入特权级 3 。*/
}/* 激活页表 */
void page_dir_activate(struct task_struct* p_thread) {/********************************************************* 执行此函数时,当前任务可能是线程。* 之所以对线程也要重新安装页表, 原因是上一次被调度的可能是进程,* 否则不恢复页表的话,线程就会使用进程的页表了。********************************************************//* 若为内核线程,需要重新填充页表为0x100000 */uint32_t pagedir_phy_addr = 0x100000;  // 默认为内核的页目录物理地址,也就是内核线程所用的页目录表if (p_thread->pgdir != NULL){ // 判断当前任务是线程还是进程，用户态进程有自己的页目录表//如果是进程，将页表转换成物理地址pagedir_phy_addr = addr_v2p((uint32_t)p_thread->pgdir);}/* 更新页目录寄存器cr3,使新页表生效 */asm volatile ("movl %0, %%cr3" : : "r" (pagedir_phy_addr) : "memory");
}/* 激活线程或进程的页表,更新tss中的esp0为进程的特权级0的栈 */
void process_activate(struct task_struct* p_thread) {ASSERT(p_thread != NULL);/* 激活该进程或线程的页表 */page_dir_activate(p_thread);/* 内核线程特权级本身就是0,处理器进入中断时并不会从tss中获取0特权级栈地址,故不需要更新esp0 */if (p_thread->pgdir) {/* 更新该进程的esp0,用于此进程被中断时保留上下文 */update_tss_esp(p_thread);}
}/* 创建页目录表,将当前页表的表示内核空间的页目录表项pde复制,* 成功则返回页目录的虚拟地址,否则返回-1 */
uint32_t* create_page_dir(void) {/* 用户进程的页表不能让用户直接访问到,所以在内核空间来申请 */uint32_t* page_dir_vaddr = get_kernel_pages(1);if (page_dir_vaddr == NULL) {//判断是线程还是进程console_put_str("create_page_dir: get_kernel_page failed!");return NULL;}/*把用户进程页目录表中的第 768～ 1023 个页目录项用内核页目录表的第 768～ 1023 个页目录项代替，其实就是将内核所在的页目录项复制到进程页目录表中同等位置，这样就能让用户进程的高 1GB 空间指向内核,从而实现用户程序共享内核*//************************** 1  先复制页表  *************************************//* 第一个形参：复制的目标地址为偏移用户进程页目录表基地址 768 个页目录项的地方第二个形参：复制的源地址为内核页目录表中第 768 个页目录项的地址第三个形参：1024/4=256 个页目录项的大小*/memcpy((uint32_t*)((uint32_t)page_dir_vaddr + 0x300*4), (uint32_t*)(0xfffff000+0x300*4), 1024);/************************** 2  更新页目录地址 **********************************/uint32_t new_page_dir_phy_addr = addr_v2p((uint32_t)page_dir_vaddr);//虚拟地址转物理地址/* 页目录地址是存入在页目录的最后一项,更新页目录地址为新页目录的物理地址 */page_dir_vaddr[1023] = new_page_dir_phy_addr | PG_US_U | PG_RW_W | PG_P_1;/*****************************************************************************/return page_dir_vaddr;
}/* 创建用户进程虚拟地址位图 */
//按照用户进程的虚拟内存信息初始化位图结构体 struct virtual addr。
void create_user_vaddr_bitmap(struct task_struct* user_prog) {user_prog->userprog_vaddr.vaddr_start = USER_VADDR_START;uint32_t bitmap_pg_cnt = DIV_ROUND_UP((0xc0000000 - USER_VADDR_START) / PG_SIZE / 8 , PG_SIZE);//除法向上取整，获取位图需要的内存页框数user_prog->userprog_vaddr.vaddr_bitmap.bits = get_kernel_pages(bitmap_pg_cnt);//为位图分配内存user_prog->userprog_vaddr.vaddr_bitmap.btmp_bytes_len = (0xc0000000 - USER_VADDR_START) / PG_SIZE / 8;bitmap_init(&user_prog->userprog_vaddr.vaddr_bitmap);
}/* 创建用户进程 */
void process_execute(void* filename, char* name) { /* pcb内核的数据结构,由内核来维护进程信息,因此要在内核内存池中申请 */struct task_struct* thread = get_kernel_pages(1);init_thread(thread, name, default_prio); //准备线程create_user_vaddr_bitmap(thread);thread_create(thread, start_process, filename);thread->pgdir = create_page_dir();//准备内存空间enum intr_status old_status = intr_disable();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);intr_set_status(old_status);
}

/* 实现任务调度 */
void schedule() {ASSERT(intr_get_status() == INTR_OFF);struct task_struct* cur = running_thread(); if (cur->status == TASK_RUNNING) { // 若此线程只是cpu时间片到了,将其加入到就绪队列尾ASSERT(!elem_find(&thread_ready_list, &cur->general_tag));list_append(&thread_ready_list, &cur->general_tag);cur->ticks = cur->priority;     // 重新将当前线程的ticks再重置为其priority;cur->status = TASK_READY;} else { /* 若此线程需要某事件发生后才能继续上cpu运行,不需要将其加入队列,因为当前线程不在就绪队列中。*/}ASSERT(!list_empty(&thread_ready_list));thread_tag = NULL;	  // thread_tag清空
/* 将thread_ready_list队列中的第一个就绪线程弹出,准备将其调度上cpu. */thread_tag = list_pop(&thread_ready_list);   struct task_struct* next = elem2entry(struct task_struct, general_tag, thread_tag);next->status = TASK_RUNNING;/* 激活任务页表等 */process_activate(next);switch_to(cur, next);
}

int main(void) {put_str("I am kernel\n");init_all();thread_start("k_thread_a", 31, k_thread_a, "argA ");thread_start("k_thread_b", 31, k_thread_b, "argB ");process_execute(u_prog_a, "user_prog_a");process_execute(u_prog_b, "user_prog_b");intr_enable();while(1);return 0;
}/* 在线程中运行的函数 */
void k_thread_a(void* arg) {     char* para = arg;while(1) {console_put_str(" v_a:0x");console_put_int(test_var_a);}
}/* 在线程中运行的函数 */
void k_thread_b(void* arg) {     char* para = arg;while(1) {console_put_str(" v_b:0x");console_put_int(test_var_b);}
}/* 测试用户进程 */
void u_prog_a(void) {while(1) {test_var_a++;}
}/* 测试用户进程 */
void u_prog_b(void) {while(1) {test_var_b++;}
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.rhkb.cn/news/99752.html

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Hive底层数据存储格式

Hive底层数据存储格式

前言 在大数据领域，Hive是一种常用的数据仓库工具，用于管理和处理大规模数据集。Hive底层支持多种数据存储格式，这些格式对于数据存储、查询性能和压缩效率等方面有不同的优缺点。本文将介绍Hive底层的三种主要数据存储格式：文本文件格式、Parquet格式和ORC格式。 一、三…
阅读更多...
jenkins同一jar包部署到多台服务器

jenkins同一jar包部署到多台服务器

文章目录 安装插件配置ssh服务构建完成后执行 没有部署过可以跟这个下面的步骤先部署一遍&#xff0c;我这篇主要讲jenkins同一jar包部署到多台服务器 【Jenkins】部署Springboot项目https://blog.csdn.net/qq_39017153/article/details/131901613 安装插件 Publish Over SSH 这…
阅读更多...
三款远程控制软件对比，5大挑选指标：安全、稳定、易用、兼容、功能

三款远程控制软件对比，5大挑选指标：安全、稳定、易用、兼容、功能

陈老老老板&#x1f934; &#x1f9d9;‍♂️本文专栏&#xff1a;生活&#xff08;主要讲一下自己生活相关的内容&#xff09;生活就像海洋,只有意志坚强的人,才能到达彼岸。 &#x1f9d9;‍♂️本文简述&#xff1a;三款远程控制软件对比&#xff0c;5大挑选指标&#xff1…
阅读更多...
openpnp - 板子上最小物料封装尺寸的选择

openpnp - 板子上最小物料封装尺寸的选择

文章目录 openpnp - 板子上最小物料封装尺寸的选择概述END openpnp - 板子上最小物料封装尺寸的选择 概述 现在设备调试完了, 用散料飞达载入物料试了一下. 0402以上贴的贴别准, 贴片流程也稳, 基本不需要手工干预. 0201可以贴, 但是由于底部相机元件视觉识别成功率不是很高…
阅读更多...
HCIP学习--三层架构

HCIP学习--三层架构

未完成 网关作为了一个广播域的中心出口&#xff1b;生成树的根网桥也是一棵树的中心&#xff0c;也是流量的集合点&#xff1b; 若将两者分配不同的设备将导致网络通讯资源浪费&#xff0c;故强烈建议两者在同一台汇聚层设备上 举个例子 看下图若VLAN2要去找VLAN3设备需要…
阅读更多...
保险龙头科技进化论：太保的六年

保险龙头科技进化论：太保的六年

如果从2013年中国首家互联网保险公司——众安在线的成立算起&#xff0c;保险科技在我国的发展已走进第十个年头。十年以来&#xff0c;在政策指引、技术发展和金融机构数字化转型的大背景下&#xff0c;科技赋能保险业高质量发展转型已成为行业共识。 大数据、云计算、人工智…
阅读更多...
spring如何进行依赖注入，通过set方法把Dao注入到serves

spring如何进行依赖注入，通过set方法把Dao注入到serves

1、选择Generate右键鼠标 你在service层后面方法的这些: 2、UserService配置文件的写法是怎样的&#xff1a; 3、我们在UserController中执行一下具体写法&#xff1a; 最后我们执行一下 &#xff1a; 4、这里可能出现空指针&#xff0c;因为你当前web层,因为你new这个对象根…
阅读更多...
YOLO目标检测算法训练过程学习记录

YOLO目标检测算法训练过程学习记录

先前已经完成过YOLO系列目标检测算法的调试过程&#xff0c;今天主要是将所有的调试加以总结 这里的conda环境就不再赘述了&#xff0c;直接使用requirement.txt文件的即可&#xff0c;也可以参考YOLOX的配置过程5 数据集处理 YOLOv5有自己的数据集格式&#xff0c;博主的数据…
阅读更多...
HarmonyOS/OpenHarmony应用开发-ArkTS语言渲染控制ForEach循环渲染

HarmonyOS/OpenHarmony应用开发-ArkTS语言渲染控制ForEach循环渲染

ForEach基于数组类型数据执行循环渲染。说明&#xff0c;从API version 9开始&#xff0c;该接口支持在ArkTS卡片中使用。 一、接口描述 ForEach(arr: any[], itemGenerator: (item: any, index?: number) > void,keyGenerator?: (item: any, index?: number) > stri…
阅读更多...
Java云原生框架Quarkus初探

Java云原生框架Quarkus初探

Java云原生框架Quarkus初探 Quarkus 介绍 Quarkus 是一个云原生&#xff0c;容器优先的Java应用框架&#xff0c;它号称是超音速和亚原子的框架&#xff0c;主要特点是构建速度、启动速度快和占用资源少等特点。它为OpenJDK HotSpot和GraalVM量身定制&#xff0c; 根据Java库和…
阅读更多...
postgresql中基础sql查询

postgresql中基础sql查询

postgresql中基础sql查询 创建表插入数据创建索引删除表postgresql命令速查简单查询计算查询结果 利用查询条件过滤数据模糊查询 创建表 -- 部门信息表 CREATE TABLE departments( department_id INTEGER NOT NULL -- 部门编号&#xff0c;主键, department_name CHARACTE…
阅读更多...
LLM提示词工程和提示词工程师Prompting and prompt engineering

LLM提示词工程和提示词工程师Prompting and prompt engineering

你输入模型的文本被称为提示&#xff0c;生成文本的行为被称为推断&#xff0c;输出文本被称为完成。用于提示的文本或可用的内存的全部量被称为上下文窗口。尽管这里的示例显示模型表现良好&#xff0c;但你经常会遇到模型在第一次尝试时无法产生你想要的结果的情况。你可能需…
阅读更多...
vue开发环境搭建（WebStorm）

vue开发环境搭建（WebStorm）

一、安装Node.js&#xff0c;搭建Vue环境 1、访问Node.js官网&#xff08;https://nodejs.org/en/download/&#xff09;进行安装包下载。 2、下载成功之后运行安装程序&#xff0c;进行安装。 如果是用安装程序进行安装&#xff0c;在安装过程中会自动进行Nodejs环境变量的配置…
阅读更多...
css 实现svg动态图标效果

css 实现svg动态图标效果

效果演示&#xff1a; 实现思路&#xff1a;主要是通过css的stroke相关属性来设置实现的。 html代码: <svgt"1692441666814"class"icon"viewBox"0 0 1024 1024"version"1.1"xmlns"http://www.w3.org/2000/svg"p-id"…
阅读更多...
数据结构：栈和队列

数据结构：栈和队列

文章目录 一、栈1.栈的概念及结构1.栈的概念及结构2.栈的实现 2.栈的顺序表实现1.栈的结构体和实现的功能函数2.栈的初始化&#xff0c;入栈和出栈操作3.栈的其他操作 3.栈的链表实现1.栈的结构体和实现的功能函数2.栈功能函数的实现 二、队列1.队列的概念及结构1.队列的概念及…
阅读更多...
java面向对象——继承以及super关键字

java面向对象——继承以及super关键字

继承的概念 1. 被继承的类称为父类&#xff08;超类&#xff09;&#xff0c;继承父类的类都称为子类&#xff08;派生类&#xff09; 2. 继承是指一个对象直接使用另一个对象的属性和方法&#xff0c;但是能继承非私有的属性和方法&#xff1b;(1) 构造方法不能被继承。(2) 但…
阅读更多...
商城-学习整理-高级-商城业务-异步线程池（十三）

商城-学习整理-高级-商城业务-异步线程池（十三）

目录 一、线程1、初始化线程的 4 种方式2、线程池的七大参数3、线程池的运行流程&#xff1a;4、例子5、常见的 4 种线程池6、开发中为什么使用线程池 二、CompletableFuture 异步编排0、业务场景&#xff1a;1、创建异步对象2、计算完成时回调方法3、handle 方法4、线程串行化…
阅读更多...
【无监督】6、SimSiam | 基于孪生网络的对比学习的成功源于梯度截断！

【无监督】6、SimSiam | 基于孪生网络的对比学习的成功源于梯度截断！

文章目录 一、背景二、方法三、效果 论文&#xff1a;Exploring Simple Siamese Representation Learning 出处&#xff1a;FAIR | 何恺明大佬 本文作者抛出了两个爆炸&#x1f4a5;性结论&#xff1a; 结论一&#xff1a;基于孪生网络的对比的学习的成功&#xff0c;不源于 …
阅读更多...
亚马逊云科技 云技能孵化营——机器学习心得

亚马逊云科技 云技能孵化营——机器学习心得

亚马逊云科技 云技能孵化营机器学习心得 前言什么是机器学习&#xff1f;机器学习如何解决业务问题&#xff1f;什么时候适合使用机器学习模型&#xff1f;总结 前言 很荣幸参加了本次亚马逊云科技云技能孵化营&#xff0c;再本期的《亚马逊云科技云技能孵化营》中&#xff0c…
阅读更多...
Leetcode-每日一题【剑指 Offer 33. 二叉搜索树的后序遍历序列】

Leetcode-每日一题【剑指 Offer 33. 二叉搜索树的后序遍历序列】

题目 输入一个整数数组&#xff0c;判断该数组是不是某二叉搜索树的后序遍历结果。如果是则返回 true&#xff0c;否则返回 false。假设输入的数组的任意两个数字都互不相同。 参考以下这颗二叉搜索树&#xff1a; 5 / \ 2 6 / \ 1 3 示例 1&#xff1a; 输入: […
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023