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


001 /* Copyright (C) 2004  The SOS Team               001 /* Copyright (C) 2004  The SOS Team
002    Copyright (C) 1999  Free Software Foundatio    002    Copyright (C) 1999  Free Software Foundation, Inc.
003                                                   003 
004    This program is free software; you can redi    004    This program is free software; you can redistribute it and/or
005    modify it under the terms of the GNU Genera    005    modify it under the terms of the GNU General Public License
006    as published by the Free Software Foundatio    006    as published by the Free Software Foundation; either version 2
007    of the License, or (at your option) any lat    007    of the License, or (at your option) any later version.
008                                                   008    
009    This program is distributed in the hope tha    009    This program is distributed in the hope that it will be useful,
010    but WITHOUT ANY WARRANTY; without even the     010    but WITHOUT ANY WARRANTY; without even the implied warranty of
011    MERCHANTABILITY or FITNESS FOR A PARTICULAR    011    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
012    GNU General Public License for more details    012    GNU General Public License for more details.
013                                                   013    
014    You should have received a copy of the GNU     014    You should have received a copy of the GNU General Public License
015    along with this program; if not, write to t    015    along with this program; if not, write to the Free Software
016    Foundation, Inc., 59 Temple Place - Suite 3    016    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
017    USA.                                           017    USA. 
018 */                                                018 */
019                                                   019 
020 /* Include definitions of the multiboot standa    020 /* Include definitions of the multiboot standard */
021 #include <bootstrap/multiboot.h>                  021 #include <bootstrap/multiboot.h>
022 #include <hwcore/idt.h>                           022 #include <hwcore/idt.h>
023 #include <hwcore/gdt.h>                           023 #include <hwcore/gdt.h>
024 #include <hwcore/irq.h>                           024 #include <hwcore/irq.h>
025 #include <hwcore/exception.h>                     025 #include <hwcore/exception.h>
026 #include <hwcore/i8254.h>                         026 #include <hwcore/i8254.h>
027 #include <sos/list.h>                          << 
028 #include <sos/physmem.h>                       << 
029 #include <sos/klibc.h>                            027 #include <sos/klibc.h>
030 #include <sos/assert.h>                           028 #include <sos/assert.h>
031 #include <drivers/x86_videomem.h>                 029 #include <drivers/x86_videomem.h>
032 #include <drivers/bochs.h>                        030 #include <drivers/bochs.h>
033                                                   031 
034                                                   032 
035 /* Helper function to display each bits of a 3    033 /* Helper function to display each bits of a 32bits integer on the
036    screen as dark or light carrets */             034    screen as dark or light carrets */
037 static void display_bits(unsigned char row, un    035 static void display_bits(unsigned char row, unsigned char col,
038                          unsigned char attribu    036                          unsigned char attribute,
039                          sos_ui32_t integer)      037                          sos_ui32_t integer)
040 {                                                 038 {
041   int i;                                          039   int i;
042   /* Scan each bit of the integer, MSb first *    040   /* Scan each bit of the integer, MSb first */
043   for (i = 31 ; i >= 0 ; i--)                     041   for (i = 31 ; i >= 0 ; i--)
044     {                                             042     {
045       /* Test if bit i of 'integer' is set */     043       /* Test if bit i of 'integer' is set */
046       int bit_i = (integer & (1 << i));           044       int bit_i = (integer & (1 << i));
047       /* Ascii 219 => dark carret, Ascii 177 =    045       /* Ascii 219 => dark carret, Ascii 177 => light carret */
048       unsigned char ascii_code = bit_i?219:177    046       unsigned char ascii_code = bit_i?219:177;
049       sos_x86_videomem_putchar(row, col++,        047       sos_x86_videomem_putchar(row, col++,
050                                attribute,         048                                attribute,
051                                ascii_code);       049                                ascii_code);
052     }                                             050     }
053 }                                                 051 }
054                                                   052 
055                                                   053 
056 /* Clock IRQ handler */                           054 /* Clock IRQ handler */
057 static void clk_it(int intid)                     055 static void clk_it(int intid)
058 {                                                 056 {
059   static sos_ui32_t clock_count = 0;              057   static sos_ui32_t clock_count = 0;
060                                                   058 
061   display_bits(0, 48,                             059   display_bits(0, 48,
062                SOS_X86_VIDEO_FG_LTGREEN | SOS_    060                SOS_X86_VIDEO_FG_LTGREEN | SOS_X86_VIDEO_BG_BLUE,
063                clock_count);                      061                clock_count);
064   clock_count++;                                  062   clock_count++;
065                                                   063 
066 }                                                 064 }
067                                                   065 
068 #define MY_PPAGE_NUM_INT 511                   !! 066 /* Division by zero exception handler */
069 struct my_ppage                                !! 067 static void divide_ex(int exid)
070 {                                                 068 {
071   sos_ui32_t before[MY_PPAGE_NUM_INT];         !! 069   static sos_ui32_t div_count = 0;
072   struct my_ppage *prev, *next;                !! 070   display_bits(0, 0,
073   sos_ui32_t after[MY_PPAGE_NUM_INT];          !! 071                SOS_X86_VIDEO_FG_LTRED | SOS_X86_VIDEO_BG_BLUE,
074 }; /* sizeof() Must be <= 4kB */               !! 072                div_count);
075                                                !! 073   div_count++;
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_p << 
081                                                << 
082   ppage_list = NULL;                           << 
083   while ((my_ppage = (struct my_ppage*)sos_phy << 
084          != NULL)                              << 
085     {                                          << 
086       int i;                                   << 
087       num_alloc_ppages++;                      << 
088                                                << 
089       /* Print the allocation status */        << 
090       sos_x86_videomem_printf(2, 0,            << 
091                               SOS_X86_VIDEO_FG << 
092                               | SOS_X86_VIDEO_ << 
093                               "Could allocate  << 
094                               num_alloc_ppages << 
095                                                << 
096       /* We fill this page with its address */ << 
097       for (i = 0 ; i < MY_PPAGE_NUM_INT ; i++) << 
098         my_ppage->before[i] = my_ppage->after[ << 
099                                                << 
100       /* We add this page at the tail of our l << 
101       list_add_tail(ppage_list, my_ppage);     << 
102     }                                          << 
103                                                << 
104   /* Now we release these pages in FIFO order  << 
105   while ((my_ppage = list_pop_head(ppage_list) << 
106     {                                          << 
107       /* We make sure this page was not overwr << 
108          value */                              << 
109       int i;                                   << 
110       for (i = 0 ; i < MY_PPAGE_NUM_INT ; i++) << 
111         {                                      << 
112           /* We don't get what we expect ! */  << 
113           if ((my_ppage->before[i] !=  (sos_ui << 
114               || (my_ppage->after[i] !=  (sos_ << 
115             {                                  << 
116               /* STOP ! */                     << 
117               sos_x86_videomem_putstring(20, 0 << 
118                                          SOS_X << 
119                                            | S << 
120                                          "Page << 
121               return;                          << 
122             }                                  << 
123         }                                      << 
124                                                << 
125       /* Release the descriptor */             << 
126       if (sos_physmem_unref_physpage((sos_padd << 
127         {                                      << 
128           /* STOP ! */                         << 
129           sos_x86_videomem_putstring(20, 0,    << 
130                                      SOS_X86_V << 
131                                        | SOS_X << 
132                                      "Cannot r << 
133           return;                              << 
134         }                                      << 
135                                                << 
136       /* Print the deallocation status */      << 
137       num_free_ppages ++;                      << 
138       sos_x86_videomem_printf(2, 0,            << 
139                               SOS_X86_VIDEO_FG << 
140                               | SOS_X86_VIDEO_ << 
141                               "Could free %d p << 
142                               num_free_ppages) << 
143     }                                          << 
144                                                << 
145   /* Print the overall stats */                << 
146   sos_x86_videomem_printf(2, 0,                << 
147                           SOS_X86_VIDEO_FG_LTG << 
148                           | SOS_X86_VIDEO_BG_B << 
149                           "Could allocate %d b << 
150                           num_alloc_ppages <<  << 
151                           num_free_ppages << S << 
152                                                << 
153   SOS_ASSERT_FATAL(num_alloc_ppages == num_fre << 
154 }                                                 074 }
155                                                   075 
156                                                << 
157 /* The C entry point of our operating system *    076 /* The C entry point of our operating system */
158 void sos_main(unsigned long magic, unsigned lo    077 void sos_main(unsigned long magic, unsigned long addr)
159 {                                                 078 {
160   unsigned i;                                     079   unsigned i;
161   sos_paddr_t sos_kernel_core_base_paddr, sos_ << 
162                                                   080 
163   /* Grub sends us a structure, called multibo    081   /* Grub sends us a structure, called multiboot_info_t with a lot of
164      precious informations about the system, s    082      precious informations about the system, see the multiboot
165      documentation for more information. */       083      documentation for more information. */
166   multiboot_info_t *mbi;                          084   multiboot_info_t *mbi;
167   mbi = (multiboot_info_t *) addr;                085   mbi = (multiboot_info_t *) addr;
168                                                   086 
169   /* Setup bochs and console, and clear the co    087   /* Setup bochs and console, and clear the console */
170   sos_bochs_setup();                              088   sos_bochs_setup();
171                                                   089 
172   sos_x86_videomem_setup();                       090   sos_x86_videomem_setup();
173   sos_x86_videomem_cls(SOS_X86_VIDEO_BG_BLUE);    091   sos_x86_videomem_cls(SOS_X86_VIDEO_BG_BLUE);
174                                                   092 
175   /* Greetings from SOS */                        093   /* Greetings from SOS */
176   if (magic == MULTIBOOT_BOOTLOADER_MAGIC)        094   if (magic == MULTIBOOT_BOOTLOADER_MAGIC)
177     /* Loaded with Grub */                        095     /* Loaded with Grub */
178     sos_x86_videomem_printf(1, 0,                 096     sos_x86_videomem_printf(1, 0,
179                             SOS_X86_VIDEO_FG_Y    097                             SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
180                             "Welcome From GRUB    098                             "Welcome From GRUB to %s%c RAM is %dMB (upper mem = 0x%x kB)",
181                             "SOS", ',',           099                             "SOS", ',',
182                             (unsigned)(mbi->me    100                             (unsigned)(mbi->mem_upper >> 10) + 1,
183                             (unsigned)mbi->mem    101                             (unsigned)mbi->mem_upper);
184   else                                            102   else
185     /* Not loaded with grub */                    103     /* Not loaded with grub */
186     sos_x86_videomem_printf(1, 0,                 104     sos_x86_videomem_printf(1, 0,
187                             SOS_X86_VIDEO_FG_Y    105                             SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
188                             "Welcome to SOS");    106                             "Welcome to SOS");
189                                                   107 
190   sos_bochs_putstring("Message in a bochs\n");    108   sos_bochs_putstring("Message in a bochs\n");
191                                                   109 
192   /* Setup CPU segmentation and IRQ subsystem     110   /* Setup CPU segmentation and IRQ subsystem */
193   sos_gdt_setup();                                111   sos_gdt_setup();
194   sos_idt_setup();                                112   sos_idt_setup();
195                                                   113 
196   /* Setup SOS IRQs and exceptions subsystem *    114   /* Setup SOS IRQs and exceptions subsystem */
197   sos_exceptions_setup();                         115   sos_exceptions_setup();
198   sos_irq_setup();                                116   sos_irq_setup();
199                                                   117 
200   /* Configure the timer so as to raise the IR    118   /* Configure the timer so as to raise the IRQ0 at a 100Hz rate */
201   sos_i8254_set_frequency(100);                   119   sos_i8254_set_frequency(100);
202                                                   120 
203                                                << 
204   /* We need a multiboot-compliant boot loader << 
205   if (magic != MULTIBOOT_BOOTLOADER_MAGIC)     << 
206     {                                          << 
207       sos_x86_videomem_putstring(20, 0,        << 
208                                  SOS_X86_VIDEO << 
209                                    | SOS_X86_V << 
210                                    | SOS_X86_V << 
211                                  "I'm not load << 
212       /* STOP ! */                             << 
213       for (;;)                                 << 
214         continue;                              << 
215     }                                          << 
216                                                << 
217   /* Binding some HW interrupts and exceptions    121   /* Binding some HW interrupts and exceptions to software routines */
218   sos_irq_set_routine(SOS_IRQ_TIMER,              122   sos_irq_set_routine(SOS_IRQ_TIMER,
219                             clk_it);              123                             clk_it);
                                                   >> 124   sos_exception_set_routine(SOS_EXCEPT_DIVIDE_ERROR,
                                                   >> 125                             divide_ex);
220   /* Enabling the HW interrupts here, this wil    126   /* Enabling the HW interrupts here, this will make the timer HW
221      interrupt call our clk_it handler */         127      interrupt call our clk_it handler */
222   asm volatile ("sti\n");                         128   asm volatile ("sti\n");
223   /* Multiboot says: "The value returned for u !! 129 
224      the address of the first upper memory hol !! 130   /* Raise a rafale of 'division by 0' exceptions. All this code is
225      also adds: "It is not guaranteed to be th !! 131      not really needed (equivalent to a bare "i=1/0;"), except when
226   sos_physmem_setup((mbi->mem_upper<<10) + (1< !! 132      compiling with -O3: "i=1/0;" is considered dead code with gcc
227                     & sos_kernel_core_base_pad !! 133      -O3. */
228                     & sos_kernel_core_top_padd !! 134   i = 10;
229   test_physmem();                              !! 135   while (1)
230                                                !! 136     {
231   /* An operatig system never ends */          !! 137       /* Stupid function call to fool gcc optimizations */
232   for (;;)                                     !! 138       sos_bochs_printf("i = 1 / %d...\n", i);
233     continue;                                  !! 139       i = 1 / i;
                                                   >> 140     }
                                                   >> 141 
                                                   >> 142   /* Will never print this since the "divide by zero" exception always
                                                   >> 143      returns to the faulting instruction (see Intel x86 doc vol 3,
                                                   >> 144      section 5.12), thus re-evaluating the "divide-by-zero" exprssion
                                                   >> 145      and raising the "divide by zero" exception again and again... */
                                                   >> 146   sos_x86_videomem_putstring(2, 0,
                                                   >> 147                              SOS_X86_VIDEO_FG_LTRED | SOS_X86_VIDEO_BG_BLUE,
                                                   >> 148                              "Invisible");
234                                                   149 
235   return;                                         150   return;
236 }                                                 151 }
                                                      

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