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


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 <hwcore/paging.h>
                                                   >> 030 #include <sos/list.h>
027 #include <sos/klibc.h>                            031 #include <sos/klibc.h>
028 #include <sos/assert.h>                           032 #include <sos/assert.h>
029 #include <drivers/x86_videomem.h>                 033 #include <drivers/x86_videomem.h>
030 #include <drivers/bochs.h>                        034 #include <drivers/bochs.h>
031                                                   035 
032                                                   036 
033 /* Helper function to display each bits of a 3    037 /* Helper function to display each bits of a 32bits integer on the
034    screen as dark or light carrets */             038    screen as dark or light carrets */
035 static void display_bits(unsigned char row, un    039 static void display_bits(unsigned char row, unsigned char col,
036                          unsigned char attribu    040                          unsigned char attribute,
037                          sos_ui32_t integer)      041                          sos_ui32_t integer)
038 {                                                 042 {
039   int i;                                          043   int i;
040   /* Scan each bit of the integer, MSb first *    044   /* Scan each bit of the integer, MSb first */
041   for (i = 31 ; i >= 0 ; i--)                     045   for (i = 31 ; i >= 0 ; i--)
042     {                                             046     {
043       /* Test if bit i of 'integer' is set */     047       /* Test if bit i of 'integer' is set */
044       int bit_i = (integer & (1 << i));           048       int bit_i = (integer & (1 << i));
045       /* Ascii 219 => dark carret, Ascii 177 =    049       /* Ascii 219 => dark carret, Ascii 177 => light carret */
046       unsigned char ascii_code = bit_i?219:177    050       unsigned char ascii_code = bit_i?219:177;
047       sos_x86_videomem_putchar(row, col++,        051       sos_x86_videomem_putchar(row, col++,
048                                attribute,         052                                attribute,
049                                ascii_code);       053                                ascii_code);
050     }                                             054     }
051 }                                                 055 }
052                                                   056 
053                                                   057 
054 /* Clock IRQ handler */                           058 /* Clock IRQ handler */
055 static void clk_it(int intid)                     059 static void clk_it(int intid)
056 {                                                 060 {
057   static sos_ui32_t clock_count = 0;              061   static sos_ui32_t clock_count = 0;
058                                                   062 
059   display_bits(0, 48,                             063   display_bits(0, 48,
060                SOS_X86_VIDEO_FG_LTGREEN | SOS_    064                SOS_X86_VIDEO_FG_LTGREEN | SOS_X86_VIDEO_BG_BLUE,
061                clock_count);                      065                clock_count);
062   clock_count++;                                  066   clock_count++;
063                                                   067 
064 }                                                 068 }
065                                                   069 
066 /* Division by zero exception handler */       !! 070 /* Page fault exception handler */
067 static void divide_ex(int exid)                !! 071 static void pgflt_ex(int exid)
068 {                                                 072 {
069   static sos_ui32_t div_count = 0;             !! 073   sos_bochs_printf("Got page fault\n");
070   display_bits(0, 0,                           !! 074   sos_x86_videomem_printf(10, 30,
071                SOS_X86_VIDEO_FG_LTRED | SOS_X8 !! 075                           SOS_X86_VIDEO_FG_LTRED | SOS_X86_VIDEO_BG_BLUE,
072                div_count);                     !! 076                           "Got EXPECTED (?) Page fault ! But where ???");
073   div_count++;                                 !! 077   for (;;) ;
                                                   >> 078 }
                                                   >> 079 
                                                   >> 080 static void test_paging(sos_vaddr_t sos_kernel_core_top_vaddr)
                                                   >> 081 {
                                                   >> 082   /* The (linear) address of the page holding the code we are
                                                   >> 083      currently executing */
                                                   >> 084   sos_vaddr_t vpage_code = SOS_PAGE_ALIGN_INF(test_paging);
                                                   >> 085 
                                                   >> 086   /* The new physical page that will hold the code */
                                                   >> 087   sos_paddr_t ppage_new;
                                                   >> 088 
                                                   >> 089   /* Where this page will be mapped temporarily in order to copy the
                                                   >> 090      code into it: right after the kernel code/data */
                                                   >> 091   sos_vaddr_t vpage_tmp = sos_kernel_core_top_vaddr;
                                                   >> 092 
                                                   >> 093   unsigned i;
                                                   >> 094 
                                                   >> 095   /* Bind the page fault exception to one of our routines */
                                                   >> 096   sos_exception_set_routine(SOS_EXCEPT_PAGE_FAULT,
                                                   >> 097                             pgflt_ex);
                                                   >> 098 
                                                   >> 099   /*
                                                   >> 100    * Test 1: move the page where we execute the code elsewhere in
                                                   >> 101    * physical memory
                                                   >> 102    */
                                                   >> 103   sos_x86_videomem_printf(4, 0,
                                                   >> 104                           SOS_X86_VIDEO_FG_LTGREEN | SOS_X86_VIDEO_BG_BLUE,
                                                   >> 105                           "Moving current code elsewhere in physical memory:");
                                                   >> 106 
                                                   >> 107 
                                                   >> 108   /* Allocate a new physical page */
                                                   >> 109   ppage_new = sos_physmem_ref_physpage_new(FALSE);
                                                   >> 110   if (! ppage_new)
                                                   >> 111     {
                                                   >> 112       /* STOP ! No memory left */
                                                   >> 113       sos_x86_videomem_putstring(20, 0,
                                                   >> 114                                  SOS_X86_VIDEO_FG_LTRED
                                                   >> 115                                    | SOS_X86_VIDEO_BG_BLUE,
                                                   >> 116                                  "test_paging : Cannot allocate page");
                                                   >> 117       return;
                                                   >> 118     }
                                                   >> 119 
                                                   >> 120   sos_x86_videomem_printf(5, 0,
                                                   >> 121                           SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
                                                   >> 122                           "Hello from the address 0x%x in physical memory",
                                                   >> 123                           sos_paging_get_paddr(vpage_code));
                                                   >> 124 
                                                   >> 125   sos_x86_videomem_printf(6, 0,
                                                   >> 126                           SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
                                                   >> 127                           "Transfer vpage 0x%x: ppage 0x%x -> 0x%x (tmp vpage 0x%x)",
                                                   >> 128                           vpage_code,
                                                   >> 129                           sos_paging_get_paddr(vpage_code),
                                                   >> 130                           ppage_new,
                                                   >> 131                           (unsigned)vpage_tmp);
                                                   >> 132 
                                                   >> 133   /* Map the page somewhere (right after the kernel mapping) in order
                                                   >> 134      to copy the code we are currently executing */
                                                   >> 135   sos_paging_map(ppage_new, vpage_tmp,
                                                   >> 136                  FALSE,
                                                   >> 137                  SOS_VM_MAP_ATOMIC
                                                   >> 138                  | SOS_VM_MAP_PROT_READ
                                                   >> 139                  | SOS_VM_MAP_PROT_WRITE);
                                                   >> 140 
                                                   >> 141   /* Ok, the new page is referenced by the mapping, we can release our
                                                   >> 142      reference to it */
                                                   >> 143   sos_physmem_unref_physpage(ppage_new);
                                                   >> 144 
                                                   >> 145   /* Copy the contents of the current page of code to this new page
                                                   >> 146      mapping */
                                                   >> 147   memcpy((void*)vpage_tmp,
                                                   >> 148          (void*)vpage_code,
                                                   >> 149          SOS_PAGE_SIZE);
                                                   >> 150 
                                                   >> 151   /* Transfer the mapping of the current page of code to this new page */
                                                   >> 152   sos_paging_map(ppage_new, vpage_code,
                                                   >> 153                  FALSE,
                                                   >> 154                  SOS_VM_MAP_ATOMIC
                                                   >> 155                  | SOS_VM_MAP_PROT_READ
                                                   >> 156                  | SOS_VM_MAP_PROT_WRITE);
                                                   >> 157   
                                                   >> 158   /* Ok, here we are: we have changed the physcal page that holds the
                                                   >> 159      code we are executing ;). However, this new page is mapped at 2
                                                   >> 160      virtual addresses:
                                                   >> 161      - vpage_tmp
                                                   >> 162      - vpage_code
                                                   >> 163      We can safely unmap it from sos_kernel_core_top_vaddr, while
                                                   >> 164      still keeping the vpage_code mapping */
                                                   >> 165   sos_paging_unmap(vpage_tmp);
                                                   >> 166 
                                                   >> 167   sos_x86_videomem_printf(7, 0,
                                                   >> 168                           SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
                                                   >> 169                           "Hello from the address 0x%x in physical memory",
                                                   >> 170                           sos_paging_get_paddr(vpage_code));
                                                   >> 171 
                                                   >> 172   sos_x86_videomem_printf(9, 0,
                                                   >> 173                           SOS_X86_VIDEO_FG_LTGREEN | SOS_X86_VIDEO_BG_BLUE,
                                                   >> 174                           "Provoking a page fault:");
                                                   >> 175 
                                                   >> 176   /*
                                                   >> 177    * Test 2: make sure the #PF handler works
                                                   >> 178    */
                                                   >> 179 
                                                   >> 180   /* Scan part of the kernel up to a page fault. This page fault
                                                   >> 181      should occur on the first page unmapped after the kernel area,
                                                   >> 182      which is exactly the page we temporarily mapped/unmapped
                                                   >> 183      (vpage_tmp) above to move the kernel code we are executing */
                                                   >> 184   for (i = vpage_code ; /* none */ ; i += SOS_PAGE_SIZE)
                                                   >> 185     {
                                                   >> 186       unsigned *pint = (unsigned *)SOS_PAGE_ALIGN_INF(i);
                                                   >> 187       sos_bochs_printf("Test vaddr 0x%x : val=", (unsigned)pint);
                                                   >> 188       sos_x86_videomem_printf(10, 0,
                                                   >> 189                               SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
                                                   >> 190                               "Test vaddr 0x%x : val=      ",
                                                   >> 191                               (unsigned)pint);
                                                   >> 192       sos_bochs_printf("0x%x\n", *pint);
                                                   >> 193       sos_x86_videomem_printf(10, 30,
                                                   >> 194                               SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
                                                   >> 195                               "0x%x          ", *pint);
                                                   >> 196     }
                                                   >> 197 
                                                   >> 198   /* BAD ! Did not get the page fault... */
                                                   >> 199   sos_x86_videomem_printf(20, 0,
                                                   >> 200                           SOS_X86_VIDEO_FG_LTRED | SOS_X86_VIDEO_BG_BLUE,
                                                   >> 201                           "We should have had a #PF at vaddr 0x%x !",
                                                   >> 202                           vpage_tmp);
074 }                                                 203 }
075                                                   204 
076 /* The C entry point of our operating system *    205 /* The C entry point of our operating system */
077 void sos_main(unsigned long magic, unsigned lo    206 void sos_main(unsigned long magic, unsigned long addr)
078 {                                                 207 {
079   unsigned i;                                     208   unsigned i;
                                                   >> 209   sos_paddr_t sos_kernel_core_base_paddr, sos_kernel_core_top_paddr;
080                                                   210 
081   /* Grub sends us a structure, called multibo    211   /* Grub sends us a structure, called multiboot_info_t with a lot of
082      precious informations about the system, s    212      precious informations about the system, see the multiboot
083      documentation for more information. */       213      documentation for more information. */
084   multiboot_info_t *mbi;                          214   multiboot_info_t *mbi;
085   mbi = (multiboot_info_t *) addr;                215   mbi = (multiboot_info_t *) addr;
086                                                   216 
087   /* Setup bochs and console, and clear the co    217   /* Setup bochs and console, and clear the console */
088   sos_bochs_setup();                              218   sos_bochs_setup();
089                                                   219 
090   sos_x86_videomem_setup();                       220   sos_x86_videomem_setup();
091   sos_x86_videomem_cls(SOS_X86_VIDEO_BG_BLUE);    221   sos_x86_videomem_cls(SOS_X86_VIDEO_BG_BLUE);
092                                                   222 
093   /* Greetings from SOS */                        223   /* Greetings from SOS */
094   if (magic == MULTIBOOT_BOOTLOADER_MAGIC)        224   if (magic == MULTIBOOT_BOOTLOADER_MAGIC)
095     /* Loaded with Grub */                        225     /* Loaded with Grub */
096     sos_x86_videomem_printf(1, 0,                 226     sos_x86_videomem_printf(1, 0,
097                             SOS_X86_VIDEO_FG_Y    227                             SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
098                             "Welcome From GRUB    228                             "Welcome From GRUB to %s%c RAM is %dMB (upper mem = 0x%x kB)",
099                             "SOS", ',',           229                             "SOS", ',',
100                             (unsigned)(mbi->me    230                             (unsigned)(mbi->mem_upper >> 10) + 1,
101                             (unsigned)mbi->mem    231                             (unsigned)mbi->mem_upper);
102   else                                            232   else
103     /* Not loaded with grub */                    233     /* Not loaded with grub */
104     sos_x86_videomem_printf(1, 0,                 234     sos_x86_videomem_printf(1, 0,
105                             SOS_X86_VIDEO_FG_Y    235                             SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
106                             "Welcome to SOS");    236                             "Welcome to SOS");
107                                                   237 
108   sos_bochs_putstring("Message in a bochs\n");    238   sos_bochs_putstring("Message in a bochs\n");
109                                                   239 
110   /* Setup CPU segmentation and IRQ subsystem     240   /* Setup CPU segmentation and IRQ subsystem */
111   sos_gdt_setup();                                241   sos_gdt_setup();
112   sos_idt_setup();                                242   sos_idt_setup();
113                                                   243 
114   /* Setup SOS IRQs and exceptions subsystem *    244   /* Setup SOS IRQs and exceptions subsystem */
115   sos_exceptions_setup();                         245   sos_exceptions_setup();
116   sos_irq_setup();                                246   sos_irq_setup();
117                                                   247 
118   /* Configure the timer so as to raise the IR    248   /* Configure the timer so as to raise the IRQ0 at a 100Hz rate */
119   sos_i8254_set_frequency(100);                   249   sos_i8254_set_frequency(100);
120                                                   250 
                                                   >> 251 
                                                   >> 252   /* We need a multiboot-compliant boot loader to get the size of the RAM */
                                                   >> 253   if (magic != MULTIBOOT_BOOTLOADER_MAGIC)
                                                   >> 254     {
                                                   >> 255       sos_x86_videomem_putstring(20, 0,
                                                   >> 256                                  SOS_X86_VIDEO_FG_LTRED
                                                   >> 257                                    | SOS_X86_VIDEO_BG_BLUE
                                                   >> 258                                    | SOS_X86_VIDEO_FG_BLINKING,
                                                   >> 259                                  "I'm not loaded with Grub !");
                                                   >> 260       /* STOP ! */
                                                   >> 261       for (;;)
                                                   >> 262         continue;
                                                   >> 263     }
                                                   >> 264 
121   /* Binding some HW interrupts and exceptions    265   /* Binding some HW interrupts and exceptions to software routines */
122   sos_irq_set_routine(SOS_IRQ_TIMER,              266   sos_irq_set_routine(SOS_IRQ_TIMER,
123                             clk_it);              267                             clk_it);
124   sos_exception_set_routine(SOS_EXCEPT_DIVIDE_ << 
125                             divide_ex);        << 
126   /* Enabling the HW interrupts here, this wil    268   /* Enabling the HW interrupts here, this will make the timer HW
127      interrupt call our clk_it handler */         269      interrupt call our clk_it handler */
128   asm volatile ("sti\n");                         270   asm volatile ("sti\n");
129                                                !! 271   /* Multiboot says: "The value returned for upper memory is maximally
130   /* Raise a rafale of 'division by 0' excepti !! 272      the address of the first upper memory hole minus 1 megabyte.". It
131      not really needed (equivalent to a bare " !! 273      also adds: "It is not guaranteed to be this value." aka "YMMV" ;) */
132      compiling with -O3: "i=1/0;" is considere !! 274   sos_physmem_setup((mbi->mem_upper<<10) + (1<<20),
133      -O3. */                                   !! 275                     & sos_kernel_core_base_paddr,
134   i = 10;                                      !! 276                     & sos_kernel_core_top_paddr);
135   while (1)                                    !! 277   
136     {                                          !! 278   /*
137       /* Stupid function call to fool gcc opti !! 279    * Switch to paged-memory mode
138       sos_bochs_printf("i = 1 / %d...\n", i);  !! 280    */
139       i = 1 / i;                               !! 281 
140     }                                          !! 282   /* Disabling interrupts should seem more correct, but it's not really
141                                                !! 283      necessary at this stage */
142   /* Will never print this since the "divide b !! 284   if (sos_paging_setup(sos_kernel_core_base_paddr,
143      returns to the faulting instruction (see  !! 285                        sos_kernel_core_top_paddr))
144      section 5.12), thus re-evaluating the "di !! 286     sos_bochs_printf("Could not setup paged memory mode\n");
145      and raising the "divide by zero" exceptio !! 287   sos_x86_videomem_printf(2, 0,
146   sos_x86_videomem_putstring(2, 0,             !! 288                           SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
147                              SOS_X86_VIDEO_FG_ !! 289                           "Paged-memory mode is activated");
148                              "Invisible");     !! 290 
                                                   >> 291   test_paging(sos_kernel_core_top_paddr);
                                                   >> 292 
                                                   >> 293   /* An operatig system never ends */
                                                   >> 294   for (;;)
                                                   >> 295     continue;
149                                                   296 
150   return;                                         297   return;
151 }                                                 298 }
                                                      

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