Inden for databehandling, en systemopkald er en programmatisk måde, hvorpå et computerprogram anmoder om en tjeneste fra kernen af det operativsystem, det udføres på. Et systemkald er en måde for programmer til interagere med operativsystemet . Et computerprogram foretager et systemkald, når det sender en anmodning til operativsystemets kerne. Systemkald giver operativsystemets tjenester til brugerprogrammerne via Application Program Interface (API). Det giver en grænseflade mellem en proces og et operativsystem for at tillade processer på brugerniveau at anmode om tjenester af operativsystemet. Systemopkald er de eneste indgangspunkter til kerne system. Alle programmer, der har brug for ressourcer, skal bruge systemkald.
Et brugerprogram kan interagere med operativsystemet ved hjælp af et systemkald. En række tjenester efterspørges af programmet, og OS reagerer ved at starte en række systemopkald for at opfylde anmodningen. Et systemkald kan skrives på højt niveau sprog som C eller Pascal eller i assemblersprog. Hvis der bruges et højt niveau sprog, kan operativsystemet direkte kalde systemkald, som er foruddefinerede funktioner.
hvor mange frugter er der
Et systemkald er en mekanisme, der bruges af programmer til at anmode om tjenester fra operativ system (OS). I enklere vendinger er det en måde for et program at interagere med det underliggende system, såsom at få adgang til hardwareressourcer eller udføre privilegerede operationer.
Et systemkald initieres ved, at programmet udfører en specifik instruktion, som udløser et skift til kerne tilstand, hvilket tillader programmet at anmode om en tjeneste fra OS. OS håndterer derefter anmodningen, udfører de nødvendige handlinger og returnerer resultatet tilbage til programmet.
Systemkald er afgørende for et operativsystems korrekte funktion, da de giver programmer en standardiseret måde at få adgang til systemressourcer på. Uden systemopkald ville hvert program skulle implementere sine egne metoder til at få adgang til hardware og systemtjenester, hvilket fører til inkonsekvent og fejltilbøjelig adfærd.
Tjenester leveret af systemopkald
- Proces skabelse og ledelse
- Hovedhukommelsesstyring
- Filadgang, bibliotek og filsystemstyring
- Enhedshåndtering (I/O)
- Beskyttelse
- Netværk mv.
- Proces kontrol: afslutte, afbryde, oprette, afslutte, allokere og frigøre hukommelse.
- Filhåndtering: oprette, åbne, lukke, slette, læse filer osv.
- Enhedshåndtering
- Informationsvedligeholdelse
- Meddelelse
Funktioner af systemopkald
- Interface: Systemkald giver en veldefineret grænseflade mellem brugerprogrammer og operativsystemet. Programmer fremsætter anmodninger ved at kalde specifikke funktioner, og operativsystemet reagerer ved at udføre den anmodede tjeneste og returnere et resultat.
- Beskyttelse: Systemkald bruges til at få adgang til privilegerede handlinger, der ikke er tilgængelige for normale brugerprogrammer. Operativsystemet bruger dette privilegium til at beskytte systemet mod ondsindet eller uautoriseret adgang.
- Kerneltilstand: Når der foretages et systemkald, skiftes programmet midlertidigt fra brugertilstand til kernetilstand. I kernetilstand har programmet adgang til alle systemressourcer, inklusive hardware, hukommelse og andre processer.
- Kontekstskift: Et systemkald kræver et kontekstskift, som involverer lagring af tilstanden for den aktuelle proces og skift til kernetilstand for at udføre den anmodede tjeneste. Dette kan introducere overhead, hvilket kan påvirke systemets ydeevne.
- Fejlhåndtering: Systemopkald kan returnere fejlkoder for at indikere problemer med den anmodede tjeneste. Programmer skal kontrollere for disse fejl og håndtere dem korrekt.
- Synkronisering: Systemopkald kan bruges til at synkronisere adgang til delte ressourcer, såsom filer eller netværksforbindelser. Operativsystemet giver synkroniseringsmekanismer, såsom låse eller semaforer, for at sikre, at flere programmer kan få sikker adgang til disse ressourcer.
Fordele ved systemopkald
- Adgang til hardwareressourcer: Systemkald giver programmer adgang til hardwareressourcer såsom diskdrev, printere og netværksenheder.
- Hukommelseshåndtering: Systemkald giver programmer mulighed for at allokere og deallokere hukommelse samt få adgang til hukommelseskortede hardwareenheder.
- Processtyring: Systemkald giver programmer mulighed for at oprette og afslutte processer samt styre kommunikation mellem processer.
- Sikkerhed: Systemkald giver programmer mulighed for at få adgang til privilegerede ressourcer, såsom muligheden for at ændre systemindstillinger eller udføre handlinger, der kræver administrative tilladelser.
- Standardisering: Systemkald giver en standardiseret grænseflade til programmer til at interagere med operativsystemet, hvilket sikrer ensartethed og kompatibilitet på tværs af forskellige hardwareplatforme og operativsystemversioner.
Hvordan fungerer systemopkald?
Her er den detaljerede forklaring trin for trin, hvordan systemopkald fungerer:
- Brugeren har brug for særlige ressourcer: Nogle gange skal programmer gøre nogle specielle ting, som ikke kan gøres uden tilladelse fra OS, som at læse fra en fil, skrive til en fil, få nogen information fra hardwaren eller anmode om en plads i hukommelsen.
- Programmet laver en systemopkaldsanmodning: Der er særlige foruddefinerede instruktioner til at sende en anmodning til operativsystemet. Disse instruktioner er intet andet end blot et systemkald. Programmet bruger disse systemkald i sin kode, når det er nødvendigt.
- Operativsystemet ser systemkaldet: Når operativsystemet ser systemkaldet, erkender det, at programmet har brug for hjælp på dette tidspunkt, så det midlertidigt stopper programudførelsen og giver al kontrol til den særlige del af sig selv kaldet 'Kernel'. Nu løser 'Kernel' behovet for program.
- Operativsystemet udfører handlingerne: Nu udfører operativsystemet den handling, som programmet anmoder om. Eksempel: læsning af indhold fra en fil osv.
- Operativsystem giver kontrol tilbage til programmet: Efter at have udført den specielle operation, giver OS kontrol tilbage til programmet for yderligere udførelse af programmet.
Eksempler på et systemkald i Windows og Unix
Systemkald til Windows og Unix findes i mange forskellige former. Disse er angivet i tabellen nedenfor som følger:
| Behandle | Windows | Unix |
|---|---|---|
| Proces kontrol | CreateProcess() ExitProcess() WaitForSingleObject() | Gaffel() Afslut() Vente() |
| Fil manipulation | CreateFile() ReadFile() WriteFile() | Åben() Læs() Skrive() Tæt() |
| Enhedshåndtering | SetConsoleMode() ReadConsole() WriteConsole() | Ioctl() Læs() Skrive() |
| Informationsvedligeholdelse | GetCurrentProcessID() SetTimer() Søvn() | Getpid() Alarm() Søvn() |
| Meddelelse | CreatePipe() CreateFileMapping() MapViewOfFile() | Rør() Shmget() hvordan man konverterer streng til heltal java Mmap() |
| Beskyttelse | SetFileSecurity() InitializeSecurityDescriptor() SetSecurityDescriptorgroup() | Chmod() afmaske() Chown() |
åben(): Adgang til en fil på et filsystem er muligt med open() systemkaldet. Det giver de filressourcer, den har brug for, og et håndtag, som processen kan bruge. En fil kan åbnes af flere processer samtidigt eller kun én proces. Alt er baseret på strukturen og filsystemet.
Læs(): Data fra en fil på filsystemet hentes ved hjælp af den. Generelt accepterer den tre argumenter:
første bærbare computer
- En beskrivelse af en fil.
- En buffer til lagring af læsedata.
- Hvor mange bytes skal læses fra filen
Før læsning kunne den fil, der skulle læses, identificeres ved dens filbeskrivelse og åbnes ved hjælp af funktionen open().
vente(): I nogle systemer skal en proces muligvis udsætte, indtil en anden proces er færdig med at køre, før den fortsætter. Når en overordnet proces opretter en underordnet proces, standses udførelsen af den overordnede proces, indtil den underordnede proces er afsluttet. Den overordnede proces stoppes ved hjælp af wait()-systemkaldet. Den overordnede proces genvinder kontrollen, når den underordnede proces er færdig med at køre.
skrive(): Data fra en brugerbuffer skrives ved hjælp af den til en enhed som en fil. Et program kan producere data på én måde ved at bruge dette systemopkald . generelt er der tre argumenter:
- En beskrivelse af en fil.
- En reference til bufferen, hvor data er gemt.
- Mængden af data, der vil blive skrevet fra bufferen i bytes.
gaffel(): Fork()-systemkaldet bruges af processer til at skabe kopier af sig selv. Det er en af de metoder, der oftest bruges i operativsystemer til at skabe processer. Når en overordnet proces opretter en underordnet proces, suspenderes den overordnede process udførelse, indtil den underordnede proces er afsluttet. Den overordnede proces genvinder kontrollen, når den underordnede proces er færdig med at køre.
Afslut(): Et systemkald kaldet exit() bruges til at afslutte et program. I miljøer med flere tråde indikerer dette kald, at trådudførelsen er afsluttet. Efter brug af exit()-systemfunktionen gendanner operativsystemet de ressourcer, der bruges af processen.
Metoder til at overføre parametre til OS
Hvis der opstår et systemkald, skal vi sende parameteren til Kernal-delen af operativsystemet.
Se for eksempel på det givne åben() systemkald:
C
//function call example> #include> int> open(>const> char> *pathname,>int> flags, mode_t mode);> |
>
>
Her stinavn , flag og mode_t er parametrene.
Så det skal bemærkes, at:
- Vi kan ikke videregive parametrene direkte som i et almindeligt funktionskald.
- I Kernal-tilstand er der en anden måde at udføre et funktionskald på.
Så vi kan ikke køre det i det normale adresserum, som processen allerede havde oprettet, og derfor kan vi ikke placere parametrene i toppen af stakken, fordi det ikke er tilgængeligt for operativsystemets Kernal til behandling. så vi er nødt til at anvende andre metoder for at overføre parametrene til OS'ets Kernal.
linje autocad kommando
Vi kan klare det igennem,
- Overførsel af parametre i registre
- Adressen på blokken videregives som en parameter i et register.
- Parametre skubbes ind i en stak.
Lad os diskutere hvert punkt i detaljer:
1. Overførsel af parametre i registre.
- Det er den enkleste metode blandt de tre
- Her videregiver vi parametrene direkte til registre.
- Men det vil det er begrænset, når antallet af parametre er større end antallet af registre.
- Her er 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.Blokkens adresse sendes som parametre
- Det kan anvendes, når antallet af parametre er større end antallet af registre.
- Parametre gemmes i blokke eller tabel.
- Blokkens adresse sendes til et register som en parameter.
- Mest almindeligt brugt i Linux og Solaris.
- Her er 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. Parametre skubbes i en stak
- I denne metode kan parametre skubbes ind ved hjælp af programmet og poppes ud ved hjælp af operativsystemet
- Så Kernal kan nemt få adgang til dataene ved at hente information fra toppen af stakken.
- Her er C-programkoden
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;> }> |
>
>
sammenligne i java
Ofte stillede spørgsmål
Q.1: Hvordan fungerer et systemopkald?
Svar:
Når et program udfører et systemkald, skifter det fra brugertilstand til kernetilstand, som er en højere privilegeret tilstand. Overgangen initieres typisk ved at kalde en specifik funktion eller afbryde instruktion fra programmeringssproget eller operativsystemet.
Når det først er i kernetilstand, håndteres systemkaldet af operativsystemet. Kernen udfører den ønskede handling på vegne af programmet og returnerer resultatet. Derefter returneres kontrollen til programmet på brugerniveau, som fortsætter sin udførelse.
Q.2: Hvorfor er systemkald nødvendige?
Svar:
Systemopkald er nødvendige af flere årsager:
Adgang til privilegerede operationer: Mange operationer, såsom administration af hardwareenheder eller ændring af systemkonfigurationer, kræver højere privilegier, som kun er tilgængelige via systemopkald.
Ressourcestyring: Systemkald giver en standardiseret grænseflade til tildeling og styring af systemressourcer som hukommelse, filer og enheder, hvilket sikrer retfærdig og kontrolleret adgang af forskellige processer.
Abstraktion: Systemkald abstraherer den underliggende kompleksitet af operativsystemet, hvilket giver applikationsudviklere mulighed for at interagere med systemet på et højere niveau, platform-uafhængig måde.
Sikkerhed og beskyttelse: Systemopkald håndhæver adgangskontrol og sikkerhedspolitikker, forhindrer uautoriseret adgang til følsomme ressourcer og beskytter systemets integritet.