Inom datorer, a systemanrop är ett programmatiskt sätt på vilket ett datorprogram begär en tjänst från kärnan i operativsystemet det körs på. Ett systemanrop är ett sätt för program att interagera med operativsystemet . Ett datorprogram gör ett systemanrop när det gör en begäran till operativsystemets kärna. Systemanrop tillhandahåller operativsystemets tjänster till användarprogrammen via Application Program Interface (API). Den tillhandahåller ett gränssnitt mellan en process och ett operativsystem för att tillåta processer på användarnivå att begära tjänster av operativsystemet. Systemsamtal är de enda ingångspunkterna till kärna systemet. Alla program som behöver resurser måste använda systemanrop.
Ett användarprogram kan interagera med operativsystemet med hjälp av ett systemanrop. Ett antal tjänster efterfrågas av programmet, och operativsystemet svarar genom att starta ett antal systemanrop för att uppfylla begäran. Ett systemanrop kan skrivas på högnivåspråk som C eller Pascal eller på assemblerspråk. Om ett språk på hög nivå används kan operativsystemet direkt anropa systemanrop, som är fördefinierade funktioner.
Ett systemanrop är en mekanism som används av program för att begära tjänster från operativ system (OS). I enklare termer är det ett sätt för ett program att interagera med det underliggande systemet, som att komma åt hårdvaruresurser eller utföra privilegierade operationer.
Ett systemanrop initieras genom att programmet exekverar en specifik instruktion, som utlöser en switch till kärna läge, vilket gör att programmet kan begära en tjänst från operativsystemet. OS hanterar sedan begäran, utför de nödvändiga operationerna och returnerar resultatet tillbaka till programmet.
Systemanrop är avgörande för att ett operativsystem ska fungera korrekt, eftersom de tillhandahåller ett standardiserat sätt för program att komma åt systemresurser. Utan systemanrop skulle varje program behöva implementera sina egna metoder för att komma åt hårdvara och systemtjänster, vilket leder till inkonsekvent och felbenäget beteende.
Tjänster som tillhandahålls av systemsamtal
- Processskapande och ledning
- Huvudminneshantering
- Filåtkomst, katalog och filsystemhantering
- Enhetshantering (I/O)
- Skydd
- Nätverk, etc.
- Processkontroll: avsluta, avbryta, skapa, avsluta, allokera och frigöra minne.
- Filhantering: skapa, öppna, stänga, ta bort, läsa filer, etc.
- Enhetshantering
- Informationsunderhåll
- Kommunikation
Funktioner i systemsamtal
- Gränssnitt: Systemanrop ger ett väldefinierat gränssnitt mellan användarprogram och operativsystemet. Program gör förfrågningar genom att anropa specifika funktioner, och operativsystemet svarar genom att utföra den begärda tjänsten och returnera ett resultat.
- Skydd: Systemanrop används för att komma åt privilegierade operationer som inte är tillgängliga för vanliga användarprogram. Operativsystemet använder denna behörighet för att skydda systemet från skadlig eller obehörig åtkomst.
- Kärnläge: När ett systemanrop görs växlas programmet tillfälligt från användarläge till kärnläge. I kärnläge har programmet tillgång till alla systemresurser, inklusive hårdvara, minne och andra processer.
- Kontextväxling: Ett systemanrop kräver en kontextväxling, vilket innebär att man sparar tillståndet för den aktuella processen och växlar till kärnläget för att exekvera den begärda tjänsten. Detta kan införa overhead, vilket kan påverka systemets prestanda.
- Felhantering: Systemanrop kan returnera felkoder för att indikera problem med den begärda tjänsten. Program måste leta efter dessa fel och hantera dem på rätt sätt.
- Synkronisering: Systemsamtal kan användas för att synkronisera åtkomst till delade resurser, såsom filer eller nätverksanslutningar. Operativsystemet tillhandahåller synkroniseringsmekanismer, såsom lås eller semaforer, för att säkerställa att flera program kan komma åt dessa resurser på ett säkert sätt.
Fördelar med systemsamtal
- Tillgång till hårdvaruresurser: Systemanrop tillåter program att komma åt hårdvaruresurser som diskenheter, skrivare och nätverksenheter.
- Minneshantering: Systemanrop tillhandahåller ett sätt för program att allokera och avallokera minne, samt komma åt minneskartade hårdvaruenheter.
- Processhantering: Systemanrop tillåter program att skapa och avsluta processer, samt hantera kommunikation mellan processer.
- Säkerhet: Systemanrop ger program åtkomst till privilegierade resurser, till exempel möjligheten att ändra systeminställningar eller utföra operationer som kräver administrativa behörigheter.
- Standardisering: Systemanrop tillhandahåller ett standardiserat gränssnitt för program att interagera med operativsystemet, vilket säkerställer konsistens och kompatibilitet mellan olika hårdvaruplattformar och operativsystemversioner.
Hur fungerar systemsamtal?
Här är den detaljerade förklaringen steg för steg hur systemanrop fungerar:
- Användare behöver speciella resurser: Ibland behöver program göra några speciella saker som inte kan göras utan OS-tillstånd som att läsa från en fil, skriva till en fil, hämta information från hårdvaran eller begära ett utrymme i minnet.
- Programmet gör en systemanropsbegäran: Det finns speciella fördefinierade instruktioner för att göra en begäran till operativsystemet. Dessa instruktioner är inget annat än bara ett systemanrop. Programmet använder dessa systemanrop i sin kod när det behövs.
- Operativsystemet ser systemanropet: När operativsystemet ser systemanropet inser det att programmet behöver hjälp vid denna tidpunkt, så det stoppar tillfälligt programkörningen och ger all kontroll till en speciell del av sig själv som kallas 'Kernel'. Nu löser 'Kernel' behovet av program.
- Operativsystemet utför följande operationer: Nu utför operativsystemet operationen som efterfrågas av programmet. Exempel: läsa innehåll från en fil etc.
- Operativsystemet ger tillbaka kontrollen till programmet: Efter att ha utfört den speciella operationen ger OS tillbaka kontrollen till programmet för vidare exekvering av programmet.
Exempel på ett systemanrop i Windows och Unix
Systemanrop för Windows och Unix finns i många olika former. Dessa listas i tabellen nedan enligt följande:
| Bearbeta | Windows | Unix |
|---|---|---|
| Processkontroll | CreateProcess() ExitProcess() WaitForSingleObject() | Gaffel() Utgång() Vänta() |
| Filmanipulation | CreateFile() ReadFile() WriteFile() | Öppen() Läsa() Skriva() Stänga() |
| Enhetshantering | SetConsoleMode() vilka månader är q1 ReadConsole() WriteConsole() | Ioctl() Läsa() Skriva() |
| Informationsunderhåll | GetCurrentProcessID() SetTimer() Sova() | Getpid() Larm() Sova() |
| Kommunikation | CreatePipe() CreateFileMapping() MapViewOfFile() | Rör() Shmget() Mmap() |
| Skydd | SetFileSecurity() InitializeSecurityDescriptor() SetSecurityDescriptorgroup() | Chmod() demaskera() Chown() börjar med java |
öppen(): Att komma åt en fil på ett filsystem är möjligt med systemanropet open(). Det ger filresurserna den behöver och ett handtag som processen kan använda. En fil kan öppnas av flera processer samtidigt eller bara en process. Allt är baserat på struktur och filsystem.
läsa(): Data från en fil på filsystemet hämtas med den. I allmänhet accepterar den tre argument:
- En beskrivning av en fil.
- En buffert för läsdatalagring.
- Hur många byte ska läsas från filen
Innan du läste kunde filen som skulle läsas identifieras av sin filbeskrivning och öppnas med funktionen open().
vänta(): I vissa system kan en process behöva vänta tills en annan process har körts färdig innan den fortsätter. När en överordnad process skapar en underordnad process, stoppas exekveringen av den överordnade processen tills den underordnade processen är klar. Den överordnade processen stoppas med systemanropet wait(). Den överordnade processen återtar kontrollen när den underordnade processen har körts färdigt.
skriva(): Data från en användarbuffert skrivs med hjälp av den till en enhet som en fil. Ett program kan producera data på ett sätt genom att använda detta systemanrop . generellt finns det tre argument:
- En beskrivning av en fil.
- En referens till bufferten där data lagras.
- Mängden data som kommer att skrivas från bufferten i byte.
gaffel(): Systemanropet fork() används av processer för att skapa kopior av sig själva. Det är en av de metoder som används mest i operativsystem för att skapa processer. När en överordnad process skapar en underordnad process, avbryts exekveringen av den överordnade processen tills den underordnade processen är klar. Den överordnade processen återtar kontrollen när den underordnade processen har körts färdigt.
utgång(): Ett systemanrop som heter exit() används för att avsluta ett program. I miljöer med flera trådar indikerar detta anrop att trådexekveringen är klar. Efter att ha använt systemfunktionen exit() återställer operativsystemet de resurser som används av processen.
Metoder för att skicka parametrar till OS
Om ett systemanrop inträffar måste vi skicka parametern till Kernal-delen av operativsystemet.
Titta till exempel på det givna öppen() systemanrop:
C
hur många nollor i 1 miljard
//function call example> #include> int> open(>const> char> *pathname,>int> flags, mode_t mode);> |
>
>
Här sökvägsnamn , flaggor och mode_t är parametrarna.
Så det bör noteras att:
- Vi kan inte skicka parametrarna direkt som i ett vanligt funktionsanrop.
- I Kernal-läge finns det ett annat sätt att utföra ett funktionsanrop.
Så vi kan inte köra det i det normala adressutrymmet som processen redan hade skapat och därför kan vi inte placera parametrarna i toppen av stacken eftersom det inte är tillgängligt för operativsystemets kärna för bearbetning. så vi måste använda andra metoder för att skicka parametrarna till OS:s kärna.
Vi kan göra det genom,
- Passar parametrar i register
- Adressen till blocket skickas som en parameter i ett register.
- Parametrar skjuts in i en stack.
Låt oss diskutera varje punkt i detalj:
1. Skicka parametrar i register.
- Det är den enklaste metoden av de tre
- Här skickar vi parametrarna direkt till register.
- Men det kommer att begränsas när antalet parametrar är större än antalet register.
- Här är C-programkoden:
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. Adressen till blocket skickas som parametrar
- Den kan tillämpas när antalet parametrar är större än antalet register.
- Parametrar lagras i block eller tabeller.
- Adressen för blocket skickas till ett register som en parameter.
- Används oftast i Linux och Solaris.
- Här är C-programkoden:
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. Parametrar skjuts i en stack
- I denna metod kan parametrar tryckas in med hjälp av programmet och poppas ut med operativsystemet
- Så Kernal kan enkelt komma åt data genom att hämta information från toppen av stacken.
- Här är C-programkoden
C
java konvertera char till sträng
//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;> }> |
>
>
Vanliga frågor
F.1: Hur fungerar ett systemanrop?
Svar:
När ett program kör ett systemanrop övergår det från användarläge till kärnläge, vilket är ett högre privilegierat läge. Övergången initieras typiskt genom att anropa en specifik funktion eller avbrytande instruktion tillhandahållen av programmeringsspråket eller operativsystemet.
Väl i kärnläge hanteras systemanropet av operativsystemet. Kärnan utför den begärda operationen på uppdrag av programmet och returnerar resultatet. Därefter återförs kontrollen till programmet på användarnivå, som fortsätter att köras.
F.2: Varför är systemanrop nödvändiga?
Svar:
Systemsamtal är nödvändiga av flera skäl:
Tillgång till privilegierad verksamhet: Många operationer, som hantering av hårdvaruenheter eller modifiering av systemkonfigurationer, kräver högre behörigheter som endast är tillgängliga via systemanrop.
Resurshantering: Systemanrop tillhandahåller ett standardiserat gränssnitt för att allokera och hantera systemresurser som minne, filer och enheter, vilket säkerställer rättvis och kontrollerad åtkomst av olika processer.
Abstraktion: Systemanrop abstraherar den underliggande komplexiteten i operativsystemet, vilket gör att applikationsutvecklare kan interagera med systemet på ett plattformsoberoende sätt på högre nivå.
Säkerhet och skydd: Systemanrop upprätthåller åtkomstkontroll och säkerhetspolicyer, förhindrar obehörig åtkomst till känsliga resurser och skyddar systemets integritet.