WebSVN – HelenOS – Diff – /branches/network/kernel/arch/ia32/src/interrupt.c



#include <cpu.h>
#include <arch/asm.h>
#include <mm/tlb.h>
#include <mm/as.h>
#include <arch.h>
 
#include <proc/thread.h>
#include <proc/task.h>
#include <synch/spinlock.h>
#include <arch/ddi/ddi.h>
#include <ipc/sysipc.h>
#include <interrupt.h>
#include <ddi/irq.h>
#include <symtab.h>
 
/*
 * Interrupt and exception dispatching.
 */
 

void (* enable_irqs_function)(uint16_t irqmask) = NULL;
void (* eoi_function)(void) = NULL;
 
void decode_istate(istate_t *istate)
{
    char *symbol;
 
 
    symbol = symtab_fmt_name_lookup(istate->eip);
 
    if (CPU)
        printf("----------------EXCEPTION OCCURED (cpu%u)----------------\n", CPU->id);
    else
        printf("----------------EXCEPTION OCCURED----------------\n");
       
    printf("%%eip: %#lx (%s)\n", istate->eip, symbol);
    printf("ERROR_WORD=%#lx\n", istate->error_word);
    printf("%%cs=%#lx,flags=%#lx\n", istate->cs, istate->eflags);
    printf("%%eax=%#lx, %%ecx=%#lx, %%edx=%#lx, %%esp=%p\n", istate->eax, istate->ecx, istate->edx, &istate->stack[0]);
 
 
 
    printf("stack: %#lx, %#lx, %#lx, %#lx\n", istate->stack[0], istate->stack[1], istate->stack[2], istate->stack[3]);
    printf("       %#lx, %#lx, %#lx, %#lx\n", istate->stack[4], istate->stack[5], istate->stack[6], istate->stack[7]);
}
 
static void trap_virtual_eoi(void)
{
    if (eoi_function)
        eoi_function();
    else
        panic("No eoi_function.");
 
}
 
static void null_interrupt(int n, istate_t *istate)
{
    fault_if_from_uspace(istate, "Unserviced interrupt: %d.", n);
 
    decode_istate(istate);
    panic("Unserviced interrupt: %d.", n);
}
 
/** General Protection Fault. */
static void gp_fault(int n __attribute__((unused)), istate_t *istate)
{

             * the instruction.
             */
            io_perm_bitmap_install();
            return;
        }
        fault_if_from_uspace(istate, "General protection fault.");
    }
 
    decode_istate(istate);
    panic("General protection fault.");
}
 
static void ss_fault(int n __attribute__((unused)), istate_t *istate)
{
    fault_if_from_uspace(istate, "Stack fault.");
 
    decode_istate(istate);
    panic("Stack fault.");
}
 
static void simd_fp_exception(int n __attribute__((unused)), istate_t *istate)
{
    uint32_t mxcsr;
    asm (
        "stmxcsr %[mxcsr]\n"
        : [mxcsr] "=m" (mxcsr)
    );
    fault_if_from_uspace(istate, "SIMD FP exception(19), MXCSR: %#zx.",
        (unative_t) mxcsr);
   
    decode_istate(istate);
    printf("MXCSR: %#lx\n", mxcsr);
    panic("SIMD FP exception(19).");
}
 
static void nm_fault(int n __attribute__((unused)), istate_t *istate __attribute__((unused)))
{
#ifdef CONFIG_FPU_LAZY     
    scheduler_fpu_lazy_request();
#else
    fault_if_from_uspace(istate, "FPU fault.");
    panic("FPU fault.");
#endif
}
 
#ifdef CONFIG_SMP
static void tlb_shootdown_ipi(int n __attribute__((unused)), istate_t *istate __attribute__((unused)))

        if (irq->preack) {
            /* Send EOI before processing the interrupt */
            trap_virtual_eoi();
            ack = true;
        }
        irq->handler(irq);
        spinlock_unlock(&irq->lock);
    } else {
        /*
         * Spurious interrupt.
         */

void trap_virtual_enable_irqs(uint16_t irqmask)
{
    if (enable_irqs_function)
        enable_irqs_function(irqmask);
    else
        panic("No enable_irqs_function.");
}
 
void trap_virtual_disable_irqs(uint16_t irqmask)
{
    if (disable_irqs_function)
        disable_irqs_function(irqmask);
    else
        panic("No disable_irqs_function.");
}
 
/** @}
 */

Rev 3386	Rev 4153
Line 42...	Line 42...
42	#include <cpu.h>	42	#include <cpu.h>
43	#include <arch/asm.h>	43	#include <arch/asm.h>
44	#include <mm/tlb.h>	44	#include <mm/tlb.h>
45	#include <mm/as.h>	45	#include <mm/as.h>
46	#include <arch.h>	46	#include <arch.h>
47	#include <symtab.h>	-
48	#include <proc/thread.h>	47	#include <proc/thread.h>
49	#include <proc/task.h>	48	#include <proc/task.h>
50	#include <synch/spinlock.h>	49	#include <synch/spinlock.h>
51	#include <arch/ddi/ddi.h>	50	#include <arch/ddi/ddi.h>
52	#include <ipc/sysipc.h>	51	#include <ipc/sysipc.h>
53	#include <interrupt.h>	52	#include <interrupt.h>
54	#include <ddi/irq.h>	53	#include <ddi/irq.h>
-		54	#include <symtab.h>
55		55
56	/*	56	/*
57	* Interrupt and exception dispatching.	57	* Interrupt and exception dispatching.
58	*/	58	*/
59		59
Line 61...	Line 61...
61	void (* enable_irqs_function)(uint16_t irqmask) = NULL;	61	void (* enable_irqs_function)(uint16_t irqmask) = NULL;
62	void (* eoi_function)(void) = NULL;	62	void (* eoi_function)(void) = NULL;
63		63
64	void decode_istate(istate_t *istate)	64	void decode_istate(istate_t *istate)
65	{	65	{
66	char *symbol = get_symtab_entry(istate->eip);	66	char *symbol;
67		67
68	if (!symbol)	-
69	symbol = "";	68	symbol = symtab_fmt_name_lookup(istate->eip);
70		69
71	if (CPU)	70	if (CPU)
72	printf("----------------EXCEPTION OCCURED (cpu%u)----------------\n", CPU->id);	71	printf("----------------EXCEPTION OCCURED (cpu%u)----------------\n", CPU->id);
73	else	72	else
74	printf("----------------EXCEPTION OCCURED----------------\n");	73	printf("----------------EXCEPTION OCCURED----------------\n");
75		74
76	printf("%%eip: %#lx (%s)\n", istate->eip, symbol);	75	printf("%%eip: %#lx (%s)\n", istate->eip, symbol);
77	printf("ERROR_WORD=%#lx\n", istate->error_word);	76	printf("ERROR_WORD=%#lx\n", istate->error_word);
78	printf("%%cs=%#lx,flags=%#lx\n", istate->cs, istate->eflags);	77	printf("%%cs=%#lx,flags=%#lx\n", istate->cs, istate->eflags);
79	printf("%%eax=%#lx, %%ecx=%#lx, %%edx=%#lx, %%esp=%p\n", istate->eax, istate->ecx, istate->edx, &istate->stack[0]);	78	printf("%%eax=%#lx, %%ecx=%#lx, %%edx=%#lx, %%esp=%p\n", istate->eax, istate->ecx, istate->edx, &istate->stack[0]);
80	#ifdef CONFIG_DEBUG_ALLREGS	-
81	printf("%%esi=%#lx, %%edi=%#lx, %%ebp=%#lx, %%ebx=%#lx\n", istate->esi, istate->edi, istate->ebp, istate->ebx);	-
82	#endif	-
83	printf("stack: %#lx, %#lx, %#lx, %#lx\n", istate->stack[0], istate->stack[1], istate->stack[2], istate->stack[3]);	79	printf("stack: %#lx, %#lx, %#lx, %#lx\n", istate->stack[0], istate->stack[1], istate->stack[2], istate->stack[3]);
84	printf(" %#lx, %#lx, %#lx, %#lx\n", istate->stack[4], istate->stack[5], istate->stack[6], istate->stack[7]);	80	printf(" %#lx, %#lx, %#lx, %#lx\n", istate->stack[4], istate->stack[5], istate->stack[6], istate->stack[7]);
85	}	81	}
86		82
87	static void trap_virtual_eoi(void)	83	static void trap_virtual_eoi(void)
88	{	84	{
89	if (eoi_function)	85	if (eoi_function)
90	eoi_function();	86	eoi_function();
91	else	87	else
92	panic("no eoi_function\n");	88	panic("No eoi_function.");
93		89
94	}	90	}
95		91
96	static void null_interrupt(int n, istate_t *istate)	92	static void null_interrupt(int n, istate_t *istate)
97	{	93	{
98	fault_if_from_uspace(istate, "unserviced interrupt: %d", n);	94	fault_if_from_uspace(istate, "Unserviced interrupt: %d.", n);
99		95
100	decode_istate(istate);	96	decode_istate(istate);
101	panic("unserviced interrupt: %d\n", n);	97	panic("Unserviced interrupt: %d.", n);
102	}	98	}
103		99
104	/** General Protection Fault. */	100	/** General Protection Fault. */
105	static void gp_fault(int n __attribute__((unused)), istate_t *istate)	101	static void gp_fault(int n __attribute__((unused)), istate_t *istate)
106	{	102	{
Line 120...	Line 116...
120	* the instruction.	116	* the instruction.
121	*/	117	*/
122	io_perm_bitmap_install();	118	io_perm_bitmap_install();
123	return;	119	return;
124	}	120	}
125	fault_if_from_uspace(istate, "general protection fault");	121	fault_if_from_uspace(istate, "General protection fault.");
126	}	122	}
127		123
128	decode_istate(istate);	124	decode_istate(istate);
129	panic("general protection fault\n");	125	panic("General protection fault.");
130	}	126	}
131		127
132	static void ss_fault(int n __attribute__((unused)), istate_t *istate)	128	static void ss_fault(int n __attribute__((unused)), istate_t *istate)
133	{	129	{
134	fault_if_from_uspace(istate, "stack fault");	130	fault_if_from_uspace(istate, "Stack fault.");
135		131
136	decode_istate(istate);	132	decode_istate(istate);
137	panic("stack fault\n");	133	panic("Stack fault.");
138	}	134	}
139		135
140	static void simd_fp_exception(int n __attribute__((unused)), istate_t *istate)	136	static void simd_fp_exception(int n __attribute__((unused)), istate_t *istate)
141	{	137	{
142	uint32_t mxcsr;	138	uint32_t mxcsr;
143	asm (	139	asm (
144	"stmxcsr %0;\n"	140	"stmxcsr %[mxcsr]\n"
145	: "=m" (mxcsr)	141	: [mxcsr] "=m" (mxcsr)
146	);	142	);
147	fault_if_from_uspace(istate, "SIMD FP exception(19), MXCSR: %#zx",	143	fault_if_from_uspace(istate, "SIMD FP exception(19), MXCSR: %#zx.",
148	(unative_t) mxcsr);	144	(unative_t) mxcsr);
149		145
150	decode_istate(istate);	146	decode_istate(istate);
151	printf("MXCSR: %#lx\n", mxcsr);	147	printf("MXCSR: %#lx\n", mxcsr);
152	panic("SIMD FP exception(19)\n");	148	panic("SIMD FP exception(19).");
153	}	149	}
154		150
155	static void nm_fault(int n __attribute__((unused)), istate_t *istate __attribute__((unused)))	151	static void nm_fault(int n __attribute__((unused)), istate_t *istate __attribute__((unused)))
156	{	152	{
157	#ifdef CONFIG_FPU_LAZY	153	#ifdef CONFIG_FPU_LAZY
158	scheduler_fpu_lazy_request();	154	scheduler_fpu_lazy_request();
159	#else	155	#else
160	fault_if_from_uspace(istate, "fpu fault");	156	fault_if_from_uspace(istate, "FPU fault.");
161	panic("fpu fault");	157	panic("FPU fault.");
162	#endif	158	#endif
163	}	159	}
164		160
165	#ifdef CONFIG_SMP	161	#ifdef CONFIG_SMP
166	static void tlb_shootdown_ipi(int n __attribute__((unused)), istate_t *istate __attribute__((unused)))	162	static void tlb_shootdown_ipi(int n __attribute__((unused)), istate_t *istate __attribute__((unused)))
Line 189...	Line 185...
189	if (irq->preack) {	185	if (irq->preack) {
190	/* Send EOI before processing the interrupt */	186	/* Send EOI before processing the interrupt */
191	trap_virtual_eoi();	187	trap_virtual_eoi();
192	ack = true;	188	ack = true;
193	}	189	}
194	irq->handler(irq, irq->arg);	190	irq->handler(irq);
195	spinlock_unlock(&irq->lock);	191	spinlock_unlock(&irq->lock);
196	} else {	192	} else {
197	/*	193	/*
198	* Spurious interrupt.	194	* Spurious interrupt.
199	*/	195	*/
Line 231...	Line 227...
231	void trap_virtual_enable_irqs(uint16_t irqmask)	227	void trap_virtual_enable_irqs(uint16_t irqmask)
232	{	228	{
233	if (enable_irqs_function)	229	if (enable_irqs_function)
234	enable_irqs_function(irqmask);	230	enable_irqs_function(irqmask);
235	else	231	else
236	panic("no enable_irqs_function\n");	232	panic("No enable_irqs_function.");
237	}	233	}
238		234
239	void trap_virtual_disable_irqs(uint16_t irqmask)	235	void trap_virtual_disable_irqs(uint16_t irqmask)
240	{	236	{
241	if (disable_irqs_function)	237	if (disable_irqs_function)
242	disable_irqs_function(irqmask);	238	disable_irqs_function(irqmask);
243	else	239	else
244	panic("no disable_irqs_function\n");	240	panic("No disable_irqs_function.");
245	}	241	}
246		242
247	/** @}	243	/** @}
248	*/	244	*/

Subversion Repositories HelenOS

(root)/branches/network/kernel/arch/ia32/src/interrupt.c – Rev 3386 → 4153