Themen

1

Lowlevel-Coding / A20 Line aktivieren

« am: 24. January 2006, 21:40 »

Hallo,
ich versuche schon eine Weile das A20 Gate zu aktivieren aber ich erhalte immer von Bochs den Fehler: "PUSHAD: eSP < 16"
Die Meldung das es erfolgreich aktiviert wurde wird jedoch ausgegeben.
Was ist der Fehler ?
danke

Code: [Auswählen]

;A20 Gate aktivieren
;GDT laden
;Protected Mode schalten

;jmp 0x10000:0000


enableA20:


pusha

;; Make sure interrupts are disabled
cli

;; Keep a counter so that we can make up to 5 attempts to turn
;; on A20 if necessary
mov CX, 5

.startAttempt1:
;; Wait for the controller to be ready for a command
.commandWait1:
xor AX, AX
in AL, 64h
bt AX, 1
jc .commandWait1

;; Tell the controller we want to read the current status.
;; Send the command D0h: read output port.
mov AL, 0D0h
out 64h, AL

;; Wait for the controller to be ready with a byte of data
.dataWait1:
xor AX, AX
in AL, 64h
bt AX, 0
jnc .dataWait1

;; Read the current port status from port 60h
xor AX, AX
in AL, 60h

;; Save the current value of (E)AX
push AX ; 16-BIT
;; push EAX ; 32-BIT

;; Wait for the controller to be ready for a command
.commandWait2:
in AL, 64h
bt AX, 1
jc .commandWait2

;; Tell the controller we want to write the status byte again
mov AL, 0D1h
out 64h, AL

;; Wait for the controller to be ready for the data
.commandWait3:
xor AX, AX
in AL, 64h
bt AX, 1
jc .commandWait3

;; Write the new value to port 60h.  Remember we saved the old
;; value on the stack
pop AX ; 16-BIT
;; pop EAX ; 32-BIT

;; Turn on the A20 enable bit
or AL, 00000010b
out 60h, AL

;; Finally, we will attempt to read back the A20 status
;; to ensure it was enabled.

;; Wait for the controller to be ready for a command
.commandWait4:
xor AX, AX
in AL, 64h
bt AX, 1
jc .commandWait4

;; Send the command D0h: read output port.
mov AL, 0D0h
out 64h, AL

;; Wait for the controller to be ready with a byte of data
.dataWait2:
xor AX, AX
in AL, 64h
bt AX, 0
jnc .dataWait2

;; Read the current port status from port 60h
xor AX, AX
in AL, 60h

;; Is A20 enabled?
bt AX, 1

;; Check the result.  If carry is on, A20 is on.
jc .success

;; Should we retry the operation?  If the counter value in ECX
;; has not reached zero, we will retry
loop .startAttempt1


;; Well, our initial attempt to set A20 has failed.  Now we will
;; try a backup method (which is supposedly not supported on many
;; chipsets, but which seems to be the only method that works on
;; other chipsets).


;; Keep a counter so that we can make up to 5 attempts to turn
;; on A20 if necessary
mov CX, 5

.startAttempt2:
;; Wait for the keyboard to be ready for another command
.commandWait6:
xor AX, AX
in AL, 64h
bt AX, 1
jc .commandWait6

;; Tell the controller we want to turn on A20
mov AL, 0DFh
out 64h, AL

;; Again, we will attempt to read back the A20 status
;; to ensure it was enabled.

;; Wait for the controller to be ready for a command
.commandWait7:
xor AX, AX
in AL, 64h
bt AX, 1
jc .commandWait7

;; Send the command D0h: read output port.
mov AL, 0D0h
out 64h, AL

;; Wait for the controller to be ready with a byte of data
.dataWait3:
xor AX, AX
in AL, 64h
bt AX, 0
jnc .dataWait3

;; Read the current port status from port 60h
xor AX, AX
in AL, 60h

;; Is A20 enabled?
bt AX, 1

;; Check the result.  If carry is on, A20 is on, but we might warn
;; that we had to use this alternate method
jc .warn

;; Should we retry the operation?  If the counter value in ECX
;; has not reached zero, we will retry
loop .startAttempt2


;; OK, we weren't able to set the A20 address line.  Do you want
;; to put an error message here?
jmp .fail


.warn:
;; Here you may or may not want to print a warning message about
;; the fact that we had to use the nonstandard alternate enabling
;; method

.success:
sti
popa
xor EAX, EAX
mov si, msg_a20_ok
call putstr
ret

.fail:
sti
popa
mov EAX, -1
mov si, msg_a20_fail
call putstr
ret


msg_a20_ok db "A20 Gate aktiviert",13,10,0
msg_a20_fail db "A20 Gate konnte nicht aktiviert werden",13,10,0

putstr:
lodsb
or al, al
jz short putstrd
mov ah, 0x0E
mov bx, 0x007
int 0x10
jmp putstr

putstrd:
retn



times 512-($-$$) db 0

2

Lowlevel-Coding / Bochs mit bestimmten Adressen

« am: 27. December 2005, 21:59 »

Hallo,
folgendes Problem, ich habe einen Bootloader von dem man verschiedene Unterprogramme aufrufen kann, mit meinem makefile kann ich sie ganz einfach auf Diskette schreiben lassen und alles ist wunderbar, an die bestimmten adressen wird mit partycopy gschrieben, jetzt meine frage, wie mache ich das mit bochs, denn jedes mal wenn ich dort probiere ein unterprogramm mit seinem namen aufzurufen dann sagt mein bootloader "File nciht gefunden", ist auch klar, weil die unterprogis nicht an der bestimmten adresse deswegen wollte ich wissen wie ich das unter bochs realisiere ?
hier mein makefile damit ihr euch etwas darunter vorstellen könnt was ich meine.

Code: [Auswählen]


nasm os.asm
nasm files.asm
nasm hello.asm
nasm ask.asm
nasm ls.asm

partcopy os 0 200 -f0
partcopy files 0 200 -f0 200
partcopy hello 0 200 -f0 400
partcopy ask 0 200 -f0 600
partcopy ls 0 200 -f0 800


3

Lowlevel-Coding / Eingabe im Real Mode

« am: 27. December 2005, 16:18 »

Hallo,
wenn ich im Real Mode jetzt einen Buchstaben einlese wo wird der gespeichert.
Ich habe folgendes Problem, ich möchte das wenn ein "r" eingeben wird der computer rebootet und wenn ein "n" eingegeben wird das er "hallo" ausgibt.
Ich verwende folgenden Code zum einlesen eines Buchstaben:

Code: [Auswählen]


readchar:
mov ah, 0
int 0x16

Wo wird der nun gespeichert damit ich mit:

Code: [Auswählen]

cmp buchstabenadresse, 'r'
ermitteln kann ob es übereinstimmt.

Danke

4

Lowlevel-Coding / Invalid Operand

« am: 24. December 2005, 22:46 »

Hallo,
wenn ich folgende Zeile compilire erhalte ich immer den Fehler "invalid operands to binary".
Wie kann das sein, der wird doch wohl dividieren können ?

Code: [Auswählen]

 case '\n':
  vidmem = (vidmem/160)*160 + 160;
  break;

5

Lowlevel-Coding / Ausgabe in C erfolgt nicht

« am: 13. December 2005, 22:12 »

Hallo,
Ich bin nun endlich in C, glaube ich zumindest und habe gleich ein Problem mit der Ausgabe eines Textes, ich glaube das er den C Kernel mit seinen Anhängseln lädt weil wenn ich zum Beispiel die Textausgabe auskommentiere in der main.c macht er gar nichts, oder wenn ich alles an lasse dann zeigt er in der linken oberen Ecke einen Querstrich an, wiso gibt er dort nicht meinen gewollten Text aus, ich habe mal meinen gesamten code angehängt vielleicht kann mir jemand helfen wäre wirklich wichtig.
Hier noch eine kleine Erklärung:
meine bootloader.bin lädt meine kernel.bin, meine kernel.bin wächselt in den Protected Mode und springt dann zu meinem kernel2.bin der aus den gelinkten *.o files besteht (kernel_to_c.asm, main.c, video.c, ports.c)
Danke

bootloader.bin:

Code: [Auswählen]

org 0x7C00

start:

cli
mov ax, 0x9000
mov ss, ax
mov sp, 0
sti

mov [bootdrv], dl

call kernel

mov ax, 0x1000
mov es, ax
mov ds, ax
push ax
mov ax,0
push ax
retf

bootdrv db 0
loadmsg db "Loading...",13,10,0

putstr:
lodsb
or al, al
jz short putstrd

mov ah, 0x0E
mov bx,0x0007
int 0x10
jmp putstr
putstrd:
retn

kernel:

push ds
mov ax, 0
mov dl, [bootdrv]
int 13h
pop ds
jc kernel

load:
mov ax,0x1000
mov es, ax
mov bx,0

mov ah, 2
mov al, 5
mov cx, 2
mov dx, 0
int 13h
jc load
mov si, loadmsg
call putstr
retn

times 512-($-$$)-2 db 0
dw 0AA55h



kernel.bin:

Code: [Auswählen]

org 0x10000
[BITS 16]       ; We need 16-bit intructions for Real mode

        cli                     ; Disable interrupts, we want to be alone

        mov ax, 0x1000
        mov ds, ax              ; Set DS-register to 0 - used by lgdt

        lgdt [gdt_desc]         ; Load the GDT descriptor

        mov eax, cr0            ; Copy the contents of CR0 into EAX
        or eax, 1               ; Set bit 0
        mov cr0, eax            ; Copy the contents of EAX into CR0

        jmp dword 08h:clear_pipe      ; Jump to code segment, offset clear_pipe


[BITS 32]                       ; We now need 32-bit instructions

clear_pipe:
        mov ax, 10h             ; Save data segment identifyer
        mov ds, ax              ; Move a valid data segment into the data segment register
        mov ss, ax              ; Move a valid data segment into the stack segment register
        mov esp, 090000h        ; Move the stack pointer to 090000h

        ;mov byte [ds:0B8000h], 'X'      ; Move the ASCII-code of 'P' into first video memory
        ;mov byte [ds:0B8001h], 1Bh      ; Assign a color code


jmp 0x10095

;hang:
 ;       jmp hang                ; Loop, self-jump


gdt:                    ; Address for the GDT

gdt_null:               ; Null Segment
        dd 0
        dd 0

gdt_code:               ; Code segment, read/execute, nonconforming
        dw 0FFFFh
        dw 0
        db 0
        db 10011010b
        db 11001111b
        db 0

gdt_data:               ; Data segment, read/write, expand down
        dw 0FFFFh
        dw 0
        db 0
        db 10010010b
        db 11001111b
        db 0

gdt_end:                ; Used to calculate the size of the GDT



gdt_desc:                       ; The GDT descriptor
        dw gdt_end - gdt - 1    ; Limit (size)
        dd gdt                  ; Address of the GDT



kernel_to_c.asm:

Code: [Auswählen]


[BITS 32]

extern _main  
global start  

start:
 call _main  

Stop:
 jmp Stop


main.c:

Code: [Auswählen]

const char *tutorial3;

int main()
{

  clrscr();
  print(tutorial3);
  for(;;);
}

const char *tutorial3 = "Hallo, Willkommen in C";


video.c:

Code: [Auswählen]

void clrscr()
{
  unsigned char *vidmem = (unsigned char *)0xB8000;
  const long size = 80*25;
  long loop;

  // Clear visible video memory
  for (loop=0; loop<size; loop++) {
    *vidmem++ = 0;
    *vidmem++ = 0xF;
  }

  // Set cursor position to 0,0
  out(0x3D4, 14);
  out(0x3D5, 0);
  out(0x3D4, 15);
  out(0x3D5, 0);
}

void print(const char *_message)
{
  unsigned short offset;
  unsigned long i;
  unsigned char *vidmem = (unsigned char *)0xB8000;

  // Read cursor position
  out(0x3D4, 14);
  offset = in(0x3D5) << 8;
  out(0x3D4, 15);
  offset |= in(0x3D5);

  // Start at writing at cursor position
  vidmem += offset*2;

  // Continue until we reach null character
  i = 0;
  while (_message[i] != 0) {
    *vidmem = _message[i++];
vidmem += 2;
  }

  // Set new cursor position
  offset += i;
  out(0x3D5, (unsigned char)(offset));
  out(0x3D4, 14);
  out(0x3D5, (unsigned char)(offset >> 8));
}



ports.c:

Code: [Auswählen]

unsigned char in(unsigned short _port)
{
  // "=a" (result) means: put AL register in variable result when finished
  // "d" (_port) means: load EDX with _port
  unsigned char result;
  __asm__  ("in %%dx, %%al" : "=a" (result) : "d" (_port));
  return result;
}

void out(unsigned short _port, unsigned char _data)
{
  // "a" (_data) means: load EAX with _data
  // "d" (_port) means: load EDX with _port
  __asm__ ("out %%al, %%dx" : :"a" (_data), "d" (_port));
}



makefile2.bat mit den link anweisungen:

Code: [Auswählen]

nasm -f aout -o kernel2.o kernel.asm

gcc -ffreestanding -c main.c -o main.o

gcc -c video.c -o video.o

gcc -c ports.c -o ports.o

ld -e _main -Ttext 0x10095 -o kernel.o kernel2.o main.o video.o ports.o

objcopy -R .note -R .comment -S -O binary kernel.o kernel2.bin

pause

6

Lowlevel-Coding / gcc Fehler

« am: 13. December 2005, 20:32 »

Hallo,
wenn ich mit meinem makefile compile erhalte ich folgenden Fehler und erstellt mir keine kernel.bin , wiso ?
Der Code funktioniert einwandfrei an dem kanns nicht liegen.
danke

Fehler:
http://hittn.ssm-tec.at/error.jpg

Makefile:

Code: [Auswählen]



nasm -f aout -o start.o start.asm


gcc -Wall -O -fstrength-reduce -fomit-frame-pointer -finline-functions -nostdinc -fno-builtin -I./include -c -o main.o main.c

gcc -Wall -O -fstrength-reduce -fomit-frame-pointer -finline-functions -nostdinc -fno-builtin -I./include -c -o scrn.o scrn.c

gcc -Wall -O -fstrength-reduce -fomit-frame-pointer -finline-functions -nostdinc -fno-builtin -I./include -c -o gdt.o gdt.c

gcc -Wall -O -fstrength-reduce -fomit-frame-pointer -finline-functions -nostdinc -fno-builtin -I./include -c -o idt.o idt.c

gcc -Wall -O -fstrength-reduce -fomit-frame-pointer -finline-functions -nostdinc -fno-builtin -I./include -c -o isrs.o isrs.c

gcc -Wall -O -fstrength-reduce -fomit-frame-pointer -finline-functions -nostdinc -fno-builtin -I./include -c -o irq.o irq.c

gcc -Wall -O -fstrength-reduce -fomit-frame-pointer -finline-functions -nostdinc -fno-builtin -I./include -c -o timer.o timer.c

gcc -Wall -O -fstrength-reduce -fomit-frame-pointer -finline-functions -nostdinc -fno-builtin -I./include -c -o kb.o kb.c


ld -T link.ld -o kernel.bin start.o main.o scrn.o gdt.o idt.o isrs.o irq.o timer.o kb.o

del *.o

echo Done!
pause

7

Lowlevel-Coding / Loader macht nicht weiter...

« am: 11. December 2005, 20:29 »

Hallo,
folgendes großes Problem beschäftigt mich nun schon seit mehreren Tagen.
Ich habe meine Bootloader.bin, diese sollte die Dateien kernel.bin und ckernel.bin in den Speicher schreiben damit ich diese später mit jmp erreichen kann, dass macht der auch noch bis zur kernel.bin und gibt dort noch seinen Text aus doch gleich danach wo der Befehl "jmp 08h:01000h" oder auch "jmp 0x1000" steht bricht er ab, also er resetet, ich weiß nicht wiso, er müsste doch eigentlich zur ckernel.bin springen und den code dort ausführen doch das macht er nicht. Ich habe euch mal meine bootloader.bin und meine kernel.bin sowie mein makefile angehängt.
Der ckernel mit seinen zugehörigen includes funktioniert, habe ich bereits getestet doch mit meinem loader und meinem kernel gibts probleme, wenn mir jemand helfen könnte und mir den code abändern könnte wäre ich sehr dankbar.

bootloader.bin:

Code: [Auswählen]


start:

cli
mov ax, 0x9000
mov ss, ax
mov sp, 0
sti

mov [bootdrv], dl

call kernel

mov ax, 0x1000
mov es, ax
mov ds, ax
push ax
mov ax,0
push ax
retf

bootdrv db 0
loadmsg db "Loading...",13,10,0

putstr:
lodsb
or al, al
jz short putstrd

mov ah, 0x0E
mov bx,0x0007
int 0x10
jmp putstr
putstrd:
retn

kernel:

push ds
mov ax, 0
mov dl, [bootdrv]
int 13h
pop ds
jc kernel

load:
mov ax,0x1000
mov es, ax
mov bx,0

mov ah, 2
mov al, 5
mov cx, 2
mov dx, 0
int 13h
jc load
mov si, loadmsg
call putstr
retn

times 512-($-$$)-2 db 0
dw 0AA55h

kernel.bin

Code: [Auswählen]

org 0x10000
[BITS 16]       ; We need 16-bit intructions for Real mode

        cli                     ; Disable interrupts, we want to be alone

        mov ax, 0x1000
        mov ds, ax              ; Set DS-register to 0 - used by lgdt

        lgdt [gdt_desc]         ; Load the GDT descriptor

        mov eax, cr0            ; Copy the contents of CR0 into EAX
        or eax, 1               ; Set bit 0
        mov cr0, eax            ; Copy the contents of EAX into CR0

        jmp dword 08h:clear_pipe      ; Jump to code segment, offset clear_pipe


[BITS 32]                       ; We now need 32-bit instructions

clear_pipe:
        mov ax, 10h             ; Save data segment identifyer
        mov ds, ax              ; Move a valid data segment into the data segment register
        mov ss, ax              ; Move a valid data segment into the stack segment register
        mov esp, 090000h        ; Move the stack pointer to 090000h

        mov byte [ds:0B8000h], 'H'      ; Move the ASCII-code of 'P' into first video memory
        mov byte [ds:0B8001h], 1Bh      ; Assign a color code
mov byte [ds:0B8002h], 'a'
mov byte [ds:0b8003h], 1Bh
mov byte [ds:0B8004h], 'l'
mov byte [ds:0b8005h], 1Bh
mov byte [ds:0B8006h], 'l'
mov byte [ds:0b8007h], 1Bh
mov byte [ds:0B8008h], 'o'
mov byte [ds:0b8009h], 1Bh

jmp 08h:01000h   ; Der oben angesprochene jmp

;hang:
;jmp hang


gdt:                    ; Address for the GDT

gdt_null:               ; Null Segment
        dd 0
        dd 0

gdt_code:               ; Code segment, read/execute, nonconforming
        dw 0FFFFh
        dw 0
        db 0
        db 10011010b
        db 11001111b
        db 0

gdt_data:               ; Data segment, read/write, expand down
        dw 0FFFFh
        dw 0
        db 0
        db 10010010b
        db 11001111b
        db 0

gdt_end:                ; Used to calculate the size of the GDT



gdt_desc:                       ; The GDT descriptor
        dw gdt_end - gdt - 1    ; Limit (size)
        dd gdt                  ; Address of the GDT


make.bat

Code: [Auswählen]

@echo off
nasm -f bin bootloader.asm -o bootloader.bin
nasm -f bin kernel.asm -o kernel.bin

gcc -ffreestanding -c main.c -o main.o
gcc -c video.c -o video.o
gcc -c ports.c -o ports.o

ld -e _main -Ttext 0x1000 -o kernel.o main.o video.o ports.o

ld -i -e _main -Ttext 0x1000 -o kernel.o main.o video.o ports.o
objcopy -R .note -R .comment -S -O binary kernel.o ckernel.bin

copy bootloader.bin+kernel.bin+ckernel.bin os.img


Edit:
wenns jemanden hilft hier noch der ckernel (ohne seine includes):

Code: [Auswählen]

const char *text1;

void main()
{
  clrscr();
  print(text1);

  for(;;);
}

const char *text1 = "Hallo, Willkommen in C";


8

Lowlevel-Coding / Fehler bei Textausgabe durch Bochs...

« am: 09. December 2005, 15:01 »

Hallo,
ich habe mal so herum probiert und lies durch einen ganz simplen Kernel Text ausgebenund jetzt kommts, manche Texte kann er ausgeben und manche nicht, da meldet Bochs den Fehler "IRET: top 6 bytes of stack not within stack limits", dies wird jedoch nur ausgegeben bei dem Text "Hallo mein Name ist Computer", wenn ich jetzt den Text "Welcome to my OS" ausgeben lasse funktionierts wieder    
Oder bei "Hello how was your day, my day as a computer is always the same, very boring" funktionierts auch wieder wobei es bei "Hallo ich bin die Nummer eins" wieder nicht geht ??
Das verstehe ich nicht ganz, weiß einer von euch weiter ?

danke

9

Lowlevel-Coding / Zu anderen Dateien springen !?

« am: 07. December 2005, 12:45 »

Hallo,
ich habe wieder einmal ein problem.
Ich habe einen bootloader den ich ja bereits mehrmals gepostet habe und ich möchte nun das dieser bootloader meine kernel1.bin lädt (macht er auch noch) und von dieser kernel1.bin möchte nun weiter zu einer weiteren kernel Datei, aber wie geht das, wahrscheinlich mit einem jmp Befehl ?
Der Bootloader müsste doch am Anfang alle Dateien irgendwo in den Speicher laden oder, jetzt würde ich gerne wissen wie ich eine weitere Datei in Speicher lade (mit der bootloader.bin glaube ich mal) und dann dort hin springen (von der kernel1.bin aus) kann ?
Für etwas code wäre ich sehr dankbar ?
danke

10

Lowlevel-Coding / Rechner neu start, Fehler im Kernel

« am: 06. December 2005, 19:57 »

Hallo,
Ich habe wie immer meinen Bootloader und meinen Kernel, ich habe nur meinen Kernel ein bisschen umgestaltet und nun folgendes Problem, jedes mal wenn ich meine bootloader.bin und kernel.bin zusammen auf .img kopiere und dann auf die Diskette schreibe und den Rechner neu starte dann liest er kurz von der Diskette und startet aber sofort neu, da muss im Kernel irgendwo ein Fehler sein, ich bitte um hilfe.

bootloader.bin:

Code: [Auswählen]

org 0x7C00

start:

cli
mov ax, 0x9000
mov ss, ax
mov sp, 0
sti

mov [bootdrv], dl

call kernel

mov ax, 0x1000
mov es, ax
mov ds, ax
push ax
mov ax,0
push ax
retf

bootdrv db 0
loadmsg db "Loading...",13,10,0

putstr:
lodsb
or al, al
jz short putstrd

mov ah, 0x0E
mov bx,0x0007
int 0x10
jmp putstr
putstrd:
retn

kernel:

push ds
mov ax, 0
mov dl, [bootdrv]
int 13h
pop ds
jc kernel

load:
mov ax,0x1000
mov es, ax
mov bx,0

mov ah, 2
mov al, 5
mov cx, 2
mov dx, 0
int 13h
jc load
mov si, loadmsg
call putstr
retn

times 512-($-$$)-2 db 0
dw 0AA55h

Kernel.bin:

Code: [Auswählen]

[BITS 16]       ; We need 16-bit intructions for Real mode

        cli                     ; Disable interrupts, we want to be alone

        xor ax, ax
        mov ds, ax              ; Set DS-register to 0 - used by lgdt

        lgdt [gdt_desc]         ; Load the GDT descriptor

        mov eax, cr0            ; Copy the contents of CR0 into EAX
        or eax, 1               ; Set bit 0
        mov cr0, eax            ; Copy the contents of EAX into CR0

        jmp 08h:clear_pipe      ; Jump to code segment, offset clear_pipe


[BITS 32]                       ; We now need 32-bit instructions

clear_pipe:
        mov ax, 10h             ; Save data segment identifyer
        mov ds, ax              ; Move a valid data segment into the data segment register
        mov ss, ax              ; Move a valid data segment into the stack segment register
        mov esp, 090000h        ; Move the stack pointer to 090000h

        mov byte [ds:0B8000h], 'X'      ; Move the ASCII-code of 'P' into first video memory
        mov byte [ds:0B8001h], 1Bh      ; Assign a color code

hang:
        jmp hang                ; Loop, self-jump


gdt:                    ; Address for the GDT

gdt_null:               ; Null Segment
        dd 0
        dd 0

gdt_code:               ; Code segment, read/execute, nonconforming
        dw 0FFFFh
        dw 0
        db 0
        db 10011010b
        db 11001111b
        db 0

gdt_data:               ; Data segment, read/write, expand down
        dw 0FFFFh
        dw 0
        db 0
        db 10010010b
        db 11001111b
        db 0

gdt_end:                ; Used to calculate the size of the GDT



gdt_desc:                       ; The GDT descriptor
        dw gdt_end - gdt - 1    ; Limit (size)
        dd gdt                  ; Address of the GDT


11

Lowlevel-Coding / C Übergang

« am: 01. December 2005, 22:03 »

Hallo,
wenn ich nun in C weiter schreiben möchte, wo bzw. wie müsste ich hier einen call machen ?
Und wie muss ich das dann assemblieren oder verbinden wenn ich nun eine bootloader.bin eine kernel.bin und eine kernelc.bin habe ?

danke schon mal


Hier der Code wo ich diesen call zu c machen will:

Code: [Auswählen]

mov ax, 1000h
mov ds, ax
mov es, ax

push dx ;wieso dx? meinst du ax?
push es
xor ax, ax
mov es, ax
cli
mov word [es:0x21*4], _int0x21 ; Pointer auf den Handler
mov [es:0x21*4+2], cs ; Pointer auf CS
sti
pop es
pop dx

start:
mov si, msg
mov al, 0x01
int 0x21

call getkey
jmp reboot

msg db "Interrupt ausgeführt",13,10,0

_int0x21:
_int0x21_ser0x01: ; funktion 0x01
cmp al, 0x01 ; funktion 0x01 angefragt?
jne _int0x21_end ; nächste Routine checken

_int0x21_ser0x01_start:
lodsb ; nächstes Byte laden
or al, al ; 0-Byte?
jz _int0x21_ser0x01_end
mov ah, 0x0E ; BIOS Teletype
mov bh, 0x00 ; Page 0
mov bl, 0x07 ; Text-Attribute
int 0x10 ; BIOS-Call
jmp _int0x21_ser0x01_start
_int0x21_ser0x01_end:
jmp _int0x21_end

_int0x21_end:
iret


getkey:
mov ah, 0
int 016h
ret

reboot:
db 0EAh
dw 0000h
dw 0FFFFh


12

Lowlevel-Coding / Keine Ausgabe

« am: 01. December 2005, 12:58 »

Hallo,

Ich habe mir eure Tutorials durch gelesen und auch probiert, der Bootloader und der Kernel nach der ersten Ausgabe von LowLevel haben noch funktioniert,
doch als ich die Interrupt Routine aus LowLevel3 eingebaut habe zeigt er mir auf dem Monitor nur die Texte an die mit putstr ausgegeben werden, diejenigen die ich mit dem interrupt ausgebe nicht ?
Ich habe den Code des Bootloaders und des Kernels angefügt.

Danke im voraus

mfg syce

Kernel:

Code: [Auswählen]

mov ax, 1000h
mov ds, ax
mov es, ax

start:
mov si, msg
mov al, 0x01
int 0x21

mov si, msg_boot
call putstr

call getkey
jmp reboot

msg db "Interrupt ausgeführt",13,10,0
msg_boot db "Ausgabe mit putstr, Taste drücken um neu zu starten",13,10,0


_int0x21:
 _int0x21_ser0x01:       ; funktion 0x01
 cmp al, 0x01            ; funktion 0x01 angefragt?
 jne _int0x21_end        ; nächste Routine checken
   
 _int0x21_ser0x01_start:
 lodsb                   ; nächstes Byte laden
 or  al, al              ; 0-Byte?
 jz  _int0x21_ser0x01_end
 mov ah, 0x0E            ; BIOS Teletype
 mov bh, 0x00            ; Page 0
 mov bl, 0x07            ; Text-Attribute
 int 0x10                ; BIOS-Call
 jmp _int0x21_ser0x01_start
 _int0x21_ser0x01_end:
 jmp _int0x21_end
 
 _int0x21_end:
 iret  


push dx
push es
xor ax, ax
mov es, ax
cli
mov word [es:0x21*4], _int0x21  ; Pointer auf den Handler
mov [es:0x21*4+2], cs           ; Pointer auf CS
sti
pop es
pop dx


putstr:
lodsb
or al, al
jz short putstrd
mov ah, 0x0E
mov bx, 0x007
int 0x10
jmp putstr

putstrd:
retn

getkey:
mov ah, 0
int 016h
ret

reboot:
db 0EAh
dw 0000h
dw 0FFFFh

Bootloader:

Code: [Auswählen]

org 0x7C00

start:

cli
mov ax, 0x9000
mov ss, ax
mov sp, 0
sti

mov [bootdrv], dl

call kernel

mov ax, 0x1000
mov es, ax
mov ds, ax
push ax
mov ax,0
push ax
retf

bootdrv db 0
loadmsg db "Loading...",13,10,0

putstr:
lodsb
or al, al
jz short putstrd

mov ah, 0x0E
mov bx,0x0007
int 0x10
jmp putstr
putstrd:
retn

kernel:

push ds
mov ax, 0
mov dl, [bootdrv]
int 13h
pop ds
jc kernel

load:
mov ax,0x1000
mov es, ax
mov bx,0

mov ah, 2
mov al, 5
mov cx, 2
mov dx, 0
int 13h
jc load
mov si, loadmsg
call putstr
retn

times 512-($-$$)-2 db 0
dw 0AA55h