Themen

1

Lowlevel-Coding / Taskswitch

« am: 14. February 2013, 01:02 »

Hi,
kann mir vielleicht jemand erklären, wie genau der Taskswitch funktioniert?

Das hier ist ja der Code aus dem Tutorial:

Code: [Auswählen]

push %esp
call handle_interrupt
mov %eax, %esp
Danach kommt ein iret und es wird mit den richtigen Registern und dem richtigen Stack an die Adresse gesprungen, die ganz oben auf dem Stack liegt, oder? Das sollte doch .eip in der Struktur des Tasks sein... Aber .eip ist doch nicht am Anfang der Struktur, oder habe ich was falsch verstanden?

2

Lowlevel-Coding / Physische Speicherverwaltung- Bitmaps

« am: 27. January 2013, 18:55 »

Hi,
ich hab eine Frage zu den Bitmaps. Ich verstehe leider nicht, was eine Seite bedeuten soll.
Das Bitmap ist doch ein Array, bei dem ein Element für einen 4kB groß ist. Wenn ich Speicher anfordere, möchte ich doch auch 4kB, oder? Wozu gibt es dann noch die Seiten?
Tut mir Leid, dass ich so blöd frage.

3

Lowlevel-Coding / Multiboot-Informationen falsch

« am: 16. December 2012, 18:47 »

Hi,
ich versuche gerade die Multiboot-Informationen zuzugreifen, was aber nicht funktioniert.
Die Ausgabe ist angehängt.
Hier der Code:
kernel.asm

Code: [Auswählen]

[BITS 32]
FLAGS    equ 0x2
MAGIC    equ 0x1BADB002
CHECKSUM equ -(MAGIC + FLAGS)
 
align 4
MultiBootHeader:
dd MAGIC
dd FLAGS
dd CHECKSUM

[GLOBAL start]
start:
mov esp, 0x200000
[EXTERN set_multiboot_information]
push ebx
call set_multiboot_information
; ...

system.c

Code: [Auswählen]

// ...
void set_multiboot_information(unsigned int* pointer_mb_info){
global_multiboot_mb_info.mbs_flags = (unsigned int)*(pointer_mb_info+(0));
global_multiboot_mb_info.mbs_mem_lower = (unsigned int)*(pointer_mb_info+4);
global_multiboot_mb_info.mbs_mem_upper = (unsigned int)*(pointer_mb_info+2*4);
global_multiboot_mb_info.mbs_bootdevice = (unsigned int)*(pointer_mb_info+3*4);
global_multiboot_mb_info.mbs_cmdline = (unsigned int)*(pointer_mb_info+4*4);
global_multiboot_mb_info.mbs_mods_count = (unsigned int)*(pointer_mb_info+5*4);
global_multiboot_mb_info.mbs_mods_addr = (unsigned int)*(pointer_mb_info+6*4);
global_multiboot_mb_info.mbs_syms[0] = (unsigned int)*(pointer_mb_info+7*4);
global_multiboot_mb_info.mbs_syms[1] = (unsigned int)*(pointer_mb_info+8*4);
global_multiboot_mb_info.mbs_syms[2] = (unsigned int)*(pointer_mb_info+9*4);
global_multiboot_mb_info.mbs_syms[3] = (unsigned int)*(pointer_mb_info+10*4);
global_multiboot_mb_info.mbs_mmap_length = (unsigned int)*(pointer_mb_info+11*4);
global_multiboot_mb_info.mbs_mmap_addr = (unsigned int)*(pointer_mb_info+12*4);
global_multiboot_mb_info.mbs_drives_length = (unsigned int)*(pointer_mb_info+13*4);
global_multiboot_mb_info.mbs_drives_addr = (unsigned int)*(pointer_mb_info+14*4);
global_multiboot_mb_info.mbs_config_table = (unsigned int)*(pointer_mb_info+15*4);
global_multiboot_mb_info.mbs_boot_loader_name = (unsigned int)*(pointer_mb_info+16*4);
global_multiboot_mb_info.mbs_apm_table = (unsigned int)*(pointer_mb_info+17*4);
global_multiboot_mb_info.mbs_vbe_control_info = (unsigned int)*(pointer_mb_info+18*4);
global_multiboot_mb_info.mbs_vbe_mode_info = (unsigned int)*(pointer_mb_info+19*4);
global_multiboot_mb_info.mbs_vbe_mode = (unsigned short)*(pointer_mb_info+20*4);
global_multiboot_mb_info.mbs_vbe_interface_seg = (unsigned short)*(pointer_mb_info+20*4+2);
global_multiboot_mb_info.mbs_vbe_interface_off = (unsigned short)*(pointer_mb_info+20*4+4);
global_multiboot_mb_info.mbs_vbe_interface_len = (unsigned short)*(pointer_mb_info+20*4+6);
}
// ...

main.c

Code: [Auswählen]

int main(){
install_start();
print("mbs_flags", 0, 0xF);
print(itoa_p(global_multiboot_mb_info.mbs_flags), 40, 0xF);
print("mbs_mem_lower", 1*80, 0xF);
print(itoa_p(global_multiboot_mb_info.mbs_mem_lower), 1*80+40, 0xF);
print("mbs_mem_upper", 2*80, 0xF);
print(itoa_p(global_multiboot_mb_info.mbs_mem_upper), 2*80+40, 0xF);
print("mbs_bootdevice", 3*80, 0xF);
print(itoa_p(global_multiboot_mb_info.mbs_bootdevice), 3*80+40, 0xF);
print("mbs_cmdline", 4*80, 0xF);
print(itoa_p(global_multiboot_mb_info.mbs_cmdline), 4*80+40, 0xF);
print("mbs_mods_count", 5*80, 0xF);
print(itoa_p(global_multiboot_mb_info.mbs_mods_count), 5*80+40, 0xF);
print("mbs_mods_addr", 6*80, 0xF);
print(itoa_p(global_multiboot_mb_info.mbs_mods_addr), 6*80+40, 0xF);
print("mbs_mmap_length", 7*80, 0xF);
print(itoa_p(global_multiboot_mb_info.mbs_mmap_length), 7*80+40, 0xF);
print("mbs_mmap_addr", 8*80, 0xF);
print(itoa_p(global_multiboot_mb_info.mbs_mmap_addr), 8*80+40, 0xF);
print("mbs_drives_length", 9*80, 0xF);
print(itoa_p(global_multiboot_mb_info.mbs_drives_length), 9*80+40, 0xF);
print("mbs_drives_addr", 10*80, 0xF);
print(itoa_p(global_multiboot_mb_info.mbs_drives_addr), 10*80+40, 0xF);
print("mbs_config_table", 11*80, 0xF);
print(itoa_p(global_multiboot_mb_info.mbs_config_table), 11*80+40, 0xF);
print("mbs_boot_loader_name", 12*80, 0xF);
print(itoa_p(global_multiboot_mb_info.mbs_boot_loader_name), 12*80+40, 0xF);
print("mbs_apm_table", 13*80, 0xF);
print(itoa_p(global_multiboot_mb_info.mbs_apm_table), 13*80+40, 0xF);
print("mbs_vbe_control_info", 14*80, 0xF);
print(itoa_p(global_multiboot_mb_info.mbs_vbe_control_info), 14*80+40, 0xF);
print("mbs_vbe_mode_info", 15*80, 0xF);
print(itoa_p(global_multiboot_mb_info.mbs_vbe_mode_info), 15*80+40, 0xF);
print("mbs_vbe_mode", 16*80, 0xF);
print(itoa_p(global_multiboot_mb_info.mbs_vbe_mode), 16*80+40, 0xF);
print("mbs_vbe_interface_seg", 17*80, 0xF);
print(itoa_p(global_multiboot_mb_info.mbs_vbe_interface_seg), 17*80+40, 0xF);
print("mbs_vbe_interface_off", 18*80, 0xF);
print(itoa_p(global_multiboot_mb_info.mbs_vbe_interface_off), 18*80+40, 0xF);
print("mbs_vbe_interface_len", 19*80, 0xF);
print(itoa_p(global_multiboot_mb_info.mbs_vbe_interface_len), 19*80+40, 0xF);
while(1);
return 0;
}
Die Ausgabe ist dezimal.
Es macht einfach keinen Sinn, was da steht.

Danke schon mal.

4

Lowlevel-Coding / Über Zeiger auf nächste Variable zugreifen

« am: 16. December 2012, 14:39 »

Hi,
ich versuche gerade über den Zeiger der ersten Variable auf den Inhalt der nächsten Variable zuzugreifen:

Code: [Auswählen]

int main(){
short var1 = 10;
short var2 = 30;
long *_var2 = (&var1+1);
print(itoa((short)*_var2), 80, 0xF);
while(1);
return 0;
}
Wenn ich statt

Code: [Auswählen]

long *_var2 = (&var1+1);


Code: [Auswählen]

long *_var2 = (&var1);
schreibe, wird mir 10 ausgegeben.
So wird mir aber nicht 30 sondern 0 ausgegeben.
Weiß jemand, woran das liegt?

Danke im Voraus.


EDIT:

Code: [Auswählen]

int main(){
short var1 = 10;
short var2 = 30;
unsigned long* _var2 = (unsigned long*)(&var1-1);
print(itoa((unsigned long)*_var2-0xA0000), 80, 0xF);
print(itoa((unsigned long)&var2), 160, 0xF);
while(1);
return 0;
}
So funktioniert das aus irgendeinem Grund. Kann's mir jemand erklären?

5

Lowlevel-Coding / IDT/ISR Assembler Problem

« am: 14. July 2012, 14:45 »

Hallo,
ich wollte heute eigentlich einfach IDTs und ISRs in Assembler implementieren, habe aber ein seltsames Problem.
Hier erstmal der Code:

Code: [Auswählen]

IDT_Zeiger:
dw 256*8-1
dd IDT

IDT:
times 256*8 db 0 ; Platzhalter für 256 IDTs mit jeweils 8 Bytes

_IDT_setzen:
; ebp+8  -> Typ und Attribute
; ebp+12 -> Selektor
; ebp+16 -> Adresse der Bahandlungsfunktion
; ebp+20 -> Nummer der IDT
push ebp
mov ebp, esp
push eax
push ebx
push ecx
mov ebx, IDT ; die Adresse der IDTs in ebx speichern
mov eax, [ebp+20] ; die Nummer der IDT in eax speichern
mov cx, 8
mul cx
add ebx, eax ; ebx ist jetzt die Startadresse der IDT
mov eax, [ebp+16]
and eax, 0xFFFF
mov [ebx], word ax ; den ersten Teil der Adresse speichern
mov ax, [ebp+12]
mov [ebx+2], word ax
mov [ebx+4], byte 0
mov al, [ebp+8]
mov [ebx+5], byte al
mov eax, [ebp+16]
rol eax, 8
and eax, 0xFFFF
mov [ebx+6], word ax
pop ecx
pop eax
pop ebx
mov esp, ebp
pop ebp
ret 16

IDT_installieren:
IDT_setzen 0, ISR0, 0x08, 0x8E
lidt [IDT_Zeiger]
ret

ISR0:
Text_schreiben "Funktioniert! :)", 0, 1, 0xF
ret

und in der main.asm

Code: [Auswählen]

mov ax, 1
mov dx, 0
div dx

Es passiert nur leider nichts, also habe ich mir mal die Bochslogs angeschaut. Es gibt tatsächlich die exception 0, aber der Rest sieht nicht gut aus:

Code: [Auswählen]

03471086138d[CPU0 ] protected mode activated
03471086157d[MEM0 ] allocate_block: used_blocks=0x3 of 0x20
03471152232d[CPU0 ] exception(0x00): error_code=0000
03471152232d[CPU0 ] interrupt(): vector = 00, TYPE = 3, EXT = 1
03471152232d[CPU0 ] interrupt(): INTERRUPT TO SAME PRIVILEGE
03471152235d[CPU0 ] BxError: Encountered an unknown instruction b1=0xff (signalling #UD)
03471152235d[CPU0 ] modrm was 0xff, nnn was 7, rm was 7
03471152235i[CPU0 ] 0x00000000d20009d2>> (invalid)  : FFFF
03471152235d[CPU0 ] exception(0x06): error_code=0000
03471152235d[CPU0 ] interrupt(): vector = 06, TYPE = 3, EXT = 1
03471152235e[CPU0 ] interrupt(): gate descriptor is not valid sys seg (vector=0x06)
03471152235d[CPU0 ] exception(0x0d): error_code=0032
03471152235d[CPU0 ] interrupt(): vector = 0d, TYPE = 3, EXT = 1
03471152235e[CPU0 ] interrupt(): gate descriptor is not valid sys seg (vector=0x0d)
03471152235d[CPU0 ] exception(0x0d): error_code=006a
03471152235d[CPU0 ] exception(0x08): error_code=0000
03471152235d[CPU0 ] interrupt(): vector = 08, TYPE = 3, EXT = 1
03471152235e[CPU0 ] interrupt(): gate descriptor is not valid sys seg (vector=0x08)
03471152235d[CPU0 ] exception(0x0d): error_code=0042
03471152235i[CPU0 ] CPU is in protected mode (active)
03471152235i[CPU0 ] CS.mode = 32 bit
03471152235i[CPU0 ] SS.mode = 32 bit
03471152235i[CPU0 ] | EAX=00000001  EBX=00000000  ECX=00090002  EDX=000f0000
03471152235i[CPU0 ] | ESP=001fffef  EBP=00000000  ESI=000e93f2  EDI=0000ffac
03471152235i[CPU0 ] | IOPL=0 id vip vif ac vm RF nt of df if tf sf zf af PF cf
03471152235i[CPU0 ] | SEG sltr(index|ti|rpl)     base    limit G D
03471152235i[CPU0 ] |  CS:0008( 0001| 0|  0) 00000000 ffffffff 1 1
03471152235i[CPU0 ] |  DS:0010( 0002| 0|  0) 00000000 ffffffff 1 1
03471152235i[CPU0 ] |  SS:0010( 0002| 0|  0) 00000000 ffffffff 1 1
03471152235i[CPU0 ] |  ES:0010( 0002| 0|  0) 00000000 ffffffff 1 1
03471152235i[CPU0 ] |  FS:0000( 0000| 0|  0) 00000000 00000000 0 0
03471152235i[CPU0 ] |  GS:0000( 0000| 0|  0) 00000000 00000000 0 0
03471152235i[CPU0 ] | EIP=d20009d2 (d20009d2)
03471152235i[CPU0 ] | CR0=0x60000011 CR2=0x00000000
03471152235i[CPU0 ] | CR3=0x00000000 CR4=0x00000000
03471152235i[CPU0 ] 0x00000000d20009d2>> (invalid)  : FFFF
03471152235d[CTRL ] searching for component 'cpu' in list 'bochs'
03471152235d[CTRL ] searching for component 'reset_on_triple_fault' in list 'cpu'
03471152235p[CPU0 ] >>PANIC<< exception(): 3rd (13) exception with no resolution
03471152235e[CPU0 ] WARNING: Any simulation after this point is completely bogus !
03471152235p[CPU0 ] >>PANIC<< Entering to shutdown state still not implemented

Dann habe ich den Code in QEMU debugged und die Funktion IDT_installieren besteht nur aus Nullen. Ich weiß nicht, was am Code falsch sein sollte und kann mir auch nicht erklären, dass alles ab der Funktion IDT_installieren leer ist.
Auch kann ich mir die seltsame Position im Code nicht erklären, an der Bochs abbricht.
Danke schon mal für jede Hilfe.

EDIT:
Das Makro IDT_setzen:

Code: [Auswählen]

%macro IDT_setzen 4
push dword %1
push dword %2
push dword %3
push dword %4
call _IDT_setzen
%endmacro


6

Lowlevel-Coding / «push ax» Problem

« am: 10. July 2012, 21:22 »

Hallo, ich habe ein seltsames Assembler (NASM) Problem.

Code: [Auswählen]

main:
mov ax, 'H'
call _Test
hlt

_Test:
push ebp
mov ebp, esp
mov al, byte [ebp+8]
mov byte [0xB8000], al
mov byte [0xB8001], 0xF
mov esp, ebp
pop ebp
ret
Das führt dazu, dass Q bzw. 0x51 ausgegeben wird. Es ist egal, was ax beinhaltet...
Wird etwas direkt gepushed, funktioniert alles problemlos. Woran liegt's?

7

Lowlevel-Coding / VESA Informationen zum Grafikmodus abfragen

« am: 04. June 2012, 18:17 »

Hallo,
ich habe mir dieses großartige Tutorial (http://www.lowlevel.eu/wiki/VESA_BIOS_Extensions) angeschaut und wollte als erstes testen, ob LFB bei verschiedenen Grafikmodi vorhanden ist.
Hier der Code:

Code: [Auswählen]

mov ax, 0x4F01
mov di, 0x0
mov bx, 0x8000
mov es, bx
mov cx, 0x0118
int 0x10
mov al, byte [0x8000]
and al, 10000000b
cmp al, 0
jne LFB
je no_lFB
LFB:
mov al, 'j'
mov ah, 0x0E
int 0x10
no_lFB:
mov al, 'n'
mov ah, 0x0E
int 0x10
jmp $
Ich habe leider keine Ahnung, warum n ausgegeben wird.

8

Lowlevel-Coding / Sprung in den RealMode

« am: 19. May 2012, 20:42 »

Hi,

ich würde gerne am Anfang meines kernels (ich benutze GRUB) kurz in den RealMode zurück springen. Nur um zu testen, ob ich etwas falsch mache, habe ich den code von osdev.org kopiert. Leider tritt der Fall ein, dass ich irgendetwas falsch machen muss, da der Code Fehlermeldungen beim Linken auslöst.
Hier erstmal der Code.

Code: [Auswählen]

[bits 16]
 
idt_real:
dw 0x3ff ; 256 entries, 4b each = 1K
dd 0 ; Real Mode IVT @ 0x0000
 
savcr0:
dd 0 ; Storage location for pmode CR0.
 
Entry16:
        ; We are already in 16-bit mode here!
 
cli ; Disable interrupts.
 
; Need 16-bit Protected Mode GDT entries!
mov eax, 0x20 ; 16-bit Protected Mode data selector.
mov ds, eax
mov es, eax
mov fs, eax
mov gs, eax
 
; Disable paging (we need everything to be 1:1 mapped).
mov eax, cr0
mov [savcr0], eax ; save pmode CR0
and eax, 0x7FFFFFFe ; Disable paging bit & enable 16-bit pmode.
mov cr0, eax

jmp 0:GoRMode ; Perform Far jump to set CS.
 
GoRMode:
mov sp, 0x8000 ; pick a stack pointer.
mov ax, 0 ; Reset segment registers to 0.
mov ds, ax
mov es, ax
mov fs, ax
mov gs, ax
lidt [idt_real]
sti ; Restore interrupts -- be careful, unhandled int's will kill it.
Und hier die Fehlermeldungen:

Code: [Auswählen]

In function `Entry16':
(.text+0x2a): relocation truncated to fit: R_386_16 against `.text'
(.text+0x36): relocation truncated to fit: R_386_16 against `.text'
In function `GoRMode':
(.text+0x4b): relocation truncated to fit: R_386_16 against `.text'
Das bezieht sich auf diese Zeilen:

Code: [Auswählen]

mov [savcr0], eax   ; save pmode CR0
; ...
jmp 0:GoRMode       ; Perform Far jump to set CS.
; ...
lidt [idt_real]
Da ich erstmal davon ausgehe, dass der Code an sich korrekt ist, poste ich hier mal, wie ich das builde.

Code: [Auswählen]

building\NASM\NASM.exe -f elf -o kernel\kernel.ao kernel\kernel.asm
"building\GCC & LD\bin\i586-elf-ld.exe" -melf_i386 -T "building\GCC & LD\bin\link.ld" -o kernel\kernel.elf kernel\kernel.ao
Hier das Linkerskript:

Code: [Auswählen]

OUTPUT_FORMAT("elf32-i386")
ENTRY(start)
SECTIONS
{
  .text 0x100000 :
  {
    code = .; _code = .; __code = .;
    *(.text)
    . = ALIGN(4096);
  }
 
  .data :
  {
     data = .; _data = .; __data = .;
     *(.data)
     *(.rodata)
     . = ALIGN(4096);
  }
 
  .bss :
  {
    bss = .; _bss = .; __bss = .;
    *(.bss)
    . = ALIGN(4096);
  }
 
  end = .; _end = .; __end = .;
}
Danke im Voraus für eure Hilfe.

9

Lowlevel-Coding / Port 0x60 leeren - Tastaturtreiber

« am: 06. May 2012, 16:44 »

Hallo,
ich habe einen kleinen Tastaturtreiber mit Port 0x60 geschrieben, der auch wunderbar funktioniert. Nun ist es aber so, dass der Port die gedrückte Taste immer speichert. Ich möchte erst prüfen, ob nach einer bestimmten Stelle eine bzw. welche Taste gedrückt wurde. Dazu habe ich folgende Funktion geschrieben:

Code: [Auswählen]

void reset_keyboard() {
outb(0x60, inb(0x60)^inb(0x60));
}
Dieser Code funktioniert im Gegensatz zu

Code: [Auswählen]

void reset_keyboard() {
outb(0x60, 0);
}
zumindest in der VirtualBox, aber nicht mit echter Hardware.
Mir ist nicht ganz klar, was an der Funktion falsch ist.
Ich bedanke mich schon einmal vorträglich für jede Hilfestellung.

10

Lowlevel-Coding / Sleep() Funktion - while() Problem

« am: 04. May 2012, 13:18 »

Hallo,

ich schreibe seit einigen Wochen an meinem kleines OS. Ich bin im PMode und habe GDT, IDT, IRQ, ISRS etc. gesetzt. Jetzt wollte ich eine kleine Sleep() Funktion programmieren, bei der ich allerdings ein kleines Problem mit einer while Schleife habe:

Code: [Auswählen]

int sleep(int freq) {
if (freq!= 0 && slept != 1) {
                IRQ_install_handler(0, ret);
freq = 1193182 / freq;
                outb(0x43, 0x34);
                outb(0x40,freq & 0xFF);
                outb(0x40,freq >> 8);
}
while (slept != 1);
return 0;
}

void ret(struct regs* null) {
print("ret", 5*160+12, 0x07);
slept=1;
}
Das "ret" wird ausgegeben, allerdings bleibt hängt der PC trotzdem in der while Schleife. Es ist egal, ob die while Schleife in der sleep() oder hinter dem sleep() Aufruf ist. Ich habe leider keine Ahnung, woran das liegt.
Ich benutze GCC.
Danke vorträglich schonmal für jede Hilfe!