Navigation
- Accueil
- Présentation :
- FAQ
- Bugs et errata
- Contributions de lecteurs
- Téléchargements
- LXR (référencement des sources)
- Mailing-list
- Liens et Projets reliés
Site hébergé par :
Site hébergé par :
|
[ source navigation ] [ diff markup ] [ identifier search ] [ general search ] |
|||
|
||||
001 /* Copyright (C) 2004 The SOS Team 001 /* Copyright (C) 2004 The SOS Team 002 002 003 This program is free software; you can redi 003 This program is free software; you can redistribute it and/or 004 modify it under the terms of the GNU Genera 004 modify it under the terms of the GNU General Public License 005 as published by the Free Software Foundatio 005 as published by the Free Software Foundation; either version 2 006 of the License, or (at your option) any lat 006 of the License, or (at your option) any later version. 007 007 008 This program is distributed in the hope tha 008 This program is distributed in the hope that it will be useful, 009 but WITHOUT ANY WARRANTY; without even the 009 but WITHOUT ANY WARRANTY; without even the implied warranty of 010 MERCHANTABILITY or FITNESS FOR A PARTICULAR 010 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 011 GNU General Public License for more details 011 GNU General Public License for more details. 012 012 013 You should have received a copy of the GNU 013 You should have received a copy of the GNU General Public License 014 along with this program; if not, write to t 014 along with this program; if not, write to the Free Software 015 Foundation, Inc., 59 Temple Place - Suite 3 015 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 016 USA. 016 USA. 017 */ 017 */ 018 018 019 /* Include definitions of the multiboot standa 019 /* Include definitions of the multiboot standard */ 020 #include <bootstrap/multiboot.h> 020 #include <bootstrap/multiboot.h> 021 #include <hwcore/idt.h> 021 #include <hwcore/idt.h> 022 #include <hwcore/gdt.h> 022 #include <hwcore/gdt.h> 023 #include <hwcore/irq.h> 023 #include <hwcore/irq.h> 024 #include <hwcore/exception.h> 024 #include <hwcore/exception.h> 025 #include <hwcore/i8254.h> 025 #include <hwcore/i8254.h> 026 #include <sos/list.h> 026 #include <sos/list.h> 027 #include <sos/physmem.h> 027 #include <sos/physmem.h> 028 #include <hwcore/paging.h> 028 #include <hwcore/paging.h> 029 #include <hwcore/mm_context.h> 029 #include <hwcore/mm_context.h> 030 #include <hwcore/swintr.h> 030 #include <hwcore/swintr.h> 031 #include <sos/kmem_vmm.h> 031 #include <sos/kmem_vmm.h> 032 #include <sos/kmalloc.h> 032 #include <sos/kmalloc.h> 033 #include <sos/time.h> 033 #include <sos/time.h> 034 #include <sos/thread.h> 034 #include <sos/thread.h> 035 #include <sos/process.h> 035 #include <sos/process.h> >> 036 #include <sos/umem_vmm.h> 036 #include <sos/klibc.h> 037 #include <sos/klibc.h> 037 #include <sos/assert.h> 038 #include <sos/assert.h> 038 #include <drivers/x86_videomem.h> 039 #include <drivers/x86_videomem.h> 039 #include <drivers/bochs.h> 040 #include <drivers/bochs.h> 040 #include <sos/calcload.h> 041 #include <sos/calcload.h> >> 042 #include <sos/umem_vmm.h> >> 043 #include <sos/binfmt_elf32.h> >> 044 #include <drivers/zero.h> 041 045 042 046 043 /* Helper function to display each bits of a 3 047 /* Helper function to display each bits of a 32bits integer on the 044 screen as dark or light carrets */ 048 screen as dark or light carrets */ 045 void display_bits(unsigned char row, unsigned 049 void display_bits(unsigned char row, unsigned char col, 046 unsigned char attribute, 050 unsigned char attribute, 047 sos_ui32_t integer) 051 sos_ui32_t integer) 048 { 052 { 049 int i; 053 int i; 050 /* Scan each bit of the integer, MSb first * 054 /* Scan each bit of the integer, MSb first */ 051 for (i = 31 ; i >= 0 ; i--) 055 for (i = 31 ; i >= 0 ; i--) 052 { 056 { 053 /* Test if bit i of 'integer' is set */ 057 /* Test if bit i of 'integer' is set */ 054 int bit_i = (integer & (1 << i)); 058 int bit_i = (integer & (1 << i)); 055 /* Ascii 219 => dark carret, Ascii 177 = 059 /* Ascii 219 => dark carret, Ascii 177 => light carret */ 056 unsigned char ascii_code = bit_i?219:177 060 unsigned char ascii_code = bit_i?219:177; 057 sos_x86_videomem_putchar(row, col++, 061 sos_x86_videomem_putchar(row, col++, 058 attribute, 062 attribute, 059 ascii_code); 063 ascii_code); 060 } 064 } 061 } 065 } 062 066 063 067 064 /* Clock IRQ handler */ 068 /* Clock IRQ handler */ 065 static void clk_it(int intid) 069 static void clk_it(int intid) 066 { 070 { 067 static sos_ui32_t clock_count = 0; 071 static sos_ui32_t clock_count = 0; 068 072 069 display_bits(0, 48, 073 display_bits(0, 48, 070 SOS_X86_VIDEO_FG_LTGREEN | SOS_ 074 SOS_X86_VIDEO_FG_LTGREEN | SOS_X86_VIDEO_BG_BLUE, 071 clock_count); 075 clock_count); 072 clock_count++; 076 clock_count++; 073 077 074 /* Execute the expired timeout actions (if a 078 /* Execute the expired timeout actions (if any) */ 075 sos_time_do_tick(); 079 sos_time_do_tick(); 076 080 077 /* Update scheduler statistics and status */ 081 /* Update scheduler statistics and status */ 078 sos_sched_do_timer_tick(); 082 sos_sched_do_timer_tick(); 079 } 083 } 080 084 081 085 082 /* =========================================== 086 /* ====================================================================== 083 * Page fault exception handling 087 * Page fault exception handling 084 */ 088 */ 085 089 086 090 087 /* Page fault exception handler with demand pa 091 /* Page fault exception handler with demand paging for the kernel */ 088 static void pgflt_ex(int intid, struct sos_cpu 092 static void pgflt_ex(int intid, struct sos_cpu_state *ctxt) 089 { 093 { 090 static sos_ui32_t demand_paging_count = 0; 094 static sos_ui32_t demand_paging_count = 0; >> 095 struct sos_thread * cur_thr = sos_thread_get_current(); 091 sos_vaddr_t faulting_vaddr = sos_cpu_contex 096 sos_vaddr_t faulting_vaddr = sos_cpu_context_get_EX_faulting_vaddr(ctxt); 092 sos_paddr_t ppage_paddr; 097 sos_paddr_t ppage_paddr; 093 098 094 if (sos_cpu_context_is_in_user_mode(ctxt)) !! 099 if (sos_cpu_context_is_in_user_mode(ctxt) >> 100 || (cur_thr->fixup_uaccess.return_vaddr)) 095 { 101 { 096 /* User-mode page faults are considered !! 102 __label__ unforce_address_space; 097 moment */ !! 103 sos_bool_t need_to_setup_mmu; >> 104 sos_ui32_t errcode = sos_cpu_context_get_EX_info(ctxt); >> 105 >> 106 /* Make sure to always stay in the interrupted thread's MMU >> 107 configuration */ >> 108 need_to_setup_mmu = (cur_thr->squatted_mm_context >> 109 != sos_process_get_mm_context(cur_thr->process)); >> 110 if (need_to_setup_mmu) >> 111 sos_thread_prepare_user_space_access(NULL, 0); >> 112 >> 113 if (SOS_OK == >> 114 sos_umem_vmm_try_resolve_page_fault(faulting_vaddr, >> 115 errcode & (1 << 1), >> 116 TRUE)) >> 117 goto unforce_address_space; >> 118 >> 119 /* If the page fault occured in kernel mode, return to kernel to >> 120 the fixup address */ >> 121 if (! sos_cpu_context_is_in_user_mode(ctxt)) >> 122 { >> 123 cur_thr->fixup_uaccess.faulted_uaddr = faulting_vaddr; >> 124 sos_cpu_context_set_EX_return_address(ctxt, >> 125 cur_thr->fixup_uaccess.return_vaddr); >> 126 goto unforce_address_space; >> 127 } >> 128 >> 129 if (need_to_setup_mmu) >> 130 sos_thread_end_user_space_access(); >> 131 098 sos_bochs_printf("Unresolved USER page F 132 sos_bochs_printf("Unresolved USER page Fault at instruction 0x%x on access to address 0x%x (info=%x)!\n", 099 sos_cpu_context_get_PC( 133 sos_cpu_context_get_PC(ctxt), 100 (unsigned)faulting_vadd 134 (unsigned)faulting_vaddr, 101 (unsigned)sos_cpu_conte 135 (unsigned)sos_cpu_context_get_EX_info(ctxt)); 102 sos_bochs_printf("Terminating User threa 136 sos_bochs_printf("Terminating User thread\n"); 103 sos_thread_exit(); 137 sos_thread_exit(); >> 138 >> 139 unforce_address_space: >> 140 if (need_to_setup_mmu) >> 141 sos_thread_end_user_space_access(); >> 142 return; 104 } 143 } 105 144 106 /* Check if address is covered by any VMM ra 145 /* Check if address is covered by any VMM range */ 107 if (! sos_kmem_vmm_is_valid_vaddr(faulting_v 146 if (! sos_kmem_vmm_is_valid_vaddr(faulting_vaddr)) 108 { 147 { 109 /* No: The page fault is out of any kern 148 /* No: The page fault is out of any kernel virtual region. For 110 the moment, we don't handle this. */ 149 the moment, we don't handle this. */ 111 sos_display_fatal_error("Unresolved page 150 sos_display_fatal_error("Unresolved page Fault at instruction 0x%x on access to address 0x%x (info=%x)!", 112 sos_cpu_context_ 151 sos_cpu_context_get_PC(ctxt), 113 (unsigned)faulti 152 (unsigned)faulting_vaddr, 114 (unsigned)sos_cp 153 (unsigned)sos_cpu_context_get_EX_info(ctxt)); 115 SOS_ASSERT_FATAL(! "Got page fault (note 154 SOS_ASSERT_FATAL(! "Got page fault (note: demand paging is disabled)"); 116 } 155 } 117 156 118 157 119 /* 158 /* 120 * Demand paging in kernel space 159 * Demand paging in kernel space 121 */ 160 */ 122 161 123 /* Update the number of demand paging reques 162 /* Update the number of demand paging requests handled */ 124 demand_paging_count ++; 163 demand_paging_count ++; 125 display_bits(0, 0, 164 display_bits(0, 0, 126 SOS_X86_VIDEO_FG_LTRED | SOS_X8 165 SOS_X86_VIDEO_FG_LTRED | SOS_X86_VIDEO_BG_BLUE, 127 demand_paging_count); 166 demand_paging_count); 128 167 129 /* Allocate a new page for the virtual addre 168 /* Allocate a new page for the virtual address */ 130 ppage_paddr = sos_physmem_ref_physpage_new(F 169 ppage_paddr = sos_physmem_ref_physpage_new(FALSE); 131 if (! ppage_paddr) 170 if (! ppage_paddr) 132 SOS_ASSERT_FATAL(! "TODO: implement swap. 171 SOS_ASSERT_FATAL(! "TODO: implement swap. (Out of mem in demand paging because no swap for kernel yet !)"); 133 SOS_ASSERT_FATAL(SOS_OK == sos_paging_map(pp 172 SOS_ASSERT_FATAL(SOS_OK == sos_paging_map(ppage_paddr, 134 SO 173 SOS_PAGE_ALIGN_INF(faulting_vaddr), 135 FA 174 FALSE, 136 SO 175 SOS_VM_MAP_PROT_READ 137 | 176 | SOS_VM_MAP_PROT_WRITE 138 | 177 | SOS_VM_MAP_ATOMIC)); 139 sos_physmem_unref_physpage(ppage_paddr); 178 sos_physmem_unref_physpage(ppage_paddr); 140 179 141 /* Ok, we can now return to interrupted cont 180 /* Ok, we can now return to interrupted context */ 142 } 181 } 143 182 144 183 145 /* =========================================== << 146 * Demonstrate the use of SOS kernel threads << 147 * - Kernel Threads are created with various << 148 * state is printed on both the console and << 149 * - For tests regarding threads' synchroniza << 150 */ << 151 << 152 struct thr_arg << 153 { << 154 char character; << 155 int color; << 156 << 157 int col; << 158 int row; << 159 }; << 160 << 161 << 162 static void demo_thread(void *arg) << 163 { << 164 struct thr_arg *thr_arg = (struct thr_arg*)a << 165 int progress = 0; << 166 << 167 sos_bochs_printf("start %c", thr_arg->charac << 168 while (1) << 169 { << 170 progress ++; << 171 display_bits(thr_arg->row, thr_arg->col+ << 172 << 173 sos_bochs_putchar(thr_arg->character); << 174 << 175 /* Yield the CPU to another thread somet << 176 if ((random() % 100) == 0) << 177 { << 178 sos_bochs_printf("[37myield(%c)[m\ << 179 sos_x86_videomem_putchar(thr_arg->ro << 180 SOS_ASSERT_FATAL(SOS_OK == sos_threa << 181 sos_x86_videomem_putchar(thr_arg->ro << 182 } << 183 << 184 /* Go to sleep some other times... */ << 185 else if ((random() % 200) == 0) << 186 { << 187 struct sos_time t = (struct sos_time << 188 sos_bochs_printf("[37msleep1(%c)[m << 189 sos_x86_videomem_putchar(thr_arg->ro << 190 SOS_ASSERT_FATAL(SOS_OK == sos_threa << 191 SOS_ASSERT_FATAL(sos_time_is_zero(& << 192 sos_x86_videomem_putchar(thr_arg->ro << 193 } << 194 << 195 /* Go to sleep for a longer time some ot << 196 else if ((random() % 300) == 0) << 197 { << 198 struct sos_time t = (struct sos_time << 199 sos_bochs_printf("[37msleep2(%c)[m << 200 sos_x86_videomem_putchar(thr_arg->ro << 201 SOS_ASSERT_FATAL(SOS_OK == sos_threa << 202 SOS_ASSERT_FATAL(sos_time_is_zero(& << 203 sos_x86_videomem_putchar(thr_arg->ro << 204 } << 205 << 206 /* Infinite loop otherwise */ << 207 } << 208 } << 209 << 210 << 211 static void test_thread() << 212 { << 213 /* "static" variables because we want them t << 214 function returns */ << 215 static struct thr_arg arg_b, arg_c, arg_d, a << 216 sos_ui32_t flags; << 217 << 218 sos_disable_IRQs(flags); << 219 << 220 arg_b = (struct thr_arg) { .character='b', . << 221 sos_create_kernel_thread("YO[b]", demo_threa << 222 << 223 arg_c = (struct thr_arg) { .character='c', . << 224 sos_create_kernel_thread("YO[c]", demo_threa << 225 << 226 arg_d = (struct thr_arg) { .character='d', . << 227 sos_create_kernel_thread("YO[d]", demo_threa << 228 << 229 arg_e = (struct thr_arg) { .character='e', . << 230 sos_create_kernel_thread("YO[e]", demo_threa << 231 << 232 arg_R = (struct thr_arg) { .character='R', . << 233 sos_create_kernel_thread("YO[R]", demo_threa << 234 << 235 arg_S = (struct thr_arg) { .character='S', . << 236 sos_create_kernel_thread("YO[S]", demo_threa << 237 << 238 sos_restore_IRQs(flags); << 239 } << 240 << 241 184 242 /* =========================================== 185 /* ====================================================================== 243 * An operating system MUST always have a read 186 * An operating system MUST always have a ready thread ! Otherwise: 244 * what would the CPU have to execute ?! 187 * what would the CPU have to execute ?! 245 */ 188 */ 246 static void idle_thread() 189 static void idle_thread() 247 { 190 { 248 sos_ui32_t idle_twiddle = 0; 191 sos_ui32_t idle_twiddle = 0; 249 192 250 while (1) 193 while (1) 251 { 194 { 252 /* Remove this instruction if you get an 195 /* Remove this instruction if you get an "Invalid opcode" CPU 253 exception (old 80386 CPU) */ 196 exception (old 80386 CPU) */ 254 asm("hlt\n"); 197 asm("hlt\n"); 255 198 256 idle_twiddle ++; 199 idle_twiddle ++; 257 display_bits(0, 0, SOS_X86_VIDEO_FG_GREE 200 display_bits(0, 0, SOS_X86_VIDEO_FG_GREEN | SOS_X86_VIDEO_BG_BLUE, 258 idle_twiddle); 201 idle_twiddle); 259 202 260 /* Lend the CPU to some other thread */ 203 /* Lend the CPU to some other thread */ 261 sos_thread_yield(); 204 sos_thread_yield(); 262 } 205 } 263 } 206 } 264 207 265 208 266 /* =========================================== 209 /* ====================================================================== 267 * Kernel thread showing some CPU usage statis 210 * Kernel thread showing some CPU usage statistics on the console every 1s 268 */ 211 */ 269 static void stat_thread() 212 static void stat_thread() 270 { 213 { 271 while (1) 214 while (1) 272 { 215 { 273 sos_ui32_t flags; 216 sos_ui32_t flags; 274 sos_ui32_t load1, load5, load15; 217 sos_ui32_t load1, load5, load15; 275 char str1[11], str5[11], str15[11]; 218 char str1[11], str5[11], str15[11]; 276 struct sos_time t; 219 struct sos_time t; 277 t.sec = 1; 220 t.sec = 1; 278 t.nanosec = 0; 221 t.nanosec = 0; 279 222 280 sos_thread_sleep(& t); 223 sos_thread_sleep(& t); 281 224 282 sos_disable_IRQs(flags); 225 sos_disable_IRQs(flags); 283 226 284 /* The IDLE task is EXcluded in the foll 227 /* The IDLE task is EXcluded in the following computation */ 285 sos_load_get_sload(&load1, &load5, &load 228 sos_load_get_sload(&load1, &load5, &load15); 286 sos_load_to_string(str1, load1); 229 sos_load_to_string(str1, load1); 287 sos_load_to_string(str5, load5); 230 sos_load_to_string(str5, load5); 288 sos_load_to_string(str15, load15); 231 sos_load_to_string(str15, load15); 289 sos_x86_videomem_printf(16, 34, 232 sos_x86_videomem_printf(16, 34, 290 SOS_X86_VIDEO_FG 233 SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE, 291 "Kernel (- Idle) 234 "Kernel (- Idle): %s %s %s ", 292 str1, str5, str1 235 str1, str5, str15); 293 236 294 sos_load_get_uload(&load1, &load5, &load 237 sos_load_get_uload(&load1, &load5, &load15); 295 sos_load_to_string(str1, load1); 238 sos_load_to_string(str1, load1); 296 sos_load_to_string(str5, load5); 239 sos_load_to_string(str5, load5); 297 sos_load_to_string(str15, load15); 240 sos_load_to_string(str15, load15); 298 sos_x86_videomem_printf(17, 34, 241 sos_x86_videomem_printf(17, 34, 299 SOS_X86_VIDEO_FG 242 SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE, 300 "User: %s %s %s 243 "User: %s %s %s ", 301 str1, str5, str1 244 str1, str5, str15); 302 245 303 sos_load_get_uratio(&load1, &load5, &loa 246 sos_load_get_uratio(&load1, &load5, &load15); 304 sos_load_to_string(str1, load1); 247 sos_load_to_string(str1, load1); 305 sos_load_to_string(str5, load5); 248 sos_load_to_string(str5, load5); 306 sos_load_to_string(str15, load15); 249 sos_load_to_string(str15, load15); 307 sos_x86_videomem_printf(18, 34, 250 sos_x86_videomem_printf(18, 34, 308 SOS_X86_VIDEO_FG 251 SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE, 309 "User CPU %%: %s 252 "User CPU %%: %s %s %s ", 310 str1, str5, str1 253 str1, str5, str15); 311 254 312 /* The IDLE task is INcluded in the foll 255 /* The IDLE task is INcluded in the following computation */ 313 sos_load_get_sratio(&load1, &load5, &loa 256 sos_load_get_sratio(&load1, &load5, &load15); 314 sos_load_to_string(str1, load1); 257 sos_load_to_string(str1, load1); 315 sos_load_to_string(str5, load5); 258 sos_load_to_string(str5, load5); 316 sos_load_to_string(str15, load15); 259 sos_load_to_string(str15, load15); 317 sos_x86_videomem_printf(19, 34, 260 sos_x86_videomem_printf(19, 34, 318 SOS_X86_VIDEO_FG 261 SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE, 319 "Kernel CPU %% ( 262 "Kernel CPU %% (+ Idle): %s %s %s ", 320 str1, str5, str1 263 str1, str5, str15); 321 sos_restore_IRQs(flags); 264 sos_restore_IRQs(flags); 322 } 265 } 323 } 266 } 324 267 325 268 326 /* =========================================== 269 /* ====================================================================== >> 270 * Start the "init" (userland) process >> 271 */ >> 272 static sos_ret_t start_init() >> 273 { >> 274 sos_ret_t retval; >> 275 struct sos_umem_vmm_as *as_init; >> 276 struct sos_process *proc_init; >> 277 struct sos_thread *new_thr; >> 278 sos_uaddr_t ustack, start_uaddr; >> 279 >> 280 /* Create the new process */ >> 281 proc_init = sos_process_create("init", FALSE); >> 282 if (! proc_init) >> 283 return -SOS_ENOMEM; >> 284 as_init = sos_process_get_address_space(proc_init); >> 285 >> 286 /* Map the 'init' program in user space */ >> 287 start_uaddr = sos_binfmt_elf32_map(as_init, "init"); >> 288 if (0 == start_uaddr) >> 289 { >> 290 sos_process_unref(proc_init); >> 291 return -SOS_ENOENT; >> 292 } >> 293 >> 294 /* Allocate the user stack */ >> 295 ustack = (SOS_PAGING_TOP_USER_ADDRESS - SOS_DEFAULT_USER_STACK_SIZE) + 1; >> 296 retval = sos_dev_zero_map(as_init, &ustack, SOS_DEFAULT_USER_STACK_SIZE, >> 297 SOS_VM_MAP_PROT_READ | SOS_VM_MAP_PROT_WRITE, >> 298 /* PRIVATE */ 0); >> 299 if (SOS_OK != retval) >> 300 { >> 301 sos_bochs_printf("ici 2\n"); >> 302 sos_process_unref(proc_init); >> 303 return -SOS_ENOMEM; >> 304 } >> 305 >> 306 /* Now create the user thread */ >> 307 new_thr = sos_create_user_thread(NULL, >> 308 proc_init, >> 309 start_uaddr, >> 310 0, 0, >> 311 ustack + SOS_DEFAULT_USER_STACK_SIZE - 4, >> 312 SOS_SCHED_PRIO_TS_LOWEST); >> 313 if (! new_thr) >> 314 { >> 315 sos_bochs_printf("ici 3\n"); >> 316 sos_process_unref(proc_init); >> 317 return -SOS_ENOMEM; >> 318 } >> 319 >> 320 sos_process_unref(proc_init); >> 321 return SOS_OK; >> 322 } >> 323 >> 324 >> 325 /* ====================================================================== 327 * The C entry point of our operating system 326 * The C entry point of our operating system 328 */ 327 */ 329 void sos_main(unsigned long magic, unsigned lo 328 void sos_main(unsigned long magic, unsigned long addr) 330 { 329 { 331 unsigned i; 330 unsigned i; 332 sos_paddr_t sos_kernel_core_base_paddr, sos_ 331 sos_paddr_t sos_kernel_core_base_paddr, sos_kernel_core_top_paddr; 333 struct sos_time tick_resolution; 332 struct sos_time tick_resolution; 334 333 335 /* Grub sends us a structure, called multibo 334 /* Grub sends us a structure, called multiboot_info_t with a lot of 336 precious informations about the system, s 335 precious informations about the system, see the multiboot 337 documentation for more information. */ 336 documentation for more information. */ 338 multiboot_info_t *mbi; 337 multiboot_info_t *mbi; 339 mbi = (multiboot_info_t *) addr; 338 mbi = (multiboot_info_t *) addr; 340 339 341 /* Setup bochs and console, and clear the co 340 /* Setup bochs and console, and clear the console */ 342 sos_bochs_setup(); 341 sos_bochs_setup(); 343 342 344 sos_x86_videomem_setup(); 343 sos_x86_videomem_setup(); 345 sos_x86_videomem_cls(SOS_X86_VIDEO_BG_BLUE); 344 sos_x86_videomem_cls(SOS_X86_VIDEO_BG_BLUE); 346 345 347 /* Greetings from SOS */ 346 /* Greetings from SOS */ 348 if (magic == MULTIBOOT_BOOTLOADER_MAGIC) 347 if (magic == MULTIBOOT_BOOTLOADER_MAGIC) 349 /* Loaded with Grub */ 348 /* Loaded with Grub */ 350 sos_x86_videomem_printf(1, 0, 349 sos_x86_videomem_printf(1, 0, 351 SOS_X86_VIDEO_FG_Y 350 SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE, 352 "Welcome From GRUB 351 "Welcome From GRUB to %s%c RAM is %dMB (upper mem = 0x%x kB)", 353 "SOS article 7", ' !! 352 "SOS article 7.5", ',', 354 (unsigned)(mbi->me 353 (unsigned)(mbi->mem_upper >> 10) + 1, 355 (unsigned)mbi->mem 354 (unsigned)mbi->mem_upper); 356 else 355 else 357 /* Not loaded with grub */ 356 /* Not loaded with grub */ 358 sos_x86_videomem_printf(1, 0, 357 sos_x86_videomem_printf(1, 0, 359 SOS_X86_VIDEO_FG_Y 358 SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE, 360 "Welcome to SOS ar !! 359 "Welcome to SOS article 7.5"); 361 360 362 sos_bochs_putstring("Message in a bochs: Thi !! 361 sos_bochs_putstring("Message in a bochs: This is SOS article 7.5.\n"); 363 362 364 /* Setup CPU segmentation and IRQ subsystem 363 /* Setup CPU segmentation and IRQ subsystem */ 365 sos_gdt_subsystem_setup(); 364 sos_gdt_subsystem_setup(); 366 sos_idt_subsystem_setup(); 365 sos_idt_subsystem_setup(); 367 366 368 /* Setup SOS IRQs and exceptions subsystem * 367 /* Setup SOS IRQs and exceptions subsystem */ 369 sos_exception_subsystem_setup(); 368 sos_exception_subsystem_setup(); 370 sos_irq_subsystem_setup(); 369 sos_irq_subsystem_setup(); 371 370 372 /* Configure the timer so as to raise the IR 371 /* Configure the timer so as to raise the IRQ0 at a 100Hz rate */ 373 sos_i8254_set_frequency(100); 372 sos_i8254_set_frequency(100); 374 373 375 /* Setup the kernel time subsystem to get pr 374 /* Setup the kernel time subsystem to get prepared to take the timer 376 ticks into account */ 375 ticks into account */ 377 tick_resolution = (struct sos_time) { .sec=0 376 tick_resolution = (struct sos_time) { .sec=0, .nanosec=10000000UL }; 378 sos_time_subsysem_setup(& tick_resolution); 377 sos_time_subsysem_setup(& tick_resolution); 379 378 380 /* We need a multiboot-compliant boot loader 379 /* We need a multiboot-compliant boot loader to get the size of the RAM */ 381 if (magic != MULTIBOOT_BOOTLOADER_MAGIC) 380 if (magic != MULTIBOOT_BOOTLOADER_MAGIC) 382 { 381 { 383 sos_x86_videomem_putstring(20, 0, 382 sos_x86_videomem_putstring(20, 0, 384 SOS_X86_VIDEO 383 SOS_X86_VIDEO_FG_LTRED 385 | SOS_X86_V 384 | SOS_X86_VIDEO_BG_BLUE 386 | SOS_X86_V 385 | SOS_X86_VIDEO_FG_BLINKING, 387 "I'm not load 386 "I'm not loaded with Grub !"); 388 /* STOP ! */ 387 /* STOP ! */ 389 for (;;) 388 for (;;) 390 continue; 389 continue; 391 } 390 } 392 391 393 /* 392 /* 394 * Some interrupt handlers 393 * Some interrupt handlers 395 */ 394 */ 396 395 397 /* Binding some HW interrupts and exceptions 396 /* Binding some HW interrupts and exceptions to software routines */ 398 sos_irq_set_routine(SOS_IRQ_TIMER, 397 sos_irq_set_routine(SOS_IRQ_TIMER, 399 clk_it); 398 clk_it); 400 399 401 /* 400 /* 402 * Setup physical memory management 401 * Setup physical memory management 403 */ 402 */ 404 403 405 /* Multiboot says: "The value returned for u 404 /* Multiboot says: "The value returned for upper memory is maximally 406 the address of the first upper memory hol 405 the address of the first upper memory hole minus 1 megabyte.". It 407 also adds: "It is not guaranteed to be th 406 also adds: "It is not guaranteed to be this value." aka "YMMV" ;) */ 408 sos_physmem_subsystem_setup((mbi->mem_upper< 407 sos_physmem_subsystem_setup((mbi->mem_upper<<10) + (1<<20), 409 & sos_kernel_cor 408 & sos_kernel_core_base_paddr, 410 & sos_kernel_cor 409 & sos_kernel_core_top_paddr); 411 410 412 /* 411 /* 413 * Switch to paged-memory mode 412 * Switch to paged-memory mode 414 */ 413 */ 415 414 416 /* Disabling interrupts should seem more cor 415 /* Disabling interrupts should seem more correct, but it's not really 417 necessary at this stage */ 416 necessary at this stage */ 418 SOS_ASSERT_FATAL(SOS_OK == 417 SOS_ASSERT_FATAL(SOS_OK == 419 sos_paging_subsystem_setup( 418 sos_paging_subsystem_setup(sos_kernel_core_base_paddr, 420 419 sos_kernel_core_top_paddr)); 421 420 422 /* Bind the page fault exception */ 421 /* Bind the page fault exception */ 423 sos_exception_set_routine(SOS_EXCEPT_PAGE_FA 422 sos_exception_set_routine(SOS_EXCEPT_PAGE_FAULT, 424 pgflt_ex); 423 pgflt_ex); 425 424 426 /* 425 /* 427 * Setup kernel virtual memory allocator 426 * Setup kernel virtual memory allocator 428 */ 427 */ 429 428 430 if (sos_kmem_vmm_subsystem_setup(sos_kernel_ 429 if (sos_kmem_vmm_subsystem_setup(sos_kernel_core_base_paddr, 431 sos_kernel_ 430 sos_kernel_core_top_paddr, 432 bootstrap_s 431 bootstrap_stack_bottom, 433 bootstrap_s 432 bootstrap_stack_bottom 434 + bootstrap 433 + bootstrap_stack_size)) 435 sos_bochs_printf("Could not setup the Kern 434 sos_bochs_printf("Could not setup the Kernel virtual space allocator\n"); 436 435 437 if (sos_kmalloc_subsystem_setup()) 436 if (sos_kmalloc_subsystem_setup()) 438 sos_bochs_printf("Could not setup the Kmal 437 sos_bochs_printf("Could not setup the Kmalloc subsystem\n"); 439 438 440 /* 439 /* 441 * Initialize the MMU context subsystem 440 * Initialize the MMU context subsystem 442 */ 441 */ 443 sos_mm_context_subsystem_setup(); 442 sos_mm_context_subsystem_setup(); 444 443 445 /* 444 /* 446 * Initialize the CPU context subsystem 445 * Initialize the CPU context subsystem 447 */ 446 */ 448 sos_cpu_context_subsystem_setup(); 447 sos_cpu_context_subsystem_setup(); 449 448 450 /* 449 /* 451 * Bind the syscall handler to its software 450 * Bind the syscall handler to its software interrupt handler 452 */ 451 */ 453 sos_swintr_subsystem_setup(); 452 sos_swintr_subsystem_setup(); 454 453 455 454 456 /* 455 /* 457 * Initialize the Kernel thread and schedule 456 * Initialize the Kernel thread and scheduler subsystems 458 */ 457 */ 459 458 460 /* Initialize kernel thread subsystem */ 459 /* Initialize kernel thread subsystem */ 461 sos_thread_subsystem_setup(bootstrap_stack_b 460 sos_thread_subsystem_setup(bootstrap_stack_bottom, 462 bootstrap_stack_s 461 bootstrap_stack_size); 463 462 464 /* Initialize the scheduler */ 463 /* Initialize the scheduler */ 465 sos_sched_subsystem_setup(); 464 sos_sched_subsystem_setup(); 466 465 467 /* Declare the IDLE thread */ 466 /* Declare the IDLE thread */ 468 SOS_ASSERT_FATAL(sos_create_kernel_thread("i 467 SOS_ASSERT_FATAL(sos_create_kernel_thread("idle", idle_thread, NULL, 469 SO 468 SOS_SCHED_PRIO_TS_LOWEST) != NULL); 470 469 471 /* Prepare the stats subsystem */ 470 /* Prepare the stats subsystem */ 472 sos_load_subsystem_setup(); 471 sos_load_subsystem_setup(); 473 472 474 /* Declare a thread that prints some stats * 473 /* Declare a thread that prints some stats */ 475 SOS_ASSERT_FATAL(sos_create_kernel_thread("s 474 SOS_ASSERT_FATAL(sos_create_kernel_thread("stat_thread", stat_thread, 476 NU 475 NULL, 477 SO 476 SOS_SCHED_PRIO_TS_LOWEST) != NULL); 478 477 479 478 480 /* 479 /* >> 480 * Initialise user address space management subsystem >> 481 */ >> 482 sos_umem_vmm_subsystem_setup(); >> 483 sos_dev_zero_subsystem_setup(); >> 484 >> 485 /* 481 * Initialize process stuff 486 * Initialize process stuff 482 */ 487 */ 483 sos_process_subsystem_setup(); 488 sos_process_subsystem_setup(); 484 489 485 490 486 /* Enabling the HW interrupts here, this wil 491 /* Enabling the HW interrupts here, this will make the timer HW 487 interrupt call the scheduler */ 492 interrupt call the scheduler */ 488 asm volatile ("sti\n"); 493 asm volatile ("sti\n"); 489 494 490 /* Run some tests involving USER processes a !! 495 /* Start the 'init' process, which in turns launches the other 491 extern void test_art7(); !! 496 programs */ 492 test_art7(); !! 497 start_init(); 493 << 494 /* Now run some Kernel threads just for fun << 495 extern void MouseSim(); << 496 MouseSim(); << 497 test_thread(); << 498 498 499 /* 499 /* 500 * We can safely exit from this function now 500 * We can safely exit from this function now, for there is already 501 * an idle Kernel thread ready to make the C 501 * an idle Kernel thread ready to make the CPU busy working... 502 * 502 * 503 * However, we must EXPLICITELY call sos_thr 503 * However, we must EXPLICITELY call sos_thread_exit() because a 504 * simple "return" will return nowhere ! Act 504 * simple "return" will return nowhere ! Actually this first thread 505 * was initialized by the Grub bootstrap sta 505 * was initialized by the Grub bootstrap stage, at a time when the 506 * word "thread" did not exist. This means t 506 * word "thread" did not exist. This means that the stack was not 507 * setup in order for a return here to call 507 * setup in order for a return here to call sos_thread_exit() 508 * automagically. Hence we must call it manu 508 * automagically. Hence we must call it manually. This is the ONLY 509 * kernel thread where we must do this manua 509 * kernel thread where we must do this manually. 510 */ 510 */ 511 sos_bochs_printf("Bye from primary thread !\ 511 sos_bochs_printf("Bye from primary thread !\n"); 512 sos_thread_exit(); 512 sos_thread_exit(); 513 SOS_FATAL_ERROR("No trespassing !"); 513 SOS_FATAL_ERROR("No trespassing !"); 514 } 514 }
| [ source navigation ] | [ diff markup ] | [ identifier search ] | [ general search ] |