Eerste dingen eerst

Voordat we ingaan op de definitie van een Linux-systeemaanroep en de details van de uitvoering ervan onderzoeken, is het het beste om te beginnen met het definiëren van de verschillende softwarelagen van een typisch Linux-systeem.

De Linux-kernel is een gespecialiseerd programma dat opstart en draait op het laagst beschikbare niveau op uw hardware. Het heeft de taak om alles wat op de computer draait te orkestreren, inclusief het verwerken van toetsenbord-, schijf- en netwerkgebeurtenissen om tijdsegmenten te bieden voor het parallel uitvoeren van meerdere programma's.

Wanneer de kernel een programma op gebruikersniveau uitvoert, virtualiseert het de geheugenruimte zodat programma's denken dat dit het enige proces is dat in het geheugen wordt uitgevoerd. Deze beschermende bubbel van hardware- en software-isolatie verhoogt de veiligheid en betrouwbaarheid. Een niet-bevoorrechte toepassing heeft geen toegang tot geheugen van andere programma's, en als dat programma crasht, wordt de kernel beëindigd zodat het de rest van het systeem niet kan schaden.

De barrière doorbreken met Linux-systeemoproepen

Deze isolatielaag tussen niet-bevoorrechte applicaties biedt een uitstekende grens om andere applicaties en gebruikers op het systeem te beschermen. Zonder een manier om te communiceren met de andere elementen in de computer en de buitenwereld, zouden programma's echter niet veel kunnen bereiken.

Om interactie te vergemakkelijken, wijst de kernel een softwarepoort aan waarmee het draaiende programma kan verzoeken dat de kernel namens hem handelt. Deze interface staat bekend als een systeemaanroep.

Omdat Linux de UNIX-filosofie van "alles is een bestand" volgt, kunnen veel functies worden uitgevoerd door een bestand te openen en te lezen of te schrijven, wat een apparaat kan zijn. In Windows kunt u bijvoorbeeld een functie gebruiken met de naam CryptGenRandom om toegang te krijgen tot willekeurige bytes. Maar op Linux kan dit worden gedaan door simpelweg het "bestand" /dev/urandom te openen en er bytes van te lezen met behulp van standaard bestandsinvoer / uitvoersysteemaanroepen. Dit cruciale verschil zorgt voor een eenvoudigere systeemoproepinterface.

Wafeldunne wikkel

In de meeste toepassingen worden systeemaanroepen niet rechtstreeks naar de kernel gedaan. Vrijwel alle programma's linken in de standaard C-bibliotheek, die een dunne maar belangrijke wrapper rond Linux-systeemaanroepen biedt. De bibliotheek zorgt ervoor dat de functieargumenten naar de juiste processorregisters worden gekopieerd en geeft vervolgens de bijbehorende Linux-systeemaanroep. Wanneer gegevens van de oproep worden ontvangen, interpreteert de wrapper de resultaten en stuurt deze op een consistente manier terug naar het programma.

Achter de schermen

Elke functie in een programma die interageert met het systeem wordt uiteindelijk vertaald in een systeemaanroep. Laten we beginnen met een eenvoudig voorbeeld om dit in actie te zien.

ongeldig hoofd()

Dit is waarschijnlijk het meest triviale C-programma dat je ooit zult zien. Het krijgt eenvoudig controle via het hoofdingangspunt en verlaat vervolgens. Het retourneert niet eens een waarde, omdat main is gedefinieerd als void. Sla het bestand op als ctest.c en laten we het compileren:

gcc ctest.c -o ctest

Zodra het is gecompileerd, kunnen we de bestandsgrootte zien als 8664 bytes. Het kan enigszins variëren op uw systeem, maar het zou ongeveer 8k . moeten zijn. Dat is veel code om in en uit te gaan! De reden dat het 8k is, is dat de libc-runtime wordt opgenomen. Zelfs als we de symbolen strippen, is het nog steeds iets meer dan 6k.

In een nog eenvoudiger voorbeeld kunnen we de Linux-systeemaanroep doen om af te sluiten in plaats van afhankelijk te zijn van de C-runtime om dat voor ons te doen.

ongeldig _start()
asm("movl $1,%eax;"
"xorl %ebx,%ebx;"
"int $ 0x80");

Hier verplaatsen we 1 naar het EAX-register, wissen het EBX-register (dat anders de retourwaarde zou bevatten) en noemen vervolgens de Linux-systeemaanroep interrupt 0x80 (of 128 in decimaal). Deze interrupt activeert de kernel om onze oproep te verwerken.

Als we ons nieuwe voorbeeld compileren, genaamd asmtest.c, en verwijder de symbolen en sluit de standaardbibliotheek uit:

gcc -s -nostdlib asmtest.c -o asmtest

we produceren een binair getal van minder dan 1k (op mijn systeem levert het 984 bytes op). Het grootste deel van deze code bestaat uit uitvoerbare headers. We noemen nu de directe Linux-systeemaanroep.

Voor alle praktische doeleinden

In bijna alle gevallen hoeft u nooit rechtstreekse systeemaanroepen te doen in uw C-programma's. Als u echter assembleertaal gebruikt, kan de behoefte zich voordoen. Bij optimalisatie is het echter het beste om de C-bibliotheekfuncties de systeemaanroepen te laten doen en alleen uw prestatiekritieke code te laten insluiten in de montagerichtlijnen.

Zelfstudies voor systeemoproepen programmeren

• Exec systeemoproep
• Fork systeemoproep
• Stat systeemoproep

Lijst met alle systeemoproepen

Als je een lijst wilt zien van alle beschikbare systeemaanroepen voor Linux, kun je deze referentiepagina's raadplegen: Volledige lijst met systeemaanroepen op LinuxHint.com, Filippo.io/linux-syscall-table/ en of syscalls.kernelgrok.com