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


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

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