/*
- * Interrupt Descriptor Table (IDT) setup and interrupt handlers for GDB stub.
+ * Interrupt handlers for GDB stub
*/
-#include <librm.h>
-
#define SIZEOF_I386_REGS 32
#define SIZEOF_I386_FLAGS 4
-/****************************************************************************
- * Interrupt Descriptor Table
- ****************************************************************************
- */
- .section ".data16", "aw", @progbits
- .globl idtr
-idtr:
-idt_limit:
- .word idt_length - 1
-idt_base:
- .long 0
-
-/* IDT entries have the following format:
- * offset_lo, segment selector, flags, offset_hi
- *
- * Since it is not possible to specify relocations in arbitrary
- * expressions like (int_overflow & 0xffff), we initialise the
- * IDT with entries in an incorrect format.
- *
- * The entries are shuffled into the correct format in init_librm().
- */
-#define IDT_ENTRY_EMPTY(name) .word 0, 0, 0, 0
-#define IDT_ENTRY_PRESENT(name) \
- .long int_##name; \
- .word 0x8e00, VIRTUAL_CS
-
-.align 16
-idt:
- IDT_ENTRY_PRESENT(divide_error)
- IDT_ENTRY_PRESENT(debug_trap)
- IDT_ENTRY_EMPTY(non_maskable_interrupt)
- IDT_ENTRY_PRESENT(breakpoint)
- IDT_ENTRY_PRESENT(overflow)
- IDT_ENTRY_PRESENT(bound_range_exceeded)
- IDT_ENTRY_PRESENT(invalid_opcode)
- IDT_ENTRY_EMPTY(device_not_available)
- IDT_ENTRY_PRESENT(double_fault)
- IDT_ENTRY_EMPTY(coprocessor_segment_overrun)
- IDT_ENTRY_PRESENT(invalid_tss)
- IDT_ENTRY_PRESENT(segment_not_present)
- IDT_ENTRY_PRESENT(stack_segment_fault)
- IDT_ENTRY_PRESENT(general_protection)
- IDT_ENTRY_PRESENT(page_fault)
-idt_end:
- .equ idt_length, idt_end - idt
-
-/* The IDT entries are fixed up (once) in init_librm() */
-idt_fixed:
- .byte 0
-
-/****************************************************************************
- * idt_init (real-mode near call, 16-bit real-mode near return address)
- *
- * Initialise the IDT, called from init_librm.
- *
- * Parameters:
- * %eax : IDT base address
- *
- * Destroys %ax, %bx, and %di.
- ****************************************************************************
- */
- .section ".text16", "ax", @progbits
- .code16
- .globl idt_init
-idt_init:
- movl %eax, idt_base
- addl $idt, idt_base
-
- /* IDT entries are only fixed up once */
- movb idt_fixed, %al
- orb %al, %al
- jnz 2f
- movb $1, idt_fixed
-
- /* Shuffle IDT entries into the correct format */
- movb $(idt_length / 8), %al
- movw $idt, %bx
- or %al, %al
- jz 2f
-1:
- movw 2(%bx), %di
- xchg %di, 6(%bx)
- movw %di, 2(%bx)
- addw $8, %bx
- dec %al
- jnz 1b
-2:
- ret
-
/****************************************************************************
* Interrupt handlers
****************************************************************************
#define SIGSEGV 11
#define SIGSTKFLT 16
-int_divide_error:
+ .globl gdbmach_nocode_sigfpe
+gdbmach_nocode_sigfpe:
pushl $SIGFPE
- jmp do_interrupt
+ jmp gdbmach_interrupt
-int_debug_trap:
-int_breakpoint:
+ .globl gdbmach_nocode_sigtrap
+gdbmach_nocode_sigtrap:
pushl $SIGTRAP
- jmp do_interrupt
+ jmp gdbmach_interrupt
-int_overflow:
-int_bound_range_exceeded:
+ .globl gdbmach_nocode_sigstkflt
+gdbmach_nocode_sigstkflt:
pushl $SIGSTKFLT
- jmp do_interrupt
+ jmp gdbmach_interrupt
-int_invalid_opcode:
+ .globl gdbmach_nocode_sigill
+gdbmach_nocode_sigill:
pushl $SIGILL
- jmp do_interrupt
+ jmp gdbmach_interrupt
-int_double_fault:
+ .globl gdbmach_withcode_sigbus
+gdbmach_withcode_sigbus:
movl $SIGBUS, (%esp)
- jmp do_interrupt
+ jmp gdbmach_interrupt
-int_invalid_tss:
-int_segment_not_present:
-int_stack_segment_fault:
-int_general_protection:
-int_page_fault:
+ .globl gdbmach_withcode_sigsegv
+gdbmach_withcode_sigsegv:
movl $SIGSEGV, (%esp)
- jmp do_interrupt
+ jmp gdbmach_interrupt
/* When invoked, the stack contains: eflags, cs, eip, signo. */
#define IH_OFFSET_GDB_REGS ( 0 )
#define IH_OFFSET_FLUX_OLD_EFLAGS ( IH_OFFSET_OLD_EFLAGS - 40 )
#define IH_OFFSET_FLUX_OLD_EIP ( IH_OFFSET_OLD_EIP - 36 )
#define IH_OFFSET_FLUX_END ( IH_OFFSET_END - 20 )
-do_interrupt:
+gdbmach_interrupt:
/* Store CPU state in GDB register snapshot */
pushw $0
pushw %gs
pushl %ecx
pushl %eax
+ /* Switch to virtual addressing */
+ call _intr_to_virt
+
/* Call GDB stub exception handler */
pushl %esp
pushl (IH_OFFSET_SIGNO + 4)(%esp)
call gdbmach_handler
addl $8, %esp
+ /* Copy register snapshot to new stack and switch to new stack */
+ movl %esp, %esi
+ movl (IH_OFFSET_GDB_SEG_REGS + 4)(%esp), %eax
+ movl %eax, %es
+ movl (IH_OFFSET_GDB_REGS + 16)(%esp), %edi
+ subl $IH_OFFSET_END, %edi
+ movl $(IH_OFFSET_END / 4), %ecx
+ pushl %edi
+ ss rep movsl
+ popl %edi
+ movl %eax, %ss
+ movl %edi, %esp
+
/* Restore CPU state from GDB register snapshot */
popl %eax
popl %ecx
popl %edx
popl %ebx
- addl $4, %esp /* Changing ESP currently not supported */
+ popl %ebp /* Skip %esp: already loaded */
popl %ebp
popl %esi
popl %edi
popl IH_OFFSET_FLUX_OLD_EIP(%esp)
popl IH_OFFSET_FLUX_OLD_EFLAGS(%esp)
popl IH_OFFSET_FLUX_OLD_CS(%esp)
- popl %ss
+ popl %ds /* Skip %ss: already loaded */
popl %ds
popl %es
popl %fs
#include <assert.h>
#include <ipxe/uaccess.h>
#include <ipxe/gdbstub.h>
+#include <librm.h>
#include <gdbmach.h>
/** @file
gdbstub_handler ( signo, regs );
gdbmach_enable_hwbps();
}
+
+static void * gdbmach_interrupt_vectors[] = {
+ gdbmach_nocode_sigfpe, /* Divide by zero */
+ gdbmach_nocode_sigtrap, /* Debug trap */
+ NULL, /* Non-maskable interrupt */
+ gdbmach_nocode_sigtrap, /* Breakpoint */
+ gdbmach_nocode_sigstkflt, /* Overflow */
+ gdbmach_nocode_sigstkflt, /* Bound range exceeded */
+ gdbmach_nocode_sigill, /* Invalid opcode */
+ NULL, /* Device not available */
+ gdbmach_withcode_sigbus, /* Double fault */
+ NULL, /* Coprocessor segment overrun */
+ gdbmach_withcode_sigsegv, /* Invalid TSS */
+ gdbmach_withcode_sigsegv, /* Segment not present */
+ gdbmach_withcode_sigsegv, /* Stack segment fault */
+ gdbmach_withcode_sigsegv, /* General protection fault */
+ gdbmach_withcode_sigsegv, /* Page fault */
+};
+
+void gdbmach_init ( void ) {
+ unsigned int i;
+
+ for ( i = 0 ; i < ( sizeof ( gdbmach_interrupt_vectors ) /
+ sizeof ( gdbmach_interrupt_vectors[0] ) ) ; i++ ) {
+ set_interrupt_vector ( i, gdbmach_interrupt_vectors[i] );
+ }
+}
addl %ebp, 12(%esp)
/* Switch to physical code segment */
+ cli
pushl $PHYSICAL_CS
leal 1f(%ebp), %eax
pushl %eax
/* Reload other segment registers and adjust %esp */
movl $PHYSICAL_DS, %eax
movl %eax, %ds
- movl %eax, %es
- movl %eax, %fs
+ movl %eax, %es
+ movl %eax, %fs
movl %eax, %gs
- movl %eax, %ss
+ movl %eax, %ss
addl %ebp, %esp
/* Restore registers and flags, and return */
* selectors. All other registers are preserved. Flags are
* preserved.
*
- * Note that this depends on the GDT already being correctly set up
- * (e.g. by a call to run_here()).
- *
* Parameters: none
* Returns: none
****************************************************************************
pushl %ebp
/* Switch to virtual code segment */
+ cli
ljmp $VIRTUAL_CS, $1f
-1:
+1:
/* Reload data segment registers */
movl $VIRTUAL_DS, %eax
movl %eax, %ds
- movl %eax, %es
- movl %eax, %fs
+ movl %eax, %es
+ movl %eax, %fs
movl %eax, %gs
/* Reload stack segment and adjust %esp */
movl virt_offset, %ebp
- movl %eax, %ss
+ movl %eax, %ss
subl %ebp, %esp
/* Change the return address to a virtual address */
popl %eax
popfl
ret
+
+/****************************************************************************
+ * _intr_to_virt (virtual code segment, virtual or physical stack segment)
+ *
+ * Switch from virtual code segment with either a virtual or physical
+ * stack segment to using virtual addressing. %esp is adjusted if
+ * necessary to a virtual value. Segment registers are set to virtual
+ * selectors. All other registers are preserved. Flags are
+ * preserved.
+ *
+ * Parameters: none
+ * Returns: none
+ ****************************************************************************
+ */
+ .globl _intr_to_virt
+_intr_to_virt:
+ /* Preserve registers and flags */
+ pushfl
+ pushl %eax
+ pushl %ebp
+
+ /* Check whether stack segment is physical or virtual */
+ movl %ss, %eax
+ cmpw $VIRTUAL_DS, %ax
+ movl $VIRTUAL_DS, %eax
+
+ /* Reload data segment registers */
+ movl %eax, %ds
+ movl %eax, %es
+ movl %eax, %fs
+ movl %eax, %gs
+
+ /* Reload stack segment and adjust %esp if necessary */
+ je 1f
+ movl virt_offset, %ebp
+ movl %eax, %ss
+ subl %ebp, %esp
+1:
+ /* Restore registers and flags, and return */
+ popl %ebp
+ popl %eax
+ popfl
+ ret
GDBMACH_AWATCH,
};
+/* Interrupt vectors */
+extern void gdbmach_nocode_sigfpe ( void );
+extern void gdbmach_nocode_sigtrap ( void );
+extern void gdbmach_nocode_sigstkflt ( void );
+extern void gdbmach_nocode_sigill ( void );
+extern void gdbmach_withcode_sigbus ( void );
+extern void gdbmach_withcode_sigsegv ( void );
+
static inline void gdbmach_set_pc ( gdbreg_t *regs, gdbreg_t pc ) {
regs [ GDBMACH_EIP ] = pc;
}
extern int gdbmach_set_breakpoint ( int type, unsigned long addr, size_t len, int enable );
+extern void gdbmach_init ( void );
+
#endif /* GDBMACH_H */
asm_code_str \
"call _phys_to_virt\n\t"
+/** Number of interrupts */
+#define NUM_INT 256
+
+/** An interrupt descriptor table register */
+struct idtr {
+ /** Limit */
+ uint16_t limit;
+ /** Base */
+ uint32_t base;
+} __attribute__ (( packed ));
+
+/** An interrupt descriptor table entry */
+struct interrupt_descriptor {
+ /** Low 16 bits of address */
+ uint16_t low;
+ /** Code segment */
+ uint16_t segment;
+ /** Unused */
+ uint8_t unused;
+ /** Type and attributes */
+ uint8_t attr;
+ /** High 16 bits of address */
+ uint16_t high;
+} __attribute__ (( packed ));
+
+/** Interrupt descriptor is present */
+#define IDTE_PRESENT 0x80
+
+/** Interrupt descriptor 32-bit interrupt gate type */
+#define IDTE_TYPE_IRQ32 0x0e
+
+/** An interrupt vector
+ *
+ * Each interrupt vector comprises an eight-byte fragment of code:
+ *
+ * 60 pushal
+ * b0 xx movb $INT, %al
+ * e9 xx xx xx xx jmp interrupt_wrapper
+ */
+struct interrupt_vector {
+ /** "pushal" instruction */
+ uint8_t pushal;
+ /** "movb" instruction */
+ uint8_t movb;
+ /** Interrupt number */
+ uint8_t intr;
+ /** "jmp" instruction */
+ uint8_t jmp;
+ /** Interrupt wrapper address offset */
+ uint32_t offset;
+ /** Next instruction after jump */
+ uint8_t next[0];
+} __attribute__ (( packed ));
+
+/** "pushal" instruction */
+#define PUSHAL_INSN 0x60
+
+/** "movb" instruction */
+#define MOVB_INSN 0xb0
+
+/** "jmp" instruction */
+#define JMP_INSN 0xe9
+
+extern void set_interrupt_vector ( unsigned int intr, void *vector );
+
#endif /* ASSEMBLY */
#endif /* LIBRM_H */
addr32 leal (%eax, %edi), %ebx
movl %ebx, rm_data16
- /* Set GDT and IDT base */
+ /* Set GDT base */
movl %eax, gdt_base
addl $gdt, gdt_base
- call idt_init
+
+ /* Initialise IDT */
+ pushl $init_idt
+ pushw %cs
+ call prot_call
+ popl %eax /* discard */
/* Restore registers */
negl %edi
.section ".text16", "ax", @progbits
.code16
- .weak idt_init
set_seg_base:
1: movw %ax, 2(%bx)
rorl $16, %eax
movb %al, 4(%bx)
movb %ah, 7(%bx)
roll $16, %eax
-idt_init: /* Reuse the return opcode here */
ret
/****************************************************************************
/* Return to virtual address */
ret
- /* Default IDTR with no interrupts */
+ /* Default real-mode interrupt descriptor table */
.section ".data16", "aw", @progbits
- .weak idtr
-idtr:
rm_idtr:
.word 0xffff /* limit */
.long 0 /* base */
flatten_dummy:
ret
+/****************************************************************************
+ * Interrupt wrapper
+ *
+ * Used by the protected-mode interrupt vectors to call the
+ * interrupt() function.
+ *
+ * May be entered with either physical or virtual stack segment.
+ ****************************************************************************
+ */
+ .globl interrupt_wrapper
+interrupt_wrapper:
+ /* Preserve segment registers and original %esp */
+ pushl %ds
+ pushl %es
+ pushl %fs
+ pushl %gs
+ pushl %ss
+ pushl %esp
+
+ /* Switch to virtual addressing */
+ call _intr_to_virt
+
+ /* Expand IRQ number to whole %eax register */
+ movzbl %al, %eax
+
+ /* Call interrupt handler */
+ call interrupt
+
+ /* Restore original stack and segment registers */
+ lss (%esp), %esp
+ popl %ss
+ popl %gs
+ popl %fs
+ popl %es
+ popl %ds
+
+ /* Restore registers and return */
+ popal
+ iret
+
/****************************************************************************
* Stored real-mode and protected-mode stack pointers
*
#include <stdint.h>
#include <realmode.h>
+#include <pic8259.h>
/*
* This file provides functions for managing librm.
*
*/
+/** The interrupt wrapper */
+extern char interrupt_wrapper[];
+
+/** The interrupt vectors */
+static struct interrupt_vector intr_vec[ IRQ_MAX + 1 ];
+
+/** The interrupt descriptor table */
+struct interrupt_descriptor idt[NUM_INT] __attribute__ (( aligned ( 16 ) ));
+
+/** The interrupt descriptor table register */
+struct idtr __data16 ( idtr ) = {
+ .limit = ( sizeof ( idt ) - 1 ),
+};
+#define idtr __use_data16 ( idtr )
+
/**
* Allocate space on the real-mode stack and copy data there from a
* user buffer
*
- * @v data User buffer
- * @v size Size of stack data
- * @ret sp New value of real-mode stack pointer
+ * @v data User buffer
+ * @v size Size of stack data
+ * @ret sp New value of real-mode stack pointer
*/
uint16_t copy_user_to_rm_stack ( userptr_t data, size_t size ) {
userptr_t rm_stack;
* Deallocate space on the real-mode stack, optionally copying back
* data to a user buffer.
*
- * @v data User buffer
- * @v size Size of stack data
+ * @v data User buffer
+ * @v size Size of stack data
*/
void remove_user_from_rm_stack ( userptr_t data, size_t size ) {
if ( data ) {
rm_sp += size;
};
+/**
+ * Set interrupt vector
+ *
+ * @v intr Interrupt number
+ * @v vector Interrupt vector, or NULL to disable
+ */
+void set_interrupt_vector ( unsigned int intr, void *vector ) {
+ struct interrupt_descriptor *idte;
+
+ idte = &idt[intr];
+ idte->segment = VIRTUAL_CS;
+ idte->attr = ( vector ? ( IDTE_PRESENT | IDTE_TYPE_IRQ32 ) : 0 );
+ idte->low = ( ( ( uint32_t ) vector ) & 0xffff );
+ idte->high = ( ( ( uint32_t ) vector ) >> 16 );
+}
+
+/**
+ * Initialise interrupt descriptor table
+ *
+ */
+void init_idt ( void ) {
+ struct interrupt_vector *vec;
+ unsigned int irq;
+ unsigned int intr;
+
+ /* Initialise the interrupt descriptor table and interrupt vectors */
+ for ( irq = 0 ; irq <= IRQ_MAX ; irq++ ) {
+ intr = IRQ_INT ( irq );
+ vec = &intr_vec[irq];
+ vec->pushal = PUSHAL_INSN;
+ vec->movb = MOVB_INSN;
+ vec->intr = intr;
+ vec->jmp = JMP_INSN;
+ vec->offset = ( ( uint32_t ) interrupt_wrapper -
+ ( uint32_t ) vec->next );
+ set_interrupt_vector ( intr, vec );
+ }
+
+ /* Initialise the interrupt descriptor table register */
+ idtr.base = virt_to_phys ( idt );
+}
+
+/**
+ * Interrupt handler
+ *
+ * @v irq Interrupt number
+ */
+void __attribute__ (( cdecl, regparm ( 1 ) )) interrupt ( int irq ) {
+ uint32_t discard_eax;
+
+ /* Reissue interrupt in real mode */
+ __asm__ __volatile__ ( REAL_CODE ( "movb %%al, %%cs:(1f + 1)\n\t"
+ "\n1:\n\t"
+ "int $0x00\n\t" )
+ : "=a" ( discard_eax ) : "0" ( irq ) );
+}
+
PROVIDE_UACCESS_INLINE ( librm, phys_to_user );
PROVIDE_UACCESS_INLINE ( librm, user_to_phys );
PROVIDE_UACCESS_INLINE ( librm, virt_to_user );
extern int gdbmach_set_breakpoint ( int type, unsigned long addr, size_t len, int enable );
+extern void gdbmach_init ( void );
+
#endif /* GDBMACH_H */
void gdbstub_start ( struct gdb_transport *trans ) {
stub.trans = trans;
stub.payload = &stub.buf [ 1 ];
+ gdbmach_init();
gdbmach_breakpoint();
}
projects / thirdparty / ipxe.git / commitdiff
