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