143 lines
3.5 KiB
C
143 lines
3.5 KiB
C
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <console.h>
|
|
#include <com32.h>
|
|
#include <syslinux/loadfile.h>
|
|
#include "serial.h"
|
|
|
|
#define X86_INT_DB 1
|
|
#define X86_INT_BP 3
|
|
#define COM32_IDT ((void*)0x100000)
|
|
#define COM32_LOAD_ADDR ((void*)0x101000)
|
|
#define STACK_SIZE 0x1000
|
|
|
|
extern char _start[], _end[];
|
|
|
|
struct reloc_info {
|
|
void *data;
|
|
size_t len;
|
|
uint32_t old_esp;
|
|
uint32_t reloc_base;
|
|
};
|
|
|
|
static inline void error(const char *msg)
|
|
{
|
|
fputs(msg, stderr);
|
|
}
|
|
|
|
static inline uint32_t reloc_ptr(struct reloc_info *ri, void *ptr)
|
|
{
|
|
return ri->reloc_base + (uint32_t) ((char *)ptr - _start);
|
|
}
|
|
|
|
static void hijack_interrupt(int intn, uint32_t handler)
|
|
{
|
|
struct {
|
|
uint32_t lo;
|
|
uint32_t hi;
|
|
} *idt = COM32_IDT;
|
|
|
|
idt[intn].lo = (idt[intn].lo & 0xffff0000) | (handler & 0x0000ffff);
|
|
idt[intn].hi = (idt[intn].hi & 0x0000ffff) | (handler & 0xffff0000);
|
|
}
|
|
|
|
static void shift_cmdline(struct com32_sys_args *com32)
|
|
{
|
|
char *p;
|
|
|
|
/* Skip leading whitespace */
|
|
for (p = com32->cs_cmdline; *p != '\0' && *p == ' '; p++) ;
|
|
|
|
/* Skip first word */
|
|
for (; *p != '\0' && *p != ' '; p++) ;
|
|
|
|
/* Skip whitespace after first word */
|
|
for (; *p != '\0' && *p == ' '; p++) ;
|
|
|
|
com32->cs_cmdline = p;
|
|
}
|
|
|
|
static __noreturn reloc_entry(struct reloc_info *ri)
|
|
{
|
|
extern char int_handler[];
|
|
size_t stack_frame_size = sizeof(struct com32_sys_args) + 4;
|
|
struct com32_sys_args *com32;
|
|
uint32_t module_esp;
|
|
|
|
hijack_interrupt(X86_INT_DB, reloc_ptr(ri, int_handler));
|
|
hijack_interrupt(X86_INT_BP, reloc_ptr(ri, int_handler));
|
|
|
|
/* Copy module to load address */
|
|
memcpy(COM32_LOAD_ADDR, ri->data, ri->len);
|
|
|
|
/* Copy stack frame onto module stack */
|
|
module_esp = (ri->reloc_base - stack_frame_size) & ~15;
|
|
memcpy((void *)module_esp, (void *)ri->old_esp, stack_frame_size);
|
|
|
|
/* Fix up command line */
|
|
com32 = (struct com32_sys_args *)(module_esp + 4);
|
|
shift_cmdline(com32);
|
|
|
|
/* Set up CPU state to run module and enter GDB */
|
|
asm volatile ("movl %0, %%esp\n\t"
|
|
"pushf\n\t"
|
|
"pushl %%cs\n\t"
|
|
"pushl %1\n\t"
|
|
"jmp *%2\n\t"::"r" (module_esp),
|
|
"c"(COM32_LOAD_ADDR), "r"(reloc_ptr(ri, int_handler))
|
|
);
|
|
for (;;) ; /* shut the compiler up */
|
|
}
|
|
|
|
static inline __noreturn reloc(void *ptr, size_t len)
|
|
{
|
|
extern uint32_t __entry_esp;
|
|
size_t total_size = _end - _start;
|
|
__noreturn(*entry_fn) (struct reloc_info *);
|
|
struct reloc_info ri;
|
|
uint32_t esp;
|
|
char *dest;
|
|
|
|
/* Calculate relocation address, preserve current stack */
|
|
asm volatile ("movl %%esp, %0\n\t":"=m" (esp));
|
|
dest = (char *)((esp - STACK_SIZE - total_size) & ~3);
|
|
|
|
/* Calculate entry point in relocated code */
|
|
entry_fn = (void *)(dest + ((char *)reloc_entry - _start));
|
|
|
|
/* Copy all sections to relocation address */
|
|
printf("Relocating %d bytes from %p to %p\n", total_size, _start, dest);
|
|
memcpy(dest, _start, total_size);
|
|
|
|
/* Call into relocated code */
|
|
ri.data = ptr;
|
|
ri.len = len;
|
|
ri.old_esp = __entry_esp;
|
|
ri.reloc_base = (uint32_t) dest;
|
|
entry_fn(&ri);
|
|
}
|
|
|
|
int main(int argc, char *argv[])
|
|
{
|
|
void *data;
|
|
size_t data_len;
|
|
|
|
openconsole(&dev_null_r, &dev_stdcon_w);
|
|
|
|
if (argc < 2) {
|
|
error("Usage: gdbstub.c32 com32_file arguments...\n");
|
|
return 1;
|
|
}
|
|
|
|
if (loadfile(argv[1], &data, &data_len)) {
|
|
error("Unable to load file\n");
|
|
return 1;
|
|
}
|
|
|
|
serial_init();
|
|
|
|
/* No more lib calls after this point */
|
|
reloc(data, data_len);
|
|
}
|