Egyes alkalmazások magasabb szintű jogosultságokat igényelnek a Windows rendszeren való futtatásához, és rendszergazdaként kell futtatni. Ez arra kéri Önt, hogy " Felhasználói felület" (Felhasználói fiókok felügyelete vagy UAC), amelyben a rendszer az Ön hozzájárulását kéri az alkalmazás elindításához.
Sok felhasználó tévesen úgy gondolja, hogy a felhasználói fiókok felügyelete csak kellemetlenség, és kikapcsolja. Ugyanakkor a számítógép biztonsága súlyosan érintett, mert. már nem szükséges a felhasználói hozzájárulás az alkalmazások futtatásához, és minden rosszindulatú zökkenőmentesen indulhat és futhat. A víruskereső jelenléte sem tudja 100%-ban garantálni a számítógép biztonságát.
Ebben a cikkben bemutatom, hogyan egyszerűsítheti le kedvenc alkalmazásai rendszergazdaként történő futtatásának folyamatát az UAC (teljes vagy részleges) letiltása és a biztonság veszélyeztetése nélkül.
Az alkalmazást rendszergazdaként többféleképpen is futtathatja:
Példaként a parancssort (cmd) rendszergazdaként fogjuk futtatni.
1. számú módszer (normál) - Indítsa el a jobb egérgombbal (megjelenik az UAC prompt)
Kattintson jobb gombbal az ikonra kívánt alkalmazástés válassza ki a " Futtatás rendszergazdaként":
2. módszer - Indítsa el a " Ctrl+Shift+Enter" (UAC prompt jelenik meg)
Kattintson Rajt, a keresősávba írja be a kívánt parancsot, és kattintson Ctrl+Shift+Enter.
3. módszer - állítsa be a futtatást rendszergazdaként a parancsikon tulajdonságaiban (megjelenik az UAC prompt)
Kattintson a jobb gombbal a kívánt parancsikonra, és válassza a " Tulajdonságok".
Ugrás a lapra Címke", nyomja meg " Továbbá", ellenőrizd a " Futtatás rendszergazdaként":
vagy menj a " Kompatibilitás"és jelölje be a négyzetet" Futtassa ezt a programot rendszergazdaként":
4. módszer – A kiválasztott alkalmazások elindításának megkönnyítése a Feladatütemezővel (az UAC prompt nem jelenik meg)
Fontos! Ez a módszer csak azoknál a fiókoknál működik, amelyek egy csoport tagjai. Rendszergazdák. Rendszeres felhasználók számára nem fog működni, mert a felső határuk korlátozott.
Menjünk tovább érdekes módon. Ha van olyan alkalmazás, amelyet folyamatosan futtat, és megbízható szoftvergyártótól származik, például ez Windows alkalmazás- könnyebben indítható. Hozzon létre egy parancsikont a következőhöz kívánt program nem tart tovább 2 percnél, és ez lehetővé teszi, hogy a jövőben megszabaduljon a felesleges műveletektől. Elindítjuk feladat ütemező (Rajt---> Minden program ---> Alapértelmezett---> Szolgáltatás---> Feladat ütemező) és nyomja meg a " Hozzon létre egy feladatot":
Adja meg Névúj feladathoz, és jelölje be a " Fuss a legmagasabb jogosultságokkal":
Ugrás a lapra Akciók, nyomja meg " Teremt", a következő ablakban nyomja meg a " Felülvizsgálat":
Adja meg a kívánt alkalmazás elérési útját, és kattintson a " Nyisd ki":
Kép nagyítása
Nyomja meg " rendben":
Zárja be az ütemezőt, és folytassa a parancsikon létrehozásával.
Parancsikon létrehozásához az asztalon kattintson a jobb gombbal, válassza a " Teremt" ---> "Címke":
A terepen Az ingatlan elhelyezkedése belép:
Schtasks /run /tn cmd_admin
Ahol cmd_admin- az általunk készített feladat neve. Ha a név szóközt tartalmaz, akkor azt idézőjelbe kell tenni.
Állítsa be a címke nevét:
Kép nagyítása
A parancsikon létrejött és használatra kész.
Az ikon megváltoztatásához kattintson a jobb gombbal a parancsikonra, válassza a " Tulajdonságok":
Ugrás a lapra Címke"és nyomja meg a" változás ikonra":
"Felülvizsgálat..."
Adja meg a program elérési útját:
Kép nagyítása
Válassza ki a kívánt ikont, és zárja be mindkét ablakot a " rendben":
Most a kívánt alkalmazás rendszergazdaként történő elindítása a létrehozott parancsikonra való dupla kattintással történik, miközben az UAC prompt nem jelenik meg, és a biztonság érintetlen marad.
Automatizálási segédprogram "4. módszer"
Ha nagyszámú programhoz kell parancsikonokat létrehoznia, kényelmes a segédprogram használata.
A segédprogrammal való munka két egyszerű lépésből áll:
- Telepítés
- Futtatható fájl (*.exe, *.bat, *.cmd) húzása a segédprogram parancsikonjára:
A fókusz automatikus átvitele egy futó programra
Az alkalmazások ütemezőből való indításának sajátossága, hogy a fókusz nem kerül át az ablakra, és például egy parancs parancssorba történő beírásához az ablakra kell kattintani. Ez a viselkedés segíthet automatizálni a rutin ütemezett műveleteket, de a "4. módszer" esetében ez nem mindig kényelmes.
Számos módszer létezik a „kikerülésre”. Kicsit másképp működnek, ezért válassza ki az Önnek legmegfelelőbbet. Az első a programok futtatásához kényelmesebb, a második pedig a szkriptek futtatásához.
Adja hozzá a feladat létrehozásakor:
A start parancs segítségével
Program vagy forgatókönyv:
Érvek:
/c indítsa el a /d "program elérési útja" fájlnév.exe fájlt
/c start /d "C:\Windows\System32\" cmd.exe
A NirCmd segédprogram használata
Program vagy forgatókönyv:
Path_to_nircmd\nircmd.exe
Érvek:
Az Exec megjeleníti a "program elérési útja\fájlnév.exe" fájlt
Az Exec megjeleníti a "C:\Windows\System32\cmd.exe" fájlt
A "Futtatás" párbeszédpanel indítása rendszergazdaként
Hasonló az induláshoz parancs sor konfigurálhatja a párbeszédpanel indítását " Fuss", és a benne megadott parancsok is rendszergazdaként fognak futni. Ennek a megközelítésnek az a kényelme, hogy a korábban használt parancsok listája mentésre kerül, és a listából kiválaszthatja a kívánt parancsot.
Amikor feladatot hoz létre az ütemezőben, a " Hozzon létre egy műveletet"adja meg:
mezőben" Program vagy script":
Rundll32
mezőben" Érvek hozzáadása":
Shell32.dll,#61
Töltse le a segédprogramot, csomagolja ki. Elindítjuk a parancssort, beírjuk a kívánt parancsot, a szintaxis meglehetősen egyszerű:
<путь к утилите> <путь к нужному приложению>
Megjelenik egy UAC prompt, és az alkalmazás rendszergazdaként fog futni.
Jegyzet: Szövegkörnyezetben windows menü 7 van egy nagyon kényelmes funkció a fájl elérési útjának másolására: tartsa lenyomva Váltás, kattintson a jobb gombbal a fájlra, válassza a " másolás útvonalként".
Programok indítása a felhasználó által rendszergazdaként rendszergazdai jelszó megadása nélkül
Fontos! Ez a módszer nem biztonságos, mert lehetővé teszi a korlátozott jogokkal rendelkező felhasználók számára, hogy teljes jogokkal futtassák a kódot. Egy ravasz felhasználó vagy rosszindulatú program kihasználhatja ezt, és veszélyeztetheti a rendszert.
Vegyünk egy másik érdekes problémát: a fiókját Windows bejegyzés a Rendszergazdák csoport tagja, van egy vagy több fiók, amely tagja a Felhasználók csoportnak. A felhasználónak olyan programot kell futtatnia, amely emelést igényel. Általában a következőképpen néz ki: a felhasználó jobb gombbal rákattint a fájlra, és kiválasztja a "Futtatás rendszergazdaként" lehetőséget, amely kéri a rendszergazdai jelszó megadását:
Természetesen a rendszergazdai jelszó szétosztása a felhasználók között nem a legtöbb jó ötlet. Ennek "megkerüléséhez" Alexey Kuryakin AdmiLink segédprogramját fogjuk használni. Segítségével az adminisztrátor parancsikont hozhat létre a felhasználó számára a szükséges program elindításához, miközben a rendszergazdai jelszó megadása csak 1 alkalommal szükséges - a parancsikon létrehozásakor. Amikor a felhasználó elindítja a programot, a jelszó titkosított formában kerül továbbításra.
Ez a módszer akkor működik, ha a program csak rendszergazdaként futtatható, és a fejlesztő nem felejtette el megadni ezt a feltételt a jegyzékben. Azonban még mindig van nagyszámú régi programokat vagy olyan programokat, amelyeket úgy lehet futtatni normál mód, és az adminisztrátor nevében (ebben az esetben egy másik funkciókészlet lesz elérhető). Amikor megpróbál egy ilyen programot futtatni az AdmiLink használatával, az normál módban indul el (adminisztrátori jogosultságok nélkül). És ha megpróbálja bejelölni a "3. módszer. A szerző eredeti stílusa megmarad.
Engedélyezi a normál fiókkal rendelkező felhasználók számára, hogy rendszergazdai jogosultságokkal rendelkező alkalmazásokat UAC vagy jelszókérés nélkül futtassanak? Akkor elmondom, hogyan kell csinálni. A parancs segítségével létrehozunk egy parancsikont runas /sacred, amely a jelszót tárolja. Megjegyzem, ez egy biztonsági résnek tekinthető - egy normál felhasználó a runas / savecred segítségével bármilyen parancsot végrehajthat rendszergazdaként, jelszó megadása nélkül. Bizonyos helyzetekben azonban hasznos lehet – például, ha azt szeretné, hogy gyermeke kikerüljön a szabványból fiókot rendszergazdaként futtathatja az alkalmazásokat anélkül, hogy Ön megkérdezné.
Rendszergazdai fiók engedélyezése
Az első lépés a beépített rendszergazdai fiók engedélyezése, amely alapértelmezés szerint le van tiltva. Tehát kattintson a jobb gombbal a parancssor parancsikonjára, és válassza a "Futtatás rendszergazdaként" lehetőséget.
A megnyíló parancssor ablakban futtassa a következő parancsot:
net felhasználó rendszergazda /aktív:igen
A fiók most már engedélyezett, bár jelszó nélkül. Jelszó beállításához nyissa meg a Vezérlőpultot, válassza ki a Felhasználói fiókok és családbiztonság kategóriát, majd nyissa meg a Felhasználói fiókok menüt. Ezután kattintson a "Másik fiók kezelése" linkre.
Válasszon ki egy rendszergazdai fiókot, kattintson a Jelszó létrehozása gombra, és hozzon létre egy jelszót a rendszergazdai fiókhoz.
Hozzon létre egy címkét
Most létrehozunk egy parancsikont, amely elindítja az alkalmazást rendszergazdai jogosultságokkal. Kattintson a jobb gombbal az asztalra, válassza az "Új" lehetőséget, majd kattintson a "Parancsikon" elemre.
A megnyíló ablakban írja be a következő parancsot:
runas /felhasználó: számítógép név\Adminisztrátor /mentett" C:\Path\To\Program.exe“
Felhívjuk figyelmét, hogy ki kell cserélni számítógép név a számítógép nevére, és C:\Path\To\Program.exe a futtatni kívánt program teljes elérési útjára. Például, ha a számítógép neve Laptop, és a futtatni kívánt program az Auslogics BoostSpeed, akkor a következő elérési utat kell megadnia:
runas /user:Laptop\Administrator /savecred "C:\Program Files\Auslogics\Auslogics BoostSpeed\BoostSpeed.exe"
A következő ablakban adja meg a parancsikon nevét. Opcionálisan kiválaszthat egy ikont az új parancsikonhoz - kattintson rá jobb gombbal, és válassza a "Tulajdonságok" lehetőséget.
A "Tulajdonságok" párbeszédpanelen kattintson a "Change icon" gombra, és válassza ki a megfelelőt.
Amikor először kattint duplán a parancsikonra, a rendszer kéri a korábban létrehozott rendszergazdai fiók jelszavát.
Ez a jelszó elmentésre kerül – a program következő futtatásakor nem kell újra megadnia.
Ahogy fentebb említettük, a szabványos fiókokban a felhasználók bármilyen programot futtathatnak rendszergazdai jogokkal jelszó megadása nélkül (a runas /savecred paranccsal), ezért ezt tartsa szem előtt.
Az adminisztrátori jelszót a "Credential Manager" tárolja – ha törölni szeretné a mentett jelszót, azt onnan megteheti.
Szép napot!
A legfontosabb dolog nem volt elég részletesen leírva: hogyan kell ezt a kódot futtatni valódi hardveren? Hogyan hozhat létre saját indítólemez? Ebben a cikkben mindezekre a kérdésekre részletesen válaszolunk (részben ezekkel a kérdésekkel foglalkoztunk az előző cikkben, de a könnyebb olvashatóság érdekében megengedjük magunknak az anyag enyhe megkettőzését).
Az interneten rengeteg leírás és oktatóanyag található a saját mini-OS megírásáról, sőt több száz kész kis hobbi operációs rendszer is létezik. Az egyik legérdemesebb forrás ebben a témában, amit szeretnék kiemelni, az osdev.org portál. Annak érdekében, hogy kiegészítsük az előző cikket a PCI-ről (és a későbbi cikkek írásának lehetőségéről minden modern operációs rendszerben jelen lévő különféle funkciókról), ismertetjük lépésről lépésre utasításokat rendszerindító lemez készítésén egy ismerős C programmal.Igyekeztünk minél részletesebben írni, hogy mindenre magunktól is rájöjjön.
Tehát a cél: a lehető legkevesebb erőfeszítéssel készítse el saját indítható USB flash meghajtóját, amely csak a klasszikus „Hello World” szöveget nyomtatja ki a számítógép képernyőjén.
Pontosabban: védett módba kell „kerülnünk” letiltott lapozással és megszakításokkal – ez a processzor legegyszerűbb módja, az egyszerű konzolprogramoknál megszokott viselkedéssel. A cél elérésének legokosabb módja egy multiboot kernel felépítése és a népszerű rendszerindítás Grub rendszerbetöltő. Ennek a megoldásnak egy alternatívája a saját kötetbetöltési rekord (VBR) írása, amely betölti a saját írott betöltőjét (betöltőjét). Egy tisztességes betöltőnek legalább képesnek kell lennie dolgozni a lemezzel, a fájlrendszerrel és elemezni az elf képeket. Ez azt jelenti, hogy sok összeállítási kódot kell írni, és sok C kódot. Röviden: egyszerűbb a Grub használata, amely már tud mindent, amire szüksége van.
Kezdjük azzal a ténnyel, hogy a további műveletekhez bizonyos fordítók és segédprogramok szükségesek. A legegyszerűbb, ha valamilyen Linuxot (például Ubuntut) használunk, mivel az már mindent tartalmaz, ami egy indítható flash meghajtó létrehozásához szükséges. Ha szokott Windows alatt dolgozni, akkor konfigurálhatja Virtuális gép Linux rendszerrel (Virtual Box vagy VMware Workstation használatával).
Ha használ linux ubuntu, akkor először telepítenie kell több segédprogramot:
1. Grub. Ehhez használja a következő parancsot:
sudo apt-get install grub
2. Qemu. Szükséges, hogy minden gyors legyen, ehhez hasonló a parancs:
sudo apt-get install qemu
A tervünk most így néz ki:
1. Hozzon létre egy C programot, amely egy sort nyomtat a képernyőre.
2. gyűjtsünk be róla egy képet (kernel.bin) miniboot formátumban, hogy elérhető legyen a GRUB segítségével történő rendszerindításhoz.
3. Hozzon létre egy rendszerindító lemezképfájlt, és formázza azt.
4. Telepítse a Grubot erre a képre.
5. másolja a létrehozott programot (kernel.bin) lemezre.
6. írja be a képet fizikai közeg vagy futtassa qemu-ban.
És a rendszerindítási folyamat:
Ahhoz, hogy ez működjön, több fájlt és könyvtárat kell létrehoznia:
1. lépés: A célprogram (kernel) kódjának létrehozása:
Létrehozunk egy kernel.c fájlt, amely a következő kódot tartalmazza, amely üzenetet nyomtat a képernyőn:
#include "printf.h" #include "screen.h" #include "types.h" void main(void) ( clear_screen(); printf("\n>>> Hello World!\n"); )
Itt minden ismerős és egyszerű. A printf és a clear_screen függvények hozzáadásával a következőkben foglalkozunk. Addig is ki kell egészítenünk ezt a kódot minden szükségessel, hogy a Grub betölthesse.
Ahhoz, hogy a kernel multiboot formátumú legyen, a következő struktúrának kell lennie a kernelkép első 8 kilobájtjában:
Ha az összes megadott feltétel teljesül, akkor a Grub a % eax és % ebx regisztereken keresztül egy mutatót ad át a multiboot Information struktúrára és a 0x1BADB002 értékre. A multiboot Information szerkezet tartalmazza különféle információk, beleértve a betöltött modulok listáját és azok helyét, amelyekre szükség lehet a rendszer további indításához.
Ahhoz, hogy a programot tartalmazó fájl tartalmazza a szükséges aláírásokat, készítsünk egy file loader.s fájlt a következő tartalommal:
Szöveg .global loader # a belépési pont láthatóvá tétele a linker számára # a Multiboot fejléc beállítása - részletekért lásd a GRUB dokumentumokat .set FLAGS, 0x0 # ez a Multiboot "zászló" mező .set MAGIC, 0x1BADB002 # "magic number" segítségével a rendszerbetöltő megtalálja a fejléc .set CHECKSUM, -(MAGIC + FLAGS) # ellenőrzőösszeg szükséges .align 4 .long MAGIC .long FLAGS .long CHECKSUM # tartalék kezdeti kernel veremterület .set STACKSIZE, 0x4000 # azaz 16k. .lcomm verem, STACKSIZE # tartalék 16k verem .comm mbd, 4 # ezt fogjuk használni a kmain .comm magic-ban, 4 # ezt fogjuk használni a kmain betöltőben: movl $(stack + STACKSIZE), %esp # állítsd be a verem movl %eax, magic # Multiboot magic number movl %ebx, mbd # Multiboot adatstruktúra call main # call C code cli hang: hlt # stop machine kell kernel visszatérni jmp hang
Tekintsük a kódot részletesebben. Ez a kód szinte változatlan formában a wiki.osdev.org/Bare_Bones oldalról származik. Mivel a fordításhoz a gcc-t használjuk, a GAS szintaxist használjuk. Nézzük meg közelebbről, mit csinál ez a kód.
.szöveg
Minden ezt követő kód a végrehajtható .text részbe kerül.
.global loader
A betöltő szimbólumot láthatóvá nyilvánítjuk a linker számára. Erre azért van szükség, mert a linker a betöltőt fogja használni belépési pontként.
.set FLAGS, 0x0 # set FLAGS = 0x0 .set MAGIC, 0x1BADB002 # set MAGIC = 0x1BADB002 .set CHECKSUM, -(MAGIC + FLAGS) # set CHECKSUM = -(MAGIC + FLAGS) .align to 4 .long MAGIC # helyezze el a MAGIC értéket az aktuális címre .long FLAGS # helyezze a FLAGS értéket az aktuális címre .long CHECKSUM # helyezze az ELLENŐRZŐ SZUM értéket az aktuális címre
Ez a kód generálja a Multiboot formátumú aláírást. A .set direktíva a karakterértéket a vesszőtől jobbra lévő kifejezésre állítja be. Az .align 4 direktíva 4 bájttal igazítja a következő tartalmat. A .long direktíva a következő négy bájtban tárolja az értéket.
.set STACKSIZE, 0x4000 # set STACKSIZE = 0x4000 .lcomm verem, STACKSIZE # STACKSIZE bájt lefoglalása. A verem a range.comm mbd-re vonatkozik, 4 # tartalék 4 bájtot az mdb változó számára a COMMON területen .comm magic, 4 # tartalék 4 bájtot a magic változó számára a COMMON területen
A rendszerindítási folyamat során a grub nem állítja be a veremet, és a kernelnek első dolga a verem beállítása, ehhez 0x4000 (16Kb) bájtot foglalunk le. Az .lcomm direktíva lefoglalja a .bss szakaszban a vessző után megadott számú bájtot. A névverem csak a lefordított fájlban lesz látható. A .comm direktíva ugyanazt teszi, mint az .lcomm, de a szimbólum neve globálisan lesz deklarálva. Ez azt jelenti, hogy a következő sort beírva a C kódba tudjuk használni.
külső int varázslat
És most az utolsó rész:
betöltő: movl $(stack + STACKSIZE), %esp # verem inicializálása movl %eax, magic # %eax írása magic movl-be %ebx, mbd # %ebx írása mbd-re hívás fő # fő függvény hívása cli # hardverlefagyásból származó megszakítások letiltása : hlt # megszakításig leállítja a cpu-t jmp hang # jump to hang label
Az első utasítás a verem tetejének értékét menti a %esp regiszterbe. Mivel a verem lefelé növekszik, a verem számára kijelölt tartomány végének címe %esp-re lesz írva. A következő két utasítás a korábban lefoglalt 4 bájtos tartományokban tárolja azokat az értékeket, amelyeket a Grub átad az %eax, %ebx regiszterekben. Ezután a fő függvényt hívják meg, ami már C-ben meg van írva. Ha ez az eljárás visszatér, a processzor hurokot indít.
2. lépés: További kód előkészítése a programhoz (rendszerkönyvtár):
Mivel a teljes program a nulláról van írva, a printf függvényt elölről kell írni. Ehhez több fájlt is elő kell készítenie.
Hozzon létre egy közös mappát, és tartalmazzon egy mappát:
mkdir gyakori mkdir tartalmazza
Készítsük el a common\printf.c fájlt, amely az ismert printf függvény megvalósítását tartalmazza majd. Ez a fájl teljes egészében átvehető a www.bitvisor.org projektből. A fájl elérési útja a bitvisor forrásokban: core/printf.c. A bitvisorból másolt printf.c fájlban a célprogramban való használathoz ki kell cserélni a sorokat:
#include "initfunc.h" #include "printf.h" #include "putchar.h" #include "spinlock.h"
a sorokhoz:
#include "types.h" #include "stdarg.h" #include "screen.h"
Ezután távolítsa el a printf_init_global függvényt és az összes hivatkozását ebben a fájlban:
Statikus void printf_init_global (void) ( spinlock_init (&printf_lock); ) INITFUNC("global0", printf_init_global);
Ezután távolítsa el a printf_lock változót és az összes hivatkozást ebben a fájlban:
statikus spinlock_t printf_lock; ... spinlock_lock(&printf_lock); ... spinlock_unlock(&printf_lock);
A printf függvény a putchar függvényt használja, amit szintén meg kell írni. Ehhez hozzunk létre egy common\screen.c fájlt a következő tartalommal:
#include "types.h" #define GREEN 0x2 #define MAX_COL 80 // Maximális oszlopok száma #define MAX_ROW 25 // Maximális sorok száma #define VRAM_SIZE (MAX_COL*MAX_ROW) // Képernyőméret, röviden"s # define DEF_VRAM_BASE 0xb8000 // A videomemória alapértelmezett alapja statikus előjel nélküli char curr_col = 0; statikus előjel nélküli char curr_row = 0; // Karakter írása a képernyő aktuális helyére #define PUT(c) (((előjel nélküli rövid *) (DEF_VRAM_BASE)) \ [(curr_row * MAX_COL) + curr_col] = (ZÖLD<< 8) | (c))
// Place a character on next screen position
static void cons_putc(int c)
{
switch (c)
{
case "\t":
do
{
cons_putc(" ");
} while ((curr_col % 8) != 0);
break;
case "\r":
curr_col = 0;
break;
case "\n":
curr_row += 1;
if (curr_row >= MAX_ROW) ( curr_row = 0; ) break; case "\b": if (curr_col > 0) ( curr_col -= 1; PUT(" "); ) break; alapértelmezett: PUT(c); curr_col += 1; if (curr_col >= MAX_COL) ( curr_col = 0; curr_row += 1; if (curr_row >= MAX_ROW) ( curr_row = 0; ) ) ); ) void putchar(int c) ( if (c == "\n") cons_putc("\r"); cons_putc(c); ) void clear_screen(void) ( curr_col = 0; curr_row = 0; int i; for (i = 0; i< VRAM_SIZE; i++)
cons_putc(" ");
curr_col = 0;
curr_row = 0;
}
A megadott kód egyszerű logikát tartalmaz a karakterek képernyőre történő nyomtatásához szöveges módban. Ebben az üzemmódban két bájtot használnak egy karakter írásához (az egyik a karakterkóddal, a másik az attribútumokkal), közvetlenül a képernyőn megjelenő videomemóriába írva a 0xB8000 címtől kezdve. A képernyő felbontása 80x25 karakter. A karakter közvetlenül a PUT makró segítségével kerül kinyomtatásra.
Most már csak néhány fejlécfájl hiányzik:
1. Fájl include\screen.h. Deklarálja a putchar függvényt, amelyet a printf függvényben használunk. Fájl tartalma:
#ifndef _SCREEN_H #define _SCREEN_H void clear_screen(void); void putchar(int c); #endif
2. Fájl include\printf.h. A mainben használt printf függvényt deklarálja. Fájl tartalma:
#ifndef _PRINTF_H #define _PRINTF_H int printf (const char *formátum, ...); #endif
3. Fájl include\stdarg.h. Funkciókat deklarál az argumentumok feletti iterációhoz, amelyek száma előre nem ismert. A teljes fájl a www.bitvisor.org projektből származik. A fájl elérési útja a bitvisor projektkódban: include\core\stdarg.h.
4. Fájl include\types.h. NULL-t és size_t-t deklarál. Fájl tartalma:
#ifndef _TYPES_H #define _TYPES_H #define NULL 0 typedef unsigned int size_t; #endif
Így az include és a közös mappák tartalmazzák azt a minimális rendszerkönyvtár kódot, amelyre minden programnak szüksége van.
3. lépés: A linker szkriptelése:
Létrehozzuk a linker.ld fájlt, amelyet a linker használ a célprogramfájl (kernel.bin) előállításához. A fájlnak a következőket kell tartalmaznia:
BEJEGYZÉS (betöltő) LMA = 0x00100000; SZEKCIÓK ( . = LMA; .multiboot ALIGN (0x1000) : ( loader.o(.text) ) . szöveg igazítás(0x1000) : ( *(.text) ) .rodata ALIGN (0x1000) : ( *(.rodata*) ) .data ALIGN (0x1000) : ( *(.data) ) .bss: ( *(COMMON) *( .bss) ) /DISCARD/ : ( *(.comment) ) )
A beépített ENTRY() függvény lehetővé teszi, hogy belépési pontot állítsunk be a kernelünk számára. A grub ezen a címen adja át az irányítást a kernel betöltése után. A linker ezt a szkriptet fogja használni egy ELF formátumú bináris fájl létrehozásához. Az ELF-fájl szegmensekből és szakaszokból áll. A szegmensek listáját a Program fejléc tábla, a szakaszok listáját a Szakaszfejléc tábla tartalmazza. A linker szakaszokkal, a képbetöltő (esetünkben a GRUB) szegmensekkel operál. 
Amint az ábrán látható, a szegmensek szakaszokból állnak. A szakaszt leíró mezők egyike a virtuális cím, ahol a szakasznak a végrehajtás időpontjában kell lennie. Valójában egy szegmensnek 2 mezője van, amelyek leírják a helyét: a szegmens virtuális címe és a szegmens fizikai címe. A szegmens virtuális címe a szegmens első bájtjának virtuális címe a kód végrehajtásának pillanatában, a szegmens fizikai címe pedig az a fizikai cím, ahol a szegmenst be kell tölteni. Alkalmazási programok esetében ezek a címek mindig ugyanazok. A Grub a képszegmenseket fizikai címük alapján tölti be. Mivel a Grub nem állít be lapozást, a szegmens virtuális címének meg kell egyeznie a fizikai címével, mert a programunkban virtuális memória szintén nem konfigurálható.
SZEKCIÓK
Azt jelzi, hogy a szakaszok leírása a következő.
. = LMA;
Ez a kifejezés közli a linkelővel, hogy az összes következő szakasz az LMA-cím után van.
IGAZÍTÁS (0x1000)
A fenti direktíva azt jelenti, hogy a szakasz 0x1000 bájthoz igazodik.
.multiboot ALIGN (0x1000) : ( loader.o(.text) )
Egy külön multiboot szakasz, amely tartalmazza a loader.o fájl .text szakaszát, biztosítja, hogy a többszörös rendszerindítási formátumú aláírás a kernelkép első 8 kb-jába kerüljön.
.bss: ( *(KÖZÖS) *(.bss) )
*(COMMON) az a terület, ahol a .comm és .lcomm utasítások memóriát foglalnak le. A .bss részbe helyezzük.
/ELdobni/ : ( *(.comment) )
A DISCARD (eldobás) megjelölésű összes rész eltávolítódik a képről. Ebben az esetben eltávolítjuk a .comment részt, amely a linker verziójával kapcsolatos információkat tartalmaz.
Most fordítsuk le a kódot egy bináris fájlba a következő parancsokkal:
as -o loader.o loader.s gcc -Include -Wall -fno-builtin -nostdinc -nostdlib -o kernel.o -c kernel.c gcc -Include -Wall -fno-builtin -nostdinc -nostdlib -o printf.o -c common/printf.c gcc -Include -Wall -fno-builtin -nostdinc -nostdlib -o screen.o -c common/screen.c ld -T linker.ld -o kernel.bin kernel.o screen.o printf .o rakodó.o
Az objdump segítségével nézzük meg, hogyan néz ki a kernel kép linkelés után:
objdump -ph ./kernel.bin
Amint látja, a kép szakaszai megegyeznek a linker szkriptben leírtakkal. A linker 3 szegmenst alkotott a leírt szakaszokból. Az első szegmens a .multiboot, .text, .rodata szakaszokat tartalmazza, virtuális és fizikai címe pedig 0x00100000. A második szegmens a .data és a .bss szakaszokat tartalmazza, és a 0x00104000 címen található. Tehát minden készen áll a fájl betöltésére a Grub segítségével.
4. lépés A Grub Boot Loader előkészítése:
Grub mappa létrehozása:
mkdir grub
Másoljon ebbe a mappába néhány Grub-fájlt, amelyek szükségesek a lemezképre való telepítéshez (a következő fájlok léteznek, ha a Grub telepítve van a rendszeren). Ehhez a következő parancsokat kell futtatnia:
cp /usr/lib/grub/i386-pc/stage1 ./grub/cp /usr/lib/grub/i386-pc/stage2 ./grub/cp /usr/lib/grub/i386-pc/fat_stage1_5 ./grub /
Hozzon létre egy grub/menu.lst fájlt a következő tartalommal:
timeout 3 alapértelmezett 0 cím mini_os root (hd0,0) kernel /kernel.bin
5. lépés: Automatizálja és hozzon létre egy rendszerindító képet:
Az építési folyamat automatizálásához a make segédprogramot fogjuk használni. Ehhez létrehozunk egy makefile-t, amely lefordítja forrás, építse fel a kernelt és hozzon létre egy rendszerindító lemezképet. A Makefile-nek a következő tartalommal kell rendelkeznie:CC=gcc CFLAGS=-Fal -fno-builtin -nostdinc -nostdlib LD=ld OBJFILES=\loader.o\common/printf.o\common/screen.o\kernel.o kép: @echo "A hdd.img létrehozása. .." @dd if=/dev/zero of=./hdd.img bs=512 count=16065 1>/dev/null 2>&1 @echo "Az első rendszerindító FAT32 partíció létrehozása..." @losetup /dev/ loop1 ./hdd.img @(echo c; echo u; echo n; echo p; echo 1; echo ; echo ; echo a; echo 1; echo t; echo c; echo w;) | fdisk /dev/loop1 1>/dev/null 2>&1 || true @echo "Partíció csatlakoztatása a /dev/loop2-hez..." @losetup /dev/loop2 ./hdd.img \ --offset `echo \`fdisk -lu /dev/loop1 | sed -n 10p | awk "(nyomtatás $3 $)"\`*512 | bc` \ --sizelimit `echo \`fdisk -lu /dev/loop1 | sed -n 10p | awk "(nyomtatás $4$)"\`*512 | bc` @losetup -d /dev/loop1 @echo "Partíció formázása..." @mkdosfs /dev/loop2 @echo "Kernel és grub fájlok másolása a partícióra..." @mkdir -p tempdir @mount /dev/loop2 tempdir @mkdir tempdir/boot @cp -r grub tempdir/boot/ @cp kernel.bin tempdir/ @sleep 1 @umount /dev/loop2 @rm -r tempdir @losetup -d /dev/loop2 @echo "A GRUB telepítése. .." @echo "eszköz (hd0) hdd.img \n \ root (hd0,0) \n \ beállítás (hd0) \n \ kilépés\n" | grub --batch 1>/dev/null @echo "Kész!" all: kernel.bin rebuild: clean all .s.o: as -o [e-mail védett] $< .c.o: $(CC) -Iinclude $(CFLAGS) -o [e-mail védett]-c $< kernel.bin: $(OBJFILES) $(LD) -T linker.ld -o [e-mail védett]$^ tiszta: rm -f $(OBJFILES) hdd.img kernel.bin
A fájl két fő célt deklarál: az all, amely a kernelt fordítja, és az image, amely létrehozza a rendszerindító lemezt. Az all target a szokásos makefile-hoz hasonlóan tartalmazza az .s.o és .c.o alcélokat, amelyek a *.s és *.c fájlokat objektumfájlokká fordítják (*.o), valamint a kernel.bin generálására szolgáló célt, amely meghívja a linker a korábban létrehozott szkripttel. Ezek a célok pontosan ugyanazokat a parancsokat hajtják végre, mint a 3. lépésben.
A legnagyobb érdeklődés itt az alkotás rendszerindító kép hdd.img (képcél). Lépésről lépésre nézzük meg, hogyan történik ez.
dd if=/dev/nulla of=./hdd.img bs=512 count=16065 1>/dev/null 2>&1
Ez a parancs létrehoz egy képet, amellyel a további munka zajlik. A szektorok száma nem véletlenszerűen van kiválasztva: 16065 = 255 * 63. Alapértelmezés szerint az fdsik úgy kezeli a lemezt, mintha CHS geometriája lenne, amelyben a fejlécek (H) = 255, a szektorok (S) = 63 és a hengerek (C) lemez méretétől függ. És így, minimális méret Az a lemez, amellyel az fdsik az alapértelmezett geometria megváltoztatása nélkül tud dolgozni, 512 * 255 * 63 * 1 = 8225280 bájt, ahol 512 a szektor mérete és 1 a hengerek száma.
Ezután létrejön a partíciós tábla:
losstup /dev/loop1 ./hdd.img (echo c; echo u; echo n; echo p; echo 1; echo ; echo ; echo a; echo 1; echo t; echo c; echo w;) | fdisk /dev/loop1 1>/dev/null 2>&1 || igaz
Az első parancs a hdd.img fájlt a /dev/loop1 blokkeszközhöz csatolja, lehetővé téve a fájl eszközként történő kezelését. A második parancs egy partíciós táblát hoz létre a /dev/loop1 eszközön, amely 1 elsődleges partíciót tartalmaz rendszerindító partíció a teljes lemezt elfoglaló és FAT32 címkével ellátott lemez.
Ezután formázzuk a létrehozott partíciót. Ehhez fel kell szerelni blokkeszközként, és formázni kell.
losstup /dev/loop2 ./hdd.img \ --offset `echo \`fdisk -lu /dev/loop1 | sed -n 10p | awk "(nyomtatás $3 $)"\`*512 | bc` \ --sizelimit `echo \`fdisk -lu /dev/loop1 | sed -n 10p | awk "(nyomtatás $4$)"\`*512 | bc`lostup -d /dev/loop1
Az első parancs felcsatolja a korábban létrehozott partíciót a /dev/loop2 eszközre. Az -offset paraméter a szakasz elejének címét adja meg, a -sizelimit pedig a szakasz végének címét. Mindkét beállítás az fdisk paranccsal érhető el.
mkdosfs /dev/loop2
Az mkdosfs segédprogram formázza a partíciót fájlrendszer FAT32.
A kernel közvetlen felépítéséhez a korábban a klasszikus makefile szintaxisban tárgyalt parancsokat használjuk.
Most nézzük meg, hogyan kell telepíteni a GRUB-ot egy partícióra:
mkdir -p tempdir # létrehoz egy ideiglenes könyvtárat mount /dev/loop2 tempdir # felcsatolja a partíciót az mkdir könyvtárba tempdir/boot # létrehozza a /boot könyvtárat a partíción cp -r grub tempdir/boot/ # másolja a grub mappát a / mappába boot cp kernel.bin tempdir / # a rendszermagot a partíció gyökerébe másolja sleep 1 # várja az Ubuntu umount /dev/loop2 # az ideiglenes mappa leválasztása rm -r tempdir # az ideiglenes mappa törlése losstup -d /dev/loop2 # válassza le a partíciót
A fenti parancsok végrehajtása után a kép készen áll a GRUB telepítésére. A következő parancs telepíti a GRUB-ot a hdd.img lemezkép MBR-ébe.
echo "eszköz (hd0) hdd.img \n \ root (hd0,0) \n \ beállítás (hd0) \n \ kilépés\n" | grub --batch 1>/dev/null
Minden készen áll a tesztelésre!
6. lépés Indítás:
A fordításhoz használja a következő parancsot:
minden
Ezután a kernel.bin fájlnak meg kell jelennie.
Rendszerindító lemezkép létrehozásához használja a következő parancsot:
sudo make image
Ennek eredményeként a hdd.img fájlnak meg kell jelennie.
Most már indítható a hdd.img lemezképről. Ezt a következő paranccsal ellenőrizheti:
qemu -hda hdd.img -m 32
vagy:
qemu-system-i386 -hda hdd.img 
Valódi gépen való ellenőrzéshez ezt a képet kell hozzáadni egy flash meghajtóhoz, és onnan kell indítani. Például ez a parancs:
sudo dd if=./hdd.img of=/dev/sdb
Összefoglalva, azt mondhatjuk, hogy a megtett intézkedések eredményeként olyan forráskódok és szkriptek készletét kapjuk, amelyek lehetővé teszik különféle kísérletek elvégzését a rendszerprogramozás területén. Az első lépés a rendszerszerűség megteremtése felé szoftver mint például a hipervizorok és az operációs rendszerek.
Mi a teendő, ha le kell futtatnia egy programot, de nem akarja telepíteni? Nulla telepítési segítség!
Világszerte emberek milliárdjai használnak számítógépet vagy laptopot a műtőben. Windows rendszer. Általában telepítünk programokat, ami után ezek elviszik szabad hely lemezen és használatban RAM. Ez csökkenti a számítógép sebességét.
Ma elmondjuk, hogyan növelheti számítógépe teljesítményét és csökkentheti a memória terhelését. Ehhez futni kell szükséges programokat telepítésük nélkül.
Hogyan futtatható a program telepítés nélkül?
1. Töltse le a Zero Install programot.
Először töltse le a Zero Install szoftvert, amely lehetővé teszi a programok futtatását anélkül, hogy telepítenie kellene őket a számítógépére.
2. Telepítse a Nulla telepítést.
Miután letöltötte a Zero Install programot, kattintson duplán a fájlra a telepítéshez. Aztán fuss új program a számítógépeden.
3. Kattintson a gombrafalazat "Katalógus".
Amint a Zero Install elindul a számítógépen, ill Windows laptop, akkor a „Katalógus” fülre kell lépnie. Itt kattintson a "Lista frissítése" gombra a lista frissítéséhez elérhető programokat.
4. Válassza ki a futtatni kívánt programot.
Nézze meg alaposan teljes lista elérhető programokat. Ha megtalálta a kívánt programot, válassza ki, és kattintson a "Futtatás" gombra. Egyes programok választhatnak Firefox böngésző vagy a Mozilla futni. Csak várja meg, amíg a szoftver teljesen letöltődik, és telepítés nélkül futtathatja a számítógépén.
Összegzés
Ha a számítógépének nincs elég szabad memóriája vagy teljesítménye a program futtatásához, használhatja a Zero Install (Zéró telepítés) funkciót. Úgy gondolom, hogy ez egy nagyszerű módja annak, hogy ne zsúfolja el számítógépét azokkal a programokkal, amelyekre egyszerre szüksége van.
Ezenkívül előfordulhat, hogy számítógépe nem rendelkezik elegendő energiával bizonyos programok futtatásához, például az Eclipse IDE, a JetBrains, a NetBeans stb. Ezek nagyon nehéz programok a fejlesztők számára, amelyek sok RAM-ot fogyasztanak.
A Zero Install segít futtatni ezeket és sok más programot anélkül, hogy telepítené őket a számítógépére.
