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


001 /* Copyright (C) 2004  David Decotigny            001 /* Copyright (C) 2004  David Decotigny
                                                   >> 002    Copyright (C) 1999  Free Software Foundation, Inc.
002                                                   003 
003    This program is free software; you can redi    004    This program is free software; you can redistribute it and/or
004    modify it under the terms of the GNU Genera    005    modify it under the terms of the GNU General Public License
005    as published by the Free Software Foundatio    006    as published by the Free Software Foundation; either version 2
006    of the License, or (at your option) any lat    007    of the License, or (at your option) any later version.
007                                                   008    
008    This program is distributed in the hope tha    009    This program is distributed in the hope that it will be useful,
009    but WITHOUT ANY WARRANTY; without even the     010    but WITHOUT ANY WARRANTY; without even the implied warranty of
010    MERCHANTABILITY or FITNESS FOR A PARTICULAR    011    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
011    GNU General Public License for more details    012    GNU General Public License for more details.
012                                                   013    
013    You should have received a copy of the GNU     014    You should have received a copy of the GNU General Public License
014    along with this program; if not, write to t    015    along with this program; if not, write to the Free Software
015    Foundation, Inc., 59 Temple Place - Suite 3    016    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
016    USA.                                           017    USA. 
017 */                                                018 */
018 #include "idt.h"                                  019 #include "idt.h"
019 #include "irq.h"                                  020 #include "irq.h"
020                                                   021 
021 #include <sos/assert.h>                        << 
022 #include "exception.h"                            022 #include "exception.h"
023                                                   023 
024 /* array of exception wrappers, defined in exc    024 /* array of exception wrappers, defined in exception_wrappers.S */
025 extern sos_vaddr_t sos_exception_wrapper_array    025 extern sos_vaddr_t sos_exception_wrapper_array[SOS_EXCEPT_NUM];
026                                                   026 
027 /* arrays of exception handlers, shared with e    027 /* arrays of exception handlers, shared with exception_wrappers.S */
028 sos_exception_handler_t sos_exception_handler_    028 sos_exception_handler_t sos_exception_handler_array[SOS_EXCEPT_NUM] =
029   { NULL, };                                      029   { NULL, };
030                                                   030 
031 /* List of exception names for the x86 archite << 
032 static const char * sos_x86_exnames[] = {      << 
033   [SOS_EXCEPT_DIVIDE_ERROR]                = " << 
034   [SOS_EXCEPT_DEBUG]                       = " << 
035   [SOS_EXCEPT_NMI_INTERRUPT]               = " << 
036   [SOS_EXCEPT_BREAKPOINT]                  = " << 
037   [SOS_EXCEPT_OVERFLOW]                    = " << 
038   [SOS_EXCEPT_BOUND_RANGE_EXCEDEED]        = " << 
039   [SOS_EXCEPT_INVALID_OPCODE]              = " << 
040   [SOS_EXCEPT_DEVICE_NOT_AVAILABLE]        = " << 
041   [SOS_EXCEPT_DOUBLE_FAULT]                = " << 
042   [SOS_EXCEPT_COPROCESSOR_SEGMENT_OVERRUN] = " << 
043   [SOS_EXCEPT_INVALID_TSS]                 = " << 
044   [SOS_EXCEPT_SEGMENT_NOT_PRESENT]         = " << 
045   [SOS_EXCEPT_STACK_SEGMENT_FAULT]         = " << 
046   [SOS_EXCEPT_GENERAL_PROTECTION]          = " << 
047   [SOS_EXCEPT_PAGE_FAULT]                  = " << 
048   [SOS_EXCEPT_INTEL_RESERVED_1]            = " << 
049   [SOS_EXCEPT_FLOATING_POINT_ERROR]        = " << 
050   [SOS_EXCEPT_ALIGNEMENT_CHECK]            = " << 
051   [SOS_EXCEPT_MACHINE_CHECK]               = " << 
052   [SOS_EXCEPT_INTEL_RESERVED_2]            = " << 
053   [SOS_EXCEPT_INTEL_RESERVED_3]            = " << 
054   [SOS_EXCEPT_INTEL_RESERVED_4]            = " << 
055   [SOS_EXCEPT_INTEL_RESERVED_5]            = " << 
056   [SOS_EXCEPT_INTEL_RESERVED_6]            = " << 
057   [SOS_EXCEPT_INTEL_RESERVED_7]            = " << 
058   [SOS_EXCEPT_INTEL_RESERVED_8]            = " << 
059   [SOS_EXCEPT_INTEL_RESERVED_9]            = " << 
060   [SOS_EXCEPT_INTEL_RESERVED_10]           = " << 
061   [SOS_EXCEPT_INTEL_RESERVED_11]           = " << 
062   [SOS_EXCEPT_INTEL_RESERVED_12]           = " << 
063   [SOS_EXCEPT_INTEL_RESERVED_13]           = " << 
064   [SOS_EXCEPT_INTEL_RESERVED_14]           = " << 
065 };                                             << 
066                                                << 
067                                                << 
068 /* Catch-all exception handler */              << 
069 static void sos_generic_ex(int exid, const str << 
070 {                                              << 
071   const char *exname = sos_exception_get_name( << 
072                                                << 
073   sos_display_fatal_error("Exception %s in Ker << 
074                           exname,              << 
075                           sos_cpu_context_get_ << 
076                           (unsigned)sos_cpu_co << 
077 }                                              << 
078                                                << 
079                                                << 
080 sos_ret_t sos_exception_subsystem_setup(void)     031 sos_ret_t sos_exception_subsystem_setup(void)
081 {                                                 032 {
082   sos_ret_t retval;                            << 
083   int exid;                                    << 
084                                                << 
085   /* Setup the generic exception handler by de << 
086      except for the double fault exception */  << 
087   for (exid = 0 ; exid < SOS_EXCEPT_NUM ; exid << 
088     {                                          << 
089       /* Skip double fault (see below) */      << 
090       if (exid == SOS_EXCEPT_DOUBLE_FAULT)     << 
091         continue;                              << 
092                                                << 
093       retval = sos_exception_set_routine(exid, << 
094       if (SOS_OK != retval)                    << 
095         return retval;                         << 
096     }                                          << 
097                                                << 
098                                                << 
099   /* We inidicate that the double fault except    033   /* We inidicate that the double fault exception handler is defined,
100      and give its address. this handler is a d    034      and give its address. this handler is a do-nothing handler (see
101      exception_wrappers.S), and it can NOT be     035      exception_wrappers.S), and it can NOT be overriden by the
102      functions below */                           036      functions below */
103   return sos_idt_set_handler(SOS_EXCEPT_BASE +    037   return sos_idt_set_handler(SOS_EXCEPT_BASE + SOS_EXCEPT_DOUBLE_FAULT,
104                             (sos_vaddr_t) sos_    038                             (sos_vaddr_t) sos_exception_wrapper_array[SOS_EXCEPT_DOUBLE_FAULT],
105                             0 /* CPL0 routine     039                             0 /* CPL0 routine */);
106 }                                                 040 }
107                                                   041 
108                                                   042 
109 sos_ret_t sos_exception_set_routine(int except    043 sos_ret_t sos_exception_set_routine(int exception_number,
110                                     sos_except    044                                     sos_exception_handler_t routine)
111 {                                                 045 {
112   sos_ret_t retval;                               046   sos_ret_t retval;
113   sos_ui32_t flags;                               047   sos_ui32_t flags;
114                                                   048   
115   if ((exception_number < 0) || (exception_num    049   if ((exception_number < 0) || (exception_number >= SOS_EXCEPT_NUM))
116     return -SOS_EINVAL;                           050     return -SOS_EINVAL;
117                                                   051 
118   /* Double fault not supported */                052   /* Double fault not supported */
119   if (exception_number == SOS_EXCEPT_DOUBLE_FA    053   if (exception_number == SOS_EXCEPT_DOUBLE_FAULT)
120     return -SOS_ENOSUP;                           054     return -SOS_ENOSUP;
121                                                   055   
122   sos_disable_IRQs(flags);                        056   sos_disable_IRQs(flags);
123                                                   057 
124   retval = SOS_OK;                                058   retval = SOS_OK;
125                                                   059 
126   /* Set the exception routine to be called by    060   /* Set the exception routine to be called by the exception wrapper */
127   sos_exception_handler_array[exception_number    061   sos_exception_handler_array[exception_number] = routine;
128                                                   062 
129   /* If the exception is to be enabled, update    063   /* If the exception is to be enabled, update the IDT with the exception
130      wrapper */                                   064      wrapper */
131   if (routine != NULL)                            065   if (routine != NULL)
132     retval                                        066     retval
133       = sos_idt_set_handler(SOS_EXCEPT_BASE +     067       = sos_idt_set_handler(SOS_EXCEPT_BASE + exception_number,
134                             (sos_vaddr_t) sos_    068                             (sos_vaddr_t) sos_exception_wrapper_array[exception_number],
135                             0 /* CPL0 routine     069                             0 /* CPL0 routine */);
136   else /* Disable the IDT entry */                070   else /* Disable the IDT entry */
137     retval                                        071     retval
138       = sos_idt_set_handler(SOS_EXCEPT_BASE +     072       = sos_idt_set_handler(SOS_EXCEPT_BASE + exception_number,
139                             (sos_vaddr_t)NULL     073                             (sos_vaddr_t)NULL /* No routine => disable IDTE */,
140                             0 /* don't care */    074                             0 /* don't care */);
141                                                   075 
142   sos_restore_IRQs(flags);                        076   sos_restore_IRQs(flags);
143   return retval;                                  077   return retval;
144 }                                                 078 }
145                                                   079 
146                                                   080 
147 sos_exception_handler_t sos_exception_get_rout    081 sos_exception_handler_t sos_exception_get_routine(int exception_number)
148 {                                                 082 {
149   if ((exception_number < 0) || (exception_num    083   if ((exception_number < 0) || (exception_number >= SOS_EXCEPT_NUM))
150     return NULL;                                  084     return NULL;
151                                                   085 
152   /* Double fault not supported */                086   /* Double fault not supported */
153   if (exception_number == SOS_EXCEPT_DOUBLE_FA    087   if (exception_number == SOS_EXCEPT_DOUBLE_FAULT)
154     return NULL;                                  088     return NULL;
155                                                   089   
156   /* Expected to be atomic */                     090   /* Expected to be atomic */
157   return sos_exception_handler_array[exception    091   return sos_exception_handler_array[exception_number];
158 }                                              << 
159                                                << 
160                                                << 
161 const char * sos_exception_get_name(int except << 
162 {                                              << 
163   if ((exception_number < 0) || (exception_num << 
164     return NULL;                               << 
165                                                << 
166   return sos_x86_exnames[exception_number];    << 
167 }                                                 092 }
                                                      

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