Doriți să permiteți utilizatorilor cu un cont standard să ruleze aplicații cu privilegii de administrator fără UAC sau o solicitare de parolă? Atunci vă voi spune cum să o faceți. Vom crea o scurtătură folosind comanda runas / salvatcare salvează parola. Rețin că acest lucru poate fi considerat o gaură de securitate - un utilizator obișnuit va putea folosi runas / salvarecred pentru a executa orice comandă în numele administratorului, fără a introduce o parolă. Cu toate acestea, în unele situații, acest lucru poate fi util - de exemplu, dacă doriți ca copilul dvs. de sub un cont standard să poată rula aplicații ca administrator fără să vă solicite.
Activați contul de admin
În primul rând, trebuie să activați contul de administrator încorporat, care este dezactivat implicit. Deci, faceți clic dreapta pe linia rapidă de comandă și selectați „Execută ca administrator”.
În fereastra promptului de comandă care se deschide, executați următoarea comandă:
administrator utilizator / activ: da
Contul este acum activat, deși fără parolă. Pentru a seta o parolă, deschideți Panoul de control, selectați categoria Conturi utilizator și securitate familială, apoi deschideți meniul Conturi utilizator. Apoi, faceți clic pe linkul „Gestionați un alt cont”.
Selectați un cont de administrator, faceți clic pe butonul „Creare parolă” și creați o parolă pentru contul de administrator.
Creați o comandă rapidă
Acum vom crea o scurtătură care va lansa aplicația cu privilegii de administrator. Faceți clic dreapta pe desktop, selectați "Create", apoi faceți clic pe "Comandă rapidă".
În fereastra care se deschide, introduceți comanda de următorul tip:
runas / utilizator: ComputerName\\ Administrator / salvat ” C: \\ Path \\ To \\ Program.exe“
Vă rugăm să rețineți că trebuie să înlocuiți ComputerName în numele computerului dvs. și C: \\ Path \\ To \\ Program.exe la calea completă către programul pe care doriți să îl rulați. De exemplu, dacă numele computerului este Laptop, iar programul pe care doriți să îl rulați este Auslogics BoostSpeed, trebuie să introduceți următoarea cale:
runas / user: Laptop \\ Administrator / savecred „C: \\ Program Files \\ Auslogics \\ Auslogics BoostSpeed \u200b\u200b\\ BoostSpeed.exe"
În fereastra următoare, introduceți un nume pentru scurtătură. Dacă doriți, puteți selecta o pictogramă pentru o scurtă comandă - faceți clic dreapta pe ea și selectați „Proprietăți”.
În caseta de dialog „Proprietăți”, faceți clic pe butonul „Modificați pictograma” și selectați-l pe cel corespunzător.
Când faceți dublu clic pe comanda rapidă pentru prima dată, vi se va cere să introduceți parola pentru contul de administrator pe care l-ați creat anterior.
Această parolă va fi salvată - data viitoare când rulați programul, nu mai trebuie să o introduceți din nou.
Așa cum am menționat mai sus, în conturile standard, utilizatorii pot rula orice program cu drepturi de administrator fără a introduce o parolă (folosind comanda runas / savecred), așa că rețineți acest lucru.
Parola de administrator este stocată în „Manager de credențe” - dacă doriți să ștergeți parola salvată, o puteți face de acolo.
Să aveți o zi minunată!
Unele aplicații Windows necesită permisiuni ridicate și trebuie să le executați ca administrator. Interogarea " Controlul contului de utilizator"(Controlul contului de utilizator sau UAC), în care sistemul îți cere acordul pentru a lansa aplicația.
Mulți utilizatori cred în mod incorect că „Controlul contului utilizatorului” îl interferează și îl dezactivează doar. În același timp, securitatea computerului este grav afectată. Consimțământul utilizatorului de a lansa aplicații nu mai este necesar și orice program dăunător poate rula și rula fără restricții. De asemenea, prezența unui antivirus nu poate garanta 100% securitatea computerului.
În acest articol vă voi spune cum să simplificați procesul de lansare a aplicațiilor selectate în numele administratorului, fără a dezactiva UAC (integral sau parțial) și fără a compromite securitatea.
Pentru a rula aplicația ca administrator, puteți utiliza mai multe metode:
Ca exemplu, vom rula linie de comandă (cmd) ca administrator.
Metoda nr. 1 (normală) - începeți cu butonul din dreapta al mouse-ului (este afișată cererea UAC)
Faceți clic dreapta pe pictogramă aplicația dorită și selectați „ Rulați ca administrator":
Metoda numărul 2 - începeți să utilizați „ Ctrl + Shift + Enter"(Se afișează solicitarea UAC)
presa start, în bara de căutare, tastați comanda dorită și faceți clic Ctrl + Shift + Enter.
Metoda nr. 3 - setați lansarea ca administrator în proprietățile de scurtătură (este afișată solicitarea UAC)
Faceți clic dreapta pe comanda rapidă dorită și selectați " proprietăţi".
Accesați „ etichetă„Faceți clic pe“ în plus„bifează caseta” Rulați ca administrator":
Sau mergeți la „ compatibilitate"și bifează caseta" Rulați acest program ca administrator":
Numărul metodei 4 - simplificați lansarea pentru aplicațiile selectate utilizând planificatorul de sarcini (solicitarea UAC nu este afișată)
Important! Această metodă funcționează numai pentru conturile din grup. Administratorii. în utilizatori obișnuiți nu va funcționa, deoarece drepturile lor sunt limitate la plafon.
Trecem la cel mai interesant mod. Dacă există o aplicație pe care o executați constant și este primită de la un producător de software fiabil, de exemplu, această aplicație Windows, puteți simplifica lansarea. Creați o comandă rapidă pentru program dorit nu durează mai mult de 2 minute și acest lucru va scăpa de acțiuni inutile în viitor. Lansăm programator sarcini (start---> Toate programele ---> standard---> Instrumente de sistem---> Scheduler de sarcini) și faceți clic pe „ Creare sarcină":
specifica Prenumepentru o nouă sarcină și bifați caseta " Performă cu cele mai înalte drepturi":
Accesați fila acţiuniclick " crea", în următoarea fereastră faceți clic pe" Privire de ansamblu asupra":
Specificați calea către aplicația dorită și faceți clic pe „ deschis":
Măriți imaginea
Împingeți " în regulă":
Închideți planificatorul și treceți la crearea unei comenzi rapide.
Pentru a crea o scurtătură pe desktop, faceți clic dreapta, selectați " crea" ---> "etichetă":
Pe teren Locația obiectului introduceți:
Schtasks / run / tn cmd_admin
unde cmd_admin - numele sarcinii pe care am creat-o. Dacă numele conține spații, trebuie să fie anexat în ghilimele.
Setați numele etichetei:
Măriți imaginea
Comanda rapidă creată și gata de utilizare.
Pentru a schimba pictograma - faceți clic dreapta pe scurtătura, selectați " proprietăţi":
Accesați „ etichetă"și faceți clic pe" Schimbați pictograma":
"Privire de ansamblu asupra..."
Specificați calea către program:
Măriți imaginea
Selectați pictograma dorită și închideți ambele ferestre cu " în regulă":
Acum, lansarea aplicației dorite ca administrator se realizează făcând dublu clic pe comanda rapidă creată, în timp ce solicitarea UAC nu este afișată și securitatea rămâne intactă.
Utilitatea pentru automatizarea "Metodei nr. 4"
În cazul în care aveți nevoie pentru a crea comenzi rapide pentru un număr mare de programe, este convenabil să utilizați utilitarul.
Lucrul cu utilitatea se reduce la doi pași simpli:
- instalare
- Trageți și plasați fișierul executabil (* .exe, * .bat, * .cmd) pe scurtătura de utilitate:
Auto focus pe un program de rulare
Specificul lansării aplicațiilor din programator este că accentul pe fereastră nu este tradus și, de exemplu, pentru a tasta o comandă pe linia de comandă, trebuie să faceți clic pe fereastră în plus. Un astfel de comportament poate ajuta la automatizarea operațiilor programate de rutină, dar pentru „Metoda nr. 4” acest lucru nu este întotdeauna convenabil.
Există mai multe metode de „lucru în jurul”. Ele funcționează puțin diferit, așa că alege-l pe cel mai potrivit. Primul este mai convenabil pentru rularea programelor, iar al doilea pentru rularea scripturilor.
Adaugă la crearea sarcinii:
Folosind comanda start
Program sau scenariu:
argumente:
/ c start / d "program_path" file_name.exe
/ c start / d "C: \\ Windows \\ System32 \\" cmd.exe
Folosind utilitatea NirCmd
Program sau scenariu:
Path_k_nircmd \\ nircmd.exe
argumente:
Exec show "program_path \\ file_name.exe"
Exec show "C: \\ Windows \\ System32 \\ cmd.exe"
Lansarea dialogului Run ca administrator
Similar lansării liniei de comandă, puteți configura lansarea " alerga", iar comenzile introduse în acesta vor fi, de asemenea, lansate în numele administratorului. Comoditatea acestei abordări este că lista comenzilor folosite anterior este salvată și puteți selecta cea dorită din listă.
Când creați o sarcină în planificator, în „ Crearea de acțiuni„Precizați:
în câmp " Program sau scenariu":
rundll32
în câmp " Adăugați argumente":
Shell32.dll, # 61
Descărcați utilitarul, despachetați-l. Lansăm linia de comandă, introducem comanda dorită, sintaxa este destul de simplă:
<путь к утилите> <путь к нужному приложению>
Este afișat un prompt UAC și aplicația pornește ca administrator.
Notă: În context meniu Windows 7 există o funcție foarte convenabilă pentru a copia calea fișierului: mențineți schimbare, faceți clic dreapta pe fișier, selectați " Copiați ca cale".
Rularea programelor de către un utilizator ca administrator fără a introduce o parolă de administrator
Important! Această metodă este nesigură, deoarece permite unui utilizator cu drepturi limitate să ruleze cod cu drepturi depline. Un utilizator viclean sau un malware poate profita de acest lucru și poate compromite sistemul.
Să luăm în considerare încă o sarcină interesantă: contul tău Înregistrare Windows aparține grupului de administratori, există unul sau mai mulți conturiinclus în grupul de utilizatori. Utilizatorul trebuie să execute un program care necesită ridicarea privilegiilor. De obicei, arată așa: utilizatorul face clic dreapta pe fișier și selectează „Executare ca administrator” și apare o solicitare pentru introducerea parolei de administrator:
Desigur, acordarea unei parole de administrator utilizatorilor nu este o idee bună. Pentru a evita acest lucru, vom folosi utilitatea AdmiLink a lui Alexei Kuryakin. Cu acesta, administratorul poate crea o comandă rapidă pentru ca utilizatorul să lanseze programul necesar, în timp ce introducerea parolei de administrator este necesară doar o dată - la crearea scurtăturii. Când utilizatorul începe programul, parola va fi transmisă într-o formă criptată.
Această metodă va funcționa dacă pornirea programului este posibilă numai în numele administratorului și dezvoltatorul nu a uitat să indice această condiție în manifest. Cu toate acestea, rămâne un număr mare programe vechi sau programe care pot fi pornite ca în modul normalși în numele administratorului (în acest caz, va fi disponibil un set de funcții diferite). Când încercați să rulați un astfel de program folosind AdmiLink, acesta începe în modul normal (fără privilegii administrative). Și dacă încercați să introduceți o bifă în „Numărul metodei 3. Stilul original al autorului este salvat.
Ce se întâmplă dacă trebuie să rulați programul, dar nu doriți să îl instalați? Zero Install la salvare!
Miliarde de oameni din întreaga lume folosesc computere sau laptopuri în sala de operație. sistem Windows. De obicei, instalăm programe, după care se iau spațiu liber pe disc și utilizare memorie de acces aleatoriu. Acest lucru reduce viteza computerului.
Astăzi vă vom spune cum puteți crește performanța computerului și reduce sarcina pe memorie. Pentru a face acest lucru, trebuie să rulați programele necesare fără a le instala.
Cum să executați programul fără instalare?
1. Descărcați Zero Install.
În primul rând, descărcați software-ul Zero Install, care vă permite să rulați programe fără a fi necesar să le instalați pe computer.
2. Instalați Zero Install.
După ce ați descărcat Zero Install, faceți dublu clic pe fișier pentru a-l instala. Apoi aleargă program nou pe computer.
3. Faceți clic pezidărie „Catalog”.
Imediat ce Zero Install este lansat pe computer sau windows laptop, ar trebui să accesați fila „Catalog”. Faceți clic pe butonul „Actualizare listă” pentru a actualiza lista de programe disponibile.
4. Selectați un program pe care să îl rulați.
Privește cu atenție lista completă programe disponibile. Dacă găsiți programul de care aveți nevoie, selectați-l și faceți clic pe „Executare”. Unele programe pot alege browserul Firefox sau Mozilla pentru a rula. Abia așteptați descărcarea completă. software-ul, după care îl puteți rula pe computer fără să îl instalați.
Rezumând
Dacă computerul nu dispune de suficientă memorie sau putere gratuită pentru a rula programul, puteți utiliza Zero Install. Cred că acesta este un mod minunat de a nu-ți lăsa computerul cu programele de care ai nevoie la un moment dat.
De asemenea, este posibil ca computerul dvs. să nu aibă suficientă putere pentru a rula anumite programe, de exemplu, Eclipse IDE, JetBrains, NetBeans etc. Acestea sunt programe cu adevărat dificile pentru dezvoltatorii care consumă o cantitate mare de memorie RAM.
Zero Install va ajuta la lansarea acestor programe, precum și a multor alte programe, fără a le instala pe computer.
Cel mai important lucru nu a fost descris în detalii suficiente: cum să executați acest cod pe hardware real? Cum să-ți creezi propria ta discul de pornire? În acest articol, vom răspunde în detaliu la toate aceste întrebări (parțial, aceste probleme au fost discutate în articolul precedent, dar pentru comoditatea lecturii ne permitem o mică duplicare a materialului).
Pe Internet există o mulțime de descrieri și tutoriale despre cum să scrieți propriul mini-OS, chiar și există sute de mici sisteme de hobby-uri gata făcute. Una dintre cele mai demne resurse pe acest subiect, pe care aș dori să le evidențiez este portalul osdev.org. Pentru a completa articolul anterior despre PCI (și posibilitatea de a scrie articole ulterioare despre diferitele funcții care sunt prezente în orice sistem de operare modern), vom descrie instrucțiuni pas cu pas pentru a crea un disc de boot cu programul obișnuit din C. Am încercat să scriem cât mai detaliat, astfel încât să ne putem da seama de unul singur.
Așadar, obiectivul: depunând cât mai puțin efort posibil, creează-ți propria unitate flash USB bootabilă, care doar imprimă clasicul „Hello World” pe ecranul computerului.
Pentru a fi mai precis, trebuie să „intrăm” în modul protejat cu adresarea de pagini dezactivată și întrerupe - cel mai simplu mod de procesor cu comportamentul obișnuit pentru un program de consolă simplu. Cel mai rezonabil mod de a atinge acest obiectiv este să construiți un nucleu care să suporte formatul multiboot și să îl încărcați folosind popularul încărcătoare de încărcare. O alternativă la această soluție este să scrieți propriul record de boot (VBR), care ar încărca propriul dvs. loader scris (loader). Cel puțin un bootloader decent ar trebui să poată lucra cu discul, cu sistemul de fișiere și să analizeze imagini elf. Acest lucru înseamnă că trebuie să scrii mult cod de asamblator și mult cod C. În scurt, este mai ușor să folosești Grub, care știe deja să facă tot ce este necesar.
Pentru început, este necesar un anumit set de compilatoare și utilități pentru acțiuni suplimentare. Cel mai simplu mod este să folosiți un fel de Linux (de exemplu, Ubuntu), deoarece acesta va conține deja tot ce aveți nevoie pentru a crea o unitate flash de pornire. Dacă obișnuiți să lucrați în Windows, puteți configura o mașină virtuală cu Linux (folosind Virtual Box sau VMware Workstation).
Dacă utilizați Linux Ubuntu, trebuie să instalați mai întâi mai multe utilități:
1. Grub. Pentru a face acest lucru, utilizați comanda:
Sudo apt-get install grub
2. Qemu. Este necesar pentru a testa rapid și a debugula totul (Link la articolul despre debugger), pentru aceasta comanda este similară:
Sudo apt-get install qemu
Acum, planul nostru arată astfel:
1. Creați un program C care tipărește o linie pe ecran.
2. compilați din ea o imagine (kernel.bin) în format miniboot, astfel încât să fie disponibilă pentru descărcare folosind GRUB.
3. Creați un fișier cu imagini de disc de boot și formatați-l.
4. Instalați Grub pe această imagine.
5. copiați programul creat (kernel.bin) pe disc.
6. arde imaginea la medii fizice sau rulați-l în qemu.
și procesul de pornire a sistemului:
Pentru ca acesta să funcționeze, va trebui să creați mai multe fișiere și directoare:
Pasul 1. Crearea codului programului țintă (kernel):
Creați un fișier kernel.c care va conține următorul cod care tipărește un mesaj pe ecran:
#include "printf.h" #include "screen.h" #include "types.h" void main (void) (clear_screen (); printf ("n \u003e\u003e\u003e Hello World! n");)
Totul este familiar și simplu aici. Adăugarea funcțiilor printf și clear_screen va fi discutată mai târziu. Între timp, trebuie să completați acest cod cu tot ceea ce este necesar pentru a putea fi încărcat de Grub.
Pentru ca nucleul să fie în format multiboot, aveți nevoie de următoarea structură în primii 8 kilobiți ai imaginii kernel-ului:
Dacă toate aceste condiții sunt îndeplinite, atunci Grub trece prin% eax și% ebx înregistrează un indicator la structura multiboot Information și respectiv la valoarea 0x1BADB002. Structura multiboot Information conține diverse informații, inclusiv o listă de module încărcate și locația acestora, care pot fi necesare pentru încărcarea ulterioară a sistemului.
Pentru ca fișierul de program să conțină semnăturile necesare, creați un fișier loader.s cu următorul conținut:
Text .global loader # făcând punctul de intrare vizibil linker-ului # setarea antetului Multiboot - consultați documentele GRUB pentru detalii .set FLAGS, 0x0 # acesta este câmpul "flag" multiboot .set MAGIC, 0x1BADB002 # "număr magic" permite bootloader-ului să găsească antetul .set CHECKSUM, - (MAGIC + FLAGS) # checkum necesar .align 4 .long MAGIC .long FLAGS .long CHECKSUM # rezerva initial kernel stack stack .set STACKSIZE, 0x4000 # adica 16k. .lcomm stack, STACKSIZE # rezerva 16k stack .comm mbd, 4 # vom folosi acest lucru în kmain .comm magic, 4 # vom folosi acest lucru în kmain loader: movl $ (stack + STACKSIZE),% esp # set the stack movl% eax, magic # Număr magic multiboot movl% ebx, mbd # Structura de date multiboot apel principal # call C cod cli hang: hlt # stop machine should kernel return jmp hang
Luați în considerare codul mai detaliat. Acest cod este aproape neschimbat de la wiki.osdev.org/Bare_Bones. Deoarece gcc este utilizat pentru compilare, se folosește sintaxa GAS. Să aruncăm o privire mai atentă la ceea ce face acest cod.
Tot codul ulterior se va încadra în secțiunea executabilă .text.
Încărcător global
Declarăm simbolul încărcătorului vizibil pentru linker. Acest lucru este necesar deoarece linkerul va folosi încărcătorul ca punct de intrare.
Setează FLAGS, 0x0 # assign FLAGS \u003d 0x0 .set MAGIC, 0x1BADB002 # assign MAGIC \u003d 0x1BADB002 .set CHECKSUM, - (MAGIC + FLAGS) # assign CHECKSUM \u003d - (MAGIC + FLAGS) .align 4 # aliniază datele ulterioare cu 4 octeți. long MAGIC # place current value MAGIC .long FLAGS # place current value FLAGS. long CHECKSUM # place current value CHECKSUM
Acest cod formează o semnătură a formatului Multiboot. Directiva .set stabilește valoarea caracterului la expresia din dreapta virgulei. Directiva .align 4 aliniază conținutul ulterior la 4 octeți. Directiva.long stochează valoarea în patru octeți următori.
Setați STACKSIZE, 0x4000 # assign STACKSIZE \u003d 0x4000 .lcomm stack, STACKSIZE # rezervă by STACKSIZE bytes. stivă se referă la range.comm mbd, 4 # rezervă 4 octeți pentru variabila mdb în zona COMUNĂ .comm magic, 4 # rezervă 4 octeți pentru variabila magică din zona COMUNĂ
În timpul procesului de pornire, grub nu configurează stiva și primul lucru pe care ar trebui să îl facă kernelul este să configureze stiva, pentru aceasta rezervăm 0x4000 (16Kb) octeți. Directiva.lcomm rezervă în secțiunea.bss numărul de octeți specificat după punctul zecimal. Stiva de nume va fi vizibilă numai în fișierul compilat. Directiva .comm face același lucru cu .lcomm, dar numele simbolului va fi declarat la nivel global. Aceasta înseamnă că, scriind următoarea linie în cod C, o putem folosi.
extern int magie
Și acum ultima parte:
Încărcător: movl $ (stivă + STACKSIZE),% esp # inițializează stiva movl% eax, magie # scrie% eax la adresa magică movl% ebx, mbd # scrie% ebx în mbd apel principal # apel principal cli funcție # deconectare întrerupe din hardware hang: hlt # stop processor până când se produce întreruperea jmp hang # jump to hang label
Prima instrucțiune salvează valoarea de sus a stivei în registrul% esp. Pe măsură ce stiva crește, adresa finalului intervalului alocat pentru stivă este scrisă în% esp. Cele două instrucțiuni ulterioare stochează în intervalele rezervate anterior de 4 octeți valorile pe care Grub le trece în registrele% eax,% ebx. Apoi se numește funcția principală, care este deja scrisă în C. Dacă reveniți de la această procedură, procesorul se va bucla.
Pasul 2. Pregătirea codului suplimentar pentru program (biblioteca de sistem):
Întrucât întregul program este scris de la zero, funcția printf trebuie scrisă de la zero. Pentru a face acest lucru, pregătiți mai multe fișiere.
Creați un folder comun și includeți:
Mkdir comun include mkdir
Creați un fișier commonprintf.c care va conține implementarea funcției printf familiar. Acest întreg fișier poate fi preluat din proiectul www.bitvisor.org/. Calea către fișierul din sursele bititorului: core / printf.c. În fișierul printf.c copiat de la bitvisor, pentru a fi utilizat în programul țintă, trebuie să înlocuiți liniile:
#include "initfunc.h" #include "printf.h" #include "putchar.h" #include "spinlock.h"
pe linie:
#include "types.h" #include "stdarg.h" #include "screen.h"
Apoi, eliminați funcția printf_init_global și toate referințele din acest fișier:
Static void printf_init_global (void) (spinlock_init (& printf_lock);) INITFUNC ("global0", printf_init_global);
Apoi ștergeți variabila printf_lock și toate referințele sale din acest fișier:
Spinlock_static_t printf_lock; ... spinlock_lock (& \u200b\u200bprintf_lock); ... spinlock_unlock (& \u200b\u200bprintf_lock);
Funcția printf folosește funcția putchar, care de asemenea trebuie scrisă. Pentru aceasta, creați un fișier commonscreen.c cu următorul conținut:
#include "types.h" #define GREEN 0x2 #define MAX_COL 80 // Numărul maxim de coloane #define MAX_ROW 25 // Numărul maxim de rânduri #define VRAM_SIZE (MAX_COL * MAX_ROW) // Dimensiunea ecranului, pe scurt "s # define DEF_VRAM_BASE 0xb8000 // Baza implicită pentru memoria video statică nesemnată char curr_col \u003d 0; static nesigned char curr_row \u003d 0; // Scrieți caracterul la locația curentă a ecranului #define PUT (c) ((scurt nesemnat *) (DEF_VRAM_BASE)) [ (curr_row * MAX_COL) + curr_col] \u003d (GREEN<< 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 >\u003d MAX_ROW) (curr_row \u003d 0;) pauză; cazul "b": if (curr_col\u003e 0) (curr_col - \u003d 1; PUT ("");) break; implicit: PUT (c); curr_col + \u003d 1; if (curr_col\u003e \u003d MAX_COL) (curr_col \u003d 0; curr_row + \u003d 1; if (curr_row\u003e \u003d MAX_ROW) (curr_row \u003d 0;))); ) void putchar (int c) (if (c \u003d\u003d "n") cons_putc ("r"); cons_putc (c);) void clear_screen (void) (curr_col \u003d 0; curr_row \u003d 0; int i; pentru (i \u003d 0; i< VRAM_SIZE; i++) cons_putc(" "); curr_col = 0; curr_row = 0; }
Codul specificat conține logică simplă pentru imprimarea caracterelor pe ecran în modul text. În acest mod, doi octeți sunt folosiți pentru a scrie un caracter (unul cu codul caracterelor, celălalt cu atributele sale), scris direct în memoria video afișată imediat pe ecran și începând cu adresa 0xB8000. Rezoluția ecranului este de 80x25 de caractere. Personajul este imprimat direct folosind macro-ul PUT.
Acum lipsesc doar câteva fișiere antet:
1. Fișierul includeescreen.h. Declarează o funcție putchar, care este folosită în funcția printf. Conținutul fișierului:
#ifndef _SCREEN_H #define _SCREEN_H void clear_screen (void); void putchar (int c); # endif
2. Fișierul includeprintf.h. Declarează funcția printf, care este folosită în principal. Conținutul fișierului:
#ifndef _PRINTF_H #define _PRINTF_H int printf (format const * *, ...); # endif
3. Fișierul includeestdarg.h. Declară funcții pentru a returna argumentele al căror număr nu este cunoscut în prealabil. Întregul fișier este preluat din proiectul www.bitvisor.org/. Calea către fișierul din codul proiectului de biți: includecorestdarg.h.
4. Fișierul includeetypes.h. Declarează NULL și size_t. Conținutul fișierului:
#ifndef _TYPES_H #define _TYPES_H #define NULL 0 typedef unsigned int size_t; # endif
Astfel, folderele includ și comune conțin codul minim al bibliotecii de sistem de care are nevoie orice program.
Pasul 3. Crearea unui script pentru linker:
Creăm fișierul linker.ld, care va fi folosit de linker pentru a genera fișierul de program țintă (kernel.bin). Fișierul trebuie să conțină următoarele:
INTRARE (incarcator) LMA \u003d 0x00100000; SECȚIUNI (. \u003d LMA; .multiboot ALIGN (0x1000): (loader.o (.text)) .text ALIGN (0x1000): (* (. Text)) .rodata ALIGN (0x1000): (* (. Rodata *) ) .data ALIGN (0x1000): (* (. date)) .bss: (* (COMUN) * (. bss)) / DISCARD /: (* (. comentariu)))
Funcția încorporată ENTRY () vă permite să setați punctul de intrare pentru nucleul nostru. La această adresă grubul va trece controlul după ghetele sâmburelui. Folosind acest script, linkerul va crea un fișier binar în format ELF. Un fișier ELF este format dintr-un set de segmente și secțiuni. Lista segmentelor este cuprinsă în tabelul antetului Programului, lista secțiunilor din tabelul antet Secțiune. Linkerul funcționează cu secțiuni, încărcătorul de imagini (în cazul nostru, GRUB) cu segmente.
După cum puteți vedea în figură, segmentele sunt formate din secțiuni. Unul dintre câmpurile care descriu secțiunea este adresa virtuală la care ar trebui să se afle secțiunea în momentul executării. De fapt, un segment are 2 câmpuri care descriu locația sa: adresa virtuală a segmentului și adresa fizică a segmentului. Adresa virtuală a segmentului este adresa virtuală a primului octet al segmentului la momentul executării codului, adresa fizică a segmentului este adresa fizică la care trebuie încărcat segmentul. Pentru aplicații, aceste adrese corespund întotdeauna. Grub descarcă segmente de imagine la adresa lor fizică. Deoarece Grub nu configurează adresarea paginii, adresa virtuală a segmentului trebuie să se potrivească cu adresa fizică, deoarece în programul nostru memoria virtuală nu este de asemenea configurată.
LMA;
Această expresie indică linkerului că toate secțiunile ulterioare sunt după adresa LMA.
ALIGN (0x1000)
Directiva de mai sus înseamnă că secțiunea este aliniată la 0x1000 de octeți.
Multifoot ALIGN (0x1000): (loader.o (.text))
O secțiune multiboot separată, care include secțiunea .text din fișierul loader.o, este proiectată pentru a se asigura că semnătura formatului multiboot ajunge în primii 8kb din imaginea kernel-ului.
Bss: (* (COMUN) * (. Bss))
* (COMUN) este zona în care memoria este rezervată de instrucțiunile .com și.lcomm. O plasăm în secțiunea .bss.
/ DISCARD /: (* (. Comentariu))
Toate secțiunile marcate DISCARD sunt eliminate din imagine. În acest caz, ștergem secțiunea .com, care conține informații despre versiunea linkerului.
Acum compilați codul într-un fișier binar cu următoarele comenzi:
Ca -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 loader.o
Folosind funcția objdump, să vedem cum arată imaginea nucleului după legarea:
Objdump -ph ./kernel.bin
După cum puteți vedea, secțiunile din imagine coincid cu cele pe care le-am descris în scriptul linker. Linkerul a format 3 segmente din secțiunile descrise. Primul segment include secțiuni.multiboot, .text, .rodata și are o adresă virtuală și fizică 0x00100000. Al doilea segment conține secțiunile .data și .bss și este situat la 0x00104000. Deci totul este gata să descarce acest fișier folosind Grub.
Pasul 4. Pregătirea încărcătorului Grub:
Creare dosar grub:
Mkdir grub
Copiați mai multe fișiere Grub în acest folder care sunt necesare pentru instalarea acestuia pe imagine (următoarele fișiere există dacă Grub este instalat în sistem). Pentru aceasta, executați următoarele comenzi:
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 /
Creați un fișier grub / menu.lst cu următorul conținut:
Timeout 3 implicit 0 title mini_os root (hd0,0) kernel /kernel.bin
Pasul 5. Automatizarea și crearea unei imagini de pornire:
Pentru a automatiza procesul de construire, vom folosi utilitatea de marca. Pentru a face acest lucru, creați un fișier care va fi compilat cod sursă, construiți nucleul și creați o imagine de boot. Fișierul trebuie să conțină următorul conținut:
CC \u003d gcc CFLAGS \u003d -Wall -fno-builtin -nostdinc -nostdlib LD \u003d ld OBJFILES \u003d loader.o common / printf.o common / screen.o kernel.o imagine: @echo "Crearea hdd.img ..." @ dd if \u003d / dev / zero of \u003d. / hdd.img bs \u003d 512 count \u003d 16065 1\u003e / dev / null 2\u003e & 1 @echo "Crearea primei partiții FAT32 bootabile ..." @losetup / dev / loop1 ./hdd .img @ (ecou c; ecou u; ecou; ecou p; ecou 1; ecou; ecou; ecou; ecou 1; ecou t; ecou; ecou w;) | fdisk / dev / loop1 1\u003e / dev / null 2\u003e & 1 || true @echo "Montarea partiției pe / dev / loop2 ..." @losetup / dev / loop2 ./hdd.img - offset `echo` fdisk -lu / dev / loop1 | sed -n 10p | awk "(print $$ 3)" `* 512 | bc` --sizelimit `ecou` fdisk -lu / dev / loop1 | sed -n 10p | awk "(print $$ 4)" `* 512 | bc` @losetup -d / dev / loop1 @echo "Formatați partiția ..." @mkdosfs / dev / loop2 @echo "Copiați fișierele kernel și grub pe partiție ..." @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 "Instalarea GRUB. .. Dispozitivul "@echo" (hd0) hdd.img n root (hd0,0) n setup (hd0) n quitn "| grub --batch 1\u003e / dev / null @echo "Gata!" all: kernel.bin rebuild: clean all .s.o: as -o $ @ $< .c.o: $(CC) -Iinclude $(CFLAGS) -o $@ -c $< kernel.bin: $(OBJFILES) $(LD) -T linker.ld -o $@ $^ clean: rm -f $(OBJFILES) hdd.img kernel.bin
Două obiective principale sunt declarate în fișier: toate - compilează nucleul și imaginea - care creează discul de pornire. Toată ținta, ca de obicei makefile, conține subgoals.s.o și.c.o care compun fișiere * .s și * .c în fișiere obiect (* .o), precum și o țintă pentru generarea kernel.bin, care apelează linkerul cu scriptul creat anterior. Aceste obiective îndeplinesc exact aceleași comenzi care sunt enumerate la pasul 3.
Cel mai mare interes aici este crearea imagine de boot hdd.img (imaginea țintă). Să luăm în considerare în etape cum se întâmplă acest lucru.
Dd if \u003d / dev / zero of \u003d. / Hdd.img bs \u003d 512 count \u003d 16065 1\u003e / dev / null 2\u003e & 1
Această comandă creează o imagine cu care vor avea loc lucrări suplimentare. Numărul de sectoare nu a fost ales la întâmplare: 16065 \u003d 255 * 63. În mod implicit, fdsik funcționează cu discul ca și cum ar avea geometria CHS în care anteturile (H) \u003d 255, Sectoarele (S) \u003d 63 și Cilindrii © depind de dimensiunea discului . Astfel, dimensiunea minimă a discului cu care poate funcționa fdsik, fără a modifica geometria implicită, este 512 * 255 * 63 * 1 \u003d 8225280 octeți, unde 512 este dimensiunea sectorului și 1 este numărul cilindrilor.
În continuare, este creată o tabelă de partiție:
Losetup / dev / loop1 ./hdd.img (ecou c; ecou u; ecou; ecou p; ecou 1; ecou; ecou; ecou; ecou 1; ecou t; ecou c; ecou w;) | fdisk / dev / loop1 1\u003e / dev / null 2\u003e & 1 || adevărat
Prima comandă montează fișierul hdd.img pe dispozitivul de bloc / dev / loop1, permițându-vă să lucrați cu fișierul ca dispozitiv. A doua comandă creează tabelul de partiție pe dispozitiv / dev / loop1, în care există 1 primar partiție de pornire un disc care se întinde pe întregul disc cu eticheta sistemului de fișiere FAT32.
Apoi formatăm secțiunea creată. Pentru a face acest lucru, montați-l ca un dispozitiv bloc și efectuați formatarea.
Losetup / dev / loop2 ./hdd.img - offset `echo` fdisk -lu / dev / loop1 | sed -n 10p | awk "(print $$ 3)" `* 512 | bc` --sizelimit `ecou` fdisk -lu / dev / loop1 | sed -n 10p | awk "(print $$ 4)" `* 512 | bc` losetup -d / dev / loop1
Prima comandă montează partiția creată anterior pe dispozitiv / dev / loop2. Opțiunea „offset” specifică adresa începutului secțiunii și -selimită adresa finalului secțiunii. Ambii parametri sunt obținuți folosind comanda fdisk.
Mkdosfs / dev / loop2
Utilitarul mkdosfs formatează o partiție în sistem de fișiere FAT32.
Pentru asamblarea directă a nucleului, comenzile discutate anterior sunt utilizate în sintaxa clasică de makefile.
Analizați acum cum se instalează GRUB pe o partiție:
Mkdir -p tempdir # creează un director temporar mount / dev / loop2 tempdir # montează partiția din directorul mkdir tempdir / boot # creează directorul / boot pe secțiunea cp -r grub tempdir / boot / # copiați folderul grub în / boot cp kernel.bin tempdir / # copiază nucleul în rădăcina partiției de repaus 1 # așteptați Ubuntu umount / dev / loop2 # demontați folderul temporar rm -r tempdir # ștergeți folderul temporar losetup -d / dev / loop2 # demontați partiția
După executarea comenzilor de mai sus, imaginea va fi gata să instaleze GRUB’a. Următoarea comandă instalează GRUB în MBR a imaginii de disc hdd.img.
Echo "dispozitiv (hd0) hdd.img n root (hd0,0) n setup (hd0) n quitn" | grub --batch 1\u003e / dev / null
Totul este gata pentru testare!
Pasul 6. Lansare:
Pentru a compila, utilizați comanda:
Faceți toate
După care ar trebui să apară fișierul kernel.bin.
Pentru a crea o imagine de disc de boot, utilizați comanda:
Sudo face imagine
Drept urmare, ar trebui să apară fișierul hdd.img.
Acum puteți porni de pe imaginea de disc hdd.img. Puteți verifica acest lucru cu următoarea comandă:
Qemu -hda hdd.img -m 32
Qemu-system-i386 -hda hdd.img
Pentru a verifica pe o mașină reală, trebuie să faceți dd din această imagine pe o unitate flash și să porniți de la ea. De exemplu, cu această comandă:
Sudo dd if \u003d. / Hdd.img din \u003d / dev / sdb
Rezumând, putem spune că, în urma acțiunilor întreprinse, obținem un set de surse și scripturi care ne permit să efectuăm diverse experimente în domeniul programării sistemului. Primul pas a fost făcut spre crearea software-ului de sistem, cum ar fi hipervizorii și sistemele de operare.
