Verfügbare Informationen zu "Kync"
Qualität des Beitrags: Beteiligte Poster: donasa Forum: Advanced-Computer Forenbeschreibung: Computer aus dem Unterforum: Projekte Antworten: 3 Forum gestartet am: Samstag 07.10.2006 Sprache: deutsch Link zum Originaltopic: Kync Letzte Antwort: vor 17 Jahren, 5 Monaten, 16 Tagen, 4 Stunden, 31 Minuten
Alle Beiträge und Antworten zu "Kync"
Re: Kync
donasa - 08.11.2006, 19:49Kync
Hier codes für kernel
Re: Kync
donasa - 08.11.2006, 19:50
Kync1:
Code:
[BITS 16] ;16 Bit Code erstellen
jmp start ;GDT überspringen
NULL_Desc:
dd 0
dd 0
CODE_Desc:
dw 0xFFFF ;Segmentgröße Byte 0/1
dw 0 ;Segmentbasisadresse Byte 0/1
db 0 ;Segmentbasisadresse Byte 2
db 10011010b ;Zugriffsberechtigungen
db 11001111b ;Zusatz + Segmentgröße Bits 16 - 19
db 0 ;Segmentbasisadresse Byte 3
DATA_Desc:
dw 0xFFFF
dw 0
db 0
db 0x92
db 0xCF
db 0
gdt:
Limit dw 0 ;Größe der GDT (wird später eingetragen)
Base dd 0 ;Adresse der GDT (wird später eingetragen)
start:
cli ;Interrupts ausschalten
mov eax, cs ;EAX auf derzeitiges Codesegment setzen
mov ds, ax ;DS auf Codesegment setzen
shl eax, 4 ;EAX mit 16 multiplizieren (Lineare Adresse
;des Codesegments errechnen)
mov [CODE_Desc+2], ax ;Lineare Adresse des Codesegmentes als
mov [DATA_Desc+2], ax ;Startadresse des Code- und Datendeskriptors
shr eax, 16 ;eintragen
mov [CODE_Desc+4], al
mov [DATA_Desc+4], al
mov eax, cs ;Startadresse der GDT errechnen
shl eax, 4
add eax, NULL_Desc
mov [Base], eax ;Startadresse der GDT eintragen
mov [Limit], WORD gdt - NULL_Desc -1 ;Größe der GDT errechnen und eintragen
lgdt [gdt] ;GDT laden
mov eax, cr0 ;In den Protected Mode schalten,
or eax, 1 ;indem Bit 0 des CR0 Registers auf 1
mov cr0, eax ;gesetzt wird
db 0xea ;FAR-JUMP zum Codesegment
dw PMODE
dw 0x8
[BITS 32] ;32 Bit Code erstellen
PMODE:
mov WORD [CODE_Desc+2], 0 ;Code Segmentstartaddresse auf 0 setzen
mov WORD [DATA_Desc+2], 0 ;Daten Segmentstartadresse auf 0 setzen
mov BYTE [CODE_Desc+4], 0 ;Code Segmentstartaddresse auf 0 setzen
mov BYTE [DATA_Desc+4], 0 ;Daten Segmentstartadresse auf 0 setzen
mov eax, 2 ;Selektor für das Datensegment erstellen
shl eax, 3
mov ds, ax ;Daten- Stack- und Extrasegment mit
mov ss, ax ;Datensegmentdeskriptor laden
mov es, ax
mov eax, 0 ;FS und GS mit Null-Deskriptor laden
mov fs, ax
mov gs, ax
mov esp, 0x1FFFFF ;Stack auf unterhalb der 2 MB Grenze setzen
jmp 0x8:0x10000 + PMODE2 ;Sprung in das "neue" Codesegment
PMODE2:
jmp END ;Zum Ende Springen
times 512-($-$$) db 0; ;Da der Linker sich nicht mit ungeraden
;Dateigrößen verträgt, wird diese Datei auf 512
;gepaddet.
END:
kync2:
Code:
[Bits 32]
extern _main
global start
start:
call _main
Stop:
jmp stop
kync3(C++) //EDITED 8 November
Code:
int main()
{
char *Text = "Lync STARTED...................WELCOME TO LYNC OS";
char *VideoMem = (char*)0xB8000;
while(*Text)
{
*VideoMem = *Text;
*VideoMem++;
*VideoMem = 7;
*VideoMem++;
*Text++;
}
return(0);
}
Verlinken:
Damit das ganze auch Gestalt annimmt, müssen wir das ganze noch zusammen durch einen Linker jagen. Dieser kopiert uns die Objektdateien zu einer zusammen und löst die verbleibenden Funktionen und Label auf. Damit erhalten wir dann schon "fast" unseren fertigen Kernel.
Fast nur deshalb, weil wir die "kernel16.bin" nicht mit durch den Linker jagen können, da es sich hier nur um eine binäre Datei handelt. Diese muß aber auch untergebracht werden. Und dabei müssen wir sicherstellen das der Code der darin enthalten ist zu allererst ausgeführt werden muss. Das erreichen wir ganz einfach, indem wir den "verlinkten" Kernel und die "kernel16.bin" zusammenkopieren. Dabei muß so kopiert werden, das die "kernel16.bin" am Anfang der neuen Datei steht. Für dieses Zusammenkopieren benutzen wir den Copy-Befehl.
So nun aber zum verlinken der beiden Dateien "kernel32.obj" und "ckernel.obj". Dazu benutzen wir den Linker "ld" der ebenfalls bei DJGPP enthalten ist. Für diesen erstellt man sich am besten eine "Linkerfile". Diese enthält die nötigen Angaben und Einstellungen die der Linker benötigt. Auch diese Datei wird zur Verfügung gestellt. Trotzdem erkläre ich hier noch ein paar kleine Einzelheiten zu dieser Datei, da diese evtl. später mal geändert werden müssen.
Da hätten wir als allererstes folgende Zeile:
INPUT(kernel32.obj ckernel.obj)
Hier werden in den Klammern alle Objektdateien angegeben, die zusammengelinkt werden sollen. Wichtig dabei ist, das die "kernel32.obj" zuerst angegeben wird, damit diese auch zuerst in der fertigen Datei steht. Sollten später mal weitere Objektdateien erzeugt werden, können diese ganze einfach ebenfalls in diese Klammer eingetragen werden und werden somit beim nächsten Linken berücksichtigt.
Dann hätten wir da noch folgende Zeile:
.text 0x10200 : {
Die genaue Bedeutung ist ansich unrelevant. Wissenswert ist lediglich das die Zahl "0x10200" (Dezimal: 66048) angibt an welcher Adresse der Kernel im Speicher beginnt. Das muß der Kernel wissen, da er nur mit dieser Angabe die Adressen für Funktionen und Variablen korrekt berrechnen kann.
Hier ist allerdings die Adresse anzugeben, welcher der Kernel innerhalb des Codesegmentes ist. Unser Kernel beginnt an der Adresse 0 im Code-Segment. Da wir jedoch die Datei "kernel16.bin" noch VOR den hier zu verlinkenden Kernel kopieren müssen. Mit der Anweisnung "times" innerhalb der Datei "kernel16.asm" habe ich dafür gesorgt das die erstellte Datei "kernel16.bin" 512 Bytes groß wird. Das mag nach Verschwendung klingen, hat aber einen Grund. Beim Linken versucht der Linker immer ein Alignment zu erzeugen. Sprich er beginnt ungern an ungeraden Adressen. Und daher könnte es leicht passieren, das wir vielleicht im Nachhinein nochmal etwas an der Datei "kernel16.asm" ändern möchten und somit Gefahr laufen das das Ergebnis (kernel16.bin) eine ungerade Bytezahl annimmt. Wenn wir das nicht bemerken und versuchen das ganze zusammenzufügen werden wir wohl Überraschungen erleben, weil der Linker dann noch ein paar Nullen einfügt die da nicht hinsollen. Daher sorgen wir also dafür das die Datei "kernel16.bin" 512 Byte größe hat und das der Linker den restlichen Kernel so linkt, das er an der Adresse 0x10200 (Dezimal: 66048) beginnt.
Und auch hier wieder die Befehlszeile für den Linker: ld -T link.txt -o c32kernel.bin
Erläuterung:
"ld" Name des Linkers.
"-T link.txt" teilt dem Linker mit, das wir eine "Linkerfile" benutzen und das deren Namen "link.txt" ist.
"-o c32kernel.bin" besagt den Namen der Datei die wir gerne als Ergebnis haben möchten.
So nun sind wir schon ein Stück weiter und haben eigentlich nur noch zwei relevante Dateien. Nämlich die "kernel16.bin" und die "c32kernel.bin".
Alles Zusammenfügen:
Jetzt haben wir es fast geschafft. Wir müssen nur noch die beiden Dateien "kernel16.bin" und "c32kernel.bin" zusammenkopieren.
Dies kann man mit dem Tool(MergeKernel) das ich geschrieben habe und zum Download am Ende mit angebe bewerkstelligen.
Dazu gibt man folgenden Syntax an:
MergeKernel kernel.bin kernel16.bin c32kernel.bin
Damit wird die Datei "kernel.bin" erstellt und die Inhalte der Dateien "kernel16.bin" und "c32kernel.bin" werden in diese kopiert. Wichtig ist dabei, das "kernel16.bin" zuerst, also direkt nach "kernel.bin", angegeben wird.
Nun haben wir den fertigen Kernel(kernel.bin).
Damit wir diesen auch starten können müssen wir zunächst meine Bootloader auf eine Diskette bekommen. Dazu benutzt man am besten das Tool Rawrite.
Code:
OUTPUT_FORMAT("binary")
INPUT(..\Kync\Compiled\kernel32.obj ..\Kync\Compiled\ckernel.obj)
ENTRY(start)
SECTIONS
{
.text 0x200 : {
code = .; _code = .; __code = .;
*(.text)
. = ALIGN(1);
}
.data : {
data = .; _data = .; __data = .;
*(.data)
. = ALIGN(1);
}
.bss :
{
bss = .; _bss = .; __bss = .;
*(.bss)
. = ALIGN(1);
}
end = .; _end = .; __end = .;
}
http://data.gym.wenzgasse.at/MergeKernel.exe
Re: Kync
donasa - 08.11.2006, 20:18
testen kann das bitte jetzt mal ein andere ich hoffe es klappt so
Mit folgendem Code, können Sie den Beitrag ganz bequem auf ihrer Homepage verlinken
Weitere Beiträge aus dem Forum Advanced-Computer
Visul Basic - gepostet von inachor am Donnerstag 02.11.2006
Ähnliche Beiträge wie "Kync"