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 9.5) 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 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 <sos/errno.h>                         << 
020                                                << 
021 /* Include definitions of the multiboot standa    020 /* Include definitions of the multiboot standard */
022 #include <bootstrap/multiboot.h>                  021 #include <bootstrap/multiboot.h>
023 #include <hwcore/idt.h>                           022 #include <hwcore/idt.h>
024 #include <hwcore/gdt.h>                           023 #include <hwcore/gdt.h>
025 #include <hwcore/irq.h>                           024 #include <hwcore/irq.h>
026 #include <hwcore/exception.h>                     025 #include <hwcore/exception.h>
027 #include <hwcore/i8254.h>                         026 #include <hwcore/i8254.h>
028 #include <sos/list.h>                             027 #include <sos/list.h>
029 #include <sos/physmem.h>                          028 #include <sos/physmem.h>
030 #include <hwcore/paging.h>                        029 #include <hwcore/paging.h>
031 #include <hwcore/mm_context.h>                 !! 030 #include <sos/list.h>
032 #include <hwcore/swintr.h>                     << 
033 #include <sos/kmem_vmm.h>                      << 
034 #include <sos/kmalloc.h>                       << 
035 #include <sos/time.h>                          << 
036 #include <sos/thread.h>                        << 
037 #include <sos/process.h>                       << 
038 #include <sos/umem_vmm.h>                      << 
039 #include <sos/klibc.h>                            031 #include <sos/klibc.h>
040 #include <sos/assert.h>                           032 #include <sos/assert.h>
041 #include <drivers/x86_videomem.h>                 033 #include <drivers/x86_videomem.h>
042 #include <drivers/bochs.h>                        034 #include <drivers/bochs.h>
043 #include <sos/calcload.h>                      !! 035 
044 #include <sos/umem_vmm.h>                      << 
045 #include <sos/binfmt_elf32.h>                  << 
046 #include <drivers/zero.h>                      << 
047 #include <sos/fs.h>                            << 
048 #include <drivers/fs_virtfs.h>                 << 
049 #include <drivers/devices.h>                   << 
050 #include <drivers/mem.h>                       << 
051 #include <drivers/tty.h>                       << 
052 #include <drivers/console.h>                   << 
053 #include <drivers/serial.h>                    << 
054 #include <sos/blkdev.h>                        << 
055 #include <sos/fs_pagecache.h>                  << 
056 #include <drivers/ide.h>                       << 
057                                                   036 
058 /* Helper function to display each bits of a 3    037 /* Helper function to display each bits of a 32bits integer on the
059    screen as dark or light carrets */             038    screen as dark or light carrets */
060 void display_bits(unsigned char row, unsigned  !! 039 static void display_bits(unsigned char row, unsigned char col,
061                   unsigned char attribute,     !! 040                          unsigned char attribute,
062                   sos_ui32_t integer)          !! 041                          sos_ui32_t integer)
063 {                                                 042 {
064   int i;                                          043   int i;
065   /* Scan each bit of the integer, MSb first *    044   /* Scan each bit of the integer, MSb first */
066   for (i = 31 ; i >= 0 ; i--)                     045   for (i = 31 ; i >= 0 ; i--)
067     {                                             046     {
068       /* Test if bit i of 'integer' is set */     047       /* Test if bit i of 'integer' is set */
069       int bit_i = (integer & (1 << i));           048       int bit_i = (integer & (1 << i));
070       /* Ascii 219 => dark carret, Ascii 177 =    049       /* Ascii 219 => dark carret, Ascii 177 => light carret */
071       unsigned char ascii_code = bit_i?219:177    050       unsigned char ascii_code = bit_i?219:177;
072       sos_x86_videomem_putchar(row, col++,        051       sos_x86_videomem_putchar(row, col++,
073                                attribute,         052                                attribute,
074                                ascii_code);       053                                ascii_code);
075     }                                             054     }
076 }                                                 055 }
077                                                   056 
                                                   >> 057 
078 /* Clock IRQ handler */                           058 /* Clock IRQ handler */
079 static void clk_it(int intid)                     059 static void clk_it(int intid)
080 {                                                 060 {
081   static sos_ui32_t clock_count = 0;              061   static sos_ui32_t clock_count = 0;
082                                                   062 
083   display_bits(0, 48,                             063   display_bits(0, 48,
084                SOS_X86_VIDEO_FG_LTGREEN | SOS_    064                SOS_X86_VIDEO_FG_LTGREEN | SOS_X86_VIDEO_BG_BLUE,
085                clock_count);                      065                clock_count);
086   clock_count++;                                  066   clock_count++;
087                                                   067 
088   /* Execute the expired timeout actions (if a << 
089   sos_time_do_tick();                          << 
090                                                << 
091   /* Update scheduler statistics and status */ << 
092   sos_sched_do_timer_tick();                   << 
093 }                                                 068 }
094                                                   069 
095                                                !! 070 /* Page fault exception handler */
096 /* =========================================== !! 071 static void pgflt_ex(int exid)
097  * Page fault exception handling               << 
098  */                                            << 
099                                                << 
100                                                << 
101 /* Page fault exception handler with demand pa << 
102 static void pgflt_ex(int intid, struct sos_cpu << 
103 {                                                 072 {
104   static sos_ui32_t demand_paging_count = 0;   !! 073   sos_bochs_printf("Got page fault\n");
105   struct sos_thread * cur_thr = sos_thread_get !! 074   sos_x86_videomem_printf(10, 30,
106   sos_vaddr_t faulting_vaddr  = sos_cpu_contex !! 075                           SOS_X86_VIDEO_FG_LTRED | SOS_X86_VIDEO_BG_BLUE,
107   sos_paddr_t ppage_paddr;                     !! 076                           "Got EXPECTED (?) Page fault ! But where ???");
108                                                !! 077   for (;;) ;
109   if (sos_cpu_context_is_in_user_mode(ctxt)    << 
110       || (cur_thr->fixup_uaccess.return_vaddr) << 
111     {                                          << 
112       __label__ unforce_address_space;         << 
113       sos_bool_t need_to_setup_mmu;            << 
114       sos_ui32_t errcode = sos_cpu_context_get << 
115                                                << 
116       /* Make sure to always stay in the inter << 
117          configuration */                      << 
118       need_to_setup_mmu = (cur_thr->squatted_m << 
119                            != sos_process_get_ << 
120       if (need_to_setup_mmu)                   << 
121         sos_thread_prepare_user_space_access(N << 
122                                                << 
123       if (SOS_OK ==                            << 
124           sos_umem_vmm_try_resolve_page_fault( << 
125                                                << 
126                                                << 
127         goto unforce_address_space;            << 
128                                                << 
129       /* If the page fault occured in kernel m << 
130          the fixup address */                  << 
131       if (! sos_cpu_context_is_in_user_mode(ct << 
132         {                                      << 
133           cur_thr->fixup_uaccess.faulted_uaddr << 
134           sos_cpu_context_set_EX_return_addres << 
135                                                << 
136           goto unforce_address_space;          << 
137         }                                      << 
138                                                << 
139       if (need_to_setup_mmu)                   << 
140         sos_thread_end_user_space_access();    << 
141                                                << 
142       sos_bochs_printf("\e[35mTHR %p: Unresolv << 
143                        (void*)sos_thread_get_c << 
144                        sos_cpu_context_get_PC( << 
145                        (unsigned)faulting_vadd << 
146                        (unsigned)sos_cpu_conte << 
147       sos_bochs_printf("Terminating User threa << 
148       sos_thread_exit();                       << 
149                                                << 
150     unforce_address_space:                     << 
151       if (need_to_setup_mmu)                   << 
152         sos_thread_end_user_space_access();    << 
153       return;                                  << 
154     }                                          << 
155                                                << 
156   /* Check if address is covered by any VMM ra << 
157   if (! sos_kmem_vmm_is_valid_vaddr(faulting_v << 
158     {                                          << 
159       /* No: The page fault is out of any kern << 
160          the moment, we don't handle this. */  << 
161       sos_display_fatal_error("Unresolved page << 
162                               sos_cpu_context_ << 
163                               (unsigned)faulti << 
164                               (unsigned)sos_cp << 
165       SOS_ASSERT_FATAL(! "Got page fault (note << 
166     }                                          << 
167                                                << 
168                                                << 
169   /*                                           << 
170    * Demand paging in kernel space             << 
171    */                                          << 
172                                                << 
173   /* Update the number of demand paging reques << 
174   demand_paging_count ++;                      << 
175   display_bits(0, 0,                           << 
176                SOS_X86_VIDEO_FG_LTRED | SOS_X8 << 
177                demand_paging_count);           << 
178                                                << 
179   /* Allocate a new page for the virtual addre << 
180   ppage_paddr = sos_physmem_ref_physpage_new(F << 
181   if (! ppage_paddr)                           << 
182     SOS_ASSERT_FATAL(! "TODO: implement swap.  << 
183   SOS_ASSERT_FATAL(SOS_OK == sos_paging_map(pp << 
184                                             SO << 
185                                             FA << 
186                                             SO << 
187                                             |  << 
188                                             |  << 
189   sos_physmem_unref_physpage(ppage_paddr);     << 
190                                                << 
191   /* Ok, we can now return to interrupted cont << 
192 }                                                 078 }
193                                                   079 
194                                                !! 080 static void test_paging(sos_vaddr_t sos_kernel_core_top_vaddr)
195                                                << 
196 /* =========================================== << 
197  * An operating system MUST always have a read << 
198  * what would the CPU have to execute ?!       << 
199  */                                            << 
200 static void idle_thread(void* unused) __attrib << 
201 static void idle_thread(void* unused)          << 
202 {                                                 081 {
203   sos_ui32_t idle_twiddle = 0;                 !! 082   /* The (linear) address of the page holding the code we are
204                                                !! 083      currently executing */
205   while (1)                                    !! 084   sos_vaddr_t vpage_code = SOS_PAGE_ALIGN_INF(test_paging);
206     {                                          << 
207       /* Remove this instruction if you get an << 
208          exception (old 80386 CPU) */          << 
209       asm("hlt\n");                            << 
210                                                << 
211       idle_twiddle ++;                         << 
212       display_bits(0, 0, SOS_X86_VIDEO_FG_GREE << 
213                    idle_twiddle);              << 
214                                                << 
215       /* Lend the CPU to some other thread */  << 
216       sos_thread_yield();                      << 
217     }                                          << 
218 }                                              << 
219                                                << 
220                                                << 
221 /* =========================================== << 
222  * Kernel thread showing some CPU usage statis << 
223  */                                            << 
224 #define LOAD_DISPLAY_BASELINE  4               << 
225 #define LOAD_DISPLAY_STARTROW 34               << 
226 static void stat_thread(void * unused) __attri << 
227 static void stat_thread(void * unused)         << 
228 {                                              << 
229   while (1)                                    << 
230     {                                          << 
231       sos_ui32_t flags;                        << 
232       sos_ui32_t load1, load5, load15;         << 
233       char str1[11], str5[11], str15[11];      << 
234       struct sos_time t;                       << 
235       t.sec = 1;                               << 
236       t.nanosec = 0;                           << 
237                                                << 
238       sos_thread_sleep(& t);                   << 
239                                                << 
240       sos_disable_IRQs(flags);                 << 
241                                                << 
242       /* The IDLE task is EXcluded in the foll << 
243       sos_load_get_sload(&load1, &load5, &load << 
244       sos_load_to_string(str1, load1);         << 
245       sos_load_to_string(str5, load5);         << 
246       sos_load_to_string(str15, load15);       << 
247       sos_x86_videomem_printf(LOAD_DISPLAY_BAS << 
248                               SOS_X86_VIDEO_FG << 
249                               "Kernel (- Idle) << 
250                               str1, str5, str1 << 
251                                                   085 
252       sos_load_get_uload(&load1, &load5, &load !! 086   /* The new physical page that will hold the code */
253       sos_load_to_string(str1, load1);         !! 087   sos_paddr_t ppage_new;
254       sos_load_to_string(str5, load5);         << 
255       sos_load_to_string(str15, load15);       << 
256       sos_x86_videomem_printf(LOAD_DISPLAY_BAS << 
257                               SOS_X86_VIDEO_FG << 
258                               "User: %s %s %s  << 
259                               str1, str5, str1 << 
260                                                << 
261       sos_load_get_uratio(&load1, &load5, &loa << 
262       sos_load_to_string(str1, load1);         << 
263       sos_load_to_string(str5, load5);         << 
264       sos_load_to_string(str15, load15);       << 
265       sos_x86_videomem_printf(LOAD_DISPLAY_BAS << 
266                               SOS_X86_VIDEO_FG << 
267                               "User CPU %%: %s << 
268                               str1, str5, str1 << 
269                                                << 
270       /* The IDLE task is INcluded in the foll << 
271       sos_load_get_sratio(&load1, &load5, &loa << 
272       sos_load_to_string(str1, load1);         << 
273       sos_load_to_string(str5, load5);         << 
274       sos_load_to_string(str15, load15);       << 
275       sos_x86_videomem_printf(LOAD_DISPLAY_BAS << 
276                               SOS_X86_VIDEO_FG << 
277                               "Kernel CPU %% ( << 
278                               str1, str5, str1 << 
279       sos_restore_IRQs(flags);                 << 
280     }                                          << 
281 }                                              << 
282                                                   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;
283                                                   092 
284 /* =========================================== !! 093   unsigned i;
285  * Start the "init" (userland) process         << 
286  */                                            << 
287 static sos_ret_t                               << 
288 start_init(struct sos_fs_manager_instance * ro << 
289 {                                              << 
290   sos_ret_t retval;                            << 
291   struct sos_umem_vmm_as *as_init;             << 
292   struct sos_process *proc_init;               << 
293   struct sos_thread *new_thr;                  << 
294   sos_uaddr_t ustack, start_uaddr;             << 
295   struct sos_fs_opened_file * init_root, * ini << 
296                                                << 
297   /* Create the new process */                 << 
298   proc_init = sos_process_create("init", FALSE << 
299   if (! proc_init)                             << 
300     return -SOS_ENOMEM;                        << 
301   as_init = sos_process_get_address_space(proc << 
302                                                   094 
                                                   >> 095   /* Bind the page fault exception to one of our routines */
                                                   >> 096   sos_exception_set_routine(SOS_EXCEPT_PAGE_FAULT,
                                                   >> 097                             pgflt_ex);
303                                                   098 
304   /*                                              099   /*
305    * Setup the root and CWD directories of the !! 100    * Test 1: move the page where we execute the code elsewhere in
306    * this process will correspond to the "glob !! 101    * physical memory
307    * system since all the future processes wil << 
308    */                                             102    */
309   retval = sos_fs_new_opened_file(proc_init, r !! 103   sos_x86_videomem_printf(4, 0,
310                                   SOS_FS_OPEN_ !! 104                           SOS_X86_VIDEO_FG_LTGREEN | SOS_X86_VIDEO_BG_BLUE,
311                                   & init_root) !! 105                           "Moving current code elsewhere in physical memory:");
312   if (SOS_OK != retval)                        << 
313     {                                          << 
314       sos_process_unref(proc_init);            << 
315       return -SOS_ENOENT;                      << 
316     }                                          << 
317                                                   106 
318   /* Duplicate the root file to set the curren << 
319      the init process */                       << 
320   retval = sos_fs_duplicate_opened_file(init_r << 
321                                         & init << 
322   if (SOS_OK != retval)                        << 
323     {                                          << 
324       sos_fs_close(init_root);                 << 
325       sos_process_unref(proc_init);            << 
326       return -SOS_ENOENT;                      << 
327     }                                          << 
328                                                   107 
329   /* Now update the process ! */               !! 108   /* Allocate a new physical page */
330   if ( ( SOS_OK != sos_process_chroot(proc_ini !! 109   ppage_new = sos_physmem_ref_physpage_new(FALSE);
331        || ( SOS_OK != sos_process_chdir(proc_i !! 110   if (! ppage_new)
332     {                                             111     {
333       sos_fs_close(init_root);                 !! 112       /* STOP ! No memory left */
334       sos_fs_close(init_cwd);                  !! 113       sos_x86_videomem_putstring(20, 0,
335       sos_process_chroot(proc_init, NULL, & un !! 114                                  SOS_X86_VIDEO_FG_LTRED
336       sos_process_chdir(proc_init, NULL, & unu !! 115                                    | SOS_X86_VIDEO_BG_BLUE,
337       sos_process_unref(proc_init);            !! 116                                  "test_paging : Cannot allocate page");
338       return -SOS_ENOENT;                      !! 117       return;
339     }                                          << 
340                                                << 
341                                                << 
342                                                << 
343   /* Map the 'init' program in user space */   << 
344   start_uaddr = sos_binfmt_elf32_map(as_init,  << 
345   if (0 == start_uaddr)                        << 
346     {                                          << 
347       sos_process_unref(proc_init);            << 
348       return -SOS_ENOENT;                      << 
349     }                                          << 
350                                                << 
351   /* Allocate the user stack */                << 
352   ustack = (SOS_PAGING_TOP_USER_ADDRESS - SOS_ << 
353   retval = sos_dev_zero_map(as_init, &ustack,  << 
354                             SOS_VM_MAP_PROT_RE << 
355                             /* PRIVATE */ 0);  << 
356   if (SOS_OK != retval)                        << 
357     {                                          << 
358       sos_process_unref(proc_init);            << 
359       return -SOS_ENOMEM;                      << 
360     }                                             118     }
361                                                   119 
362   /* Now create the user thread */             !! 120   sos_x86_videomem_printf(5, 0,
363   new_thr = sos_create_user_thread(NULL,       !! 121                           SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
364                                    proc_init,  !! 122                           "Hello from the address 0x%x in physical memory",
365                                    start_uaddr !! 123                           sos_paging_get_paddr(vpage_code));
366                                    0, 0,       !! 124 
367                                    ustack + SO !! 125   sos_x86_videomem_printf(6, 0,
368                                    SOS_SCHED_P !! 126                           SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
369   if (! new_thr)                               !! 127                           "Transfer vpage 0x%x: ppage 0x%x -> 0x%x (tmp vpage 0x%x)",
370     {                                          !! 128                           vpage_code,
371       sos_process_unref(proc_init);            !! 129                           sos_paging_get_paddr(vpage_code),
372       return -SOS_ENOMEM;                      !! 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);
373     }                                             196     }
374                                                   197 
375   sos_process_unref(proc_init);                !! 198   /* BAD ! Did not get the page fault... */
376   return SOS_OK;                               !! 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);
377 }                                                 203 }
378                                                   204 
379                                                !! 205 /* The C entry point of our operating system */
380                                                !! 206 void sos_main(unsigned long magic, unsigned long addr)
381 /* =========================================== << 
382  * The C entry point of our operating system   << 
383  */                                            << 
384 void sos_main(unsigned long magic, unsigned lo << 
385      __attribute__((noreturn));                << 
386 void sos_main(unsigned long magic, unsigned lo << 
387 {                                                 207 {
                                                   >> 208   unsigned i;
388   sos_paddr_t sos_kernel_core_base_paddr, sos_    209   sos_paddr_t sos_kernel_core_base_paddr, sos_kernel_core_top_paddr;
389   struct sos_time tick_resolution;             << 
390   struct sos_fs_manager_instance * rootfs;     << 
391                                                   210 
392   /* Size of RAM above 1MB. Might be undefined !! 211   /* Grub sends us a structure, called multiboot_info_t with a lot of
393   unsigned long int upper_mem = 0;             !! 212      precious informations about the system, see the multiboot
                                                   >> 213      documentation for more information. */
                                                   >> 214   multiboot_info_t *mbi;
                                                   >> 215   mbi = (multiboot_info_t *) addr;
394                                                   216 
395   /* Setup bochs and console, and clear the co    217   /* Setup bochs and console, and clear the console */
396   sos_bochs_subsystem_setup();                 !! 218   sos_bochs_setup();
397                                                   219 
398   sos_x86_videomem_setup();                       220   sos_x86_videomem_setup();
399   sos_x86_videomem_cls(SOS_X86_VIDEO_BG_BLUE);    221   sos_x86_videomem_cls(SOS_X86_VIDEO_BG_BLUE);
400                                                   222 
401   /* Greetings from SOS */                        223   /* Greetings from SOS */
402   if (magic == MULTIBOOT_BOOTLOADER_MAGIC)        224   if (magic == MULTIBOOT_BOOTLOADER_MAGIC)
403     {                                          !! 225     /* Loaded with Grub */
404       /* Grub sends us a structure, called mul !! 226     sos_x86_videomem_printf(1, 0,
405          precious informations about the syste !! 227                             SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
406          documentation for more information. * !! 228                             "Welcome From GRUB to %s%c RAM is %dMB (upper mem = 0x%x kB)",
407       multiboot_info_t *mbi = (multiboot_info_ !! 229                             "SOS", ',',
408                                                !! 230                             (unsigned)(mbi->mem_upper >> 10) + 1,
409       /* Multiboot says: "The value returned f !! 231                             (unsigned)mbi->mem_upper);
410          maximally the address of the first up << 
411          megabyte.". It also adds: "It is not  << 
412          value." aka "YMMV" ;) */              << 
413       upper_mem = mbi->mem_upper;              << 
414       sos_x86_videomem_printf(1, 0,            << 
415                               SOS_X86_VIDEO_FG << 
416                               "Welcome From GR << 
417                               "SOS article 9.5 << 
418                               (unsigned)(upper << 
419                               (unsigned)upper_ << 
420     }                                          << 
421   else if (magic == 0x42244224)                << 
422     {                                          << 
423       /* Loaded with SOS bootsect */           << 
424       upper_mem = arg;                         << 
425       sos_x86_videomem_printf(1, 0,            << 
426                               SOS_X86_VIDEO_FG << 
427                               "Welcome to %s%c << 
428                               "SOS article 9.5 << 
429                               (unsigned)(upper << 
430                               (unsigned)upper_ << 
431     }                                          << 
432   else                                            232   else
433     /* Not loaded with grub, not from an enhan !! 233     /* Not loaded with grub */
434     sos_x86_videomem_printf(1, 0,                 234     sos_x86_videomem_printf(1, 0,
435                             SOS_X86_VIDEO_FG_Y    235                             SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
436                             "Welcome to SOS ar !! 236                             "Welcome to SOS");
437                                                   237 
438   sos_bochs_putstring("Message in a bochs: Thi !! 238   sos_bochs_putstring("Message in a bochs\n");
439                                                   239 
440   /* Setup CPU segmentation and IRQ subsystem     240   /* Setup CPU segmentation and IRQ subsystem */
441   sos_gdt_subsystem_setup();                   !! 241   sos_gdt_setup();
442   sos_idt_subsystem_setup();                   !! 242   sos_idt_setup();
443                                                   243 
444   /* Setup SOS IRQs and exceptions subsystem *    244   /* Setup SOS IRQs and exceptions subsystem */
445   sos_exception_subsystem_setup();             !! 245   sos_exceptions_setup();
446   sos_irq_subsystem_setup();                   !! 246   sos_irq_setup();
447                                                   247 
448   /* Configure the timer so as to raise the IR    248   /* Configure the timer so as to raise the IRQ0 at a 100Hz rate */
449   sos_i8254_set_frequency(100);                   249   sos_i8254_set_frequency(100);
450                                                   250 
451   /* Setup the kernel time subsystem to get pr << 
452      ticks into account */                     << 
453   tick_resolution = (struct sos_time) { .sec=0 << 
454   sos_time_subsysem_setup(& tick_resolution);  << 
455                                                   251 
456   /* We need to know the RAM size */           !! 252   /* We need a multiboot-compliant boot loader to get the size of the RAM */
457   if (upper_mem == 0)                          !! 253   if (magic != MULTIBOOT_BOOTLOADER_MAGIC)
458     {                                             254     {
459       sos_x86_videomem_putstring(20, 0,           255       sos_x86_videomem_putstring(20, 0,
460                                  SOS_X86_VIDEO    256                                  SOS_X86_VIDEO_FG_LTRED
461                                    | SOS_X86_V    257                                    | SOS_X86_VIDEO_BG_BLUE
462                                    | SOS_X86_V    258                                    | SOS_X86_VIDEO_FG_BLINKING,
463                                  "I don't know !! 259                                  "I'm not loaded with Grub !");
464       /* STOP ! */                                260       /* STOP ! */
465       for (;;)                                    261       for (;;)
466         continue;                                 262         continue;
467     }                                             263     }
468                                                   264 
469   /*                                           << 
470    * Some interrupt handlers                   << 
471    */                                          << 
472                                                << 
473   /* Binding some HW interrupts and exceptions    265   /* Binding some HW interrupts and exceptions to software routines */
474   sos_irq_set_routine(SOS_IRQ_TIMER,              266   sos_irq_set_routine(SOS_IRQ_TIMER,
475                       clk_it);                 !! 267                             clk_it);
476                                                !! 268   /* Enabling the HW interrupts here, this will make the timer HW
477   /*                                           !! 269      interrupt call our clk_it handler */
478    * Setup physical memory management          !! 270   asm volatile ("sti\n");
479    */                                          !! 271   /* Multiboot says: "The value returned for upper memory is maximally
480                                                !! 272      the address of the first upper memory hole minus 1 megabyte.". It
481   SOS_ASSERT_FATAL(SOS_OK                      !! 273      also adds: "It is not guaranteed to be this value." aka "YMMV" ;) */
482                    == sos_physmem_subsystem_se !! 274   sos_physmem_setup((mbi->mem_upper<<10) + (1<<20),
483                                                !! 275                     & sos_kernel_core_base_paddr,
484                                                !! 276                     & sos_kernel_core_top_paddr);
485                                                   277   
486   /*                                              278   /*
487    * Switch to paged-memory mode                  279    * Switch to paged-memory mode
488    */                                             280    */
489                                                   281 
490   /* Disabling interrupts should seem more cor    282   /* Disabling interrupts should seem more correct, but it's not really
491      necessary at this stage */                   283      necessary at this stage */
492   SOS_ASSERT_FATAL(SOS_OK ==                   !! 284   if (sos_paging_setup(sos_kernel_core_base_paddr,
493                    sos_paging_subsystem_setup( !! 285                        sos_kernel_core_top_paddr))
494                                                !! 286     sos_bochs_printf("Could not setup paged memory mode\n");
495                                                !! 287   sos_x86_videomem_printf(2, 0,
496   /* Bind the page fault exception */          !! 288                           SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
497   sos_exception_set_routine(SOS_EXCEPT_PAGE_FA !! 289                           "Paged-memory mode is activated");
498                             pgflt_ex);         !! 290 
499                                                !! 291   test_paging(sos_kernel_core_top_paddr);
500   /*                                           !! 292 
501    * Setup kernel virtual memory allocator     !! 293   /* An operatig system never ends */
502    */                                          !! 294   for (;;)
503                                                !! 295     continue;
504   if (sos_kmem_vmm_subsystem_setup(sos_kernel_ << 
505                                    sos_kernel_ << 
506                                    bootstrap_s << 
507                                    bootstrap_s << 
508                                    + bootstrap << 
509     sos_bochs_printf("Could not setup the Kern << 
510                                                << 
511   if (sos_kmalloc_subsystem_setup())           << 
512     sos_bochs_printf("Could not setup the Kmal << 
513                                                << 
514   /*                                           << 
515    * Initialize the MMU context subsystem      << 
516    */                                          << 
517   sos_mm_context_subsystem_setup();            << 
518                                                << 
519   /*                                           << 
520    * Initialize the CPU context subsystem      << 
521    */                                          << 
522   sos_cpu_context_subsystem_setup();           << 
523                                                   296 
524   /*                                           !! 297   return;
525    * Bind the syscall handler to its software  << 
526    */                                          << 
527   sos_swintr_subsystem_setup();                << 
528                                                << 
529                                                << 
530   /*                                           << 
531    * Initialize the Kernel thread and schedule << 
532    */                                          << 
533                                                << 
534   /* Initialize kernel thread subsystem */     << 
535   sos_thread_subsystem_setup(bootstrap_stack_b << 
536                              bootstrap_stack_s << 
537                                                << 
538   /* Initialize the scheduler */               << 
539   sos_sched_subsystem_setup();                 << 
540                                                << 
541   /* Declare the IDLE thread */                << 
542   SOS_ASSERT_FATAL(sos_create_kernel_thread("i << 
543                                             SO << 
544                                                << 
545   /* Prepare the stats subsystem */            << 
546   sos_load_subsystem_setup();                  << 
547                                                << 
548   /* Declare a thread that prints some stats * << 
549   SOS_ASSERT_FATAL(sos_create_kernel_thread("s << 
550                                             NU << 
551                                             SO << 
552                                                << 
553                                                << 
554   /*                                           << 
555    * Initialise user address space management  << 
556    */                                          << 
557   sos_umem_vmm_subsystem_setup();              << 
558   sos_dev_zero_subsystem_setup();              << 
559                                                << 
560   /* Initialize the page and block cache subsy << 
561   sos_fs_pagecache_subsystem_setup();          << 
562   sos_blockdev_subsystem_setup();              << 
563   sos_dev_mem_chardev_setup();                 << 
564                                                << 
565   /*                                           << 
566    * Initialize process stuff                  << 
567    */                                          << 
568   sos_process_subsystem_setup();               << 
569                                                << 
570                                                << 
571   /* Enabling the HW interrupts here, this wil << 
572      interrupt call the scheduler */           << 
573   asm volatile ("sti\n");                      << 
574                                                << 
575                                                << 
576   SOS_ASSERT_FATAL(SOS_OK == sos_fs_virtfs_sub << 
577   SOS_ASSERT_FATAL(SOS_OK == sos_fs_subsystem_ << 
578                                                << 
579                                                << 
580                                                << 
581                                                << 
582                                                << 
583   tty_subsystem_setup();                       << 
584   sos_ttyS0_subsystem_setup();                 << 
585   sos_console_subsystem_setup();               << 
586                                                << 
587                                                << 
588   sos_ide_subsystem_setup();                   << 
589                                                << 
590                                                << 
591                                                << 
592   /* Start the 'init' process, which in turns  << 
593      programs */                               << 
594   start_init(rootfs);                          << 
595   /*                                           << 
596    * We can safely exit from this function now << 
597    * an idle Kernel thread ready to make the C << 
598    *                                           << 
599    * However, we must EXPLICITELY call sos_thr << 
600    * simple "return" will return nowhere ! Act << 
601    * was initialized by the Grub bootstrap sta << 
602    * word "thread" did not exist. This means t << 
603    * setup in order for a return here to call  << 
604    * automagically. Hence we must call it manu << 
605    * kernel thread where we must do this manua << 
606    */                                          << 
607   sos_bochs_printf("Bye from primary thread !\ << 
608   sos_thread_exit();                           << 
609   SOS_FATAL_ERROR("No trespassing !");         << 
610 }                                                 298 }
                                                      

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