/* Copyright (C) 2004  The SOS Team
 
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License
    as published by the Free Software Foundation; either version 2
    of the License, or (at your option) any later version.
    
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
    USA. 
 */
 
 #include <sos/errno.h>
 
 /* Include definitions of the multiboot standard */
 #include <bootstrap/multiboot.h>
 #include <hwcore/idt.h>
 #include <hwcore/gdt.h>
 #include <hwcore/irq.h>
 #include <hwcore/exception.h>
 #include <hwcore/i8254.h>
 #include <sos/list.h>
 #include <sos/physmem.h>
 #include <hwcore/paging.h>
 #include <hwcore/mm_context.h>
 #include <hwcore/swintr.h>
 #include <sos/kmem_vmm.h>
 #include <sos/kmalloc.h>
 #include <sos/time.h>
 #include <sos/thread.h>
 #include <sos/process.h>
 #include <sos/umem_vmm.h>
 #include <sos/klibc.h>
 #include <sos/assert.h>
 #include <drivers/x86_videomem.h>
 #include <drivers/bochs.h>
 #include <sos/calcload.h>
 #include <sos/umem_vmm.h>
 #include <sos/binfmt_elf32.h>
 #include <drivers/zero.h>
 #include <sos/fs.h>
 #include <drivers/fs_virtfs.h>
 #include <drivers/devices.h>
 #include <drivers/mem.h>
 #include <drivers/tty.h>
 #include <drivers/console.h>
 #include <drivers/serial.h>
 
 /* Helper function to display each bits of a 32bits integer on the
    screen as dark or light carrets */
 void display_bits(unsigned char row, unsigned char col,
                   unsigned char attribute,
                   sos_ui32_t integer)
 {
   int i;
   /* Scan each bit of the integer, MSb first */
   for (i = 31 ; i >= 0 ; i--)
     {
       /* Test if bit i of 'integer' is set */
       int bit_i = (integer & (1 << i));
       /* Ascii 219 => dark carret, Ascii 177 => light carret */
       unsigned char ascii_code = bit_i?219:177;
       sos_x86_videomem_putchar(row, col++,
                                attribute,
                                ascii_code);
     }
 }
 
 /* Clock IRQ handler */
 static void clk_it(int intid)
 {
   static sos_ui32_t clock_count = 0;
 
   display_bits(0, 48,
                SOS_X86_VIDEO_FG_LTGREEN | SOS_X86_VIDEO_BG_BLUE,
                clock_count);
   clock_count++;
 
   /* Execute the expired timeout actions (if any) */
   sos_time_do_tick();
 
   /* Update scheduler statistics and status */
   sos_sched_do_timer_tick();
 }
 
 
 /* ======================================================================
  * Page fault exception handling
  */
 
 
 /* Page fault exception handler with demand paging for the kernel */
 static void pgflt_ex(int intid, struct sos_cpu_state *ctxt)
 {
   static sos_ui32_t demand_paging_count = 0;
   struct sos_thread * cur_thr = sos_thread_get_current();
   sos_vaddr_t faulting_vaddr  = sos_cpu_context_get_EX_faulting_vaddr(ctxt);
   sos_paddr_t ppage_paddr;
 
   if (sos_cpu_context_is_in_user_mode(ctxt)
       || (cur_thr->fixup_uaccess.return_vaddr))
     {
       __label__ unforce_address_space;
       sos_bool_t need_to_setup_mmu;
       sos_ui32_t errcode = sos_cpu_context_get_EX_info(ctxt);
 
       /* Make sure to always stay in the interrupted thread's MMU
          configuration */
       need_to_setup_mmu = (cur_thr->squatted_mm_context
                            != sos_process_get_mm_context(cur_thr->process));
       if (need_to_setup_mmu)
         sos_thread_prepare_user_space_access(NULL, 0);
 
       if (SOS_OK ==
           sos_umem_vmm_try_resolve_page_fault(faulting_vaddr,
                                               errcode & (1 << 1),
                                               TRUE))
         goto unforce_address_space;
 
       /* If the page fault occured in kernel mode, return to kernel to
          the fixup address */
       if (! sos_cpu_context_is_in_user_mode(ctxt))
         {
           cur_thr->fixup_uaccess.faulted_uaddr = faulting_vaddr;
           sos_cpu_context_set_EX_return_address(ctxt,
                                                 cur_thr->fixup_uaccess.return_vaddr);
           goto unforce_address_space;
         }
 
       if (need_to_setup_mmu)
         sos_thread_end_user_space_access();
 
       sos_bochs_printf("Unresolved USER page Fault at instruction 0x%x on access to address 0x%x (info=%x)!\n",
                        sos_cpu_context_get_PC(ctxt),
                        (unsigned)faulting_vaddr,
                        (unsigned)sos_cpu_context_get_EX_info(ctxt));
       sos_bochs_printf("Terminating User thread\n");
       sos_thread_exit();
 
     unforce_address_space:
       if (need_to_setup_mmu)
         sos_thread_end_user_space_access();
       return;
     }
 
   /* Check if address is covered by any VMM range */
   if (! sos_kmem_vmm_is_valid_vaddr(faulting_vaddr))
     {
       /* No: The page fault is out of any kernel virtual region. For
          the moment, we don't handle this. */
       sos_display_fatal_error("Unresolved page Fault at instruction 0x%x on access to address 0x%x (info=%x)!",
                               sos_cpu_context_get_PC(ctxt),
                               (unsigned)faulting_vaddr,
                               (unsigned)sos_cpu_context_get_EX_info(ctxt));
       SOS_ASSERT_FATAL(! "Got page fault (note: demand paging is disabled)");
     }
 
 
   /*
    * Demand paging in kernel space
    */
  
   /* Update the number of demand paging requests handled */
   demand_paging_count ++;
   display_bits(0, 0,
                SOS_X86_VIDEO_FG_LTRED | SOS_X86_VIDEO_BG_BLUE,
                demand_paging_count);
 
   /* Allocate a new page for the virtual address */
   ppage_paddr = sos_physmem_ref_physpage_new(FALSE);
   if (! ppage_paddr)
     SOS_ASSERT_FATAL(! "TODO: implement swap. (Out of mem in demand paging because no swap for kernel yet !)");
   SOS_ASSERT_FATAL(SOS_OK == sos_paging_map(ppage_paddr,
                                             SOS_PAGE_ALIGN_INF(faulting_vaddr),
                                             FALSE,
                                             SOS_VM_MAP_PROT_READ
                                             | SOS_VM_MAP_PROT_WRITE
                                             | SOS_VM_MAP_ATOMIC));
   sos_physmem_unref_physpage(ppage_paddr);
 
   /* Ok, we can now return to interrupted context */
 }
 
 
 
 /* ======================================================================
  * An operating system MUST always have a ready thread ! Otherwise:
  * what would the CPU have to execute ?!
  */
 static void idle_thread()
 {
   sos_ui32_t idle_twiddle = 0;
 
   while (1)
     {
       /* Remove this instruction if you get an "Invalid opcode" CPU
          exception (old 80386 CPU) */
       asm("hlt\n");
 
       idle_twiddle ++;
       display_bits(0, 0, SOS_X86_VIDEO_FG_GREEN | SOS_X86_VIDEO_BG_BLUE,
                    idle_twiddle);
       
       /* Lend the CPU to some other thread */
       sos_thread_yield();
     }
 }
 
 
 /* ======================================================================
  * Kernel thread showing some CPU usage statistics on the console every 1s
  */
 #define LOAD_DISPLAY_BASELINE  4
 #define LOAD_DISPLAY_STARTROW 34
 static void stat_thread()
 {
   while (1)
     {
       sos_ui32_t flags;
       sos_ui32_t load1, load5, load15;
       char str1[11], str5[11], str15[11];
       struct sos_time t;
       t.sec = 1;
       t.nanosec = 0;
 
       sos_thread_sleep(& t);
 
       sos_disable_IRQs(flags);
 
       /* The IDLE task is EXcluded in the following computation */
       sos_load_get_sload(&load1, &load5, &load15);
       sos_load_to_string(str1, load1);
       sos_load_to_string(str5, load5);
       sos_load_to_string(str15, load15);
       sos_x86_videomem_printf(LOAD_DISPLAY_BASELINE+0, LOAD_DISPLAY_STARTROW,
                               SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
                               "Kernel (- Idle): %s %s %s    ",
                               str1, str5, str15);
 
       sos_load_get_uload(&load1, &load5, &load15);
       sos_load_to_string(str1, load1);
       sos_load_to_string(str5, load5);
       sos_load_to_string(str15, load15);
       sos_x86_videomem_printf(LOAD_DISPLAY_BASELINE+1, LOAD_DISPLAY_STARTROW,
                               SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
                               "User: %s %s %s        ",
                               str1, str5, str15);
 
       sos_load_get_uratio(&load1, &load5, &load15);
       sos_load_to_string(str1, load1);
       sos_load_to_string(str5, load5);
       sos_load_to_string(str15, load15);
       sos_x86_videomem_printf(LOAD_DISPLAY_BASELINE+2, LOAD_DISPLAY_STARTROW,
                               SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
                               "User CPU %%: %s %s %s        ",
                               str1, str5, str15);
 
       /* The IDLE task is INcluded in the following computation */
       sos_load_get_sratio(&load1, &load5, &load15);
       sos_load_to_string(str1, load1);
       sos_load_to_string(str5, load5);
       sos_load_to_string(str15, load15);
       sos_x86_videomem_printf(LOAD_DISPLAY_BASELINE+3, LOAD_DISPLAY_STARTROW,
                               SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
                               "Kernel CPU %% (+ Idle): %s %s %s    ",
                               str1, str5, str15);
       sos_restore_IRQs(flags);
     }
 }
 
 
 /* ======================================================================
  * Start the "init" (userland) process
  */
 static sos_ret_t
 start_init(struct sos_fs_manager_instance * rootfs)
 {
   sos_ret_t retval;
   struct sos_umem_vmm_as *as_init;
   struct sos_process *proc_init;
   struct sos_thread *new_thr;
   sos_uaddr_t ustack, start_uaddr;
   struct sos_fs_opened_file * init_root, * init_cwd, * unused_of;
 
   /* Create the new process */
   proc_init = sos_process_create("init", FALSE);
   if (! proc_init)
     return -SOS_ENOMEM;
   as_init = sos_process_get_address_space(proc_init);
 
 
   /*
    * Setup the root and CWD directories of the process. The root of
    * this process will correspond to the "global" root of the whole
    * system since all the future processes will duplicate it !
    */
   retval = sos_fs_new_opened_file(proc_init, rootfs->root,
                                   SOS_FS_OPEN_READ | SOS_FS_OPEN_WRITE,
                                   & init_root);
   if (SOS_OK != retval)
     {
       sos_process_unref(proc_init);
       return -SOS_ENOENT;
     }
 
   /* Duplicate the root file to set the current working directory of
      the init process */
   retval = sos_fs_duplicate_opened_file(init_root, proc_init,
                                         & init_cwd);
   if (SOS_OK != retval)
     {
       sos_fs_close(init_root);
       sos_process_unref(proc_init);
       return -SOS_ENOENT;
     }
 
   /* Now update the process ! */
   if ( ( SOS_OK != sos_process_chroot(proc_init, init_root, & unused_of) )
        || ( SOS_OK != sos_process_chdir(proc_init, init_cwd, & unused_of) ) )
     {
       sos_fs_close(init_root);
       sos_fs_close(init_cwd);
       sos_process_chroot(proc_init, NULL, & unused_of);
       sos_process_chdir(proc_init, NULL, & unused_of);
       sos_process_unref(proc_init);
       return -SOS_ENOENT;
     }
 
 
 
   /* Map the 'init' program in user space */
   start_uaddr = sos_binfmt_elf32_map(as_init, "init");
   if (0 == start_uaddr)
     {
       sos_process_unref(proc_init);
       return -SOS_ENOENT;
     }
 
   /* Allocate the user stack */
   ustack = (SOS_PAGING_TOP_USER_ADDRESS - SOS_DEFAULT_USER_STACK_SIZE) + 1;
   retval = sos_dev_zero_map(as_init, &ustack, SOS_DEFAULT_USER_STACK_SIZE,
                             SOS_VM_MAP_PROT_READ | SOS_VM_MAP_PROT_WRITE,
                             /* PRIVATE */ 0);
   if (SOS_OK != retval)
     {
       sos_process_unref(proc_init);
       return -SOS_ENOMEM;
     }
 
   /* Now create the user thread */
   new_thr = sos_create_user_thread(NULL,
                                    proc_init,
                                    start_uaddr,
                                    0, 0,
                                    ustack + SOS_DEFAULT_USER_STACK_SIZE - 4,
                                    SOS_SCHED_PRIO_TS_LOWEST);
   if (! new_thr)
     {
       sos_process_unref(proc_init);
       return -SOS_ENOMEM;
     }
 
   sos_process_unref(proc_init);
   return SOS_OK;
 }
 
 
 /* ======================================================================
  * The C entry point of our operating system
  */
 void sos_main(unsigned long magic, unsigned long arg)
 {
   unsigned i;
   sos_paddr_t sos_kernel_core_base_paddr, sos_kernel_core_top_paddr;
   struct sos_time tick_resolution;
   struct sos_fs_manager_instance * rootfs;
 
   /* Size of RAM above 1MB. Might be undefined ! */
   unsigned long int upper_mem = 0;
 
   /* Setup bochs and console, and clear the console */
   sos_bochs_subsystem_setup();
 
   sos_x86_videomem_setup();
   sos_x86_videomem_cls(SOS_X86_VIDEO_BG_BLUE);
 
   /* Greetings from SOS */
   if (magic == MULTIBOOT_BOOTLOADER_MAGIC)
     {
       /* Grub sends us a structure, called multiboot_info_t with a lot of
          precious informations about the system, see the multiboot
          documentation for more information. */
       multiboot_info_t *mbi = (multiboot_info_t *) arg;
 
       /* Multiboot says: "The value returned for upper memory is
          maximally the address of the first upper memory hole minus 1
          megabyte.". It also adds: "It is not guaranteed to be this
          value." aka "YMMV" ;) */
       upper_mem = mbi->mem_upper;
       sos_x86_videomem_printf(1, 0,
                               SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
                               "Welcome From GRUB to %s%c RAM is %dMB (upper mem = 0x%x kB)",
                               "SOS article 9", ',',
                               (unsigned)(upper_mem >> 10) + 1,
                               (unsigned)upper_mem);
     }
   else if (magic == 0x42244224)
     {
       /* Loaded with SOS bootsect */
       upper_mem = arg;
       sos_x86_videomem_printf(1, 0,
                               SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
                               "Welcome to %s%c RAM is %dMB (upper mem = 0x%x kB)",
                               "SOS article 9", ',',
                               (unsigned)(upper_mem >> 10) + 1,
                               (unsigned)upper_mem);
     }
   else
     /* Not loaded with grub, not from an enhanced bootsect */
     sos_x86_videomem_printf(1, 0,
                             SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
                             "Welcome to SOS article 9");
 
   sos_bochs_putstring("Message in a bochs: This is SOS article 9.\n");
 
   /* Setup CPU segmentation and IRQ subsystem */
   sos_gdt_subsystem_setup();
   sos_idt_subsystem_setup();
 
   /* Setup SOS IRQs and exceptions subsystem */
   sos_exception_subsystem_setup();
   sos_irq_subsystem_setup();
 
   /* Configure the timer so as to raise the IRQ0 at a 100Hz rate */
   sos_i8254_set_frequency(100);
 
   /* Setup the kernel time subsystem to get prepared to take the timer
      ticks into account */
   tick_resolution = (struct sos_time) { .sec=0, .nanosec=10000000UL };
   sos_time_subsysem_setup(& tick_resolution);
 
   /* We need to know the RAM size */
   if (upper_mem == 0)
     {
       sos_x86_videomem_putstring(20, 0,
                                  SOS_X86_VIDEO_FG_LTRED
                                    | SOS_X86_VIDEO_BG_BLUE
                                    | SOS_X86_VIDEO_FG_BLINKING,
                                  "I don't know RAM size ! Load me with Grub...");
       /* STOP ! */
       for (;;)
         continue;
     }
 
   /*
    * Some interrupt handlers
    */
 
   /* Binding some HW interrupts and exceptions to software routines */
   sos_irq_set_routine(SOS_IRQ_TIMER,
                       clk_it);
 
   /*
    * Setup physical memory management
    */
 
   SOS_ASSERT_FATAL(SOS_OK
                    == sos_physmem_subsystem_setup((upper_mem<<10) + (1<<20),
                                                   &sos_kernel_core_base_paddr,
                                                   &sos_kernel_core_top_paddr));
   
   /*
    * Switch to paged-memory mode
    */
 
   /* Disabling interrupts should seem more correct, but it's not really
      necessary at this stage */
   SOS_ASSERT_FATAL(SOS_OK ==
                    sos_paging_subsystem_setup(sos_kernel_core_base_paddr,
                                               sos_kernel_core_top_paddr));
   
   /* Bind the page fault exception */
   sos_exception_set_routine(SOS_EXCEPT_PAGE_FAULT,
                             pgflt_ex);
 
   /*
    * Setup kernel virtual memory allocator
    */
 
   if (sos_kmem_vmm_subsystem_setup(sos_kernel_core_base_paddr,
                                    sos_kernel_core_top_paddr,
                                    bootstrap_stack_bottom,
                                    bootstrap_stack_bottom
                                    + bootstrap_stack_size))
     sos_bochs_printf("Could not setup the Kernel virtual space allocator\n");
 
   if (sos_kmalloc_subsystem_setup())
     sos_bochs_printf("Could not setup the Kmalloc subsystem\n");
 
   /*
    * Initialize the MMU context subsystem
    */
   sos_mm_context_subsystem_setup();
 
   /*
    * Initialize the CPU context subsystem
    */
   sos_cpu_context_subsystem_setup();
 
   /*
    * Bind the syscall handler to its software interrupt handler
    */
   sos_swintr_subsystem_setup();
 
 
   /*
    * Initialize the Kernel thread and scheduler subsystems
    */
   
   /* Initialize kernel thread subsystem */
   sos_thread_subsystem_setup(bootstrap_stack_bottom,
                              bootstrap_stack_size);
 
   /* Initialize the scheduler */
   sos_sched_subsystem_setup();
 
   /* Declare the IDLE thread */
   SOS_ASSERT_FATAL(sos_create_kernel_thread("idle", idle_thread, NULL,
                                             SOS_SCHED_PRIO_TS_LOWEST) != NULL);
 
   /* Prepare the stats subsystem */
   sos_load_subsystem_setup();
 
   /* Declare a thread that prints some stats */
   SOS_ASSERT_FATAL(sos_create_kernel_thread("stat_thread", stat_thread,
                                             NULL,
                                             SOS_SCHED_PRIO_TS_LOWEST) != NULL);
 
 
   /*
    * Initialise user address space management subsystem
    */
   sos_umem_vmm_subsystem_setup();
   sos_dev_zero_subsystem_setup();
   sos_dev_mem_chardev_setup();
 
   /*
    * Initialize process stuff
    */
   sos_process_subsystem_setup();
 
 
   /* Enabling the HW interrupts here, this will make the timer HW
      interrupt call the scheduler */
   asm volatile ("sti\n");
 
 
   SOS_ASSERT_FATAL(SOS_OK == sos_fs_virtfs_subsystem_setup());
   SOS_ASSERT_FATAL(SOS_OK == sos_fs_subsystem_setup(NULL,
                                                     "virtfs",
                                                     NULL,
                                                     & rootfs));
 
 
   tty_subsystem_setup();
   sos_ttyS0_subsystem_setup();
   sos_console_subsystem_setup();
 
 
 
 
   /* Start the 'init' process, which in turns launches the other
      programs */
   start_init(rootfs);
   /*
    * We can safely exit from this function now, for there is already
    * an idle Kernel thread ready to make the CPU busy working...
    *
    * However, we must EXPLICITELY call sos_thread_exit() because a
    * simple "return" will return nowhere ! Actually this first thread
    * was initialized by the Grub bootstrap stage, at a time when the
    * word "thread" did not exist. This means that the stack was not
    * setup in order for a return here to call sos_thread_exit()
    * automagically. Hence we must call it manually. This is the ONLY
    * kernel thread where we must do this manually.
    */
   sos_bochs_printf("Bye from primary thread !\n");
   sos_thread_exit();
   SOS_FATAL_ERROR("No trespassing !");
 }