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 1)


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/gdt.h>                        << 
023 #include <hwcore/irq.h>                        << 
024 #include <hwcore/exception.h>                  << 
025 #include <hwcore/i8254.h>                      << 
026 #include <sos/list.h>                          << 
027 #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>                            022 #include <sos/klibc.h>
034 #include <sos/assert.h>                           023 #include <sos/assert.h>
035 #include <drivers/x86_videomem.h>                 024 #include <drivers/x86_videomem.h>
036 #include <drivers/bochs.h>                        025 #include <drivers/bochs.h>
037                                                   026 
038                                                   027 
039 /* Helper function to display each bits of a 3 << 
040    screen as dark or light carrets */          << 
041 void display_bits(unsigned char row, unsigned  << 
042                   unsigned char attribute,     << 
043                   sos_ui32_t integer)          << 
044 {                                              << 
045   int i;                                       << 
046   /* Scan each bit of the integer, MSb first * << 
047   for (i = 31 ; i >= 0 ; i--)                  << 
048     {                                          << 
049       /* Test if bit i of 'integer' is set */  << 
050       int bit_i = (integer & (1 << i));        << 
051       /* Ascii 219 => dark carret, Ascii 177 = << 
052       unsigned char ascii_code = bit_i?219:177 << 
053       sos_x86_videomem_putchar(row, col++,     << 
054                                attribute,      << 
055                                ascii_code);    << 
056     }                                          << 
057 }                                              << 
058                                                << 
059                                                << 
060 /* Clock IRQ handler */                        << 
061 static void clk_it(int intid)                  << 
062 {                                              << 
063   static sos_ui32_t clock_count = 0;           << 
064                                                << 
065   display_bits(0, 48,                          << 
066                SOS_X86_VIDEO_FG_LTGREEN | SOS_ << 
067                clock_count);                   << 
068   clock_count++;                               << 
069                                                << 
070   /* Execute the expired timeout actions (if a << 
071   sos_time_do_tick();                          << 
072 }                                              << 
073                                                << 
074                                                << 
075 /* =========================================== << 
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 {                                              << 
086   static void backtracer(sos_vaddr_t PC,       << 
087                          sos_vaddr_t params,   << 
088                          sos_ui32_t depth,     << 
089                          void *custom_arg)     << 
090     {                                          << 
091       sos_ui32_t invalid = 0xffffffff, *arg1,  << 
092                                                << 
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                                                << 
131     }                                          << 
132                                                << 
133   sos_backtrace(cpu_state, 15, stack_bottom, s << 
134 }                                              << 
135                                                << 
136                                                << 
137 /* Page fault exception handler with demand pa << 
138 static void pgflt_ex(int intid, const struct s << 
139 {                                              << 
140   static sos_ui32_t demand_paging_count = 0;   << 
141   sos_vaddr_t faulting_vaddr = sos_cpu_context << 
142   sos_paddr_t ppage_paddr;                     << 
143                                                << 
144   /* Check if address is covered by any VMM ra << 
145   if (! sos_kmem_vmm_is_valid_vaddr(faulting_v << 
146     {                                          << 
147       /* No: The page fault is out of any kern << 
148          the moment, we don't handle this. */  << 
149       dump_backtrace(ctxt,                     << 
150                      bootstrap_stack_bottom,   << 
151                      bootstrap_stack_size,     << 
152                      TRUE, TRUE);              << 
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         {                                      << 
229           struct sos_time t = (struct sos_time << 
230           sos_bochs_printf("sleep1(%c) << 
231           sos_x86_videomem_putchar(thr_arg->ro << 
232           SOS_ASSERT_FATAL(SOS_OK == sos_threa << 
233           SOS_ASSERT_FATAL(sos_time_is_zero(&  << 
234           sos_x86_videomem_putchar(thr_arg->ro << 
235         }                                      << 
236                                                << 
237       /* Go to sleep for a longer time some ot << 
238       else if ((random() % 300) == 0)          << 
239         {                                      << 
240           struct sos_time t = (struct sos_time << 
241           sos_bochs_printf("sleep2(%c) << 
242           sos_x86_videomem_putchar(thr_arg->ro << 
243           SOS_ASSERT_FATAL(SOS_OK == sos_threa << 
244           SOS_ASSERT_FATAL(sos_time_is_zero(&  << 
245           sos_x86_videomem_putchar(thr_arg->ro << 
246         }                                      << 
247                                                << 
248       /* Infinite loop otherwise */            << 
249     }                                          << 
250 }                                              << 
251                                                   028 
252                                                !! 029 /* The C entry point of our operating system */
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                                                << 
271   arg_e = (struct thr_arg) { .character='e', . << 
272   sos_create_kernel_thread("YO[e]", demo_threa << 
273                                                << 
274   arg_R = (struct thr_arg) { .character='R', . << 
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 }                                              << 
282                                                << 
283                                                << 
284 /* =========================================== << 
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    030 void sos_main(unsigned long magic, unsigned long addr)
312 {                                                 031 {
313   unsigned i;                                     032   unsigned i;
314   sos_paddr_t sos_kernel_core_base_paddr, sos_ << 
315   struct sos_time tick_resolution;             << 
316                                                   033 
317   /* Grub sends us a structure, called multibo    034   /* Grub sends us a structure, called multiboot_info_t with a lot of
318      precious informations about the system, s    035      precious informations about the system, see the multiboot
319      documentation for more information. */       036      documentation for more information. */
320   multiboot_info_t *mbi;                          037   multiboot_info_t *mbi;
321   mbi = (multiboot_info_t *) addr;                038   mbi = (multiboot_info_t *) addr;
322                                                   039 
323   /* Setup bochs and console, and clear the co    040   /* Setup bochs and console, and clear the console */
324   sos_bochs_setup();                              041   sos_bochs_setup();
325                                                   042 
326   sos_x86_videomem_setup();                       043   sos_x86_videomem_setup();
327   sos_x86_videomem_cls(SOS_X86_VIDEO_BG_BLUE);    044   sos_x86_videomem_cls(SOS_X86_VIDEO_BG_BLUE);
328                                                   045 
329   /* Greetings from SOS */                        046   /* Greetings from SOS */
330   if (magic == MULTIBOOT_BOOTLOADER_MAGIC)        047   if (magic == MULTIBOOT_BOOTLOADER_MAGIC)
331     /* Loaded with Grub */                        048     /* Loaded with Grub */
332     sos_x86_videomem_printf(1, 0,                 049     sos_x86_videomem_printf(1, 0,
333                             SOS_X86_VIDEO_FG_Y    050                             SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
334                             "Welcome From GRUB    051                             "Welcome From GRUB to %s%c RAM is %dMB (upper mem = 0x%x kB)",
335                             "SOS article 6.5", !! 052                             "SOS", ',',
336                             (unsigned)(mbi->me    053                             (unsigned)(mbi->mem_upper >> 10) + 1,
337                             (unsigned)mbi->mem    054                             (unsigned)mbi->mem_upper);
338   else                                            055   else
339     /* Not loaded with grub */                    056     /* Not loaded with grub */
340     sos_x86_videomem_printf(1, 0,                 057     sos_x86_videomem_printf(1, 0,
341                             SOS_X86_VIDEO_FG_Y    058                             SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
342                             "Welcome to SOS ar !! 059                             "Welcome to SOS");
                                                   >> 060 
                                                   >> 061   sos_bochs_putstring("Message in a bochs\n");
                                                   >> 062 
343                                                   063 
344   sos_bochs_putstring("Message in a bochs: Thi !! 064   /* An operatig system never ends */
                                                   >> 065   for (;;)
                                                   >> 066     continue;
345                                                   067 
346   /* Setup CPU segmentation and IRQ subsystem  !! 068   return;
347   sos_gdt_subsystem_setup();                   << 
348   sos_idt_subsystem_setup();                   << 
349                                                << 
350   /* Setup SOS IRQs and exceptions subsystem * << 
351   sos_exception_subsystem_setup();             << 
352   sos_irq_subsystem_setup();                   << 
353                                                << 
354   /* Configure the timer so as to raise the IR << 
355   sos_i8254_set_frequency(100);                << 
356                                                << 
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                                                << 
362   /* We need a multiboot-compliant boot loader << 
363   if (magic != MULTIBOOT_BOOTLOADER_MAGIC)     << 
364     {                                          << 
365       sos_x86_videomem_putstring(20, 0,        << 
366                                  SOS_X86_VIDEO << 
367                                    | SOS_X86_V << 
368                                    | SOS_X86_V << 
369                                  "I'm not load << 
370       /* STOP ! */                             << 
371       for (;;)                                 << 
372         continue;                              << 
373     }                                          << 
374                                                << 
375   /*                                           << 
376    * Some interrupt handlers                   << 
377    */                                          << 
378                                                << 
379   /* Binding some HW interrupts and exceptions << 
380   sos_irq_set_routine(SOS_IRQ_TIMER,           << 
381                       clk_it);                 << 
382                                                << 
383   /*                                           << 
384    * Setup physical memory management          << 
385    */                                          << 
386                                                << 
387   /* Multiboot says: "The value returned for u << 
388      the address of the first upper memory hol << 
389      also adds: "It is not guaranteed to be th << 
390   sos_physmem_subsystem_setup((mbi->mem_upper< << 
391                               & sos_kernel_cor << 
392                               & sos_kernel_cor << 
393                                                << 
394   /*                                           << 
395    * Switch to paged-memory mode               << 
396    */                                          << 
397                                                << 
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                                                << 
441   /* Now run some Kernel threads just for fun  << 
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 }                                                 069 }
                                                      

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