WebSVN – HelenOS – Diff – //branches/tracing/kernel/arch/amd64/src/interrupt.c



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

void (* eoi_function)(void) = NULL;
 
void decode_istate(int n, istate_t *istate)
{
    char *symbol;
 
 
    symbol = symtab_fmt_name_lookup(istate->rip);
 
 
    printf("-----EXCEPTION(%d) OCCURED----- ( %s )\n", n, __func__);
    printf("%%rip: %#llx (%s)\n", istate->rip, symbol);
    printf("ERROR_WORD=%#llx\n", istate->error_word);
    printf("%%cs=%#llx, rflags=%#llx, %%cr0=%#llx\n", istate->cs,

        istate->rcx, istate->rdx);
    printf("%%rsi=%#llx, %%rdi=%#llx, %%r8=%#llx\n", istate->rsi,
        istate->rdi, istate->r8);
    printf("%%r9=%#llx, %%r10=%#llx, %%r11=%#llx\n", istate->r9,
        istate->r10, istate->r11);
 
 
 
 
 
 
    printf("%%rsp=%#llx\n", &istate->stack[0]);
}
 
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(n, istate);
    panic("Unserviced interrupt.");
}
 
/** General Protection Fault. */
static void gp_fault(int n, istate_t *istate)
{

             * the instruction.
             */
            io_perm_bitmap_install();
            return;
        }
        fault_if_from_uspace(istate, "General protection fault.");
    }
 
    decode_istate(n, istate);
    panic("General protection fault.");
}
 
static void ss_fault(int n, istate_t *istate)
{
    fault_if_from_uspace(istate, "Stack fault.");
    decode_istate(n, istate);
    panic("Stack fault.");
}
 
static void nm_fault(int n, istate_t *istate)
{
#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, istate_t *istate)
{
    trap_virtual_eoi();
    tlb_shootdown_ipi_recv();
}
#endif
 
/** Handler of IRQ exceptions */
static void irq_interrupt(int n, istate_t *istate)
{
    ASSERT(n >= IVT_IRQBASE);

        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 2787	Rev 4377
Line 41...	Line 41...
41	#include <cpu.h>	41	#include <cpu.h>
42	#include <arch/asm.h>	42	#include <arch/asm.h>
43	#include <mm/tlb.h>	43	#include <mm/tlb.h>
44	#include <mm/as.h>	44	#include <mm/as.h>
45	#include <arch.h>	45	#include <arch.h>
46	#include <symtab.h>	-
47	#include <arch/asm.h>	46	#include <arch/asm.h>
48	#include <proc/scheduler.h>	47	#include <proc/scheduler.h>
49	#include <proc/thread.h>	48	#include <proc/thread.h>
50	#include <proc/task.h>	49	#include <proc/task.h>
51	#include <synch/spinlock.h>	50	#include <synch/spinlock.h>
52	#include <arch/ddi/ddi.h>	51	#include <arch/ddi/ddi.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 62...	Line 62...
62	void (* eoi_function)(void) = NULL;	62	void (* eoi_function)(void) = NULL;
63		63
64	void decode_istate(int n, istate_t *istate)	64	void decode_istate(int n, istate_t *istate)
65	{	65	{
66	char *symbol;	66	char *symbol;
67	/* uint64_t x = &istate->stack[0]; /	-
68		67
69	if (!(symbol = get_symtab_entry(istate->rip)))	68	symbol = symtab_fmt_name_lookup(istate->rip);
70	symbol = "";	-
71		69
72	printf("-----EXCEPTION(%d) OCCURED----- ( %s )\n", n, __func__);	70	printf("-----EXCEPTION(%d) OCCURED----- ( %s )\n", n, __func__);
73	printf("%%rip: %#llx (%s)\n", istate->rip, symbol);	71	printf("%%rip: %#llx (%s)\n", istate->rip, symbol);
74	printf("ERROR_WORD=%#llx\n", istate->error_word);	72	printf("ERROR_WORD=%#llx\n", istate->error_word);
75	printf("%%cs=%#llx, rflags=%#llx, %%cr0=%#llx\n", istate->cs,	73	printf("%%cs=%#llx, rflags=%#llx, %%cr0=%#llx\n", istate->cs,
Line 78...	Line 76...
78	istate->rcx, istate->rdx);	76	istate->rcx, istate->rdx);
79	printf("%%rsi=%#llx, %%rdi=%#llx, %%r8=%#llx\n", istate->rsi,	77	printf("%%rsi=%#llx, %%rdi=%#llx, %%r8=%#llx\n", istate->rsi,
80	istate->rdi, istate->r8);	78	istate->rdi, istate->r8);
81	printf("%%r9=%#llx, %%r10=%#llx, %%r11=%#llx\n", istate->r9,	79	printf("%%r9=%#llx, %%r10=%#llx, %%r11=%#llx\n", istate->r9,
82	istate->r10, istate->r11);	80	istate->r10, istate->r11);
83	#ifdef CONFIG_DEBUG_ALLREGS	-
84	printf("%%r12=%#llx, %%r13=%#llx, %%r14=%#llx\n", istate->r12,	-
85	istate->r13, istate->r14);	-
86	printf("%%r15=%#llx, %%rbx=%#llx, %%rbp=%#llx\n", istate->r15,	-
87	istate->rbx, &istate->rbp);	-
88	#endif	-
89	printf("%%rsp=%#llx\n", &istate->stack[0]);	81	printf("%%rsp=%#llx\n", &istate->stack[0]);
90	}	82	}
91		83
92	static void trap_virtual_eoi(void)	84	static void trap_virtual_eoi(void)
93	{	85	{
94	if (eoi_function)	86	if (eoi_function)
95	eoi_function();	87	eoi_function();
96	else	88	else
97	panic("no eoi_function\n");	89	panic("No eoi_function.");
98		90
99	}	91	}
100		92
101	static void null_interrupt(int n, istate_t *istate)	93	static void null_interrupt(int n, istate_t *istate)
102	{	94	{
103	fault_if_from_uspace(istate, "unserviced interrupt: %d", n);	95	fault_if_from_uspace(istate, "Unserviced interrupt: %d.", n);
104	decode_istate(n, istate);	96	decode_istate(n, istate);
105	panic("unserviced interrupt\n");	97	panic("Unserviced interrupt.");
106	}	98	}
107		99
108	/** General Protection Fault. */	100	/** General Protection Fault. */
109	static void gp_fault(int n, istate_t *istate)	101	static void gp_fault(int n, istate_t *istate)
110	{	102	{
Line 124...	Line 116...
124	* the instruction.	116	* the instruction.
125	*/	117	*/
126	io_perm_bitmap_install();	118	io_perm_bitmap_install();
127	return;	119	return;
128	}	120	}
129	fault_if_from_uspace(istate, "general protection fault");	121	fault_if_from_uspace(istate, "General protection fault.");
130	}	122	}
131		123
132	decode_istate(n, istate);	124	decode_istate(n, istate);
133	panic("general protection fault\n");	125	panic("General protection fault.");
134	}	126	}
135		127
136	static void ss_fault(int n, istate_t *istate)	128	static void ss_fault(int n, istate_t *istate)
137	{	129	{
138	fault_if_from_uspace(istate, "stack fault");	130	fault_if_from_uspace(istate, "Stack fault.");
139	decode_istate(n, istate);	131	decode_istate(n, istate);
140	panic("stack fault\n");	132	panic("Stack fault.");
141	}	133	}
142		134
143	static void nm_fault(int n, istate_t *istate)	135	static void nm_fault(int n, istate_t *istate)
144	{	136	{
145	#ifdef CONFIG_FPU_LAZY	137	#ifdef CONFIG_FPU_LAZY
146	scheduler_fpu_lazy_request();	138	scheduler_fpu_lazy_request();
147	#else	139	#else
148	fault_if_from_uspace(istate, "fpu fault");	140	fault_if_from_uspace(istate, "FPU fault.");
149	panic("fpu fault");	141	panic("FPU fault.");
150	#endif	142	#endif
151	}	143	}
152		144
-		145	#ifdef CONFIG_SMP
153	static void tlb_shootdown_ipi(int n, istate_t *istate)	146	static void tlb_shootdown_ipi(int n, istate_t *istate)
154	{	147	{
155	trap_virtual_eoi();	148	trap_virtual_eoi();
156	tlb_shootdown_ipi_recv();	149	tlb_shootdown_ipi_recv();
157	}	150	}
-		151	#endif
158		152
159	/** Handler of IRQ exceptions */	153	/** Handler of IRQ exceptions */
160	static void irq_interrupt(int n, istate_t *istate)	154	static void irq_interrupt(int n, istate_t *istate)
161	{	155	{
162	ASSERT(n >= IVT_IRQBASE);	156	ASSERT(n >= IVT_IRQBASE);
Line 175...	Line 169...
175	if (irq->preack) {	169	if (irq->preack) {
176	/* Send EOI before processing the interrupt */	170	/* Send EOI before processing the interrupt */
177	trap_virtual_eoi();	171	trap_virtual_eoi();
178	ack = true;	172	ack = true;
179	}	173	}
180	irq->handler(irq, irq->arg);	174	irq->handler(irq);
181	spinlock_unlock(&irq->lock);	175	spinlock_unlock(&irq->lock);
182	} else {	176	} else {
183	/*	177	/*
184	* Spurious interrupt.	178	* Spurious interrupt.
185	*/	179	*/
Line 219...	Line 213...
219	void trap_virtual_enable_irqs(uint16_t irqmask)	213	void trap_virtual_enable_irqs(uint16_t irqmask)
220	{	214	{
221	if (enable_irqs_function)	215	if (enable_irqs_function)
222	enable_irqs_function(irqmask);	216	enable_irqs_function(irqmask);
223	else	217	else
224	panic("no enable_irqs_function\n");	218	panic("No enable_irqs_function.");
225	}	219	}
226		220
227	void trap_virtual_disable_irqs(uint16_t irqmask)	221	void trap_virtual_disable_irqs(uint16_t irqmask)
228	{	222	{
229	if (disable_irqs_function)	223	if (disable_irqs_function)
230	disable_irqs_function(irqmask);	224	disable_irqs_function(irqmask);
231	else	225	else
232	panic("no disable_irqs_function\n");	226	panic("No disable_irqs_function.");
233	}	227	}
234		228
235	/** @}	229	/** @}
236	*/	230	*/

Subversion Repositories HelenOS

(root)//branches/tracing/kernel/arch/amd64/src/interrupt.c – Rev 2787 → 4377