19. April 2024, 00:19
Beiträge anzeigen
Diese Sektion erlaubt es dir alle Beiträge dieses Mitglieds zu sehen. Beachte, dass du nur solche Beiträge sehen kannst, zu denen du auch Zugriffsrechte hast.
Übersicht
Wiki
Hilfe
Suche
Einloggen
Registrieren
isr_common_stub:
; save cpu state by pushing
; main purpose registers onto the stack
pusha
mov eax, ds
push eax
mov eax, 0x10
mov ds, eax
mov es, eax
push esp
call Isr_Handler ; call interrupt handler
mov esp, eax
pop eax
mov ds, eax ; get old values
mov es, eax
popa
add esp, 8 ; pop error code, interrupt number
sti ; enable interrupts
iret ; interrupt return
void switch_to_user_mode()
{
// Set up a stack structure for switching to user mode.
asm volatile(" \
cli; \
mov $0x23, %ax; \
mov %ax, %ds; \
mov %ax, %es; \
mov %ax, %fs; \
mov %ax, %gs; \
\
mov %esp, %eax; \
pushl $0x23; \
pushl %eax; \
pushf; \
pushl $0x1B; \
push $1f; \
iret; \
1: \
");
}
[ISR] Exception captured. Kernel stopped.
CPU State:
INT: 13, RING: 0, ERRCODE: 0x0
EAX: 0x1034D2 EBP: 0x1057F4 EBX: 0x0 ECX: 0x0
EDI: 0x0 EDX: 0x0 EIP: 0x100DAC ESI: 0x0
ESP: 0x1057B8 EFLAGS: 0x10216
CS: 0x8 DS: 0x0 SS: 0x0
*
*
*/
cpu_state* Thread_Init(Thread *self, uint32_t *entry, uint8_t *stack)
{
cpu_state new_state = {
.ds = 0,
.eax = 0,
.ebx = 0,
.ecx = 0,
.edx = 0,
.esi = 0,
.edi = 0,
.ebp = 0,
.esp = (uint32_t) stack,
.eip = (uint32_t) entry,
/* Ring-0-Segmentregister */
.cs = 0x08,
.ss = 0x20,
/* Turn on IRQ (IF = 1) */
.eflags = 0x202,
//.useresp = 0,
};
/*
* Copying the new cpu-state on the thread stack let it looks like
* the thread has been interrupted by an interrupt. That way the
* scheduler will just start scheduling this new thread.
*/
cpu_state *state = (void*) (stack + STACK_SIZE - sizeof(new_state));
*state = new_state;
return state;
}
okay dann nenne ich es ab jetzt GP. Ich verstehe aber nicht wieso ich den bekomme da ich nie vom kernel mode in einen anderen switche ..
Erstmal ein allgemeiner Kommentar, der mit dem Problem nichts zu tun hat: Wenn dein Interrupthandler mit cli anfängt, machst du was falsch. Informier dich über den Unterschied zwischen Interrupt und Trap Gates und nimm das passende anstatt IF im Handler manuell zu ändern.
Das nächste ist, dass Segmentregister nur 16 Bit breit sind. Du solltest also ax statt eax benutzen. Ich bin mir nicht sicher, was dein Assembler aus mov eax, ds macht. Speziell bin ich mir unsicher, was mit den oberen 16 Bit passiert. Auch das dürfte nicht das Problem sein, weil du ja nachher beim mov ds, eax wieder eine 16-Bit-Truncation bekommst und dann egal ist, ob in den oberen 16 Bit noch Müll stand.
Ist es der erste Userspace-Entry, der schiefgeht, oder kannst du am Anfang erfolgreich switchen und der Fehler passiert später? Bei ersterem müssten wir die ursprüngliche Initialisierung des Stacks anschauen, bei letzterem den Anfang des Interrupthandlers, der ds sichert. Hilfreich wäre es auch noch, wenn du den Wert von eax beim GPF rausbekommen könntest (z.B. durch den Registerdump von qemu -d int, oder den Errorcode).
Poste mal einen Qemu interrupt-Log!Code: [Auswählen]BENUTZTE_QEMU_BINARY -d int -kernel KERNELSoweit ich rauslesen kann scheinst du ein #gp-Fault zu haben.
bei einem struct cpu_state * kannst du nacheinander alle Register in umgekehrter reinfolge pushen:Code: [Auswählen]push ebp
push edi
push esi
push edx
push ecx
push ebx
push eax
push esp
danach musst du um 4 incrementieren.
%macro isr_stub 1
global isr%1
isr%1:
cli
push byte 0
push byte %1
jmp isr_common_stub
%endmacro
isr_common_stub:
; save cpu state by pushing
; main purpose registers onto the stack
pusha
mov eax, ds
push eax
mov eax, 0x10
mov ds, eax
mov es, eax
mov fs, eax
mov gs, eax
push esp
call Isr_Handler ; call interrupt handler
mov esp, eax
pop eax
mov ds, eax ; get old ds
;mov es, eax
;mov fs, eax
;mov gs, eax
popa
add esp, 8 ; pop error code, interrupt number
sti ; enable interrupts
iret ; interrupt returncpu_state* Isr_Handler(cpu_state *state) {
if (state->int_no <= 0x1F) {
dprint("[ISR] Exception captured. Kernel stopped.");
dprint("CPU State:");
dprint(" INT: %d, RING: %d, ERRCODE: 0x%X\n"
"\n"
" EAX: 0x%X EBP: 0x%X EBX: 0x%X ECX: 0x%X\n"
" EDI: 0x%X EDX: 0x%X EIP: 0x%X ESI: 0x%X\n"
" ESP: 0x%X EFLAGS: 0x%X\n"
" CS: 0x%X DS: 0x%X SS: 0x%X", state->int_no,
state->useresp, state->err_code, state->eax, state->ebp, state->ebx,
state->ecx, state->edi, state->edx, state->eip, state->esi,
state->esp, state->eflags, state->cs, state->ds, state->ss);
while (1) {
// Stop CPU
asm volatile ("cli; hlt");
}
}
// Hardware-Interrupts
if (state->int_no >= 0x20 && state->int_no <= 0x2f) {
dprint("[ISR] Hardware interrupt 0x%X received.", state->int_no);
dprint(" INT: %d, RING: %d, ERRCODE: 0x%X\n"
"\n"
" EAX: 0x%X EBP: 0x%X EBX: 0x%X ECX: 0x%X\n"
" EDI: 0x%X EDX: 0x%X EIP: 0x%X ESI: 0x%X\n"
" ESP: 0x%X EFLAGS: 0x%X\n"
" CS: 0x%X DS: 0x%X SS: 0x%X\n",
state->int_no, state->useresp, state->err_code,
state->eax, state->ebp, state->ebx, state->ecx,
state->edi, state->edx, state->eip, state->esi,
state->esp, state->eflags,
state->cs, state->ds, state->ss);
//uint32_t tss[32] = { 0x00, 0x00, 0x10 };
// Call Scheduler
if (state->int_no == 0x20) {
state = Scheduler_Schedule(scheduler, state);
}
if (state->int_no >= 0x28) {
// TODO Keyboard driver
outb(0xA0, 0x20);
}
outb(0x20, 0x20); // End of interrupt (EOI)
return state;
}
Stack Segment Pointer
Stack Pointer
EFLAGS
Code Segment Pointer
Index Pointer (Nächste Instruktion)
Error Code
Interrupt Nummer
EAX
ECX
.
.
EDI
DS
Return Address
TOP OF STACK
typedef struct cpu_state_struct {
uint32_t ds;
uint32_t edi;
uint32_t esi;
uint32_t ebp;
uint32_t esp;
uint32_t ebx;
uint32_t edx;
uint32_t ecx;
uint32_t eax;
uint32_t int_no, err_code;
uint32_t eip, cs, eflags, useresp, ss; // um usersp und ss geht es...
} cpu_state;
isr_common_stub:
; pusha: (E)AX, (E)CX, (E)DX, (E)BX, (E)SP, (E)BP, (E)SI, (E)DI
; pushes these registers in that order on the stack
pusha
mov eax, ds
push eax
push esp ; pointer to cpu_state structure
call Isr_Handler
mov esp, eax
pop eax
popa
add esp, 8
sti ; enable interrupts
iret ; interrupt return
u32int eip, cs, eflags, useresp, ss; // Pushed by the processor automatically.
_manipulate:
mov eax, [esp+8] ; First parameter
mov ebx, [esp+12] ; Second parameter
mov byte [eax+11], bl
ret
_manipulate:
push ebp
mov ebp, esp
mov eax, [ebp+8] ; First parameter
mov ebx, [ebp+12] ; Second parameter
mov byte [eax+11], bl
pop ebp
ret
http://mycpu.eu/
Der hat sowas selber gemacht auch mit TTL-Bausteinen. Ist aber glaube ich ein CISC.
Gdt_Init();
Idt_Init();
Thread init_threads[2];
cpu_state *init_states[2];
init_states[0] = Thread_Init(&init_threads[0], (uint32_t*)&task_a, stack_a);
init_states[1] = Thread_Init(&init_threads[1], (uint32_t*)&task_b, stack_b);
Scheduler_Init(scheduler, init_states, 2);
Idt_EnableHardwareInterrupts();
static inline void outb(uint16_t port, uint8_t val)
{
1016c0: 55 push ebp
1016c1: 89 e5 mov ebp,esp
1016c3: 83 ec 08 sub esp,0x8
1016c6: 8b 55 08 mov edx,DWORD PTR [ebp+0x8]
1016c9: 8b 45 0c mov eax,DWORD PTR [ebp+0xc]
1016cc: 66 89 55 fc mov WORD PTR [ebp-0x4],dx
1016d0: 88 45 f8 mov BYTE PTR [ebp-0x8],al
__asm__ __volatile__ (
1016d3: 0f b6 45 f8 movzx eax,BYTE PTR [ebp-0x8]
1016d7: 0f b7 55 fc movzx edx,WORD PTR [ebp-0x4]
1016db: ee out dx,al
"outb %b0, %w1"
:
: "a"(val), "d"(port));
}
1016dc: c9 leave
1016dd: c3 ret
(gdb) stepi
27 __asm__ __volatile__ (
(gdb) stepi
0x001016d7 27 __asm__ __volatile__ (
(gdb) stepi
0x001016db 27 __asm__ __volatile__ (
(gdb) info registers
eax 0xb7 183
ecx 0x0 0
edx 0x6667 26215
ebx 0x0 0
esp 0xffffffb0 0xffffffb0
ebp 0xffffffb8 0xffffffb8
esi 0x0 0
edi 0x0 0
eip 0x1016db 0x1016db <outb+27>
eflags 0x82 [ SF ]
cs 0x8 8
ss 0x10 16
ds 0x10 16
es 0x10 16
fs 0x10 16
gs 0x10 16
(gdb) stepi
31 }
(gdb) info registers
eax 0xb7 183
ecx 0x0 0
edx 0x6667 26215
ebx 0x0 0
esp 0xffffffb0 0xffffffb0
ebp 0xffffffb8 0xffffffb8
esi 0x0 0
edi 0x0 0
eip 0x1016dc 0x1016dc <outb+28>
eflags 0x82 [ SF ]
cs 0x8 8
ss 0x10 16
ds 0x10 16
es 0x10 16
fs 0x10 16
gs 0x10 16
(gdb) stepi
0x001016dd in outb (port=26215, val=183 '\267')
at arch/x86/common/source/../../../../debug/include/../../arch/x86/ports/include/Ports.h:31
31 }
(gdb) info registers
eax 0xb7 183
ecx 0x0 0
edx 0x6667 26215
ebx 0x0 0
esp 0xffffffbc 0xffffffbc
ebp 0x66042454 0x66042454
esi 0x0 0
edi 0x0 0
eip 0x1016dd 0x1016dd <outb+29>
eflags 0x82 [ SF ]
cs 0x8 8
ss 0x10 16
ds 0x10 16
es 0x10 16
fs 0x10 16
gs 0x10 16
(gdb) stepi
0x67c2af0f in ?? ()
(gdb) info registers
eax 0xb7 183
ecx 0x0 0
edx 0x6667 26215
ebx 0x0 0
esp 0xffffffc0 0xffffffc0
ebp 0x66042454 0x66042454
esi 0x0 0
edi 0x0 0
eip 0x67c2af0f 0x67c2af0f
eflags 0x82 [ SF ]
cs 0x8 8
ss 0x10 16
ds 0x10 16
es 0x10 16
fs 0x10 16
gs 0x10 16