← Back to branch summary

~galfy/helenos/bird-port-mainline

« back to all changes in this revision

Viewing changes to kernel/generic/src/interrupt/interrupt.c

  • Committer: Martin Decky
  • Date: 2009-08-04 11:19:19 UTC
  • Revision ID: martin@uranus.dsrg.hide.ms.mff.cuni.cz-20090804111919-evyclddlr3v5lhmp
Initial import

Show diffs side-by-side

added added

removed removed

Lines of Context:
kernel/generic/src/interrupt/interrupt.c
 
1
/*
 
2
 * Copyright (c) 2005 Ondrej Palkovsky
 
3
 * All rights reserved.
 
4
 *
 
5
 * Redistribution and use in source and binary forms, with or without
 
6
 * modification, are permitted provided that the following conditions
 
7
 * are met:
 
8
 *
 
9
 * - Redistributions of source code must retain the above copyright
 
10
 *   notice, this list of conditions and the following disclaimer.
 
11
 * - Redistributions in binary form must reproduce the above copyright
 
12
 *   notice, this list of conditions and the following disclaimer in the
 
13
 *   documentation and/or other materials provided with the distribution.
 
14
 * - The name of the author may not be used to endorse or promote products
 
15
 *   derived from this software without specific prior written permission.
 
16
 *
 
17
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 
18
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 
19
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 
20
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 
21
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 
22
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 
23
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 
24
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 
25
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 
26
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
27
 */
 
28
 
 
29
/** @addtogroup genericinterrupt
 
30
 * @{
 
31
 */
 
32
/**
 
33
 * @file
 
34
 * @brief       Interrupt redirector.
 
35
 *
 
36
 * This file provides means of registering interrupt handlers
 
37
 * by kernel functions and calling the handlers when interrupts
 
38
 * occur.
 
39
 */
 
40
 
 
41
#include <interrupt.h>
 
42
#include <debug.h>
 
43
#include <console/kconsole.h>
 
44
#include <console/console.h>
 
45
#include <console/cmd.h>
 
46
#include <panic.h>
 
47
#include <print.h>
 
48
#include <symtab.h>
 
49
 
 
50
static struct {
 
51
        const char *name;
 
52
        iroutine f;
 
53
} exc_table[IVT_ITEMS];
 
54
 
 
55
SPINLOCK_INITIALIZE(exctbl_lock);
 
56
 
 
57
/** Register exception handler
 
58
 * 
 
59
 * @param n Exception number
 
60
 * @param name Description 
 
61
 * @param f Exception handler
 
62
 */
 
63
iroutine exc_register(int n, const char *name, iroutine f)
 
64
{
 
65
        ASSERT(n < IVT_ITEMS);
 
66
        
 
67
        iroutine old;
 
68
        
 
69
        spinlock_lock(&exctbl_lock);
 
70
        
 
71
        old = exc_table[n].f;
 
72
        exc_table[n].f = f;
 
73
        exc_table[n].name = name;
 
74
        
 
75
        spinlock_unlock(&exctbl_lock);
 
76
        
 
77
        return old;
 
78
}
 
79
 
 
80
/** Dispatch exception according to exception table
 
81
 *
 
82
 * Called directly from the assembler code.
 
83
 * CPU is interrupts_disable()'d.
 
84
 */
 
85
void exc_dispatch(int n, istate_t *istate)
 
86
{
 
87
        ASSERT(n < IVT_ITEMS);
 
88
 
 
89
#ifdef CONFIG_UDEBUG
 
90
        if (THREAD) THREAD->udebug.uspace_state = istate;
 
91
#endif
 
92
        
 
93
        exc_table[n].f(n + IVT_FIRST, istate);
 
94
 
 
95
#ifdef CONFIG_UDEBUG
 
96
        if (THREAD) THREAD->udebug.uspace_state = NULL;
 
97
#endif
 
98
 
 
99
        /* This is a safe place to exit exiting thread */
 
100
        if (THREAD && THREAD->interrupted && istate_from_uspace(istate))
 
101
                thread_exit();
 
102
}
 
103
 
 
104
/** Default 'null' exception handler */
 
105
static void exc_undef(int n, istate_t *istate)
 
106
{
 
107
        fault_if_from_uspace(istate, "Unhandled exception %d.", n);
 
108
        panic("Unhandled exception %d.", n);
 
109
}
 
110
 
 
111
#ifdef CONFIG_KCONSOLE
 
112
 
 
113
/** kconsole cmd - print all exceptions */
 
114
static int cmd_exc_print(cmd_arg_t *argv)
 
115
{
 
116
#if (IVT_ITEMS > 0)
 
117
        unsigned int i;
 
118
        char *symbol;
 
119
 
 
120
        spinlock_lock(&exctbl_lock);
 
121
 
 
122
#ifdef __32_BITS__
 
123
        printf("Exc Description          Handler    Symbol\n");
 
124
        printf("--- -------------------- ---------- --------\n");
 
125
#endif
 
126
 
 
127
#ifdef __64_BITS__
 
128
        printf("Exc Description          Handler            Symbol\n");
 
129
        printf("--- -------------------- ------------------ --------\n");
 
130
#endif
 
131
        
 
132
        for (i = 0; i < IVT_ITEMS; i++) {
 
133
                symbol = symtab_fmt_name_lookup((unative_t) exc_table[i].f);
 
134
 
 
135
#ifdef __32_BITS__
 
136
                printf("%-3u %-20s %10p %s\n", i + IVT_FIRST, exc_table[i].name,
 
137
                        exc_table[i].f, symbol);
 
138
#endif
 
139
 
 
140
#ifdef __64_BITS__
 
141
                printf("%-3u %-20s %18p %s\n", i + IVT_FIRST, exc_table[i].name,
 
142
                        exc_table[i].f, symbol);
 
143
#endif
 
144
                
 
145
                if (((i + 1) % 20) == 0) {
 
146
                        printf(" -- Press any key to continue -- ");
 
147
                        spinlock_unlock(&exctbl_lock);
 
148
                        indev_pop_character(stdin);
 
149
                        spinlock_lock(&exctbl_lock);
 
150
                        printf("\n");
 
151
                }
 
152
        }
 
153
        
 
154
        spinlock_unlock(&exctbl_lock);
 
155
#endif
 
156
        
 
157
        return 1;
 
158
}
 
159
 
 
160
 
 
161
static cmd_info_t exc_info = {
 
162
        .name = "exc",
 
163
        .description = "Print exception table.",
 
164
        .func = cmd_exc_print,
 
165
        .help = NULL,
 
166
        .argc = 0,
 
167
        .argv = NULL
 
168
};
 
169
 
 
170
#endif
 
171
 
 
172
/** Initialize generic exception handling support */
 
173
void exc_init(void)
 
174
{
 
175
        int i;
 
176
 
 
177
        for (i = 0; i < IVT_ITEMS; i++)
 
178
                exc_register(i, "undef", (iroutine) exc_undef);
 
179
 
 
180
#ifdef CONFIG_KCONSOLE
 
181
        cmd_initialize(&exc_info);
 
182
        if (!cmd_register(&exc_info))
 
183
                printf("Cannot register command %s\n", exc_info.name);
 
184
#endif
 
185
}
 
186
 
 
187
/** @}
 
188
 */