[自制作業系統] 第19回 實現使用者程序(下)
2022-09-04 15:02:15
目錄
一、前景回顧
二、程序的建立與初始化
三、如何進行程序的切換
四、執行測試
五、原書勘誤
在上一回我們大概講述了工作切換的發展，並且知道Linux採用的是一個CPU使用一個TSS的方式，在最後我們成功實現了tss。現在萬事俱備，我們正式來實現使用者程序。
程序的建立與執行緒的建立很相似，這裡直接上圖來對比分析：
我們使用process_execute函數來建立初始化程序。
1 /*建立使用者程序*/ 2 void process_execute(void *filename, char *name) 3 { 4 /*pcb核心的資料結構，由核心來維護程序資訊，因此要在核心記憶體池中申請*/ 5 struct task_struct *thread = get_kernel_pages(1); 6 init_thread(thread, name, 31); 7 thread_create(thread, start_process, filename); 8 create_user_vaddr_bitmap(thread); //建立虛擬地址的點陣圖 9 thread->pgdir = create_page_dir(); //使用者程序的頁目錄表的實體地址，這裡傳進來的是頁目錄表實體地址所對應的虛擬地址 10 11 enum intr_status old_status = intr_disable(); 12 ASSERT(!elem_find(&thread_ready_list, &thread->general_tag)); 13 list_append(&thread_ready_list, &thread->general_tag); 14 15 ASSERT(!elem_find(&thread_all_list, &thread->all_list_tag)); 16 list_append(&thread_all_list, &thread->all_list_tag); 17 intr_set_status(old_status); 18 }
在該函數中首先使用get_kernel_pages函數在核心物理空間中申請一頁實體記憶體來作為程序的PCB，因為最終排程是由核心來操控的，所以PCB統一都在核心物理空間中申請。隨後依舊呼叫init_thread()和thread_create()函數來初始化程序的PCB。
下面開始不一樣了，create_user_vaddr_bitmap()函數的作用是給程序建立初始化點陣圖。這裡科普一下：我們都知道程序有4GB的虛擬空間，其中第1~3GB是分配給使用者空間，第4GB是分配給核心空間，這是Linux下的分配習慣，我們照搬。而使用者空間實際上只用上了0x08048000到0xc0000000這一部分。所以create_user_vaddr_bitmap()函數也就是將這一部分空間劃分到使用者的虛擬地址記憶體池中。
再來看create_page_dir()函數，我們知道作業系統被所有使用者程序所共用，所以我們將使用者程序頁目錄表中的第768~1023個頁目錄項用核心頁目錄表的第768~1023個頁目錄項代替，其實就是將核心所在的頁目錄項複製到程序頁目錄表中同等位置，這樣就能讓使用者程序的高1GB空間指向核心。最後再將程序新增到全部佇列和就緒佇列中供排程。至此，使用者程序就算建立初始化完畢了。
我們現在來看看程序的PCB的內容：
因為我們之前一直都是處於核心態下，也就是0特權級下。現在要切換到使用者程序也就是使用者態，3特權級下執行，和之前的切換不太一樣。還是舉例來說明吧。
假設當前核心執行緒A時間片用光了，在排程函數schedule()中會從就緒佇列中彈出下一個程序B的PCB，根據PCB我們就知道了程序B的所有資訊。不過接下來和之前執行緒的切換不一樣了，首先呼叫process_activate()函數啟用下一個核心執行緒或者程序的頁表。對於核心執行緒來說，核心執行緒的頁目錄表在之前啟用分頁機制的時候就已經設定好了，被存放在0x10000地址處。如果不是核心執行緒，那麼就需要將程序B的頁目錄表地址賦給CR3暫存器，因為CPU定址是基於CR3暫存器中儲存的頁目錄表的地址來定址的。切換到程序B後，需要將程序B的頁目錄表地址賦給了CR3暫存器。
1 /*啟用執行緒或程序的頁表，更新tss中的esp0為程序的特權級0的棧*/
2 void process_activate(struct task_struct *p_thread)
3 {
4 ASSERT(p_thread != NULL);
5 //啟用該執行緒或者程序的頁表
6 page_dir_activate(p_thread);
7
8 if (p_thread->pgdir) { //如果是程序那麼需要在tss中填入0級特權棧的esp0
9 update_tss_esp(p_thread);
10 }
11 }
除此之外，還要將tss中的esp0欄位更新為程序B的0級棧。前面已經說過，程序在由例如中斷等操作從3特權級進入0特權級後，也就是進入核心態，使用的會是0特權級下的棧，不再是3特權級的棧。因此在這個地方我們需要給程序B更新0特權級棧。方便以後程序B進入核心態。這裡我們可以看到，程序B的0特權級的棧頂指標指向程序B的PCB最高處。
1 /*更新tss中的esp0欄位的值為pthread的0級棧*/
2 void update_tss_esp(struct task_struct *pthread)
3 {
4 tss.esp0 = (uint32_t *)((uint32_t)pthread + PG_SIZE);
5 }
這一系列操作完成後，我們又回到switch_to函數，和前面講執行緒切換也是一樣，首先通過一系列的push操作，將當前核心執行緒A的暫存器資訊壓入棧中以便下次又被排程上CPU後可以恢復環境。隨後從程序B的PCB中得到新的棧。此時程序B的棧的情況如下：
1 switch_to: 2 push esi ;這裡是根據ABI原則保護四個暫存器 放到棧裡面 3 push edi 4 push ebx 5 push ebp 6 7 mov eax, [esp+20] ;esp+20的位置是cur cur的pcb賦值給eax 8 mov [eax], esp ;[eax]為pcb的核心棧指標變數 把當前環境的esp值記錄下來 9 10 mov eax, [esp+24] 11 mov esp, [eax] 12 13 pop ebp 14 pop ebx 15 pop edi 16 pop esi 17 ret
程序B的還是通過一系列POP操作，最終呼叫*eip所指向的函數kernel_thread，在該函數中又呼叫*function所指向的函數start_process()，該函數程式碼如下：
1 void start_process(void *filename) 2 { 3 void *function = filename; 4 struct task_struct *cur = running_thread(); 5 cur->self_kstack += sizeof(struct thread_stack); 6 struct intr_stack *proc_stack = (struct intr_stack *)cur->self_kstack; 7 proc_stack->edi = proc_stack->esi = proc_stack->ebp = proc_stack->esp_dummy = 0; 8 proc_stack->ebx = proc_stack->edx = proc_stack->ecx = proc_stack->eax = 0; 9 proc_stack->gs = 0; 10 proc_stack->ds = proc_stack->es = proc_stack->fs = SELECTOR_U_DATA; //資料段選擇子 11 proc_stack->eip = function; //函數地址 ip 12 proc_stack->cs = SELECTOR_U_CODE; //cs ip cs選擇子 13 proc_stack->eflags = (EFLAGS_IOPL_0 | EFLAGS_MBS | EFLAGS_IF_1); //不能夠關閉中斷 ELFAG_IF_1 不然會導致無法排程 14 proc_stack->esp = (void *)((uint32_t)get_a_page(PF_USER, USER_STACK3_VADDR) + PG_SIZE); //棧空間在0xc0000000以下一頁的地方 當然實體記憶體是作業系統來分配 15 proc_stack->ss = SELECTOR_U_DATA; //資料段選擇子 16 asm volatile ("movl %0, %%esp; jmp intr_exit" : : "g" (proc_stack) : "memory"); 17 }
來細品一下這個函數的內容。還記得前面的那個程序的PCB圖嗎？
首先通過running_thread函數獲取到當前程序的PCB的地址。根據圖中我們可以知道self_kstack一開始是被賦值指向棧頂，也就是執行緒棧的開始位置。經過cur->self_kstack += sizeof(struct thread_stack)後，現在self_kstack指向中斷棧處了，如圖所示。然後定義一個pro_stack指標指向self_kstack。這個先記住，待會兒會用上。
隨後便是對一系列暫存器的初始化，重點關注ds、es、fs、cs、ss和gs這幾個段暫存器的初始化，我們將它們初始化為使用者程序下的3特權級的段選擇子。因為在使用者態下，我們是不能存取0特權級下的程式碼段和資料段的。對於gs暫存器，這裡其實不管是否設定為0都無所謂，因為使用者態下的程式是不能直接存取視訊記憶體的，程序在從核心態進入使用者態時會進行特權檢查，如果gs段暫存器中的段選擇子的特權等級高於程序返回後的特權等級，CPU就會自動將段暫存器gs給置0，如果使用者程序一旦存取視訊記憶體，就會報錯。
再往下就給esp賦值，這個地方是為了當回到使用者態空間後，給使用者程式指定一個棧頂指標。這裡我們將使用者態的棧頂指標設定為使用者態空間下的0xc0000000處。
最後通過內聯組合：
asm volatile ("movl %0, %%esp; jmp intr_exit" : : "g" (proc_stack) : "memory");
將proc_stack所指向的值賦給當前程序的esp，也就是棧頂指標，前面我們知道proc_stack已經被賦好了值，為self_kstack。最後便是跳轉到intr_exit處執行程式碼。
此時棧的情況如下：
然後intr_exit的程式碼如下所示：
1 intr_exit: 2 add esp, 4 3 popad 4 pop gs 5 pop fs 6 pop es 7 pop ds 8 add esp, 4 9 iretd
看著程式碼就很好理解了，首先add esp, 4跳過棧中的vec_no，隨後popad和pop操作彈出8個32位元的通用暫存器和4個段暫存器。又是通過add esp, 4跳過棧中的err_code，最後執行iretd指令，將(*eip)、cs、eflags彈出，而我們事先已經將使用者程序要執行的函數地址存放在eip中。最後，由於我們跳轉後的使用者態，它的特權級不同於當前核心態的特權級，所以需要恢復舊棧，CPU自動將棧中的esp和ss彈出。這些值在我們前面的start_process()函數中已經初始化完畢。至此我們就已經完成了核心態到使用者態的轉換。
這裡我貼上本章所有相關程式碼：
1 #include "process.h"
2 #include "thread.h"
3 #include "global.h"
4 #include "memory.h"
5 #include "debug.h"
6 #include "console.h"
7 #include "interrupt.h"
8 #include "tss.h"
9
10 extern void intr_exit(void);
11 extern struct list thread_ready_list; //就緒佇列
12 extern struct list thread_all_list;
13
14 void start_process(void *filename)
15 {
16 void *function = filename;
17 struct task_struct *cur = running_thread();
18 cur->self_kstack += sizeof(struct thread_stack);
19 struct intr_stack *proc_stack = (struct intr_stack *)cur->self_kstack;
20 proc_stack->edi = proc_stack->esi = proc_stack->ebp = proc_stack->esp_dummy = 0;
21 proc_stack->ebx = proc_stack->edx = proc_stack->ecx = proc_stack->eax = 0;
22 proc_stack->gs = 0;
23 proc_stack->ds = proc_stack->es = proc_stack->fs = SELECTOR_U_DATA; //資料段選擇子
24 proc_stack->eip = function; //函數地址 ip
25 proc_stack->cs = SELECTOR_U_CODE; //cs ip cs選擇子
26 proc_stack->eflags = (EFLAGS_IOPL_0 | EFLAGS_MBS | EFLAGS_IF_1); //不能夠關閉中斷 ELFAG_IF_1 不然會導致無法排程
27 proc_stack->esp = (void *)((uint32_t)get_a_page(PF_USER, USER_STACK3_VADDR) + PG_SIZE); //棧空間在0xc0000000以下一頁的地方 當然實體記憶體是作業系統來分配
28 proc_stack->ss = SELECTOR_U_DATA; //資料段選擇子
29 asm volatile ("movl %0, %%esp; jmp intr_exit" : : "g" (proc_stack) : "memory");
30 }
31
32
33 /*啟用頁表*/
34 void page_dir_activate(struct task_struct *p_thread)
35 {
36 //核心執行緒的頁目錄表的實體地址為0x100000
37 uint32_t pagedir_phy_addr = 0x100000;
38 if (p_thread->pgdir != NULL) { //說明下一個呼叫的是程序，否則是核心執行緒
39 pagedir_phy_addr = addr_v2p((uint32_t)p_thread->pgdir);
40 }
41
42 /*更新頁目錄暫存器CR3，使新頁表生效*/
43 asm volatile("movl %0, %%cr3" : : "r" (pagedir_phy_addr) : "memory");
44 }
45
46 /*啟用執行緒或程序的頁表，更新tss中的esp0為程序的特權級0的棧*/
47 void process_activate(struct task_struct *p_thread)
48 {
49 ASSERT(p_thread != NULL);
50 //啟用該執行緒或者程序的頁表
51 page_dir_activate(p_thread);
52
53 if (p_thread->pgdir) { //如果是程序那麼需要在tss中填入0級特權棧的esp0
54 update_tss_esp(p_thread);
55 }
56 }
57
58 uint32_t *create_page_dir(void)
59 {
60 //使用者程序的頁表不能讓使用者直接存取到，所以在核心空間申請
61 uint32_t *page_dir_vaddr = get_kernel_pages(1); //得到記憶體
62 if (page_dir_vaddr == NULL) {
63 console_put_str("create_page_dir: get_kernel_page failed!\n");
64 return NULL;
65 }
66
67 memcpy((uint32_t*)((uint32_t)page_dir_vaddr + 0x300 * 4), (uint32_t*)(0xfffff000 + 0x300 * 4), 1024); // 256項
68 uint32_t new_page_dir_phy_addr = addr_v2p((uint32_t)page_dir_vaddr);
69 page_dir_vaddr[1023] = new_page_dir_phy_addr | PG_US_U | PG_RW_W | PG_P_1; //最後一項是頁目錄項自己的地址
70
71 return page_dir_vaddr;
72 }
73
74
75 /*建立使用者程序虛擬地址點陣圖*/
76 void create_user_vaddr_bitmap(struct task_struct *user_prog)
77 {
78 user_prog->userprog_vaddr.vaddr_start = USER_VADDR_START;
79
80 //計算需要多少實體記憶體頁來記錄點陣圖 USER_VADDR_START為0x08048000
81 uint32_t bitmap_pg_cnt = DIV_ROUND_UP((0xc0000000 - USER_VADDR_START) / PG_SIZE / 8, PG_SIZE);
82 user_prog->userprog_vaddr.vaddr_bitmap.bits = get_kernel_pages(bitmap_pg_cnt);
83
84 user_prog->userprog_vaddr.vaddr_bitmap.btmp_bytes_len = (0xc0000000 - USER_VADDR_START) / PG_SIZE / 8;
85 bitmap_init(&user_prog->userprog_vaddr.vaddr_bitmap);
86 }
87
88 /*建立使用者程序*/
89 void process_execute(void *filename, char *name)
90 {
91 /*pcb核心的資料結構，由核心來維護程序資訊，因此要在核心記憶體池中申請*/
92 struct task_struct *thread = get_kernel_pages(1);
93 init_thread(thread, name, 31);
94 thread_create(thread, start_process, filename);
95 create_user_vaddr_bitmap(thread); //建立虛擬地址的點陣圖
96 thread->pgdir = create_page_dir(); //使用者程序的頁目錄表的實體地址，這裡傳進來的是頁目錄表實體地址所對應的虛擬地址
97
98 enum intr_status old_status = intr_disable();
99 ASSERT(!elem_find(&thread_ready_list, &thread->general_tag));
100 list_append(&thread_ready_list, &thread->general_tag);
101
102 ASSERT(!elem_find(&thread_all_list, &thread->all_list_tag));
103 list_append(&thread_all_list, &thread->all_list_tag);
104 intr_set_status(old_status);
105 }
1 #ifndef __USERPROG_PROCESS_H
2 #define __USERPROG_PROCESS_H
3 #include "stdint.h"
4 #include "thread.h"
5
6 #define USER_STACK3_VADDR (0xc0000000 - 0x1000)
7 #define USER_VADDR_START 0x08048000
8
9
10 void process_execute(void *filename, char *name);
11 void create_user_vaddr_bitmap(struct task_struct *user_prog);
12 uint32_t *create_page_dir(void);
13 void process_activate(struct task_struct *p_thread);
14 void page_dir_activate(struct task_struct *p_thread);
15 void start_process(void *filename);
16
17 #endif
1 #include "memory.h"
2 #include "print.h"
3 #include "stdio.h"
4 #include "debug.h"
5 #include "string.h"
6 #include "thread.h"
7 #include "sync.h"
8
9 #define PG_SIZE 4096 //頁大小
10
11 /*0xc0000000是核心從虛擬地址3G起，
12 * 0x100000意指低端記憶體1MB，為了使虛擬地址在邏輯上連續
13 * 後面申請的虛擬地址都從0xc0100000開始
14 */
15 #define K_HEAP_START 0xc0100000
16
17 #define PDE_IDX(addr) ((addr & 0xffc00000) >> 22)
18 #define PTE_IDX(addr) ((addr & 0x003ff000) >> 12)
19
20 struct pool {
21 struct bitmap pool_bitmap; //本記憶體池用到的點陣圖結構
22 uint32_t phy_addr_start; //本記憶體池管理的實體記憶體的起始地址
23 uint32_t pool_size; //記憶體池的容量
24 struct lock lock;
25 };
26
27 struct pool kernel_pool, user_pool; //生成核心記憶體池和使用者記憶體池
28 struct virtual_addr kernel_vaddr; //此結構用來給核心分配虛擬地址
29
30
31 /*初始化記憶體池*/
32 static void mem_pool_init(uint32_t all_mem)
33 {
34 put_str("mem_pool_init start\n");
35 /*目前頁表和頁目錄表的佔用記憶體
36 * 1頁頁目錄表 + 第0和第768個頁目錄項指向同一個頁表 + 第769～1022個頁目錄項共指向254個頁表 = 256個頁表
37 */
38 lock_init(&kernel_pool.lock);
39 lock_init(&user_pool.lock);
40
41 uint32_t page_table_size = PG_SIZE * 256;
42 uint32_t used_mem = page_table_size + 0x100000; //目前總共用掉的記憶體空間
43 uint32_t free_mem = all_mem - used_mem; //剩餘記憶體為32MB-used_mem
44 uint16_t all_free_pages = free_mem / PG_SIZE; //將剩餘記憶體劃分為頁，餘數捨去，方便計算
45
46 /*核心空間和使用者空間各自分配一半的記憶體頁*/
47 uint16_t kernel_free_pages = all_free_pages / 2;
48 uint16_t user_free_pages = all_free_pages - kernel_free_pages;
49
50 /*為簡化點陣圖操作，餘數不用做處理，壞處是這樣會丟記憶體，不過只要記憶體沒用到極限就不會出現問題*/
51 uint32_t kbm_length = kernel_free_pages / 8; //點陣圖的長度單位是位元組
52 uint32_t ubm_length = user_free_pages / 8;
53
54 uint32_t kp_start = used_mem; //核心記憶體池的起始實體地址
55 uint32_t up_start = kp_start + kernel_free_pages * PG_SIZE; //使用者記憶體池的起始實體地址
56
57 /*初始化核心使用者池和使用者記憶體池*/
58 kernel_pool.phy_addr_start = kp_start;
59 user_pool.phy_addr_start = up_start;
60
61 kernel_pool.pool_size = kernel_free_pages * PG_SIZE;
62 user_pool.pool_size = user_free_pages * PG_SIZE;
63
64 kernel_pool.pool_bitmap.btmp_bytes_len = kbm_length;
65 user_pool.pool_bitmap.btmp_bytes_len = ubm_length;
66
67 /***********核心記憶體池和使用者記憶體池點陣圖************
68 *核心的棧底是0xc009f00，減去4KB的PCB大小，便是0xc009e00
69 *這裡再分配4KB的空間用來儲存點陣圖，那麼點陣圖的起始地址便是
70 *0xc009a00,4KB的空間可以管理4*1024*8*4KB=512MB的實體記憶體
71 *這對於我們的系統來說已經綽綽有餘了。
72 */
73 /*核心記憶體池點陣圖地址*/
74 kernel_pool.pool_bitmap.bits = (void *)MEM_BIT_BASE; //MEM_BIT_BASE(0xc009a00)
75 /*使用者記憶體池點陣圖地址緊跟其後*/
76 user_pool.pool_bitmap.bits = (void *)(MEM_BIT_BASE + kbm_length);
77
78 /*輸出記憶體池資訊*/
79 put_str("kernel_pool_bitmap_start:");
80 put_int((int)kernel_pool.pool_bitmap.bits);
81 put_str("\n");
82 put_str("kernel_pool.phy_addr_start:");
83 put_int(kernel_pool.phy_addr_start);
84 put_str("\n");
85
86 put_str("user_pool_bitmap_start:");
87 put_int((int)user_pool.pool_bitmap.bits);
88 put_str("\n");
89 put_str("user_pool.phy_addr_start:");
90 put_int(user_pool.phy_addr_start);
91 put_str("\n");
92
93 /*將點陣圖置0*/
94 bitmap_init(&kernel_pool.pool_bitmap);
95 bitmap_init(&user_pool.pool_bitmap);
96
97 /*初始化核心虛擬地址的點陣圖，按照實際實體記憶體大小生成陣列*/
98 kernel_vaddr.vaddr_bitmap.btmp_bytes_len = kbm_length;
99 /*核心虛擬地址記憶體池點陣圖地址在使用者記憶體池點陣圖地址其後*/
100 kernel_vaddr.vaddr_bitmap.bits = (void *)(MEM_BIT_BASE + kbm_length + ubm_length);
101 /*核心虛擬地址記憶體池的地址以K_HEAP_START為起始地址*/
102 kernel_vaddr.vaddr_start = K_HEAP_START;
103 bitmap_init(&kernel_vaddr.vaddr_bitmap);
104
105 put_str("mem_pool_init done\n");
106 }
107
108 /*記憶體管理部分初始化入口*/
109 void mem_init(void)
110 {
111 put_str("mem_init start\n");
112 uint32_t mem_bytes_total = 33554432; //32MB記憶體 32*1024*1024=33554432
113 mem_pool_init(mem_bytes_total);
114 put_str("mem_init done\n");
115 }
116
117
118 /*在pf表示的虛擬記憶體池中申請pg_cnt個虛擬頁
119 * 成功則返回虛擬地址的起始地址，失敗返回NULL
120 */
121 static void *vaddr_get(enum pool_flags pf, uint32_t pg_cnt)
122 {
123 int vaddr_start = 0;
124 int bit_idx_start = -1;
125 uint32_t cnt = 0;
126 if (pf == PF_KERNEL) {
127 bit_idx_start = bitmap_scan(&kernel_vaddr.vaddr_bitmap, pg_cnt);
128 if (bit_idx_start == -1) {
129 return NULL;
130 }
131 /*在點陣圖中將申請到的虛擬記憶體頁所對應的位給置1*/
132 while (cnt < pg_cnt) {
133 bitmap_set(&kernel_vaddr.vaddr_bitmap, bit_idx_start + cnt++, 1);
134 }
135 vaddr_start = kernel_vaddr.vaddr_start + bit_idx_start * PG_SIZE;
136
137 } else { //使用者記憶體池
138 struct task_struct *cur = running_thread();
139 bit_idx_start = bitmap_scan(&cur->userprog_vaddr.vaddr_bitmap, pg_cnt);
140 if (bit_idx_start == -1) {
141 return NULL;
142 }
143 while (cnt < pg_cnt) {
144 bitmap_set(&cur->userprog_vaddr.vaddr_bitmap, bit_idx_start + cnt++, 1);
145 }
146 vaddr_start = cur->userprog_vaddr.vaddr_start + bit_idx_start * PG_SIZE;
147 /*0xc00000000 - PG_SIZE作為使用者3級棧已經在start_process被分配*/
148 ASSERT((uint32_t)vaddr_start < (0xc0000000 - PG_SIZE));
149 }
150 return (void *)vaddr_start;
151 }
152
153 /*得到虛擬地址vaddr所對應的pte指標
154 * 這個指標也是一個虛擬地址，CPU通過這個虛擬地址去定址會得到一個真實的實體地址
155 * 這個實體地址便是存放虛擬地址vaddr對應的普通物理頁的地址
156 * 假設我們已經知道虛擬地址vaddr對應的普通物理頁地址為0xa
157 * 那麼便可以通過如下操作完成虛擬地址和普通物理頁地址的對映
158 * *pte = 0xa
159 */
160 uint32_t *pte_ptr(uint32_t vaddr)
161 {
162 uint32_t *pte = (uint32_t *)(0xffc00000 + \
163 ((vaddr & 0xffc00000) >> 10) + \
164 PTE_IDX(vaddr) * 4);
165 return pte;
166 }
167
168 /*得到虛擬地址vaddr所對應的pde指標
169 * 這個指標也是一個虛擬地址，CPU通過這個虛擬地址去定址會得到一個真實的實體地址
170 * 這個實體地址便是存放虛擬地址vaddr對應的頁表的地址，使用方法同pte_ptr()一樣
171 */
172 uint32_t *pde_ptr(uint32_t vaddr)
173 {
174 uint32_t *pde = (uint32_t *)(0xfffff000 + PDE_IDX(vaddr) * 4);
175 return pde;
176 }
177
178 /*在m_pool指向的實體記憶體地址中分配一個物理頁
179 * 成功則返回頁框的實體地址，失敗返回NULL
180 */
181 static void *palloc(struct pool *m_pool)
182 {
183 int bit_idx = bitmap_scan(&m_pool->pool_bitmap, 1);
184 if (bit_idx == -1) {
185 return NULL;
186 }
187 /*在點陣圖中將申請到的實體記憶體頁所對應的位給置1*/
188 bitmap_set(&m_pool->pool_bitmap, bit_idx, 1);
189 /*得到申請的物理頁所在地址*/
190 uint32_t page_phyaddr = (m_pool->phy_addr_start + bit_idx * PG_SIZE);
191
192 return (void *)page_phyaddr;
193 }
194
195 /*在頁表中新增虛擬地址_vaddr與實體地址_page_phyaddr的對映*/
196 static void page_table_add(void *_vaddr, void *_page_phyaddr)
197 {
198 uint32_t vaddr = (uint32_t)_vaddr;
199 uint32_t page_phyaddr = (uint32_t)_page_phyaddr;
200 uint32_t *pde = pde_ptr(vaddr);
201 uint32_t *pte = pte_ptr(vaddr);
202
203 //先判斷虛擬地址對應的pde是否存在
204 if (*pde & 0x00000001) {
205 ASSERT(!(*pte & 0x00000001));
206 *pte = (page_phyaddr | PG_US_U | PG_RW_W | PG_P_1);
207 } else { //頁目錄項不存在，需要先建立頁目錄再建立頁表項
208 uint32_t pde_phyaddr = (uint32_t)palloc(&kernel_pool);
209 *pde = (pde_phyaddr | PG_US_U | PG_RW_W | PG_P_1);
210 /* 將分配到的物理頁地址pde_phyaddr對應的實體記憶體清0
211 * 避免裡面的陳舊資料變成頁表項
212 */
213 /* 這個地方不能這樣memset((void *)pde_phyaddr, 0, PG_SIZE);
214 * 因為現在我們所使用的所有地址都是虛擬地址，雖然我們知道pde_phyaddr是真實的實體地址
215 * 可是CPU是不知道的，CPU會把pde_phyaddr當作虛擬地址來使用，這樣就肯定無法清0了
216 * 所以解決問題的思路就是：如何得到pde_phyaddr所對應的虛擬地址。
217 */
218 //為什麼不是memset((void *)((int)pde & 0xffc00000), 0, PG_SIZE);
219 //建議好好看看pde_ptr()和pte_ptr()函數的實現
220 memset((void *)((int)pte & 0xfffff000), 0, PG_SIZE);
221 ASSERT(!(*pte & 0x00000001));
222 *pte = (page_phyaddr | PG_US_U | PG_RW_W | PG_P_1);
223 }
224 }
225
226 /*分配pg_cnt個頁空間，成功則返回起始虛擬地址，失敗返回NULL*/
227 void *malloc_page(enum pool_flags pf, uint32_t pg_cnt)
228 {
229 ASSERT((pg_cnt > 0) && (pg_cnt < 3840));
230 void *vaddr_start = vaddr_get(pf, pg_cnt);
231 if (vaddr_start == NULL) {
232 return NULL;
233 }
234
235 uint32_t vaddr = (uint32_t)vaddr_start;
236 uint32_t cnt = pg_cnt;
237
238 struct pool *mem_pool = pf & PF_KERNEL ? &kernel_pool : &user_pool;
239
240 /*因為虛擬地址連續，而實體地址不一定連續，所以逐個做對映*/
241 while (cnt-- > 0) {
242 void *page_phyaddr = palloc(mem_pool);
243 if (page_phyaddr == NULL) {
244 return NULL;
245 }
246 page_table_add((void *)vaddr, page_phyaddr);
247 vaddr += PG_SIZE;
248 }
249 return vaddr_start;
250 }
251
252 /*從核心實體記憶體池中申請pg_cnt頁記憶體，成功返回其虛擬地址，失敗返回NULL*/
253 void *get_kernel_pages(uint32_t pg_cnt)
254 {
255 void *vaddr = malloc_page(PF_KERNEL, pg_cnt);
256 if (vaddr != NULL) {
257 memset(vaddr, 0, pg_cnt * PG_SIZE);
258 }
259 return vaddr;
260 }
261
262
263 /*在使用者空間中申請4K記憶體，並返回其虛擬地址*/
264 void *get_user_pages(uint32_t pg_cnt)
265 {
266 lock_acquire(&user_pool.lock);
267 void *vaddr = malloc_page(PF_USER, pg_cnt);
268 memset(vaddr, 0, pg_cnt * PG_SIZE);
269 lock_release(&user_pool.lock);
270 return vaddr;
271 }
272
273 /*將地址vaddr與pf池中的實體地址關聯起來，僅支援一頁記憶體空間分配*/
274 void *get_a_page(enum pool_flags pf, uint32_t vaddr)
275 {
276 struct pool *mem_pool = pf & PF_KERNEL ? &kernel_pool : &user_pool;
277 lock_acquire(&mem_pool->lock);
278
279 struct task_struct* cur = running_thread();
280 int32_t bit_idx = -1;
281
282 //虛擬地址點陣圖置1
283 if (cur->pgdir != NULL && pf == PF_USER) {
284 bit_idx = (vaddr - cur->userprog_vaddr.vaddr_start) / PG_SIZE;
285 ASSERT(bit_idx > 0);
286 bitmap_set(&cur->userprog_vaddr.vaddr_bitmap, bit_idx, 1);
287 } else if(cur->pgdir == NULL && pf == PF_KERNEL) {
288 bit_idx = (vaddr - kernel_vaddr.vaddr_start) / PG_SIZE;
289 ASSERT(bit_idx > 0);
290 bitmap_set(&kernel_vaddr.vaddr_bitmap, bit_idx, 1);
291 } else {
292 PANIC("get_a_page:not allow kernel alloc userspace or user alloc kernelspace by get_a_page");
293 }
294
295 void* page_phyaddr = palloc(mem_pool);
296 if (page_phyaddr == NULL)
297 return NULL;
298 page_table_add((void *)vaddr, page_phyaddr);
299 lock_release(&mem_pool->lock);
300 return (void *)vaddr;
301 }
302
303 /*得到虛擬地址對映的實體地址*/
304 uint32_t addr_v2p(uint32_t vaddr)
305 {
306 uint32_t *pte = pte_ptr(vaddr);
307 return ((*pte & 0xfffff000) + (vaddr & 0x00000fff));
308 }
1 #ifndef __KERNEL_MEMORY_H
2 #define __KERNEL_MEMORY_H
3 #include "stdint.h"
4 #include "bitmap.h"
5
6 #define MEM_BIT_BASE 0xc009a000
7
8 /*虛擬地址池，用於虛擬地址管理*/
9 struct virtual_addr {
10 struct bitmap vaddr_bitmap; //虛擬地址用到的點陣圖結構
11 uint32_t vaddr_start; //虛擬地址起始地址
12 };
13
14 /*記憶體池標記，用於判斷用哪個記憶體池*/
15 enum pool_flags {
16 PF_KERNEL = 1,
17 PF_USER = 2
18 };
19
20 #define PG_P_1 1 //頁表項或頁目錄項存在屬性位，存在
21 #define PG_P_0 0 //頁表項或頁目錄項存在屬性位，不存在
22 #define PG_RW_R 0 //R/W屬性位值，不可讀/不可寫
23 #define PG_RW_W 2 //R/W屬性位值，可讀/可寫
24 #define PG_US_S 0 //U/S屬性位值，系統級
25 #define PG_US_U 4 //U/S屬性位值，使用者級
26
27 void mem_init(void);
28 void *get_kernel_pages(uint32_t pg_cnt);
29 void *get_a_page(enum pool_flags pf, uint32_t vaddr);
30 void *get_user_pages(uint32_t pg_cnt);
31 uint32_t addr_v2p(uint32_t vaddr);
32 void *get_a_page(enum pool_flags pf, uint32_t vaddr);
33
34 #endif
1 #include "thread.h"
2 #include "string.h"
3 #include "memory.h"
4 #include "list.h"
5 #include "interrupt.h"
6 #include "debug.h"
7 #include "print.h"
8 #include "stddef.h"
9 #include "process.h"
10
11 struct task_struct *main_thread; //主執行緒PCB
12 struct list thread_ready_list; //就緒佇列
13 struct list thread_all_list; //所有人物佇列
14 static struct list_elem *thread_tag; //用於儲存佇列中的執行緒節點
15 extern void switch_to(struct task_struct* cur, struct task_struct* next);
16
17
18 /*獲取當前執行緒PCB指標*/
19 struct task_struct *running_thread(void)
20 {
21 uint32_t esp;
22 asm volatile ("mov %%esp, %0" : "=g" (esp));
23
24 /*取esp整數部分，即PCB起始地址*/
25 return (struct task_struct *)(esp & 0xfffff000);
26 }
27
28 /*由kernel_thread去執行function(func_arg)*/
29 static void kernel_thread(thread_func *function, void *func_arg)
30 {
31 /*執行function前要開中斷，避免後面的時鐘中斷被遮蔽，而無法排程其他執行緒*/
32 intr_enable();
33 function(func_arg);
34 }
35
36 /*初始化執行緒PCB*/
37 void init_thread(struct task_struct *pthread, char *name, int prio)
38 {
39 memset(pthread, 0, sizeof(*pthread));
40 strcpy(pthread->name, name);
41
42 /*由於main函數也封裝成了一個執行緒，並且他是一直在執行的，所以將其直接設定為TASK_RUNNING*/
43 if (pthread == main_thread) {
44 pthread->status = TASK_RUNNING;
45 } else {
46 pthread->status = TASK_READY;
47 }
48 //pthread->status = TASK_RUNNING;
49 pthread->priority = prio;
50 pthread->ticks = prio;
51 pthread->elapsed_ticks = 0;
52 pthread->pgdir = NULL;
53 pthread->self_kstack = (uint32_t *)((uint32_t)pthread + PG_SIZE);
54 pthread->stack_magic = 0x19870916;
55 }
56
57 void thread_create(struct task_struct *pthread, thread_func function, void *func_arg)
58 {
59 pthread->self_kstack -= sizeof(struct intr_stack);
60 pthread->self_kstack -= sizeof(struct thread_stack);
61
62 //初始化執行緒棧
63 struct thread_stack *kthread_stack = (struct thread_stack *)pthread->self_kstack;
64 kthread_stack->eip = kernel_thread;
65 kthread_stack->function = function;
66 kthread_stack->func_arg = func_arg;
67 kthread_stack->ebp = kthread_stack->ebx = kthread_stack->edi = kthread_stack->esi = 0;
68 }
69
70 /*建立一個優先順序為prio的執行緒，執行緒名字為name，執行緒所執行的函數為function(func_arg)*/
71 struct task_struct *thread_start(char *name, int prio, thread_func function, void *func_arg)
72 {
73 /*建立執行緒的pcb，大小為4kb*/
74 struct task_struct *thread = get_kernel_pages(1);
75 init_thread(thread, name, prio);
76 thread_create(thread, function, func_arg);
77
78 /*確保之前不在佇列中*/
79 ASSERT(!elem_find(&thread_ready_list, &thread->general_tag));
80
81 /*加入就緒執行緒佇列*/
82 list_append(&thread_ready_list, &thread->general_tag);
83
84 /*確保之前不在佇列*/
85 ASSERT(!elem_find(&thread_all_list, &thread->all_list_tag));
86
87 /*加入全部執行緒佇列*/
88 list_append(&thread_all_list, &thread->all_list_tag);
89
90 return thread;
91 }
92
93 static void make_main_thread(void)
94 {
95 main_thread = running_thread();
96 init_thread(main_thread, "main", 31);
97
98 /*main函數是當前執行緒，當前執行緒不在thread_ready_list,所以只能將其加在thread_all_list*/
99 ASSERT(!elem_find(&thread_all_list, &main_thread->all_list_tag));
100 list_append(&thread_all_list, &main_thread->all_list_tag);
101 }
102
103 /*實現任務排程*/
104 void schedule(void)
105 {
106 ASSERT(intr_get_status() == INTR_OFF);
107 struct task_struct *cur = running_thread();
108 if (cur->status == TASK_RUNNING) {
109 ASSERT(!elem_find(&thread_ready_list, &cur->general_tag));
110 list_append(&thread_ready_list, &cur->general_tag);
111 cur->ticks = cur->priority;
112 cur->status = TASK_READY;
113 } else {
114 /*阻塞等其他情況*/
115 }
116
117 ASSERT(!list_empty(&thread_ready_list));
118 thread_tag = NULL;
119 thread_tag = list_pop(&thread_ready_list);
120
121 struct task_struct *next = elem2entry(struct task_struct, general_tag, thread_tag);
122 next->status = TASK_RUNNING;
123
124 process_activate(next);
125 switch_to(cur, next);
126 }
127
128 /*初始化執行緒環境*/
129 void thread_init(void)
130 {
131 put_str("thread_init start\n");
132 list_init(&thread_ready_list);
133 list_init(&thread_all_list);
134 /*將當前main函數建立為執行緒*/
135 make_main_thread();
136 put_str("thread_init done\n");
137 }
138
139 /*當前執行緒將自己阻塞，標誌其狀態為stat*/
140 void thread_block(enum task_status stat)
141 {
142 /*stat取值為TASK_BLOCKED、TASK_WAITING、TASK_HANGING
143 這三種狀態才不會被排程*/
144 ASSERT(((stat == TASK_BLOCKED) || (stat == TASK_WAITING) || (stat == TASK_HANGING)));
145 enum intr_status old_status = intr_disable();
146 struct task_struct *cur_thread = running_thread();
147 cur_thread->status = stat;
148 schedule();
149 intr_set_status(old_status);
150 }
151
152 /*將執行緒thread解除阻塞*/
153 void thread_unblock(struct task_struct *thread)
154 {
155 enum intr_status old_status = intr_disable();
156 ASSERT(((thread->status == TASK_BLOCKED) || (thread->status == TASK_WAITING) || (thread->status == TASK_HANGING)));
157 if (thread->status != TASK_READY) {
158 ASSERT(!elem_find(&thread_ready_list, &thread->general_tag));
159 if (elem_find(&thread_ready_list, &thread->general_tag)) {
160 PANIC("thread_unblock: blocked thread in ready_list!\n");
161 }
162 list_push(&thread_ready_list, &thread->general_tag);
163 thread->status = TASK_READY;
164 }
165 intr_set_status(old_status);
166 }
1 #ifndef __KERNEL_THREAD_H
2 #define __KERNEL_THREAD_H
3 #include "stdint.h"
4 #include "list.h"
5 #include "memory.h"
6
7 /*自定義通用函數型別，它將在很多執行緒函數中作為形參型別*/
8 typedef void thread_func (void *);
9 #define PG_SIZE 4096
10 /*程序或執行緒的狀態*/
11 enum task_status {
12 TASK_RUNNING,
13 TASK_READY,
14 TASK_BLOCKED,
15 TASK_WAITING,
16 TASK_HANGING,
17 TASK_DIED
18 };
19
20 /****************中斷棧intr_stack****************/
21 struct intr_stack {
22 uint32_t vec_no;
23 uint32_t edi;
24 uint32_t esi;
25 uint32_t ebp;
26 uint32_t esp_dummy;
27 uint32_t ebx;
28 uint32_t edx;
29 uint32_t ecx;
30 uint32_t eax;
31 uint32_t gs;
32 uint32_t fs;
33 uint32_t es;
34 uint32_t ds;
35
36 /*以下由cpu從低特權級進入高特權級時壓入*/
37 uint32_t err_code;
38 void (*eip)(void);
39 uint32_t cs;
40 uint32_t eflags;
41 void *esp;
42 uint32_t ss;
43 };
44
45 /***************執行緒棧thread_stack**********/
46 struct thread_stack
47 {
48 uint32_t ebp;
49 uint32_t ebx;
50 uint32_t edi;
51 uint32_t esi;
52
53 void (*eip) (thread_func *func, void *func_arg);
54 void (*unused_retaddr);
55 thread_func *function;
56 void *func_arg;
57 };
58
59 /************程序或者執行緒的pcb,程式控制塊**********/
60 struct task_struct
61 {
62 uint32_t *self_kstack; //每個核心執行緒自己的核心棧
63 enum task_status status;
64 uint8_t priority;
65
66 char name[16];
67 uint8_t ticks; //每次在處理器上執行的時間滴答數
68
69 /*此任務自從上CPU執行至今佔用了多少滴答數，也就是這個任務執行了多久時間*/
70 uint32_t elapsed_ticks;
71
72 /*general_tag的作用是用於執行緒在一般的佇列中的節點*/
73 struct list_elem general_tag;
74
75 /*all_list_tag的作用是用於執行緒thread_all_list的節點*/
76 struct list_elem all_list_tag;
77
78 uint32_t *pgdir;//程序自己頁表的虛擬地址
79
80 struct virtual_addr userprog_vaddr; //使用者程序的虛擬地址池
81
82 uint32_t stack_magic;
83 };
84
85 void schedule(void);
86 struct task_struct *running_thread(void);
87 static void kernel_thread(thread_func *function, void *func_arg);
88 void init_thread(struct task_struct *pthread, char *name, int prio);
89 void thread_create(struct task_struct *pthread, thread_func function, void *func_arg);
90 struct task_struct *thread_start(char *name, int prio, thread_func function, void *func_arg);
91 static void make_main_thread(void);
92 void thread_init(void);
93 void thread_block(enum task_status stat);
94 void thread_unblock(struct task_struct *thread);
95
96
97 #endif
修改main.c檔案，本來使用者程序在執行前，是由作業系統的程式載入起將使用者程式從檔案系統直接讀取到記憶體，再根據程式檔案的格式解析其內容，將程式中的段展開到相應的記憶體地址。程式格式會記錄程式的入口地址，CPU把CS:[E]IP指向它，該程式就被執行了，C語言雖然不能直接控制這兩個暫存器，但是函數呼叫其實就是改變這兩個暫存器的指向，故C語言編寫的作業系統可以像呼叫函數那樣呼叫執行使用者程式。因此使用者程序被載入到記憶體中後如同函數一樣，僅僅是個指令區域，由於我們目前沒有實現檔案系統，前期我們用普通函數來代替使用者程式，所以在main函數中我們新建了兩個名為u_prog_a和u_prog_b的兩個函數來作為程序執行的使用者程式。在這兩個程式中分別對test_var_a和test_var_b變數進行加1操作，由於使用者態下的字串列印函數我們還沒實現，所以又新建兩個核心執行緒k_thread_a和k_thread_b來列印這兩個變數。
1 #include "print.h"
2 #include "debug.h"
3 #include "init.h"
4 #include "memory.h"
5 #include "thread.h"
6 #include "timer.h"
7 #include "list.h"
8 #include "interrupt.h"
9 #include "console.h"
10 #include "keyboard.h"
11 #include "ioqueue.h"
12 #include "process.h"
13
14 void k_thread_a(void *arg);
15 void k_thread_b(void *arg);
16 void u_prog_a(void);
17 void u_prog_b(void);
18 int test_var_a = 0, test_var_b = 0;
19 int main (void)
20 {
21 put_str("I am Kernel\n");
22 init_all();
23
24 thread_start("k_thread_a", 31, k_thread_a, "argA ");
25 thread_start("k_thread_b", 31, k_thread_b, "argB ");
26 process_execute(u_prog_a, "user_prog_a");
27 process_execute(u_prog_b, "user_prog_b");
28 intr_enable();
29
30 while (1);
31 return 0;
32 }
33
34 void u_prog_a(void)
35 {
36 while(1) {
37 test_var_a = *(int *)(0xc0006480);
38 }
39 }
40
41 void u_prog_b(void)
42 {
43 while(1) {
44 test_var_b++;
45 }
46 }
47
48 void k_thread_a(void *arg)
49 {
50 char *para = arg;
51 while (1) {
52 console_put_str("v_a:0x");
53 console_put_int(test_var_a);
54 console_put_str("\n");
55 }
56 }
57
58 void k_thread_b(void *arg)
59 {
60 char *para = arg;
61 while (1) {
62 console_put_str("v_b:0x");
63 console_put_int(test_var_b);
64 console_put_str("\n");
65 }
66 }
執行測試，可以看到基本正常。
五、原書勘誤
這個地方我當初做到這裡這一章節時，死活調不通。通過打斷點，可以看到進入程序後，中斷表有明顯的異常。
在程序中，中斷表的位置位於0x000063c0處，當然每個人的實際情況可能不太一樣。總之明顯不對，因為我們只給程序的頁目錄表對映了核心部分，很明顯這個地址是沒有被新增到頁表中的。所以一旦發生了中斷，CPU拿著這個中斷表的地址去找中斷描述符時就會報錯，因為頁表中沒有記錄這個位置的對映關係。
後面偵錯的時候發現其實是在實現中斷程式碼那一章時，書上給的程式碼有誤，原書第330頁，如下:
黃色部分的程式碼是罪魁禍首，我測試了一下，在我的系統中idt被存放在虛擬地址0xc00063c0處，對應到實體地址就是0x000063c0處。經過上圖這種移位元運算後，最終得到的地址變成了虛擬地址0x000063c0，可以發現高16位元被舍掉了。在我們還沒有實現程序的時候，在核心執行緒的頁表中0x000063c0和0xc00063c0這兩個虛擬地址都是對映到0x000063c0這個實體地址的，所以我們前面並不會報錯。但是到了程序，在我們程序的頁表中，只有0xc00063c0這個虛擬地址對映到0x000063c0這個實體地址，而0x000063c0這個虛擬地址是沒有被新增對映關係的，所以才會一執行就報錯。所以將程式碼修改成如下就好了：
uint64_t idt_operand = (sizeof(idt) - 1) | ((uint64_t)(uint32_t)idt << 16);
好了，本回合就到此結束了。這一章知識量還是比較多的，程式碼也是很長的，我也是回味了很久。預知後事如何，請看下回分解。