[assembly]Mini osje.

[Verwijderd]

In een poging een minimalistisch osje te maken probeer ik het volgende,
eerst een bootloader te programmeren en dan vervolgens een stukje code hierin dat een sector in leest en die code dan kopieert in het geheugen en nadien uit uitvoert.

Alles is op dit moment nog maar om te proberen dus het eerste stukje code laat eee op het scherm zien het volgende stukje normaal fff
echter het tweede stukje code wordt nooit uitgevoerd iemand enig idee waarom hij blijft lezen op de diskette?

bootloader:

code:

use16
?                       equ     0
ORG 0

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Boot sector starts here ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

        jmp             start

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Boot sector code starts here ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

start:
        mov ah,01h
        int 10h     ;zet in teksmode

        mov al,'e'
        mov bh,0
        mov bl,10h
        mov cx,10
        mov ah,09h
        int 10h     ;schrijf karakter op scherm



   mov ah,02h
   mov al,1
   mov ch,1
   mov cl,1
   mov dh,1
   mov dl,1
   mov bx,513  ; offset van begin adres   hier moet de code ingeladen worden

   int 13h
   jmp 513




times 510- ($-0)  db 0
dw 0xaa55

en dan het stukje om de f te laten zien:

code:

use16

ORG 0

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Boot sector starts here ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
jmp     start


start:
        mov ah,01h
        int 10h     ;zet in teksmode

        mov al,'f'
        mov bh,0
        mov bl,10h
        mov cx,100
        mov ah,09h
        int 10h     ;schrijf karakter op scherm



times 510- ($-0)  db 0
dw 0xaa55

Ik maak hier twee Bin's van en join die dan met een file joiner nadien schrijf ik het geheel met rawrite.

Groeten.

[.oisyn]

Tijd geleden dat ik hier iets mee gedaan heb, maar het eerste wat bij me opkomt is of je segmenten wel goed staan ingesteld? Geen idee hoor, kan zomaar zijn dat het bios dat al voor je doet, maar er staat me iets van bij dat je zelf moest doen. Gewoon even cs naar ds en es kopiëren. Ss kun je ook wel doen, maar wel even opletten dat sp dan op FFFE staat en dat je uiteindelijk niet je eigen code overschrijft

[unclero]

Dat, en je appje mag maar 512byte groot zijn (ivm sectoren op de floppy).
Anders maak je er 2 bins van, en zorg je dat die bootloader de volgende sector (je 2e bin) oppakt en uitvoert.

[Verwijderd]

Ik zie niet goed hoe ik me sectoren goed moet instellen. ik heb eens gekeken naar een ander voorbeeld waar men dat ook doet maar daar heb je een speciaal data segment. hier heb je dat niet dus hoe doet je dat hier? Waar moet ik en waarom moet ik mijn sp aanpassen? Groeten.

[Verwijderd]

Ik bedoel natuurlijk mijn segmenten en niet mijn sectoren.

[roy-t]

Ik zou zeggen, begin hier is: JayTaph in "[tutorial] how to write your own OS"

edit: het topic lijkt/is dood, maar op de eerste en laatste (2) pagina's staan toch de tutorials zodat je een stuk verder komt .

[ Voor 38% gewijzigd door roy-t op 04-02-2009 11:27 ]

[.oisyn]

.edit: bij nader inzien kun je beter even naar de topic van JayTaph kijken idd

[ Voor 88% gewijzigd door .oisyn op 04-02-2009 11:23 ]

[stappel_]

Dat is wel heel lang geleden. Virus aan het schrijven?
je maakt wat foutjes.
1) DL=1, Waarom drive B?
2) CH=1 en CL=1. Je moet CX vullen op een aparte manier. Het is 10bits cylinder en 6 bits sector nummer
3) DH=1, deze begint ook gewoon op 0 hoor.
4) Je vergeet ES te zetten voor het datasegment.

code:

mov ax, 4000h
mov es, ax
xor bx, bx
..
..
int 13h
jmp 4000h:0000h

[Verwijderd]

Bedankt voor de link ik ga daar wat mee aan de slag uit zoeken hoe ik een sector goed in laad. Groeten.

[Verwijderd]

Ik die tut eens doorgenomen en mijn programma verbeterd maar de jump maken naar het tweede stuk lukt nog niet waar zit de fout?

code:

jmp     start

start:

        mov ax,0x07C0 ;segment naar 07C0
        mov ds,ax     ; nu staat datasegment goed

        mov [bootdrive],dl   ; Onthoud de bootdrive


        mov ah,01h
        int 10h     ;zet in teksmode

        mov al,'e'
        mov bh,0
        mov bl,10h
        mov cx,10
        mov ah,09h
        int 10h     ;schrijf karakter op scherm

ReadSectors:

        mov dl,[bootdrive]
        mov bx,[Cur_Seg]        ; Data wordt in CurSeg:CurOff
        mov es,bx               ; geladen.
        mov bx,[Cur_Off]
       ; mov ah,02h              ; start read sector
        mov cx,1                ; sectors to read
        mov ax, 0x0201

        int 0x13

        mov ax,[Cur_Seg]
        mov ds,ax

       ; mov al,'g'
       ; mov bh,0
       ; mov bl,10h
       ; mov cx,10
       ; mov ah,09h
       ; int 10h     ;schrijf karakter op scherm

        jmp 0x1000:0x0000   ; [Cur_Off]


    Cur_Seg        dw    0x1000
    Cur_Off        dw    0x0000
    bootdrive      db    0

times 510- ($-0)  db 0
dw 0xaa55

[unclero]

Hoe schrijf je het weg naar je flop? Copypasta? Of gebruik je rawrite of een progje waar je een blok naar een bepaalde sector kan schrijven?

[_the_crow_]

Dus als ik het goed begrijp wordt alles vanaf 'Readsectors' niet uitgevoerd?

---

Ik heb zelf Bochs gebruikt om te testen toen ik zelf een OS aan het schrijven was. Elke keer rebooten is natuurlijk geen doen.

Mierenneuk tipje: gebruik XOR ax,ax om een register leeg te maken i.p.v. een MOV AX,0. Het is sneller en neemt minder bytes in beslag.

[.oisyn]

offtopic:
Het is sneller *omdat* het minder bytes in beslag neemt, waardoor er in de grand scheme of things meer instructies in je instruction cache passen. De instructie zelf is niet sneller

[_the_crow_]

.oisyn schreef op donderdag 05 februari 2009 @ 11:30:

offtopic:
Het is sneller *omdat* het minder bytes in beslag neemt, waardoor er in de grand scheme of things meer instructies in je instruction cache passen. De instructie zelf is niet sneller

offtopic:
Er stond mij bij dat het 2 of 3cycles vs. 1 cycle was. Maar als jij het zeker weet, neem ik dat uiteraard van je aan.

[_js_]

_the_crow_ schreef op donderdag 05 februari 2009 @ 11:35:
[...]

offtopic:
Er stond mij bij dat het 2 of 3cycles vs. 1 cycle was. Maar als jij het zeker weet, neem ik dat uiteraard van je aan.

Volgens mij alleen op de 8086/8088, op moderne processors zoals de 80286 zijn ze even lang in cycles.

[.oisyn]

Ik moet trouwens zeggen dat deze topic mij ook weer zin heeft gegeven om weer aan m'n OS te hobbyen . Vroeger (ik gok een jaar of 6 geledel ofzo) gebruikte ik daar GCC voor (DJGPP onder DOS) zoals de meesten wel doen, maar daar heb ik nu geen zin in. Ik wil eigenlijk gewoon met Visual C++ coden . Ik heb even gezocht en toen kwam ik op dit artikel. Door gebruik te maken van GRUB (een multiboot bootloader) en door een header in je code te zetten kan hij dus gewoon een PE "executable" laden.

Bovendien heb ik ook geen behoefte om de bootloader zelf te gaan zitten maken. Been there, done that, ik concentreer me nu liever op het interessante deel: de kernel.

offtopic:
@hieronder: klopt, en zo heb ik nog 100.000 projecten in de ijskast liggen

[ Voor 5% gewijzigd door .oisyn op 05-02-2009 15:57 ]

[Verwijderd]

offtopic:
Hoor jij niet aan een programmeertaal te werken

[unclero]

.oisyn schreef op donderdag 05 februari 2009 @ 15:40:
Ik moet trouwens zeggen dat deze topic mij ook weer zin heeft gegeven om weer aan m'n OS te hobbyen . Vroeger (ik gok een jaar of 6 geledel ofzo) gebruikte ik daar GCC voor (DJGPP onder DOS) zoals de meesten wel doen, maar daar heb ik nu geen zin in. Ik wil eigenlijk gewoon met Visual C++ coden . Ik heb even gezocht en toen kwam ik op dit artikel. Door gebruik te maken van GRUB (een multiboot bootloader) en door een header in je code te zetten kan hij dus gewoon een PE "executable" laden.

Ik had destijds nog een tooltje gebouwd die van een PE een a.out kon maken .

Bovendien heb ik ook geen behoefte om de bootloader zelf te gaan zitten maken. Been there, done that, ik concentreer me nu liever op het interessante deel: de kernel.

Ikzelf loop te prutsen aan een Virtual Machine voor (Free)DOS met een soort CIL.

[Verwijderd]

Hoe schrijf je het weg naar je flop? Copypasta? Of gebruik je rawrite of een progje waar je een blok naar een bepaalde sector kan schrijven?

Ik maak hier één bin van en schrijf die dan weg met rawrite op een floppy.

Dus als ik het goed begrijp wordt alles vanaf 'Readsectors' niet uitgevoerd?

Mijn bedoeling is om met deze code de tweede (dus eerste als ze vanaf nul beginnen te tellen) sector van een diskette te laden en nadien dan deze code uit te voeren.
De eerste code (dus die in de bootsector) werkt goed maar het gaat mis op het moment het tweede stuk code moet uitgevoerd.
Ik weet het niet meer zit er een fout bij de jump lees die slecht in of maak ik een fout bij het samenbrengen van de stukken?
Iemand enig idee? Groeten.

[LtMarx]

roy-t schreef op woensdag 04 februari 2009 @ 11:21:
Ik zou zeggen, begin hier is: JayTaph in "[tutorial] how to write your own OS"

edit: het topic lijkt/is dood, maar op de eerste en laatste (2) pagina's staan toch de tutorials zodat je een stuk verder komt .

lol

Eventueel een computer (minimaal een 80386) met minimaal 1 MB geheugen

[unclero]

Verwijderd schreef op donderdag 05 februari 2009 @ 20:33:
[...]

Ik maak hier één bin van en schrijf die dan weg met rawrite op een floppy.


[...]


Mijn bedoeling is om met deze code de tweede (dus eerste als ze vanaf nul beginnen te tellen) sector van een diskette te laden en nadien dan deze code uit te voeren.
De eerste code (dus die in de bootsector) werkt goed maar het gaat mis op het moment het tweede stuk code moet uitgevoerd.
Ik weet het niet meer zit er een fout bij de jump lees die slecht in of maak ik een fout bij het samenbrengen van de stukken?
Iemand enig idee? Groeten.

Probeer eens copyboot ipv rawrite..
Met copyboot kun je aangeven welke sector je weg wilt schrijven..

Bijv:

code:

copyboot boot.bin 0
copyboot mijnos.bin 1

[.oisyn]

unclero schreef op donderdag 05 februari 2009 @ 16:00:
[...]


Ik had destijds nog een tooltje gebouwd die van een PE een a.out kon maken .

Ik moet dat misschien ook maar gaan doen, want dit schiet niet op. Ik krijg niet voor elkaar dat de linker de entry point (multiboot header) ook daadwerkelijk als alle eerste functie in het .text section zet, en het is me ook nog niet gelukt om een section te definieren dat nog voor .text komt.

[roy-t]

Lt. Marx schreef op donderdag 05 februari 2009 @ 20:41:
[...]

lol

[...]

tsja vanaf dat moment was X86 helemaal hip! .

[Verwijderd]

Ikheb het gevonden.
Een disette zijn sectors beginnen te tellen vanaf 1 dus op 1 staat de bootloader en op 2 het nieuwe stukje code.
Verder had ik ook nog een registertje vergeten bij het oproepen van de 13h dit heeft me geholpen: http://www.dftech.cwc.net/osdev/LoadingSectorsTut.txt

Bedankt voor de antwoorden.

[.oisyn]

Ah ja, dat probleem was ik in het begin ook eens tegenaan gelopen. Ik las de eerste N sectors in, maar die bleken 512 bytes te worden geoffset. Nou ja, het zal wel goed zijn, het werkte iig. In Bochs tenminste, want toen ik het live uitprobeerde gebeurde er vrij weinig. Bleek dat Bochs het prima vond als je sector 0 probeerde in te lezen - gaf ie gewoon nullen terug

(Wie overigens bedacht heeft dat het bij 1 begint verdient stokslagen)

[ Voor 9% gewijzigd door .oisyn op 06-02-2009 11:09 ]

[Verwijderd]

ik heb nog één klein probleempje, ik heb nu de jmp 0x2000:0x0000 als ik dit wil omschrijven naar variable dan defineer ik Cur_Seg dw 0x2000 Cur_Off dw 0x0000

dan zouw ik zeggen jmp [Cur_Seg]:[Cur_Off] maar dit lukt niet, geeft me een foutmelding. Hoe los ik dit op?

Een ander mogelijkheid is mss het data segment goed te zetten en dan te jmp naar 0000h maar dat lukt niet.

[stappel_]

.oisyn schreef op vrijdag 06 februari 2009 @ 11:08:
Ah ja, dat probleem was ik in het begin ook eens tegenaan gelopen. Ik las de eerste N sectors in, maar die bleken 512 bytes te worden geoffset. Nou ja, het zal wel goed zijn, het werkte iig. In Bochs tenminste, want toen ik het live uitprobeerde gebeurde er vrij weinig. Bleek dat Bochs het prima vond als je sector 0 probeerde in te lezen - gaf ie gewoon nullen terug

(Wie overigens bedacht heeft dat het bij 1 begint verdient stokslagen)

dus het is head 0, track 0, sector 1 voor de eerste (=boot) sector?
benieuwd wat dan sector 0 vroeger was. Alles begint met 0 in asm.
Vanavond toch nog eens de MS-DOS Encyclopedia van Duncan uit de kast pakken. DE BIJBEL

[.oisyn]

Verwijderd schreef op vrijdag 06 februari 2009 @ 11:46:
ik heb nog één klein probleempje, ik heb nu de jmp 0x2000:0x0000 als ik dit wil omschrijven naar variable dan defineer ik Cur_Seg dw 0x2000 Cur_Off dw 0x0000

dan zouw ik zeggen jmp [Cur_Seg]:[Cur_Off] maar dit lukt niet, geeft me een foutmelding. Hoe los ik dit op?

Logisch, dat zijn twee memory reads. Je moet het zien als 1 FAR pointer - een offset en een segment paar. Uit de nasm docs:

The JMP FAR mem forms execute a far jump by loading the destination address out of memory. The address loaded consists of 16 or 32 bits of offset (depending on the operand size), and 16 bits of segment. The operand size may be overridden using JMP WORD FAR mem or JMP DWORD FAR mem.

Oftewel, je moet ze even omwisselen (eerst de offset, dan het segment), en dan een jmp far [Cur_Off] doen.

[Verwijderd]

dat lukt me niet, probleem is eigenlijk dat ik de jmp ox2000:0x0000 wil omschrijven in iets met twee variablen hoe doe je dat?

[.oisyn]

Waarom lukt dat niet? Wat ik zeg doet dat precies, met het enige verschil dat je er 1 geheugenadres van moet maken waar zowel de offset als het segment in staat (in die volgorde). Als je twee losse variabelen hebt zul je die eerst achter elkaar moeten zetten.

[Verwijderd]

Oké ik begrijp nu dat ik naar één geheugen adres moet maar om er één van te maken moet ik ze op één of andere manier optellen?

[Verwijderd]

jmp dword far 0x00002000

[.oisyn]

Verwijderd schreef op vrijdag 06 februari 2009 @ 14:45:
Oké ik begrijp nu dat ik naar één geheugen adres moet maar om er één van te maken moet ik ze op één of andere manier optellen?

Ik denk dat waar het misgaat is dat jij denkt in variabelen, maar asm kent helemaal geen variabelen. Eigenlijk alleen geheugenadressen.

Jij doet nu

GAS:

CurSeg dw 0x2000
CurOff dw 0x0000

Ik zeg: je moet die twee dingen na elkaar in het geheugen hebben staan (heb jij al), en de offset vooraan zetten (heb jij dus omgedraaid). Dat wordt:

GAS:

CurOff dw 0x0000
CurSeg dw 0x2000

Nu kun je vervolgens dit doen

GAS:

jmp far [CurOff]

Nee, dat springt niet alleen naar CurOff, CurOff is slechst een geheugenadres. Op die plek staat namelijk een offset/segment paar die de jmp far verwacht. Hij leest dus in totaal 32 bits uit vanaf plek CurOff, waarvan de eerste 16 bits de offset voorstelt en de tweede 16 bits het segment. Vervolgens springt ie naar die uitgelezen CurSeg:CurOff.

[Verwijderd]

Oké bedankt dat begrijp ik maar hoe doe je dat universeel door eerst die waarde op die geheugen plaatsten te veranderen en dan dezelfde constructie toe te passen? Groeten.

[JayTaph]

Ik heb een complete OS (voor zover hij draait) met source niet zo lang geleden gepost maar iemand heeft die op een andere plek neergezet maar als je zoekt kan je die wel vinden.. Die is redelijk uitgebreid qua functionaliteit (ik denk meer werkbaar dan 95% van alle OS'en ) en kan je misschien op weg helpen..


([Alg] Welke tools heb jij gemaakt? - deel IV hier is ie naartoe verplaatst zodat niemand em meer kan vinden )

[farlane]

offtopic:
It's alive!

[RobIII]

JayTaph in "[Alg] Welke tools heb jij gemaakt? - dee..." Directe(re) linkjes rule