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.5) and /sos/main.c (Article 3)


001 /* Copyright (C) 2004  The SOS Team               001 /* Copyright (C) 2004  The SOS Team
                                                   >> 002    Copyright (C) 1999  Free Software Foundation, Inc.
002                                                   003 
003    This program is free software; you can redi    004    This program is free software; you can redistribute it and/or
004    modify it under the terms of the GNU Genera    005    modify it under the terms of the GNU General Public License
005    as published by the Free Software Foundatio    006    as published by the Free Software Foundation; either version 2
006    of the License, or (at your option) any lat    007    of the License, or (at your option) any later version.
007                                                   008    
008    This program is distributed in the hope tha    009    This program is distributed in the hope that it will be useful,
009    but WITHOUT ANY WARRANTY; without even the     010    but WITHOUT ANY WARRANTY; without even the implied warranty of
010    MERCHANTABILITY or FITNESS FOR A PARTICULAR    011    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
011    GNU General Public License for more details    012    GNU General Public License for more details.
012                                                   013    
013    You should have received a copy of the GNU     014    You should have received a copy of the GNU General Public License
014    along with this program; if not, write to t    015    along with this program; if not, write to the Free Software
015    Foundation, Inc., 59 Temple Place - Suite 3    016    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
016    USA.                                           017    USA. 
017 */                                                018 */
018                                                   019 
019 /* Include definitions of the multiboot standa    020 /* Include definitions of the multiboot standard */
020 #include <bootstrap/multiboot.h>                  021 #include <bootstrap/multiboot.h>
021 #include <hwcore/idt.h>                           022 #include <hwcore/idt.h>
022 #include <hwcore/gdt.h>                           023 #include <hwcore/gdt.h>
023 #include <hwcore/irq.h>                           024 #include <hwcore/irq.h>
024 #include <hwcore/exception.h>                     025 #include <hwcore/exception.h>
025 #include <hwcore/i8254.h>                         026 #include <hwcore/i8254.h>
026 #include <sos/list.h>                             027 #include <sos/list.h>
027 #include <sos/physmem.h>                          028 #include <sos/physmem.h>
028 #include <hwcore/paging.h>                     << 
029 #include <sos/kmem_vmm.h>                      << 
030 #include <sos/kmalloc.h>                       << 
031 #include <sos/time.h>                          << 
032 #include <sos/thread.h>                        << 
033 #include <sos/klibc.h>                            029 #include <sos/klibc.h>
034 #include <sos/assert.h>                           030 #include <sos/assert.h>
035 #include <drivers/x86_videomem.h>                 031 #include <drivers/x86_videomem.h>
036 #include <drivers/bochs.h>                        032 #include <drivers/bochs.h>
037                                                   033 
038                                                   034 
039 /* Helper function to display each bits of a 3    035 /* Helper function to display each bits of a 32bits integer on the
040    screen as dark or light carrets */             036    screen as dark or light carrets */
041 void display_bits(unsigned char row, unsigned  !! 037 static void display_bits(unsigned char row, unsigned char col,
042                   unsigned char attribute,     !! 038                          unsigned char attribute,
043                   sos_ui32_t integer)          !! 039                          sos_ui32_t integer)
044 {                                                 040 {
045   int i;                                          041   int i;
046   /* Scan each bit of the integer, MSb first *    042   /* Scan each bit of the integer, MSb first */
047   for (i = 31 ; i >= 0 ; i--)                     043   for (i = 31 ; i >= 0 ; i--)
048     {                                             044     {
049       /* Test if bit i of 'integer' is set */     045       /* Test if bit i of 'integer' is set */
050       int bit_i = (integer & (1 << i));           046       int bit_i = (integer & (1 << i));
051       /* Ascii 219 => dark carret, Ascii 177 =    047       /* Ascii 219 => dark carret, Ascii 177 => light carret */
052       unsigned char ascii_code = bit_i?219:177    048       unsigned char ascii_code = bit_i?219:177;
053       sos_x86_videomem_putchar(row, col++,        049       sos_x86_videomem_putchar(row, col++,
054                                attribute,         050                                attribute,
055                                ascii_code);       051                                ascii_code);
056     }                                             052     }
057 }                                                 053 }
058                                                   054 
059                                                   055 
060 /* Clock IRQ handler */                           056 /* Clock IRQ handler */
061 static void clk_it(int intid)                     057 static void clk_it(int intid)
062 {                                                 058 {
063   static sos_ui32_t clock_count = 0;              059   static sos_ui32_t clock_count = 0;
064                                                   060 
065   display_bits(0, 48,                             061   display_bits(0, 48,
066                SOS_X86_VIDEO_FG_LTGREEN | SOS_    062                SOS_X86_VIDEO_FG_LTGREEN | SOS_X86_VIDEO_BG_BLUE,
067                clock_count);                      063                clock_count);
068   clock_count++;                                  064   clock_count++;
069                                                   065 
070   /* Execute the expired timeout actions (if a << 
071   sos_time_do_tick();                          << 
072 }                                                 066 }
073                                                   067 
074                                                !! 068 #define MY_PPAGE_NUM_INT 511
075 /* =========================================== !! 069 struct my_ppage
076  * Page fault exception handling               << 
077  */                                            << 
078                                                << 
079 /* Helper function to dump a backtrace on boch << 
080 static void dump_backtrace(const struct sos_cp << 
081                            sos_vaddr_t stack_b << 
082                            sos_size_t  stack_s << 
083                            sos_bool_t on_conso << 
084                            sos_bool_t on_bochs << 
085 {                                                 070 {
086   static void backtracer(sos_vaddr_t PC,       !! 071   sos_ui32_t before[MY_PPAGE_NUM_INT];
087                          sos_vaddr_t params,   !! 072   struct my_ppage *prev, *next;
088                          sos_ui32_t depth,     !! 073   sos_ui32_t after[MY_PPAGE_NUM_INT];
089                          void *custom_arg)     !! 074 }; /* sizeof() Must be <= 4kB */
                                                   >> 075 
                                                   >> 076 static void test_physmem()
                                                   >> 077 {
                                                   >> 078   /* We place the pages we did allocate here */
                                                   >> 079   struct my_ppage *ppage_list, *my_ppage;
                                                   >> 080   sos_count_t num_alloc_ppages = 0, num_free_ppages = 0;
                                                   >> 081 
                                                   >> 082   ppage_list = NULL;
                                                   >> 083   while ((my_ppage = (struct my_ppage*)sos_physmem_ref_physpage_new(FALSE))
                                                   >> 084          != NULL)
090     {                                             085     {
091       sos_ui32_t invalid = 0xffffffff, *arg1,  !! 086       int i;
092                                                !! 087       num_alloc_ppages++;
093       /* Get the address of the first 3 argume << 
094          frame. Among these arguments, 0, 1, 2 << 
095          meaningful (depending on how many arg << 
096          take). */                             << 
097       arg1 = (sos_ui32_t*)params;              << 
098       arg2 = (sos_ui32_t*)(params+4);          << 
099       arg3 = (sos_ui32_t*)(params+8);          << 
100       arg4 = (sos_ui32_t*)(params+12);         << 
101                                                << 
102       /* Make sure the addresses of these argu << 
103          stack boundaries */                   << 
104 #define INTERVAL_OK(b,v,u) ( ((b) <= (sos_vadd << 
105                              && ((sos_vaddr_t) << 
106       if (!INTERVAL_OK(stack_bottom, arg1, sta << 
107         arg1 = &invalid;                       << 
108       if (!INTERVAL_OK(stack_bottom, arg2, sta << 
109         arg2 = &invalid;                       << 
110       if (!INTERVAL_OK(stack_bottom, arg3, sta << 
111         arg3 = &invalid;                       << 
112       if (!INTERVAL_OK(stack_bottom, arg4, sta << 
113         arg4 = &invalid;                       << 
114                                                << 
115       /* Print the function context for this f << 
116       if (on_bochs)                            << 
117         sos_bochs_printf("[%d] PC=0x%x arg1=0x << 
118                          (unsigned)depth, (uns << 
119                          (unsigned)*arg1, (uns << 
120                          (unsigned)*arg3);     << 
121                                                << 
122       if (on_console)                          << 
123         sos_x86_videomem_printf(23-depth, 3,   << 
124                                 SOS_X86_VIDEO_ << 
125                                   | SOS_X86_VI << 
126                                 "[%d] PC=0x%x  << 
127                                 (unsigned)dept << 
128                                 (unsigned)*arg << 
129                                 (unsigned)*arg << 
130                                                   088       
131     }                                          !! 089       /* Print the allocation status */
132                                                !! 090       sos_x86_videomem_printf(2, 0,
133   sos_backtrace(cpu_state, 15, stack_bottom, s !! 091                               SOS_X86_VIDEO_FG_YELLOW
134 }                                              !! 092                               | SOS_X86_VIDEO_BG_BLUE,
135                                                !! 093                               "Could allocate %d pages      ",
136                                                !! 094                               num_alloc_ppages);
137 /* Page fault exception handler with demand pa !! 095 
138 static void pgflt_ex(int intid, const struct s !! 096       /* We fill this page with its address */
139 {                                              !! 097       for (i = 0 ; i < MY_PPAGE_NUM_INT ; i++)
140   static sos_ui32_t demand_paging_count = 0;   !! 098         my_ppage->before[i] = my_ppage->after[i] = (sos_ui32_t)my_ppage;
141   sos_vaddr_t faulting_vaddr = sos_cpu_context !! 099 
142   sos_paddr_t ppage_paddr;                     !! 100       /* We add this page at the tail of our list of ppages */
143                                                !! 101       list_add_tail(ppage_list, my_ppage);
144   /* Check if address is covered by any VMM ra !! 102     }
145   if (! sos_kmem_vmm_is_valid_vaddr(faulting_v !! 103 
146     {                                          !! 104   /* Now we release these pages in FIFO order */
147       /* No: The page fault is out of any kern !! 105   while ((my_ppage = list_pop_head(ppage_list)) != NULL)
148          the moment, we don't handle this. */  !! 106     {
149       dump_backtrace(ctxt,                     !! 107       /* We make sure this page was not overwritten by any unexpected
150                      bootstrap_stack_bottom,   !! 108          value */
151                      bootstrap_stack_size,     !! 109       int i;
152                      TRUE, TRUE);              !! 110       for (i = 0 ; i < MY_PPAGE_NUM_INT ; i++)
153       sos_display_fatal_error("Unresolved page << 
154                               sos_cpu_context_ << 
155                               (unsigned)faulti << 
156                               (unsigned)sos_cp << 
157       SOS_ASSERT_FATAL(! "Got page fault (note << 
158     }                                          << 
159                                                << 
160                                                << 
161   /*                                           << 
162    * Demand paging                             << 
163    */                                          << 
164                                                << 
165   /* Update the number of demand paging reques << 
166   demand_paging_count ++;                      << 
167   display_bits(0, 0,                           << 
168                SOS_X86_VIDEO_FG_LTRED | SOS_X8 << 
169                demand_paging_count);           << 
170                                                << 
171   /* Allocate a new page for the virtual addre << 
172   ppage_paddr = sos_physmem_ref_physpage_new(F << 
173   if (! ppage_paddr)                           << 
174     SOS_ASSERT_FATAL(! "TODO: implement swap.  << 
175   SOS_ASSERT_FATAL(SOS_OK == sos_paging_map(pp << 
176                                             SO << 
177                                             FA << 
178                                             SO << 
179                                             |  << 
180                                             |  << 
181   sos_physmem_unref_physpage(ppage_paddr);     << 
182                                                << 
183   /* Ok, we can now return to interrupted cont << 
184 }                                              << 
185                                                << 
186                                                << 
187 /* =========================================== << 
188  * Demonstrate the use of SOS kernel threads   << 
189  *  - Kernel Threads are created with various  << 
190  *    state is printed on both the console and << 
191  *  - For tests regarding threads' synchroniza << 
192  */                                            << 
193                                                << 
194 struct thr_arg                                 << 
195 {                                              << 
196   char character;                              << 
197   int  color;                                  << 
198                                                << 
199   int col;                                     << 
200   int row;                                     << 
201 };                                             << 
202                                                << 
203                                                << 
204 static void demo_thread(void *arg)             << 
205 {                                              << 
206   struct thr_arg *thr_arg = (struct thr_arg*)a << 
207   int progress = 0;                            << 
208                                                << 
209   sos_bochs_printf("start %c", thr_arg->charac << 
210   while (1)                                    << 
211     {                                          << 
212       progress ++;                             << 
213       display_bits(thr_arg->row, thr_arg->col+ << 
214                                                << 
215       sos_bochs_putchar(thr_arg->character);   << 
216                                                << 
217       /* Yield the CPU to another thread somet << 
218       if ((random() % 100) == 0)               << 
219         {                                      << 
220           sos_bochs_printf("yield(%c)\ << 
221           sos_x86_videomem_putchar(thr_arg->ro << 
222           SOS_ASSERT_FATAL(SOS_OK == sos_threa << 
223           sos_x86_videomem_putchar(thr_arg->ro << 
224         }                                      << 
225                                                << 
226       /* Go to sleep some other times... */    << 
227       else if ((random() % 200) == 0)          << 
228         {                                         111         {
229           struct sos_time t = (struct sos_time !! 112           /* We don't get what we expect ! */
230           sos_bochs_printf("sleep1(%c) !! 113           if ((my_ppage->before[i] !=  (sos_ui32_t)my_ppage)
231           sos_x86_videomem_putchar(thr_arg->ro !! 114               || (my_ppage->after[i] !=  (sos_ui32_t)my_ppage))
232           SOS_ASSERT_FATAL(SOS_OK == sos_threa !! 115             {
233           SOS_ASSERT_FATAL(sos_time_is_zero(&  !! 116               /* STOP ! */
234           sos_x86_videomem_putchar(thr_arg->ro !! 117               sos_x86_videomem_putstring(20, 0,
                                                   >> 118                                          SOS_X86_VIDEO_FG_LTRED
                                                   >> 119                                            | SOS_X86_VIDEO_BG_BLUE,
                                                   >> 120                                          "Page overwritten");
                                                   >> 121               return;
                                                   >> 122             }
235         }                                         123         }
236                                                   124 
237       /* Go to sleep for a longer time some ot !! 125       /* Release the descriptor */
238       else if ((random() % 300) == 0)          !! 126       if (sos_physmem_unref_physpage((sos_paddr_t)my_ppage) < 0)
239         {                                         127         {
240           struct sos_time t = (struct sos_time !! 128           /* STOP ! */
241           sos_bochs_printf("sleep2(%c) !! 129           sos_x86_videomem_putstring(20, 0,
242           sos_x86_videomem_putchar(thr_arg->ro !! 130                                      SOS_X86_VIDEO_FG_LTRED
243           SOS_ASSERT_FATAL(SOS_OK == sos_threa !! 131                                        | SOS_X86_VIDEO_BG_BLUE,
244           SOS_ASSERT_FATAL(sos_time_is_zero(&  !! 132                                      "Cannot release page");
245           sos_x86_videomem_putchar(thr_arg->ro !! 133           return;
246         }                                         134         }
247                                                   135 
248       /* Infinite loop otherwise */            !! 136       /* Print the deallocation status */
                                                   >> 137       num_free_ppages ++;
                                                   >> 138       sos_x86_videomem_printf(2, 0,
                                                   >> 139                               SOS_X86_VIDEO_FG_YELLOW
                                                   >> 140                               | SOS_X86_VIDEO_BG_BLUE,
                                                   >> 141                               "Could free %d pages      ",
                                                   >> 142                               num_free_ppages);
249     }                                             143     }
250 }                                              << 
251                                                << 
252                                                << 
253 static void test_thread()                      << 
254 {                                              << 
255   /* "static" variables because we want them t << 
256      function returns */                       << 
257   static struct thr_arg arg_b, arg_c, arg_d, a << 
258   sos_ui32_t flags;                            << 
259                                                << 
260   sos_disable_IRQs(flags);                     << 
261                                                << 
262   arg_b = (struct thr_arg) { .character='b', . << 
263   sos_create_kernel_thread("YO[b]", demo_threa << 
264                                                << 
265   arg_c = (struct thr_arg) { .character='c', . << 
266   sos_create_kernel_thread("YO[c]", demo_threa << 
267                                                << 
268   arg_d = (struct thr_arg) { .character='d', . << 
269   sos_create_kernel_thread("YO[d]", demo_threa << 
270                                                   144 
271   arg_e = (struct thr_arg) { .character='e', . !! 145   /* Print the overall stats */
272   sos_create_kernel_thread("YO[e]", demo_threa !! 146   sos_x86_videomem_printf(2, 0,
                                                   >> 147                           SOS_X86_VIDEO_FG_LTGREEN
                                                   >> 148                           | SOS_X86_VIDEO_BG_BLUE,
                                                   >> 149                           "Could allocate %d bytes, could free %d bytes     ",
                                                   >> 150                           num_alloc_ppages << SOS_PAGE_SHIFT,
                                                   >> 151                           num_free_ppages << SOS_PAGE_SHIFT);
273                                                   152 
274   arg_R = (struct thr_arg) { .character='R', . !! 153   SOS_ASSERT_FATAL(num_alloc_ppages == num_free_ppages);
275   sos_create_kernel_thread("YO[R]", demo_threa << 
276                                                << 
277   arg_S = (struct thr_arg) { .character='S', . << 
278   sos_create_kernel_thread("YO[S]", demo_threa << 
279                                                << 
280   sos_restore_IRQs(flags);                     << 
281 }                                                 154 }
282                                                   155 
283                                                   156 
284 /* =========================================== !! 157 /* The C entry point of our operating system */
285  * An operating system MUST always have a read << 
286  * what would the CPU have to execute ?!       << 
287  */                                            << 
288 static void idle_thread()                      << 
289 {                                              << 
290   sos_ui32_t idle_twiddle = 0;                 << 
291                                                << 
292   while (1)                                    << 
293     {                                          << 
294       /* Remove this instruction if you get an << 
295          exception (old 80386 CPU) */          << 
296       asm("hlt\n");                            << 
297                                                << 
298       idle_twiddle ++;                         << 
299       display_bits(0, 0, SOS_X86_VIDEO_FG_GREE << 
300                    idle_twiddle);              << 
301                                                << 
302       /* Lend the CPU to some other thread */  << 
303       sos_thread_yield();                      << 
304     }                                          << 
305 }                                              << 
306                                                << 
307                                                << 
308 /* =========================================== << 
309  * The C entry point of our operating system   << 
310  */                                            << 
311 void sos_main(unsigned long magic, unsigned lo    158 void sos_main(unsigned long magic, unsigned long addr)
312 {                                                 159 {
313   unsigned i;                                     160   unsigned i;
314   sos_paddr_t sos_kernel_core_base_paddr, sos_    161   sos_paddr_t sos_kernel_core_base_paddr, sos_kernel_core_top_paddr;
315   struct sos_time tick_resolution;             << 
316                                                   162 
317   /* Grub sends us a structure, called multibo    163   /* Grub sends us a structure, called multiboot_info_t with a lot of
318      precious informations about the system, s    164      precious informations about the system, see the multiboot
319      documentation for more information. */       165      documentation for more information. */
320   multiboot_info_t *mbi;                          166   multiboot_info_t *mbi;
321   mbi = (multiboot_info_t *) addr;                167   mbi = (multiboot_info_t *) addr;
322                                                   168 
323   /* Setup bochs and console, and clear the co    169   /* Setup bochs and console, and clear the console */
324   sos_bochs_setup();                              170   sos_bochs_setup();
325                                                   171 
326   sos_x86_videomem_setup();                       172   sos_x86_videomem_setup();
327   sos_x86_videomem_cls(SOS_X86_VIDEO_BG_BLUE);    173   sos_x86_videomem_cls(SOS_X86_VIDEO_BG_BLUE);
328                                                   174 
329   /* Greetings from SOS */                        175   /* Greetings from SOS */
330   if (magic == MULTIBOOT_BOOTLOADER_MAGIC)        176   if (magic == MULTIBOOT_BOOTLOADER_MAGIC)
331     /* Loaded with Grub */                        177     /* Loaded with Grub */
332     sos_x86_videomem_printf(1, 0,                 178     sos_x86_videomem_printf(1, 0,
333                             SOS_X86_VIDEO_FG_Y    179                             SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
334                             "Welcome From GRUB    180                             "Welcome From GRUB to %s%c RAM is %dMB (upper mem = 0x%x kB)",
335                             "SOS article 6.5", !! 181                             "SOS", ',',
336                             (unsigned)(mbi->me    182                             (unsigned)(mbi->mem_upper >> 10) + 1,
337                             (unsigned)mbi->mem    183                             (unsigned)mbi->mem_upper);
338   else                                            184   else
339     /* Not loaded with grub */                    185     /* Not loaded with grub */
340     sos_x86_videomem_printf(1, 0,                 186     sos_x86_videomem_printf(1, 0,
341                             SOS_X86_VIDEO_FG_Y    187                             SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
342                             "Welcome to SOS ar !! 188                             "Welcome to SOS");
343                                                   189 
344   sos_bochs_putstring("Message in a bochs: Thi !! 190   sos_bochs_putstring("Message in a bochs\n");
345                                                   191 
346   /* Setup CPU segmentation and IRQ subsystem     192   /* Setup CPU segmentation and IRQ subsystem */
347   sos_gdt_subsystem_setup();                   !! 193   sos_gdt_setup();
348   sos_idt_subsystem_setup();                   !! 194   sos_idt_setup();
349                                                   195 
350   /* Setup SOS IRQs and exceptions subsystem *    196   /* Setup SOS IRQs and exceptions subsystem */
351   sos_exception_subsystem_setup();             !! 197   sos_exceptions_setup();
352   sos_irq_subsystem_setup();                   !! 198   sos_irq_setup();
353                                                   199 
354   /* Configure the timer so as to raise the IR    200   /* Configure the timer so as to raise the IRQ0 at a 100Hz rate */
355   sos_i8254_set_frequency(100);                   201   sos_i8254_set_frequency(100);
356                                                   202 
357   /* Setup the kernel time subsystem to get pr << 
358      ticks into account */                     << 
359   tick_resolution = (struct sos_time) { .sec=0 << 
360   sos_time_subsysem_setup(& tick_resolution);  << 
361                                                   203 
362   /* We need a multiboot-compliant boot loader    204   /* We need a multiboot-compliant boot loader to get the size of the RAM */
363   if (magic != MULTIBOOT_BOOTLOADER_MAGIC)        205   if (magic != MULTIBOOT_BOOTLOADER_MAGIC)
364     {                                             206     {
365       sos_x86_videomem_putstring(20, 0,           207       sos_x86_videomem_putstring(20, 0,
366                                  SOS_X86_VIDEO    208                                  SOS_X86_VIDEO_FG_LTRED
367                                    | SOS_X86_V    209                                    | SOS_X86_VIDEO_BG_BLUE
368                                    | SOS_X86_V    210                                    | SOS_X86_VIDEO_FG_BLINKING,
369                                  "I'm not load    211                                  "I'm not loaded with Grub !");
370       /* STOP ! */                                212       /* STOP ! */
371       for (;;)                                    213       for (;;)
372         continue;                                 214         continue;
373     }                                             215     }
374                                                   216 
375   /*                                           << 
376    * Some interrupt handlers                   << 
377    */                                          << 
378                                                << 
379   /* Binding some HW interrupts and exceptions    217   /* Binding some HW interrupts and exceptions to software routines */
380   sos_irq_set_routine(SOS_IRQ_TIMER,              218   sos_irq_set_routine(SOS_IRQ_TIMER,
381                       clk_it);                 !! 219                             clk_it);
382                                                !! 220   /* Enabling the HW interrupts here, this will make the timer HW
383   /*                                           !! 221      interrupt call our clk_it handler */
384    * Setup physical memory management          !! 222   asm volatile ("sti\n");
385    */                                          << 
386                                                << 
387   /* Multiboot says: "The value returned for u    223   /* Multiboot says: "The value returned for upper memory is maximally
388      the address of the first upper memory hol    224      the address of the first upper memory hole minus 1 megabyte.". It
389      also adds: "It is not guaranteed to be th    225      also adds: "It is not guaranteed to be this value." aka "YMMV" ;) */
390   sos_physmem_subsystem_setup((mbi->mem_upper< !! 226   sos_physmem_setup((mbi->mem_upper<<10) + (1<<20),
391                               & sos_kernel_cor !! 227                     & sos_kernel_core_base_paddr,
392                               & sos_kernel_cor !! 228                     & sos_kernel_core_top_paddr);
393                                                !! 229   test_physmem();
394   /*                                           !! 230 
395    * Switch to paged-memory mode               !! 231   /* An operatig system never ends */
396    */                                          !! 232   for (;;)
397                                                !! 233     continue;
398   /* Disabling interrupts should seem more cor << 
399      necessary at this stage */                << 
400   SOS_ASSERT_FATAL(SOS_OK ==                   << 
401                    sos_paging_subsystem_setup( << 
402                                                << 
403                                                << 
404   /* Bind the page fault exception */          << 
405   sos_exception_set_routine(SOS_EXCEPT_PAGE_FA << 
406                             pgflt_ex);         << 
407                                                << 
408   /*                                           << 
409    * Setup kernel virtual memory allocator     << 
410    */                                          << 
411                                                << 
412   if (sos_kmem_vmm_subsystem_setup(sos_kernel_ << 
413                                    sos_kernel_ << 
414                                    bootstrap_s << 
415                                    bootstrap_s << 
416                                    + bootstrap << 
417     sos_bochs_printf("Could not setup the Kern << 
418                                                << 
419   if (sos_kmalloc_subsystem_setup())           << 
420     sos_bochs_printf("Could not setup the Kmal << 
421                                                << 
422   /*                                           << 
423    * Initialize the Kernel thread and schedule << 
424    */                                          << 
425                                                << 
426   /* Initialize kernel thread subsystem */     << 
427   sos_thread_subsystem_setup(bootstrap_stack_b << 
428                              bootstrap_stack_s << 
429                                                << 
430   /* Initialize the scheduler */               << 
431   sos_sched_subsystem_setup();                 << 
432                                                << 
433   /* Declare the IDLE thread */                << 
434   SOS_ASSERT_FATAL(sos_create_kernel_thread("i << 
435                                                << 
436   /* Enabling the HW interrupts here, this wil << 
437      interrupt call the scheduler */           << 
438   asm volatile ("sti\n");                      << 
439                                                << 
440                                                   234 
441   /* Now run some Kernel threads just for fun  !! 235   return;
442   extern void MouseSim();                      << 
443   MouseSim();                                  << 
444   test_thread();                               << 
445                                                << 
446   /*                                           << 
447    * We can safely exit from this function now << 
448    * an idle Kernel thread ready to make the C << 
449    *                                           << 
450    * However, we must EXPLICITELY call sos_thr << 
451    * simple "return" will return nowhere ! Act << 
452    * was initialized by the Grub bootstrap sta << 
453    * word "thread" did not exist. This means t << 
454    * setup in order for a return here to call  << 
455    * automagically. Hence we must call it manu << 
456    * kernel thread where we must do this manua << 
457    */                                          << 
458   sos_bochs_printf("Bye from primary thread !\ << 
459   sos_thread_exit();                           << 
460   SOS_FATAL_ERROR("No trespassing !");         << 
461 }                                                 236 }
                                                      

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