În calcul, a apel de sistem este o modalitate programatică prin care un program de calculator solicită un serviciu din nucleul sistemului de operare pe care este executat. Un apel de sistem este o modalitate prin care programele fac interacționează cu sistemul de operare . Un program de calculator efectuează un apel de sistem atunci când face o solicitare către nucleul sistemului de operare. Apel de sistem prevede serviciile sistemului de operare către programele utilizatorului prin Interfața Programului de Aplicație (API). Acesta oferă o interfață între un proces și un sistem de operare pentru a permite proceselor la nivel de utilizator să solicite servicii sistemului de operare. Apelurile de sistem sunt singurele puncte de intrare în nucleu sistem. Toate programele care au nevoie de resurse trebuie să utilizeze apeluri de sistem.
Un program de utilizator poate interacționa cu sistemul de operare folosind un apel de sistem. O serie de servicii sunt solicitate de program, iar sistemul de operare răspunde lansând un număr de apeluri de sistem pentru a îndeplini cererea. Un apel de sistem poate fi scris în limbaje de nivel înalt precum C sau Pascal sau în limbaj de asamblare. Dacă se folosește un limbaj de nivel înalt, sistemul de operare poate invoca direct apeluri de sistem, care sunt funcții predefinite.
Un apel de sistem este un mecanism folosit de programe pentru a solicita servicii de la sistem de operare (OS). În termeni mai simpli, este o modalitate prin care un program poate interacționa cu sistemul de bază, cum ar fi accesarea resurselor hardware sau efectuarea de operațiuni privilegiate.
Un apel de sistem este inițiat de programul care execută o anumită instrucțiune, care declanșează o comutare la nucleu modul, permițând programului să solicite un serviciu de la sistemul de operare. Apoi, sistemul de operare gestionează cererea, efectuează operațiunile necesare și returnează rezultatul înapoi în program.
Apelurile de sistem sunt esențiale pentru buna funcționare a unui sistem de operare, deoarece oferă o modalitate standardizată pentru programele de a accesa resursele sistemului. Fără apeluri de sistem, fiecare program ar trebui să implementeze propriile metode de accesare a hardware-ului și a serviciilor de sistem, ceea ce duce la un comportament inconsecvent și predispus la erori.
Servicii furnizate de apeluri de sistem
- Crearea si managementul proceselor
- Managementul memoriei principale
- Accesul la fișiere, directorul și gestionarea sistemului de fișiere
- Manevrarea dispozitivului (I/O)
- Protecţie
- Rețele, etc.
- Controlul procesului: terminați, anulați, creați, terminați, alocați și eliberați memoria.
- Gestionarea fișierelor: creați, deschideți, închideți, ștergeți, citiți fișiere, etc.
- Gestionarea dispozitivelor
- Menținerea informațiilor
- Comunicare
Caracteristicile apelurilor de sistem
- Interfata: Apelurile de sistem oferă o interfață bine definită între programele utilizatorului și sistemul de operare. Programele fac solicitări apelând anumite funcții, iar sistemul de operare răspunde executând serviciul solicitat și returnând un rezultat.
- Protecţie: Apelurile de sistem sunt folosite pentru a accesa operațiuni privilegiate care nu sunt disponibile pentru programele utilizatorului obișnuit. Sistemul de operare folosește acest privilegiu pentru a proteja sistemul împotriva accesului rău intenționat sau neautorizat.
- Modul Kernel: Când se efectuează un apel de sistem, programul este comutat temporar din modul utilizator în modul kernel. În modul kernel, programul are acces la toate resursele sistemului, inclusiv hardware, memorie și alte procese.
- Schimbarea contextului: Un apel de sistem necesită o schimbare de context, care implică salvarea stării procesului curent și trecerea la modul kernel pentru a executa serviciul solicitat. Acest lucru poate introduce cheltuieli generale, ceea ce poate afecta performanța sistemului.
- Eroare de manipulare: Apelurile de sistem pot returna coduri de eroare pentru a indica probleme cu serviciul solicitat. Programele trebuie să verifice aceste erori și să le gestioneze în mod corespunzător.
- Sincronizare: Apelurile de sistem pot fi utilizate pentru a sincroniza accesul la resursele partajate, cum ar fi fișierele sau conexiunile de rețea. Sistemul de operare oferă mecanisme de sincronizare, cum ar fi încuietori sau semafoare, pentru a se asigura că mai multe programe pot accesa aceste resurse în siguranță.
Apeluri de sistem Avantaje
- Acces la resurse hardware: Apelurile de sistem permit programelor să acceseze resurse hardware, cum ar fi unități de disc, imprimante și dispozitive de rețea.
- Gestionarea memoriei: Apelurile de sistem oferă o modalitate pentru programe de a aloca și dezaloca memorie, precum și de a accesa dispozitivele hardware mapate cu memorie.
- Administrarea procesului: Apelurile de sistem permit programelor să creeze și să încheie procese, precum și să gestioneze comunicarea între procese.
- Securitate: Apelurile de sistem oferă o modalitate pentru programe de a accesa resurse privilegiate, cum ar fi capacitatea de a modifica setările sistemului sau de a efectua operațiuni care necesită permisiuni administrative.
- Standardizare: Apelurile de sistem oferă o interfață standardizată pentru ca programele să interacționeze cu sistemul de operare, asigurând consistența și compatibilitatea pe diferite platforme hardware și versiuni ale sistemului de operare.
Cum funcționează apelul de sistem?
Iată explicația detaliată pas cu pas cum funcționează apelurile de sistem:
- Utilizatorul are nevoie de resurse speciale: Uneori, programele trebuie să facă unele lucruri speciale care nu pot fi făcute fără permisiunea sistemului de operare, cum ar fi citirea dintr-un fișier, scrierea într-un fișier, obținerea de informații din hardware sau solicitarea unui spațiu în memorie.
- Programul face o cerere de apel de sistem: Există instrucțiuni speciale predefinite pentru a face o cerere către sistemul de operare. Aceste instrucțiuni nu sunt altceva decât un apel de sistem. Programul folosește aceste apeluri de sistem în codul său atunci când este necesar.
- Sistemul de operare vede apelul de sistem: Când sistemul de operare vede apelul de sistem, recunoaște că programul are nevoie de ajutor în acest moment, așa că oprește temporar execuția programului și dă tot controlul unei părți speciale din sine numită „Kernel”. Acum „Kernel” rezolvă nevoia programului.
- Sistemul de operare realizează operațiunile: Acum sistemul de operare efectuează operația cerută de program. Exemplu: citirea conținutului dintr-un fișier etc.
- Sistemul de operare redă controlul programului: După efectuarea operației speciale, sistemul de operare redă controlul programului pentru execuția ulterioară a programului.
Exemple de apel de sistem în Windows și Unix
Apelurile de sistem pentru Windows și Unix vin în multe forme diferite. Acestea sunt enumerate în tabelul de mai jos, după cum urmează:
| Proces | Windows | Unix |
|---|---|---|
| Controlul procesului | CreateProcess() ExitProcess() WaitForSingleObject() | Furculiţă() Ieșire() Aștepta() |
| Manipularea fișierelor | CreateFile() ReadFile() WriteFile() | Deschis() Citit() Scrie() Închide() |
| Managementul dispozitivelor | SetConsoleMode() ReadConsole() WriteConsole() face scriptul shell executabil | Ioctl() Citit() Scrie() |
| Întreținerea informațiilor | GetCurrentProcessID() SetTimer() Dormi() | Getpid() Alarma() Dormi() |
| Comunicare | CreatePipe() CreateFileMapping() MapViewOfFile() | teava() Shmget() Mmap() |
| Protecţie | SetFileSecurity() InitializeSecurityDescriptor() SetSecurityDescriptorgroup() | Chmod() demasca() Chown() |
deschis(): Accesarea unui fișier dintr-un sistem de fișiere este posibilă cu apelul de sistem open(). Oferă resursele fișierelor de care are nevoie și un mâner pe care procesul îl poate folosi. Un fișier poate fi deschis de mai multe procese simultan sau doar de un singur proces. Totul se bazează pe structură și sistemul de fișiere.
citit(): Datele dintr-un fișier de pe sistemul de fișiere sunt preluate folosindu-l. În general, acceptă trei argumente:
- O descriere a unui fișier.
- Un buffer pentru stocarea datelor de citire.
- Câți octeți trebuie citiți din fișier
Înainte de citire, fișierul de citit ar putea fi identificat prin descriptorul său de fișier și deschis folosind funcția open().
aștepta(): În unele sisteme, este posibil ca un proces să fie nevoie să amâne până când un alt proces se termină de rulat înainte de a continua. Când un proces părinte creează un proces copil, execuția procesului părinte este oprită până la finalizarea procesului copil. Procesul părinte este oprit folosind apelul de sistem wait(). Procesul părinte își recapătă controlul odată ce procesul copil a terminat de rulat.
scrie(): Datele dintr-un buffer utilizator sunt scrise folosindu-le pe un dispozitiv ca un fișier. Un program poate produce date într-un fel utilizând acest lucru apel de sistem . în general, există trei argumente:
- O descriere a unui fișier.
- O referință la memoria tampon în care sunt stocate datele.
- Cantitatea de date care va fi scrisă din buffer în octeți.
furculiţă(): Apelul de sistem fork() este folosit de procese pentru a crea copii ale lor. Este una dintre metodele folosite cel mai frecvent în sistemele de operare pentru a crea procese. Când un proces părinte creează un proces copil, execuția procesului părinte este suspendată până la finalizarea procesului copil. Procesul părinte își recapătă controlul odată ce procesul copil a terminat de rulat.
Ieșire(): Un apel de sistem numit exit() este folosit pentru a termina un program. În mediile cu fire multiple, acest apel indică faptul că execuția firului de execuție este încheiată. După utilizarea funcției de sistem exit(), sistemul de operare recuperează resursele utilizate de proces.
Metode de transmitere a parametrilor către sistemul de operare
Dacă are loc un apel de sistem, trebuie să transmitem parametrul părții Kernal a sistemului de operare.
De exemplu, uită-te la dat deschis() apel de sistem:
C
//function call example> #include> int> open(>const> char> *pathname,>int> flags, mode_t mode);> |
>
>
Aici nume cale , steaguri și mode_t sunt parametrii.
Deci este de remarcat faptul că:
- Nu putem transmite parametrii direct ca într-un apel obișnuit de funcție.
- În modul Kernal există o modalitate diferită de a efectua un apel de funcție.
Deci nu îl putem rula în spațiul de adrese normal pe care procesul l-a creat deja și, prin urmare, nu putem plasa parametrii în partea de sus a stivei, deoarece nu este disponibil pentru procesare pentru Kernal-ul sistemului de operare. așa că trebuie să adoptăm orice alte metode pentru a trece parametrii către Kernal-ul sistemului de operare.
scaner scan java
O putem face prin,
- Trecerea parametrilor în registre
- Adresa blocului este transmisă ca parametru într-un registru.
- Parametrii sunt împinși într-o stivă.
Să discutăm despre fiecare punct în detaliu:
1. Trecerea parametrilor în registre.
- Este cea mai simplă metodă dintre cele trei
- Aici trecem direct parametrii în registre.
- Dar va fi limitat atunci când numărul de parametri este mai mare decât numărul de registre.
- Iată codul programului C:
C
// Passing parameters in registers.> #include> #include> int> main()> {> >const> char>* pathname =>'example.txt'>;> >int> flags = O_RDONLY;> >mode_t mode = 0644;> >int> fd = open(pathname, flags, mode);> >// in function call open(), we passed the parameters pathanme,flags,mode to the kernal directly> >if> (fd == -1) {> >perror>(>'Error opening file'>);> >return> 1;> >}> >// File operations here...> >close(fd);> >return> 0;> }> |
verificarea nulului java
>
>
2.Adresa blocului este transmisă ca parametri
- Poate fi aplicat atunci când numărul de parametri este mai mare decât numărul de registre.
- Parametrii sunt stocați în blocuri sau tabel.
- Adresa blocului este transmisă unui registru ca parametru.
- Cel mai frecvent utilizat în Linux și Solaris.
- Iată codul programului C:
C
//Address of the block is passed as parameters> #include> #include> int> main() {> >const> char> *pathname =>'example.txt'>;> >int> flags = O_RDONLY;> >mode_t mode = 0644;> >int> params[3];> >// Block of data(parameters) in array> >params[0] = (>int>)pathname;> >params[1] = flags;> >params[2] = mode;> >int> fd = syscall(SYS_open, params);> >// system call> >if> (fd == -1) {> >perror>(>'Error opening file'>);> >return> 1;> >}> >// File operations here...> >close(fd);> >return> 0;> }> |
>
>
3.Parametrii sunt împinși într-o stivă
- În această metodă, parametrii pot fi introduși folosind programul și pot fi scoși din sistem de operare
- Astfel, Kernalul poate accesa cu ușurință datele prin preluarea informațiilor din partea de sus a stivei.
- Aici este codul programului C
C
//parameters are pushed into the stack> #include> #include> #include> int> main() {> >const> char> *pathname =>'example.txt'>;> >int> flags = O_RDONLY;> >mode_t mode = 0644;> >int> fd;> >asm>volatile>(> >'mov %1, %%rdi
'> >'mov %2, %%rsi
'> >'mov %3, %%rdx
'> >'mov , %%rax
'> >'syscall'> >:>'=a'> (fd)> >:>'r'> (pathname),>'r'> (flags),>'r'> (mode)> >:>'%rdi'>,>'%rsi'>,>'%rdx'> >);> >if> (fd == -1) {> >perror>(>'Error opening file'>);> >return> 1;> >}> >// File operations here...> >close(fd);> >return> 0;> }> |
>
>
Intrebari frecvente
Î.1: Cum funcționează un apel de sistem?
Răspuns:
Când un program execută un apel de sistem, acesta trece de la modul utilizator la modul kernel, care este un mod cu privilegii mai mari. Tranziția este de obicei inițiată prin invocarea unei anumite funcții sau întreruperea instrucțiunii furnizate de limbajul de programare sau de sistemul de operare.
Odată ajuns în modul kernel, apelul de sistem este gestionat de sistemul de operare. Nucleul efectuează operația solicitată în numele programului și returnează rezultatul. Ulterior, controlul este returnat programului la nivel de utilizator, care își continuă execuția.
Î.2: De ce sunt necesare apeluri de sistem?
Răspuns:
Apelurile de sistem sunt necesare din mai multe motive:
Acces la operațiuni privilegiate: Multe operațiuni, cum ar fi gestionarea dispozitivelor hardware sau modificarea configurațiilor sistemului, necesită privilegii mai mari care sunt accesibile numai prin apeluri de sistem.
Managementul resurselor: Apelurile de sistem oferă o interfață standardizată pentru alocarea și gestionarea resurselor sistemului, cum ar fi memoria, fișierele și dispozitivele, asigurând acces corect și controlat prin diferite procese.
Abstracție: Apelurile de sistem abstracte complexitățile subiacente ale sistemului de operare, permițând dezvoltatorilor de aplicații să interacționeze cu sistemul într-un mod de nivel superior, independent de platformă.
Paza si protectie: Apelurile de sistem impun controlul accesului și politicile de securitate, prevenind accesul neautorizat la resursele sensibile și protejând integritatea sistemului.