Linux Kernel API

Vi vil gå gjennom Linux -applikasjonsprogrammeringsgrensesnittet, API. Linux -kjernen gir systemanropene som kan brukes til å få oppgaven gjort gjennom kjerne. La oss diskutere de få, mye brukte systemanropene til Linux.

Beskrivelse:

Linux -kjernen gir settet eller listen over funksjoner som kan brukes av brukerens romprogrammer for å bruke Linux -kjernetjenestene.

Blokkdiagrammet ser ut som følgende:

Noen av de få mye brukte systemanropene er åpne, lukker, leser og skriver. Dette er grunnleggende systemanrop levert av Linux -kjernen. Hver oppgave gjøres gjennom fil i Linux. Så de grunnleggende operasjonene på en hvilken som helst fil kan gjøres gjennom åpne, lukke, lese og skrive.

La oss ta et reelt eksempel der vi ønsker å trykke "Hello World" på seriekonsoll. For å oppnå denne oppgaven gjennom systemanrop, må vi åpne enhetsfilen for konsoll i /Dev. Når vi har funnet enhetsfilen for konsoll eller UART, kan vi bruke det åpne systemanropet til å åpne enheten.

Her er syntaksen til det åpne systemanropet:

int åpen (const char *pathname, int flagg);
int åpen (const char *pathname, int flags, mode_t mode);

Fra denne syntaksen er det første argumentet filstien vi vil åpne. I vårt tilfelle er det enhetsfilen vi fant som en konsollenhet. I neste argument gir flaggene brukeren en viss fleksibilitet til å spille med filen. Få eksempel på flaggene er O_Creat, O_Append, etc. Disse flaggene har spesifikke betydninger og formål, og diskusjonen er utenfor omfanget av denne diskusjonen. For mer informasjon om flaggene og parametrene, vennligst se Kernelmannssidene.

Når filen er åpen vellykket, må vi bruke skrivesystemanropet for å sende "Hello World" til konsollenheten. Prototypen til skrivesystemanropet er som følger:

ssize_t skriv (int fd, const void *buf, size_t count);

Den første parameteren for skrivesystemanropet er FD som er filbeskriveren. "FD" blir gitt oss av det åpne systemanropet. Etter å ha åpnet filen med hell, bør vi få filbeskrivelsen. Denne FD brukes videre til å skrive dataene.

Den andre parameteren er bufferadressen for dataene som skal sendes til konsollenheten. I vårt tilfelle er testdataene “Hello World”.

Den siste parameteren er det totale antallet byte som brukeren ønsker å skrive til konsollenheten. I vårt tilfelle er antallet byte størrelsen på "Hello World". Vi kan enten bruke størrelsen på operatøren eller Strlen -funksjonen for å få antall byte. Vi skal være forsiktige mens vi bruker strlen. Denne funksjonen ignorerer strengterminator -tegnet som “\ 0”. Så mens vi leser strengen, må vi sørge for at nullkarakteren blir håndtert ordentlig. Ellers vil vi ende opp med segmenteringsfeilen.

La oss nå implementere kodedelen av dette eksemplet. Først må vi lokalisere seriekonsollen eller UART -enheten. I maskinen har det vi bruker den serielle tty -enheten som/dev/pts/0. Så som diskutert, må vi først åpne denne filen. Vi må også inkludere den hardere filen som gir erklæringen om åpent systemanrop.

Koden vår for å åpne enhetsfilen ser ut som følgende:

#inkludere
fd = åpen (“/dev/pts/0”, o_wronly);

Neste, når vi vil ringe skrivesystemanropet, bruker vi FD som er gitt av Open. Vår oppfordring til å skrive funksjon ser ut som følgende:

#inkludere
char *data = “hei verden”;
skriv (FD, data, strlen (data) +1);

Det forrige kodebiten skriver "Hello World" til seriekonsollen som vi fant og vil skrive.

La oss sette sammen alle brikkene:

#inkludere
#inkludere
#inkludere
#inkludere
#inkludere
int main ()

int fd; int rc;
char *data = “hei verden”;
fd = åpen (“/dev/pts/0”, o_wronly);
if (fd<0)

printf (“Feilåpningsfil:%d”, FD);
Avslutt (-1);

RC = skriv (FD, data, strlen (data) +1);
if (rc<0)

printf (“Feilskrivingsfil:%d”, RC);
Avslutt (-1);

Lukk (FD); // Filoperasjon er utført, lukk filen.
retur 0;

Å sammenstille det forrige programmet er det samme som å sammenstille de andre C -programmene som følgende:

GCC TEST_WRITE.c -o test_write.

Test_write.C er filnavnet til C -koden vår.

Etter samlingen får vi den kjørbare med test_skrivnavnet.

Se følgende øyeblikksbilde:

Etter å ha kjørt den kompilerte og genererte binære, har vi følgende utgang.

Programutgangen vår er fremhevet med fet skrift. Følgende er øyeblikksbildet for referanse:

Så langt har vi sett et eksempel der vi bruker Linux API for å vise teststrengen på konsollen. Dette er det enkle eksemplet. Det er mange andre tilbud som leveres av systemanropet. Få av systemanropene som er gitt av Linux er som følger:

• lese: Lesing fra filen.
• skrive: Skrive til filen.
• åpen: Åpne filen.
• Lukk: Lukke filen.
• avstemming: Polling enheten for endring i tilstand.
• Lseek: Søker en bestemt forskyvning i filen.
• MMAP: Kartlegge det virtuelle minnet til det fysiske minnet.
• brk: Endre segmentstørrelse.
• IOCTL: Kontrollenheter.
• adgang: Tilgang for å få tillatelsene til filen.
• rør: Refererer til røropprettelsen.

og mange flere.

Dette er den enorme listen over funksjoner levert av Linux -kjernen. Vi har sett og diskutert veldig få. Se kjernekilden for den komplette listen over systemanrop som er gitt av kjernen.

Konklusjon

Vi diskuterte om systemanropene som er en måte å be kjernen om å utføre oppgavene for brukerens romprogrammer. Uten systemanropet, vil det ikke være mulig for brukerens romprogrammer å få oppgaven gjort av kjernen. Vi tok en enkel oppgave eller eksempel på å skrive testdataene, “Hello World”, til seriell enhet. Vi ansatte de åpne, skrive og lukke API -ene i kjernen for å fullføre oppgaven i hånden. En viktigste ting er å sjekke systemet. Kernel gir riktige avkastningsverdier for å forklare årsaken i tilfelle funksjon av funksjon. Brukeren kan få ideen om feilårsaken ved å se returverdiene fra systemanropet. Returverdier har en viss spesifikk mening og er godt tatt i bruk i kjernedokumentasjonen.