I denne artikkelen skal vi bruke faktiske systemanrop til å utføre reelt arbeid i vårt C -program. Først ser vi på om du trenger å bruke et systemanrop, og gir deretter et eksempel ved å bruke sendfile () -anropet som kan forbedre ytelsen til filkopiering dramatisk. Til slutt vil vi gå over noen punkter å huske mens du bruker Linux -systemanrop.
Selv om det er uunngåelig, vil du bruke et systemanrop på et tidspunkt i din C -utviklingskarriere, med mindre du er rettet mot høy ytelse eller en bestemt type funksjonalitet, vil glibc -biblioteket og andre grunnleggende biblioteker som er inkludert i store Linux -distribusjoner ta seg av flertallet av dine behov.
Glibc standardbibliotek gir et godt testet rammeverk på tvers av plattformer for å utføre funksjoner som ellers ville kreve systemspesifikke systemanrop. For eksempel kan du lese en fil med fscanf (), fread (), getc (), etc., eller du kan bruke read () Linux -systemanropet. Glibc -funksjonene gir flere funksjoner (dvs. bedre feilhåndtering, formatert IO, etc.) og fungerer på alle systemglibc -støtter.
På den annen side er det tider hvor kompromissløs ytelse og eksakt utførelse er kritisk. Emballasjen som fread () gir kommer til å legge til overhead, og selv om den er mindre, er den ikke helt gjennomsiktig. I tillegg er det ikke sikkert du vil eller trenger ekstrafunksjonene som emballasjen gir. I så fall er du best tjent med et systemanrop.
Du kan også bruke systemanrop til å utføre funksjoner som ennå ikke er støttet av glibc. Hvis din kopi av glibc er oppdatert, vil dette neppe være et problem, men utvikling av eldre distribusjoner med nyere kjerner kan kreve denne teknikken.
Nå som du har lest ansvarsfraskrivelsene, advarslene og potensielle omkjøringene, la oss nå grave i noen praktiske eksempler.
Hvilken CPU er vi på?
Et spørsmål som de fleste programmer sannsynligvis ikke tenker å stille, men likevel et gyldig spørsmål. Dette er et eksempel på et systemanrop som ikke kan dupliseres med glibc og ikke er dekket med en glibc -innpakning. I denne koden ringer vi getcpu () -samtalen direkte via syscall () -funksjonen. Syscall -funksjonen fungerer som følger:
syscall(SYS_call,arg1,arg2,...);Det første argumentet, SYS_call, er en definisjon som representerer nummeret på systemanropet. Når du inkluderer sys/syscall.h, er disse inkludert. Den første delen er SYS_ og den andre delen er navnet på systemanropet.
Argumenter for samtalen går inn i arg1, arg2 ovenfor. Noen samtaler krever flere argumenter, og de fortsetter i rekkefølge fra mannssiden. Husk at de fleste argumenter, spesielt for returer, vil kreve pekepunkter til char -matriser eller minne som er tilordnet via malloc -funksjonen.
eksempel1.c
#inkludere#inkludere
#inkludere
#inkludere
inthoved-() {
usignertprosessor,node;
// Få nåværende CPU -kjerne og NUMA -node via systemanrop
// Merk at dette ikke har noen glibc -innpakning, så vi må kalle det direkte
syscall(SYS_getcpu, &prosessor, &node,NULL);
// Vis informasjon
printf ('Dette programmet kjører på CPU -kjernen %u og NUMA -noden %u. n n',prosessor,node);
komme tilbake 0;
}
Å kompilere og kjøre:
gcc eksempel 1.c -o eksempel 1
./eksempel 1
For mer interessante resultater kan du spinne tråder via pthreads -biblioteket og deretter ringe denne funksjonen for å se på hvilken prosessor tråden din kjører.
Sendfil: Overlegen ytelse
Sendfile gir et utmerket eksempel på å forbedre ytelsen gjennom systemanrop. Sendfile () -funksjonen kopierer data fra en filbeskrivelse til en annen. I stedet for å bruke flere fread () og fwrite () funksjoner, utfører sendfile overføringen i kjerneområdet, reduserer overhead og øker dermed ytelsen.
I dette eksemplet skal vi kopiere 64 MB data fra en fil til en annen. I en test skal vi bruke standard lese/skrive -metoder i standardbiblioteket. I den andre bruker vi systemanrop og sendfile () -anropet for å sprenge disse dataene fra ett sted til et annet.
test1.c (glibc)
#inkludere#inkludere
#inkludere
#inkludere
#define BUFFER_SIZE 67108864
#define BUFFER_1 'buffer1'
#define BUFFER_2 'buffer2'
inthoved-() {
FIL*feil, *slutt;
printf (' nI/O -test med tradisjonelle glibc -funksjoner. n n');
// Ta en BUFFER_SIZE -buffer.
// Bufferen vil ha tilfeldige data i den, men vi bryr oss ikke om det.
printf ('Tildeler 64 MB buffer:');
røye *buffer= (røye *) malloc (BUFFER STØRRELSE);
printf ('UTFØRT n');
// Skriv bufferen til fOut
printf ('Skrive data til første buffer:');
feil= fopen (BUFFER_1, 'wb');
fwrite (buffer, størrelsen av(røye),BUFFER STØRRELSE,feil);
fclose (feil);
printf ('UTFØRT n');
printf ('Kopiere data fra første fil til andre:');
slutt= fopen (BUFFER_1, 'rb');
feil= fopen (BUFFER_2, 'wb');
fread (buffer, størrelsen av(røye),BUFFER STØRRELSE,slutt);
fwrite (buffer, størrelsen av(røye),BUFFER STØRRELSE,feil);
fclose (slutt);
fclose (feil);
printf ('UTFØRT n');
printf ('Frigjøringsbuffer:');
gratis (buffer);
printf ('UTFØRT n');
printf ('Sletter filer:');
ta bort (BUFFER_1);
ta bort (BUFFER_2);
printf ('UTFØRT n');
komme tilbake 0;
}
test2.c (systemanrop)
#inkludere#inkludere
#inkludere
#inkludere
#inkludere
#inkludere
#inkludere
#inkludere
#inkludere
#define BUFFER_SIZE 67108864
inthoved-() {
intfeil,slutt;
printf (' nI/O -test med sendfile () og relaterte systemanrop. n n');
// Ta en BUFFER_SIZE -buffer.
// Bufferen vil ha tilfeldige data i den, men vi bryr oss ikke om det.
printf ('Tildeler 64 MB buffer:');
røye *buffer= (røye *) malloc (BUFFER STØRRELSE);
printf ('UTFØRT n');
// Skriv bufferen til fOut
printf ('Skrive data til første buffer:');
feil=åpen('buffer1',O_RDONLY);
skrive(feil, &buffer,BUFFER STØRRELSE);
Lukk(feil);
printf ('UTFØRT n');
printf ('Kopiere data fra første fil til andre:');
slutt=åpen('buffer1',O_RDONLY);
feil=åpen('buffer2',O_RDONLY);
Send fil(feil,slutt, 0,BUFFER STØRRELSE);
Lukk(slutt);
Lukk(feil);
printf ('UTFØRT n');
printf ('Frigjøringsbuffer:');
gratis (buffer);
printf ('UTFØRT n');
printf ('Sletter filer:');
koble fra('buffer1');
koble fra('buffer2');
printf ('UTFØRT n');
komme tilbake 0;
}
Kompilering og kjøring av tester 1 og 2
For å bygge disse eksemplene trenger du utviklingsverktøyene installert i distribusjonen din. På Debian og Ubuntu kan du installere dette med:
passendeinstallerebygge-nødvendigheterKompiler deretter med:
gcctest1.c-ellertest1&& gcctest2.c-ellertest2For å kjøre begge og teste ytelsen, kjør:
tid./test1&& tid./test2Du bør få resultater som dette:
I/O -test med tradisjonelle glibc -funksjoner.
Tildel 64 MB buffer: UTFØRTSkrive data til første buffer: DONE
Kopiering av data fra første fil til andre: DONE
Frigjøringsbuffer: UTFØRT
Sletter filer: DONE
ekte 0m0.397s
bruker 0m0.000s
sys 0m0.203s
I/O -test med sendfile () og relaterte systemanrop.
Tildel 64 MB buffer: UTFØRT
Skrive data til første buffer: DONE
Kopiering av data fra første fil til andre: DONE
Frigjøringsbuffer: UTFØRT
Sletter filer: DONE
ekte 0m0.019s
bruker 0m0.000s
sys 0m0.016s
Som du kan se, kjører koden som bruker systemanropene mye raskere enn glibc -ekvivalenten.
Ting å huske
Systemanrop kan øke ytelsen og gi tilleggsfunksjonalitet, men de er ikke uten sine ulemper. Du må veie fordelene systemsamtaler gir mot mangelen på plattformportabilitet og noen ganger redusert funksjonalitet sammenlignet med bibliotekfunksjoner.
Når du bruker noen systemanrop, må du passe på å bruke ressurser som returneres fra systemanrop i stedet for bibliotekfunksjoner. For eksempel er FILE -strukturen som brukes for glibcs funksjoner fopen (), fread (), fwrite () og fclose () ikke det samme som filbeskrivelsesnummeret fra det åpne () systemanropet (returnert som et heltall). Å blande disse kan føre til problemer.
Generelt har Linux -systemanrop færre støtfangerbaner enn glibc -funksjoner. Selv om det er sant at systemanrop har litt feilhåndtering og rapportering, får du mer detaljert funksjonalitet fra en glibc -funksjon.
Og til slutt, et ord om sikkerhet. Systemanrop grensesnitt direkte med kjernen. Linux -kjernen har omfattende beskyttelse mot shenanigans fra brukerland, men det finnes uoppdagede feil. Ikke stol på at et systemanrop vil validere innspillet ditt eller isolere deg fra sikkerhetsproblemer. Det er lurt å sikre at dataene du overleverer til et systemanrop blir desinfisert. Selvfølgelig er dette et godt råd for alle API -anrop, men du kan ikke være forsiktig når du arbeider med kjernen.
Jeg håper du likte dette dypere dykket inn i Linux -systemsamtalene. For en fullstendig liste over Linux System Calls, se vår hovedliste.