/* Copyright (C) 2000-2004, The KOS team
    Copyright (C) 1999  Free Software Foundation, Inc.
 
    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/assert.h>
 #include <sos/klibc.h>
 #include <drivers/bochs.h>
 #include <drivers/x86_videomem.h>
 #include <hwcore/segment.h>
 
 #include "cpu_context.h"
 
 
 /**
  * Here is the definition of a CPU context for IA32 processors. This
  * is a SOS convention, not a specification given by the IA32
  * spec. However there is a strong constraint related to the x86
  * interrupt handling specification: the top of the stack MUST be
  * compatible with the 'iret' instruction, ie there must be the
  * err_code (might be 0), eip, cs and eflags of the destination
  * context in that order (see Intel x86 specs vol 3, figure 5-4).
  *
  * @note IMPORTANT: This definition MUST be consistent with the way
  * the registers are stored on the stack in
  * irq_wrappers.S/exception_wrappers.S !!! Hence the constraint above.
  */
 struct sos_cpu_kstate {
   /* (Lower addresses) */
 
   /* These are SOS convention */
   sos_ui16_t  gs;
   sos_ui16_t  fs;
   sos_ui16_t  es;
   sos_ui16_t  ds;
   sos_ui16_t  ss;
   sos_ui16_t  alignment_padding; /* unused */
   sos_ui32_t  eax;
   sos_ui32_t  ebx;
   sos_ui32_t  ecx;
   sos_ui32_t  edx;
   sos_ui32_t  esi;
   sos_ui32_t  edi;
   sos_ui32_t  ebp;
 
   /* MUST NEVER CHANGE (dependent on the IA32 iret instruction) */
   sos_ui32_t  error_code;
   sos_vaddr_t eip;
   sos_ui32_t  cs;
   sos_ui32_t  eflags;
 
   /* (Higher addresses) */
 } __attribute__((packed));
 
 
 static void core_routine (sos_cpu_kstate_function_arg1_t *start_func,
                           sos_ui32_t start_arg,
                           sos_cpu_kstate_function_arg1_t *exit_func,
                           sos_ui32_t exit_arg)
      __attribute__((noreturn));
 
 static void core_routine (sos_cpu_kstate_function_arg1_t *start_func,
                           sos_ui32_t start_arg,
                           sos_cpu_kstate_function_arg1_t *exit_func,
                           sos_ui32_t exit_arg)
 {
   start_func(start_arg);
   exit_func(exit_arg);
 
   SOS_ASSERT_FATAL(! "The exit function of the thread should NOT return !");
   for(;;);
 }
 
 
 sos_ret_t sos_cpu_kstate_init(struct sos_cpu_kstate **ctxt,
                               sos_cpu_kstate_function_arg1_t *start_func,
                               sos_ui32_t  start_arg,
                               sos_vaddr_t stack_bottom,
                               sos_size_t  stack_size,
                               sos_cpu_kstate_function_arg1_t *exit_func,
                               sos_ui32_t  exit_arg)
 {
   /* This is a critical internal function, so that it is assumed that
      the caller knows what he does: we legitimally assume that values
      for ctxt, start_func, stack_* and exit_func are allways VALID ! */
 
   /* Setup the stack.
    *
    * On x86, the stack goes downward. Each frame is configured this
    * way (higher addresses first):
    *
    *  - (optional unused space. As of gcc 3.3, this space is 24 bytes)
    *  - arg n
    *  - arg n-1
    *  - ...
    *  - arg 1
    *  - return instruction address: The address the function returns to
    *    once finished
    *  - local variables
    *
    * The remaining of the code should be read from the end upward to
    * understand how the processor will handle it.
    */
 
   sos_vaddr_t tmp_vaddr = stack_bottom + stack_size;
   sos_ui32_t *stack = (sos_ui32_t*)tmp_vaddr;
 
   /* If needed, poison the stack */
 #ifdef SOS_CPU_KSTATE_DETECT_UNINIT_VARS
   memset((void*)stack_bottom, SOS_CPU_KSTATE_STACK_POISON, stack_size);
 #elif defined(SOS_CPU_KSTATE_DETECT_STACK_OVERFLOW)
   sos_cpu_kstate_prepare_detect_stack_overflow(stack_bottom, stack_size);
 #endif
 
   /* Simulate a call to the core_routine() function: prepare its
      arguments */
   *(--stack) = exit_arg;
   *(--stack) = (sos_ui32_t)exit_func;
   *(--stack) = start_arg;
   *(--stack) = (sos_ui32_t)start_func;
   *(--stack) = 0; /* Return address of core_routine => force page fault */
 
   /*
    * Setup the initial context structure, so that the CPU will execute
    * the function core_routine() once this new context has been
    * restored on CPU
    */
 
   /* Compute the base address of the structure, which must be located
      below the previous elements */
   tmp_vaddr  = ((sos_vaddr_t)stack) - sizeof(struct sos_cpu_kstate);
   *ctxt = (struct sos_cpu_kstate*)tmp_vaddr;
 
   /* Initialize the CPU context structure */
   memset(*ctxt, 0x0, sizeof(struct sos_cpu_kstate));
 
   /* Tell the CPU context structure that the first instruction to
      execute will be that of the core_routine() function */
   (*ctxt)->eip = (sos_ui32_t)core_routine;
 
   /* Setup the segment registers */
   (*ctxt)->cs  = SOS_BUILD_SEGMENT_REG_VALUE(0, 0, SOS_SEG_KCODE); /* Code */
   (*ctxt)->ds  = SOS_BUILD_SEGMENT_REG_VALUE(0, 0, SOS_SEG_KDATA); /* Data */
   (*ctxt)->es  = SOS_BUILD_SEGMENT_REG_VALUE(0, 0, SOS_SEG_KDATA); /* Data */
   (*ctxt)->ss  = SOS_BUILD_SEGMENT_REG_VALUE(0, 0, SOS_SEG_KDATA); /* Stack */
   /* fs and gs unused for the moment. */
 
   /* The newly created context is initially interruptible */
   (*ctxt)->eflags = (1 << 9); /* set IF bit */
 
   return SOS_OK;
 }
 
 
 #if defined(SOS_CPU_KSTATE_DETECT_STACK_OVERFLOW)
 void
 sos_cpu_kstate_prepare_detect_stack_overflow(const struct sos_cpu_kstate *ctxt,
                                              sos_vaddr_t stack_bottom,
                                              sos_size_t stack_size)
 {
   sos_size_t poison_size = SOS_CPU_KSTATE_DETECT_STACK_OVERFLOW;
   if (poison_size > stack_size)
     poison_size = stack_size;
 
   memset((void*)stack_bottom, SOS_CPU_KSTATE_STACK_POISON, poison_size);
 }
 
 
 void
 sos_cpu_kstate_detect_stack_overflow(const struct sos_cpu_kstate *ctxt,
                                      sos_vaddr_t stack_bottom,
                                      sos_size_t stack_size)
 {
   unsigned char *c;
   int i;
 
   SOS_ASSERT_FATAL(((sos_vaddr_t)ctxt) >= stack_bottom);
   SOS_ASSERT_FATAL(((sos_vaddr_t)ctxt) + sizeof(struct sos_cpu_kstate)
                    <= stack_bottom + stack_size);
   for (c = (unsigned char*) stack_bottom, i = 0 ;
        (i < SOS_CPU_KSTATE_DETECT_STACK_OVERFLOW) && (i < stack_size) ;
        c++, i++)
     {
       SOS_ASSERT_FATAL(SOS_CPU_KSTATE_STACK_POISON == *c);
     }
 }
 #endif
 
 
 sos_vaddr_t sos_cpu_kstate_get_PC(const struct sos_cpu_kstate *ctxt)
 {
   SOS_ASSERT_FATAL(NULL != ctxt);
   return ctxt->eip;
 }
 
 
 sos_vaddr_t sos_cpu_kstate_get_SP(const struct sos_cpu_kstate *ctxt)
 {
   SOS_ASSERT_FATAL(NULL != ctxt);
   return (sos_vaddr_t)ctxt;
 }
 
 
 void sos_cpu_kstate_dump(const struct sos_cpu_kstate *ctxt)
 {
   char buf[128];
   snprintf(buf, sizeof(buf),
            "CPU: eip=%x esp=%x eflags=%x cs=%x ds=%x ss=%x err=%x",
            (unsigned)ctxt->eip, (unsigned)ctxt, (unsigned)ctxt->eflags,
            (unsigned)ctxt->cs, (unsigned)ctxt->ds, (unsigned)ctxt->ss,
            (unsigned)ctxt->error_code);
   sos_bochs_putstring(buf); sos_bochs_putstring("\n");
   sos_x86_videomem_putstring(23, 0,
                           SOS_X86_VIDEO_FG_BLACK | SOS_X86_VIDEO_BG_LTGRAY,
                           buf);
 }
 
 
 sos_ui32_t sos_cpu_kstate_get_EX_info(const struct sos_cpu_kstate *ctxt)
 {
   SOS_ASSERT_FATAL(NULL != ctxt);
   return ctxt->error_code;
 }
 
 
 sos_vaddr_t
 sos_cpu_kstate_get_EX_faulting_vaddr(const struct sos_cpu_kstate *ctxt)
 {
   sos_ui32_t cr2;
 
   /* See Intel Vol 3 (section 5.14): the address of the faulting
      virtual address of a page fault is stored in the cr2 register */
   asm volatile ("movl %%cr2, %0"
                 :"=r"(cr2)
                 : );
 
   return cr2;
 }
 
 
 sos_ui32_t sos_backtrace(const struct sos_cpu_kstate *cpu_kstate,
                          sos_ui32_t max_depth,
                          sos_vaddr_t stack_bottom,
                          sos_size_t stack_size,
                          sos_backtrace_callback_t * backtracer,
                          void *custom_arg)
 {
   int depth;
   sos_vaddr_t callee_PC, caller_frame;
 
   /*
    * Layout of a frame on the x86 (compiler=gcc):
    *
    * funcA calls funcB calls funcC
    *
    *         ....
    *         funcB Argument 2
    *         funcB Argument 1
    *         funcA Return eip
    * frameB: funcA ebp (ie previous stack frame)
    *         ....
    *         (funcB local variables)
    *         ....
    *         funcC Argument 2
    *         funcC Argument 1
    *         funcB Return eip
    * frameC: funcB ebp (ie previous stack frame == A0) <---- a frame address
    *         ....
    *         (funcC local variables)
    *         ....
    *
    * The presence of "ebp" on the stack depends on 2 things:
    *   + the compiler is gcc
    *   + the source is compiled WITHOUT the -fomit-frame-pointer option
    * In the absence of "ebp", chances are high that the value pushed
    * at that address is outside the stack boundaries, meaning that the
    * function will return -SOS_ENOSUP.
    */
 
   if (cpu_kstate)
     {
       callee_PC    = cpu_kstate->eip;
       caller_frame = cpu_kstate->ebp;
     }
   else
     {
       /* Skip the sos_backtrace() frame */
       callee_PC    = (sos_vaddr_t)__builtin_return_address(0);
       caller_frame = (sos_vaddr_t)__builtin_frame_address(1);
     }
 
   for(depth=0 ; depth < max_depth ; depth ++)
     {
       /* Call the callback */
       backtracer(callee_PC, caller_frame + 8, depth, custom_arg);
 
       /* If the frame address is funky, don't go further */
       if ( (caller_frame < stack_bottom)
            || (caller_frame + 4 >= stack_bottom + stack_size) )
         return depth;
 
       /* Go to caller frame */
       callee_PC    = *((sos_vaddr_t*) (caller_frame + 4));
       caller_frame = *((sos_vaddr_t*) caller_frame);
     }
   
   return depth;
 }