Tietojenkäsittelyssä a järjestelmäpuhelu on ohjelmallinen tapa, jolla tietokoneohjelma pyytää palvelua sen käyttöjärjestelmän ytimältä, jossa se suoritetaan. Järjestelmäkutsu on tapa ohjelmille olla vuorovaikutuksessa käyttöjärjestelmän kanssa . Tietokoneohjelma tekee järjestelmäkutsun, kun se tekee pyynnön käyttöjärjestelmän ytimelle. Järjestelmäpuhelu tarjoaa käyttöjärjestelmän palvelut käyttäjäohjelmille Application Program Interfacen (API) kautta. Se tarjoaa käyttöliittymän prosessin ja käyttöjärjestelmän välille, jotta käyttäjätason prosessit voivat pyytää käyttöjärjestelmän palveluita. Järjestelmäpuhelut ovat ainoat sisääntulokohdat ydin järjestelmä. Kaikkien resursseja tarvitsevien ohjelmien on käytettävä järjestelmäkutsuja.
Käyttäjäohjelma voi olla vuorovaikutuksessa käyttöjärjestelmän kanssa järjestelmäkutsulla. Ohjelma pyytää useita palveluita, ja käyttöjärjestelmä vastaa käynnistämällä useita järjestelmäkutsuja pyynnön täyttämiseksi. Järjestelmäkutsu voidaan kirjoittaa korkean tason kielillä, kuten C tai Pascal, tai kokoonpanokielellä. Jos käytetään korkean tason kieltä, käyttöjärjestelmä voi kutsua suoraan järjestelmäkutsuja, jotka ovat ennalta määritettyjä toimintoja.
Järjestelmäkutsu on mekanismi, jota ohjelmat käyttävät pyytääkseen palveluita käyttöjärjestelmä (OS). Yksinkertaisemmin sanottuna se on tapa, jolla ohjelma voi olla vuorovaikutuksessa taustalla olevan järjestelmän kanssa, kuten käyttää laitteistoresursseja tai suorittaa etuoikeutettuja toimintoja.
Järjestelmäkutsun käynnistää ohjelma suorittamalla tietyn käskyn, joka laukaisee vaihdon ydin -tilassa, jolloin ohjelma voi pyytää palvelua käyttöjärjestelmästä. Tämän jälkeen käyttöjärjestelmä käsittelee pyynnön, suorittaa tarvittavat toiminnot ja palauttaa tuloksen takaisin ohjelmaan.
Järjestelmäkutsut ovat välttämättömiä käyttöjärjestelmän asianmukaiselle toiminnalle, koska ne tarjoavat ohjelmille standardoidun tavan käyttää järjestelmäresursseja. Ilman järjestelmäkutsuja jokaisen ohjelman olisi otettava käyttöön omat menetelmänsä päästäkseen laitteistoon ja järjestelmäpalveluihin, mikä johtaisi epäjohdonmukaiseen ja virhealttiiseen toimintaan.
Järjestelmäpuheluiden tarjoamat palvelut
- Prosessien luominen ja hallinta
- Päämuistin hallinta
- Tiedostojen käyttö, hakemiston ja tiedostojärjestelmän hallinta
- Laitteen käsittely (I/O)
- Suojaus
- Verkostoituminen jne.
- Prosessinhallinta: lopettaa, keskeyttää, luoda, lopettaa, varata ja vapauttaa muistia.
- Tiedostonhallinta: luoda, avata, sulkea, poistaa, lukea tiedostoja jne.
- Laitehallinta
- Tietojen ylläpito
- Viestintä
Järjestelmäpuheluiden ominaisuudet
- Käyttöliittymä: Järjestelmäkutsut tarjoavat hyvin määritellyn rajapinnan käyttäjäohjelmien ja käyttöjärjestelmän välillä. Ohjelmat tekevät pyyntöjä kutsumalla tiettyjä toimintoja, ja käyttöjärjestelmä vastaa suorittamalla pyydetyn palvelun ja palauttamalla tuloksen.
- Suojaus: Järjestelmäkutsuja käytetään sellaisten etuoikeutettujen toimintojen käyttämiseen, jotka eivät ole tavallisten käyttäjäohjelmien käytettävissä. Käyttöjärjestelmä käyttää tätä oikeutta suojatakseen järjestelmää haitallisilta tai luvattomalta käytöltä.
- Ydintila: Kun järjestelmäkutsu tehdään, ohjelma siirtyy tilapäisesti käyttäjätilasta ydintilaan. Ydintilassa ohjelmalla on pääsy kaikkiin järjestelmäresursseihin, mukaan lukien laitteisto, muisti ja muut prosessit.
- Kontekstin vaihto: Järjestelmäkutsu vaatii kontekstin vaihtamisen, joka sisältää nykyisen prosessin tilan tallentamisen ja vaihdon ydintilaan pyydetyn palvelun suorittamiseksi. Tämä voi aiheuttaa ylimääräisiä kuluja, jotka voivat vaikuttaa järjestelmän suorituskykyyn.
- Virheiden käsittely: Järjestelmäpuhelut voivat palauttaa virhekoodeja, jotka osoittavat pyydetyn palvelun ongelmia. Ohjelmien tulee tarkistaa nämä virheet ja käsitellä niitä asianmukaisesti.
- Synkronointi: Järjestelmäkutsuja voidaan käyttää jaettujen resurssien, kuten tiedostojen tai verkkoyhteyksien, käytön synkronoimiseen. Käyttöjärjestelmä tarjoaa synkronointimekanismeja, kuten lukkoja tai semaforeja, joilla varmistetaan, että useat ohjelmat voivat käyttää näitä resursseja turvallisesti.
Järjestelmäpuheluiden edut
- Pääsy laitteistoresursseihin: Järjestelmäkutsujen avulla ohjelmat voivat käyttää laitteistoresursseja, kuten levyasemia, tulostimia ja verkkolaitteita.
- Muistin hallinta: Järjestelmäkutsut tarjoavat ohjelmille tavan varata ja vapauttaa muistia sekä käyttää muistikartoitettuja laitteita.
- Prosessinhallinta: Järjestelmäkutsujen avulla ohjelmat voivat luoda ja lopettaa prosesseja sekä hallita prosessien välistä viestintää.
- Turvallisuus: Järjestelmäkutsut tarjoavat ohjelmille tavan käyttää etuoikeutettuja resursseja, kuten mahdollisuuden muokata järjestelmäasetuksia tai suorittaa toimintoja, jotka edellyttävät järjestelmänvalvojan oikeuksia.
- Standardointi: Järjestelmäkutsut tarjoavat standardoidun käyttöliittymän ohjelmille, jotka voivat olla vuorovaikutuksessa käyttöjärjestelmän kanssa, mikä varmistaa johdonmukaisuuden ja yhteensopivuuden eri laitteistoympäristöissä ja käyttöjärjestelmäversioissa.
Kuinka järjestelmäpuhelu toimii?
Tässä on yksityiskohtainen selitys vaihe vaiheelta, kuinka järjestelmäkutsut toimivat:
- Käyttäjä tarvitsee erityisresursseja: Joskus ohjelmien on tehtävä joitain erikoistoimintoja, joita ei voida tehdä ilman käyttöjärjestelmän lupaa, kuten lukeminen tiedostosta, kirjoittaminen tiedostoon, tietojen saaminen laitteistosta tai muistitilan pyytäminen.
- Ohjelma tekee järjestelmäkutsupyynnön: Pyynnön tekemiseen käyttöjärjestelmälle on olemassa erityisiä ennalta määritettyjä ohjeita. Nämä ohjeet ovat vain järjestelmäkutsu. Ohjelma käyttää näitä järjestelmäkutsuja koodissaan tarvittaessa.
- Käyttöjärjestelmä näkee järjestelmäkutsun: Kun käyttöjärjestelmä näkee järjestelmäkutsun, se tunnistaa, että ohjelma tarvitsee apua tällä hetkellä, joten se pysäyttää tilapäisesti ohjelman suorittamisen ja antaa kaiken hallinnan erityiselle osalleen nimeltä 'Kernel'. Nyt 'Ydin' ratkaisee ohjelman tarpeen.
- Käyttöjärjestelmä suorittaa seuraavat toiminnot: Nyt käyttöjärjestelmä suorittaa ohjelman pyytämän toiminnon. Esimerkki: sisällön lukeminen tiedostosta jne.
- Käyttöjärjestelmä antaa ohjauksen takaisin ohjelmalle: Erikoistoiminnon suorittamisen jälkeen käyttöjärjestelmä antaa ohjauksen takaisin ohjelmalle ohjelman suorittamista varten.
Esimerkkejä järjestelmäkutsusta Windowsissa ja Unixissa
Windows- ja Unix-järjestelmäkutsut tulevat monissa eri muodoissa. Ne on lueteltu alla olevassa taulukossa seuraavasti:
| Käsitellä asiaa | Windows | Unix |
|---|---|---|
| Prosessinhallinta | CreateProcess() ExitProcess() WaitForSingleObject() | Haarukka() Poistu() Odota() |
| Tiedostojen käsittely | Luo tiedosto() Lue tiedosto() Kirjoitatiedosto() | Avata() Lukea() Kirjoittaa() Kiinni() |
| Laitehallinta | SetConsoleMode() ReadConsole() WriteConsole() | Ioctl() Lukea() 3d autocadissa Kirjoittaa() |
| Tietojen ylläpito | Get CurrentProcessID() SetTimer() Nukkua() | Getpid() Hälytys() Nukkua() |
| Viestintä | CreatePipe() CreateFileMapping() MapViewOfFile() | Putki() Shmget() Mmap() |
| Suojaus | SetFileSecurity() InitializeSecurityDescriptor() SetSecurityDescriptorgroup() | Chmod() paljastaa() Chown() |
avata(): Tiedostojärjestelmän tiedostoon pääsy on mahdollista open()-järjestelmäkutsulla. Se antaa tarvitsemansa tiedostoresurssit ja kahvan, jota prosessi voi käyttää. Tiedosto voidaan avata usealla prosessilla samanaikaisesti tai vain yhdellä prosessilla. Kaikki perustuu rakenteeseen ja tiedostojärjestelmään.
lukea(): Tiedostojärjestelmässä olevan tiedoston tiedot haetaan sen avulla. Yleisesti ottaen se hyväksyy kolme argumenttia:
- Tiedoston kuvaus.
- Puskuri lukutietojen tallentamiseen.
- Kuinka monta tavua tiedostosta tulee lukea
Ennen lukemista luettava tiedosto voitiin tunnistaa sen tiedostokuvaajan avulla ja avata open()-funktiolla.
odota(): Joissakin järjestelmissä prosessia on ehkä lykättävä, kunnes toinen prosessi on päättynyt ennen jatkamista. Kun ylätason prosessi luo aliprosessin, ylätason prosessin suoritus keskeytetään, kunnes aliprosessi on valmis. Pääprosessi pysäytetään wait()-järjestelmäkutsulla. Pääprosessi saa hallinnan takaisin, kun aliprosessi on päättynyt.
kirjoittaa(): Käyttäjäpuskurin tiedot kirjoitetaan sen avulla laitteeseen, kuten tiedostoon. Ohjelma voi tuottaa dataa yhdellä tavalla tätä käyttämällä järjestelmäpuhelu . Yleensä argumentteja on kolme:
- Tiedoston kuvaus.
- Viittaus puskuriin, johon tiedot on tallennettu.
- Puskurista kirjoitettavan datan määrä tavuina.
haarukka(): Prosessit käyttävät järjestelmäkutsua fork() luodakseen kopioita itsestään. Se on yksi menetelmistä, joita käytetään useimmin käyttöjärjestelmissä prosessien luomiseen. Kun pääprosessi luo aliprosessin, pääprosessin suoritus keskeytetään, kunnes aliprosessi on valmis. Pääprosessi saa hallinnan takaisin, kun aliprosessi on päättynyt.
exit(): Järjestelmäkutsua nimeltä exit() käytetään ohjelman lopettamiseen. Ympäristöissä, joissa on useita säikeitä, tämä kutsu osoittaa, että säikeen suoritus on valmis. Exit() system -funktion käytön jälkeen käyttöjärjestelmä palauttaa prosessin käyttämät resurssit.
Menetelmät parametrien siirtämiseksi käyttöjärjestelmään
Jos järjestelmäkutsu tapahtuu, meidän on välitettävä parametri käyttöjärjestelmän ydinosalle.
Katso esimerkiksi annettua avata() järjestelmäkutsu:
C
//function call example> #include> int> open(>const> char> *pathname,>int> flags, mode_t mode);> |
>
>
Tässä polun nimi , liput ja mode_t ovat parametrit.
On siis huomioitava, että:
- Emme voi välittää parametreja suoraan kuten tavallisessa funktiokutsussa.
- Kernal-tilassa funktiokutsu voidaan suorittaa eri tavalla.
Emme siis voi suorittaa sitä normaalissa osoiteavaruudessa, jonka prosessi oli jo luonut, ja siksi emme voi sijoittaa parametreja pinon yläosaan, koska se ei ole käyttöjärjestelmän ytimen käytettävissä käsittelyä varten. joten meidän on käytettävä muita menetelmiä parametrien välittämiseksi käyttöjärjestelmän ytimeen.
Voimme tehdä sen läpi,
- Parametrien välittäminen rekistereissä
- Lohkon osoite välitetään parametrina rekisterissä.
- Parametrit työnnetään pinoon.
Keskustellaan jokaisesta kohdasta yksityiskohtaisesti:
1. Parametrien välittäminen rekistereissä.
- Se on yksinkertaisin menetelmä näistä kolmesta
- Tässä välitämme parametrit suoraan rekistereihin.
- Mutta se on rajoitettu, kun parametrien määrä on suurempi kuin rekisterien lukumäärä.
- Tässä on C-ohjelman koodi:
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. Lohkon osoite välitetään parametreina
- Sitä voidaan käyttää, kun parametrien lukumäärä on suurempi kuin rekisterien lukumäärä.
- Parametrit tallennetaan lohkoihin tai taulukkoon.
- Lohkon osoite välitetään rekisteriin parametrina.
- Yleisimmin käytetty Linuxissa ja Solariksessa.
- Tässä on C-ohjelman koodi:
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. Parametrit työnnetään pinoon
- Tässä menetelmässä parametrit voidaan työntää sisään ohjelman avulla ja ponnahtaa ulos käyttöjärjestelmän avulla
- Joten Kernal pääsee helposti käsiksi tietoihin hakemalla tietoja pinon yläosasta.
- Tässä on C-ohjelmakoodi
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;> }> |
>
>
Usein kysytty kysymys
K.1: Kuinka järjestelmäkutsu toimii?
Vastaus:
Kun ohjelma suorittaa järjestelmäkutsun, se siirtyy käyttäjätilasta ytimen tilaan, joka on korkeampi etuoikeus. Siirtyminen aloitetaan tyypillisesti kutsumalla tietty toiminto tai keskeyttämällä ohjelmointikielen tai käyttöjärjestelmän antama käsky.
Kerneltilassa käyttöjärjestelmä käsittelee järjestelmäkutsun. Ydin suorittaa pyydetyn toiminnon ohjelman puolesta ja palauttaa tuloksen. Tämän jälkeen ohjaus palautetaan käyttäjätason ohjelmalle, joka jatkaa suoritustaan.
K.2: Miksi järjestelmäkutsut ovat tarpeen?
Vastaus:
Järjestelmäkutsuja tarvitaan useista syistä:
Pääsy etuoikeutettuihin toimintoihin: Monet toiminnot, kuten laitteiston hallinta tai järjestelmäkokoonpanojen muokkaaminen, vaativat korkeampia oikeuksia, jotka ovat käytettävissä vain järjestelmäkutsujen kautta.
Resurssienhallinta: Järjestelmäkutsut tarjoavat standardoidun käyttöliittymän järjestelmäresurssien, kuten muistin, tiedostojen ja laitteiden, varaamiseen ja hallintaan, mikä varmistaa oikeudenmukaisen ja kontrolloidun pääsyn eri prosesseille.
Abstraktio: Järjestelmäkutsut abstraktioivat käyttöjärjestelmän taustalla olevista monimutkaisista syistä, jolloin sovelluskehittäjät voivat olla vuorovaikutuksessa järjestelmän kanssa korkeammalla tasolla, alustasta riippumattomalla tavalla.
Turvallisuus ja suojaus: Järjestelmäpuhelut pakottavat kulunvalvonta- ja suojauskäytännöt, estävät luvattoman pääsyn arkaluonteisiin resursseihin ja suojaavat järjestelmän eheyttä.