Unele aplicații necesită privilegii ridicate pentru a rula pe Windows și trebuie să fie rulate ca administrator. Acest lucru vă solicită să „ Controlul contului utilizatorului" (Controlul contului utilizatorului sau UAC), în care sistemul vă solicită acordul pentru lansarea aplicației.
Mulți utilizatori cred în mod incorect că Controlul contului de utilizator este doar o pacoste și îl dezactivează. În același timp, securitatea computerului este grav afectată, deoarece. consimțământul utilizatorului pentru a rula aplicații nu mai este necesar și orice malware poate porni și rula fără probleme. De asemenea, prezența unui antivirus nu poate garanta 100% securitatea unui computer.
În acest articol, vă voi arăta cum să simplificați procesul de rulare a aplicațiilor preferate ca administrator fără a dezactiva UAC (total sau parțial) și fără a compromite securitatea.
Există mai multe moduri de a rula aplicația ca administrator:
De exemplu, vom rula linia de comandă (cmd) ca administrator.
Metoda numărul 1 (normal) - lansare prin butonul din dreapta al mouse-ului (este afișat promptul UAC)
Faceți clic dreapta pe pictogramă aplicatia doritași selectați „ Rulat ca administrator":
Metoda numărul 2 - lansați folosind „ Ctrl+Shift+Enter" (afișat promptul UAC)
Clic start, în bara de căutare, tastați comanda dorită și faceți clic Ctrl+Shift+Enter.
Metoda numărul 3 - setați rularea ca administrator în proprietățile comenzii rapide (este afișat promptul UAC)
Faceți clic dreapta pe comanda rapidă dorită și selectați „ Proprietăți".
Accesați fila " Eticheta", presa " În plus", verifică " Rulat ca administrator":
Sau mergi la " Compatibilitate"și bifați caseta" Rulați acest program ca administrator":
Metoda #4 - Ușurează lansarea aplicațiilor selectate folosind Task Scheduler (promptul UAC nu este afișat)
Important! Această metodă funcționează numai pentru conturile care sunt membri ai unui grup. Administratorii. Nu va funcționa pentru utilizatorii obișnuiți, deoarece plafonul lor are permisiuni limitate.
Să trecem la mod interesant. Dacă există o aplicație pe care o rulați tot timpul și provine de la un furnizor de software de încredere, de exemplu, aceasta aplicatie windows- poate fi mai ușor de început. Creați o comandă rapidă pentru programul dorit nu durează mai mult de 2 minute și acest lucru vă va permite să scăpați de acțiunile inutile în viitor. Lansăm planificator de sarcini (start---> Toate programele ---> Standard---> Serviciu---> Planificator de sarcini) și apăsați „ Creați o sarcină":
Specifica Nume pentru o sarcină nouă și bifați caseta " Alergați cu cele mai înalte privilegii":
Accesați fila Acțiuni, presa " Crea", în fereastra următoare apăsați " Revizuire":
Specificați calea către aplicația dorită și faceți clic pe „ Deschis":
Măriți imaginea
Presa " Bine":
Închideți programatorul și continuați să creați o comandă rapidă.
Pentru a crea o comandă rapidă pe desktop, faceți clic dreapta, selectați „ Crea" ---> "Eticheta":
În câmp Locația proprietății introduce:
Schtasks /run /tn cmd_admin
Unde cmd_admin- numele sarcinii pe care am creat-o. Dacă numele conține spații, acesta trebuie să fie cuprins între ghilimele.
Setați numele etichetei:
Măriți imaginea
Comanda rapidă este creată și gata de utilizare.
Pentru a schimba pictograma - faceți clic dreapta pe comandă rapidă, selectați „ Proprietăți":
Accesați fila " Eticheta"și apăsați" schimbă iconița":
"Revizuire..."
Specificați calea către program:
Măriți imaginea
Selectați pictograma dorită și închideți ambele ferestre cu „ Bine":
Acum lansarea aplicației dorite ca administrator se realizează făcând dublu clic pe scurtătura creată, în timp ce promptul UAC nu este afișat și securitatea rămâne intactă.
Utilitate pentru automatizare „Metoda nr. 4”
Dacă trebuie să creați comenzi rapide pentru un număr mare de programe, este convenabil să utilizați utilitarul.
Lucrul cu utilitarul se reduce la doi pași simpli:
- Instalare
- Tragerea unui fișier executabil (*.exe, *.bat, *.cmd) pe comanda rapidă a utilitarului:
Se transferă automat focalizarea către un program care rulează
Specificul lansării aplicațiilor din planificator este că focalizarea nu este transferată în fereastră și, de exemplu, pentru a tasta o comandă pe linia de comandă, trebuie să faceți clic suplimentar pe fereastră. Acest comportament poate ajuta la automatizarea operațiunilor programate de rutină, dar pentru „Metoda # 4” nu este întotdeauna convenabil.
Există mai multe metode de „ocolire”. Funcționează puțin diferit, așa că alege-l pe cel care ți se potrivește cel mai bine. Primul este mai convenabil pentru rularea programelor, iar al doilea pentru rularea scripturilor.
Adăugați la crearea unei sarcini:
Folosind comanda de pornire
Program sau script:
Argumente:
/c start /d „calea_la_program” nume_fișier.exe
/c porniți /d „C:\Windows\System32\” cmd.exe
Folosind utilitarul NirCmd
Program sau script:
Calea_către_nircmd\nircmd.exe
Argumente:
Exec arată „calea_la_program\nume_fișier.exe”
Exec arată „C:\Windows\System32\cmd.exe”
Lansarea casetei de dialog „Run” ca administrator
Similar cu pornirea Linie de comanda puteți configura lansarea casetei de dialog " Alerga", iar comenzile introduse în acesta vor fi rulate și ca administrator. Comoditatea acestei abordări este că lista comenzilor utilizate anterior este salvată și o puteți selecta pe cea de care aveți nevoie din listă.
Când creați o sarcină în planificator, în „ Creați o acțiune"specifica:
în câmp" Program sau scenariu":
Rundll32
în câmp" Adăugați argumente":
Shell32.dll, #61
Descărcați utilitarul, despachetați. Lansăm linia de comandă, introducem comanda dorită, sintaxa este destul de simplă:
<путь к утилите> <путь к нужному приложению>
Va fi afișat un prompt UAC și aplicația va rula ca administrator.
Notă: In context meniul Windows 7 există o funcție foarte convenabilă de copiere a căii fișierului: țineți apăsat Schimb, faceți clic dreapta pe fișier, selectați " copiați ca cale".
Lansarea 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 malware poate profita de acest lucru și poate compromite sistemul.
Luați în considerare o altă problemă interesantă: contul dvs intrare Windows este membru al grupului Administratori, există unul sau mai multe conturi care sunt membri ai grupului Utilizatori. Utilizatorul trebuie să ruleze un program care necesită elevație. De obicei arată astfel: utilizatorul face clic dreapta pe fișier și selectează „Run as administrator”, care vă solicită să introduceți parola de administrator:
Desigur, distribuirea unei parole de administrator utilizatorilor nu este cea mai mare bună idee. Pentru a „ocoli” acest lucru, vom folosi utilitarul AdmiLink de la Alexey Kuryakin. Cu ajutorul acestuia, administratorul poate crea o comandă rapidă pentru ca utilizatorul să lanseze programul necesar, în timp ce introducerea parolei de administrator este necesară o singură dată - la crearea comenzii rapide. Când utilizatorul pornește programul, parola va fi transmisă în formă criptată.
Această metodă va funcționa dacă programul poate fi rulat doar ca administrator și dezvoltatorul nu a uitat să specifice această condiție în manifest. Cu toate acestea, mai există un numar mare de programe vechi sau programe care pot fi rulate ca în Mod normal, și în numele administratorului (în acest caz, un set diferit de funcții va fi disponibil). Când încercați să rulați un astfel de program folosind AdmiLink, acesta pornește în modul normal (fără privilegii administrative). Și dacă încercați să bifați caseta „Metoda numărul 3. Se păstrează stilul original al autorului.
Doriți să permiteți utilizatorilor cu un cont standard să ruleze aplicații cu privilegii administrative fără UAC sau o solicitare de parolă? Atunci îți voi spune cum să faci. Vom crea o comandă rapidă folosind comanda runas /savecred, care stochează parola. Observ că aceasta poate fi considerată o gaură de securitate - un utilizator normal va putea folosi runas / savecred pentru a executa orice comandă ca administrator fără a introduce o parolă. Cu toate acestea, în unele situații poate fi util - de exemplu, dacă doriți ca copilul dvs. să fie în afara standardului cont ar putea rula aplicații ca administrator fără să vă întrebe.
Activați contul de administrator
Primul pas este să activați contul de administrator încorporat, care este dezactivat implicit. Deci, faceți clic dreapta pe comanda rapidă din promptul de comandă și selectați „Run as administrator”.
În fereastra de linie de comandă care se deschide, executați următoarea comandă:
administrator net user /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 de utilizator și Siguranța familiei, apoi deschideți meniul Conturi de utilizator. Apoi faceți clic pe linkul „Gestionați 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 etichetă
Acum vom crea o comandă rapidă care va lansa aplicația cu privilegii de administrator. Faceți clic dreapta pe desktop, selectați „Nou” și apoi faceți clic pe „Comandă rapidă”.
În fereastra care se deschide, introduceți următoarea comandă:
runas / utilizator: numele calculatorului\Administrator /savecred" C:\Calee\To\Program.exe“
Vă rugăm să rețineți că trebuie să înlocuiți numele calculatorului la numele computerului dvs. și C:\Calee\To\Program.exe la calea completă către programul pe care doriți să-l rulați. De exemplu, dacă numele computerului este Laptop și programul pe care doriți să-l rulați este Auslogics BoostSpeed, veți introduce următoarea cale:
runas /user:Laptop\Administrator /savecred „C:\Program Files\Auslogics\Auslogics BoostSpeed\BoostSpeed.exe”
În fereastra următoare, introduceți un nume pentru comanda rapidă. Opțional, puteți alege o pictogramă pentru noua comandă rapidă - 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-o pe cea potrivită.
Prima dată când faceți dublu clic pe scurtătură, vi se va solicita parola pentru contul de administrator creat anterior.
Această parolă va fi salvată - data viitoare când rulați programul, nu va trebui să o introduceți din nou.
După 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ă țineți cont de asta.
Parola de administrator este stocată în „Credential Manager” - dacă doriți să ștergeți parola salvată, o puteți face de acolo.
O zi bună!
Cel mai important lucru nu a fost descris suficient de detaliat: cum să rulați acest cod pe hardware real? Cum să-ți creezi propriul tău disc de pornire? În acest articol, vom răspunde în detaliu la toate aceste întrebări (parțial, aceste întrebări au fost tratate în articolul precedent, dar pentru ușurința citirii, ne permitem o ușoară duplicare a materialului).
Există un număr mare de descrieri și tutoriale pe Internet despre cum să vă scrieți propriul mini-OS, există chiar și sute de sisteme de operare mici hobby gata făcute. Una dintre cele mai demne resurse pe această temă, pe care aș dori să o subliniez, este portalul osdev.org. Pentru a completa articolul anterior despre PCI (și capacitatea 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 la crearea unui disc bootabil cu un program familiar C. Am încercat să scriem cât mai detaliat posibil, astfel încât totul să poată fi deslușit singuri.
Așadar, obiectivul: cu cât mai puțin efort posibil, creați-vă 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 paginarea și întreruperile dezactivate - cel mai simplu mod al procesorului cu comportamentul obișnuit pentru un program simplu de consolă. Cea mai inteligentă modalitate de a atinge acest obiectiv este de a construi un nucleu cu mai multe porniri și de a-l porni folosind popularul Grub bootloader. O alternativă la această soluție este să scrieți propria înregistrare de încărcare a volumului (VBR), care ar încărca propriul încărcător scris (loader). Un încărcător decent, cel puțin, ar trebui să poată lucra cu discul, cu sistemul de fișiere și să analizeze imaginile elf. Aceasta înseamnă să scrieți mult cod de asamblare și mult cod C. Pe scurt, este mai ușor să utilizați Grub, care deja știe cum să facă tot ce aveți nevoie.
Să începem cu faptul că un anumit set de compilatoare și utilitare este necesar pentru acțiuni ulterioare. Cel mai simplu mod este să utilizați Linux (de exemplu, Ubuntu), deoarece va conține deja tot ce aveți nevoie pentru a crea o unitate flash bootabilă. Dacă sunteți obișnuit să lucrați în Windows, atunci puteți configura mașină virtuală cu Linux (folosind Virtual Box sau VMware Workstation).
Dacă utilizați linux ubuntu, apoi mai întâi de toate trebuie să instalați mai multe utilitare:
1. Grub. Pentru a face acest lucru, utilizați comanda:
sudo apt-get install grub
2. Qemu. Este necesar să faceți totul rapid, pentru aceasta comanda este similară:
sudo apt-get install qemu
Acum planul nostru arată astfel:
1. creați un program C care imprimă o linie pe ecran.
2. colectați o imagine din ea (kernel.bin) în format miniboot, astfel încât să fie disponibilă pentru pornire folosind GRUB.
3. creați un fișier imagine de disc de pornire și formatați-l.
4. instalați Grub pe această imagine.
5. copiați programul creat (kernel.bin) pe disc.
6. scrieți imaginea către 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):
Creăm un fișier kernel.c care va conține următorul cod care afișează un mesaj pe ecran:
#include "printf.h" #include "screen.h" #include "types.h" void main(void) ( clear_screen(); printf("\n>>> Bună lume!\n"); )
Aici totul este familiar și simplu. Adăugarea funcțiilor printf și clear_screen va fi tratată în continuare. Între timp, trebuie să suplimentăm acest cod cu tot ce este necesar pentru a putea fi încărcat de Grub.
Pentru ca nucleul să fie în format multiboot, următoarea structură trebuie să fie în primii 8 kiloocteți ai imaginii nucleului:
Dacă sunt îndeplinite toate condițiile specificate, atunci Grub trece un pointer către structura de informații multiboot și, respectiv, valoarea 0x1BADB002, prin registrele % eax și % ebx. Structura de informații multiboot conține diverse informatii, inclusiv o listă a modulelor încărcate și locația acestora, care poate fi necesară pentru a porni în continuare sistemul.
Pentru ca fișierul cu programul să conțină semnăturile necesare, să creăm un fișier loader.s cu următorul conținut:
Text .global loader # face punctul de intrare vizibil pentru linker # configurarea antetului Multiboot - consultați documentele GRUB pentru detalii .set FLAGS, 0x0 # acesta este câmpul „flag” Multiboot .set MAGIC, 0x1BADB002 # „numărul magic” permite încărcătorul de încărcare să găsească antetul .set CHECKSUM, -(MAGIC + FLAGS) # checksum required .align 4 .long MAGIC .long FLAGS .long CHECKSUM # rezervă spațiu inițial de stivă kernel .set STACKSIZE, 0x4000 # adică 16k. .lcomm stack, STACKSIZE # rezervă 16k stack .comm mbd, 4 # vom folosi asta în kmain .comm magic, 4 # vom folosi asta în kmain loader: movl $(stack + STACKSIZE), %esp # configurați stiva movl %eax, magic # Multiboot magic number movl %ebx, mbd # Multiboot data structure call main # call cod C cli hang: hlt # stop mașina ar trebui să returneze nucleul jmp hang
Să luăm în considerare codul mai detaliat. Acest cod este preluat de pe wiki.osdev.org/Bare_Bones aproape neschimbat. Deoarece gcc este folosit pentru compilare, este folosită sintaxa GAS. Să aruncăm o privire mai atentă la ceea ce face acest cod.
.text
Tot codul următor va intra în secțiunea executabilă .text.
.încărcător global
Declaram simbolul de încărcare vizibil pentru linker. Acest lucru este necesar deoarece linkerul va folosi încărcătorul ca punct de intrare.
.set FLAGS, 0x0 # set FLAGS = 0x0 .set MAGIC, 0x1BADB002 # set MAGIC = 0x1BADB002 .set CHECKSUM, -(MAGIC + FLAGS) # set CHECKSUM = -(MAGIC + FLAGS) .align 4 # by data to align subsequents .long MAGIC # plasați valoarea MAGIC la adresa curentă .long FLAGS # plasați valoarea FLAGS la adresa curentă .long CHECKSUM # plasați valoarea CHECKSUM la adresa curentă
Acest cod generează semnătura în format Multiboot. Directiva .set setează valoarea caracterului la expresia din dreapta virgulei. Directiva .align 4 aliniază următorul conținut cu 4 octeți. Directiva .long stochează valoarea în următorii patru octeți.
.set STACKSIZE, 0x4000 # set STACKSIZE = 0x4000 .lcomm stack, STACKSIZE # rezervă un octet STACKSIZE. stiva se referă la range.comm mbd, 4 # rezervă 4 octeți pentru variabila mdb în zona COMUNE .comm magic, 4 # rezervă 4 octeți pentru variabila magică în zona COMUNE
În timpul procesului de pornire, grub nu configurează stiva, iar primul lucru pe care trebuie să-l facă kernel-ul este configurarea stivei, pentru aceasta ne rezervăm 0x4000 (16Kb) octeți. Directiva .lcomm rezervă numărul de octeți specificat după virgulă în secțiunea .bss. Stiva de nume va fi vizibilă numai în fișierul compilat. Directiva .comm face la fel ca .lcomm, dar numele simbolului va fi declarat global. Aceasta înseamnă că, scriind următoarea linie în codul C, o putem folosi.
extern int magic
Și acum ultima parte:
încărcător: movl $(stack + STACKSIZE), %esp # inițializați stiva movl %eax, magic # scrieți %eax în magic movl %ebx, mbd # scrieți %ebx în mbd call main # apelați funcția principală cli # dezactivați întreruperile de la blocarea hardware : hlt # opri CPU până când apare întreruperea jmp hang # sări pentru a bloca eticheta
Prima instrucțiune salvează valoarea vârfului stivei în registrul %esp. Deoarece stiva crește în jos, adresa sfârșitului intervalului alocat stivei este scrisă în %esp. Următoarele două instrucțiuni stochează în intervalele de 4 octeți rezervate anterior valorile pe care Grub le transmite în registrele %eax, %ebx. Apoi se numește funcția principală, care este deja scrisă în C. Dacă această procedură revine, procesorul va face bucla.
Pasul 2. Pregătirea codului suplimentar pentru program (biblioteca de sistem):
Deoarece întregul program este scris de la zero, funcția printf trebuie scrisă de la zero. Pentru a face acest lucru, trebuie să pregătiți mai multe fișiere.
Să creăm un folder comun și include:
mkdir mkdir comun include
Să creăm fișierul common\printf.c, care va conține implementarea funcției familiare printf. Acest fișier poate fi preluat integral din proiectul www.bitvisor.org. Calea către fișier în sursele bitvisor: core/printf.c. În fișierul printf.c copiat din bitvisor, pentru utilizare în programul țintă, trebuie să înlocuiți liniile:
#include „initfunc.h” #include „printf.h” #include „putchar.h” #include „spinlock.h”
la liniile:
#include „types.h” #include „stdarg.h” #include „screen.h”
Apoi, eliminați funcția printf_init_global și toate referințele ei din acest fișier:
Static void printf_init_global (void) ( spinlock_init (&printf_lock); ) INITFUNC("global0", printf_init_global);
Apoi eliminați variabila printf_lock și toate referințele la aceasta din acest fișier:
static spinlock_t printf_lock; ... spinlock_lock(&printf_lock); ... spinlock_unlock(&printf_lock);
Funcția printf folosește funcția putchar, care trebuie de asemenea scrisă. Pentru a face acest lucru, să creăm un fișier comun\screen.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 # define DEF_VRAM_BASE 0xb8000 // Baza implicită pentru memoria video static unsigned char curr_col = 0; static unsigned char curr_row = 0; // Scrie caracterul în locația curentă a ecranului #define PUT(c) (((unsigned short *) (DEF_VRAM_BASE)) \ [(curr_row * MAX_COL) + curr_col] = (VERDE<< 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; ) pauză; case "\b": if (curr_col > 0) ( curr_col -= 1; PUT(" "); ) break; implicit: 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;
}
Codul specificat conține o logică simplă pentru tipărirea caracterelor pe ecran în modul text. În acest mod se folosesc doi octeți pentru a scrie un caracter (unul cu codul caracterului, celălalt cu atributele acestuia), scris direct în memoria video afișată imediat pe ecran și începând de la adresa 0xB8000. Rezoluția ecranului este de 80x25 de caractere. Caracterul este imprimat direct folosind macro-ul PUT.
Acum doar câteva fișiere de antet lipsesc:
1. Fișier include\screen.h. Declara functia putchar, care este folosita in functia printf. Conținutul fișierului:
#ifndef _SCREEN_H #define _SCREEN_H void clear_screen(void); void putchar(int c); #endif
2. Fișier include\printf.h. Declara o functie printf care este folosita in main. Conținutul fișierului:
#ifndef _PRINTF_H #define _PRINTF_H int printf (const char *format, ...); #endif
3. Fișier include\stdarg.h. Declara functii pentru iterarea peste argumente, al caror numar nu este cunoscut in prealabil. Întregul fișier este preluat din proiectul www.bitvisor.org. Calea către fișier în codul proiectului bitvisor: include\core\stdarg.h.
4. Fișier include\types.h. Declara 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 include și comune conțin codul minim de bibliotecă de sistem de care are nevoie orice program.
Pasul 3. Scriptarea linkerului:
Creăm fișierul linker.ld, care va fi folosit de linker pentru a genera fișierul program țintă (kernel.bin). Fișierul trebuie să conțină următoarele:
INTRARE (încărcător) LMA = 0x00100000; SECȚIUNI ( . = LMA; .multiboot ALIGN (0x1000) : ( loader.o(.text) ) . aliniere text(0x1000) : ( *(.text) ) .rodata ALIGN (0x1000) : ( *(.rodata*) ) .data ALIGN (0x1000) : ( *(.data) ) .bss: ( *(COMMON) *( .bss) ) /DISCARD/ : ( *(.comment) ) )
Funcția încorporată ENTRY() ne permite să setăm un punct de intrare pentru nucleul nostru. La această adresă grub va transfera controlul după încărcarea nucleului. Linkerul va folosi acest script pentru a crea un fișier binar în format ELF. Un fișier ELF constă dintr-un set de segmente și secțiuni. Lista segmentelor este conținută în tabelul antet program, lista secțiunilor din tabelul antet secțiuni. Linkerul operează 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 descrie o secțiune este adresa virtuală, unde secțiunea ar trebui să fie în momentul execuției. 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 în momentul în care codul este executat, adresa fizică a segmentului este adresa fizică la care ar trebui să fie încărcat segmentul. Pentru programele de aplicație, aceste adrese sunt întotdeauna aceleași. Grub încarcă segmente de imagine după adresa lor fizică. Deoarece Grub nu configurează paginarea, adresa virtuală a segmentului trebuie să se potrivească cu adresa sa fizică, deoarece în programul nostru memorie virtuala de asemenea, nu este configurabil.
SECȚIUNI
Indică faptul că secțiunile sunt descrise în continuare.
. = LMA;
Această expresie îi spune linkerului că toate secțiunile ulterioare sunt după adresa LMA.
ALIGNE (0x1000)
Directiva de mai sus înseamnă că secțiunea este aliniată la 0x1000 de octeți.
.multiboot ALIGN (0x1000) : ( loader.o(.text) )
O secțiune separată de pornire multiplă, care include secțiunea .text din fișierul loader.o, este creată pentru a se asigura că semnătura în formatul de pornire multiplă intră în primii 8 kb ai imaginii nucleului.
.bss: ( *(COMUN) *(.bss) )
*(COMUN) este zona în care memoria este rezervată de instrucțiunile .comm și .lcomm. Îl plasăm în secțiunea .bss.
/DISCARD/ : ( *(.comment) )
Toate secțiunile marcate ca DISCARD sunt eliminate din imagine. În acest caz, eliminăm secțiunea .comment, care conține informații despre versiunea linkerului.
Acum să compilam codul într-un fișier binar cu următoarele comenzi:
ca -o loader.o loader.s gcc -Iinclude -Wall -fno-builtin -nostdinc -nostdlib -o kernel.o -c kernel.c gcc -Iinclude -Wall -fno-builtin -nostdinc -nostdlib -o printf.o -c common/printf.c gcc -Iinclude -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 încărcător.o
Folosind objdump, să vedem cum arată imaginea nucleului după conectarea:
objdump -ph ./kernel.bin
După cum puteți vedea, secțiunile din imagine se potrivesc cu cele descrise în scriptul linker. Linker-ul a format 3 segmente din secțiunile descrise. Primul segment include secțiunile .multiboot, .text, .rodata și are o adresă virtuală și fizică de 0x00100000. Al doilea segment conține secțiunile .data și .bss și este situat la 0x00104000. Deci totul este gata pentru a încărca acest fișier folosind Grub.
Pasul 4Pregătirea încărcării Grub Boot Loader:
Creați folderul grub:
mkdir grub
Copiați în acest folder câteva fișiere Grub care sunt necesare pentru a-l instala pe imagine (următoarele fișiere există dacă Grub este instalat pe sistem). Pentru a face acest lucru, trebuie să rulaț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 titlu mini_os root (hd0,0) kernel /kernel.bin
Pasul 5: Automatizați și creați o imagine de pornire:
Pentru a automatiza procesul de construire, vom folosi utilitarul make. Pentru a face acest lucru, vom crea un makefile care se va compila sursă, construiți nucleul și creați o imagine de pornire. Makefile-ul ar trebui să aibă următorul conținut:CC=gcc CFLAGS=-Wall -fno-builtin -nostdinc -nostdlib LD=ld OBJFILES=\loader.o\common/printf.o\common/screen.o\kernel.o imagine: @echo „Crearea hdd.img. .." @dd if=/dev/zero of=./hdd.img bs=512 count=16065 1>/dev/null 2>&1 @echo "Se creează prima partiție FAT32 bootabilă..." @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 „Se montează partiția pe /dev/loop2...” @losetup /dev/loop2 ./hdd.img \ --offset `echo \`fdisk -lu /dev/loop1 | sed -n 10p | awk "(printați $$3)"\`*512 | bc` \ --sizelimit `echo \`fdisk -lu /dev/loop1 | sed -n 10p | awk "(printați $$4)"\`*512 | bc` @losetup -d /dev/loop1 @echo "Format 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 „Se instalează GRUB. .." @echo "dispozitiv (hd0) hdd.img \n \ root (hd0,0) \n \ setup (hd0) \n \ ieșire\n" | grub --lotul 1>/dev/null @echo „Terminat!” 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
Fișierul declară două ținte principale: all, care compilează nucleul, și image, care creează discul de pornire. Ținta all, ca și fișierul makefile obișnuit, conține subținte .s.o și .c.o, care compilează fișierele *.s și *.c în fișiere obiect (*.o), precum și ținta pentru generarea kernel.bin, care apelează linker-ul cu scriptul creat mai devreme. Aceste ținte execută exact aceleași comenzi ca la pasul 3.
De cel mai mare interes aici este creația imaginea de boot hdd.img (țintă imagine). Să analizăm pas cu pas cum se întâmplă acest lucru.
dd if=/dev/zero of=./hdd.img bs=512 count=16065 1>/dev/null 2>&1
Această comandă creează o imagine cu care vor avea loc lucrări ulterioare. Numărul de sectoare nu este ales aleatoriu: 16065 = 255 * 63. În mod implicit, fdsik tratează discul ca și cum ar avea geometrie CHS, în care Antete (H) = 255, Sectoare (S) = 63 și Cilindri (C) depinde de dimensiunea discului. Prin urmare, dimensiune minimă discul cu care poate lucra fdsik fără a modifica geometria implicită este 512 * 255 * 63 * 1 = 8225280 octeți, unde 512 este dimensiunea sectorului și 1 este numărul de cilindri.
În continuare, tabelul de partiții este creat:
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 || Adevărat
Prima comandă montează fișierul hdd.img pe dispozitivul bloc /dev/loop1, permițând ca fișierul să fie tratat ca un dispozitiv. A doua comandă creează un tabel de partiții pe dispozitivul /dev/loop1, care conține 1 primar partiția de pornire disc care ocupă întregul disc și este etichetat FAT32.
Apoi formatăm partiția creată. Pentru a face acest lucru, trebuie să îl montați ca dispozitiv bloc și să îl formatați.
losetup /dev/loop2 ./hdd.img \ --offset `echo \`fdisk -lu /dev/loop1 | sed -n 10p | awk "(printați $$3)"\`*512 | bc` \ --sizelimit `echo \`fdisk -lu /dev/loop1 | sed -n 10p | awk "(printați $$4)"\`*512 | bc` losetup -d /dev/loop1
Prima comandă montează partiția creată anterior pe dispozitivul /dev/loop2. Opțiunea -offset specifică adresa începutului secțiunii, iar -sizelimit adresa sfârșitului secțiunii. Ambele opțiuni sunt obținute folosind comanda fdisk.
mkdosfs /dev/loop2
Utilitarul mkdosfs formatează partiția în Sistemul de fișiere FAT32.
Pentru a construi direct nucleul, sunt folosite comenzile discutate mai devreme în sintaxa clasică makefile.
Acum să vedem cum să instalați GRUB pe o partiție:
mkdir -p tempdir # creează un director temporar mount /dev/loop2 tempdir # montează partiția în directorul mkdir tempdir/boot # creează directorul /boot pe partiția cp -r grub tempdir/boot/ # copiază folderul grub în / boot cp kernel.bin tempdir / # copiează nucleul la rădăcina partiției sleep 1 # așteptați Ubuntu umount /dev/loop2 # demontează folderul temporar rm -r tempdir # șterge folderul temporar losetup -d /dev/loop2 # demontați partiția
După executarea comenzilor de mai sus, imaginea va fi gata pentru a instala GRUB. Următoarea comandă instalează GRUB în MBR-ul imaginii de disc hdd.img.
echo "dispozitiv (hd0) hdd.img \n \ root (hd0,0) \n \ setup (hd0) \n \ ieșire\n" | grub --lotul 1>/dev/null
Totul este gata de testare!
Pasul 6 Lansare:
Pentru a compila, utilizați comanda:
face totul
După care ar trebui să apară fișierul kernel.bin.
Pentru a crea o imagine de disc bootabilă, utilizați comanda:
sudo make image
Ca rezultat, ar trebui să apară fișierul hdd.img.
Acum puteți porni de pe imaginea discului hdd.img. Puteți verifica acest lucru cu următoarea comandă:
qemu -hda hdd.img -m 32
sau:
qemu-system-i386 -hda hdd.img 
Pentru a verifica o mașină reală, trebuie să adăugați această imagine pe o unitate flash și să porniți de pe ea. De exemplu, această comandă:
sudo dd if=./hdd.img of=/dev/sdb
Rezumând, putem spune că în urma acțiunilor întreprinse se obține un set de coduri sursă și scripturi care vă permit să efectuați diverse experimente în domeniul programării sistemului. Primul pas spre crearea unui sistem sistemic software precum hipervizorii și sistemele de operare.
Ce se întâmplă dacă trebuie să rulezi un program, dar nu vrei să-l instalezi? Zero Install Help!
Miliarde de oameni din întreaga lume folosesc computere sau laptopuri în sala de operație. sistem Windows. De obicei, instalăm programe, după care iau loc liber pe disc și folosiți RAM. Acest lucru reduce viteza computerului.
Astăzi vă vom spune cum puteți crește performanța computerului și reduce sarcina de memorie. Pentru asta trebuie să alergi programele necesare fara a le instala.
Cum se rulează programul fără instalare?
1. Descărcați Zero Install.
Mai întâi, descărcați software-ul Zero Install, care vă va permite să rulați programe fără a fi nevoie 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 fugi program nou pe calculatorul tau.
3. Faceți clic pezidărie „Catalog”.
De îndată ce Zero Install este lansat pe computer sau Laptop Windows, trebuie să accesați fila „Catalog”. Aici faceți clic pe butonul „Actualizați lista” pentru a reîmprospăta lista programele disponibile.
4. Selectați un program de rulat.
Aruncă o privire atentă lista plina programele disponibile. Dacă găsiți programul de care aveți nevoie, selectați-l și faceți clic pe „Run”. Unele programe pot alege browser Firefox sau Mozilla pentru a rula. Doar așteptați ca software-ul să se descarce complet și apoi îl puteți rula pe computer fără a-l instala.
Rezumând
Dacă computerul nu are suficientă memorie liberă sau putere pentru a rula programul, puteți utiliza Zero Install. Cred că aceasta este o modalitate excelentă de a nu aglomera computerul cu programele de care aveți nevoie la un moment dat.
De asemenea, este posibil ca computerul să nu aibă suficientă putere pentru a rula anumite programe, cum ar fi Eclipse IDE, JetBrains, NetBeans etc. Acestea sunt programe cu adevărat grele pentru dezvoltatori care consumă multă memorie RAM.
Zero Install vă va ajuta să rulați aceste programe și multe alte programe fără a le instala pe computer.
