In dit artikel gaan we echte systeemaanroepen gebruiken om echt werk te doen in ons C-programma. Eerst bekijken we of u een systeemaanroep moet gebruiken en geven we vervolgens een voorbeeld met de aanroep sendfile() die de kopieerprestaties van bestanden drastisch kan verbeteren. Ten slotte zullen we enkele punten bespreken om te onthouden tijdens het gebruik van Linux-systeemaanroepen.
Hoewel het onvermijdelijk is dat je op een bepaald moment in je C-ontwikkelingscarrière een systeemaanroep zult gebruiken, zullen de glibc-bibliotheek en andere basisbibliotheken die zijn opgenomen in grote Linux-distributies, zorgen voor de meerderheid van de je behoeften.
De glibc-standaardbibliotheek biedt een platformonafhankelijk, goed getest raamwerk om functies uit te voeren die anders systeemspecifieke systeemaanroepen zouden vereisen. U kunt bijvoorbeeld een bestand lezen met fscanf(), fread(), getc(), enz., of u kunt de Linux-systeemaanroep read() gebruiken. De glibc-functies bieden meer functies (d.w.z. betere foutafhandeling, geformatteerde IO, enz.) en werken op elk systeem dat glibc ondersteunt.
Aan de andere kant zijn er momenten waarop compromisloze prestaties en exacte uitvoering van cruciaal belang zijn. De wrapper die fread() biedt, gaat overhead toevoegen en is, hoewel klein, niet helemaal transparant. Bovendien wilt of hebt u misschien niet de extra functies die de wrapper biedt. In dat geval ben je het beste geholpen met een systeemoproep.
U kunt ook systeemaanroepen gebruiken om functies uit te voeren die nog niet door glibc worden ondersteund. Als uw exemplaar van glibc up-to-date is, zal dit nauwelijks een probleem zijn, maar ontwikkelen op oudere distributies met nieuwere kernels kan deze techniek vereisen.
Nu je de disclaimers, waarschuwingen en mogelijke omwegen hebt gelezen, gaan we nu in op enkele praktische voorbeelden.
Welke CPU hebben we?
Een vraag die de meeste programma's waarschijnlijk niet denken te stellen, maar toch een geldige. Dit is een voorbeeld van een systeemaanroep die niet kan worden gedupliceerd met glibc en niet is bedekt met een glibc-wrapper. In deze code zullen we de getcpu()-aanroep rechtstreeks aanroepen via de functie syscall(). De syscall-functie werkt als volgt:
syscall(SYS_call,arg1,arg2,...);Het eerste argument, SYS_call, is een definitie die het nummer van de systeemaanroep vertegenwoordigt. Wanneer u sys/syscall.h opneemt, worden deze opgenomen. Het eerste deel is SYS_ en het tweede deel is de naam van de systeemaanroep.
Argumenten voor de oproep gaan naar arg1, arg2 hierboven. Sommige oproepen vereisen meer argumenten en ze gaan in volgorde verder vanaf hun man-pagina. Onthoud dat de meeste argumenten, vooral voor retouren, verwijzingen nodig hebben naar char-arrays of geheugen dat is toegewezen via de malloc-functie.
voorbeeld1.c
#erbij betrekken#erbij betrekken
#erbij betrekken
#erbij betrekken
inthoofd() {
niet ondertekendprocessor,knooppunt;
// Haal de huidige CPU-kern en NUMA-knooppunt op via systeemaanroep
// Merk op dat dit geen glibc-wrapper heeft, dus we moeten het direct aanroepen
syscall(SYS_getcpu, &processor, &knooppunt,NUL);
// Informatie weergeven
printf ('Dit programma draait op CPU-kern %u en NUMA-knooppunt %u.NN',processor,knooppunt);
opbrengst 0;
}
Compileren en uitvoeren:
gcc voorbeeld1.C -o voorbeeld1
./voorbeeld 1
Voor interessantere resultaten kun je threads draaien via de pthreads-bibliotheek en deze functie aanroepen om te zien op welke processor je thread draait.
Verzendbestand: Superieure prestaties
Sendfile is een uitstekend voorbeeld van het verbeteren van de prestaties door middel van systeemaanroepen. De functie sendfile() kopieert gegevens van de ene bestandsdescriptor naar de andere. In plaats van meerdere functies fread() en fwrite() te gebruiken, voert sendfile de overdracht uit in de kernelruimte, waardoor de overhead wordt verminderd en de prestaties worden verhoogd.
In dit voorbeeld gaan we 64 MB aan gegevens van het ene bestand naar het andere kopiëren. In één test gaan we de standaard lees-/schrijfmethoden in de standaardbibliotheek gebruiken. In de andere gebruiken we systeemaanroepen en de aanroep sendfile() om deze gegevens van de ene locatie naar de andere te blazen.
test1.c (glibc)
#erbij betrekken#erbij betrekken
#erbij betrekken
#erbij betrekken
#define BUFFER_SIZE 67108864
#define BUFFER_1 'buffer1'
#define BUFFER_2 'buffer2'
inthoofd() {
HET DOSSIER*fOut, *einde;
printf ('NI/O-test met traditionele glibc-functies.NN');
// Pak een BUFFER_SIZE buffer.
// De buffer zal willekeurige gegevens bevatten, maar dat maakt ons niet uit.
printf (' 64 MB buffer toewijzen: ');
char *buffer= (char *) malloc (BUFFER GROOTTE);
printf ('GEDAANN');
// Schrijf de buffer naar fOut
printf ('Gegevens naar eerste buffer schrijven: ');
fOut= fopen (BUFFER_1, 'wb');
fwrite (buffer, De grootte van(char),BUFFER GROOTTE,fOut);
fsluiten (fOut);
printf ('GEDAANN');
printf ('Gegevens kopiëren van eerste bestand naar tweede: ');
einde= fopen (BUFFER_1, 'rb');
fOut= fopen (BUFFER_2, 'wb');
fread (buffer, De grootte van(char),BUFFER GROOTTE,einde);
fwrite (buffer, De grootte van(char),BUFFER GROOTTE,fOut);
fsluiten (einde);
fsluiten (fOut);
printf ('GEDAANN');
printf ('Buffer vrijmaken:');
vrij (buffer);
printf ('GEDAANN');
printf ('Bestanden verwijderen: ');
verwijderen (BUFFER_1);
verwijderen (BUFFER_2);
printf ('GEDAANN');
opbrengst 0;
}
test2.c (systeemoproepen)
#erbij betrekken#erbij betrekken
#erbij betrekken
#erbij betrekken
#erbij betrekken
#erbij betrekken
#erbij betrekken
#erbij betrekken
#erbij betrekken
#define BUFFER_SIZE 67108864
inthoofd() {
intfOut,einde;
printf ('NI/O-test met sendfile() en gerelateerde systeemaanroepen.NN');
// Pak een BUFFER_SIZE buffer.
// De buffer zal willekeurige gegevens bevatten, maar dat maakt ons niet uit.
printf (' 64 MB buffer toewijzen: ');
char *buffer= (char *) malloc (BUFFER GROOTTE);
printf ('GEDAANN');
// Schrijf de buffer naar fOut
printf ('Gegevens naar eerste buffer schrijven: ');
fOut=open('buffer1',O_RDONLY);
schrijven(fOut, &buffer,BUFFER GROOTTE);
dichtbij(fOut);
printf ('GEDAANN');
printf ('Gegevens kopiëren van eerste bestand naar tweede: ');
einde=open('buffer1',O_RDONLY);
fOut=open('buffer2',O_RDONLY);
verstuur bestand(fOut,einde, 0,BUFFER GROOTTE);
dichtbij(einde);
dichtbij(fOut);
printf ('GEDAANN');
printf ('Buffer vrijmaken:');
vrij (buffer);
printf ('GEDAANN');
printf ('Bestanden verwijderen: ');
ontkoppelen('buffer1');
ontkoppelen('buffer2');
printf ('GEDAANN');
opbrengst 0;
}
Samenstellen en uitvoeren van tests 1 & 2
Om deze voorbeelden te bouwen, hebt u de ontwikkeltools nodig die op uw distributie zijn geïnstalleerd. Op Debian en Ubuntu kunt u dit installeren met:
geschiktinstallerenbouw-essentialsCompileer dan met:
gcctest1.c-oftest1&& gcctest2.c-oftest2Om beide uit te voeren en de prestaties te testen, voert u het volgende uit:
tijd./test1&& tijd./test2U zou de volgende resultaten moeten krijgen:
I/O-test met traditionele glibc-functies.
64 MB buffer toewijzen: KLAARGegevens naar de eerste buffer schrijven: KLAAR
Gegevens kopiëren van het eerste bestand naar het tweede: KLAAR
Buffer vrijmaken: KLAAR
Bestanden verwijderen: KLAAR
echt 0m0.397s
gebruiker 0m0.000s
sys 0m0.203s
I/O-test met sendfile() en gerelateerde systeemaanroepen.
64 MB buffer toewijzen: KLAAR
Gegevens naar de eerste buffer schrijven: KLAAR
Gegevens kopiëren van het eerste bestand naar het tweede: KLAAR
Buffer vrijmaken: KLAAR
Bestanden verwijderen: KLAAR
echte 0m0.019s
gebruiker 0m0.000s
sys 0m0.016s
Zoals u kunt zien, werkt de code die de systeemaanroepen gebruikt veel sneller dan het glibc-equivalent.
Dingen om te onthouden
Systeemoproepen kunnen de prestaties verhogen en extra functionaliteit bieden, maar ze zijn niet zonder nadelen. U moet de voordelen die systeemaanroepen bieden afwegen tegen het gebrek aan platformportabiliteit en soms verminderde functionaliteit in vergelijking met bibliotheekfuncties.
Wanneer u bepaalde systeemaanroepen gebruikt, moet u ervoor zorgen dat u bronnen gebruikt die worden geretourneerd door systeemaanroepen in plaats van bibliotheekfuncties. De FILE-structuur die wordt gebruikt voor de functies fopen(), fread(), fwrite() en fclose() van glibc is bijvoorbeeld niet hetzelfde als het bestandsdescriptornummer van de systeemaanroep open() (geretourneerd als een geheel getal). Het mengen hiervan kan tot problemen leiden.
Over het algemeen hebben Linux-systeemaanroepen minder bumperlanes dan glibc-functies. Hoewel het waar is dat systeemaanroepen enige foutafhandeling en rapportage hebben, krijgt u meer gedetailleerde functionaliteit van een glibc-functie.
En tot slot een woord over veiligheid. Systeemaanroepen hebben een directe interface met de kernel. De Linux-kernel heeft uitgebreide bescherming tegen shenanigans van gebruikersland, maar er bestaan onontdekte bugs. Vertrouw er niet op dat een systeemaanroep uw invoer valideert of u isoleert van beveiligingsproblemen. Het is verstandig om ervoor te zorgen dat de gegevens die u aan een systeemoproep overhandigt, worden opgeschoond. Dit is natuurlijk een goed advies voor elke API-aanroep, maar je kunt niet voorzichtig zijn als je met de kernel werkt.
Ik hoop dat je genoten hebt van deze diepere duik in het land van Linux-systeemaanroepen. Zie onze hoofdlijst voor een volledige lijst met Linux-systeemaanroepen.