Diff markup
001 001
002 002
003 003
004 004
005 005
006 006
007 007
008 008
009 009
010 010
011 011
012 012
013 013
014 014
015 015
016 016
017 017
018 018
019 #include <sos/errno.h> 019 #include <sos/errno.h>
020 020
021 021
022 #include <bootstrap/multiboot.h> 022 #include <bootstrap/multiboot.h>
023 #include <hwcore/idt.h> 023 #include <hwcore/idt.h>
024 #include <hwcore/gdt.h> 024 #include <hwcore/gdt.h>
025 #include <hwcore/irq.h> 025 #include <hwcore/irq.h>
026 #include <hwcore/exception.h> 026 #include <hwcore/exception.h>
027 #include <hwcore/i8254.h> 027 #include <hwcore/i8254.h>
028 #include <sos/list.h> 028 #include <sos/list.h>
029 #include <sos/physmem.h> 029 #include <sos/physmem.h>
030 #include <hwcore/paging.h> 030 #include <hwcore/paging.h>
031 #include <hwcore/mm_context.h> 031 #include <hwcore/mm_context.h>
032 #include <hwcore/swintr.h> 032 #include <hwcore/swintr.h>
033 #include <sos/kmem_vmm.h> 033 #include <sos/kmem_vmm.h>
034 #include <sos/kmalloc.h> 034 #include <sos/kmalloc.h>
035 #include <sos/time.h> 035 #include <sos/time.h>
036 #include <sos/thread.h> 036 #include <sos/thread.h>
037 #include <sos/process.h> 037 #include <sos/process.h>
038 #include <sos/umem_vmm.h> 038 #include <sos/umem_vmm.h>
039 #include <sos/klibc.h> 039 #include <sos/klibc.h>
040 #include <sos/assert.h> 040 #include <sos/assert.h>
041 #include <drivers/x86_videomem.h> 041 #include <drivers/x86_videomem.h>
042 #include <drivers/bochs.h> 042 #include <drivers/bochs.h>
043 #include <sos/calcload.h> 043 #include <sos/calcload.h>
044 #include <sos/umem_vmm.h> 044 #include <sos/umem_vmm.h>
045 #include <sos/binfmt_elf32.h> 045 #include <sos/binfmt_elf32.h>
046 #include <drivers/zero.h> 046 #include <drivers/zero.h>
047 #include <sos/fs.h> 047 #include <sos/fs.h>
048 #include <drivers/fs_virtfs.h> 048 #include <drivers/fs_virtfs.h>
>> 049 #include <drivers/devices.h>
>> 050 #include <drivers/mem.h>
>> 051 #include <drivers/tty.h>
>> 052 #include <drivers/console.h>
>> 053 #include <drivers/serial.h>
049 054
050 055
051 056
052 void display_bits(unsigned char row, unsigned 057 void display_bits(unsigned char row, unsigned char col,
053 unsigned char attribute, 058 unsigned char attribute,
054 sos_ui32_t integer) 059 sos_ui32_t integer)
055 { 060 {
056 int i; 061 int i;
057 062
058 for (i = 31 ; i >= 0 ; i--) 063 for (i = 31 ; i >= 0 ; i--)
059 { 064 {
060 065
061 int bit_i = (integer & (1 << i)); 066 int bit_i = (integer & (1 << i));
062 067
063 unsigned char ascii_code = bit_i?219:177 068 unsigned char ascii_code = bit_i?219:177;
064 sos_x86_videomem_putchar(row, col++, 069 sos_x86_videomem_putchar(row, col++,
065 attribute, 070 attribute,
066 ascii_code); 071 ascii_code);
067 } 072 }
068 } 073 }
069 074
070 075
071 static void clk_it(int intid) 076 static void clk_it(int intid)
072 { 077 {
073 static sos_ui32_t clock_count = 0; 078 static sos_ui32_t clock_count = 0;
074 079
075 display_bits(0, 48, 080 display_bits(0, 48,
076 SOS_X86_VIDEO_FG_LTGREEN | SOS_ 081 SOS_X86_VIDEO_FG_LTGREEN | SOS_X86_VIDEO_BG_BLUE,
077 clock_count); 082 clock_count);
078 clock_count++; 083 clock_count++;
079 084
080 085
081 sos_time_do_tick(); 086 sos_time_do_tick();
082 087
083 088
084 sos_sched_do_timer_tick(); 089 sos_sched_do_timer_tick();
085 } 090 }
086 091
087 092
088 093
089 094
090 095
091 096
092 097
093 098
094 static void pgflt_ex(int intid, struct sos_cpu 099 static void pgflt_ex(int intid, struct sos_cpu_state *ctxt)
095 { 100 {
096 static sos_ui32_t demand_paging_count = 0; 101 static sos_ui32_t demand_paging_count = 0;
097 struct sos_thread * cur_thr = sos_thread_get 102 struct sos_thread * cur_thr = sos_thread_get_current();
098 sos_vaddr_t faulting_vaddr = sos_cpu_contex 103 sos_vaddr_t faulting_vaddr = sos_cpu_context_get_EX_faulting_vaddr(ctxt);
099 sos_paddr_t ppage_paddr; 104 sos_paddr_t ppage_paddr;
100 105
101 if (sos_cpu_context_is_in_user_mode(ctxt) 106 if (sos_cpu_context_is_in_user_mode(ctxt)
102 || (cur_thr->fixup_uaccess.return_vaddr) 107 || (cur_thr->fixup_uaccess.return_vaddr))
103 { 108 {
104 __label__ unforce_address_space; 109 __label__ unforce_address_space;
105 sos_bool_t need_to_setup_mmu; 110 sos_bool_t need_to_setup_mmu;
106 sos_ui32_t errcode = sos_cpu_context_get 111 sos_ui32_t errcode = sos_cpu_context_get_EX_info(ctxt);
107 112
108 113
109 114
110 need_to_setup_mmu = (cur_thr->squatted_m 115 need_to_setup_mmu = (cur_thr->squatted_mm_context
111 != sos_process_get_ 116 != sos_process_get_mm_context(cur_thr->process));
112 if (need_to_setup_mmu) 117 if (need_to_setup_mmu)
113 sos_thread_prepare_user_space_access(N 118 sos_thread_prepare_user_space_access(NULL, 0);
114 119
115 if (SOS_OK == 120 if (SOS_OK ==
116 sos_umem_vmm_try_resolve_page_fault( 121 sos_umem_vmm_try_resolve_page_fault(faulting_vaddr,
117 122 errcode & (1 << 1),
118 123 TRUE))
119 goto unforce_address_space; 124 goto unforce_address_space;
120 125
121 126
122 127
123 if (! sos_cpu_context_is_in_user_mode(ct 128 if (! sos_cpu_context_is_in_user_mode(ctxt))
124 { 129 {
125 cur_thr->fixup_uaccess.faulted_uaddr 130 cur_thr->fixup_uaccess.faulted_uaddr = faulting_vaddr;
126 sos_cpu_context_set_EX_return_addres 131 sos_cpu_context_set_EX_return_address(ctxt,
127 132 cur_thr->fixup_uaccess.return_vaddr);
128 goto unforce_address_space; 133 goto unforce_address_space;
129 } 134 }
130 135
131 if (need_to_setup_mmu) 136 if (need_to_setup_mmu)
132 sos_thread_end_user_space_access(); 137 sos_thread_end_user_space_access();
133 138
134 sos_bochs_printf("Unresolved USER page F 139 sos_bochs_printf("Unresolved USER page Fault at instruction 0x%x on access to address 0x%x (info=%x)!\n",
135 sos_cpu_context_get_PC( 140 sos_cpu_context_get_PC(ctxt),
136 (unsigned)faulting_vadd 141 (unsigned)faulting_vaddr,
137 (unsigned)sos_cpu_conte 142 (unsigned)sos_cpu_context_get_EX_info(ctxt));
138 sos_bochs_printf("Terminating User threa 143 sos_bochs_printf("Terminating User thread\n");
139 sos_thread_exit(); 144 sos_thread_exit();
140 145
141 unforce_address_space: 146 unforce_address_space:
142 if (need_to_setup_mmu) 147 if (need_to_setup_mmu)
143 sos_thread_end_user_space_access(); 148 sos_thread_end_user_space_access();
144 return; 149 return;
145 } 150 }
146 151
147 152
148 if (! sos_kmem_vmm_is_valid_vaddr(faulting_v 153 if (! sos_kmem_vmm_is_valid_vaddr(faulting_vaddr))
149 { 154 {
150 155
151 156
152 sos_display_fatal_error("Unresolved page 157 sos_display_fatal_error("Unresolved page Fault at instruction 0x%x on access to address 0x%x (info=%x)!",
153 sos_cpu_context_ 158 sos_cpu_context_get_PC(ctxt),
154 (unsigned)faulti 159 (unsigned)faulting_vaddr,
155 (unsigned)sos_cp 160 (unsigned)sos_cpu_context_get_EX_info(ctxt));
156 SOS_ASSERT_FATAL(! "Got page fault (note 161 SOS_ASSERT_FATAL(! "Got page fault (note: demand paging is disabled)");
157 } 162 }
158 163
159 164
160 165
161 166
162 167
163 168
164 169
165 demand_paging_count ++; 170 demand_paging_count ++;
166 display_bits(0, 0, 171 display_bits(0, 0,
167 SOS_X86_VIDEO_FG_LTRED | SOS_X8 172 SOS_X86_VIDEO_FG_LTRED | SOS_X86_VIDEO_BG_BLUE,
168 demand_paging_count); 173 demand_paging_count);
169 174
170 175
171 ppage_paddr = sos_physmem_ref_physpage_new(F 176 ppage_paddr = sos_physmem_ref_physpage_new(FALSE);
172 if (! ppage_paddr) 177 if (! ppage_paddr)
173 SOS_ASSERT_FATAL(! "TODO: implement swap. 178 SOS_ASSERT_FATAL(! "TODO: implement swap. (Out of mem in demand paging because no swap for kernel yet !)");
174 SOS_ASSERT_FATAL(SOS_OK == sos_paging_map(pp 179 SOS_ASSERT_FATAL(SOS_OK == sos_paging_map(ppage_paddr,
175 SO 180 SOS_PAGE_ALIGN_INF(faulting_vaddr),
176 FA 181 FALSE,
177 SO 182 SOS_VM_MAP_PROT_READ
178 | 183 | SOS_VM_MAP_PROT_WRITE
179 | 184 | SOS_VM_MAP_ATOMIC));
180 sos_physmem_unref_physpage(ppage_paddr); 185 sos_physmem_unref_physpage(ppage_paddr);
181 186
182 187
183 } 188 }
184 189
185 190
186 191
187 192
188 193
189 194
190 195
191 static void idle_thread() 196 static void idle_thread()
192 { 197 {
193 sos_ui32_t idle_twiddle = 0; 198 sos_ui32_t idle_twiddle = 0;
194 199
195 while (1) 200 while (1)
196 { 201 {
197 202
198 203
199 asm("hlt\n"); 204 asm("hlt\n");
200 205
201 idle_twiddle ++; 206 idle_twiddle ++;
202 display_bits(0, 0, SOS_X86_VIDEO_FG_GREE 207 display_bits(0, 0, SOS_X86_VIDEO_FG_GREEN | SOS_X86_VIDEO_BG_BLUE,
203 idle_twiddle); 208 idle_twiddle);
204 209
205 210
206 sos_thread_yield(); 211 sos_thread_yield();
207 } 212 }
208 } 213 }
209 214
210 215
211 216
212 217
213 218
>> 219 #define LOAD_DISPLAY_BASELINE 4
>> 220 #define LOAD_DISPLAY_STARTROW 34
214 static void stat_thread() 221 static void stat_thread()
215 { 222 {
216 while (1) 223 while (1)
217 { 224 {
218 sos_ui32_t flags; 225 sos_ui32_t flags;
219 sos_ui32_t load1, load5, load15; 226 sos_ui32_t load1, load5, load15;
220 char str1[11], str5[11], str15[11]; 227 char str1[11], str5[11], str15[11];
221 struct sos_time t; 228 struct sos_time t;
222 t.sec = 1; 229 t.sec = 1;
223 t.nanosec = 0; 230 t.nanosec = 0;
224 231
225 sos_thread_sleep(& t); 232 sos_thread_sleep(& t);
226 233
227 sos_disable_IRQs(flags); 234 sos_disable_IRQs(flags);
228 235
229 236
230 sos_load_get_sload(&load1, &load5, &load 237 sos_load_get_sload(&load1, &load5, &load15);
231 sos_load_to_string(str1, load1); 238 sos_load_to_string(str1, load1);
232 sos_load_to_string(str5, load5); 239 sos_load_to_string(str5, load5);
233 sos_load_to_string(str15, load15); 240 sos_load_to_string(str15, load15);
234 sos_x86_videomem_printf(16, 34, !! 241 sos_x86_videomem_printf(LOAD_DISPLAY_BASELINE+0, LOAD_DISPLAY_STARTROW,
235 SOS_X86_VIDEO_FG 242 SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
236 "Kernel (- Idle) 243 "Kernel (- Idle): %s %s %s ",
237 str1, str5, str1 244 str1, str5, str15);
238 245
239 sos_load_get_uload(&load1, &load5, &load 246 sos_load_get_uload(&load1, &load5, &load15);
240 sos_load_to_string(str1, load1); 247 sos_load_to_string(str1, load1);
241 sos_load_to_string(str5, load5); 248 sos_load_to_string(str5, load5);
242 sos_load_to_string(str15, load15); 249 sos_load_to_string(str15, load15);
243 sos_x86_videomem_printf(17, 34, !! 250 sos_x86_videomem_printf(LOAD_DISPLAY_BASELINE+1, LOAD_DISPLAY_STARTROW,
244 SOS_X86_VIDEO_FG 251 SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
245 "User: %s %s %s 252 "User: %s %s %s ",
246 str1, str5, str1 253 str1, str5, str15);
247 254
248 sos_load_get_uratio(&load1, &load5, &loa 255 sos_load_get_uratio(&load1, &load5, &load15);
249 sos_load_to_string(str1, load1); 256 sos_load_to_string(str1, load1);
250 sos_load_to_string(str5, load5); 257 sos_load_to_string(str5, load5);
251 sos_load_to_string(str15, load15); 258 sos_load_to_string(str15, load15);
252 sos_x86_videomem_printf(18, 34, !! 259 sos_x86_videomem_printf(LOAD_DISPLAY_BASELINE+2, LOAD_DISPLAY_STARTROW,
253 SOS_X86_VIDEO_FG 260 SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
254 "User CPU %%: %s 261 "User CPU %%: %s %s %s ",
255 str1, str5, str1 262 str1, str5, str15);
256 263
257 264
258 sos_load_get_sratio(&load1, &load5, &loa 265 sos_load_get_sratio(&load1, &load5, &load15);
259 sos_load_to_string(str1, load1); 266 sos_load_to_string(str1, load1);
260 sos_load_to_string(str5, load5); 267 sos_load_to_string(str5, load5);
261 sos_load_to_string(str15, load15); 268 sos_load_to_string(str15, load15);
262 sos_x86_videomem_printf(19, 34, !! 269 sos_x86_videomem_printf(LOAD_DISPLAY_BASELINE+3, LOAD_DISPLAY_STARTROW,
263 SOS_X86_VIDEO_FG 270 SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
264 "Kernel CPU %% ( 271 "Kernel CPU %% (+ Idle): %s %s %s ",
265 str1, str5, str1 272 str1, str5, str15);
266 sos_restore_IRQs(flags); 273 sos_restore_IRQs(flags);
267 } 274 }
268 } 275 }
269 276
270 277
271 278
272 279
273 280
274 static sos_ret_t 281 static sos_ret_t
275 start_init(struct sos_fs_manager_instance * ro 282 start_init(struct sos_fs_manager_instance * rootfs)
276 { 283 {
277 sos_ret_t retval; 284 sos_ret_t retval;
278 struct sos_umem_vmm_as *as_init; 285 struct sos_umem_vmm_as *as_init;
279 struct sos_process *proc_init; 286 struct sos_process *proc_init;
280 struct sos_thread *new_thr; 287 struct sos_thread *new_thr;
281 sos_uaddr_t ustack, start_uaddr; 288 sos_uaddr_t ustack, start_uaddr;
282 struct sos_fs_opened_file * init_root, * ini 289 struct sos_fs_opened_file * init_root, * init_cwd, * unused_of;
283 290
284 291
285 proc_init = sos_process_create("init", FALSE 292 proc_init = sos_process_create("init", FALSE);
286 if (! proc_init) 293 if (! proc_init)
287 return -SOS_ENOMEM; 294 return -SOS_ENOMEM;
288 as_init = sos_process_get_address_space(proc 295 as_init = sos_process_get_address_space(proc_init);
289 296
290 297
291 298
292 299
293 300
294 301
295 302
296 retval = sos_fs_new_opened_file(proc_init, r 303 retval = sos_fs_new_opened_file(proc_init, rootfs->root,
297 SOS_FS_OPEN_ 304 SOS_FS_OPEN_READ | SOS_FS_OPEN_WRITE,
298 & init_root) 305 & init_root);
299 if (SOS_OK != retval) 306 if (SOS_OK != retval)
300 { 307 {
301 sos_process_unref(proc_init); 308 sos_process_unref(proc_init);
302 return -SOS_ENOENT; 309 return -SOS_ENOENT;
303 } 310 }
304 311
305 312
306 313
307 retval = sos_fs_duplicate_opened_file(init_r 314 retval = sos_fs_duplicate_opened_file(init_root, proc_init,
308 & init 315 & init_cwd);
309 if (SOS_OK != retval) 316 if (SOS_OK != retval)
310 { 317 {
311 sos_fs_close(init_root); 318 sos_fs_close(init_root);
312 sos_process_unref(proc_init); 319 sos_process_unref(proc_init);
313 return -SOS_ENOENT; 320 return -SOS_ENOENT;
314 } 321 }
315 322
316 323
317 if ( ( SOS_OK != sos_process_chroot(proc_ini 324 if ( ( SOS_OK != sos_process_chroot(proc_init, init_root, & unused_of) )
318 || ( SOS_OK != sos_process_chdir(proc_i 325 || ( SOS_OK != sos_process_chdir(proc_init, init_cwd, & unused_of) ) )
319 { 326 {
320 sos_fs_close(init_root); 327 sos_fs_close(init_root);
321 sos_fs_close(init_cwd); 328 sos_fs_close(init_cwd);
322 sos_process_chroot(proc_init, NULL, & un 329 sos_process_chroot(proc_init, NULL, & unused_of);
323 sos_process_chdir(proc_init, NULL, & unu 330 sos_process_chdir(proc_init, NULL, & unused_of);
324 sos_process_unref(proc_init); 331 sos_process_unref(proc_init);
325 return -SOS_ENOENT; 332 return -SOS_ENOENT;
326 } 333 }
327 334
>> 335
>> 336
328 337
329 start_uaddr = sos_binfmt_elf32_map(as_init, 338 start_uaddr = sos_binfmt_elf32_map(as_init, "init");
330 if (0 == start_uaddr) 339 if (0 == start_uaddr)
331 { 340 {
332 sos_process_unref(proc_init); 341 sos_process_unref(proc_init);
333 return -SOS_ENOENT; 342 return -SOS_ENOENT;
334 } 343 }
335 344
336 345
337 ustack = (SOS_PAGING_TOP_USER_ADDRESS - SOS_ 346 ustack = (SOS_PAGING_TOP_USER_ADDRESS - SOS_DEFAULT_USER_STACK_SIZE) + 1;
338 retval = sos_dev_zero_map(as_init, &ustack, 347 retval = sos_dev_zero_map(as_init, &ustack, SOS_DEFAULT_USER_STACK_SIZE,
339 SOS_VM_MAP_PROT_RE 348 SOS_VM_MAP_PROT_READ | SOS_VM_MAP_PROT_WRITE,
340 0); 349 0);
341 if (SOS_OK != retval) 350 if (SOS_OK != retval)
342 { 351 {
343 sos_process_unref(proc_init); 352 sos_process_unref(proc_init);
344 return -SOS_ENOMEM; 353 return -SOS_ENOMEM;
345 } 354 }
346 355
347 356
348 new_thr = sos_create_user_thread(NULL, 357 new_thr = sos_create_user_thread(NULL,
349 proc_init, 358 proc_init,
350 start_uaddr 359 start_uaddr,
351 0, 0, 360 0, 0,
352 ustack + SO 361 ustack + SOS_DEFAULT_USER_STACK_SIZE - 4,
353 SOS_SCHED_P 362 SOS_SCHED_PRIO_TS_LOWEST);
354 if (! new_thr) 363 if (! new_thr)
355 { 364 {
356 sos_process_unref(proc_init); 365 sos_process_unref(proc_init);
357 return -SOS_ENOMEM; 366 return -SOS_ENOMEM;
358 } 367 }
359 368
360 sos_process_unref(proc_init); 369 sos_process_unref(proc_init);
361 return SOS_OK; 370 return SOS_OK;
362 } 371 }
363 372
364 373
365 374
366 375
367 376
368 void sos_main(unsigned long magic, unsigned lo 377 void sos_main(unsigned long magic, unsigned long arg)
369 { 378 {
370 unsigned i; 379 unsigned i;
371 sos_paddr_t sos_kernel_core_base_paddr, sos_ 380 sos_paddr_t sos_kernel_core_base_paddr, sos_kernel_core_top_paddr;
372 struct sos_time tick_resolution; 381 struct sos_time tick_resolution;
373 struct sos_fs_manager_instance * rootfs; 382 struct sos_fs_manager_instance * rootfs;
374 383
375 384
376 unsigned long int upper_mem = 0; 385 unsigned long int upper_mem = 0;
377 386
378 387
379 sos_bochs_setup(); !! 388 sos_bochs_subsystem_setup();
380 389
381 sos_x86_videomem_setup(); 390 sos_x86_videomem_setup();
382 sos_x86_videomem_cls(SOS_X86_VIDEO_BG_BLUE); 391 sos_x86_videomem_cls(SOS_X86_VIDEO_BG_BLUE);
383 392
384 393
385 if (magic == MULTIBOOT_BOOTLOADER_MAGIC) 394 if (magic == MULTIBOOT_BOOTLOADER_MAGIC)
386 { 395 {
387 396
388 397
389 398
390 multiboot_info_t *mbi = (multiboot_info_ 399 multiboot_info_t *mbi = (multiboot_info_t *) arg;
391 400
392 401
393 402
394 403
395 404
396 upper_mem = mbi->mem_upper; 405 upper_mem = mbi->mem_upper;
397 sos_x86_videomem_printf(1, 0, 406 sos_x86_videomem_printf(1, 0,
398 SOS_X86_VIDEO_FG 407 SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
399 "Welcome From GR 408 "Welcome From GRUB to %s%c RAM is %dMB (upper mem = 0x%x kB)",
400 "SOS article 8", !! 409 "SOS article 9", ',',
401 (unsigned)(upper 410 (unsigned)(upper_mem >> 10) + 1,
402 (unsigned)upper_ 411 (unsigned)upper_mem);
403 } 412 }
404 else if (magic == 0x42244224) 413 else if (magic == 0x42244224)
405 { 414 {
406 415
407 upper_mem = arg; 416 upper_mem = arg;
408 sos_x86_videomem_printf(1, 0, 417 sos_x86_videomem_printf(1, 0,
409 SOS_X86_VIDEO_FG 418 SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
410 "Welcome to %s%c 419 "Welcome to %s%c RAM is %dMB (upper mem = 0x%x kB)",
411 "SOS article 8", !! 420 "SOS article 9", ',',
412 (unsigned)(upper 421 (unsigned)(upper_mem >> 10) + 1,
413 (unsigned)upper_ 422 (unsigned)upper_mem);
414 } 423 }
415 else 424 else
416 425
417 sos_x86_videomem_printf(1, 0, 426 sos_x86_videomem_printf(1, 0,
418 SOS_X86_VIDEO_FG_Y 427 SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
419 "Welcome to SOS ar !! 428 "Welcome to SOS article 9");
420 429
421 sos_bochs_putstring("Message in a bochs: Thi !! 430 sos_bochs_putstring("Message in a bochs: This is SOS article 9.\n");
422 431
423 432
424 sos_gdt_subsystem_setup(); 433 sos_gdt_subsystem_setup();
425 sos_idt_subsystem_setup(); 434 sos_idt_subsystem_setup();
426 435
427 436
428 sos_exception_subsystem_setup(); 437 sos_exception_subsystem_setup();
429 sos_irq_subsystem_setup(); 438 sos_irq_subsystem_setup();
430 439
431 440
432 sos_i8254_set_frequency(100); 441 sos_i8254_set_frequency(100);
433 442
434 443
435 444
436 tick_resolution = (struct sos_time) { .sec=0 445 tick_resolution = (struct sos_time) { .sec=0, .nanosec=10000000UL };
437 sos_time_subsysem_setup(& tick_resolution); 446 sos_time_subsysem_setup(& tick_resolution);
438 447
439 448
440 if (upper_mem == 0) 449 if (upper_mem == 0)
441 { 450 {
442 sos_x86_videomem_putstring(20, 0, 451 sos_x86_videomem_putstring(20, 0,
443 SOS_X86_VIDEO 452 SOS_X86_VIDEO_FG_LTRED
444 | SOS_X86_V 453 | SOS_X86_VIDEO_BG_BLUE
445 | SOS_X86_V 454 | SOS_X86_VIDEO_FG_BLINKING,
446 "I don't know 455 "I don't know RAM size ! Load me with Grub...");
447 456
448 for (;;) 457 for (;;)
449 continue; 458 continue;
450 } 459 }
451 460
452 461
453 462
454 463
455 464
456 465
457 sos_irq_set_routine(SOS_IRQ_TIMER, 466 sos_irq_set_routine(SOS_IRQ_TIMER,
458 clk_it); 467 clk_it);
459 468
460 469
461 470
462 471
463 472
464 SOS_ASSERT_FATAL(SOS_OK 473 SOS_ASSERT_FATAL(SOS_OK
465 == sos_physmem_subsystem_se 474 == sos_physmem_subsystem_setup((upper_mem<<10) + (1<<20),
466 475 &sos_kernel_core_base_paddr,
467 476 &sos_kernel_core_top_paddr));
468 477
469 478
470 479
471 480
472 481
473 482
474 483
475 SOS_ASSERT_FATAL(SOS_OK == 484 SOS_ASSERT_FATAL(SOS_OK ==
476 sos_paging_subsystem_setup( 485 sos_paging_subsystem_setup(sos_kernel_core_base_paddr,
477 486 sos_kernel_core_top_paddr));
478 487
479 488
480 sos_exception_set_routine(SOS_EXCEPT_PAGE_FA 489 sos_exception_set_routine(SOS_EXCEPT_PAGE_FAULT,
481 pgflt_ex); 490 pgflt_ex);
482 491
483 492
484 493
485 494
486 495
487 if (sos_kmem_vmm_subsystem_setup(sos_kernel_ 496 if (sos_kmem_vmm_subsystem_setup(sos_kernel_core_base_paddr,
488 sos_kernel_ 497 sos_kernel_core_top_paddr,
489 bootstrap_s 498 bootstrap_stack_bottom,
490 bootstrap_s 499 bootstrap_stack_bottom
491 + bootstrap 500 + bootstrap_stack_size))
492 sos_bochs_printf("Could not setup the Kern 501 sos_bochs_printf("Could not setup the Kernel virtual space allocator\n");
493 502
494 if (sos_kmalloc_subsystem_setup()) 503 if (sos_kmalloc_subsystem_setup())
495 sos_bochs_printf("Could not setup the Kmal 504 sos_bochs_printf("Could not setup the Kmalloc subsystem\n");
496 505
497 506
498 507
499 508
500 sos_mm_context_subsystem_setup(); 509 sos_mm_context_subsystem_setup();
501 510
502 511
503 512
504 513
505 sos_cpu_context_subsystem_setup(); 514 sos_cpu_context_subsystem_setup();
506 515
507 516
508 517
509 518
510 sos_swintr_subsystem_setup(); 519 sos_swintr_subsystem_setup();
511 520
512 521
513 522
514 523
515 524
516 525
517 526
518 sos_thread_subsystem_setup(bootstrap_stack_b 527 sos_thread_subsystem_setup(bootstrap_stack_bottom,
519 bootstrap_stack_s 528 bootstrap_stack_size);
520 529
521 530
522 sos_sched_subsystem_setup(); 531 sos_sched_subsystem_setup();
523 532
524 533
525 SOS_ASSERT_FATAL(sos_create_kernel_thread("i 534 SOS_ASSERT_FATAL(sos_create_kernel_thread("idle", idle_thread, NULL,
526 SO 535 SOS_SCHED_PRIO_TS_LOWEST) != NULL);
527 536
528 537
529 sos_load_subsystem_setup(); 538 sos_load_subsystem_setup();
530 539
531 540
532 SOS_ASSERT_FATAL(sos_create_kernel_thread("s 541 SOS_ASSERT_FATAL(sos_create_kernel_thread("stat_thread", stat_thread,
533 NU 542 NULL,
534 SO 543 SOS_SCHED_PRIO_TS_LOWEST) != NULL);
535 544
536 545
537 546
538 547
539 548
540 sos_umem_vmm_subsystem_setup(); 549 sos_umem_vmm_subsystem_setup();
541 sos_dev_zero_subsystem_setup(); 550 sos_dev_zero_subsystem_setup();
>> 551 sos_dev_mem_chardev_setup();
542 552
543 553
544 554
545 555
546 sos_process_subsystem_setup(); 556 sos_process_subsystem_setup();
547 557
548 558
549 559
550 560
551 asm volatile ("sti\n"); 561 asm volatile ("sti\n");
552 562
553 563
554 SOS_ASSERT_FATAL(SOS_OK == sos_fs_virtfs_sub 564 SOS_ASSERT_FATAL(SOS_OK == sos_fs_virtfs_subsystem_setup());
555 SOS_ASSERT_FATAL(SOS_OK == sos_fs_subsystem_ 565 SOS_ASSERT_FATAL(SOS_OK == sos_fs_subsystem_setup(NULL,
556 566 "virtfs",
557 567 NULL,
558 568 & rootfs));
>> 569
>> 570
>> 571 tty_subsystem_setup();
>> 572 sos_ttyS0_subsystem_setup();
>> 573 sos_console_subsystem_setup();
>> 574
>> 575
559 576
560 577
561 578
562 579
563 start_init(rootfs); 580 start_init(rootfs);
564 581
565 582
566 583
567 584
568 585
569 586
570 587
571 588
572 589
573 590
574 591
575 592
576 sos_bochs_printf("Bye from primary thread !\ 593 sos_bochs_printf("Bye from primary thread !\n");
577 sos_thread_exit(); 594 sos_thread_exit();
578 SOS_FATAL_ERROR("No trespassing !"); 595 SOS_FATAL_ERROR("No trespassing !");
579 } 596 }