Ha a lényegre térünk...

Az operációs rendszer olyan dolog, amely (általában) multitaskingot valósít meg, és kezeli az erőforrások elosztását ezen feladatok között és általában. Gondoskodnia kell arról, hogy a feladatok ne károsíthassák egymást, és a memória különböző területein működjenek, és felváltva működjenek együtt az eszközökkel, legalábbis ez. Lehetőséget kell biztosítani arra is, hogy üzeneteket továbbítson egyik feladatból a másikba.

Ezenkívül az operációs rendszernek, ha van hosszú távú memória, hozzáférést kell biztosítania hozzá: azaz biztosítania kell a fájlrendszerrel való munkavégzéshez szükséges összes funkciót. Ez a minimum.

Szinte mindenhol a legelső rendszerindító kódot assembly nyelven kell megírni - egy csomó szabály van arra vonatkozóan, hogy hol kell lennie, hogyan kell kinéznie, mit kell tennie, és mekkora méretet nem szabad túllépnie.

PC-hez írnod ​​kell egy rendszerbetöltőt az ASMA-n, amelyet a BIOS hív meg, és amelynek négy és néhány száz bájt túllépése nélkül kell valamit tennie, és elindítani a fő operációs rendszert - át kell adnia a vezérlést a fő kódra, amely a közeljövő C-ben írható.

Az ARM-hez létre kell hozni egy megszakítási táblát az ACMA-n (reset, különféle hibák, IRQ, FIQ megszakítások stb.), és át kell adni a vezérlést a fő kódra. Bár sok fejlesztői környezetben ilyen kód szinte minden vezérlőhöz elérhető.

Vagyis ehhez kell:

1. Ismerje a célplatform assembler nyelvét.
2. Ismerje a processzor architektúráját és mindenféle szolgáltatási parancsot és regisztert, hogy be tudja állítani, hogy működjön kívánt módot. PC-n ez átmenet például védett módba, vagy 64 bites módba... ARM-ben ez a mag és a perifériák órajelének beállítása.
3. Pontosan tudja, hogyan indul el az operációs rendszer, hol és hogyan kell lenyomnia a kódot.
4. Ismerje a C nyelvet - tapasztalat nélkül nehéz nagy kódot írni Asmában, karbantartása még nehezebb lesz. Ezért a kernelt C-ben kell írni.
5. Ismerje az operációs rendszer működési elveit. Nos, sok orosz nyelvű könyv van erről a témáról, bár nem tudom, hogy mindegyik jó-e.
6. Sok-sok türelmet és kitartást. Lesznek hibák, ezeket meg kell találni és ki kell javítani. Sokat kell majd olvasnod is.
7. Legyen sok-sok időd.

Következő. Tegyük fel, hogy írtál valamit. Tesztelnünk kell ezt a dolgot. Vagy kell egy fizikai eszköz, amelyen a kísérletek történnek (debug board, második számítógép), vagy egy emulátor hozzá. A második általában könnyebben és gyorsabban használható. PC-hez például VMWare.

Az interneten is rengeteg cikk található ebben a témában, ha jól keresel. Számos példa van forráskóddal rendelkező, kész operációs rendszerre is.

Akár az NT rendszerek (Windows) régi kernelének forráskódját is megtekintheti, ha nagyon akarja, külön-külön (melyet a Microsoft tett közzé, megjegyzésekkel és különféle referenciaanyagokkal), és a régivel együtt. OS (kiszivárgott).

Útmutató kernel létrehozásához x86 rendszerhez. 1. rész. Csak a mag

Írjunk egy egyszerű kernelt, amely a GRUB rendszerbetöltővel indítható x86 rendszeren. Ez a kernel üzenetet jelenít meg a képernyőn, és vár.

Hogyan indul az x86 rendszer?

Mielőtt elkezdenénk írni a rendszermagot, ismerjük meg, hogyan indul el a rendszer, és hogyan adja át a vezérlést a kernelnek.

A legtöbb processzorregiszter már indításkor tartalmaz bizonyos értékeket. Az utasítások címére mutató regiszter (Instruction Pointer, EIP) azt a memóriacímet tárolja, ahol a processzor által végrehajtott utasítás található. Az alapértelmezett EIP 0xFFFFFFFF0. Így az x86 processzorok hardver szinten a 0xFFFFFFFF0 címen kezdenek dolgozni. Ez valójában a 32 bites címtér utolsó 16 bájtja. Ezt a címet reset vektornak nevezzük.

Most a lapkakészlet memóriatérképe biztosítja, hogy a 0xFFFFFFF0 a BIOS egy meghatározott részéhez tartozik, nem a RAM-hoz. Ebbe BIOS idő a RAM-ba másolja magát a továbbiakért gyors hozzáférés. A 0xFFFFFFF0 cím csak egy utasítást tartalmaz, hogy a memóriában arra a címre ugorjon, ahol a BIOS másolata tárolva van.

Így kezdődik meg a BIOS kód végrehajtása. A BIOS először egy előre beállított sorrendben keres egy eszközt, amelyről indítható. A rendszer egy mágikus számot keres annak meghatározására, hogy az eszköz indítható-e (az első szektor 511. és 512. bájtjának egyenlőnek kell lennie 0xAA55).

Amikor a BIOS megtalálja rendszerindító eszköz, az eszköz első szektorának tartalmát a RAM-ba másolja, a fizikai címtől kezdve 0x7c00; majd a címre megy és végrehajtja a letöltött kódot. Ezt a kódot hívják rendszerbetöltő.

A rendszerbetöltő fizikai címre tölti be a kernelt 0x100000. Ezt a címet használják kiindulási címként minden nagy kernelben x86 rendszereken.

Minden x86 processzor egy egyszerű 16 bites módban indul valós mód. A GRUB rendszerbetöltő 32 bitesre vált védett mód, a CR0 regiszter alsó bitjének beállításával 1 . Így a kernel 32 bites védett módban töltődik be.

Ne feledje, hogy a Linux kernel esetében a GRUB látja a protokollokat Linux letöltésekés betölti a kernelt valós mód. A kernel automatikusan védett módba kapcsol.

Mire van szükségünk?

• x86 számítógép;
• Linux;
• ld (GNU Linker);

A belépési pont beállítása az assemblerben

Bármennyire is csak a C-re szeretnéd korlátozni magad, valamit az assemblerben kell írnod. Írunk rá egy kis fájlt, amely a kernelünk kiindulópontjaként szolgál majd. Mindössze annyit tesz, hogy meghív egy C-ben írt külső függvényt, és leállítja a programfolyamatot.

Hogyan biztosíthatjuk, hogy ez a kód legyen a kiindulópont?

A végső végrehajtható fájl létrehozásához egy linker szkriptet fogunk használni, amely összekapcsolja az objektumfájlokat. Ebben a szkriptben kifejezetten jelezni fogjuk, hogy adatokat szeretnénk betölteni a 0x100000 címen.

Íme az assembler kód:

;;kernel.asm bitek 32 ;nasm direktíva - 32 bites szakasz .text global start extern kmain ;kmain a c fájlban van definiálva start: cli ;blokk megszakítja a mov esp-t, a stack_space .bss resb 8192 ;8 KB a verem stack_space számára:

Az első utasítás, a 32. bit, nem x86-os összeállítási utasítás. Ez egy direktíva a NASM assembler számára, amely meghatározza a 32 bites módban működő processzor kódgenerálását. A mi esetünkben ez nem szükséges, de általában hasznos.

A kódot tartalmazó szakasz a második sorban kezdődik.

A global egy másik NASM direktíva, amely szimbólumokat készít forráskód globális. Így a linker tudja, hogy hol van a kezdő szimbólum – a belépési pontunk.

A kmain egy függvény, amely a kernel.c fájlban lesz meghatározva. extern azt jelenti, hogy a függvény valahol máshol van deklarálva.

Ezután jön a start függvény, ami meghívja a kmain függvényt és a hlt utasítással leállítja a processzort. Ezért a cli utasítással előre letiltjuk a megszakításokat.

Ideális esetben le kell foglalnunk egy kis memóriát, és rá kell mutatnunk egy veremmutatóval (esp). Úgy tűnik azonban, hogy a GRUB már megtette ezt helyettünk. Azonban továbbra is le kell foglalnia egy kis helyet a BSS szakaszban, és a veremmutatót az elejére mozgatja. A resb utasítást használjuk, amely lefoglalja a megadott számú bájtot. Közvetlenül a kmain hívása előtt a veremmutató (esp) a mov utasítással a megfelelő helyre kerül.

Kernel C-ben

A kernel.asm-ben meghívtuk a kmain() függvényt. Így a „C” kódunk végrehajtását a kmain() paranccsal kell elindítani:

/* * kernel.c */ void kmain(void) ( const char *str = "az első kernelem"; char *vidptr = (char*)0xb8000; //video mem itt kezdődik. unsigned int i = 0; unsigned int j = 0; /* ez a ciklus törli a képernyőt * 80 oszlopból 25 sor van. */ while(j< 80 * 25 * 2) { /* blank character */ vidptr[j] = " "; /* attribute-byte - light grey on black screen */ vidptr = 0x07; j = j + 2; } j = 0; /* this loop writes the string to video memory */ while(str[j] != "\0") { /* the character"s ascii */ vidptr[i] = str[j]; /* attribute-byte: give character black bg and light grey fg */ vidptr = 0x07; ++j; i = i + 2; } return; }

A kernelünk csak annyit tesz, hogy törli a képernyőt, és megjeleníti az „első kernelem” sort.

Először létrehozunk egy vidptr mutatót, amely a címre mutat 0xb8000. Védett módban a „videomemória” ettől a címtől kezdődik. A szöveg képernyőn való megjelenítéséhez 25 sort foglalunk le, 80 ASCII karakterből, 0xb8000-től kezdve.

Minden karakter nem a szokásos 8 bittel, hanem 16 bittel jelenik meg. Az első bájt magát a karaktert tárolja, a második pedig - attribútum-byte . Leírja a karakter formázását, például színét.

A zöld s karakter fekete háttéren való megjelenítéséhez ezt a karaktert írjuk az első bájtba, a másodikba pedig a 0x02 értéket. A 0 fekete hátteret jelent, a 2 - zöld szöveg.

Íme a színtábla:

0 - fekete, 1 - kék, 2 - zöld, 3 - cián, 4 - piros, 5 - bíbor, 6 - barna, 7 - világosszürke, 8 - sötétszürke, 9 - világoskék, 10/a - világoszöld, 11/b - Világos cián, 12/c - Világos piros, 13/d - Világos bíbor, 14/e - Világosbarna, 15/f - Fehér.

A kernelünkben világosszürke szöveget fogunk használni fekete alapon, így az attribútumbyte értéke 0x07 lesz.

Az első ciklusban a program egy üres szimbólumot nyomtat a teljes 80x25-ös zónára. Ez törli a képernyőt. A következő ciklusban a null-végződésű „első kernelem” karakterlánc 0x07-es attribútumbyte-jéből a „videomemória”-ba íródnak. Ez kinyomtatja a karakterláncot a képernyőre.

Csatlakozó rész

Össze kell raknunk a kernel.asm fájlt egy objektumfájlba a NASM segítségével; majd a GCC segítségével fordítsa le a kernel.c fájlt egy másik objektumfájlba. Ezután csatolni kell őket a végrehajtható rendszerindító kernelhez.

Ehhez egy kötési szkriptet fogunk használni, amelyet argumentumként adunk át az ld-nek.

/* * link.ld */ OUTPUT_FORMAT(elf32-i386) ENTRY(start) SZEKCIÓK ( . = 0x100000; .text: ( *(.text) ) .data: ( *(.data) ) .bss: ( *( .bss) ) )

Először is megkérdezzük kimeneti formátum 32 bites végrehajtható és összekapcsolható formátumként (ELF). Az ELF egy szabványos bináris fájlformátum Unix x86 rendszerekhez. BELÉPÉS egy argumentumot vesz fel, amely megadja annak a szimbólumnak a nevét, amely a belépési pont. SZEKCIÓK- ez a legfontosabb része. Ez határozza meg a futtatható fájlunk jelölését. Meghatározzuk, hogy a különböző szakaszokat hogyan kell összekötni, és hova kell elhelyezni.

A SZEKCIÓK után zárójelben a pont (.) jelzi a pozíciószámlálót, amely alapértelmezés szerint 0x0. Megváltoztatható, amit mi csinálunk.

Nézzük a következő sort: .text: ( *(.text) ) . A csillag (*) az különleges karakter, bármely fájlnévnek megfelelő. A *(.text) kifejezés az összes .text szakaszt jelenti az összes bemeneti fájlból.

Így a linker az objektumfájlok összes kódrészét a végrehajtható fájl egy szakaszába egyesíti a pozíciószámlálóban lévő címen (0x100000). Ezt követően a számláló értéke 0x100000 + a kapott szakasz mérete lesz.

Ugyanez történik más szakaszokkal is.

Grub és Multiboot

Most az összes fájl készen áll a kernel létrehozására. De van még egy lépés hátra.

Létezik egy szabvány az x86-os magok betöltésére az úgynevezett rendszerbetöltővel Multiboot specifikáció. A GRUB csak akkor indítja el a kernelünket, ha megfelel ezeknek a specifikációknak.

Ezek után a kernelnek tartalmaznia kell egy fejlécet az első 8 kilobájtjában. Ezenkívül ennek a fejlécnek 3 mezőt kell tartalmaznia, amelyek 4 bájtosak:

• mágikus mező: mágikus számot tartalmaz 0x1BADB002 azonosítani a magot.
• mező zászlókat: nincs rá szükségünk, állítsuk nullára.
• mező ellenőrző összeg: ha összeadja az előző kettővel, akkor nullát kell kapnia.

A kernel.asm fájlunk így fog kinézni:

;;kernel.asm ;nasm direktíva - 32 bites bit 32 szakasz .text ;multiboot spec align 4 dd 0x1BADB002 ;magic dd 0x00 ;flags dd - (0x1BADB002 + 0x00) ;ellenőrző összeg. m+f+c nullának kell lennie globális start extern kmain ;kmain a c file startban van definiálva: cli ;blokk megszakítja a mov esp-t, a stack_space-t ;set veremmutatót hívja a kmain hlt stack_space:

A mag felépítése

Most objektumfájlokat fogunk létrehozni a kernel.asm és kernel.c fájlokból, és összekapcsoljuk őket a szkriptünk segítségével.

Nasm -f elf32 kernel.asm -o kasm.o

Ez a sor futtatja az assemblert a kasm.o objektumfájl ELF-32 formátumú létrehozásához.

Gcc -m32 -c kernel.c -o kc.o

A „-c” opció biztosítja, hogy a fordítás után ne forduljon elő rejtett hivatkozás.

Ld -m elf_i386 -T link.ld -o kernel kasm.o kc.o

Ez futtatja a linkert a szkriptünkkel, és létrehozza futtatható fájl hívott kernel.

A grub beállítása és a kernel indítása

A GRUB megköveteli a kernel nevét, hogy megfeleljen a minta kernel- . Tehát nevezd át a kernelt. Az enyémet kernel-701-nek neveztem el.

Most tedd be a könyvtárba /csomagtartó. Ehhez szuperfelhasználói jogokra lesz szükség.

A grub.cfg GRUB konfigurációs fájlban adja hozzá a következőket:

Cím myKernel root (hd0,0) kernel /boot/kernel-701 ro

Ne felejtse el eltávolítani a hiddenmenu direktívát, ha van.

Indítsa újra a számítógépet, és látni fogja a kernelek listáját, beleértve az Önét is. Válassza ki, és látni fogja:

Ez a te magod! Adjunk hozzá egy bemeneti/kimeneti rendszert.

P.S.

• Minden kerneltrükkhöz jobb egy virtuális gépet használni.
• A kernel futtatásához grub2 a konfigurációnak így kell kinéznie: "kernel 7001" menü (set root="hd0,msdos1" multiboot /boot/kernel-7001 ro )
• ha a qemu emulátort szeretnéd használni, használd: qemu-system-i386 -kernel kernel

Habrt olvasva az elmúlt két évben csak néhány kísérletet láttam operációs rendszer fejlesztésére (konkrétan: felhasználóktól és (határozatlan időre elhalasztott) és (nem elhagyva, de egyelőre inkább a védett mód működésének leírásának tűnik az x86-kompatibilis processzorok közül, amit kétségtelenül tudni kell, hogy OS-t írhassunk az x86-hoz, és a kész rendszer leírását (bár nem a semmiből, bár nincs ezzel semmi baj, talán az ellenkezője is)) . Valamiért úgy gondolom, hogy szinte minden rendszer- (és néhány alkalmazás-) programozó legalább egyszer gondolkodott azon, hogy megírja a sajátját operációs rendszer. Ezzel kapcsolatban 3 operációs rendszer ennek az erőforrásnak a nagy közösségéből nevetséges számnak tűnik. A saját operációs rendszeren gondolkodók többsége láthatóan nem megy tovább az ötleten, egy kis része leáll a bootloader megírása után, néhány írási darab a kernelből, és csak a reménytelenül makacsok alkotnak valami homályosan OS-re emlékeztetőt. (ha összehasonlítjuk valamivel, mint a Windows/Linux) . Ennek sok oka van, de a fő szerintem az, hogy az emberek feladják a fejlesztést (néhányan még a megkezdés előtt) az operációs rendszer írási és hibakeresési folyamatának kevés leírása miatt, ami egészen más, mint ami történik. alkalmazásszoftver fejlesztése során.

Ezzel a rövid megjegyzéssel azt szeretném megmutatni, hogy ha helyesen kezdi, akkor nincs különösebb nehézség a saját operációs rendszer fejlesztésében. A vágás alatt egy rövid és meglehetősen általános útmutató található az operációs rendszer nulláról való megírásához.

Hogyan Nem szükséges elindul

Kérjük, ne tekintse az alábbi szöveget az operációs rendszer megírásával kapcsolatos cikkek vagy útmutatók kifejezett kritikájának. Csak hát az ilyen cikkekben túl gyakran hangos címek alatt egy minimális munkadarab megvalósítására helyezik a hangsúlyt, és a kernel prototípusaként mutatják be. Valójában a kernel felépítésén és az operációs rendszer egyes részeinek interakcióján kell gondolkodnia, és ezt a prototípust egy szabványos „Hello, World!” alkalmazásnak tekinteni az alkalmazásszoftverek világában. Ezen észrevételek enyhe indoklásaként el kell mondanunk, hogy alul van egy „Hello, World!” alfejezet, amelyre ebben az esetben pontosan annyi figyelmet fordítanak, amennyire szükséges, és nem több.

Nem kell bootloadert írni. Okos emberek kitalálta a Multiboot Specification-t, implementálta és részletesen leírta, hogy mi ez és hogyan kell használni. Nem akarom ismételni magam, csak azt mondom, hogy működik, megkönnyíti az életet, és ki kell használni. Egyébként jobb, ha teljes egészében elolvasod a specifikációt, kicsi és még példákat is tartalmaz.

Nem szükséges az operációs rendszert teljesen az assemblerben megírni. Ez nem is olyan rossz, inkább fordítva - a gyors és kis programokat mindig nagy becsben tartják. Csupán arról van szó, hogy mivel ennek a nyelvnek a fejlesztése lényegesen több erőfeszítést igényel, az assembler használata csak a lelkesedés csökkenéséhez vezet, és ennek következtében az operációs rendszer forrásainak egy hosszú dobozba dobásához.

Nincs szükség egyéni betűtípus betöltésére a videomemóriába, és semmit sem kell megjeleníteni oroszul. Ennek semmi értelme. Sokkal egyszerűbb és univerzálisabb az angol nyelv használata, és a betűtípus módosítását későbbre, innen való letöltésre hagyva merevlemez a fájlrendszer-illesztőprogramon keresztül (egyúttal további ösztönzés is lesz arra, hogy az induláson túl többet tegyen).

Készítmény

Először is, mint mindig, meg kell ismerkednie az általános elmélettel, hogy fogalma legyen az elkövetkező munkakörről. A vizsgált témában jó források E. Tanenbaum könyvei, amelyeket már említettek más cikkekben a Habré operációs rendszer megírásáról. Vannak cikkek is, amelyek leírják a meglévő rendszereket, és vannak különféle útmutatók/levelezések/cikkek/példák/oldalak, amelyek hangsúlyt fektetnek az operációs rendszer fejlesztésére, amelyek némelyikére mutató hivatkozások a cikk végén találhatók.

A kezdeti oktatási program után el kell döntenie a fő kérdéseket:

• cél architektúra - x86 (valós / védett / hosszú mód), PowerPC, ARM, ...
• kernel/OS architektúra - monolit, moduláris monolit, mikrokernel, exokernel, különféle hibridek
• nyelv és fordítója - C, C++, ...
• Kernel fájlformátum - elf, a.out, coff, bináris, ...
• fejlesztői környezet (igen, ez is fontos szerepet játszik) - IDE, vim, emacs, ...

Ezután a kiválasztottnak megfelelően és a következő területeken kell elmélyítenie tudását:

• videomemória és a vele való munkavégzés - a működés igazolására szolgáló kimenetre a kezdetektől fogva szükség van
• HAL (Hardware Abstraction layer) – még ha több hardverarchitektúra is támogatott, és nem tervezik a kernel legalsó szintű részeit megfelelően elkülöníteni az olyan absztrakt dolgok megvalósításától, mint a folyamatok, szemaforok stb. ne legyen felesleges
• memóriakezelés - fizikai és virtuális
• végrehajtásmenedzsment - folyamatok és szálak, tervezésük
• eszközkezelés – illesztőprogramok
• virtuális fájlrendszerek – egyetlen felület biztosítása a különféle fájlrendszerek tartalmához
• API (Application Programming Interface) – pontosan hogyan érik el az alkalmazások a kernelt
• IPC (Interprocess Communication) – előbb-utóbb a folyamatoknak kommunikálniuk kell

Eszközök

Figyelembe véve a választott nyelvet és fejlesztőeszközöket, olyan segédprogramokat és azok beállításait kell kiválasztani, amelyek a jövőben szkriptek írásával a lehető legegyszerűbben és gyorsabban teszik lehetővé a virtuális gép felépítését, képkészítését és elindítását. egy projektet. Nézzük meg közelebbről az egyes pontokat:

• bármelyik összeszerelésre alkalmas szabvány azt jelenti, mint a make, cmake,... Itt használhatók a linker szkriptjei és (speciálisan írt) segédprogramok Multiboot fejléc hozzáadásához, ellenőrző összegek hozzáadásához vagy bármilyen más célra.
• A kép elkészítése alatt a beillesztést és a fájlok másolását értjük. Ennek megfelelően a képfájl formátumát úgy kell kiválasztani, hogy azt a beillesztő/másoló segédprogram és a virtuális gép is támogassa. Természetesen senki sem tiltja a műveletek végrehajtását innentől kezdve sem az összeállítás utolsó részeként, sem az emulátor indításának előkészítéseként. Minden a konkrét eszközöktől és a használatukra kiválasztott lehetőségektől függ.
• A virtuális gép indítása nem nehéz, de ne felejtse el először leválasztani a képfájlt (ennél a pontnál le kell választani, mivel ennek a műveletnek nincs értelme a virtuális gép elindítása előtt). Hasznos lenne egy szkript is az emulátor hibakeresési módban történő elindításához (ha elérhető).

Ha az összes előző lépést elvégezte, akkor írjon egy minimális programot, amely kernelként indul el és nyomtat valamit a képernyőre. Ha a választott eszköznél kellemetlenségeket, hiányosságokat fedeznek fel, akkor azokat (a hiányosságokat) ki kell küszöbölni, vagy legrosszabb esetben természetesnek kell tekinteni.

Ebben a lépésben ellenőriznie kell a jövőben használni kívánt fejlesztői eszközök minél több funkcióját. Például modulok betöltése GRUB-ban vagy használata virtuális gép kép helyett fizikai lemez/partíció/flash meghajtó.

Miután ez a szakasz sikeres, kezdődik az igazi fejlődés.

Futásidejű támogatás biztosítása

Mivel azt javasolják, hogy magas szintű nyelveken írjunk, ügyelni kell arra, hogy bizonyos nyelvi jellemzőket támogassunk, amelyeket általában a fordítócsomag szerzői implementálnak. Például C++ esetén ezek a következők:

• funkció egy adatblokk dinamikus kiosztásához a veremben
• halommal dolgozik
• adatblokk másolási funkció (memcpy)
• funkció a program belépési pontja
• hívja a globális objektumok konstruktorait és destruktorait
• számos funkció a kivételekkel való munkavégzéshez
• csonk meg nem valósított tiszta virtuális funkciókhoz

Amikor a "Hello, World!" Lehet, hogy ezeknek a függvényeknek a hiánya nem érezhető, de a kód hozzáadásával a linker panaszkodni kezd a kielégítetlen függőségek miatt.

Természetesen meg kell említenünk a standard könyvtárat is. A teljes megvalósítás nem szükséges, de a funkcionalitás egy alapvető részhalmazát érdemes megvalósítani. Ekkor a kódírás sokkal ismerősebb és gyorsabb lesz.

Hibakeresés

Ne nézze meg, mit mondanak a hibakeresésről a cikk vége felé. Valójában ez egy nagyon komoly és nehéz kérdés az operációs rendszer fejlesztésében, mivel a hagyományos eszközök itt nem alkalmazhatók (néhány kivételtől eltekintve).

A következőket tudjuk ajánlani:

• magától értetődő, debug kimenet
• assert azonnali kilépéssel a „hibakeresőből” (lásd a következő bekezdést)
• valami konzolhibakereső látszata
• ellenőrizze, hogy az emulátor lehetővé teszi-e hibakereső, szimbólumtáblák vagy valami más csatlakoztatását

A kernelbe épített hibakereső nélkül a hibakeresésnek nagyon is van esélye arra, hogy rémálommá változzon. Így egyszerűen nincs menekvés attól, hogy a fejlődés valamely szakaszában megírjuk. És mivel ez elkerülhetetlen, jobb, ha előre elkezdi írni, és ezzel nagyban megkönnyíti a fejlesztést, és sok időt takarít meg. Fontos, hogy egy hibakeresőt kernelfüggetlen módon tudjunk megvalósítani, hogy a hibakeresés minimális hatással legyen a rendszer normál működésére. Íme néhány típusú parancs, amelyek hasznosak lehetnek:

• a szabványos hibakeresési műveletek része: töréspontok, hívási verem, értékek nyomtatása, nyomtatási dump, ...
• különféle kimeneti parancsok hasznos információkat, mint például az ütemező végrehajtási sora vagy különféle statisztikák (nem olyan haszontalan, mint elsőre tűnik)
• parancsok különböző struktúrák állapotának konzisztenciájának ellenőrzésére: szabad/használt memória listák, kupac vagy üzenetsor

Fejlesztés

Ezután meg kell írnia és hibakeresnie kell az operációs rendszer fő elemeit, amelyek pillanatnyilag biztosítania kell stabil munkavégzés, a jövőben pedig - könnyű bővíthetőség és rugalmasság. A memória/folyamat/(bármi más) menedzserek mellett a driver interfész ill fájlrendszerek. Kialakításukat különös gonddal kell megközelíteni, figyelembe véve az eszköztípusok/FS változatosságát. Idővel természetesen módosíthatók, de ez egy nagyon fájdalmas és hibára hajlamos folyamat (és a kernel hibakeresése nem egyszerű feladat), ezért ne feledje – legalább tízszer gondolja át ezeket a felületeket, mielőtt elkezdi a megvalósítást. őket.

Hasonló SDK

Ahogy a projekt fejlődik, új illesztőprogramokat és programokat kell hozzáadni hozzá. Valószínűleg már a második meghajtón (esetleg egy bizonyos típusú)/programon is észrevehető lesz néhány közös jellemző (könyvtárstruktúra, összeállításvezérlő fájlok, modulok közötti függőségek meghatározása, ismétlődő kód a fő vagy a rendszer kéréskezelőiben (pl. ha maguk az illesztőprogramok ellenőrzik azok kompatibilitását az eszközzel )). Ha igen, akkor ez annak a jele, hogy szükség van sablonok fejlesztésére különféle típusok programok az Ön operációs rendszeréhez.

Nincs szükség olyan dokumentációra, amely leírná az adott típusú program megírásának folyamatát. De érdemes szabványos elemekből üreset készíteni. Ez nemcsak megkönnyíti a programok hozzáadását (amit a meglévő programok másolásával, majd módosításával lehet megtenni, de ez több időt vesz igénybe), hanem a felületek, formátumok vagy bármi más változása esetén is könnyebben frissíthetők. Nyilvánvaló, hogy ilyen változások ideális esetben nem történhetnek meg, de mivel az operációs rendszer fejlesztése atipikus dolog, elég sok hely van az esetlegesen rossz döntéseknek. De a tévedés megértése hozott döntéseket mint mindig, valamivel a megvalósításuk után fog megjelenni.

Következő lépések

Röviden tehát: olvass az operációs rendszerekről (és mindenekelőtt a tervezésükről), fejleszd a rendszeredet (a tempó nem igazán fontos, a lényeg, hogy ne állj le teljesen, és időnként térj vissza a projekthez erő és ötletek) és természetes, hogy kijavítjuk benne a hibákat (amelyek megtalálásához időnként el kell indítani a rendszert és „játszani” vele). Idővel a fejlesztési folyamat egyre könnyebb lesz, a hibák ritkábban fordulnak elő, és felkerül a „reménytelenül makacsok” listájára, azon kevesek közé, akik a fejlesztési ötlet bizonyos abszurditása ellenére saját operációs rendszerrel, mégis megcsináltam.

Mit kell tudni az operációs rendszer írásához

Az operációs rendszer létrehozása a programozás egyik legnehezebb feladata, mert széleskörű és összetett ismereteket igényel a számítógép működéséről. Melyek pontosan? Alább megtudjuk.

Mi az az OS

Az operációs rendszer (OS) az szoftver, amely a számítógép hardverével és erőforrásaival dolgozik, és hidat képez a számítógép hardvere és szoftvere között.

Az első generációs számítógépekben nem volt operációs rendszer. Az első számítógépeken lévő programok tartalmaztak kódot a rendszer közvetlen működéséhez, a kommunikációhoz perifériás eszközökés számítások, amelyekhez ez a program készült. Emiatt még az egyszerű logikájú programokat is nehéz volt szoftverben megvalósítani.

Ahogy a számítógépek változatosabbá és összetettebbé váltak, az operációs rendszerként és alkalmazásként is működő programok írása egyszerűen kényelmetlenné vált. Ezért, hogy megkönnyítsék a programok írását, a számítógép-tulajdonosok elkezdtek szoftvereket fejleszteni. Így jelentek meg az operációs rendszerek.

Az operációs rendszer mindent biztosít, ami a felhasználói programok futtatásához szükséges. Megjelenésük azt jelentette, hogy a programoknak már nem volt szükségük a számítógépen végzett munka teljes mennyiségének vezérlésére (ez egy kiváló példa a tokozásra). Most a programoknak kifejezetten az operációs rendszerrel kellett dolgozniuk, és maga a rendszer gondoskodott az erőforrásokról és a perifériákkal (billentyűzet, nyomtató) való munkavégzésről.

Az operációs rendszerek rövid története

C nyelv

Mint fentebb említettük, számos magas szintű programozási nyelv létezik az operációs rendszer írásához. Közülük azonban a legnépszerűbb a C.

Innen kezdheti el tanulni ezt a nyelvet. Ez az erőforrás bemutatja az alapvető fogalmakat, és felkészít a haladóbb feladatokra.

„Learn C the Hard Way” – ez a címe egy másik könyvnek. A megszokott elmélet mellett sok gyakorlati megoldást is tartalmaz. Ez az oktatóanyag a nyelv minden aspektusát lefedi.

Vagy választhat az alábbi könyvek közül:

• "The C programozási nyelv" Kernighan és Ritchie;
• "C programozási abszolút kezdők útmutatója", Parry és Miller.

OS fejlesztés

Miután elsajátította mindazt, amit a számítástechnikával, az assembly nyelvvel és a C-vel kapcsolatban tudnia kell, el kell olvasnia legalább egy-két könyvet az operációs rendszer tényleges fejlesztéséről. Íme néhány forrás ehhez:

"Linux a semmiből". A műtő összeszerelésének folyamatát itt tárgyaljuk. Linux rendszerek(a tankönyvet számos nyelvre lefordították, köztük oroszra is). Itt is, mint más tankönyvekben, minden szükségeset megadnak alapismeretek. Rájuk támaszkodva kipróbálhatja magát az operációs rendszer létrehozásában. tenni szoftver rész Az operációs rendszer professzionálisabb, vannak kiegészítések a tankönyvhöz: "

Szerző Vulf játékos részben tette fel a kérdést Más nyelvek és technológiák

Hogyan készítsünk saját operációs rendszert? és megkapta a legjobb választ

Alexander Bagrov válasza[guru]
Az ötlet dicséretes.
Először is ismernie kell annak a gépnek a parancsrendszerét, amelyre operációs rendszert kíván írni.
A parancsrendszer közvetlenül tükröződik az assembly nyelvben.
Ezért mindenekelőtt ki kell találnia a saját assembly nyelvét, és írnia kell egy programot (assembler), amely az alfanumerikus szimbólumokat gépi nyelvre fordítja.
kód.
Ha érdekel, megnézheti, milyen követelményeknek kell megfelelnie egy új (ideális) operációs rendszernek.
Néhány ilyen funkció itt található:
.ru/D_OS/OS-PolyM.html#IdealOS
Szükséges a mikroprocesszor-fejlesztő oldalak anyagainak tanulmányozása. Például az Intel és az AMD.
Hasznosnak találhatja az OS-ről szóló videó előadást, amelyet itt mutatunk be:
.ru/D_OS/OS_General.html
PS: Ne hallgass a pesszimistákra. A csirkét kergető kakas ideológiája alapján:
– Nem fogom utolérni, legalább bemelegítek.
Forrás: Weboldal "Használja helyesen számítógépét!"

Válasz tőle 2 válasz[guru]

Helló! Íme néhány téma a válaszokkal a kérdésére: Hogyan hozhat létre saját operációs rendszert?

Válasz tőle Vadim Khprlamov[újonc]
Természetesen) Itt csak kapuk ülnek) Kérdezze meg a Microsoftot)

Válasz tőle Irina Starodubtseva[újonc]
vegye be az összes operációs rendszert, és zsúfolja össze őket egybe

Válasz tőle Alekszandr Tuncov[guru]
Ismerkedjen meg a Linux operációs rendszerrel, tanuljon programozni, és menjen

Válasz tőle ~Lángokban~[guru]
Taníts programozást a legmagasabb szinten, gyűjts össze egy egész tömeget ugyanazokból a számítógépes zsenikből, és akkor meg tudod csinálni.

Válasz tőle Rasul Magomedov[guru]
Kezdje egy szórakoztató háttérkép létrehozásával

Válasz tőle Google kapitány[guru]
Ne hallgass a „10 éve tanulni az alapokat”-ra; Torvalds 22 évesen írta a Linux első verzióját, és 12 évesen kapott egy számítógépet. Mint érti, nem csak az alapokat tanulta.
Kezdje azzal, hogy tanulmányozza a már létezőket – egyrészt a Tannenbaum „Modern Operating Systems”-jét, másrészt készítsen Linuxot a nulláról, harmadrészt tanulja meg az Assemble, C, C++ nyelveket. 3-4 év alatt mindent megtehetsz. Utána elkezdheti a rendszer fejlesztését... ha még akarja.

Válasz tőle Yoanya Semenov[guru]
Tudod mit csinált Gates? próbáld meg ugyanezt, azt mondják, hogy jövedelmezőnek bizonyul.
Amikor a szülei megbüntették, nem volt jobb dolga, ugrálni kezdett a billentyűzeten, majd eladta, amit kapott, "ablaknak" nevezte.
ps és ha igaz, először írd meg " Hello World"C++ nyelven, és azonnal megérted, hogy az ötlet paranoiás

Válasz tőle Kostafey[guru]
Miért? Mi az, ami alapvetően elégedetlen a meglévőkkel? Tényleg nincs olyan, amelyik legalább részben megfelel az operációs rendszer követelményeinek? Talán jobb, ha csatlakozol a fejlesztőcsapathoz? 100500-szor több értelme lesz.
És akkor ezt az ötletet a megvalósítás további 0.(0)1%-ára hagyja el.

Válasz tőle Jevgenyij Lomega[guru]
E. Tanenbaum "Operációs rendszerek: fejlesztés és megvalósítás"
Sok szerencsét
PS Sajnos nem valószínű, hogy sikerül, mint Bill Gates. Az anyja menő bankár, a tied?

Válasz tőle Krab Bark[guru]
Ön is írhat egy egyszerű operációs rendszert, de az soha nem lesz képes felvenni a versenyt egy olyan operációs rendszerrel, mint a Windows, a MAC OS vagy a Linux, amelyen programozók százai vagy ezrei dolgoztak legalább tíz éve. Emellett az operációs rendszer csak az alap. Szükséges, hogy a hardverfejlesztők saját meghajtókat írjanak ehhez az operációs rendszerhez, fejlesztők alkalmazási programok szerkesztők, lejátszók, böngészők, játékok, az ördög a habarcsban írt rá... És e nélkül az OS haszontalan alapja marad egy háznak, amit senki sem fog felépíteni.

Válasz tőle Vadim Sztahanov[aktív]
Jobb lenne, ha filológusnak mennék tanulni. És akkor kiabált: "Ingyen pénztárgép!"

Válasz tőle =Serge=[guru]
Hurrá! Végül az 58. kérdés a webhelyen a „saját” operációs rendszer létrehozásáról))
Itt vannak a „saját operációs rendszer megírásával” kapcsolatos kérdések - csak 34 van belőlük))
Olvassa el...92 kérdés*10 válasz = körülbelül 920 válasz))
Ugyanakkor valószínűleg megérti, mit jelent a „nem unalmas háttérkép”).

Válasz tőle Reprodukálhatatlan[guru]
egy másik Denis Popov egy másik BolgenOS-szal?

Válasz tőle Ivan Tatarcsuk[újonc]
indítsa el a jegyzettömböt, töltse le a toadscript fordítót, és kezdje el ugrálni a billentyűzeten
60 perc alatt lefordítani és ennyi
az oskád készen áll

Válasz tőle Mila a bárány[újonc]
OS? Melyiket pontosan? OS-eredeti Chester (eredeti karakter (lefordítva))
Szüksége van magáról rajzfilmekben vagy filmekben készült képekre.
1. Gondold végig, milyen rajzfilmet/filmet szeretnél az operációs rendszerre
2. Vegye figyelembe a rajzfilm/film stílusát
3. Ki lesz a karaktered (tündér, póni, bűvész, robot stb.)
4. Írd le gondolatban, majd papíron
5. Készítsen tervet
6. Találja ki a nevet és az életrajzot
7. Rajzolj egy karaktert!
8. Most pedig térjünk rá a Paint Tooth Sai-ra

WiFi