25. April 2024, 09:44
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.
). Um PSE verwenden zu können, muss der Prozessor dies ja unterstützen.). Die LEDs sind dabei einfach die acht Datenleitungen.
Übersicht
Wiki
Hilfe
Suche
Einloggen
Registrieren
qemu: fatal trying to execute code outside RAM or ROM at 0x2e532074
EAX=00000000 EBX=32303032 ECX=00000000 EDX=00000000
ESI=6e614d20 EDI=6b617264 EBP666f5365 ESP=ffffff18
EIP=2e532074 EFL=00000002 [-------] CPL=0 II=0 A20=1 SMM=0 HLT=0
ES =0010 00000000 ffffffff 00cf9300
CS =0008 00000000 ffffffff 00cf9a00
SS =0010 00000000 ffffffff 00cf9300
DS =0010 00000000 ffffffff 00cf9300
FS =0000 00000000 00000000 00000000
GS =0000 00000000 00000000 00000000
LDT=0000 00000000 0000ffff 00008200
TR =0028 00103020 00000080 0000e910
GDT= 00104000 00000037
IDT= 001080c0 000007ff
CR0=60000011 CR2=00000000 CR3=00000000 CR4=00000000
DR0=00000000 DR1=00000000 DR2=00000000 DR3=00000000
DR6=ffff0ff0 DR7=00000400
CCS=0000007c CCD=00000000 CCO=LOGICL
FCW=037f FSW=0000 [ST=0] FTW=00 MXCSR=00001f80
FPR0-7 (alle gleich) = 0000000000000000 0000
XMM00-07 (alle gleich) = 00000000000000000000000000000000struct {uint16_t limit;
void* pointer;
} __attribute__((packed)) gdtp = {
.limit = GDT_ENTRIES * 8 - 1,
.pointer = gdt,
};
// GDT-Eintraege aufbauen
gdt_set_entry(0, 0, 0, 0);
gdt_set_entry(1, 0, 0xfffff, GDT_FLAG_SEGMENT | GDT_FLAG_32_BIT |
GDT_FLAG_CODESEG | GDT_FLAG_4K | GDT_FLAG_PRESENT);
gdt_set_entry(2, 0, 0xfffff, GDT_FLAG_SEGMENT | GDT_FLAG_32_BIT |
GDT_FLAG_DATASEG | GDT_FLAG_4K | GDT_FLAG_PRESENT);
gdt_set_entry(3, 0, 0xfffff, GDT_FLAG_SEGMENT | GDT_FLAG_32_BIT |
GDT_FLAG_CODESEG | GDT_FLAG_4K | GDT_FLAG_PRESENT | GDT_FLAG_RING3);
gdt_set_entry(4, 0, 0xfffff, GDT_FLAG_SEGMENT | GDT_FLAG_32_BIT |
GDT_FLAG_DATASEG | GDT_FLAG_4K | GDT_FLAG_PRESENT | GDT_FLAG_RING3);
gdt_set_entry(5, (uint32_t) tss, sizeof(tss),
GDT_FLAG_TSS | GDT_FLAG_PRESENT | GDT_FLAG_RING3);
// GDT neu laden
asm volatile("lgdt %0" : : "m" (gdtp));
// Segmentregister neu laden, damit die neuen GDT-Eintraege auch wirklich
// benutzt werden
asm volatile("mov $0x10, %ax;"
"mov %ax, %ds;"
"mov %ax, %es;"
"mov %ax, %ss;"
"ljmp $0x8, $.1;"
".1:");
// Taskregister neu laden
asm volatile("ltr %%ax" : : "a" (5 << 3));task_states[0] = init_task(stack_a, user_stack_a, task_a);
task_states[1] = init_task(stack_b, user_stack_b, task_b);; CPU-Zustand sichern
push ebp
push edi
push esi
push edx
push ecx
push ebx
push eax
; Kernel-Datensegmente laden
mov ax, 0x10
mov ds, ax
mov es, ax
; Handler aufrufen
push esp
call interrupt_handler
mov esp, eax
; User-Datensegmente laden
mov ax, 0x23
mov ds, ax
mov es, ax
; CPU-Zustand wiederherstellen
pop eax
pop ebx
pop ecx
pop edx
pop esi
pop edi
pop ebp
; Fehlercode und Interruptnummer vom Stack nehmen
add esp, 8
; Ruecksprung zum unterbrochenen Code
iret.if(r->int_no == 49)
{
// RegisterEventHandler
// eax = Funktionsnummer (momentan immer 0)
// edx = Speicheradresse des Eventhandlers
if(r->eax == 0)
{
currentEventHandler = (void*)r->edx;
}
}void (*currentEventHandler)(int message, long params);void eventHandler(int message, long params);
void _start(void)
{
asm("movl %0, %%edx;"::"r"(eventHandler));
asm("movl $0, %eax");
asm("int $49");
while(1);
}
void eventHandler(int message, long params)
{
if(message == 0x00000001)
{
char temp[2] = "";
temp[0] = params;
temp[1] = 0;
asm("mov $0x07, %edx");
asm("movl %0, %%esi;"::"r"(temp));
asm("movl $0, %eax");
asm("movl $10, %ebx");
asm("movl $5, %ecx");
asm("int $48");
}
}
#include "main.h"
int yPos = 0;
int xPos = 0;
void task_a(void)
{
while (1) {
print_string_at_pos("A", 0x02, xPos, yPos);
xPos++;
}
}
void task_b(void)
{
while (1) {
print_string_at_pos("B", 0x04, xPos, yPos);
xPos++;
}
}
static char stack_a[4096];
static char stack_b[4096];
/*
* Jeder Task braucht seinen eigenen Stack, auf dem er beliebig arbeiten kann,
* ohne dass ihm andere Tasks Dinge ueberschreiben. Ausserdem braucht ein Task
* einen Einsprungspunkt.
*/
struct cpu_state* init_task(char* stack, void* entry)
{
/*
* CPU-Zustand fuer den neuen Task festlegen
*/
struct cpu_state new_state = {
.eax = 0,
.ebx = 0,
.ecx = 0,
.edx = 0,
.esi = 0,
.edi = 0,
.ebp = 0,
//.esp = unbenutzt (kein Ring-Wechsel)
.eip = (unsigned long) entry,
/* Ring-0-Segmentregister */
.cs = 0x08,
//.ss = unbenutzt (kein Ring-Wechsel)
/* IRQs einschalten (IF = 1) */
.eflags = 0x202,
};
/*
* Den angelegten CPU-Zustand auf den Stack des Tasks kopieren, damit es am
* Ende so aussieht als waere der Task durch einen Interrupt unterbrochen
* worden. So kann man dem Interrupthandler den neuen Task unterschieben
* und er stellt einfach den neuen Prozessorzustand "wieder her".
*/
struct cpu_state* state = (void*) (stack + 4096 - sizeof(new_state));
*state = new_state;
return state;
}
static int current_task = 1;
static int num_tasks = 2;
static struct cpu_state* task_states[2];
void init_multitasking(void)
{
task_states[0] = init_task(stack_a, task_a);
task_states[1] = init_task(stack_b, task_b);
}
/*
* Gibt den Prozessorzustand des naechsten Tasks zurueck. Der aktuelle
* Prozessorzustand wird als Parameter uebergeben und gespeichert, damit er
* beim naechsten Aufruf des Tasks wiederhergestellt werden kann
*/
struct cpu_state* schedule(struct cpu_state* cpu)
{
/*
* Wenn schon ein Task laeuft, Zustand sichern. Wenn nicht, springen wir
* gerade zum ersten Mal in einen Task. Diesen Prozessorzustand brauchen
* wir spaeter nicht wieder.
*/
if (current_task >= 0) {
task_states[current_task] = cpu;
}
/*
* Naechsten Task auswaehlen. Wenn alle durch sind, geht es von vorne los
*/
if(current_task == 0)
current_task = 1;
else if(current_task == 1)
current_task = 0;
/* Prozessorzustand des neuen Tasks aktivieren */
cpu = task_states[current_task];
return cpu;
}...
irq_common_stub:
push ebp
push edi
push esi
push edx
push ecx
push ebx
push eax
; // Handler aufrufen
; // Der Rueckgabewert ist der Prozessorzustand des moeglicherweise
; // gewechselten Tasks. Wir muessen also den Stack dorthin wechseln
; // um die Register wiederherzustellen.
push esp
call irq_handler
mov esp, eax
; // CPU-Zustand wiederherstellen
pop eax
pop ebx
pop ecx
pop edx
pop esi
pop edi
pop ebp
; // Fehlercode und Interruptnummer vom Stack nehmen
add esp, 8
; // Ruecksprung zum unterbrochenen Code
iret
...