INTRODUCTIE VAN SYSTEEMOPROEP

Bij computergebruik is a systeem oproep is een programmatische manier waarop een computerprogramma een dienst vraagt aan de kernel van het besturingssysteem waarop het wordt uitgevoerd. Een systeemaanroep is een manier voor programma's om interactie met het besturingssysteem . Een computerprogramma doet een systeemoproep wanneer het een verzoek doet aan de kernel van het besturingssysteem. Systeemoproep biedt de diensten van het besturingssysteem aan de gebruikersprogramma's via Application Program Interface (API). Het biedt een interface tussen een proces en een besturingssysteem, zodat processen op gebruikersniveau diensten van het besturingssysteem kunnen aanvragen. Systeemoproepen zijn de enige toegangspunten tot het kern systeem. Alle programma's die bronnen nodig hebben, moeten systeemaanroepen gebruiken.

Een gebruikersprogramma kan communiceren met het besturingssysteem via een systeemaanroep. Het programma vraagt een aantal services aan en het besturingssysteem reageert door een aantal systeemaanroepen te lanceren om aan het verzoek te voldoen. Een systeemaanroep kan worden geschreven in talen op hoog niveau, zoals C of Pascal, of in assembleertaal. Als een taal op hoog niveau wordt gebruikt, kan het besturingssysteem rechtstreeks systeemaanroepen oproepen, dit zijn vooraf gedefinieerde functies.

Een systeemaanroep is een mechanisme dat door programma's wordt gebruikt om services aan te vragen bij de besturingssysteem (OS). In eenvoudiger bewoordingen is het een manier waarop een programma kan communiceren met het onderliggende systeem, zoals toegang krijgen tot hardwarebronnen of bevoorrechte bewerkingen uitvoeren.

Een systeemaanroep wordt geïnitieerd doordat het programma een specifieke instructie uitvoert, waardoor er wordt overgeschakeld naar kern modus, waardoor het programma een service van het besturingssysteem kan aanvragen. Het besturingssysteem handelt vervolgens het verzoek af, voert de noodzakelijke bewerkingen uit en stuurt het resultaat terug naar het programma.

Systeemaanroepen zijn essentieel voor de goede werking van een besturingssysteem, omdat ze programma's een gestandaardiseerde manier bieden om toegang te krijgen tot systeembronnen. Zonder systeemaanroepen zou elk programma zijn eigen methoden moeten implementeren voor toegang tot hardware en systeemservices, wat leidt tot inconsistent en foutgevoelig gedrag.

Diensten geleverd door systeemoproepen

Procescreatie en beheer
Beheer van het hoofdgeheugen
Bestandstoegang, directory- en bestandssysteembeheer
Apparaatverwerking (I/O)
Bescherming
Netwerken, enz.
- Procesbeheersing: geheugen beëindigen, afbreken, creëren, beëindigen, toewijzen en vrijmaken.
- Bestandsbeheer: bestanden maken, openen, sluiten, verwijderen, lezen, enz.
- Apparaatbeheer
- Onderhoud van informatie
- Communicatie

Kenmerken van systeemoproepen

Koppel: Systeemaanroepen bieden een goed gedefinieerde interface tussen gebruikersprogramma's en het besturingssysteem. Programma's doen verzoeken door specifieke functies aan te roepen, en het besturingssysteem reageert door de gevraagde service uit te voeren en een resultaat te retourneren.
Bescherming: Systeemaanroepen worden gebruikt om toegang te krijgen tot bevoorrechte bewerkingen die niet beschikbaar zijn voor normale gebruikersprogramma's. Het besturingssysteem gebruikt dit recht om het systeem te beschermen tegen kwaadwillige of ongeautoriseerde toegang.
Kernel-modus: Wanneer er een systeemaanroep wordt gedaan, wordt het programma tijdelijk overgeschakeld van de gebruikersmodus naar de kernelmodus. In de kernelmodus heeft het programma toegang tot alle systeembronnen, inclusief hardware, geheugen en andere processen.
Contextwisseling: Een systeemaanroep vereist een contextwisseling, waarbij de status van het huidige proces wordt opgeslagen en naar de kernelmodus wordt overgeschakeld om de gevraagde service uit te voeren. Dit kan overhead met zich meebrengen, wat van invloed kan zijn op de systeemprestaties.
Foutafhandeling: Systeemoproepen kunnen foutcodes retourneren om problemen met de gevraagde service aan te geven. Programma's moeten deze fouten controleren en op de juiste manier afhandelen.
Synchronisatie: Systeemoproepen kunnen worden gebruikt om de toegang tot gedeelde bronnen, zoals bestanden of netwerkverbindingen, te synchroniseren. Het besturingssysteem biedt synchronisatiemechanismen, zoals vergrendelingen of semaforen, om ervoor te zorgen dat meerdere programma's veilig toegang kunnen krijgen tot deze bronnen.

Systeemoproepen voordelen

Toegang tot hardwarebronnen: Met systeemaanroepen kunnen programma's toegang krijgen tot hardwarebronnen zoals schijfstations, printers en netwerkapparaten.
Geheugen management: Systeemaanroepen bieden programma's een manier om geheugen toe te wijzen en de toewijzing ervan ongedaan te maken, en om toegang te krijgen tot geheugentoegewezen hardwareapparaten.
Procesmanagement: Met systeemaanroepen kunnen programma's processen creëren en beëindigen, en de communicatie tussen processen beheren.
Beveiliging: Systeemaanroepen bieden programma's een manier om toegang te krijgen tot bevoorrechte bronnen, zoals de mogelijkheid om systeeminstellingen te wijzigen of bewerkingen uit te voeren waarvoor beheerdersrechten nodig zijn.
Standaardisatie: Systeemaanroepen bieden een gestandaardiseerde interface waarmee programma's kunnen communiceren met het besturingssysteem, waardoor consistentie en compatibiliteit tussen verschillende hardwareplatforms en besturingssysteemversies wordt gegarandeerd.

Hoe werkt systeemoproep?

Hier vindt u stap voor stap een gedetailleerde uitleg over hoe systeemoproepen werken:

De gebruiker heeft speciale bronnen nodig: Soms moeten programma's speciale dingen doen die niet kunnen worden gedaan zonder de toestemming van het besturingssysteem, zoals het lezen van een bestand, het schrijven naar een bestand, het ophalen van informatie van de hardware of het opvragen van ruimte in het geheugen.

Programma maakt een systeemoproepverzoek: Er zijn speciale vooraf gedefinieerde instructies om een verzoek in te dienen bij het besturingssysteem. Deze instructies zijn niets anders dan slechts een systeemaanroep. Het programma gebruikt deze systeemaanroepen in de code wanneer dat nodig is.

Het besturingssysteem ziet de systeemaanroep: Wanneer het besturingssysteem de systeemaanroep ziet, herkent het dat het programma op dit moment hulp nodig heeft, dus stopt het tijdelijk de uitvoering van het programma en geeft het alle controle aan een speciaal deel van zichzelf genaamd ‘Kernel’. Nu lost ‘Kernel’ de behoefte aan programma op.

Het besturingssysteem voert de bewerkingen uit: Nu voert het besturingssysteem de bewerking uit die door het programma wordt gevraagd. Voorbeeld: inhoud uit een bestand lezen enz.

Besturingssysteem geeft de controle terug aan het programma: Na het uitvoeren van de speciale bewerking geeft het besturingssysteem de controle terug aan het programma voor verdere uitvoering van programma.

Voorbeelden van een systeemoproep in Windows en Unix

Systeemaanroepen voor Windows en Unix zijn er in veel verschillende vormen. Deze staan in onderstaande tabel als volgt vermeld:

ctc volledige vorm

Proces	ramen	Unix
Procesbeheersing	CreateProces() ExitProces() WaitForSingleObject()	Vork() Uitgang() Wachten()
Bestandsmanipulatie	Bestand maken() LeesBestand() SchrijfBestand()	Open() Lezen() Schrijven() Dichtbij()
Apparaatbeheer	SetConsoleMode() LeesConsole() SchrijfConsole()	Ioctl() Lezen() Schrijven()
Informatie Onderhoud	GetCurrentProcessID() SetTimer() Slaap()	Getpid() Alarm() Slaap()
Communicatie	CreatePipe() CreateFileMapping() MapViewOfFile()	Pijp() Shmget() Mmap()
Bescherming	SetFileSecurity() InitializeSecurityDescriptor() SetSecurityDescriptorgroep()	Chmod() ontmaskeren() Chown()

Proces

ramen

Unix

Procesbeheersing

CreateProces()

ExitProces()

WaitForSingleObject()

Vork()

Uitgang()

Wachten()

Bestandsmanipulatie

Bestand maken()

LeesBestand()

SchrijfBestand()

Open()

Lezen()

Schrijven()

Dichtbij()

Apparaatbeheer

SetConsoleMode()

LeesConsole()

SchrijfConsole()

Ioctl()

Lezen()

Schrijven()

Informatie Onderhoud

GetCurrentProcessID()

SetTimer()

Slaap()

Getpid()

Alarm()

Slaap()

Communicatie

CreatePipe()

CreateFileMapping()

MapViewOfFile()

Pijp()

Shmget()

Mmap()

Bescherming

SetFileSecurity()

InitializeSecurityDescriptor()

SetSecurityDescriptorgroep()

Chmod()

ontmaskeren()

Chown()

open(): Toegang krijgen tot een bestand op een bestandssysteem is mogelijk met de systeemaanroep open(). Het geeft de bestandsbronnen die het nodig heeft en een handvat dat het proces kan gebruiken. Een bestand kan tegelijkertijd door meerdere processen of slechts door één proces worden geopend. Alles is gebaseerd op de structuur en het bestandssysteem.

lezen(): Gegevens uit een bestand op het bestandssysteem worden ermee opgehaald. Over het algemeen aanvaardt het drie argumenten:

Een beschrijving van een bestand.
Een buffer voor opslag van leesgegevens.
Hoeveel bytes moeten er uit het bestand worden gelezen
Vóór het lezen kan het te lezen bestand worden geïdentificeerd aan de hand van de bestandsdescriptor en worden geopend met de functie open().

wachten(): In sommige systemen moet een proces wellicht wachten tot een ander proces klaar is voordat het verdergaat. Wanneer een ouderproces een onderliggend proces aanmaakt, wordt de uitvoering van het bovenliggende proces stopgezet totdat het onderliggend proces voltooid is. Het bovenliggende proces wordt gestopt met behulp van de wait() systeemaanroep. Het bovenliggende proces krijgt weer de controle zodra het onderliggende proces is voltooid.

schrijven(): Gegevens uit een gebruikersbuffer worden hiermee als een bestand naar een apparaat geschreven. Hiermee kan een programma op één manier gegevens produceren systeem oproep . Over het algemeen zijn er drie argumenten:

Een beschrijving van een bestand.
Een verwijzing naar de buffer waarin gegevens worden opgeslagen.
De hoeveelheid gegevens die vanuit de buffer wordt geschreven, in bytes.

vork(): De systeemaanroep fork() wordt door processen gebruikt om kopieën van zichzelf te maken. Het is een van de methoden die het meest worden gebruikt in besturingssystemen om processen te creëren. Wanneer een ouderproces een onderliggend proces aanmaakt, wordt de uitvoering van het bovenliggende proces opgeschort totdat het onderliggend proces is voltooid. Het bovenliggende proces krijgt weer de controle zodra het onderliggende proces is voltooid.

Uitgang(): Een systeemaanroep genaamd exit() wordt gebruikt om een programma te beëindigen. In omgevingen met meerdere threads geeft deze aanroep aan dat de uitvoering van de thread is voltooid. Na gebruik van de systeemfunctie exit() herstelt het besturingssysteem de bronnen die door het proces worden gebruikt.

javascriptvariabele globaal

Methoden om parameters door te geven aan het besturingssysteem

Als er een systeemaanroep plaatsvindt, moeten we de parameter doorgeven aan het Kernal-gedeelte van het besturingssysteem.

Kijk bijvoorbeeld eens naar het gegeven open() systeemoproep:

C

//function call example> #include> int> open(>const> char> *pathname,>int> flags, mode_t mode);>

Hier padnaam , vlaggen En mode_t zijn de parameters.

jquery deze klik

Er moet dus worden opgemerkt dat:

We kunnen de parameters niet rechtstreeks doorgeven, zoals bij een gewone functieaanroep.
In de Kernal-modus is er een andere manier om een functieaanroep uit te voeren.

We kunnen het dus niet uitvoeren in de normale adresruimte die het proces al heeft aangemaakt en daarom kunnen we de parameters niet bovenaan de stapel plaatsen omdat het niet beschikbaar is voor de Kernal van het besturingssysteem voor verwerking. dus we moeten andere methoden gebruiken om de parameters door te geven aan de Kernal van het besturingssysteem.

We kunnen het doen door,

Parameters doorgeven in registers
Het adres van het blok wordt als parameter in een register doorgegeven.
Parameters worden in een stapel geduwd.

Laten we elk punt in detail bespreken:

1. Parameters doorgeven in registers.

Het is de eenvoudigste methode van de drie
Hier geven we de parameters rechtstreeks door aan registers.
Maar het zal beperkt zijn wanneer het aantal parameters groter is dan het aantal registers.
Hier is de C-programmacode:

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;> }>

2. Het adres van het blok wordt als parameter doorgegeven

Het kan worden toegepast als het aantal parameters groter is dan het aantal registers.
Parameters worden opgeslagen in blokken of in tabellen.
Het adres van het blok wordt als parameter aan een register doorgegeven.
Meestal gebruikt in Linux en Solaris.
Hier is de C-programmacode:

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.Parameters worden in een stapel geduwd

Bij deze methode kunnen parameters met behulp van het programma worden ingevoerd en met behulp van het besturingssysteem worden verwijderd
De Kernal heeft dus eenvoudig toegang tot de gegevens door informatie van de bovenkant van de stapel op te halen.
Hier is de C-programmacode

C

microlithische kern

//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;> }>

Vaak gestelde vraag

Vraag.1: Hoe werkt een systeemoproep?

Antwoord:

Wanneer een programma een systeemaanroep uitvoert, gaat het over van de gebruikersmodus naar de kernelmodus, wat een modus met hogere privileges is. De overgang wordt doorgaans geïnitieerd door het aanroepen van een specifieke functie of het onderbreken van instructies die door de programmeertaal of het besturingssysteem worden geleverd.

Eenmaal in de kernelmodus wordt de systeemaanroep afgehandeld door het besturingssysteem. De kernel voert de gevraagde bewerking uit namens het programma en retourneert het resultaat. Daarna wordt de controle teruggegeven aan het programma op gebruikersniveau, dat de uitvoering ervan voortzet.

Vraag 2: Waarom zijn systeemoproepen nodig?