Diff markup
001 001
002 <<
003 002
004 003
005 004
006 005
007 006
008 007
009 008
010 009
011 010
012 011
013 012
014 013
015 014
016 015
017 016
018 017
019 018
020 019
021 #include <bootstrap/multiboot.h> 020 #include <bootstrap/multiboot.h>
022 #include <hwcore/idt.h> 021 #include <hwcore/idt.h>
023 #include <hwcore/gdt.h> 022 #include <hwcore/gdt.h>
024 #include <hwcore/irq.h> 023 #include <hwcore/irq.h>
025 #include <hwcore/exception.h> 024 #include <hwcore/exception.h>
026 #include <hwcore/i8254.h> 025 #include <hwcore/i8254.h>
027 #include <sos/list.h> 026 #include <sos/list.h>
028 #include <sos/physmem.h> 027 #include <sos/physmem.h>
029 #include <hwcore/paging.h> 028 #include <hwcore/paging.h>
030 #include <sos/kmem_vmm.h> 029 #include <sos/kmem_vmm.h>
031 #include <sos/kmalloc.h> 030 #include <sos/kmalloc.h>
>> 031 #include <sos/time.h>
>> 032 #include <sos/thread.h>
032 #include <sos/klibc.h> 033 #include <sos/klibc.h>
033 #include <sos/assert.h> 034 #include <sos/assert.h>
034 #include <drivers/x86_videomem.h> 035 #include <drivers/x86_videomem.h>
035 #include <drivers/bochs.h> 036 #include <drivers/bochs.h>
036 037
037 038
038 039
039 040
040 static void display_bits(unsigned char row, un !! 041 void display_bits(unsigned char row, unsigned char col,
041 unsigned char attribu !! 042 unsigned char attribute,
042 sos_ui32_t integer) !! 043 sos_ui32_t integer)
043 { 044 {
044 int i; 045 int i;
045 046
046 for (i = 31 ; i >= 0 ; i--) 047 for (i = 31 ; i >= 0 ; i--)
047 { 048 {
048 049
049 int bit_i = (integer & (1 << i)); 050 int bit_i = (integer & (1 << i));
050 051
051 unsigned char ascii_code = bit_i?219:177 052 unsigned char ascii_code = bit_i?219:177;
052 sos_x86_videomem_putchar(row, col++, 053 sos_x86_videomem_putchar(row, col++,
053 attribute, 054 attribute,
054 ascii_code); 055 ascii_code);
055 } 056 }
056 } 057 }
057 058
058 059
059 060
060 static void clk_it(int intid) 061 static void clk_it(int intid)
061 { 062 {
062 static sos_ui32_t clock_count = 0; 063 static sos_ui32_t clock_count = 0;
063 064
064 display_bits(0, 48, 065 display_bits(0, 48,
065 SOS_X86_VIDEO_FG_LTGREEN | SOS_ 066 SOS_X86_VIDEO_FG_LTGREEN | SOS_X86_VIDEO_BG_BLUE,
066 clock_count); 067 clock_count);
067 clock_count++; 068 clock_count++;
068 069
>> 070
>> 071 sos_time_do_tick();
069 } 072 }
070 struct digit <<
071 { <<
072 struct digit *prev, *next; <<
073 char value; <<
074 }; <<
075 <<
076 <<
077 <<
078 <<
079 typedef struct digit * big_number_t; <<
080 073
081 074
082 !! 075
083 void bn_push_lsd(big_number_t * bn, char value !! 076
084 { !! 077
085 struct digit *d; !! 078
086 d = (struct digit*) sos_kmalloc(sizeof(struc !! 079
087 SOS_ASSERT_FATAL(d != NULL); !! 080 static void dump_backtrace(const struct sos_cpu_state *cpu_state,
088 d->value = value; !! 081 sos_vaddr_t stack_bottom,
089 list_add_tail(*bn, d); !! 082 sos_size_t stack_size,
090 } !! 083 sos_bool_t on_console,
>> 084 sos_bool_t on_bochs)
>> 085 {
>> 086 static void backtracer(sos_vaddr_t PC,
>> 087 sos_vaddr_t params,
>> 088 sos_ui32_t depth,
>> 089 void *custom_arg)
>> 090 {
>> 091 sos_ui32_t invalid = 0xffffffff, *arg1, *arg2, *arg3, *arg4;
>> 092
>> 093
>> 094
>> 095
>> 096
>> 097 arg1 = (sos_ui32_t*)params;
>> 098 arg2 = (sos_ui32_t*)(params+4);
>> 099 arg3 = (sos_ui32_t*)(params+8);
>> 100 arg4 = (sos_ui32_t*)(params+12);
>> 101
>> 102
>> 103
>> 104 #define INTERVAL_OK(b,v,u) ( ((b) <= (sos_vaddr_t)(v)) \
>> 105 && ((sos_vaddr_t)(v) < (u)) )
>> 106 if (!INTERVAL_OK(stack_bottom, arg1, stack_bottom + stack_size))
>> 107 arg1 = &invalid;
>> 108 if (!INTERVAL_OK(stack_bottom, arg2, stack_bottom + stack_size))
>> 109 arg2 = &invalid;
>> 110 if (!INTERVAL_OK(stack_bottom, arg3, stack_bottom + stack_size))
>> 111 arg3 = &invalid;
>> 112 if (!INTERVAL_OK(stack_bottom, arg4, stack_bottom + stack_size))
>> 113 arg4 = &invalid;
>> 114
>> 115
>> 116 if (on_bochs)
>> 117 sos_bochs_printf("[%d] PC=0x%x arg1=0x%x arg2=0x%x arg3=0x%x\n",
>> 118 (unsigned)depth, (unsigned)PC,
>> 119 (unsigned)*arg1, (unsigned)*arg2,
>> 120 (unsigned)*arg3);
>> 121
>> 122 if (on_console)
>> 123 sos_x86_videomem_printf(23-depth, 3,
>> 124 SOS_X86_VIDEO_BG_BLUE
>> 125 | SOS_X86_VIDEO_FG_LTGREEN,
>> 126 "[%d] PC=0x%x arg1=0x%x arg2=0x%x arg3=0x%x arg4=0x%x",
>> 127 (unsigned)depth, PC,
>> 128 (unsigned)*arg1, (unsigned)*arg2,
>> 129 (unsigned)*arg3, (unsigned)*arg4);
>> 130
>> 131 }
>> 132
>> 133 sos_backtrace(cpu_state, 15, stack_bottom, stack_size, backtracer, NULL);
>> 134 }
>> 135
>> 136
>> 137
>> 138 static void pgflt_ex(int intid, const struct sos_cpu_state *ctxt)
>> 139 {
>> 140 static sos_ui32_t demand_paging_count = 0;
>> 141 sos_vaddr_t faulting_vaddr = sos_cpu_context_get_EX_faulting_vaddr(ctxt);
>> 142 sos_paddr_t ppage_paddr;
>> 143
>> 144
>> 145 if (! sos_kmem_vmm_is_valid_vaddr(faulting_vaddr))
>> 146 {
>> 147
>> 148
>> 149 dump_backtrace(ctxt,
>> 150 bootstrap_stack_bottom,
>> 151 bootstrap_stack_size,
>> 152 TRUE, TRUE);
>> 153 sos_display_fatal_error("Unresolved page Fault at instruction 0x%x on access to address 0x%x (info=%x)!",
>> 154 sos_cpu_context_get_PC(ctxt),
>> 155 (unsigned)faulting_vaddr,
>> 156 (unsigned)sos_cpu_context_get_EX_info(ctxt));
>> 157 SOS_ASSERT_FATAL(! "Got page fault (note: demand paging is disabled)");
>> 158 }
091 159
092 160
093 !! 161
094 void bn_push_msd(big_number_t * bn, char value !! 162
095 { !! 163
096 struct digit *d; !! 164
097 d = (struct digit*) sos_kmalloc(sizeof(struc !! 165
098 SOS_ASSERT_FATAL(d != NULL); !! 166 demand_paging_count ++;
099 d->value = value; !! 167 display_bits(0, 0,
100 list_add_head(*bn, d); !! 168 SOS_X86_VIDEO_FG_LTRED | SOS_X86_VIDEO_BG_BLUE,
>> 169 demand_paging_count);
>> 170
>> 171
>> 172 ppage_paddr = sos_physmem_ref_physpage_new(FALSE);
>> 173 if (! ppage_paddr)
>> 174 SOS_ASSERT_FATAL(! "TODO: implement swap. (Out of mem in demand paging because no swap for kernel yet !)");
>> 175 SOS_ASSERT_FATAL(SOS_OK == sos_paging_map(ppage_paddr,
>> 176 SOS_PAGE_ALIGN_INF(faulting_vaddr),
>> 177 FALSE,
>> 178 SOS_VM_MAP_PROT_READ
>> 179 | SOS_VM_MAP_PROT_WRITE
>> 180 | SOS_VM_MAP_ATOMIC));
>> 181 sos_physmem_unref_physpage(ppage_paddr);
>> 182
>> 183
101 } 184 }
102 185
103 186
104 !! 187
105 big_number_t bn_new(unsigned long int i) !! 188
106 { !! 189
107 big_number_t retval; !! 190
108 !! 191
109 list_init(retval); !! 192
110 do <<
111 { <<
112 bn_push_msd(&retval, i%10); <<
113 i /= 10; <<
114 } <<
115 while (i != 0); <<
116 <<
117 return retval; <<
118 } <<
119 <<
120 193
121 !! 194 struct thr_arg
122 big_number_t bn_copy(const big_number_t bn) <<
123 { 195 {
124 big_number_t retval; !! 196 char character;
125 int nb_elts; !! 197 int color;
126 struct digit *d; <<
127 198
128 list_init(retval); !! 199 int col;
129 list_foreach(bn, d, nb_elts) !! 200 int row;
130 { !! 201 };
131 bn_push_lsd(&retval, d->value); <<
132 } <<
133 <<
134 return retval; <<
135 } <<
136 202
137 203
138 !! 204 static void demo_thread(void *arg)
139 void bn_del(big_number_t * bn) <<
140 { 205 {
141 struct digit *d; !! 206 struct thr_arg *thr_arg = (struct thr_arg*)arg;
>> 207 int progress = 0;
142 208
143 list_collapse(*bn, d) !! 209 sos_bochs_printf("start %c", thr_arg->character);
>> 210 while (1)
144 { 211 {
145 sos_kfree((sos_vaddr_t)d); !! 212 progress ++;
146 } !! 213 display_bits(thr_arg->row, thr_arg->col+1, thr_arg->color, progress);
147 } <<
148 <<
149 214
150 !! 215 sos_bochs_putchar(thr_arg->character);
151 void bn_shift(big_number_t *bn, int shift) <<
152 { <<
153 for ( ; shift > 0 ; shift --) <<
154 { <<
155 bn_push_lsd(bn, 0); <<
156 } <<
157 } <<
158 216
>> 217
>> 218 if ((random() % 100) == 0)
>> 219 {
>> 220 sos_bochs_printf("[37myield(%c)[m\n", thr_arg->character);
>> 221 sos_x86_videomem_putchar(thr_arg->row, thr_arg->col, 0x1e, 'Y');
>> 222 SOS_ASSERT_FATAL(SOS_OK == sos_thread_yield());
>> 223 sos_x86_videomem_putchar(thr_arg->row, thr_arg->col, 0x1e, 'R');
>> 224 }
159 225
160 !! 226
161 void bn_print_bochs(const big_number_t bn) !! 227 else if ((random() % 200) == 0)
162 { !! 228 {
163 int nb_elts; !! 229 struct sos_time t = (struct sos_time){ .sec=0, .nanosec=50000000 };
164 const struct digit *d; !! 230 sos_bochs_printf("[37msleep1(%c)[m\n", thr_arg->character);
165 !! 231 sos_x86_videomem_putchar(thr_arg->row, thr_arg->col, 0x1e, 's');
166 if (list_is_empty(bn)) !! 232 SOS_ASSERT_FATAL(SOS_OK == sos_thread_sleep(& t));
167 sos_bochs_printf("0"); !! 233 SOS_ASSERT_FATAL(sos_time_is_zero(& t));
168 else !! 234 sos_x86_videomem_putchar(thr_arg->row, thr_arg->col, 0x1e, 'R');
169 list_foreach(bn, d, nb_elts) !! 235 }
170 sos_bochs_printf("%d", d->value); <<
171 } <<
172 <<
173 <<
174 void bn_print_console(unsigned char row, unsig <<
175 unsigned char attribute, <<
176 const big_number_t bn, <<
177 int nb_decimals) <<
178 { <<
179 if (list_is_empty(bn)) <<
180 sos_x86_videomem_printf(row, col, attribut <<
181 else <<
182 { <<
183 int nb_elts; <<
184 const struct digit *d; <<
185 unsigned char x = col; <<
186 236
187 list_foreach(bn, d, nb_elts) !! 237
>> 238 else if ((random() % 300) == 0)
188 { 239 {
189 if (nb_elts == 0) !! 240 struct sos_time t = (struct sos_time){ .sec=0, .nanosec=300000000 };
190 { !! 241 sos_bochs_printf("[37msleep2(%c)[m\n", thr_arg->character);
191 sos_x86_videomem_printf(row, x, !! 242 sos_x86_videomem_putchar(thr_arg->row, thr_arg->col, 0x1e, 'S');
192 x += 2; !! 243 SOS_ASSERT_FATAL(SOS_OK == sos_thread_sleep(& t));
193 } !! 244 SOS_ASSERT_FATAL(sos_time_is_zero(& t));
194 else if (nb_elts < nb_decimals) !! 245 sos_x86_videomem_putchar(thr_arg->row, thr_arg->col, 0x1e, 'R');
195 { <<
196 sos_x86_videomem_printf(row, x, <<
197 x ++; <<
198 } <<
199 } 246 }
200 247
201 sos_x86_videomem_printf(row, x, attribut !! 248
202 } 249 }
203 } 250 }
204 251
205 252
206 !! 253 static void test_thread()
207 big_number_t bn_add (const big_number_t bn1, c <<
208 { 254 {
209 big_number_t retval; !! 255
210 const struct digit *d1, *d2; !! 256
211 sos_bool_t bn1_end = FALSE, bn2_end = FALSE !! 257 static struct thr_arg arg_b, arg_c, arg_d, arg_e, arg_R, arg_S;
212 char carry = 0; !! 258 sos_ui32_t flags;
213 <<
214 list_init(retval); <<
215 d1 = list_get_tail(bn1); <<
216 bn1_end = list_is_empty(bn1); <<
217 d2 = list_get_tail(bn2); <<
218 bn2_end = list_is_empty(bn2); <<
219 do <<
220 { <<
221 if (! bn1_end) <<
222 carry += d1->value; <<
223 if (! bn2_end) <<
224 carry += d2->value; <<
225 <<
226 bn_push_msd(&retval, carry % 10); <<
227 carry /= 10; <<
228 <<
229 if (! bn1_end) <<
230 d1 = d1->prev; <<
231 if (! bn2_end) <<
232 d2 = d2->prev; <<
233 if (d1 == list_get_tail(bn1)) <<
234 bn1_end = TRUE; <<
235 if (d2 == list_get_tail(bn2)) <<
236 bn2_end = TRUE; <<
237 } <<
238 while (!bn1_end || !bn2_end); <<
239 259
240 if (carry > 0) !! 260 sos_disable_IRQs(flags);
241 { <<
242 bn_push_msd(&retval, carry); <<
243 } <<
244 261
245 return retval; !! 262 arg_b = (struct thr_arg) { .character='b', .col=0, .row=21, .color=0x14 };
246 } !! 263 sos_create_kernel_thread("YO[b]", demo_thread, (void*)&arg_b);
247 264
>> 265 arg_c = (struct thr_arg) { .character='c', .col=46, .row=21, .color=0x14 };
>> 266 sos_create_kernel_thread("YO[c]", demo_thread, (void*)&arg_c);
248 267
249 !! 268 arg_d = (struct thr_arg) { .character='d', .col=0, .row=20, .color=0x14 };
250 big_number_t bn_muli (const big_number_t bn, c !! 269 sos_create_kernel_thread("YO[d]", demo_thread, (void*)&arg_d);
251 { <<
252 big_number_t retval; <<
253 int nb_elts; <<
254 char carry = 0; <<
255 const struct digit *d; <<
256 270
257 list_init(retval); !! 271 arg_e = (struct thr_arg) { .character='e', .col=0, .row=19, .color=0x14 };
258 list_foreach_backward(bn, d, nb_elts) !! 272 sos_create_kernel_thread("YO[e]", demo_thread, (void*)&arg_e);
259 { <<
260 carry += d->value * digit; <<
261 bn_push_msd(&retval, carry % 10); <<
262 carry /= 10; <<
263 } <<
264 273
265 if (carry > 0) !! 274 arg_R = (struct thr_arg) { .character='R', .col=0, .row=17, .color=0x1c };
266 { !! 275 sos_create_kernel_thread("YO[R]", demo_thread, (void*)&arg_R);
267 bn_push_msd(&retval, carry); !! 276
268 } !! 277 arg_S = (struct thr_arg) { .character='S', .col=0, .row=16, .color=0x1c };
>> 278 sos_create_kernel_thread("YO[S]", demo_thread, (void*)&arg_S);
269 279
270 return retval; !! 280 sos_restore_IRQs(flags);
271 } 281 }
272 282
273 283
274 !! 284
275 big_number_t bn_mult(const big_number_t bn1, c !! 285
>> 286
>> 287
>> 288 static void idle_thread()
276 { 289 {
277 int shift = 0; !! 290 sos_ui32_t idle_twiddle = 0;
278 big_number_t retval; <<
279 int nb_elts; <<
280 struct digit *d; <<
281 291
282 list_init(retval); !! 292 while (1)
283 list_foreach_backward(bn2, d, nb_elts) <<
284 { 293 {
285 big_number_t retmult = bn_muli(bn1, d->v !! 294
286 big_number_t old_retval = retval; !! 295
287 bn_shift(& retmult, shift); !! 296 asm("hlt\n");
288 retval = bn_add(old_retval, retmult); <<
289 bn_del(& retmult); <<
290 bn_del(& old_retval); <<
291 shift ++; <<
292 } <<
293 <<
294 return retval; <<
295 } <<
296 297
297 !! 298 idle_twiddle ++;
298 !! 299 display_bits(0, 0, SOS_X86_VIDEO_FG_GREEN | SOS_X86_VIDEO_BG_BLUE,
299 big_number_t bn_fact(unsigned long int v) !! 300 idle_twiddle);
300 { !! 301
301 unsigned long int i; !! 302
302 big_number_t retval = bn_new(1); !! 303 sos_thread_yield();
303 for (i = 1 ; i <= v ; i++) <<
304 { <<
305 big_number_t I = bn_new(i); <<
306 big_number_t tmp = bn_mult(retval, I); <<
307 sos_x86_videomem_printf(4, 0, <<
308 SOS_X86_VIDEO_BG <<
309 "%d! = ", (int)i <<
310 bn_print_console(4, 8, SOS_X86_VIDEO_BG_ <<
311 tmp, 55); <<
312 bn_del(& I); <<
313 bn_del(& retval); <<
314 retval = tmp; <<
315 } 304 }
316 <<
317 return retval; <<
318 } 305 }
319 306
320 307
321 void bn_test() !! 308
322 { !! 309
323 big_number_t bn = bn_fact(1000); !! 310
324 sos_bochs_printf("1000! = "); <<
325 bn_print_bochs(bn); <<
326 sos_bochs_printf("\n"); <<
327 <<
328 } <<
329 <<
330 <<
331 <<
332 void sos_main(unsigned long magic, unsigned lo 311 void sos_main(unsigned long magic, unsigned long addr)
333 { 312 {
334 unsigned i; 313 unsigned i;
335 sos_paddr_t sos_kernel_core_base_paddr, sos_ 314 sos_paddr_t sos_kernel_core_base_paddr, sos_kernel_core_top_paddr;
>> 315 struct sos_time tick_resolution;
336 316
337 317
338 318
339 319
340 multiboot_info_t *mbi; 320 multiboot_info_t *mbi;
341 mbi = (multiboot_info_t *) addr; 321 mbi = (multiboot_info_t *) addr;
342 322
343 323
344 sos_bochs_setup(); 324 sos_bochs_setup();
345 325
346 sos_x86_videomem_setup(); 326 sos_x86_videomem_setup();
347 sos_x86_videomem_cls(SOS_X86_VIDEO_BG_BLUE); 327 sos_x86_videomem_cls(SOS_X86_VIDEO_BG_BLUE);
348 328
349 329
350 if (magic == MULTIBOOT_BOOTLOADER_MAGIC) 330 if (magic == MULTIBOOT_BOOTLOADER_MAGIC)
351 331
352 sos_x86_videomem_printf(1, 0, 332 sos_x86_videomem_printf(1, 0,
353 SOS_X86_VIDEO_FG_Y 333 SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
354 "Welcome From GRUB 334 "Welcome From GRUB to %s%c RAM is %dMB (upper mem = 0x%x kB)",
355 "SOS", ',', !! 335 "SOS article 6.5", ',',
356 (unsigned)(mbi->me 336 (unsigned)(mbi->mem_upper >> 10) + 1,
357 (unsigned)mbi->mem 337 (unsigned)mbi->mem_upper);
358 else 338 else
359 339
360 sos_x86_videomem_printf(1, 0, 340 sos_x86_videomem_printf(1, 0,
361 SOS_X86_VIDEO_FG_Y 341 SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
362 "Welcome to SOS"); !! 342 "Welcome to SOS article 6.5");
363 343
364 sos_bochs_putstring("Message in a bochs\n"); !! 344 sos_bochs_putstring("Message in a bochs: This is SOS article 6.5.\n");
365 345
366 346
367 sos_gdt_setup(); !! 347 sos_gdt_subsystem_setup();
368 sos_idt_setup(); !! 348 sos_idt_subsystem_setup();
369 349
370 350
371 sos_exceptions_setup(); !! 351 sos_exception_subsystem_setup();
372 sos_irq_setup(); !! 352 sos_irq_subsystem_setup();
373 353
374 354
375 sos_i8254_set_frequency(100); 355 sos_i8254_set_frequency(100);
376 356
>> 357
>> 358
>> 359 tick_resolution = (struct sos_time) { .sec=0, .nanosec=10000000UL };
>> 360 sos_time_subsysem_setup(& tick_resolution);
377 361
378 362
379 if (magic != MULTIBOOT_BOOTLOADER_MAGIC) 363 if (magic != MULTIBOOT_BOOTLOADER_MAGIC)
380 { 364 {
381 sos_x86_videomem_putstring(20, 0, 365 sos_x86_videomem_putstring(20, 0,
382 SOS_X86_VIDEO 366 SOS_X86_VIDEO_FG_LTRED
383 | SOS_X86_V 367 | SOS_X86_VIDEO_BG_BLUE
384 | SOS_X86_V 368 | SOS_X86_VIDEO_FG_BLINKING,
385 "I'm not load 369 "I'm not loaded with Grub !");
386 370
387 for (;;) 371 for (;;)
388 continue; 372 continue;
389 } 373 }
390 374
>> 375
>> 376
>> 377
>> 378
391 379
392 sos_irq_set_routine(SOS_IRQ_TIMER, 380 sos_irq_set_routine(SOS_IRQ_TIMER,
393 clk_it); !! 381 clk_it);
394 !! 382
395 !! 383
396 asm volatile ("sti\n"); !! 384
>> 385
>> 386
397 387
398 388
399 389
400 sos_physmem_setup((mbi->mem_upper<<10) + (1< !! 390 sos_physmem_subsystem_setup((mbi->mem_upper<<10) + (1<<20),
401 & sos_kernel_core_base_pad !! 391 & sos_kernel_core_base_paddr,
402 & sos_kernel_core_top_padd !! 392 & sos_kernel_core_top_paddr);
403 393
404 394
405 395
406 396
407 397
408 398
409 399
410 if (sos_paging_setup(sos_kernel_core_base_pa !! 400 SOS_ASSERT_FATAL(SOS_OK ==
411 sos_kernel_core_top_pad !! 401 sos_paging_subsystem_setup(sos_kernel_core_base_paddr,
412 sos_bochs_printf("Could not setup paged me !! 402 sos_kernel_core_top_paddr));
413 sos_x86_videomem_printf(2, 0, !! 403
414 SOS_X86_VIDEO_FG_YEL !! 404
415 "Paged-memory mode i !! 405 sos_exception_set_routine(SOS_EXCEPT_PAGE_FAULT,
>> 406 pgflt_ex);
416 407
>> 408
>> 409
>> 410
417 411
418 if (sos_kmem_vmm_setup(sos_kernel_core_base_ !! 412 if (sos_kmem_vmm_subsystem_setup(sos_kernel_core_base_paddr,
419 sos_kernel_core_top_p !! 413 sos_kernel_core_top_paddr,
>> 414 bootstrap_stack_bottom,
>> 415 bootstrap_stack_bottom
>> 416 + bootstrap_stack_size))
420 sos_bochs_printf("Could not setup the Kern 417 sos_bochs_printf("Could not setup the Kernel virtual space allocator\n");
421 418
422 if (sos_kmalloc_setup()) !! 419 if (sos_kmalloc_subsystem_setup())
423 sos_bochs_printf("Could not setup the Kmal 420 sos_bochs_printf("Could not setup the Kmalloc subsystem\n");
424 421
425 !! 422
426 bn_test(); !! 423
>> 424
>> 425
>> 426
>> 427 sos_thread_subsystem_setup(bootstrap_stack_bottom,
>> 428 bootstrap_stack_size);
>> 429
>> 430
>> 431 sos_sched_subsystem_setup();
>> 432
>> 433
>> 434 SOS_ASSERT_FATAL(sos_create_kernel_thread("idle", idle_thread, NULL) != NULL);
>> 435
>> 436
>> 437
>> 438 asm volatile ("sti\n");
>> 439
427 440
428 !! 441
429 for (;;) !! 442 extern void MouseSim();
430 continue; !! 443 MouseSim();
>> 444 test_thread();
431 445
432 return; !! 446
>> 447
>> 448
>> 449
>> 450
>> 451
>> 452
>> 453
>> 454
>> 455
>> 456
>> 457
>> 458 sos_bochs_printf("Bye from primary thread !\n");
>> 459 sos_thread_exit();
>> 460 SOS_FATAL_ERROR("No trespassing !");
433 } 461 }