SimpleOS

LXR

Navigation



Site hébergé par : enix

The LXR Cross Referencer for SOS

source navigation ]
diff markup ]
identifier search ]
general search ]
 
 
Article:1 ] [ 2 ] [ 3 ] [ 4 ] [ 5 ] [ 6 ] [ 6.5 ] [ 7 ] [ 7.5 ] [ 8 ] [ 9 ] [ 9.5 ]

Diff markup

Differences between /sos/main.c (Article 6) and /sos/main.c (Article 7.5)


001 /* Copyright (C) 2004  The SOS Team               001 /* Copyright (C) 2004  The SOS Team
002    Copyright (C) 1999  Free Software Foundatio << 
003                                                   002 
004    This program is free software; you can redi    003    This program is free software; you can redistribute it and/or
005    modify it under the terms of the GNU Genera    004    modify it under the terms of the GNU General Public License
006    as published by the Free Software Foundatio    005    as published by the Free Software Foundation; either version 2
007    of the License, or (at your option) any lat    006    of the License, or (at your option) any later version.
008                                                   007    
009    This program is distributed in the hope tha    008    This program is distributed in the hope that it will be useful,
010    but WITHOUT ANY WARRANTY; without even the     009    but WITHOUT ANY WARRANTY; without even the implied warranty of
011    MERCHANTABILITY or FITNESS FOR A PARTICULAR    010    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
012    GNU General Public License for more details    011    GNU General Public License for more details.
013                                                   012    
014    You should have received a copy of the GNU     013    You should have received a copy of the GNU General Public License
015    along with this program; if not, write to t    014    along with this program; if not, write to the Free Software
016    Foundation, Inc., 59 Temple Place - Suite 3    015    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
017    USA.                                           016    USA. 
018 */                                                017 */
019                                                   018 
020 /* Include definitions of the multiboot standa    019 /* Include definitions of the multiboot standard */
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>
                                                   >> 029 #include <hwcore/mm_context.h>
                                                   >> 030 #include <hwcore/swintr.h>
030 #include <sos/kmem_vmm.h>                         031 #include <sos/kmem_vmm.h>
031 #include <sos/kmalloc.h>                          032 #include <sos/kmalloc.h>
                                                   >> 033 #include <sos/time.h>
                                                   >> 034 #include <sos/thread.h>
                                                   >> 035 #include <sos/process.h>
                                                   >> 036 #include <sos/umem_vmm.h>
032 #include <sos/klibc.h>                            037 #include <sos/klibc.h>
033 #include <sos/assert.h>                           038 #include <sos/assert.h>
034 #include <drivers/x86_videomem.h>                 039 #include <drivers/x86_videomem.h>
035 #include <drivers/bochs.h>                        040 #include <drivers/bochs.h>
                                                   >> 041 #include <sos/calcload.h>
                                                   >> 042 #include <sos/umem_vmm.h>
                                                   >> 043 #include <sos/binfmt_elf32.h>
                                                   >> 044 #include <drivers/zero.h>
036                                                   045 
037                                                   046 
038 /* Helper function to display each bits of a 3    047 /* Helper function to display each bits of a 32bits integer on the
039    screen as dark or light carrets */             048    screen as dark or light carrets */
040 void display_bits(unsigned char row, unsigned     049 void display_bits(unsigned char row, unsigned char col,
041                   unsigned char attribute,        050                   unsigned char attribute,
042                   sos_ui32_t integer)             051                   sos_ui32_t integer)
043 {                                                 052 {
044   int i;                                          053   int i;
045   /* Scan each bit of the integer, MSb first *    054   /* Scan each bit of the integer, MSb first */
046   for (i = 31 ; i >= 0 ; i--)                     055   for (i = 31 ; i >= 0 ; i--)
047     {                                             056     {
048       /* Test if bit i of 'integer' is set */     057       /* Test if bit i of 'integer' is set */
049       int bit_i = (integer & (1 << i));           058       int bit_i = (integer & (1 << i));
050       /* Ascii 219 => dark carret, Ascii 177 =    059       /* Ascii 219 => dark carret, Ascii 177 => light carret */
051       unsigned char ascii_code = bit_i?219:177    060       unsigned char ascii_code = bit_i?219:177;
052       sos_x86_videomem_putchar(row, col++,        061       sos_x86_videomem_putchar(row, col++,
053                                attribute,         062                                attribute,
054                                ascii_code);       063                                ascii_code);
055     }                                             064     }
056 }                                                 065 }
057                                                   066 
058                                                   067 
059 /* Clock IRQ handler */                           068 /* Clock IRQ handler */
060 static void clk_it(int intid,                  !! 069 static void clk_it(int intid)
061                    const struct sos_cpu_kstate << 
062 {                                                 070 {
063   static sos_ui32_t clock_count = 0;              071   static sos_ui32_t clock_count = 0;
064                                                   072 
065   display_bits(0, 48,                             073   display_bits(0, 48,
066                SOS_X86_VIDEO_FG_LTGREEN | SOS_    074                SOS_X86_VIDEO_FG_LTGREEN | SOS_X86_VIDEO_BG_BLUE,
067                clock_count);                      075                clock_count);
068   clock_count++;                                  076   clock_count++;
                                                   >> 077 
                                                   >> 078   /* Execute the expired timeout actions (if any) */
                                                   >> 079   sos_time_do_tick();
                                                   >> 080 
                                                   >> 081   /* Update scheduler statistics and status */
                                                   >> 082   sos_sched_do_timer_tick();
069 }                                                 083 }
070                                                   084 
071                                                   085 
072 /* ===========================================    086 /* ======================================================================
073  * Page fault exception handling                  087  * Page fault exception handling
074  */                                               088  */
075                                                   089 
076 /* Helper function to dump a backtrace on boch << 
077 static void dump_backtrace(const struct sos_cp << 
078                            sos_vaddr_t stack_b << 
079                            sos_size_t  stack_s << 
080                            sos_bool_t on_conso << 
081                            sos_bool_t on_bochs << 
082 {                                              << 
083   static void backtracer(sos_vaddr_t PC,       << 
084                          sos_vaddr_t params,   << 
085                          sos_ui32_t depth,     << 
086                          void *custom_arg)     << 
087     {                                          << 
088       sos_ui32_t invalid = 0xffffffff, *arg1,  << 
089                                                << 
090       /* Get the address of the first 3 argume << 
091          frame. Among these arguments, 0, 1, 2 << 
092          meaningful (depending on how many arg << 
093          take). */                             << 
094       arg1 = (sos_ui32_t*)params;              << 
095       arg2 = (sos_ui32_t*)(params+4);          << 
096       arg3 = (sos_ui32_t*)(params+8);          << 
097       arg4 = (sos_ui32_t*)(params+12);         << 
098                                                << 
099       /* Make sure the addresses of these argu << 
100          stack boundaries */                   << 
101 #define INTERVAL_OK(b,v,u) ( ((b) <= (sos_vadd << 
102                              && ((sos_vaddr_t) << 
103       if (!INTERVAL_OK(stack_bottom, arg1, sta << 
104         arg1 = &invalid;                       << 
105       if (!INTERVAL_OK(stack_bottom, arg2, sta << 
106         arg2 = &invalid;                       << 
107       if (!INTERVAL_OK(stack_bottom, arg3, sta << 
108         arg3 = &invalid;                       << 
109       if (!INTERVAL_OK(stack_bottom, arg4, sta << 
110         arg4 = &invalid;                       << 
111                                                << 
112       /* Print the function context for this f << 
113       if (on_bochs)                            << 
114         sos_bochs_printf("[%d] PC=0x%x arg1=0x << 
115                          (unsigned)depth, (uns << 
116                          (unsigned)*arg1, (uns << 
117                          (unsigned)*arg3);     << 
118                                                << 
119       if (on_console)                          << 
120         sos_x86_videomem_printf(23-depth, 3,   << 
121                                 SOS_X86_VIDEO_ << 
122                                   | SOS_X86_VI << 
123                                 "[%d] PC=0x%x  << 
124                                 (unsigned)dept << 
125                                 (unsigned)*arg << 
126                                 (unsigned)*arg << 
127                                                << 
128     }                                          << 
129                                                << 
130   sos_backtrace(cpu_kstate, 15, stack_bottom,  << 
131 }                                              << 
132                                                << 
133                                                   090 
134 /* Page fault exception handler with demand pa    091 /* Page fault exception handler with demand paging for the kernel */
135 static void pgflt_ex(int intid, const struct s !! 092 static void pgflt_ex(int intid, struct sos_cpu_state *ctxt)
136 {                                                 093 {
137   static sos_ui32_t demand_paging_count = 0;      094   static sos_ui32_t demand_paging_count = 0;
138   sos_vaddr_t faulting_vaddr = sos_cpu_kstate_ !! 095   struct sos_thread * cur_thr = sos_thread_get_current();
                                                   >> 096   sos_vaddr_t faulting_vaddr  = sos_cpu_context_get_EX_faulting_vaddr(ctxt);
139   sos_paddr_t ppage_paddr;                        097   sos_paddr_t ppage_paddr;
140                                                   098 
                                                   >> 099   if (sos_cpu_context_is_in_user_mode(ctxt)
                                                   >> 100       || (cur_thr->fixup_uaccess.return_vaddr))
                                                   >> 101     {
                                                   >> 102       __label__ unforce_address_space;
                                                   >> 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 
                                                   >> 132       sos_bochs_printf("Unresolved USER page Fault at instruction 0x%x on access to address 0x%x (info=%x)!\n",
                                                   >> 133                        sos_cpu_context_get_PC(ctxt),
                                                   >> 134                        (unsigned)faulting_vaddr,
                                                   >> 135                        (unsigned)sos_cpu_context_get_EX_info(ctxt));
                                                   >> 136       sos_bochs_printf("Terminating User thread\n");
                                                   >> 137       sos_thread_exit();
                                                   >> 138 
                                                   >> 139     unforce_address_space:
                                                   >> 140       if (need_to_setup_mmu)
                                                   >> 141         sos_thread_end_user_space_access();
                                                   >> 142       return;
                                                   >> 143     }
                                                   >> 144 
141   /* Check if address is covered by any VMM ra    145   /* Check if address is covered by any VMM range */
142   if (! sos_kmem_vmm_is_valid_vaddr(faulting_v    146   if (! sos_kmem_vmm_is_valid_vaddr(faulting_vaddr))
143     {                                             147     {
144       /* No: The page fault is out of any kern    148       /* No: The page fault is out of any kernel virtual region. For
145          the moment, we don't handle this. */     149          the moment, we don't handle this. */
146       dump_backtrace(ctxt,                     !! 150       sos_display_fatal_error("Unresolved page Fault at instruction 0x%x on access to address 0x%x (info=%x)!",
147                      bootstrap_stack_bottom,   !! 151                               sos_cpu_context_get_PC(ctxt),
148                      bootstrap_stack_size,     << 
149                      TRUE, TRUE);              << 
150       sos_display_fatal_error("Unresolved page << 
151                               (unsigned)faulti    152                               (unsigned)faulting_vaddr,
152                               (unsigned)sos_cp !! 153                               (unsigned)sos_cpu_context_get_EX_info(ctxt));
153       SOS_ASSERT_FATAL(! "Got page fault (note    154       SOS_ASSERT_FATAL(! "Got page fault (note: demand paging is disabled)");
154     }                                             155     }
155                                                   156 
156                                                   157 
157   /*                                              158   /*
158    * Demand paging                             !! 159    * Demand paging in kernel space
159    */                                             160    */
160                                                   161  
161   /* Update the number of demand paging reques    162   /* Update the number of demand paging requests handled */
162   demand_paging_count ++;                         163   demand_paging_count ++;
163   display_bits(0, 0,                              164   display_bits(0, 0,
164                SOS_X86_VIDEO_FG_LTRED | SOS_X8    165                SOS_X86_VIDEO_FG_LTRED | SOS_X86_VIDEO_BG_BLUE,
165                demand_paging_count);              166                demand_paging_count);
166                                                   167 
167   /* Allocate a new page for the virtual addre    168   /* Allocate a new page for the virtual address */
168   ppage_paddr = sos_physmem_ref_physpage_new(F    169   ppage_paddr = sos_physmem_ref_physpage_new(FALSE);
169   if (! ppage_paddr)                              170   if (! ppage_paddr)
170     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 !)");
171   SOS_ASSERT_FATAL(SOS_OK == sos_paging_map(pp    172   SOS_ASSERT_FATAL(SOS_OK == sos_paging_map(ppage_paddr,
172                                             SO    173                                             SOS_PAGE_ALIGN_INF(faulting_vaddr),
173                                             FA    174                                             FALSE,
174                                             SO    175                                             SOS_VM_MAP_PROT_READ
175                                             |     176                                             | SOS_VM_MAP_PROT_WRITE
176                                             |     177                                             | SOS_VM_MAP_ATOMIC));
177   sos_physmem_unref_physpage(ppage_paddr);        178   sos_physmem_unref_physpage(ppage_paddr);
178                                                   179 
179   /* Ok, we can now return to interrupted cont    180   /* Ok, we can now return to interrupted context */
180 }                                                 181 }
181                                                   182 
182                                                   183 
183                                                   184 
184 /* ===========================================    185 /* ======================================================================
185  * Demonstrate the use of the CPU kernet conte !! 186  * An operating system MUST always have a ready thread ! Otherwise:
186  *  - A coroutine prints "Hlowrd" and switches !! 187  * what would the CPU have to execute ?!
187  *    letter                                   << 
188  *  - A coroutine prints "el ol\n" and switche << 
189  *    each letter.                             << 
190  * The first to reach the '\n' returns back to << 
191  */                                               188  */
192 struct sos_cpu_kstate *ctxt_hello1;            !! 189 static void idle_thread()
193 struct sos_cpu_kstate *ctxt_hello2;            << 
194 struct sos_cpu_kstate *ctxt_main;              << 
195 sos_vaddr_t hello1_stack, hello2_stack;        << 
196                                                << 
197 static void reclaim_stack(sos_vaddr_t stack_va << 
198 {                                                 190 {
199   sos_kfree(stack_vaddr);                      !! 191   sos_ui32_t idle_twiddle = 0;
200 }                                              << 
201                                                << 
202                                                << 
203 static void exit_hello12(sos_vaddr_t stack_vad << 
204 {                                              << 
205   sos_cpu_kstate_exit_to(ctxt_main,            << 
206                          (sos_cpu_kstate_funct << 
207                          stack_vaddr);         << 
208 }                                              << 
209                                                << 
210                                                << 
211 static void hello1 (char *str)                 << 
212 {                                              << 
213   for ( ; *str != '\n' ; str++)                << 
214     {                                          << 
215       sos_bochs_printf("hello1: %c\n", *str);  << 
216       sos_cpu_kstate_switch(& ctxt_hello1, ctx << 
217     }                                          << 
218                                                << 
219   /* You can uncomment this in case you explic << 
220      now. But returning from the function will << 
221   /* sos_cpu_kstate_exit_to(ctxt_main,         << 
222                          (sos_cpu_kstate_funct << 
223                          hello1_stack); */     << 
224 }                                              << 
225                                                << 
226                                                   192 
227 static void hello2 (char *str)                 !! 193   while (1)
228 {                                              << 
229   for ( ; *str != '\n' ; str++)                << 
230     {                                             194     {
231       sos_bochs_printf("hello2: %c\n", *str);  !! 195       /* Remove this instruction if you get an "Invalid opcode" CPU
232       sos_cpu_kstate_switch(& ctxt_hello2, ctx !! 196          exception (old 80386 CPU) */
233     }                                          !! 197       asm("hlt\n");
234                                                << 
235   /* You can uncomment this in case you explic << 
236      now. But returning from the function will << 
237   /* sos_cpu_kstate_exit_to(ctxt_main,         << 
238                          (sos_cpu_kstate_funct << 
239                          hello2_stack); */     << 
240 }                                              << 
241                                                << 
242                                                << 
243 void print_hello_world ()                      << 
244 {                                              << 
245 #define DEMO_STACK_SIZE 1024                   << 
246   /* Allocate the stacks */                    << 
247   hello1_stack = sos_kmalloc(DEMO_STACK_SIZE,  << 
248   hello2_stack = sos_kmalloc(DEMO_STACK_SIZE,  << 
249                                                << 
250   /* Initialize the coroutines' contexts */    << 
251   sos_cpu_kstate_init(&ctxt_hello1,            << 
252                       (sos_cpu_kstate_function << 
253                       (sos_ui32_t) "Hlowrd",   << 
254                       (sos_vaddr_t) hello1_sta << 
255                       (sos_cpu_kstate_function << 
256                       (sos_ui32_t) hello1_stac << 
257   sos_cpu_kstate_init(&ctxt_hello2,            << 
258                       (sos_cpu_kstate_function << 
259                       (sos_ui32_t) "el ol\n",  << 
260                       (sos_vaddr_t) hello2_sta << 
261                       (sos_cpu_kstate_function << 
262                       (sos_ui32_t) hello2_stac << 
263                                                << 
264   /* Go to first coroutine */                  << 
265   sos_bochs_printf("Printing Hello World\\n... << 
266   sos_cpu_kstate_switch(& ctxt_main, ctxt_hell << 
267                                                << 
268   /* The first coroutine to reach the '\n' swi << 
269   sos_bochs_printf("Back in main !\n");        << 
270 }                                              << 
271                                                << 
272                                                << 
273 /* =========================================== << 
274  * Generate page faults on an unmapped but all << 
275  * region, which results in a series of physic << 
276  * faulted pages.                              << 
277  */                                            << 
278 static void test_demand_paging(int nb_alloc_vp << 
279 {                                              << 
280   int i;                                       << 
281   sos_vaddr_t base_vaddr;                      << 
282                                                << 
283   sos_x86_videomem_printf(10, 0,               << 
284                           SOS_X86_VIDEO_BG_BLU << 
285                           "Demand paging test  << 
286                           nb_alloc_vpages >> 8 << 
287                                                << 
288   /* Allocate virtual memory */                << 
289   base_vaddr = sos_kmem_vmm_alloc(nb_alloc_vpa << 
290                                                << 
291   SOS_ASSERT_FATAL(base_vaddr != (sos_vaddr_t) << 
292   sos_x86_videomem_printf(11, 0,               << 
293                           SOS_X86_VIDEO_BG_BLU << 
294                           "Allocated virtual r << 
295                           base_vaddr,          << 
296                           base_vaddr + nb_allo << 
297                                                   198 
298   /* Now use part of it in physical memory */  !! 199       idle_twiddle ++;
299   for (i = 0 ; (i < nb_alloc_ppages) && (i < n !! 200       display_bits(0, 0, SOS_X86_VIDEO_FG_GREEN | SOS_X86_VIDEO_BG_BLUE,
300     {                                          !! 201                    idle_twiddle);
301       /* Compute an address inside the range * !! 202       
302       sos_ui32_t *value, j;                    !! 203       /* Lend the CPU to some other thread */
303       sos_vaddr_t vaddr = base_vaddr;          !! 204       sos_thread_yield();
304       vaddr += (nb_alloc_vpages - (i + 1))*SOS << 
305       vaddr += 2345;                           << 
306                                                << 
307       sos_x86_videomem_printf(12, 0,           << 
308                               SOS_X86_VIDEO_BG << 
309                               "Writing %d at v << 
310                               i, vaddr);       << 
311                                                << 
312       /* Write at this address */              << 
313       value = (sos_ui32_t*)vaddr;              << 
314       *value = i;                              << 
315                                                << 
316       /* Yep ! A new page should normally have << 
317       sos_x86_videomem_printf(13, 0,           << 
318                               SOS_X86_VIDEO_BG << 
319                               "Value read at a << 
320                               vaddr, (unsigned << 
321     }                                             205     }
322                                                << 
323   SOS_ASSERT_FATAL(SOS_OK == sos_kmem_vmm_free << 
324   /* Yep ! A new page should normally have bee << 
325   sos_x86_videomem_printf(14, 0,               << 
326                           SOS_X86_VIDEO_BG_BLU << 
327                           "Done (area un-alloc << 
328 }                                                 206 }
329                                                   207 
330                                                   208 
331                                                << 
332 /* ===========================================    209 /* ======================================================================
333  * Shows how the backtrace stuff works         !! 210  * Kernel thread showing some CPU usage statistics on the console every 1s
334  */                                               211  */
335                                                !! 212 static void stat_thread()
336 /* Recursive function. Print the backtrace fro << 
337 static void test_backtrace(int i, int magic, s << 
338                            sos_size_t  stack_s << 
339 {                                                 213 {
340   if (i <= 0)                                  !! 214   while (1)
341     {                                             215     {
342       /* The page fault exception handler will !! 216       sos_ui32_t flags;
343          this function, because address 0x42 i !! 217       sos_ui32_t load1, load5, load15;
344       *((char*)0x42) = 12;                     !! 218       char str1[11], str5[11], str15[11];
345                                                !! 219       struct sos_time t;
346       /* More direct variant: */               !! 220       t.sec = 1;
347       /* dump_backtrace(NULL, stack_bottom, st !! 221       t.nanosec = 0;
                                                   >> 222 
                                                   >> 223       sos_thread_sleep(& t);
                                                   >> 224 
                                                   >> 225       sos_disable_IRQs(flags);
                                                   >> 226 
                                                   >> 227       /* The IDLE task is EXcluded in the following computation */
                                                   >> 228       sos_load_get_sload(&load1, &load5, &load15);
                                                   >> 229       sos_load_to_string(str1, load1);
                                                   >> 230       sos_load_to_string(str5, load5);
                                                   >> 231       sos_load_to_string(str15, load15);
                                                   >> 232       sos_x86_videomem_printf(16, 34,
                                                   >> 233                               SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
                                                   >> 234                               "Kernel (- Idle): %s %s %s    ",
                                                   >> 235                               str1, str5, str15);
                                                   >> 236 
                                                   >> 237       sos_load_get_uload(&load1, &load5, &load15);
                                                   >> 238       sos_load_to_string(str1, load1);
                                                   >> 239       sos_load_to_string(str5, load5);
                                                   >> 240       sos_load_to_string(str15, load15);
                                                   >> 241       sos_x86_videomem_printf(17, 34,
                                                   >> 242                               SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
                                                   >> 243                               "User: %s %s %s        ",
                                                   >> 244                               str1, str5, str15);
                                                   >> 245 
                                                   >> 246       sos_load_get_uratio(&load1, &load5, &load15);
                                                   >> 247       sos_load_to_string(str1, load1);
                                                   >> 248       sos_load_to_string(str5, load5);
                                                   >> 249       sos_load_to_string(str15, load15);
                                                   >> 250       sos_x86_videomem_printf(18, 34,
                                                   >> 251                               SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
                                                   >> 252                               "User CPU %%: %s %s %s        ",
                                                   >> 253                               str1, str5, str15);
                                                   >> 254 
                                                   >> 255       /* The IDLE task is INcluded in the following computation */
                                                   >> 256       sos_load_get_sratio(&load1, &load5, &load15);
                                                   >> 257       sos_load_to_string(str1, load1);
                                                   >> 258       sos_load_to_string(str5, load5);
                                                   >> 259       sos_load_to_string(str15, load15);
                                                   >> 260       sos_x86_videomem_printf(19, 34,
                                                   >> 261                               SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
                                                   >> 262                               "Kernel CPU %% (+ Idle): %s %s %s    ",
                                                   >> 263                               str1, str5, str15);
                                                   >> 264       sos_restore_IRQs(flags);
348     }                                             265     }
349   else                                         << 
350     test_backtrace(i-1, magic, stack_bottom, s << 
351 }                                                 266 }
352                                                   267 
353                                                   268 
354 /* ===========================================    269 /* ======================================================================
355  * Parsing of Mathematical expressions         !! 270  * Start the "init" (userland) process
356  *                                             << 
357  * This is a recursive lexer/parser/evaluator  << 
358  * expressions. Supports both binary +/-* and  << 
359  * well as parentheses.                        << 
360  *                                             << 
361  * Terminal tokens (Lexer):                    << 
362  *  - Number: positive integer number          << 
363  *  - Variable: ascii name (regexp: [a-zA-Z]+) << 
364  *  - Operator: +*-/                           << 
365  *  - Opening/closing parentheses              << 
366  *                                             << 
367  * Grammar (Parser):                           << 
368  *  Expression ::= Term E'                     << 
369  *  Expr_lr    ::= + Term Expr_lr | - Term Exp << 
370  *  Term       ::= Factor Term_lr              << 
371  *  Term_lr    ::= * Factor Term_lr | / Factor << 
372  *  Factor     ::= - Factor | + Factor | Scala << 
373  *  Scalar     ::= Number | Variable           << 
374  *                                             << 
375  * Note. This is the left-recursive equivalent << 
376  *  Expression ::= Expression + Term | Express << 
377  *  Term       ::= Term * Factor | Term / Fact << 
378  *  factor     ::= - Factor | + Factor | Scala << 
379  *  Scalar     ::= Number | Variable           << 
380  *                                             << 
381  * The parsing is composed of a 3 stages pipel << 
382  *  - The reader: reads a string 1 character a << 
383  *    the control back to lexer after each cha << 
384  *    interest in using coroutines, because it << 
385  *    implicitely stored in the stack between  << 
386  *  - The lexer: consumes the characters from  << 
387  *    the terminal tokens, 1 token at a time,  << 
388  *    to the parser after each token. This fun << 
389  *    in using coroutines, because its state ( << 
390  *    implicitely stored in the stack between  << 
391  *  - The parser: consumes the tokens from the << 
392  *    syntax tree of the expression. There is  << 
393  *    interest in defining a coroutine devoted << 
394  *    do use one for that because this allows  << 
395  *    deeper stack. Actually, the parser is hi << 
396  *    the default 16kB stack of the sos_main() << 
397  *    enough. Here, we switch to a 64kB stack, << 
398  *    recursive functions. The Parser uses int << 
399  *    are defined and implemented as internal  << 
400  *    just for the sake of clarity, and is abs << 
401  *    the algorithm: one can transfer these fu << 
402  *    function without restriction.            << 
403  *                                             << 
404  * The evaluator is another recursive function << 
405  * parser's stack to evaluate the parsed expre << 
406  * values for the variables present in the exp << 
407  * parser function, this function defines and  << 
408  * which can be extracted from the main evalua << 
409  *                                             << 
410  * All these functions support a kind of "exce << 
411  * something goes wrong, control is transferre << 
412  * sos_main() context, without unrolling the r << 
413  * how exceptions basically work, but one shou << 
414  * a reference exceptions implementation. Real << 
415  * (such as that in the C++ language) call the << 
416  * objects allocated on the stack during the " << 
417  * upon exception handling, which complicates  << 
418  * don't have real Objects here (in the OOP se << 
419  * destructors), so we don't have to complicat << 
420  *                                             << 
421  * After this little coroutine demo, one shoul << 
422  * a low-level manual direct manipulation of s << 
423  * probably mess up the whole kernel to do wha << 
424  * resources such as mutex/semaphore won't be  << 
425  * ...). Higher level "kernel thread" primitiv << 
426  * presented, which provide a higher-level set << 
427  * contexts. You'll have to use EXCLUSIVELY th << 
428  * need a huge stack to do recursion for examp << 
429  * think of changing manually the stack for so << 
430  * rethink your algorithm, making it non-recur << 
431  */                                            << 
432                                                << 
433                                                << 
434 /* The stacks involved */                      << 
435 static char stack_reader[1024];                << 
436 static char stack_lexer[1024];                 << 
437 static char deep_stack[65536]; /* For the pars << 
438                                                << 
439 /* The CPU states for the various coroutines * << 
440 static struct sos_cpu_kstate *st_reader, *st_l << 
441   *st_eval, *st_free, *st_main;                << 
442                                                << 
443                                                << 
444 /*                                             << 
445  * Default exit/reclaim functions: return cont << 
446  * context                                     << 
447  */                                               271  */
448 static void reclaim(int unused)                !! 272 static sos_ret_t start_init()
449 {                                              << 
450 }                                              << 
451 static void func_exit(sos_ui32_t unused)       << 
452 {                                              << 
453   sos_cpu_kstate_exit_to(st_main, (sos_cpu_kst << 
454 }                                              << 
455                                                << 
456                                                << 
457 /*                                             << 
458  * The reader coroutine and associated variabl << 
459  * have been a normal function, except that th << 
460  * character would have to be stored somewhere << 
461  */                                            << 
462 static char data_reader_to_lexer;              << 
463                                                << 
464 static void func_reader(const char *str)       << 
465 {                                              << 
466   for ( ; str && (*str != '\0') ; str++)       << 
467     {                                          << 
468       data_reader_to_lexer = *str;             << 
469       sos_cpu_kstate_switch(& st_reader, st_le << 
470     }                                          << 
471                                                << 
472   data_reader_to_lexer = '\0';                 << 
473   sos_cpu_kstate_switch(& st_reader, st_lexer) << 
474 }                                              << 
475                                                << 
476                                                << 
477 /*                                             << 
478  * The Lexer coroutine and associated types/va << 
479  * could have been a normal function, except t << 
480  * character, token and previous token would h << 
481  * somewhere.                                  << 
482  */                                            << 
483 #define STR_VAR_MAXLEN 16                      << 
484 static struct lex_elem                         << 
485 {                                              << 
486   enum { LEX_IS_NUMBER, LEX_IS_OPER, LEX_IS_VA << 
487          LEX_IS_OPENPAR, LEX_IS_CLOSEPAR, LEX_ << 
488   union {                                      << 
489     int  number;                               << 
490     char operator;                             << 
491     char var[STR_VAR_MAXLEN];                  << 
492   };                                           << 
493 } data_lexer_to_parser;                        << 
494                                                << 
495 static void func_lexer(sos_ui32_t unused)      << 
496 {                                                 273 {
497   char c;                                      !! 274   sos_ret_t retval;
498   enum { GOT_SPACE, GOT_NUM, GOT_OP, GOT_STR,  !! 275   struct sos_umem_vmm_as *as_init;
499          GOT_OPENPAR, GOT_CLOSEPAR } got_what, !! 276   struct sos_process *proc_init;
500                                                !! 277   struct sos_thread *new_thr;
501   data_lexer_to_parser.number = 0;             !! 278   sos_uaddr_t ustack, start_uaddr;
502   got_what_before = GOT_SPACE;                 !! 279 
503   do                                           !! 280   /* Create the new process */
504     {                                          !! 281   proc_init = sos_process_create("init", FALSE);
505       /* Consume one character from the reader !! 282   if (! proc_init)
506       sos_cpu_kstate_switch(& st_lexer, st_rea !! 283     return -SOS_ENOMEM;
507       c = data_reader_to_lexer;                !! 284   as_init = sos_process_get_address_space(proc_init);
508                                                !! 285 
509       /* Classify the consumed character */    !! 286   /* Map the 'init' program in user space */
510       if ( (c >= '0') && (c <= '9') )          !! 287   start_uaddr = sos_binfmt_elf32_map(as_init, "init");
511         got_what = GOT_NUM;                    !! 288   if (0 == start_uaddr)
512       else if ( (c == '+') || (c == '-') || (c !! 289     {
513         got_what = GOT_OP;                     !! 290       sos_process_unref(proc_init);
514       else if ( ( (c >= 'a') && (c <= 'z') )   !! 291       return -SOS_ENOENT;
515                 || ( (c >= 'A') && (c <= 'Z')  !! 292     }
516         got_what = GOT_STR;                    !! 293      
517       else if (c == '(')                       !! 294   /* Allocate the user stack */
518         got_what = GOT_OPENPAR;                !! 295   ustack = (SOS_PAGING_TOP_USER_ADDRESS - SOS_DEFAULT_USER_STACK_SIZE) + 1;
519       else if (c == ')')                       !! 296   retval = sos_dev_zero_map(as_init, &ustack, SOS_DEFAULT_USER_STACK_SIZE,
520         got_what = GOT_CLOSEPAR;               !! 297                             SOS_VM_MAP_PROT_READ | SOS_VM_MAP_PROT_WRITE,
521       else                                     !! 298                             /* PRIVATE */ 0);
522         got_what = GOT_SPACE;                  !! 299   if (SOS_OK != retval)
523                                                !! 300     {
524       /* Determine whether the current token i !! 301       sos_bochs_printf("ici 2\n");
525       if ( (got_what != got_what_before)       !! 302       sos_process_unref(proc_init);
526            || (got_what_before == GOT_OP)      !! 303       return -SOS_ENOMEM;
527            || (got_what_before == GOT_OPENPAR) !! 304     }
528            || (got_what_before == GOT_CLOSEPAR !! 305 
529         {                                      !! 306   /* Now create the user thread */
530           /* return control back to the parser !! 307   new_thr = sos_create_user_thread(NULL,
531              has been recognized */            !! 308                                    proc_init,
532           if ( (got_what_before != GOT_SPACE)  !! 309                                    start_uaddr,
533             sos_cpu_kstate_switch(& st_lexer,  !! 310                                    0, 0,
534                                                !! 311                                    ustack + SOS_DEFAULT_USER_STACK_SIZE - 4,
535           data_lexer_to_parser.number = 0;     !! 312                                    SOS_SCHED_PRIO_TS_LOWEST);
536         }                                      !! 313   if (! new_thr)
537                                                !! 314     {
538       /* Update the token being currently reco !! 315       sos_bochs_printf("ici 3\n");
539       if (got_what == GOT_OP)                  !! 316       sos_process_unref(proc_init);
540         {                                      !! 317       return -SOS_ENOMEM;
541           data_lexer_to_parser.type = LEX_IS_O << 
542           data_lexer_to_parser.operator = c;   << 
543         }                                      << 
544       else if (got_what == GOT_NUM)            << 
545         {                                      << 
546           data_lexer_to_parser.type = LEX_IS_N << 
547           data_lexer_to_parser.number *= 10;   << 
548           data_lexer_to_parser.number += (c -  << 
549         }                                      << 
550       else if (got_what == GOT_STR)            << 
551         {                                      << 
552           char to_cat[] = { c, '\0' };         << 
553           data_lexer_to_parser.type = LEX_IS_V << 
554           strzcat(data_lexer_to_parser.var, to << 
555         }                                      << 
556       else if (got_what == GOT_OPENPAR)        << 
557         data_lexer_to_parser.type = LEX_IS_OPE << 
558       else if (got_what == GOT_CLOSEPAR)       << 
559         data_lexer_to_parser.type = LEX_IS_CLO << 
560                                                << 
561       got_what_before = got_what;              << 
562     }                                             318     }
563   while (c != '\0');                           << 
564                                                   319 
565   /* Transfer last recognized token to the par !! 320   sos_process_unref(proc_init);
566   if ( (got_what_before != GOT_SPACE) )        !! 321   return SOS_OK;
567     sos_cpu_kstate_switch(& st_lexer, st_parse << 
568                                                << 
569   /* Signal that no more token are available * << 
570   data_lexer_to_parser.type = LEX_END;         << 
571   sos_cpu_kstate_switch(& st_lexer, st_parser) << 
572                                                << 
573   /* Exception: parser asks for a token AFTER  << 
574      one */                                    << 
575   sos_bochs_printf("Error: end of string alrea << 
576   sos_cpu_kstate_switch(& st_lexer, st_main);  << 
577 }                                              << 
578                                                << 
579                                                << 
580 /*                                             << 
581  * The Parser coroutine and associated types/v << 
582  */                                            << 
583 struct syntax_node                             << 
584 {                                              << 
585   enum { YY_IS_BINOP, YY_IS_UNAROP, YY_IS_NUM, << 
586   union                                        << 
587   {                                            << 
588     int  number;                               << 
589     char var[STR_VAR_MAXLEN];                  << 
590     struct                                     << 
591     {                                          << 
592       char op;                                 << 
593       struct syntax_node *parm_left, *parm_rig << 
594     } binop;                                   << 
595     struct                                     << 
596     {                                          << 
597       char op;                                 << 
598       struct syntax_node *parm;                << 
599     } unarop;                                  << 
600   };                                           << 
601 };                                             << 
602                                                << 
603 static void func_parser(struct syntax_node **  << 
604 {                                              << 
605   static struct syntax_node *alloc_node_num(in << 
606   static struct syntax_node *alloc_node_var(co << 
607   static struct syntax_node *alloc_node_binop( << 
608                                                << 
609                                                << 
610   static struct syntax_node *alloc_node_unarop << 
611                                                << 
612   static struct syntax_node * get_expr();      << 
613   static struct syntax_node * get_expr_lr(stru << 
614   static struct syntax_node * get_term();      << 
615   static struct syntax_node * get_term_lr(stru << 
616   static struct syntax_node * get_factor();    << 
617   static struct syntax_node * get_scalar();    << 
618                                                << 
619   /* Create a new node to store a number */    << 
620   static struct syntax_node *alloc_node_num(in << 
621     {                                          << 
622       struct syntax_node *n                    << 
623         = (struct syntax_node*) sos_kmalloc(si << 
624       n->type   = YY_IS_NUM;                   << 
625       n->number = val;                         << 
626       return n;                                << 
627     }                                          << 
628   /* Create a new node to store a variable */  << 
629   static struct syntax_node *alloc_node_var(co << 
630     {                                          << 
631       struct syntax_node *n                    << 
632         = (struct syntax_node*) sos_kmalloc(si << 
633       n->type   = YY_IS_VAR;                   << 
634       strzcpy(n->var, name, STR_VAR_MAXLEN);   << 
635       return n;                                << 
636     }                                          << 
637   /* Create a new node to store a binary opera << 
638   static struct syntax_node *alloc_node_binop( << 
639                                                << 
640                                                << 
641     {                                          << 
642       struct syntax_node *n                    << 
643         = (struct syntax_node*) sos_kmalloc(si << 
644       n->type             = YY_IS_BINOP;       << 
645       n->binop.op         = op;                << 
646       n->binop.parm_left  = parm_left;         << 
647       n->binop.parm_right = parm_right;        << 
648       return n;                                << 
649     }                                          << 
650   /* Create a new node to store a unary operat << 
651   static struct syntax_node *alloc_node_unarop << 
652                                                << 
653     {                                          << 
654       struct syntax_node *n                    << 
655         = (struct syntax_node*) sos_kmalloc(si << 
656       n->type        = YY_IS_UNAROP;           << 
657       n->unarop.op   = op;                     << 
658       n->unarop.parm = parm;                   << 
659       return n;                                << 
660     }                                          << 
661                                                << 
662   /* Raise an exception: transfer control back << 
663      without unrolling the whole recursion */  << 
664   static void parser_exception(const char *str << 
665     {                                          << 
666       sos_bochs_printf("Parser exception: %s\n << 
667       sos_cpu_kstate_switch(& st_parser, st_ma << 
668     }                                          << 
669                                                << 
670   /* Consume the current terminal "number" tok << 
671      token */                                  << 
672   static int get_number()                      << 
673     {                                          << 
674       int v;                                   << 
675       if (data_lexer_to_parser.type != LEX_IS_ << 
676         parser_exception("Expected number");   << 
677       v = data_lexer_to_parser.number;         << 
678       sos_cpu_kstate_switch(& st_parser, st_le << 
679       return v;                                << 
680     }                                          << 
681   /* Consume the current terminal "variable" t << 
682      token */                                  << 
683   static void get_str(char name[STR_VAR_MAXLEN << 
684     {                                          << 
685       if (data_lexer_to_parser.type != LEX_IS_ << 
686         parser_exception("Expected variable"); << 
687       strzcpy(name, data_lexer_to_parser.var,  << 
688       sos_cpu_kstate_switch(& st_parser, st_le << 
689     }                                          << 
690   /* Consume the current terminal "operator" t << 
691      token */                                  << 
692   static char get_op()                         << 
693     {                                          << 
694       char op;                                 << 
695       if (data_lexer_to_parser.type != LEX_IS_ << 
696         parser_exception("Expected operator"); << 
697       op = data_lexer_to_parser.operator;      << 
698       sos_cpu_kstate_switch(& st_parser, st_le << 
699       return op;                               << 
700     }                                          << 
701   /* Consume the current terminal "parenthese" << 
702      token */                                  << 
703   static void get_par()                        << 
704     {                                          << 
705       if ( (data_lexer_to_parser.type != LEX_I << 
706            && (data_lexer_to_parser.type != LE << 
707         parser_exception("Expected parenthese" << 
708       sos_cpu_kstate_switch(& st_parser, st_le << 
709     }                                          << 
710                                                << 
711   /* Parse an Expression */                    << 
712   static struct syntax_node * get_expr()       << 
713     {                                          << 
714       struct syntax_node *t = get_term();      << 
715       return get_expr_lr(t);                   << 
716     }                                          << 
717   /* Parse an Expr_lr */                       << 
718   static struct syntax_node * get_expr_lr(stru << 
719     {                                          << 
720       if ( (data_lexer_to_parser.type == LEX_I << 
721            && ( (data_lexer_to_parser.operator << 
722                 || (data_lexer_to_parser.opera << 
723         {                                      << 
724           char op = get_op();                  << 
725           struct syntax_node *term = get_term( << 
726           struct syntax_node *node_op = alloc_ << 
727           return get_expr_lr(node_op);         << 
728         }                                      << 
729       return n;                                << 
730     }                                          << 
731   /* Parse a Term */                           << 
732   static struct syntax_node * get_term()       << 
733     {                                          << 
734       struct syntax_node *f1 = get_factor();   << 
735       return get_term_lr(f1);                  << 
736     }                                          << 
737   /* Parse a Term_lr */                        << 
738   static struct syntax_node * get_term_lr(stru << 
739     {                                          << 
740       if ( (data_lexer_to_parser.type == LEX_I << 
741            && ( (data_lexer_to_parser.operator << 
742                 || (data_lexer_to_parser.opera << 
743         {                                      << 
744           char op = get_op();                  << 
745           struct syntax_node *factor = get_fac << 
746           struct syntax_node *node_op = alloc_ << 
747           return get_term_lr(node_op);         << 
748         }                                      << 
749       return n;                                << 
750     }                                          << 
751   /* Parse a Factor */                         << 
752   static struct syntax_node * get_factor()     << 
753     {                                          << 
754       if ( (data_lexer_to_parser.type == LEX_I << 
755            && ( (data_lexer_to_parser.operator << 
756                 || (data_lexer_to_parser.opera << 
757         { char op = data_lexer_to_parser.opera << 
758         get_op(); return alloc_node_unarop(op, << 
759       else if (data_lexer_to_parser.type == LE << 
760         {                                      << 
761           struct syntax_node *expr;            << 
762           get_par();                           << 
763           expr = get_expr();                   << 
764           if (data_lexer_to_parser.type != LEX << 
765             parser_exception("Mismatched paren << 
766           get_par();                           << 
767           return expr;                         << 
768         }                                      << 
769                                                << 
770       return get_scalar();                     << 
771     }                                          << 
772   /* Parse a Scalar */                         << 
773   static struct syntax_node * get_scalar()     << 
774     {                                          << 
775       if (data_lexer_to_parser.type != LEX_IS_ << 
776         {                                      << 
777           char var[STR_VAR_MAXLEN];            << 
778           get_str(var);                        << 
779           return alloc_node_var(var);          << 
780         }                                      << 
781       return alloc_node_num(get_number());     << 
782     }                                          << 
783                                                << 
784                                                << 
785   /*                                           << 
786    * Body of the function                      << 
787    */                                          << 
788                                                << 
789   /* Get the first token */                    << 
790   sos_cpu_kstate_switch(& st_parser, st_lexer) << 
791                                                << 
792   /* Begin the parsing ! */                    << 
793   *syntax_tree = get_expr();                   << 
794   /* The result is returned in the syntax_tree << 
795 }                                              << 
796                                                << 
797                                                << 
798 /*                                             << 
799  * Setup the parser's pipeline                 << 
800  */                                            << 
801 static struct syntax_node * parse_expression(c << 
802 {                                              << 
803   struct syntax_node *retval = NULL;           << 
804                                                << 
805   /* Build the context of the functions in the << 
806   sos_cpu_kstate_init(& st_reader,             << 
807                       (sos_cpu_kstate_function << 
808                       (sos_ui32_t)expr,        << 
809                       (sos_vaddr_t)stack_reade << 
810                       (sos_cpu_kstate_function << 
811   sos_cpu_kstate_init(& st_lexer,              << 
812                       (sos_cpu_kstate_function << 
813                       0,                       << 
814                       (sos_vaddr_t)stack_lexer << 
815                       (sos_cpu_kstate_function << 
816   sos_cpu_kstate_init(& st_parser,             << 
817                       (sos_cpu_kstate_function << 
818                       (sos_ui32_t) /* syntax t << 
819                       (sos_vaddr_t)deep_stack, << 
820                       (sos_cpu_kstate_function << 
821                                                << 
822   /* Parse the expression */                   << 
823   sos_cpu_kstate_switch(& st_main, st_parser); << 
824   return retval;                               << 
825 }                                              << 
826                                                << 
827                                                << 
828 /*                                             << 
829  * The Evaluator coroutine and associated type << 
830  */                                            << 
831 struct func_eval_params                        << 
832 {                                              << 
833   const struct syntax_node *e;                 << 
834   const char **var_name;                       << 
835   int *var_val;                                << 
836   int nb_vars;                                 << 
837                                                << 
838   int result;                                  << 
839 };                                             << 
840                                                << 
841 static void func_eval(struct func_eval_params  << 
842 {                                              << 
843   /* The internal (recursive) nested function  << 
844      the syntax tree */                        << 
845   static int rec_eval(const struct syntax_node << 
846                       const char* var_name[],  << 
847     {                                          << 
848       switch (n->type)                         << 
849         {                                      << 
850         case YY_IS_NUM:                        << 
851           return n->number;                    << 
852                                                << 
853         case YY_IS_VAR:                        << 
854           {                                    << 
855             int i;                             << 
856             for (i = 0 ; i < nb_vars ; i++)    << 
857               if (0 == strcmp(var_name[i], n-> << 
858                 return var_val[i];             << 
859                                                << 
860             /* Exception: no variable with tha << 
861             sos_bochs_printf("ERROR: unknown v << 
862             sos_cpu_kstate_switch(& st_eval, s << 
863           }                                    << 
864                                                << 
865         case YY_IS_BINOP:                      << 
866           {                                    << 
867             int left = rec_eval(n->binop.parm_ << 
868                                 var_name, var_ << 
869             int right = rec_eval(n->binop.parm << 
870                                  var_name, var << 
871             switch (n->binop.op)               << 
872               {                                << 
873               case '+': return left + right;   << 
874               case '-': return left - right;   << 
875               case '*': return left * right;   << 
876               case '/': return left / right;   << 
877               default:                         << 
878                 /* Exception: no such operator << 
879                 sos_bochs_printf("ERROR: unkno << 
880                 sos_cpu_kstate_switch(& st_eva << 
881               }                                << 
882           }                                    << 
883                                                << 
884         case YY_IS_UNAROP:                     << 
885           {                                    << 
886             int arg = rec_eval(n->unarop.parm, << 
887             switch (n->unarop.op)              << 
888               {                                << 
889               case '-': return -arg;           << 
890               case '+': return arg;            << 
891               default:                         << 
892                 /* Exception: no such operator << 
893                 sos_bochs_printf("ERROR: unkno << 
894                 sos_cpu_kstate_switch(& st_eva << 
895               }                                << 
896           }                                    << 
897         }                                      << 
898                                                << 
899       /* Exception: no such syntax node (INTER << 
900       sos_bochs_printf("ERROR: invalid node ty << 
901       sos_cpu_kstate_switch(& st_eval, st_main << 
902       return -1; /* let's make gcc happy */    << 
903     }                                          << 
904                                                << 
905                                                << 
906   /*                                           << 
907    * Function BODY                             << 
908    */                                          << 
909   /* Update p.result returned back to calling  << 
910   parms->result                                << 
911     = rec_eval(parms->e, parms->var_name, parm << 
912 }                                              << 
913                                                << 
914 /*                                             << 
915  * Change the stack for something larger in or << 
916  * recursive function above in a safe way      << 
917  */                                            << 
918 static int eval_expression(const struct syntax << 
919                            const char* var_nam << 
920 {                                              << 
921   struct func_eval_params p                    << 
922     = (struct func_eval_params){ .e=e,         << 
923                                  .var_name=var << 
924                                  .var_val=var_ << 
925                                  .nb_vars=nb_v << 
926                                  .result = 0 } << 
927                                                << 
928   sos_cpu_kstate_init(& st_eval,               << 
929                       (sos_cpu_kstate_function << 
930                       (sos_ui32_t)/* p.result  << 
931                       (sos_vaddr_t)deep_stack, << 
932                       (sos_cpu_kstate_function << 
933                                                << 
934   /* Go ! */                                   << 
935   sos_cpu_kstate_switch(& st_main, st_eval);   << 
936   return p.result;                             << 
937 }                                              << 
938                                                << 
939                                                << 
940 /*                                             << 
941  * Function to free the syntax tree            << 
942  */                                            << 
943 static void func_free(struct syntax_node *n)   << 
944 {                                              << 
945   switch (n->type)                             << 
946     {                                          << 
947     case YY_IS_NUM:                            << 
948     case YY_IS_VAR:                            << 
949       break;                                   << 
950                                                << 
951     case YY_IS_BINOP:                          << 
952       func_free(n->binop.parm_left);           << 
953       func_free(n->binop.parm_right);          << 
954       break;                                   << 
955                                                << 
956     case YY_IS_UNAROP:                         << 
957       func_free(n->unarop.parm);               << 
958       break;                                   << 
959     }                                          << 
960                                                << 
961   sos_kfree((sos_vaddr_t)n);                   << 
962 }                                              << 
963                                                << 
964 /*                                             << 
965  * Change the stack for something larger in or << 
966  * recursive function above in a safe way      << 
967  */                                            << 
968 static void free_syntax_tree(struct syntax_nod << 
969 {                                              << 
970   sos_cpu_kstate_init(& st_free,               << 
971                       (sos_cpu_kstate_function << 
972                       (sos_ui32_t)tree,        << 
973                       (sos_vaddr_t)deep_stack, << 
974                       (sos_cpu_kstate_function << 
975                                                << 
976   /* Go ! */                                   << 
977   sos_cpu_kstate_switch(& st_main, st_free);   << 
978 }                                                 322 }
979                                                   323 
980                                                   324 
981 /* ===========================================    325 /* ======================================================================
982  * The C entry point of our operating system      326  * The C entry point of our operating system
983  */                                               327  */
984 void sos_main(unsigned long magic, unsigned lo    328 void sos_main(unsigned long magic, unsigned long addr)
985 {                                                 329 {
986   unsigned i;                                     330   unsigned i;
987   sos_paddr_t sos_kernel_core_base_paddr, sos_    331   sos_paddr_t sos_kernel_core_base_paddr, sos_kernel_core_top_paddr;
988   struct syntax_node *syntax_tree;             !! 332   struct sos_time tick_resolution;
989                                                   333 
990   /* Grub sends us a structure, called multibo    334   /* Grub sends us a structure, called multiboot_info_t with a lot of
991      precious informations about the system, s    335      precious informations about the system, see the multiboot
992      documentation for more information. */       336      documentation for more information. */
993   multiboot_info_t *mbi;                          337   multiboot_info_t *mbi;
994   mbi = (multiboot_info_t *) addr;                338   mbi = (multiboot_info_t *) addr;
995                                                   339 
996   /* Setup bochs and console, and clear the co    340   /* Setup bochs and console, and clear the console */
997   sos_bochs_setup();                              341   sos_bochs_setup();
998                                                   342 
999   sos_x86_videomem_setup();                       343   sos_x86_videomem_setup();
1000   sos_x86_videomem_cls(SOS_X86_VIDEO_BG_BLUE)    344   sos_x86_videomem_cls(SOS_X86_VIDEO_BG_BLUE);
1001                                                  345 
1002   /* Greetings from SOS */                       346   /* Greetings from SOS */
1003   if (magic == MULTIBOOT_BOOTLOADER_MAGIC)       347   if (magic == MULTIBOOT_BOOTLOADER_MAGIC)
1004     /* Loaded with Grub */                       348     /* Loaded with Grub */
1005     sos_x86_videomem_printf(1, 0,                349     sos_x86_videomem_printf(1, 0,
1006                             SOS_X86_VIDEO_FG_    350                             SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
1007                             "Welcome From GRU    351                             "Welcome From GRUB to %s%c RAM is %dMB (upper mem = 0x%x kB)",
1008                             "SOS", ',',       !! 352                             "SOS article 7.5", ',',
1009                             (unsigned)(mbi->m    353                             (unsigned)(mbi->mem_upper >> 10) + 1,
1010                             (unsigned)mbi->me    354                             (unsigned)mbi->mem_upper);
1011   else                                           355   else
1012     /* Not loaded with grub */                   356     /* Not loaded with grub */
1013     sos_x86_videomem_printf(1, 0,                357     sos_x86_videomem_printf(1, 0,
1014                             SOS_X86_VIDEO_FG_    358                             SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
1015                             "Welcome to SOS") !! 359                             "Welcome to SOS article 7.5");
1016                                                  360 
1017   sos_bochs_putstring("Message in a bochs\n") !! 361   sos_bochs_putstring("Message in a bochs: This is SOS article 7.5.\n");
1018                                                  362 
1019   /* Setup CPU segmentation and IRQ subsystem    363   /* Setup CPU segmentation and IRQ subsystem */
1020   sos_gdt_subsystem_setup();                     364   sos_gdt_subsystem_setup();
1021   sos_idt_subsystem_setup();                     365   sos_idt_subsystem_setup();
1022                                                  366 
1023   /* Setup SOS IRQs and exceptions subsystem     367   /* Setup SOS IRQs and exceptions subsystem */
1024   sos_exception_subsystem_setup();               368   sos_exception_subsystem_setup();
1025   sos_irq_subsystem_setup();                     369   sos_irq_subsystem_setup();
1026                                                  370 
1027   /* Configure the timer so as to raise the I    371   /* Configure the timer so as to raise the IRQ0 at a 100Hz rate */
1028   sos_i8254_set_frequency(100);                  372   sos_i8254_set_frequency(100);
1029                                                  373 
                                                   >> 374   /* Setup the kernel time subsystem to get prepared to take the timer
                                                   >> 375      ticks into account */
                                                   >> 376   tick_resolution = (struct sos_time) { .sec=0, .nanosec=10000000UL };
                                                   >> 377   sos_time_subsysem_setup(& tick_resolution);
                                                   >> 378 
1030   /* We need a multiboot-compliant boot loade    379   /* We need a multiboot-compliant boot loader to get the size of the RAM */
1031   if (magic != MULTIBOOT_BOOTLOADER_MAGIC)       380   if (magic != MULTIBOOT_BOOTLOADER_MAGIC)
1032     {                                            381     {
1033       sos_x86_videomem_putstring(20, 0,          382       sos_x86_videomem_putstring(20, 0,
1034                                  SOS_X86_VIDE    383                                  SOS_X86_VIDEO_FG_LTRED
1035                                    | SOS_X86_    384                                    | SOS_X86_VIDEO_BG_BLUE
1036                                    | SOS_X86_    385                                    | SOS_X86_VIDEO_FG_BLINKING,
1037                                  "I'm not loa    386                                  "I'm not loaded with Grub !");
1038       /* STOP ! */                               387       /* STOP ! */
1039       for (;;)                                   388       for (;;)
1040         continue;                                389         continue;
1041     }                                            390     }
1042                                                  391 
1043   /*                                             392   /*
1044    * Some interrupt handlers                     393    * Some interrupt handlers
1045    */                                            394    */
1046                                                  395 
1047   /* Binding some HW interrupts and exception    396   /* Binding some HW interrupts and exceptions to software routines */
1048   sos_irq_set_routine(SOS_IRQ_TIMER,             397   sos_irq_set_routine(SOS_IRQ_TIMER,
1049                       clk_it);                   398                       clk_it);
1050                                                  399 
1051   /*                                             400   /*
1052    * Setup physical memory management            401    * Setup physical memory management
1053    */                                            402    */
1054                                                  403 
1055   /* Multiboot says: "The value returned for     404   /* Multiboot says: "The value returned for upper memory is maximally
1056      the address of the first upper memory ho    405      the address of the first upper memory hole minus 1 megabyte.". It
1057      also adds: "It is not guaranteed to be t    406      also adds: "It is not guaranteed to be this value." aka "YMMV" ;) */
1058   sos_physmem_subsystem_setup((mbi->mem_upper    407   sos_physmem_subsystem_setup((mbi->mem_upper<<10) + (1<<20),
1059                               & sos_kernel_co    408                               & sos_kernel_core_base_paddr,
1060                               & sos_kernel_co    409                               & sos_kernel_core_top_paddr);
1061                                                  410   
1062   /*                                             411   /*
1063    * Switch to paged-memory mode                 412    * Switch to paged-memory mode
1064    */                                            413    */
1065                                                  414 
1066   /* Disabling interrupts should seem more co    415   /* Disabling interrupts should seem more correct, but it's not really
1067      necessary at this stage */                  416      necessary at this stage */
1068   SOS_ASSERT_FATAL(SOS_OK ==                     417   SOS_ASSERT_FATAL(SOS_OK ==
1069                    sos_paging_subsystem_setup    418                    sos_paging_subsystem_setup(sos_kernel_core_base_paddr,
1070                                                  419                                               sos_kernel_core_top_paddr));
1071                                                  420   
1072   /* Bind the page fault exception */            421   /* Bind the page fault exception */
1073   sos_exception_set_routine(SOS_EXCEPT_PAGE_F    422   sos_exception_set_routine(SOS_EXCEPT_PAGE_FAULT,
1074                             pgflt_ex);           423                             pgflt_ex);
1075                                                  424 
1076   /*                                             425   /*
1077    * Setup kernel virtual memory allocator       426    * Setup kernel virtual memory allocator
1078    */                                         !! 427    */
1079                                                  428 
1080   if (sos_kmem_vmm_subsystem_setup(sos_kernel    429   if (sos_kmem_vmm_subsystem_setup(sos_kernel_core_base_paddr,
1081                                    sos_kernel    430                                    sos_kernel_core_top_paddr,
1082                                    bootstrap_    431                                    bootstrap_stack_bottom,
1083                                    bootstrap_    432                                    bootstrap_stack_bottom
1084                                    + bootstra    433                                    + bootstrap_stack_size))
1085     sos_bochs_printf("Could not setup the Ker    434     sos_bochs_printf("Could not setup the Kernel virtual space allocator\n");
1086                                                  435 
1087   if (sos_kmalloc_subsystem_setup())             436   if (sos_kmalloc_subsystem_setup())
1088     sos_bochs_printf("Could not setup the Kma    437     sos_bochs_printf("Could not setup the Kmalloc subsystem\n");
1089                                                  438 
1090   /*                                             439   /*
1091    * Enabling the HW interrupts here, this wi !! 440    * Initialize the MMU context subsystem
1092    * interrupt call our clk_it handler        << 
1093    */                                            441    */
1094   asm volatile ("sti\n");                     !! 442   sos_mm_context_subsystem_setup();
1095                                                  443 
1096   /*                                             444   /*
1097    * Print hello world using coroutines       !! 445    * Initialize the CPU context subsystem
1098    */                                            446    */
1099   print_hello_world();                        !! 447   sos_cpu_context_subsystem_setup();
1100                                               << 
1101                                                  448 
1102   /*                                             449   /*
1103    * Run coroutine tests                      !! 450    * Bind the syscall handler to its software interrupt handler
1104    */                                            451    */
1105   sos_x86_videomem_printf(4, 0,               !! 452   sos_swintr_subsystem_setup();
1106                           SOS_X86_VIDEO_BG_BL << 
1107                           "Coroutine test");  << 
1108   sos_x86_videomem_printf(5, 0,               << 
1109                           SOS_X86_VIDEO_BG_BL << 
1110                           "Parsing...");      << 
1111   syntax_tree = parse_expression(" -  ( (69/  << 
1112                                                  453 
1113   if (syntax_tree != NULL)                    << 
1114     {                                         << 
1115       sos_x86_videomem_printf(6, 0,           << 
1116                               SOS_X86_VIDEO_B << 
1117                               "Evaluating..." << 
1118       sos_x86_videomem_printf(7, 0,           << 
1119                               SOS_X86_VIDEO_B << 
1120                               "Result=%d (if  << 
1121                               eval_expression << 
1122                                               << 
1123                                               << 
1124                                               << 
1125       free_syntax_tree(syntax_tree);          << 
1126       sos_x86_videomem_printf(8, 0,           << 
1127                               SOS_X86_VIDEO_B << 
1128                               "Done (un-alloc << 
1129     }                                         << 
1130   else                                        << 
1131     {                                         << 
1132       sos_x86_videomem_printf(6, 0,           << 
1133                               SOS_X86_VIDEO_B << 
1134                               "Error in parsi << 
1135     }                                         << 
1136                                                  454 
1137   /*                                             455   /*
1138    * Run some demand-paging tests             !! 456    * Initialize the Kernel thread and scheduler subsystems
1139    */                                            457    */
1140   test_demand_paging(234567, 500);            !! 458   
                                                   >> 459   /* Initialize kernel thread subsystem */
                                                   >> 460   sos_thread_subsystem_setup(bootstrap_stack_bottom,
                                                   >> 461                              bootstrap_stack_size);
                                                   >> 462 
                                                   >> 463   /* Initialize the scheduler */
                                                   >> 464   sos_sched_subsystem_setup();
                                                   >> 465 
                                                   >> 466   /* Declare the IDLE thread */
                                                   >> 467   SOS_ASSERT_FATAL(sos_create_kernel_thread("idle", idle_thread, NULL,
                                                   >> 468                                             SOS_SCHED_PRIO_TS_LOWEST) != NULL);
                                                   >> 469 
                                                   >> 470   /* Prepare the stats subsystem */
                                                   >> 471   sos_load_subsystem_setup();
                                                   >> 472 
                                                   >> 473   /* Declare a thread that prints some stats */
                                                   >> 474   SOS_ASSERT_FATAL(sos_create_kernel_thread("stat_thread", stat_thread,
                                                   >> 475                                             NULL,
                                                   >> 476                                             SOS_SCHED_PRIO_TS_LOWEST) != NULL);
1141                                                  477 
1142                                                  478 
1143   /*                                             479   /*
1144    * Create an un-resolved page fault, which  !! 480    * Initialise user address space management subsystem
1145    * handler print the backtrace.             << 
1146    */                                            481    */
1147   test_backtrace(6, 0xdeadbeef, bootstrap_sta !! 482   sos_umem_vmm_subsystem_setup();
                                                   >> 483   sos_dev_zero_subsystem_setup();
1148                                                  484 
1149   /*                                             485   /*
1150    * System should be halted BEFORE here !    !! 486    * Initialize process stuff
1151    */                                            487    */
                                                   >> 488   sos_process_subsystem_setup();
1152                                                  489 
1153                                                  490 
1154   /* An operatig system never ends */         !! 491   /* Enabling the HW interrupts here, this will make the timer HW
1155   for (;;)                                    !! 492      interrupt call the scheduler */
1156     {                                         !! 493   asm volatile ("sti\n");
1157       /* Remove this instruction if you get a << 
1158          exception (old 80386 CPU) */         << 
1159       asm("hlt\n");                           << 
1160                                                  494 
1161       continue;                               !! 495   /* Start the 'init' process, which in turns launches the other
1162     }                                         !! 496      programs */
                                                   >> 497   start_init();
                                                   >> 498 
                                                   >> 499   /*
                                                   >> 500    * We can safely exit from this function now, for there is already
                                                   >> 501    * an idle Kernel thread ready to make the CPU busy working...
                                                   >> 502    *
                                                   >> 503    * However, we must EXPLICITELY call sos_thread_exit() because a
                                                   >> 504    * simple "return" will return nowhere ! Actually this first thread
                                                   >> 505    * was initialized by the Grub bootstrap stage, at a time when the
                                                   >> 506    * word "thread" did not exist. This means that the stack was not
                                                   >> 507    * setup in order for a return here to call sos_thread_exit()
                                                   >> 508    * automagically. Hence we must call it manually. This is the ONLY
                                                   >> 509    * kernel thread where we must do this manually.
                                                   >> 510    */
                                                   >> 511   sos_bochs_printf("Bye from primary thread !\n");
                                                   >> 512   sos_thread_exit();
                                                   >> 513   SOS_FATAL_ERROR("No trespassing !");
1163 }                                                514 }
                                                      

source navigation ] diff markup ] identifier search ] general search ]