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


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

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