Hirdetés

Aktív témák

  • RedAnt

    aktív tag

    Haliho!
    Valaki tudna segiteni nekem?
    Probaltam oprendszert irni, de nem tudom hogy kell bekapcsolni bootolaskor a vedett modot. Nekem 386os szinten boven megfelelne!
    A belepes elott kell letrehozni a GDT-t? Es mit kell csinalni a szegmensregiszterekkel?
    Es ez belefer a bootstrap prgba?
    ??

    ╚╦╦╦

  • Pizzafutar

    tag

    válasz RedAnt #1 üzenetére

    Fogalmam sincs, de valaki mar probalkozott ezzel vagy 10 eve. :)
    Nezd meg a linux forraskodot.

  • Pizzafutar

    tag

    válasz Pizzafutar #2 üzenetére

    Na, ha senki nem szolt hozza, akkor ide másolom a kérdéses részt.
    arch/i386/boot/setup.S

    # Well, now's the time to actually move into protected mode. To make
    # things as simple as possible, we do no register set-up or anything,
    # we let the gnu-compiled 32-bit programs do that. We just jump to
    # absolute address 0x1000 (or the loader supplied one),
    # in 32-bit protected mode.
    #
    # Note that the short jump isn't strictly needed, although there are
    # reasons why it might be a good idea. It won't hurt in any case.
    movw $1, %ax # protected mode (PE) bit
    lmsw %ax # This is it!
    jmp flush_instr

    flush_instr:
    xorw %bx, %bx # Flag to indicate a boot
    xorl %esi, %esi # Pointer to real-mode code
    movw %cs, %si
    subw $DELTA_INITSEG, %si
    shll $4, %esi # Convert to 32-bit pointer

    # jump to startup_32 in arch/i386/boot/compressed/head.S
    #
    # NOTE: For high loaded big kernels we need a
    # jmpi 0x100000,__BOOT_CS
    #
    # but we yet haven't reloaded the CS register, so the default size
    # of the target offset still is 16 bit.
    # However, using an operand prefix (0x66), the CPU will properly
    # take our 48 bit far pointer. (INTeL 80386 Programmer's Reference
    # Manual, Mixing 16-bit and 32-bit code, page 16-6)

    .byte 0x66, 0xea # prefix + jmpi-opcode
    code32: .long 0x1000 # will be set to 0x100000
    # for big kernels

  • RedAnt

    aktív tag

    Nincs meg valahol inteles szintatikaval?
    Ezt nem szeretem a linuxos forrasokban... eleg ijeszto :(
    Amugy NASM-t hasznalok,szoval kell egy kis precompileing :)
    Azer kosz, megprobalom kisilabizalni!
    Ja es azt tudja valaki hogy utana lehet e hasznalni a bios interruptokat, vagy az egeszet meg kell irni ujra? Peldaul ha ki akarok vmit irni a kepernyore.
    Mondjuk azt hogy Kiraly, benn vagy a vedett modban! :DD

    ╚╦╦╦

  • Pizzafutar

    tag

    válasz RedAnt #4 üzenetére

    Szerintem nem lehet használni az interruptokat.
    Annak 3 feltétele lenne:
    Létre kellene hozni az uj int. tablazatot, ez ebben a modban 8 byteos cimeket tartalmazna. A táblázat cimét be kell tolteni az IDT regiszterbe.
    Létezni-e kellen az uj bios rutinoknak
    Az int utasitas vedett modban kizarast eredményezhet.

    Egyébként emlékeim szerint, protected modba kapcsolas utan az oprendszerek sem hasznaljak már a BIOS-t.

    Az intel szintaktikához talan a fent emlitett
    INTeL 80386 Programmer's Reference
    # Manual, Mixing 16-bit and 32-bit code, page 16-6

    Vagy google lmsw


    [Szerkesztve]

  • blemidon

    tag

    válasz RedAnt #4 üzenetére

    Hi!

    Végre normális téma:)
    Anno az egyik legjobb védett módú fejlesztőeszköz a watcom c/c++ volt (ezzel készült az UFO, DOOM, és társai, a.k.a dos4gw) A jó hír, hogy manapság ez már ingyenes. [L]http://www.openwatcom.org[/L]
    A Sybase csinálta, csak mikor már nem nagyon kellett, abba akarták hagyni, de a SciTech, aki nagy watcom felhasználó volt, szólt nekik, hogy kéne belőle csináni ha mást nem, opensource valamit. Ez van most folyamatban.
    Emellett a watcom assembler a legnagyobb asm amit szerintem valaha PCre csináltak.
    Ezzel kellene megpróbálkoznod. Már régen nem foglalkoztam vele, de anno eléggé bentvoltam a témában, megpróbálok segíteni ha gondod van.

    Interruptokra visszattérve:
    Az int31 a ''global'' védett módú megszakítás, ennek az egyik funkciója hogy hív real módú megszakításokat. Tehát a sima int 21h nem megy, hanem úgy tdod megcsinálni, hogy int31nek megadod hogy a 21et akarod hívni ezekkel a paraméterekkel, és int31, és ő meghívja. pontosan nemtdom hogy melyik funkció, de így működik az biztos.


    [Szerkesztve]

  • escie

    őstag

    válasz Pizzafutar #2 üzenetére

    jól tévedek, hogy Linus ''Linux:)'' Torvalds is hasonló okból kezdett oprendszer fabrikálásába?

    I'm back, baby!

  • blemidon

    tag

    válasz blemidon #6 üzenetére

    u.i.:
    Anno volt 1 fekete klassziker ''csikoselejü'' LSI könyv, az a ''386 I-II'', az első része vékoyn volt, a második annál vastagabb. Ebben pseudo kóddal megtalálható volt a védett módba belépés és stb, tehát hogy egy PM keretrendszert hogy kell felépíteni. Ha kell, előtúrom padlásról, és beszkennelem az idevágó részt.

    u.i.2:
    Az int31 a dos4gw extenderrel működött, valószínű, de nem biztos hogy a többi PM bővítőnél is ez. Nem tudom hogy szabvány e vagy hogy mennyire dolgoztak együtt.
    A mostani watcomban van dos4gw, CauseWay, PMode/W extender, a régibe volt vmi másik is, aminek nemtom a nevét, és azt se tudom, hogy a mostaniba benne van e, de változhat a védett mód programozásod attól függően, hogy melyiket használod. Ha egyiket se, akkor az nem lesz egyszerű, de legalább te döntöd el hogy mi van:)

    Amúgy az OpenWatcom választék:

    Host Platforms

    DOS
    OS/2 Warp
    Windows 3.1
    Windows 95/98/Me
    Windows NT/2000/XP

    Target Platforms

    16 and 32-bit DOS
    16 and 32-bit OS/2
    Windows 3.1
    Win32s
    Windows 95/98/Me
    Windows NT/2000/XP
    Novell NLM

    watcom rulez:)

    (Visual C++nál örülhetek hogy azt az 1 szaros win32 targetet atták annyi pénzér:)

  • blemidon

    tag

    válasz escie #7 üzenetére

    A Linux az a unix rendszer PC-s átirata. Amugy ha megnézed hogy előtte neki PCre csak DOS/Windows volt, esetleg OS/2, akkor nem lehet hibáztatni hogy belefogott:)

    [Szerkesztve]

  • blemidon

    tag

    válasz blemidon #8 üzenetére

    Na még írok hozzá:)

    Az OpenWatcomot akarják fejleszteni linux/bsd rendszerektre is, az pedig oda fog b@szni:)
    Lesz egy olyan natív platformfüggetlen fejlesztőrendszered mint pl a QT, csak többet fog nyújtani. Nem csak sima ablakkezelő API, hanem teljes fullos C++ rendszer. És free. Álat.

  • escie

    őstag

    válasz blemidon #9 üzenetére

    mostmár igen.

    én azt olvastam, eleinte csak ezt a dologot akarta kipróbálni, akkor volt új...
    aztán csöppet eldurvult az ügy. :))
    de a v0.1-es linux még minden volt csak oprendszer nem.
    állítólag csak Linus XT-jén futott valami csoda folytán... :)

    I'm back, baby!

  • g4dg3t

    senior tag

    válasz RedAnt #1 üzenetére

    HeLLa!

    Halvanyak az emlekeim, de vmi meg remlik :)
    Igen a GDT-t meg belepes elott kell inicializalni, de elotte illik leellenorizni hogy legalabb 386-os procrol van-e szo, es hogy esetleg vedett modban vagyunk-e mar (OS fejlesztesnel utobbit nem szukseges...)! A szegmensregiszterek vedett modban a szelektorokat tartalmazzak, ezek pedig a deszkriptorokat mutatjak...es vegul a deszkriptor fogja meghatarozni a szegmenst!

    Udv Gadget.

  • blemidon

    tag

    válasz g4dg3t #12 üzenetére

    286on is volt protected mode, kemény 16M ramot bírt benne cimezni 24 biten (de ezt is csak max 64K szegmensekkel) az 1M szegmentált helyett helyett amit realba:) De rendes 32bit PM tényleg csak 386tól van, úgyhogy arra illik fejleszteni minimum

  • Miracle

    senior tag

    válasz escie #11 üzenetére

    eleinte minix-pótló volt a linux. linus meg egy jó értelemben vett őrült. (nincs jó OS, hát ír egyet)

    re: topic:
    ajánlom ezt a könyvet :
    http://www.kiskapu.hu/main.php?SHOW_BODY=termekinfo&TERMEKINFO_ID=1805801
    ebben elvileg egy jórészt C és ASM nyelvű oprendszer elkészül a könyv végére, meg van rajta minix forrás. bár még nem olvastam, de tervbe van véve, meg rosszat még nem hallottam róla.

    meg van két magyar ''projekt'', amiről hallottam: a NAX, meg a FOS, azoknak is érdemes utánanézni.

    ja, és sok sikert!

    értelmező késziszótár :: rekurzió --> lásd : rekurzió

  • WN31RD

    addikt

    válasz RedAnt #1 üzenetére

    Hacsak nem valami nagyon speciális beágyazott rendszert akarsz csinálni, a legnagyobb problémád nem a védett mód, hanem az eszközvezérlők (driverek) megírása lesz.
    Vannak már egyébként egész jó operációs rendszerek, mielőtt egy ilyen projectbe fognál, gondold át, nem lenne-e megoldható a feladat valamelyik már létezővel, pl.: Linux, FreeBSD, NetBSD, OpenBSD, QNX, eCos, BeOS, stb., ezek csak amik hirtelen eszembe jutottak.
    Persze ha csak tanulgatni szeretnéd a védett módot/assembly programozást, az más. Ajánlom a korábban említettek mellé még a CWSDPMI nevő DPMI szerver + a DJGPP projectben levő programindító ''stub'' forráskódjának a tanulmányozását is, és esetleg a PMODE 3.07 is érdekes lehet.

    [Szerkesztve]

    ''... we as consumers want our content free (as in Freedom) and if we don't get it, we'll take our content free (as in beer).''

  • blemidon

    tag

    válasz WN31RD #15 üzenetére

    Közben körülnéztem:
    [L]http://www.programmersheaven.com[/L]
    Az assembly szekcióba vannak jókis példák hogy védett módba lépés meg minden.

  • WN31RD

    addikt

    válasz WN31RD #15 üzenetére

    No meg egy operációs rendszer nem csak abból áll, hogy védett mód, sőt, ez nem is elengedhetetlen feltétele. Vannak még olyan apróságok, mint memóriakezelés, processzkezelés, IPC, filerendszerek, hogy csak a legalapvetőbbeket említsem.
    Mielőtt ennyire nagy fába vágnád a fejszéd, nézz utána, hogy mire vállalkozol. A Tanenbaum-féle ''Operációs rendszerek'' c. könyv pl. egész jó áttekintés, forráskóddal, működő példa-oprendszerrel (Minix).

    ''... we as consumers want our content free (as in Freedom) and if we don't get it, we'll take our content free (as in beer).''

  • kisfurko

    aktív tag

    Ne ijesszétek már el...
    Én írtam egy DOS extendert segítség nélkül (van beépített debuggere is, de az nem lesz kész már soha :D), szóval csak kitartás kell.

    Először is le kell tiltani minden megszakítást. Utána létre kell hozni a GDT-t, IDT-t, egy TSS-t (ha nem csak 0-ás privilégium szinten akarsz szüttyögni), ezeket betölteni a megfelelő regiszterekbe. A GDT-ben minimum kell egy kód és egy adat szegmens leírója, ha nem csak 0-ás p. szint van, akkor kell még egy-egy ezekből megfelelő jogosultságokkal. Az IDT-ben kell a megszakításoknak (mind a 16-nak) és az exception-öknek bejegyzés. Ha BIOS-t is akarsz használni, akkor nem árt egy int vagy call gate, amivel hívhatod virtual 86 módban a valós kódokat. Ha kultúrált vagy, akkor csinálsz LDT-t is (ez egy bejegyzés a GDT-ben) és betöltöd azt is a megfelelő regiszterbe. Ajánlatos még átprogramozni a PIC-eket, hogy ne olyan kretén helyeken jöjjenek az interruptok (ne ütközzön például a GP Fault-tal a HDD). A GDT, IDT, TSS (szóval ezek a táblák nyugodtan lehetnek data sorokban, csak a bázisukat kell számítani, kivéve, ha mindig ugyanoda rakod).
    Kérdezz nyugodtan, sajnos forrást most nem tudok bemásolni, mert nincs bekötve az első, szeretett, kicsi HDD-m, de ha kell, akkor szívesen megteszem, remélem még működik.
    Sokat szoptam a témával, jelentősen lerövidítheti a fejlesztési idődet a segítség (mert okos intelék nem írnak le ám mindent...:(). Még az a szerencséd is megvan, hogy teljesen dokumentáltam, hogy később is megértsem.

    Szerk: úgyis kihagytam valamit, ha kell még a segítség, szólj!

    [Szerkesztve]

  • kisfurko

    aktív tag

    válasz WN31RD #17 üzenetére

    Baromira attól függ a bonyolultság, hogy mire akarja használni. Sima memóriakezelés nem nagy ügy, a processzkezelés sem (ha egyáltalán multitaszk kell neki), de ez nem is lényeg. Gondolj egy C64-re például, abban nem volt se memóriakezelés (jó, a BASIC interpreter kezelte a sajátját), se processzkezelés, se IPC, mégis jól lehetett használni.
    Én is akartam saját operációs rendszert írni, de letettem róla, mert nem adnak ki elég információt a hardware-ekről. Meg azért is hagytam abba, mert a PC-vel ilyen szinten nem érdemes foglalkozni, diliházban végeztem volna az apró idiótaságok miatt. :DD
    De ameddig irogattam az extendert (az első lépés a védett módhoz), addig baromira élveztem, nagyon sokat tanultam, szinte kívülről fújom az x86 architektúrát.
    Egyszerűen csodálatos volt, amikor működött a V86 mód :))

  • RedAnt

    aktív tag

    Na, ujra itt vagyok!
    Vegigolvastam az eddigi hozzaszolasokat, hat nagyon koszonom!
    Csak az a baj hogy most epp Angliaban vagyok es nem tudom kiprobalni :(

    A Minixes konyv megvan nekem, csak az a bajom, hogy pont az egesz dolog legelejet hagytak ki belole, szoval pl. a bootolas gyakorlatat. Szoval az egeszet akkor tudtam elkezdeni amikor valami regi konyvben raakadtam hogy a bootszektor vegere kell hogy 55AA, meg egy baratom elmondta hogy kell floppy imageot kiirni.
    Szoval en foleg gyakorlati szempontbol nezem az egeszet, nem azert probalkozom hogy irjak egy hiperszuper OSt, ami minden eddigin tultesz, hanem hogy irjak valami gagyit magamnak, de azt teljesen en.
    Real modban mar egesz jol elszorakoztam, mar kitalaltam egy filerendszert is:
    1 floppy 1 file! :D Nem bonyolitom tul... :D Memoriakezelessel sem kell sokat bajlodni: mivel nincsenek felhasznaloi programok ( :) ), eleg az oprendszernek biztositani a helyet. Emiatt szerintem pmodeban is eleg lesz 1 privilegiumszint :)

    Ja es dos4gw-t meg pmodew-t es hasonlo DOS extendereket nem hasznalok, mivel mindent az alapoktol kell! Mar parszor feladtam, de neha unatkozom :)

    Szerintem a NASM a legjobb assembler, azzal forditgatok binarisba!
    Mar probalkoztam a gepi koddal, de az agyhalal!

    Na nemsokara hazamegyek aztan probalkozom! :DD Ha valakinek van meg otlete, varom ide!

    ╚╦╦╦

  • kisfurko

    aktív tag

    válasz RedAnt #20 üzenetére

    ''Emiatt szerintem pmodeban is eleg lesz 1 privilegiumszint''
    Azért ajánlanám a két szintet, mert ha stack hiba van (ami igen gyakori), akkor triple fault miatt reset a vége, és ekkor nem tudod, hol a hiba. Úgy célszerű csinálni, hogy először legyen meg a megfelelő IDT az exception-ök lekezeléséhez. Ezt úgy érdemes csinálni, hogy mondjuk:

    exception1:
    push 1
    jmp exceptionhandler
    exception2:
    push 2
    ...

    exceptionhandler:
    kiírni a CS:EIP-t, a regisztereket, meg egyéb dolgokat, amik jólesnek...:))

    Az IDT-be meg szépen beírkálod a címeket.
    Meg tanulásnak sem rossz a több privilégiumszint. Mert ahhoz kell a TSS (ami a V86-hoz is kell).
    Különben protected mode-ba lépni gyerekjáték, de hogy interaktív programot csináljál... Persze könnyen írhatsz egy billentyűkezelő interruptot pufferrel, meg egy karakterkiíró rutint, ami 0b8000h-tól rakja be a karaktereket (ilyet is csináltam, hogy a debugger csak maga fusson, minden segédrutin nélkül, így BIOS-t is lehet vele lépésről lépésre futtatni). Én inkább csináltam V86-os futtatást, hogy simán használhassam a BIOS rutinokat (meg esetleg a DOS-t).

    A NASM pedig tényleg jó, én megszokásból használtam tasm-ot.
    Igazából assemblert is akartam írni, meg linkert, talán egyszer még előveszem a ''project''-et :) Csak mostanság a 3D grafikával foglalkozom.
    Szóval, ha kell segítség, akkor nyugodtan szólj!

    [Szerkesztve]

  • OddMan

    őstag

    Éppen egy boot progit csinálok, amivel egy nagyon egyszerű kernelt szeretnék majd elindítani floppy lemezről, de nem tudom, hogy a floppy lemez melyik szektorára mit kell írni.
    Az első 512 byte az MBR ide kerül a boot progim, amit sikerült is elhelyeznem a <B>debug boot.exe 100 0 0 1</B> paranccsal. Viszont azt nem tudom, hogy a köv szektorok hogyan vannak. Szal gondolom ez után kell lenni valahol a 12bit-es fat táblának és utána kéne lennie valahol a mini kernelemnek ugye? Az egész kernel kezdeményt meg boot progit egyelőre csak 16bit-es és valós módban írtam meg.
    A másik dolog amit észrevettem, hogy a lemezre amire kiírom a debug-al a boot sectort, többet nem tudom megnézni a tartalmát. Ez mitől lehet? :F

    Tegnap linux-ban a dd parancsal megnéztem egy NTFS filerendszerű driveot, aminél az első 512 byte volt a boot sector és utána majdnem 32Kb-os területen keresztül csak 00 byte-ok voltak, utána jött az első partició boot sectora. Ebből arra következtetek, hogy minden filerendszernél máshogyan kell majd betölteni a boot filet ugye? ?F

    ''A szíved szabad! Légy bátor és kövesd!''

  • OddMan

    őstag

    válasz OddMan #22 üzenetére

    Közben rájöttem, hogy miért nem látom a floppy tartalmát.

    000h 446 Machine Code and Associated Data.
    1BEh 16 Partition 1 Information. //ezek a byte-ok nálam végig nullák. Ez volt a baj szerintem.
    1CEh 16 Partition 2 Information.
    1DEh 16 Partition 3 Information.
    1EEh 16 Partition 4 Information.
    1FEh 2 Boot Signature AA55h.

    Szal az első 446 byte a boot code és a következő 4x16 byte pedig a particíós táblák elhelyezkedése mérete és a boot flag állapota van itt tárolva.
    Aztán jön a lezáró AA55h .

    Láttam egy kódot a nasm-hoz a neten, de valamit nem értek benne.
    iderakom:

    ; 3.ASM
    ; Load a program off the disk and jump to it

    ; Tell the compiler that this is offset 0.
    ; It isn't offset 0, but it will be after the jump.
    [ORG 0]

    jmp 07C0h:start ; Goto segment 07C0 ;Ezt az első ugrást nem értem. ha elugrik a 07C00h:start címre, akkor ott nincsen semmi. A következő code sorok már nem tudnak lefutni, mivel azok a 00000:0000 címre lettek betöltve vagy nem? Szal szerintem ez így nem múködik. Valki segítsen!

    start:
    .|. the segment registers
    mov ax, cs
    mov ds, ax
    mov es, ax


    reset: ; Reset the floppy drive
    mov ax, 0 ;
    mov dl, 0 ; Drive=0 (=A)
    int 16h ;
    jc reset ; ERROR => reset again


    read:
    mov ax, 1000h ; ES:BX = 1000:0000
    mov es, ax ;
    mov bx, 0 ;

    mov ah, 2 ; Load disk data to ES:BX
    mov al, 5 ; Load 5 sectors
    mov ch, 0 ; Cylinder=0
    mov cl, 2 ; Sector=2
    mov dh, 0 ; Head=0
    mov dl, 0 ; Drive=0
    int 13h ; Read!

    jc read ; ERROR => Try again


    jmp 1000h:0000 ; Jump to the program


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

    ''A szíved szabad! Légy bátor és kövesd!''

  • kisfurko

    aktív tag

    válasz OddMan #22 üzenetére

    Floppynál nincs MBR, az csak HDD-n van. Az MBR-ben a partíciók leírásai, és a boot szektor betöltője van. Igazából mindegy, mert fogja, betölti az első szektort, majd futtatja. Semmi másra nincs szükség, a FAT az a DOS része. Oda rakod a kerneled, ahová jólesik, neked kell betöltened a boot szektorbeli kóddal.
    Azért nem látja a lemez tartalmát, mert számára ismeretlen a formátum.
    Megszokásból csak a második sávon kezdik az adatokat, az első sávon csak a boot szektor van (HDD esetén MBR).

  • kisfurko

    aktív tag

    válasz OddMan #23 üzenetére

    Úgy van megcsinálva az MBR, hogy a 0:7c00 címre tölti a boot szektort. Ezért ugrik a 07c0:start címre.
    Legegyszerűbb, ha olyan kódot írsz, ami relokálható (csak relativ címzések vannak benne), s akkor le van tojva, hova töltötték be a kódodat.

  • Flashy

    veterán

    eldöntheted hogy valamilyen létező filerendszert használsz, ami ilyen próbálgatásnál macerás, vagy egyszerűen felülírod az első szektort és úgy kezeled a floppyt ahogy akarod. ilyenkor nem fogod tudni olvasni más progival, de nem kell filerendszerrel bajlódnod.

  • OddMan

    őstag

    Köszi mindenkinek a segítséget. Sikerült bootolnom és elindítani egy nagyon egyszerű saját kernel kezdeményt.
    Lenne még egy kis problémám. Valós módban hogyan kell használni a jmp far parancsot? Szal arra gondoltam, hogy a progimat az 1MB-on belül a F0000h címre szeretném betölteni és aztán ráadni a vezérlét a jmp far 0F0000h:0 paranccsal, de a nasm valamiért állandóan hibát ír ki. Távoli ugrást még sosem használtam ezért nem ismerem a parancs működését.

    A neten láttam egy példát, de nekem az sem működik jól.
    Iderakom egy részletét egy kicsit átírva, ahogy nekem kéne.

    section .text

    jmp far [OS32ADDR]

    section .data

    OS32ADDR: dw 0 ;IP
    dw 0F000 ;CS

    ;CS:IP = 0F000:0

    ''A szíved szabad! Légy bátor és kövesd!''

  • OddMan

    őstag

    válasz OddMan #27 üzenetére

    Még van egy-két kérdésem, ezeket ti már biztosan tudjátok.
    Elkezdtem tanulmányozni a védett módot. Sajnos a megszakítások és kivételek kezelése rész eléggé homályos számomra. Kivételkezelés valós módban nem volt. Nos akkor amit nem tudok, hogy mi az a minimum 16 kivétel amit az IDT-be fell kell vennem? Tudtok valami doksit, ahol van erről leírás? A köv. kérdésem, hogy, védett módban az int xxh parancsot már nem lehet használni ugye? Tehát a bios-t el lehet felejteni?

    A GDT-vel kapcsolatban még annyit szeretnék kérdezni, hogy idézet:
    ''szóval ezek a táblák nyugodtan lehetnek data sorokban, csak a bázisukat kell számítani, kivéve, ha mindig ugyanoda rakod).''
    Hogyan kell a bázist számolni és miért kell? Ez még valós módban történik ugye?

    Érdekelne a sorrend is, hogyan kezdjek egy védett modú asm progit:
    -Na először is én ellenőrzöm a proc típusát.
    -Utána a GDT fizikai címmé alakítása aztán a GDT beállítása az lgdt src paranccsal. A GDT struktúráját is elkészítettem.
    -A CR0 PE bitjének 1-be állításával védett módba kapcsolok.
    -A szegmens regiszterekbe betöltöm a kívánt szelektorokat.

    Ha egyenlőre nem akarok taszkokat és egyéb nyalánkságot, akkor érdemes egy 4GB-os code és egy data szegmens deszkriptor-t használni?

    Talán egyelőre ennyi. :DD
    Előre is nagyon köszi a segítséget! :U
    Ha valaki tud olyan helyet, ahol még lehet kapni a Dr. Kovács Magda 80386 I. és 80386/80486 II. című könyvét, az legyen szíves írja ide a bolt címét. :F

    ''A szíved szabad! Légy bátor és kövesd!''

  • kisfurko

    aktív tag

    válasz OddMan #27 üzenetére

    Hát....
    Ne tedd 0f0000h-ra a programod, mert ott a BIOS van...:D
    A jmp far-t heggeszteni kell:
    db 0eah ;ez a jmp far abszolut címre kódja
    dw uj_ip,uj_cs
    Értelemszerűen, az IP legyen 32 bites, ha 32 bites kód fut.

  • kisfurko

    aktív tag

    válasz OddMan #28 üzenetére

    Én úgy tudom, hogy az első 32 int vektor van lefoglalva. Itt [L]http://www.intel.com/design/Pentium4/documentation.htm?iid=ipp_dlc_procp4f+tech_doc

  • OddMan

    őstag

    válasz kisfurko #30 üzenetére

    Nagyon köszi, hogy segítesz.

    ''Ne tedd 0f0000h-ra a programod, mert ott a BIOS van...''
    Szereztem egy valós modú memória térképet, és most már tudom, hogy hova lehet töltögetni.

    ''A jmp far-t heggeszteni kell:
    db 0eah ;ez a jmp far abszolut címre kódja
    dw uj_ip,uj_cs
    Értelemszerűen, az IP legyen 32 bites, ha 32 bites kód fut.''
    Na a nasm-ban a ''jmp dword cs:ip'' 32bit-es és ''jmp word cs:ip'' 16bit-es far ugrás.
    Megnéztem az exe-t hexa editorral és úgy néz ki, hogy a nasm jól fordítja le ezeket az utasításokat. Te próbáltad már a nasm-ot? Mert ha mégsem fordítja jól, akkor az álltalad írt gépikód formát fogom használni. Meg gondolom bizonyos esetekben kell a 66h prefix, amikor a szegmens 16bit-es az utasítás meg 32bit-es.

    Más:
    Azt értem, hogy az lgdt utasításnak fizikai cím kell, de azt már nem, hogyan kell azt megkapni.

    mov eax, ds
    shl eax, 4 ;ezt nem értem, hogyha 4-el balra léptetem a biteket, akkor mitől lesz az a fizikai címe a DS-nek? :F
    add [GDT_ptr+2], eax
    lgdt [GDT_ptr] ;Load the GDT


    GDT_addr:
    ;;0. descriptor
    NULL_SEL equ $-GDT_addr
    dw 0
    dw 0
    db 0
    db 0
    db 0
    db 0

    ;;1. descriptor (code segment 1MB 0-nál kezdődik)
    CODE16_SEL equ $-GDT_addr
    dw 0FFFFh ;a szegmens hosszának alsó wordja (határ)
    dw 0 ;a báziscím alsó wordje
    db 0 ;a báziscím felső wordjének alsó bájtja
    db 10011010b ;P=1, DPL=00, S=1, C/D=1, C/E=0, R/W=1, A=0
    db 00001111b ;G=0, D/B=0, AVL=0, reserved=0, határ=1111
    db 0 ;a báziscím felső wordjének felső bájtja

    ;;2. descriptor (data segment 1MB 0-nál kezdődik)
    DATA16_SEL equ $-GDT_addr
    dw 0FFFFh ;a szegmens hosszának alsó wordja (határ)
    dw 0 ;a báziscím alsó wordje
    db 0 ;a báziscím felső wordjének alsó bájtja
    db 10010010b ;P=1, DPL=00, S=1, C/D=0, C/E=0, R/W=1, A=0
    db 00001111b ;G=0, D/B=1, AVL=0, reserved=0, határ=1111
    db 0 ;a báziscím felső wordjének felső bájtja

    ;;3. descriptor (code segment 1MB 0-nál kezdődik)
    CODE32_SEL equ $-GDT_addr
    dw 0FFFFh ;a szegmens hosszának alsó wordja (határ)
    dw 0 ;a báziscím alsó wordje
    db 0 ;a báziscím felső wordjének alsó bájtja
    db 10011010b ;P=1, DPL=00, S=1, C/D=1, C/E=0, R/W=1, A=0
    db 01001111b ;G=0, D/B=1, AVL=0, reserved=0, határ=1111
    db 0 ;a báziscím felső wordjének felső bájtja

    ;;4. descriptor (data segment 1MB 0-nál kezdődik)
    DATA32_SEL equ $-GDT_addr
    dw 0FFFFh ;a szegmens hosszának alsó wordja (határ)
    dw 0 ;a báziscím alsó wordje
    db 0 ;a báziscím felső wordjének alsó bájtja
    db 10010010b ;P=1, DPL=00, S=1, C/D=0, C/E=0, R/W=1, A=0
    db 01001111b ;G=0, D/B=1, AVL=0, reserved=0, határ=1111
    db 0 ;a báziscím felső wordjének felső bájtja

    ;;5. deszkriptor (stack segment 8Kb 200000h-nál kezdődik)
    STACK_SEL equ $-GDT_addr
    dw 02000h ;a szegmens hosszának alsó wordja (határ)
    dw 0 ;a báziscím alsó wordje
    db 20h ;a báziscím felső wordjének alsó bájtja
    db 10010010b ;P=1, DPL=00, S=1, C/D=0, C/E=0, R/W=1, A=0
    db 01000000b ;G=0, D/B=1, AVL=0, reserved=0, határ=0000
    db 0 ;a báziscím felső wordjének felső bájtja

    ;;6. deszkriptor (screen segment 16Kb 0B8000h-nál kezdődik)
    SCREEN_SEL equ $-GDT_addr
    dw 04000h ;a szegmens hosszának alsó wordja (határ)
    dw 08000h ;a báziscím alsó wordje
    db 0Bh ;a báziscím felső wordjének alsó bájtja
    db 10010010b ;P=1, DPL=00, S=1, C/D=0, C/E=0, R/W=1, A=0
    db 01000000b ;G=0, D/B=1, AVL=0, reserved=0, határ=0000
    db 0 ;a báziscím felső wordjének felső bájtja
    GDT_end:

    GDT_ptr:
    dw GDT_end-GDT_addr ;GDT mérete
    dd GDT_addr ;GDT címe

    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

    A segmenseim határai csak 1MB, mert úgysem kell egyelőre több.
    Egyébként én most kezdetnek egy olyan progit írok, amely dos alatt átkapcsol védett módba majd vissza. Amíg ez nem megy, addig nem megyek tovább.
    Előre is köszi a válaszokat. :U

    ''A szíved szabad! Légy bátor és kövesd!''

  • OddMan

    őstag

    válasz OddMan #31 üzenetére

    Huh most esett le a hogyan kell fizikai címet csinálni kérdésem.

    mov eax, ds
    shl eax, 4 ;ezt nem értem, hogyha 4-el balra léptetem a biteket, akkor mitől lesz az a fizikai címe a DS-nek?

    Tehát azért, mert a DS csak 16bit-es és mindig utána kell képzelni még 4db 0-ás bitet. Így ha balra léptetem 4-el, akkor az eax-be már a 20 bites fizikai cím lesz. Aztán azt meg csak hozzá kell adni a GDT_addr relatív címéhez és így már tényleg a GDT_addr változóban az igazi fizikai cím szerepel, ugye? :DD

    ''A szíved szabad! Légy bátor és kövesd!''

  • kisfurko

    aktív tag

    válasz OddMan #31 üzenetére

    ''Na a nasm-ban a ''jmp dword cs:ip'' 32bit-es és ''jmp word cs:ip'' 16bit-es far ugrás.
    Megnéztem az exe-t hexa editorral és úgy néz ki, hogy a nasm jól fordítja le ezeket az utasításokat. Te próbáltad már a nasm-ot? Mert ha mégsem fordítja jól, akkor az álltalad írt gépikód formát fogom használni. Meg gondolom bizonyos esetekben kell a 66h prefix, amikor a szegmens 16bit-es az utasítás meg 32bit-es.''

    Még nem nasm-oztam, mert mindent meg tudtam oldani tasm alatt, és át kellett volna szoknom. Egyszer olvastam végig a doksiját, és nem sokra emlékszem...

    Na, megnéztem amit küldtél, de szerintem semmi probléma. Hogyan futtatod? Ugye nem debuggerben? Mivel nem használod a GDT-t (mert nincs szegmens betöltés), ezért azzal még nem kell foglalkozni. Van valami memory manager (qemm, emm386 stb.) bent a memóriában? És honnan tudod, hogy pontosan hol szállt el? Valami emulátorból próbálkozol?

    [Szerkesztve]

  • OddMan

    őstag

    válasz kisfurko #33 üzenetére

    ''Hogyan futtatod? Ugye nem debuggerben?'' :B De, azért nem ment!
    A Turbo debugger-ben akartam futtatni azért fagyott le az egész.
    Találtam a neten egy teljesen ingyenes dos emulátort a neve DOSBox-0.61 és abban teljesen tökéletesen működik. Egyébként rendes MS-DOS alatt is működik. Létezik egyáltalán olyan debugger, amit lehetne használni? :F

    Írtam védett módban egy olyan kiíró rutint, amivel az összes regiszter értékét hexában ki tudom írni a képernyőre. A kérdésem, hogy hogyan kell beállítani az IDT, hogy ha kivétel történik, akkor fusson le ez a kis rutin, hogy lássam hol száll el a program, ha már debuggolni nem tudok. :U

    ''A szíved szabad! Légy bátor és kövesd!''

  • kisfurko

    aktív tag

    válasz OddMan #34 üzenetére

    ''Létezik egyáltalán olyan debugger, amit lehetne használni?''
    A probléma ott van, hogy védett módba csak valós módból lehet átkapcsolni, így csak olyan debuggert használhatsz, ami valós módú. De mivel átkapcsolsz, a szegmens regiszterek új értelmet nyernek, azokhoz kellene a megfelelő GDT stb. Ráadásul az interruptokat is engedélyezi (hiába volt cli, az csak virtuálisan, a programod szempontjából érvényes). A turbo debugger meg amúgy is elég béna (kicsi, valós módú programokhoz jó).
    Én úgy csináltam, hogy stack-re mentettem az engem érdeklő regiszetereket, majd vissza valós módba, ott pedig szépen, kényelmesen kibányásztam a védett módú stack helyéről a számokat.
    Az IDT az egy nagy tömb, felépítését tekintve olyan, mint a GDT. Ugyanúgy kell beállítani, mint a GDT-t (lidt). A bejegyzések szintén 8 byte-osak. Egy bejegyzés így néz ki:

    dw offszet also 16 bitje
    dw szelektor
    db 0 ; ez igazabol csak 5 bites, ez azt mondja meg, hogy call gate eseten hany dwordot (wordot) kell a ket kulonbozo szint verme kozott masolni (mert minden szintnek sajat verme van)
    db 0 ; a tipust es a priv. szintet adja meg, ugyanugy mint egy deszkriptornal. A tipus ertekei a kovetkezok lehetnek:
    ; 4 286 call gate
    ; 5 386 task gate
    ; 6 286 interrupt gate
    ; 7 286 trap gate
    ; 12 386 call gate
    ; 14 386 int gate
    ; 15 386 trap gate
    dw 0 ; offszet felso 16 bitje

    Szóval, baromira hasonló, de itt nem bázis és határ van, hanem szelektor és offszet. Ez a címe a kiszolgáló rutinnak, ide ugrik, a valós módban csak szelektor és offszet van pl. A típust állítsd interrupt gate-re (14)!

    A kivételek listája:

    0 osztás hiba
    1 debug trap
    2 NMI
    3 int3 utasítás
    4 into utasítás
    5 bound hiba
    6 érvénytelen utasítás
    7 device not available (taszkváltásnál kell, vagy koprocesszor emulációnál)
    8 double fault (hiba amikor éppen hibát szolgálsz ki)
    10 érvénytelen TSS
    11 szegmens nem aktív (a P bitje 0)
    12 stack hiba
    13 általános hiba (ez kell nagyon :DD)
    14 lapozási hiba
    16 FPU hiba
    Meg még van egy pár, de ezek a legfontosabbak. A 9-es és 15-ös nem maradt ki, az nincs. A legegyszerűbb, ha csinálsz egy 32 elemű IDT-t, az lefedi az összes (akár jövőbeni) kivételt. Ahogy ajánlottam feljebb, az összes rutin csak annyi, hogy beteszed a számát a kivételnek a verembe, majd ugrasz a közös rutinra. Érdemes a verembe piszmogni, mert amikor a kiszolgálóra jut a vezérlés, akkor csak az ''áll készen'', hiszen a szegmens regiszterek ismeretlen értéket tartalmaznak (és a CS nem írható). Vagy benyomatod a verembe a DS-t, majd szabad a pálya. Mindenképpen 0-ás priv. szint kell a kiszolgáláshoz (természetesen a cél CS-nek is 0-ás szintűnek kell lennie)! Persze az int3, into lehet alacsonyabb szinten, ott azt jelenti, hogy melyik a legalacsonyabb szint, ahol végrehajtható az utasítás.

    Van még egy lényeges dolog. Lehet, hogy tudsz róla, lehet, hogy nem. Amikor átváltasz másik módba, akkor a szegmensek megőrzik a régi tartalmukat. De itt ne csak a számra gondolj, amit betöltöttél, hanem azokra az értékekre, amit a deszkriptorban állítani tudsz (valós módban is ugyanúgy működik a határ ellenőrzés pl.). Hogy ez ne okozzon gondot, átváltás után szükség van egy szegmensközi ugrásra (far jmp pl.). Ha vissza is akarsz váltani, akkor szükséged lesz egy olyan deszkriptorra, ami egy valós módú szegmenst ír le. 64k-s határral, 16 bites móddal, 0-ás priv. szinttel. Lehet, hogy a fajtáját is be kell állítani, már nem emlékszem, hogy én hogyan csináltam.
    Kiváncsian várom a fejleményeket!

  • eddie303

    őstag

    ügyesek vagytok gyerekek, ha lesz belõle bármilyen müködõ oprendszer, igényelek belõle tesztpéldányt :) Már ha ingyenes lesz, tudjátok, oprendszergyüjtés mániám van :)

    Linux.... The choice of a GNU generation.

  • OddMan

    őstag

    válasz kisfurko #35 üzenetére

    Na sikerült a kivételkezelés is. :DD Most egy TSS-t szeretnék létrehozni, ami nem a 0-ás privilégium szinten futna. A másik dolog, amin most gondolkodom, hogy szeretném az egész progit átírni C-be. Szal az is tele lenne asm betétekkel, de lennének függvények meg struktúrák, használhatnék ciklusokat feltételeket stb.
    A kérdésem, hogy szerinted ezt, mibe lehetne megcsinálni? Eddig a Mingw-t és a DJGPP fejlesztő környezeteket nézegettem. Ezekkel lehetne a.out, COFF, ELF formátumú fájlokat készíteni, amiket a GRUB loader képes betölteni. Ennek az lenne az előnye, hogy a GRUB már maga védett módba kapcsolja gépet, és egy csomó információt átadhat az induló kernelnek. Egyébként azt néztem, hogy a GRUB az 1MB fölé teszi a kernelt, tehát fixen be lehetne írni a GDT-be a báziscímeket is. Nem kell számolgatni, hogy éppen hol van a kernel. Aztán C-ben már könnyedén lehetne írni saját függvényeket, amelyek kezelnék a képernyőt, billentyűt, időzítőt stb. :U Nem akarok C könyvtári függvényeket használni, csak magát a C-t, és így egy tényleg szép strukturált kódot lehetne írni, ami tele van assembly-vel, de mégis strukturált ás átlátható. :t

    ''A szíved szabad! Légy bátor és kövesd!''

  • OddMan

    őstag

    Egy aprócska asm kérdés:

    Van különbség a kettő között?

    azonosito dd 1000h
    azonosito: dd 1000h

    A kettőspontot '':'' valahol kiteszik valahol pedig nem.
    Mit jelent a kettőspont pontosan? :F

    ''A szíved szabad! Légy bátor és kövesd!''

  • kisfurko

    aktív tag

    válasz OddMan #38 üzenetére

    Nincs különbség, csak egyes nyomorék assemblerek kettősponttal viszik csak.
    Majd válaszolok a többire is, de egyelőre nincs időm, ne haragudj.

  • OddMan

    őstag

    válasz kisfurko #39 üzenetére

    Oké, köszke! :DD

    ''A szíved szabad! Légy bátor és kövesd!''

  • kisfurko

    aktív tag

    válasz OddMan #37 üzenetére

    ''Most egy TSS-t szeretnék létrehozni, ami nem a 0-ás privilégium szinten futna.''
    Ezt nem értem...:)
    A TSS ahhoz kell, hogy mindenféle járulékos információt a taszkkal kapcsolatban tárolni tudjon a proci (Task State Segment). Itt tárolódik például az összes stack címe, vagy taszkváltáskor a regiszterek tartalma, de az I/O permission bitmap is (a V86 módnak). Tehát, ha akarsz 0-ás priv. szinten kívül más szintet, akkor kell egy TSS. A szükséges priv. szint stack mutatóit be kell állítani benne, majd a deszkriptor táblában létre kell hozni egy TSS bejegyzést, és ezt a címet (mint akár egy szegmens címét) be kell tölteni, csak nem egy szegmens regiszterbe, hanem a Task Register-be (pl. mov ax,TSS_SEG ltr ax). Ha nincs szükség az I/O permission bitmap-re, akkor állítsd a kezdetét a TSS határán túlra.
    A C-s dologhoz sajnos nem tudok semmit tanácsolni, én csak full assemblyben csináltam mindent. Ezt a GRUB-os dolgot említették sokan, biztos jó. :DD

Aktív témák