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.


Themen - Cjreek

Seiten: [1]
1
Lowlevel-Coding / Keine VBE-Infos per Multiboot (GRUB4DOS)
« am: 29. October 2014, 10:41 »
Hallo,

Woher kommt es dass GRUB4DOS keine VBE Infos im Multiboot struct ablegt?
Ich benutze QEMU und in der GRUB console listet er mir auch einige VBE-Modes auf wenn ich "probevbe" eingebe.

Muss ich da was spezielles einstellen oder was ist das Problem?

(Crosspost: http://forum.osdev.org/viewtopic.php?t=28669 )
2
Hallo,

Ich nutze es grad mal etwas aus, dass wir ja offiziell ein "Lowlevel" Forum sind und explizit nicht nur ein Betriebssystem-Forum  :-)

Ich weiß, dass die meisten von euch Linux haben/benutzen. Hoffe jedoch vllt. doch ein bisschen weiter zu kommen. Was ich prinzipiell machen will/müsste wäre einen Treiber für einen virtuellen Monitor zu schreiben. Ich hab allerdings nicht mal ne Ahnung ob sowas überhaupt möglich ist.

Abgesehen davon, wüsste ich gerne ob es ein Forum rund um (Windows) Treiber-Entwicklung gibt. Habe jetzt bisher noch nichts anständiges gefunden. Zumindest kein Forum wo ich das Gefühl habe dass mir dort je irgendjemand auf meine Fragen antworten wird.

Oder vielleicht auch ein paar weiterführende Tutorials. Alles was ich bisher gefunden hab ging nicht (weit) über "Hallo Welt" hinaus.
3
Lowlevel-Coding / Lowlevel außerhalb der OS-Programmierung
« am: 18. October 2010, 15:54 »
Hallo,

Fallen euch andere "Einsatzgebiete" der Lowlevel-Programmierung außerhalb der Betriebssystemprogrammierung ein? Bootloader zählen jetzt auch nicht.

Welche sinnvollen "stand-alone Programme" gibt es oder kann/könnte es geben?

Würde mich mal interessieren, weil mir jetzt nicht wirklich was einfällt  :?

Edit: Falls das doch eher in den Off-Topic Bereich gehört, dann bitte verschieben!

Lg
Cjreek
4
Lowlevel-Coding / CGA - 65x25 Textmodus?
« am: 06. July 2010, 13:39 »
Hallo,

Ich spiele gerade mal (aus Langeweile) mit den CGA-Registern etc rum. Will mich da mal ein bisschen vertraut machen.

Jetzt habe ich sowas wie einen 65x25 Textmodus aktiviert.. o.O Habe von sowas noch nie gelesen.
Ich bin mir (fast) sicher dass ich irgendwelchen Unfug treibe, aber interessant finde ich es jetzt schon.



Hier mein Code: http://pastebin.com/7S6cPqeP

(Man muss vorher die Register 0-7 mit "disable_vga_protection" beschreibbar machen.. dazu gibt es im Register 17 ein Bit welches das steuert)

EDIT: Wobei ich gerade bemerke dass meine übergebenen Werte ziemlicher Schwachsinn sind.
Aber meine Frage steht immernoch.

Weiß jemand was da passiert?^^

Gruß
Cjreek
5
Softwareentwicklung / Assembler - Set-Ausdrücke
« am: 12. June 2010, 13:26 »
Hallo,

Folgender Delphi-Code:

procedure TSynAsmSyn.NumberProc;
begin
  inc(Run);
  fTokenID := tkNumber;
  while FLine[Run] in ['0'..'9', '.', 'a'..'f', 'h', 'A'..'F', 'H'] do
    Inc(Run);
end;

Dazu wird folgender (von mir so gut wie möglich lesbar gemachter) Assemblercode generiert:

(Hier externe Version mit Highlighting: *klick*)
; Label   | Adresse |     Opcode    |   Mnemonic

; Initialisierung
           00475bac  55                 push ebp
           00475bad  8bec               mov ebp,esp
           00475baf  51                 push ecx
           00475bb0  8945 fc            mov dword ptr ss:[ebp-4],eax
           00475bb3  8b45 fc            mov eax,dword ptr ss:[ebp-4]

; inc(Run)
           00475bb6  ff80 70080000      inc dword ptr ds:[eax+870]
           00475bbc  8b45 fc            mov eax,dword ptr ss:[ebp-4]

; fTokenID := tkNumber;
           00475bbf  c680 80080000      mov byte ptr ds:[eax+880],4

           00475bc6  eb 09              jmp short 00475bd1                    ; ---> 1.Durchl
Schleife:  00475bc8  8b45 fc              / mov eax,dword ptr ss:[ebp-4]     

; inc(Run)
           00475bcb  ff80 70080000        | inc dword ptr ds:[eax+870]

; al := FLine[Run]
1.Durchl:  00475bd1  8b45 fc              | mov eax,dword ptr ss:[ebp-4]
           00475bd4  8b40 68              | mov eax,dword ptr ds:[eax+68]
           00475bd7  8b55 fc              | mov edx,dword ptr ss:[ebp-4]
           00475bda  8b92 70080000        | mov edx,dword ptr ds:[edx+870]
           00475be0  8a0410               | mov al,byte ptr ds:[eax+edx]

; al in ['0'..'9', '.', 'a'..'f', 'h', 'A'..'F', 'H'] ?
           00475be3  04 d8                | add al,0d8
           00475be5  3c 47                | cmp al,47
           00475be7  77 0a                | ja short 00475bf3                ; ---> Schl_end
           00475be9  83e0 7f              | and eax,7f
           00475bec  0fa305 f85b470>      | bt dword ptr ds:[475bf8],eax     ; **** Bitmaske
Schl_end:  00475bf3  72 d3                \ jb short 00475bc8                ; ---> Schleife

; Finalisierung
           00475bf5  59                 pop ecx
           00475bf6  5d                 pop ebp
           00475bf7  c3                 retn



; Daten
Bitmaske:  00475bf8  40ff037e           dd 7e03ff40                       
           00475bfc  01                 db 01
           00475bfd  00                 db 00
           00475bfe  00                 db 00
           00475bff  7e                 db 7e                                 
           00475c00  01                 db 01
           00475c01  00                 db 00
           00475c02  00                 db 00
           00475c03  00                 db 00

Das ist der Codes von dem SEG-Editor, der mir sehr gefällt, aber dessen (auf TSynEdit basierendes) Syntaxhighlighting gefällt mir leider nicht so, weswegen ich die exe gerade (bisher sehr erfolgreich) meinen Wünschen anpasse.

Mein Problem ist dass er keine Hexzahlen im Format 0xABCDEF erkennt, da er das "x" nicht als Bestandteil einer Zahl ansieht.

Ziel ist es jetzt den Assemblercode so umzugestalten (die Dateigröße darf natürlich nicht wachsen!), dass auch "x"-Zeichen akzeptiert werden.
Der Assemblercode soll dann äquivalent sein zu einer der folgenden Delphi-Codes:

A)
procedure TSynAsmSyn.NumberProc;
begin
  inc(Run);
  fTokenID := tkNumber;
  while FLine[Run] in ['0'..'9', '.', 'a'..'f', 'h', 'A'..'F', 'H', 'x', 'X'] do
    Inc(Run);
end;

B)
// auf das "H" kann ich persönlich verzichten
procedure TSynAsmSyn.NumberProc;
begin
  inc(Run);
  fTokenID := tkNumber;
  while FLine[Run] in ['0'..'9', '.', 'a'..'f', 'x', 'A'..'F', 'X'] do
    Inc(Run);
end;

Würde mich freuen wenn mir da jemand helfen könnte ;-)

Lg
Cjreek
6
Softwareentwicklung / Meine Programmiersprache - Haze
« am: 13. March 2010, 14:45 »
Hi,

Also ich habe ja versprochen ein paar Infos über meine werdende Programmiersprache zu posten. Hier sind sie!

Die Syntax von "Haze" ähnelt der von Pascal SEHR, was ihr auch gleich sehen werdet. Der Grund dafür ist einfach, dass ich mit dieser Art von Syntax "aufgewachsen" bin und damit am besten zurecht komme.
Einige Syntaxelemente sind allerdings an die Syntax von C angelehnt. Z.B. die Art wie Arrays deklariert werden oder die Darstellung von Hex-Zahlen.

Hier ein kleines (mehr oder weniger sinnvolles) Codebeispiel. Dieser Code ist zurzeit alles andere als compilierbar. Der Code soll nur einen Eindruck vermitteln, wie es später mal ungefähr aussehen wird.
Große Teile der Syntax die zu sehen ist, habe ich bereits per EBNF festgehalten. Einige Dinge muss ich noch ergänzen.

Der Beispiel-Code: http://pastebin.com/1bWXx1Zm

Die bisherige (unfertige!) EBNF:
(Meine EBNF-Syntax weicht minimal von der offiziellen ab, aber ich denke man kann es trotzdem lesen)


Die EBNF ist sicher auch in ihrer bisherigen Form alles andere als minimal oder perfekt. Aber ich arbeite daran ;-)

Den Compiler inkl. Scanner und Parser schreibe ich komplett selbst in Delphi. Der Scanner ist soweit fertig. Mit dem Parser fange ich an, sobald die EBNF reif genug ist. Der Compiler wird Assemblercode (NASM) erzeugen und dann NASM die Umwandlung in Machinencode überlassen.

Meine Sprache wird (wie schon anhand der EBNF zu erahnen) ein ähnliches Unit-System unterstützen wie Pascal und Delphi es tun.

Mehr fällt mir jetzt auf Anhieb nicht ein. Wenn ihr irgendwelche Fragen habt, dann stellt sie ruhig und ich versuche eine Antwort darauf zu geben  :wink:
7
Softwareentwicklung / Turbo C - COM Datei erstellen
« am: 28. February 2010, 21:16 »
Hi,

Ich versuche gerade mit einer alten 16-Bit Turbo C Version eine 16-Bit COM-Datei zu erstellen, die ich auch für meinen Bootloader benutzen kann.

Habe dazu erstmal eine Testdatei erstellt:

test.c

int main()
{

}

Compilieren tue ich die Datei folgendermaßen:

Zitat
tcc -mt -c test.c

-c = Nur compilieren, nicht linken
-mt = Tiny Memory Model

Das funktioniert auch schonmal ganz gut und ich erhalte die gewünschte test.obj. Allerdings scheitere ich jetzt beim linken:

Zitat
tlink test.obj /n /t

/n = Keine default libs verwenden
/t = COM Datei erstellen

Allerdings erhalte ich immer die Meldung:

Zitat
Cannot generate COM file : invalid initial entry point address

Kenne mich aber weder mit dem Linker noch mit dem Compiler noch generell mit C wirklich gut aus.

Also wie kann ich ihm jetzt den richtigen Entry-Point (0x100) übergeben?

Per Compilerschalter oder irgendwie doch über den Linker oder sonst irgendwie?

Gruß
Cjreek
8
OS-Design / Idee zum Thema Prozessverwaltung
« am: 19. August 2009, 02:47 »
Hi,

Folgende Geschichte:

Habe eben mal wieder Lust gehabt mit dem Editor von Warcraft III eine Map zu basteln. Bzw nur etwas damit rumzuspielen. Mir kam die Idee eine Einheit zu basteln, die bei ihrem Tod 2 weitere ihres Typs spawnt.

Habe damit etwas rumexperimentiert.. Diese Experimente sind z.T. etwas nach hinten losgegangen und haben meinen PC nach wenigen Sekunden in die Knie gezwungen und ich war gezwungen den Resetknopf zu drücken, da ich es nicht geschafft habe Warcraft 3 zu beenden.

Idee:

Nun kam mir eine Idee. Ich dachte mir, dass es doch ganz nützlich wäre wenn der Kernel eine Funktion bereitstellen würde, die den angeforderten Speicher und die benutzte CPU-Power eines jeden Prozesses überwacht. Sollte nun ein Prozess (über Sekunden hinweg) eine ungesund hohe CPU Auslastung erzeugen oder auffällig/übertrieben viel Speicher anfordern (Speicherleck?), dann unterbricht der Kernel das auffällige Programm und fragt den Benutzer ob dieses Verhalten so in Ordnung/erwünscht ist und nun darf der Benutzer dann entscheiden ob er das Programm beenden möchte oder ob alles seine Richtigkeit hat und das Programm fortgeführt werden soll.

Was haltet ihr von der Idee? Natürlich sollte dieses Feature abgestellt werden können und ggf. Ausnahmen hinzugefügt werden können etc. falls einem User das zu lästig werden sollte.

Lg
Cjreek
9
Lowlevel-Coding / GRUB und Windows
« am: 11. June 2009, 18:36 »
Hi,

Kann es sein, dass GRUB äußerst sch...lecht auf Windows zum laufen gebracht werden kann?

Habe mir das Tutorial hier durchgelesen und habe jetzt unter Windows das Problem, dass ich folgendes nicht in Windows umsetzen kann

Zitat
Und dann folgendes eingeben:

device (fd0) floppy.img
root (fd0)
setup (fd0)
quit

Ich weiß jedenfalls nicht wie.... Habe auch schon gegoogelt und irgendwelche GRUB Versionen extra für Windows gefunden aber entweder funktionieren die nicht oder/und ich bin zu blöd dafür -.-

10
Lowlevel-Coding / Kleine FAT12 Verunsicherung
« am: 08. June 2009, 23:02 »
Hi,

Habe mir mit dem Programm MagicISO eine FAT12 Diskette (3,5) als .img erstellen lassen. Und jetzt schaue ich mir gerade die Datei im Hexeditor an weil ich hoffe dadurch etwas schlauer zu werden was FAT12 angeht.

Das hier sind die ersten 16 Bytes der FAT Tabelle:

Zitat
F0 FF FF FF 4F 00 05 60 00 FF FF FF FF 0F 00 00

Habe in Wikipedia gelesen, dass die ersten beiden Einträge Pseudoeinträge sind. Das wären dann ja wohl:

FF0 und FFF. Aber es scheinen ja 3 zu sein oder? Darauf folgt ja noch ein FFF Eintrag. Und dann beginnt es erst bei 004 anstatt bei 003.. Ist das generell so (habe gerade hier keine echte Diskette da) oder irgendeine Besonderheit/Ausnahme oder sogar einfach nur ein Fehler?

Lg
Cjreek

11
Lowlevel-Coding / Stack funktioniert nicht (rmode)
« am: 03. June 2009, 23:25 »
Hi,

Ich bins mal wieder  :-D

Ich hab irgendwie ein Problem mit meinem Stack.... Beim poppen bekomm ich nur scheiße zurück -.-

Ich zeig euch mal etwas Code:

    mov ax, 0    ; etwas ungünstig aber andere segmente gehn auch nicht
    mov ss, ax
    mov sp, 0xFFFF

jetzt der eigentliche Code:
mov dx,1
mov al,1
call floppy_read
; ...

floppy_read:
xor cx,cx
mov es,cx     
mov bx,0x7E00

push dx
call lba_to_chs
; ...
ret

lba_to_chs:
    pop ax
;   Hier kommt nur müll raus ==> 0x7C5A statt 0x0001
;   ...
    ret

 :?
12
Lowlevel-Coding / int13 - Wo sind meine Daten?
« am: 03. June 2009, 17:29 »
Hi,

Ich versuche so den 2. Sektor meiner (Boot-)Diskette auszulesen.

Zitat
[ORG 0x7C00]

; ...

    mov ax,0x7E00
    mov es,ax   
    xor bx,bx           ; Daten nach 0x7E000 bzw 7E00:0000 lesen
   
    mov al, 1           ; 1 Sektor
    mov ch, 1          ; Spur 1
    mov cl, 1           ; 1 = 2. Sektor ?! (1. Sektor = 0?)
    mov dh, 1         ; Kopf
    mov dl, 0          ; Laufwerk 0 ==> Diskettenlaufwerk

    mov ah, 0x02
    int 13h

; ...

Das eax-Register hat nach dem Aufruf den Wert 00000001h. Also müsste eigentlich alles funktioniert haben und al = 1 Sektor gelesen worden sein.

Das Ende meines Codes sieht so aus:

Zitat
times 510-($-$$) db 0
db 0x55
db 0xAA
test db "Hallo Int13!",0

Wenn ich allerdings nach int13 ein jmp $ setze und dann mit QEMU schaue, was bei 0x7E000 steht, dann wird mir angezeigt, dass da eine 0 steht. Eigentlich müsste es ja 0x48 sein...
13
Lowlevel-Coding / Kernel mit Pascal
« am: 02. June 2009, 22:47 »
Hi,

Das scheint ja eine etwas problematische Sache zu sein. Vorallem wenn man nicht GRUB, sondern einen eigenen Bootloader benutzen will.

Das Problem ist, dass ich mit dem Free Pascal compiler fpc scheinbar keine flat binaries erzeugen kann. Nur ELF oder PE. Und die kann ich ja nicht laden/benutzen.

Ich stehe also gerade etwas blöd da  :|

Das andere Problem ist:

Zitat
nasm boot.asm -f bin -o boot.o
==>
Zitat
boot.asm:43: error: binary output format does not support external references

Fehlermeldung kommt wegen [extern kernel_main] in meinem asm Code. Das brauche ich ja. Sonst kann ich ja nicht in meinen Kernel springen -.-

Was heißt das jetzt für mich?
14
Lowlevel-Coding / Aufbau der GDT
« am: 02. June 2009, 16:56 »
Hi,

Habe erst vor kurzem angefangen und habe jetzt erstmal eine Frage zur GDT. Das Ding ist ja aus irgendeinem Grund ziemlich unnötig kompliziert aufgebaut.

Mein Problem ist wie jetzt die einzelnen Limit- bzw Base-Bits zusammengebaut werden.

Der Aufbau ist ja folgender:

8 Bit Limit (Bits 0-7)
8 Bit Limit (Bits 8-15)
...

Angenommen ich hätte nur diese beiden Bytes und ich schreibe folgendes:

db 01000000b
db 11111101b

Was ergäbe das dann zusammengesetzt?

Meine Logik sagt mir: 00000010 10111111

Stimmt das?  :?
Seiten: [1]

Einloggen