Nachrichten

201

Offtopic / Windows XP Professional

« am: 14. April 2006, 11:30 »

nicht böse gemeint, aber das hört sich schon ziemlich komisch an
wenn dein Key nicht genommen wird, hat das bestimmt irgendeinen Grund
und wenn du den legal erworben hast, würdest du dich beschweren
ich glaube nicht, dass das wirklich so ist wie du es gerade erzählst

du hast einfach keinen Key und brauchst nun einen, da du XP von der CD von jemand anders instaliert hast, oder auf einem 2. Pc installieren willst, ohne dafür zu bezahlen

aber du dachtest nicht wirklich, dass dir deine Geschichte jemand abnimmt oder?

202

Lowlevel-Coding / Bochs von realer Diskette booten lassen

« am: 13. April 2006, 23:44 »

a: und b: hat bei mir nicht funktioniert, hab aber auch auto benutzt, das wird wahrscheinlich der Fehler gewesen sein
danke

203

Lowlevel-Coding / Disketten Lesefehler

« am: 13. April 2006, 18:59 »

Ich hab ein Problem beim Laden von Sektoren von einer Diskette:
ich bekomme immer einen Lesefehler zurück:

0x10

hab dann nachgeguckt was der bedeutet:

Lesefehler

klasse, das bringt mich natürlich weiter

in Bochs funktioniert das ganze übrigens,
ich benutzt int 0x13 zum lesen, die macht ja das meiste alleine
(Lesekopf positionieren und was es da alles gibt)

deswegen kann ich mir nicht vorstellen was den Lesefehler verursacht haben soll, ein Sektor ist auch nicht beschädigt, das hätte ich beim beschreiben der Diskette gemerkt

also weis jemand was genau "Lesefehler" bedeutet und woran das liegen kann?

EDIT:
ich hab auch schon versucht statt neu zu starten einfach nochmal zu versuchen den Sektor einzulesen, das funktioniert allerdings auch nicht, dann kommt bei jedem Versuch der "Lesefehler"

EDIT2:
ich hab jetzt versucht das Diskettenlaufwerk zu resetten bevor ich lese
(auch mit int 0x13)
das Ergebnis ist aber genau das Gleiche
morgen versuch ichs noch auf nem anderen Pc, aber auch wenn es da klappt hilft mir das nicht wirklich weiter
naja, mal schaun...

204

Lowlevel-Coding / Bochs von realer Diskette booten lassen

« am: 13. April 2006, 14:00 »

weis jemand wie man bochs dazu bringen kann von einer realen Diskette zu booten?
ich hab keine Lust immer erst ein Image von der Diskette zu machen,
leider kom ich nich drauf wie das gehen soll, in der Anleitung steht auch nichts

geht das etwa gar nicht?

205

Lowlevel-Coding / in boch gehts, in Wirklichkeit nicht (allgemein)

« am: 10. April 2006, 13:38 »

Ich möchte mal wissen woran es allgemein liegen kann, wenn ein Programm in Bochs läuft, auf einem realen Computer aber nicht
also wo genau sind da die Unterschiede?

das einzige was ich mal gehört habe, ist dass das mit dem A20 Gate und mit dem Diskettenlaufwerk zusammenhängen kann, aber mehr auch nicht

206

Lowlevel-Coding / int 13h - 0x55 Sektoren lesen

« am: 05. April 2006, 17:44 »

85 sektoren (und es werden noch mehr) einzeln laden? dauert das nicht ein bischen lang? würde ich auf dauer nicht so machen. naja, ist ja deine entscheidung.

und wenn ich das ganze schneller haben will, muss ich das Diskettenlaufwerk sowiso direkt ansprechen, ohne BIOS-Interrupts

 

207

Lowlevel-Coding / int 13h - 0x55 Sektoren lesen

« am: 05. April 2006, 15:14 »

ah, das ist eine gute Idee, das mach ich,
dann muss man nie über irgendwelche Grenzen, da alles einzeln gelesen wird
und wenn ich das ganze schneller haben will, muss ich das Diskettenlaufwerk sowiso direkt ansprechen, ohne BIOS-Interrupts

der Kernel ist nur so groß, weil ich C benutzt habe, erstmal habe ich meine 3d-Engine eingelinkt (mein VGA-Treiber funktioniert schon einigermaßen, ist auch nicht wirklich schwer) und mit der dann auch gleich die komplette Fließkomma Emulation
eigentlich bin ich noch ziemlich am Anfang mit allem

208

Lowlevel-Coding / int 13h - 0x55 Sektoren lesen

« am: 03. April 2006, 19:07 »

Mein Kernel ist nun schon so weit das er größer als 2 Sektoren geworden ist
(ganze 0x55 Sektoren *stolz*)

deswegen muss ich über Zylinder Grenzen hinweglesen, dazu hab ich ein paar Fragen:

1. kann int 0x13 über Zylinder und über Kopf Grenzen lesen?
oder müsst ich z.B. den letzten Sektor eines Zylinders und den 1. des nächsten getrennt lesen?

2. der erste Sektor einer Diskette ist ja
Kopf 0 Zylinder/Spur 0 Sektor 1

aber welcher ist der 1. des 2. Zylinders?
Kopf 0 Zylinder/Spur 1 Sektor 0
oder
Kopf 0 Zylinder/Spur 1 Sektor 1

und das gleiche dann noch bei den Köpfen:

ist der 1. Sektor des 2. Kopfes
Kopf 1 Zylinder/Spur 0 Sektor 0
oder
Kopf 1 Zylinder/Spur 0 Sektor 1

209

Lowlevel-Coding / Code anfang richtig setzen

« am: 31. March 2006, 17:59 »

nein, so einfach geht es eben nicht, das ist doch das Problem an der Sache

ich hab aber in nem neuen Thema den Quellcode gespostet, wenn du ihn ausprobierst wirst du sehen das es nicht geht

210

Lowlevel-Coding / C Kernel: andere Adresse

« am: 31. March 2006, 15:31 »

eigentlich schon, aber erstmal ist das so übersichtlicher
und außerdem ist es jetzt nicht mehr das gleiche Problem wie vorher
die gesuchte org Funktion hab ich nämlich gefunden
leider half die eben auch nicht weiter und es geht jetzt nicht mehr darum eine zu finden

also im Endeffekt geht es um etwas anderes => neues Thema

211

Lowlevel-Coding / C Kernel: andere Adresse

« am: 31. March 2006, 15:15 »

Ich will nun in meinen Assemblerkernel C mit einbauen, indem ich das ganze einfach zusammenlinke, damit ich in C Funktionen aus de Assemblerteil aufrufen kann und umgekehrt

allerdings stürzt das Programm ab, ich denke ich weiß auch warum:
ich sage ld das der Code am Offset 0 anfängt im code stell ich dann noch ein dass er im Segment 1000 ist
also im endeffekt 1000:0000

das Problem ist nun, dass der C Teil aber erst 512 bytes hinter dem Assembler Teil anfängt, somit sind im C Teil alle Adressen falsch
wie kann ich die nun richtig machen?

für den C Teil müsste ich ld ja 200h als Startoffset übergeben der Assembler Teil braucht aber 0, ich muss das ganze aber zusammenlinken

ld Konfigurationsdatei:

Code: [Auswählen]

OUTPUT_FORMAT("binary")
INPUT(askernel.o ckernel.o)
ENTRY(start)
SECTIONS
{
  .text 0x0 : {
    code = .; _code = .; __code = .;
    *(.text)
    . = ALIGN(1);
  }
  .data  : {
    data = .; _data = .; __data = .;
    *(.data)
    . = ALIGN(1);
  }
  .bss  :
  {
    bss = .; _bss = .; __bss = .;
    *(.bss)
    . = ALIGN(1);
  }
  end = .; _end = .; __end = .;
}

C Teil:

Code: [Auswählen]

__asm__ (".code16gcc\n");
int _main()
{
  return(0);
}

Assembler Teil:

Code: [Auswählen]

[BITS 16]

extern __main
global start
start:

cli
mov ax, cs
mov ds, ax
mov es, ax
sti

mov si, m_started
call text
mov si, absatz
call text
mov si, m_c
call text
mov si, absatz
call text
call __main

ende:
jmp ende
text:
lodsb
cmp al, 00h
je text_e
mov ah, 0eh
mov bx, 0007h
int 10h
jmp text
text_e:
ret
m_started db "kernel gestartet", 13, 10, 0
m_c db "ckernel wird gestartet...", 13, 10, 0
absatz db 13, 10, 0
times 512-($-$$) db 0

EDIT:

die Bochs Fehlermeldung ist übrigens "prefetch: RIP > CS.limit"
geb ich in der ld Konfigurationsdatei statt 0 200 ein, funktioniert wie erwartet der Assemblerteil nicht

212

Lowlevel-Coding / Code anfang richtig setzen

« am: 31. March 2006, 14:06 »

genau das mein ich ja
wenn den Assemblerkernel assembliere, geht nasm davon aus, dass er bei 0 anfängt, deswegen stell ich manuell das DS und ES register um:

Code: [Auswählen]

cli
mov ax, cs
mov ds, ax
mov es, ax
sti

dann funtkioniert der Assemblerkernel

aber der CKernel ist bei 1000:0200, der compiler denkt aber nun auch er wäre bei 0000:0000, das Segment wird ja schon auf 1000 gestellt, also denkt er im Endeffekt er ist bei 1000:0000
deswegen muss ich ja das Offset erst umstellen bevor etwas funktionieren kann

das wär auch nicht das Problem,
ich will aber aus dem CKernel Funktionen im Assemblerkernel ausführen
das heißt ich msste die Register die ganze Zeit wieder umstellen

Im Endeffekt muss ich dem Compiler der den CKernel compiliert (gcc) klar machen, dass alle seine Daten 200h bytes weiter hinten liegen, als er eigentlich denkt, bei nasm wär das mit

Code: [Auswählen]

org 200

erledigt
und so einen Befehl bräucht ich halt für gcc, bzw. für as (as ist der Assembler den gcc nach dem compilieren benutzt um das ganze zu assemblieren)

EDIT:
as unterstützt sogar org, allerdings funktioniert das Programm trotzdem nicht

213

Lowlevel-Coding / Code anfang richtig setzen

« am: 31. March 2006, 13:30 »

ich versteh den Zusammenhang zwischen meiner Frage und deiner Anwort nicht
ich weiß wie man aus Assembler C-Funktionen aufruft und umgekehrt

aber wenn ich mit ld die Startadresse beispielsweiße auf 1000:0000 setze
wird im Assemblerkernel, der ja wirklich an 1000:0000 anfängt alles richtig adressiert
im CKernel, der erst an 1000:0200 anfängt aber natürlich nicht, da müsste ja zu allen Adressen 200h dazugerechnet werden, also bräuchte ich soetwas wie eine org Funktion, nur eben für C

ich hab mir auch schon das CKernel Tutorial von Tee-Jay angeguckt, aber das funktioniert ja nicht, wird mir also nicht weiterhelfen

214

Lowlevel-Coding / Code anfang richtig setzen

« am: 31. March 2006, 09:31 »

Hallo,

ich habe einen Kernel aus C und Assembler gemacht, indem ich beide zusammen gelinkt habe
aber wenn ich jetzt in ld (der Linker) den Einsprungpunkt auf 1000:0000 setze (da wird der Kernel hingeladen) stimmt der ja nur für den Assemblerkernel
der CKernel ist ja 512 bytes hinter dem assemblerkernel

deswegen funktioniert das ganze natürlich nicht
da die Sprünge des CKernels alle ins Nirvana führen
wie stelle ich das jetzt richtig ein?

215

Lowlevel-Coding / Speicher Management

« am: 30. March 2006, 21:41 »

dann lies dir mal das Protected Mode Tutorial von Tee-Jay durch (www.jay-code.de)
und sonst wirst du das mit Tutorials (vondenen es reichlich gibt, wer suchet der findet) viel besser verstehen, als hier im Forum

216

Lowlevel-Coding / mit sub auf 0 setzen schneller?

« am: 30. March 2006, 11:55 »

aber das summiert sich ja alles, wenn irgendeine grundlegenede Funktion eines Betriebssystem auch nur ein ganz kleines bisschen schneller ist
und dann aber millionen mal aufgerufen wird, ist das ganze Betriebssystem schon um ein paar Sekunden schneller
und wenn man das dann noch mit mehreren Funktionen macht lohnt sich das richtig

na egal, ich bleib einfach bei xor
Pipeline Optimierung kann ich noch machen wenns drauf an kommt

217

Lowlevel-Coding / mit sub auf 0 setzen schneller?

« am: 29. March 2006, 14:34 »

Hallo,

ein Register setzt man ja normalerweise mit

Code: [Auswählen]

mov ax, 0000h

auf 0

dann gibt es noch diese Möglichkeit:

Code: [Auswählen]

xor ax, ax

die schneller ist da sie ein Byte kleiner als die o.g. ist

aber was ist mit dieser:

Code: [Auswählen]

sub ax, ax

ist die schneller oder langsamer als die 2. o.g.?

ich hab mir mal den Linux Bootsektor angeschaut und die haben sub benutzt

218

Lowlevel-Coding / Aufbau des Betriebssystem?

« am: 29. March 2006, 14:19 »

mein Bootloader kann hex anzeigen, Text ausgeben und Disketten lesen
um den Kernel zu laden
Der Kernel sollte über 10h Textausgeben können, tut aber noch nicht
mein größeres Ziel ist in den Kernel einen VGA-Treiber einzubauen
damit ich n'kleines Spiel machen kann, um das ganze zu demonstrieren

das beste was ich mir vorstellen kann ist ein TCP/IP-Stack, aber das wird wohl noch ne Weile dauern

219

Lowlevel-Coding / Stack richtig initalisieren

« am: 28. March 2006, 17:51 »

das komische ist das es im tutorial eben auf 0 ist
und das tutorial funzt ja

deswegen hab ich den Fehler auch nicht gefunden
ich hab schon überlegt dass das eigentlich höher sein müsste
aber im tutorial wars halt auf 0

220

Lowlevel-Coding / int 10h: im bootloader gehts, im Kernel nicht

« am: 28. March 2006, 15:37 »

Ich schreib das hier jetzt nochmal neu, da ich n'paar Probleme beseitigt habe, die Fehler hab ich zwar nicht gefunden, aber ich hab das ganze nochmal von vorne neu geschrieben und siehe da, die ganzen Probleme mit dem Stack sind wie weggeblasen

Ein Rätsel bleibt allerdings noch:
wenn ich

Code: [Auswählen]

mov al, "h"
mov ah, 0eh
mov bx, 0007h
int 10h
aufrufe, soll das einfach nur das Zeichen "h" ausgeben
im Bootloader funktioniert das problemlos, sogar mit einer ganzen Textausgabe Routine,
aber im Kernel will er partout nicht mal ein Zeichen anzeigen

den Bootloader assembliere ich mit nasm zu flat binary,
den Kernel zu aout um ihn dann mit ld zu flat binary zu machen,
mache ich auch den Kernel direkt mit nasm zu flat binary klappt die Textausgabe, ich will den Kernel aber mit ld machen,
damit ich später C einbauen kann

hier der Kernel:

Code: [Auswählen]

global start
start:

cli
mov ax, 1000h
mov ds, ax
mov es, ax
sti

mov al, "h"
mov ah, 0eh
mov bx, 0007h
int 10h

ende:
jmp ende
times 512-($-$$) db 0

hier der Bootloader:

Code: [Auswählen]

org 7c00h

cli
mov ax, 9000h
mov ss, ax
mov sp,0ffffh
sti

mov al, "h"
mov ah, 0eh
mov bx, 0007h
int 10h

call readbr
mov ax, 0x1000
mov es, ax
mov ds, ax
push ax
xor ax, ax
push ax
retf

readbr:
mov ah, 02h   ;fest
mov al, 01h   ;Anzahl
mov ch, 00h   ;Spur
mov cl, 02h   ;Sektor
mov dh, 00h   ;Kopf
mov dl, 00h   ;Laufwerksnummer
mov bx, 1000h
mov es, bx    ;Segment
mov bx, 0000h ;Offset
int 13h
ret

times 510-($-$$) db 0
signatur dw 0aa55h