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 /hwcore/exception.c (Article 6.5) and /hwcore/exception.c (Article 7)


001 /* Copyright (C) 2004  David Decotigny            001 /* Copyright (C) 2004  David Decotigny
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 #include "idt.h"                                  018 #include "idt.h"
019 #include "irq.h"                                  019 #include "irq.h"
020                                                   020 
021 #include <sos/assert.h>                           021 #include <sos/assert.h>
                                                   >> 022 #include <drivers/bochs.h>
                                                   >> 023 #include <sos/thread.h>
                                                   >> 024 
022 #include "exception.h"                            025 #include "exception.h"
023                                                   026 
024 /* array of exception wrappers, defined in exc    027 /* array of exception wrappers, defined in exception_wrappers.S */
025 extern sos_vaddr_t sos_exception_wrapper_array    028 extern sos_vaddr_t sos_exception_wrapper_array[SOS_EXCEPT_NUM];
026                                                   029 
027 /* arrays of exception handlers, shared with e    030 /* arrays of exception handlers, shared with exception_wrappers.S */
028 sos_exception_handler_t sos_exception_handler_    031 sos_exception_handler_t sos_exception_handler_array[SOS_EXCEPT_NUM] =
029   { NULL, };                                      032   { NULL, };
030                                                   033 
031 /* List of exception names for the x86 archite    034 /* List of exception names for the x86 architecture */
032 static const char * sos_x86_exnames[] = {         035 static const char * sos_x86_exnames[] = {
033   [SOS_EXCEPT_DIVIDE_ERROR]                = "    036   [SOS_EXCEPT_DIVIDE_ERROR]                = "Division by zero",
034   [SOS_EXCEPT_DEBUG]                       = "    037   [SOS_EXCEPT_DEBUG]                       = "Debug",
035   [SOS_EXCEPT_NMI_INTERRUPT]               = "    038   [SOS_EXCEPT_NMI_INTERRUPT]               = "Non Maskable Interrupt",
036   [SOS_EXCEPT_BREAKPOINT]                  = "    039   [SOS_EXCEPT_BREAKPOINT]                  = "Breakpoint",
037   [SOS_EXCEPT_OVERFLOW]                    = "    040   [SOS_EXCEPT_OVERFLOW]                    = "Overflow",
038   [SOS_EXCEPT_BOUND_RANGE_EXCEDEED]        = "    041   [SOS_EXCEPT_BOUND_RANGE_EXCEDEED]        = "Bound Range Exceeded",
039   [SOS_EXCEPT_INVALID_OPCODE]              = "    042   [SOS_EXCEPT_INVALID_OPCODE]              = "Invalid Opcode",
040   [SOS_EXCEPT_DEVICE_NOT_AVAILABLE]        = "    043   [SOS_EXCEPT_DEVICE_NOT_AVAILABLE]        = "Device Unavailable",
041   [SOS_EXCEPT_DOUBLE_FAULT]                = "    044   [SOS_EXCEPT_DOUBLE_FAULT]                = "Double Fault",
042   [SOS_EXCEPT_COPROCESSOR_SEGMENT_OVERRUN] = "    045   [SOS_EXCEPT_COPROCESSOR_SEGMENT_OVERRUN] = "Coprocessor Segment Overrun",
043   [SOS_EXCEPT_INVALID_TSS]                 = "    046   [SOS_EXCEPT_INVALID_TSS]                 = "Invalid TSS",
044   [SOS_EXCEPT_SEGMENT_NOT_PRESENT]         = "    047   [SOS_EXCEPT_SEGMENT_NOT_PRESENT]         = "Segment Not Present",
045   [SOS_EXCEPT_STACK_SEGMENT_FAULT]         = "    048   [SOS_EXCEPT_STACK_SEGMENT_FAULT]         = "Stack Segfault",
046   [SOS_EXCEPT_GENERAL_PROTECTION]          = "    049   [SOS_EXCEPT_GENERAL_PROTECTION]          = "General Protection",
047   [SOS_EXCEPT_PAGE_FAULT]                  = "    050   [SOS_EXCEPT_PAGE_FAULT]                  = "Page Fault",
048   [SOS_EXCEPT_INTEL_RESERVED_1]            = "    051   [SOS_EXCEPT_INTEL_RESERVED_1]            = "INTEL1",
049   [SOS_EXCEPT_FLOATING_POINT_ERROR]        = "    052   [SOS_EXCEPT_FLOATING_POINT_ERROR]        = "FP Error",
050   [SOS_EXCEPT_ALIGNEMENT_CHECK]            = "    053   [SOS_EXCEPT_ALIGNEMENT_CHECK]            = "Alignment Check",
051   [SOS_EXCEPT_MACHINE_CHECK]               = "    054   [SOS_EXCEPT_MACHINE_CHECK]               = "Machine Check",
052   [SOS_EXCEPT_INTEL_RESERVED_2]            = "    055   [SOS_EXCEPT_INTEL_RESERVED_2]            = "INTEL2",
053   [SOS_EXCEPT_INTEL_RESERVED_3]            = "    056   [SOS_EXCEPT_INTEL_RESERVED_3]            = "INTEL3",
054   [SOS_EXCEPT_INTEL_RESERVED_4]            = "    057   [SOS_EXCEPT_INTEL_RESERVED_4]            = "INTEL4",
055   [SOS_EXCEPT_INTEL_RESERVED_5]            = "    058   [SOS_EXCEPT_INTEL_RESERVED_5]            = "INTEL5",
056   [SOS_EXCEPT_INTEL_RESERVED_6]            = "    059   [SOS_EXCEPT_INTEL_RESERVED_6]            = "INTEL6",
057   [SOS_EXCEPT_INTEL_RESERVED_7]            = "    060   [SOS_EXCEPT_INTEL_RESERVED_7]            = "INTEL7",
058   [SOS_EXCEPT_INTEL_RESERVED_8]            = "    061   [SOS_EXCEPT_INTEL_RESERVED_8]            = "INTEL8",
059   [SOS_EXCEPT_INTEL_RESERVED_9]            = "    062   [SOS_EXCEPT_INTEL_RESERVED_9]            = "INTEL9",
060   [SOS_EXCEPT_INTEL_RESERVED_10]           = "    063   [SOS_EXCEPT_INTEL_RESERVED_10]           = "INTEL10",
061   [SOS_EXCEPT_INTEL_RESERVED_11]           = "    064   [SOS_EXCEPT_INTEL_RESERVED_11]           = "INTEL11",
062   [SOS_EXCEPT_INTEL_RESERVED_12]           = "    065   [SOS_EXCEPT_INTEL_RESERVED_12]           = "INTEL12",
063   [SOS_EXCEPT_INTEL_RESERVED_13]           = "    066   [SOS_EXCEPT_INTEL_RESERVED_13]           = "INTEL13",
064   [SOS_EXCEPT_INTEL_RESERVED_14]           = "    067   [SOS_EXCEPT_INTEL_RESERVED_14]           = "INTEL14"
065 };                                                068 };
066                                                   069 
067                                                   070 
068 /* Catch-all exception handler */                 071 /* Catch-all exception handler */
069 static void sos_generic_ex(int exid, const str !! 072 static void sos_generic_ex(int exid, struct sos_cpu_state *ctxt)
070 {                                                 073 {
071   const char *exname = sos_exception_get_name(    074   const char *exname = sos_exception_get_name(exid);
072                                                   075 
073   sos_display_fatal_error("Exception %s in Ker !! 076   if (sos_cpu_context_is_in_user_mode(ctxt))
074                           exname,              !! 077     {
075                           sos_cpu_context_get_ !! 078       /* Exception while in user mode */
076                           (unsigned)sos_cpu_co !! 079       sos_bochs_printf("Exception %s in User mode at instruction 0x%x (info=%x)!\n",
                                                   >> 080                        exname,
                                                   >> 081                        sos_cpu_context_get_PC(ctxt),
                                                   >> 082                        (unsigned)sos_cpu_context_get_EX_info(ctxt));
                                                   >> 083       sos_bochs_printf("Terminating User thread\n");
                                                   >> 084       sos_thread_exit();
                                                   >> 085     }
                                                   >> 086   else
                                                   >> 087     sos_display_fatal_error("Exception %s in Kernel at instruction 0x%x (info=%x)!\n",
                                                   >> 088                             exname,
                                                   >> 089                             sos_cpu_context_get_PC(ctxt),
                                                   >> 090                             (unsigned)sos_cpu_context_get_EX_info(ctxt));
077 }                                                 091 }
078                                                   092 
079                                                   093 
080 sos_ret_t sos_exception_subsystem_setup(void)     094 sos_ret_t sos_exception_subsystem_setup(void)
081 {                                                 095 {
082   sos_ret_t retval;                               096   sos_ret_t retval;
083   int exid;                                       097   int exid;
084                                                   098 
085   /* Setup the generic exception handler by de    099   /* Setup the generic exception handler by default for everybody
086      except for the double fault exception */     100      except for the double fault exception */
087   for (exid = 0 ; exid < SOS_EXCEPT_NUM ; exid    101   for (exid = 0 ; exid < SOS_EXCEPT_NUM ; exid ++)
088     {                                             102     {
089       /* Skip double fault (see below) */         103       /* Skip double fault (see below) */
090       if (exid == SOS_EXCEPT_DOUBLE_FAULT)        104       if (exid == SOS_EXCEPT_DOUBLE_FAULT)
091         continue;                                 105         continue;
092                                                   106 
093       retval = sos_exception_set_routine(exid,    107       retval = sos_exception_set_routine(exid, sos_generic_ex);
094       if (SOS_OK != retval)                       108       if (SOS_OK != retval)
095         return retval;                            109         return retval;
096     }                                             110     }
097                                                   111 
098                                                   112 
099   /* We inidicate that the double fault except    113   /* We inidicate that the double fault exception handler is defined,
100      and give its address. this handler is a d    114      and give its address. this handler is a do-nothing handler (see
101      exception_wrappers.S), and it can NOT be     115      exception_wrappers.S), and it can NOT be overriden by the
102      functions below */                           116      functions below */
103   return sos_idt_set_handler(SOS_EXCEPT_BASE +    117   return sos_idt_set_handler(SOS_EXCEPT_BASE + SOS_EXCEPT_DOUBLE_FAULT,
104                             (sos_vaddr_t) sos_    118                             (sos_vaddr_t) sos_exception_wrapper_array[SOS_EXCEPT_DOUBLE_FAULT],
105                             0 /* CPL0 routine     119                             0 /* CPL0 routine */);
106 }                                                 120 }
107                                                   121 
108                                                   122 
109 sos_ret_t sos_exception_set_routine(int except    123 sos_ret_t sos_exception_set_routine(int exception_number,
110                                     sos_except    124                                     sos_exception_handler_t routine)
111 {                                                 125 {
112   sos_ret_t retval;                               126   sos_ret_t retval;
113   sos_ui32_t flags;                               127   sos_ui32_t flags;
114                                                   128   
115   if ((exception_number < 0) || (exception_num    129   if ((exception_number < 0) || (exception_number >= SOS_EXCEPT_NUM))
116     return -SOS_EINVAL;                           130     return -SOS_EINVAL;
117                                                   131 
118   /* Double fault not supported */                132   /* Double fault not supported */
119   if (exception_number == SOS_EXCEPT_DOUBLE_FA    133   if (exception_number == SOS_EXCEPT_DOUBLE_FAULT)
120     return -SOS_ENOSUP;                           134     return -SOS_ENOSUP;
121                                                   135   
122   sos_disable_IRQs(flags);                        136   sos_disable_IRQs(flags);
123                                                   137 
124   retval = SOS_OK;                                138   retval = SOS_OK;
125                                                   139 
126   /* Set the exception routine to be called by    140   /* Set the exception routine to be called by the exception wrapper */
127   sos_exception_handler_array[exception_number    141   sos_exception_handler_array[exception_number] = routine;
128                                                   142 
129   /* If the exception is to be enabled, update    143   /* If the exception is to be enabled, update the IDT with the exception
130      wrapper */                                   144      wrapper */
131   if (routine != NULL)                            145   if (routine != NULL)
132     retval                                        146     retval
133       = sos_idt_set_handler(SOS_EXCEPT_BASE +     147       = sos_idt_set_handler(SOS_EXCEPT_BASE + exception_number,
134                             (sos_vaddr_t) sos_    148                             (sos_vaddr_t) sos_exception_wrapper_array[exception_number],
135                             0 /* CPL0 routine     149                             0 /* CPL0 routine */);
136   else /* Disable the IDT entry */                150   else /* Disable the IDT entry */
137     retval                                        151     retval
138       = sos_idt_set_handler(SOS_EXCEPT_BASE +     152       = sos_idt_set_handler(SOS_EXCEPT_BASE + exception_number,
139                             (sos_vaddr_t)NULL     153                             (sos_vaddr_t)NULL /* No routine => disable IDTE */,
140                             0 /* don't care */    154                             0 /* don't care */);
141                                                   155 
142   sos_restore_IRQs(flags);                        156   sos_restore_IRQs(flags);
143   return retval;                                  157   return retval;
144 }                                                 158 }
145                                                   159 
146                                                   160 
147 sos_exception_handler_t sos_exception_get_rout    161 sos_exception_handler_t sos_exception_get_routine(int exception_number)
148 {                                                 162 {
149   if ((exception_number < 0) || (exception_num    163   if ((exception_number < 0) || (exception_number >= SOS_EXCEPT_NUM))
150     return NULL;                                  164     return NULL;
151                                                   165 
152   /* Double fault not supported */                166   /* Double fault not supported */
153   if (exception_number == SOS_EXCEPT_DOUBLE_FA    167   if (exception_number == SOS_EXCEPT_DOUBLE_FAULT)
154     return NULL;                                  168     return NULL;
155                                                   169   
156   /* Expected to be atomic */                     170   /* Expected to be atomic */
157   return sos_exception_handler_array[exception    171   return sos_exception_handler_array[exception_number];
158 }                                                 172 }
159                                                   173 
160                                                   174 
161 const char * sos_exception_get_name(int except    175 const char * sos_exception_get_name(int exception_number)
162 {                                                 176 {
163   if ((exception_number < 0) || (exception_num    177   if ((exception_number < 0) || (exception_number >= SOS_EXCEPT_NUM))
164     return NULL;                                  178     return NULL;
165                                                   179 
166   return sos_x86_exnames[exception_number];       180   return sos_x86_exnames[exception_number];
167 }                                                 181 }
                                                      

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