Kernel/arch/x86/errors.c

   1 /*
   2  * Acess2 - x86 Architecture
   3  * arch/x86/errors.c
   4  * - CPU Error Handler
   5  */
   6 #include <common.h>
   7 #include <proc.h>
   8
   9 // === CONSTANTS ===
  10 #define MAX_BACKTRACE   8       //!< Maximum distance to trace the stack backwards
  11
  12 // === IMPORTS ===
  13 extern void     MM_PageFault(Uint Addr, Uint ErrorCode, tRegs *Regs);
  14 extern void Threads_Dump();
  15
  16 // === PROTOTYPES ===
  17 void    Error_Backtrace(Uint eip, Uint ebp);
  18
  19 // === CODE ===
  20 /**
  21  * \fn void ErrorHandler(tRegs *Regs)
  22  * \brief General Error Handler
  23  */
  24 void ErrorHandler(tRegs *Regs)
  25 {
  26         Uint    cr;
  27         __asm__ __volatile__ ("cli");
  28
  29         if(Regs->int_num == 14)
  30         {
  31                 __asm__ __volatile__ ("mov %%cr2, %0":"=r"(cr));
  32                 MM_PageFault( cr, Regs->err_code, Regs );
  33                 return ;
  34         }
  35
  36         Warning("CPU Error %i, Code: 0x%x", Regs->int_num, Regs->err_code);
  37         Warning(" CS:EIP = 0x%04x:%08x", Regs->cs, Regs->eip);
  38         Warning(" SS:ESP = 0x%04x:%08x", Regs->ss, Regs->esp);
  39         Warning(" EFLAGS = 0x%08x", Regs->eflags);
  40         Warning(" EAX %08x EBX %08x", Regs->eax, Regs->ebx);
  41         Warning(" ECX %08x EDX %08x", Regs->ecx, Regs->edx);
  42         Warning(" ESP %08x EBP %08x", Regs->esp, Regs->ebp);
  43         Warning(" ESI %08x EDI %08x", Regs->esi, Regs->edi);
  44         Warning(" DS %04x ES %04x", Regs->ds, Regs->es);
  45         Warning(" FS %04x GS %04x", Regs->fs, Regs->gs);
  46
  47         // Control Registers
  48         __asm__ __volatile__ ("mov %%cr0, %0":"=r"(cr));
  49         Warning(" CR0: 0x%08x", cr);
  50         __asm__ __volatile__ ("mov %%cr2, %0":"=r"(cr));
  51         Warning(" CR2: 0x%08x", cr);
  52         __asm__ __volatile__ ("mov %%cr3, %0":"=r"(cr));
  53         Warning(" CR3: 0x%08x", cr);
  54
  55         // Print Stack Backtrace
  56         Error_Backtrace(Regs->eip, Regs->ebp);
  57
  58         // Dump running threads
  59         Threads_Dump();
  60
  61         for(;;) __asm__ __volatile__ ("hlt");
  62 }
  63 /**
  64  * \fn void Error_Backtrace(Uint eip, Uint ebp)
  65  * \brief Unrolls the stack to trace execution
  66  */
  67 void Error_Backtrace(Uint eip, Uint ebp)
  68 {
  69          int    i = 0;
  70         Uint    delta = 0;
  71         char    *str = NULL;
  72
  73         //if(eip < 0xC0000000 && eip > 0x1000)
  74         //{
  75         //      LogF("Backtrace: User - 0x%x\n", eip);
  76         //      return;
  77         //}
  78
  79         if(eip > 0xE0000000)
  80         {
  81                 LogF("Backtrace: Data Area - 0x%x\n", eip);
  82                 return;
  83         }
  84
  85         if(eip > 0xC8000000)
  86         {
  87                 LogF("Backtrace: Kernel Module - 0x%x\n", eip);
  88                 return;
  89         }
  90
  91         //str = Debug_GetSymbol(eip, &delta);
  92         if(str == NULL)
  93                 LogF("Backtrace: 0x%x", eip);
  94         else
  95                 LogF("Backtrace: %s+0x%x", str, delta);
  96         if(!MM_GetPhysAddr(ebp))
  97         {
  98                 LogF("\nBacktrace: Invalid EBP, stopping\n");
  99                 return;
 100         }
 101
 102
 103         while( MM_GetPhysAddr(ebp) && i < MAX_BACKTRACE )
 104         {
 105                 //str = Debug_GetSymbol(*(Uint*)(ebp+4), &delta);
 106                 if(str == NULL)
 107                         LogF(" >> 0x%x", *(Uint*)(ebp+4));
 108                 else
 109                         LogF(" >> %s+0x%x", str, delta);
 110                 ebp = *(Uint*)ebp;
 111                 i++;
 112         }
 113         LogF("\n");
 114 }
 115
 116 /**
 117  * \fn void StartupPrint(char *Str)
 118  */
 119 void StartupPrint(char *Str)
 120 {
 121         Uint16  *buf = (void*)0xC00B8000;
 122          int    i = 0;
 123         static int      line = 0;
 124         while(*Str)
 125         {
 126                 buf[line*80 + i++] = *Str | 0x0700;
 127                 Str ++;
 128         }
 129
 130         while(i < 80)   buf[line*80 + i++] = 0x0720;
 131
 132         line ++;
 133         if(line == 25)
 134         {
 135                 line --;
 136                 memcpy(buf, &buf[80], 80*24*2);
 137                 memset(&buf[80*24], 0, 80*2);
 138         }
 139 }