Wat is POSIX (draagbare besturingssysteeminterface)?

POSIX is een reeks standaarden die definieert hoe besturingssystemen zich op fundamenteel niveau zouden moeten gedragen.

Wat wordt er bedoeld met POSIX?

POSIX (Portable Operating System Interface) is een reeks IEEE-standaarden (Institute of Electrical and Electronics Engineers) die een gemeenschappelijke interface voor besturingssystemen specificeren , zodat software eenmaal geschreven kan worden en met minimale aanpassingen op meerdere compatibele systemen kan worden uitgevoerd.

Het definieert het gedrag en de kenmerken van belangrijke API's die door applicaties worden gebruikt , met name de C- bibliotheek en de onderliggende systeemoproepen. Het omvat kerngebieden zoals processen en signalen, bestands- en mapbewerkingen, machtigingen, primitieven voor interprocescommunicatie, tijdfuncties en basisthreading. POSIX standaardiseert ook een set commandoregelprogramma 's en een shellomgeving, waardoor veel scripts uitgaan van een POSIX-achtige /bin/sh en een voorspelbaar gedragspatroon van de tools.

In de praktijk fungeert POSIX als een compatibiliteitscontract tussen applicaties en het besturingssysteem: als een besturingssysteem en de bijbehorende standaardbibliotheken voldoen aan de POSIX-specificaties, kunnen ontwikkelaars vertrouwen op consistente semantiek voor zaken als bestandsdescriptors, pipes, exitstatussen en foutcodes, waardoor de portabiliteit over UNIX- en Unix-achtige platformen (en over verschillende leveranciers en distributies) wordt verbeterd.

Wat is de geschiedenis van POSIX?

POSIX is ontstaan uit de portabiliteitsproblemen van het vroege UNIX-tijdperk, toen verschillende leveranciers Unix-varianten uitbrachten die zich weliswaar vergelijkbaar, maar niet identiek gedroegen. Halverwege de jaren tachtig startte IEEE een formeel standaardiseringsproject (het "P1003"-project) om een consistente, leveranciersneutrale interface te definiëren voor een "draagbaar besturingssysteem", grotendeels gebaseerd op gangbare UNIX-praktijken. De naam "POSIX" zelf werd voorgesteld door Richard Stallman, oprichter van het GNU -project, als een korte, gemakkelijk uit te spreken benaming voor de Portable Operating System Interface.

De eerste kernstandaard werd gepubliceerd als IEEE Std 1003.1-1988, met de focus op fundamentele besturingssysteemservices en C/POSIX-systeeminterfaces (processen, bestanden/directory's, signalen, pijpen en aanverwante basisprincipes). Deze werd later afgestemd op ISO/IEC als de 9945-serie (bijvoorbeeld ISO/IEC 9945-1:1990).

Van daaruit breidde POSIX zich uit en evolueerde door middel van herzieningen en gerelateerde specificaties. Een belangrijk keerpunt kwam in 1998 met de oprichting van de Austin Group, een gezamenlijk initiatief van IEEE, The Open Group en ISO/IEC om een enkele, geharmoniseerde set "basisspecificaties" te ontwikkelen. Dat werk leidde tot POSIX.1-2001 (technisch afgestemd op de Single UNIX Specification, versie 3), die begin 2002 werd uitgebracht, met latere belangrijke herzieningen zoals POSIX.1-2008 die de standaard bleven bijwerken en verduidelijken.

POSIX-voorbeelden

POSIX komt het duidelijkst tot uiting in de gemeenschappelijke "bouwstenen" die UNIX-achtige systemen delen. Daarom draaien dezelfde code en shellscripts vaak met weinig of geen aanpassingen op Linux , BSD en macOS.

Veelvoorkomende POSIX-voorbeelden zijn onder andere:

Bestands- en procesinterfaces, zoals open(), read(), write() en close() voor bestandstoegang, en fork() / execve() voor het starten van nieuwe programma's.
Bestandsbeschrijvingen en pijpen, waarmee programma's gegevens aan elkaar kunnen doorgeven met behulp van aanroepen zoals pipe() en dup2().
Signalen, zoals SIGINT en SIGTERM, die programma's op een standaard manier afhandelen met behulp van sigaction().
Discussies, beschikbaar gesteld via de POSIX threads (pthreads) API's, inclusief functies zoals pthread_create() en pthread_mutex_lock().
POSIX-compatibele shellscripts, geschreven voor /bin/sh en gebruikmakend van draagbare hulpprogramma's zoals sh, grep, sed, awk, find en tar, die consistent werken op verschillende systemen.

Deze standaardisatie zorgt ervoor dat op POSIX gebaseerde software overdraagbaar is naar verschillende UNIX-achtige platforms.

Waarvoor wordt POSIX gebruikt?

POSIX wordt gebruikt om software draagbaar en voorspelbaar te maken op UNIX- en UNIX-achtige besturingssystemen door de interfaces waarop programma's vertrouwen te standaardiseren. Ontwikkelaars gebruiken het als een basiscontract voor het kerngedrag van het besturingssysteem, inclusief hoe processen worden aangemaakt en beheerd, hoe bestanden en mappen worden benaderd, hoe machtigingen werken, hoe signalen en tijdfuncties zich gedragen en hoe primitieven voor interprocescommunicatie zoals pijpen werken.

Op deze manier kan dezelfde applicatiecode met minimale aanpassingen op verschillende systemen worden gecompileerd en uitgevoerd. Het wordt ook gebruikt als een doelwit voor portabiliteit van shellscripts en commandoregeltools, aangezien POSIX een gemeenschappelijke shellomgeving en gestandaardiseerd hulpprogrammagedrag definieert, waardoor de verschillen tussen distributies en leveranciers wat betreft "werkt op mijn machine" worden verkleind.

Welke besturingssystemen ondersteunen POSIX?

De meeste moderne UNIX- en UNIX-achtige besturingssystemen ondersteunen POSIX tot op zekere hoogte, hetzij volledig, hetzij met goed gedocumenteerde uitbreidingen en hiaten.

Native UNIX-systemen zoals Linux, FreeBSD, OpenBSD, NetBSD en macOS zijn allemaal gebouwd rond POSIX-concepten en bieden brede POSIX-compatibiliteit in hun kernels , C-bibliotheken, shells en kernprogramma's. Deze systemen zijn de belangrijkste reden waarom POSIX relevant blijft, omdat ze ervoor zorgen dat dezelfde applicaties en scripts met minimale aanpassingen op verschillende leveranciers en distributies kunnen draaien.

Sommige niet-UNIX-systemen ondersteunen POSIX gedeeltelijk of via compatibiliteitslagen. IBM AIX, HP-UX en Solaris waren bijvoorbeeld in het verleden gecertificeerd volgens POSIX en de Single UNIX Specification.

Windows is niet van nature POSIX-ondersteund, maar biedt wel beperkte POSIX-ondersteuning via omgevingen zoals het Windows Subsystem for Linux (WSL) of compatibiliteitslagen zoals Cygwin, die POSIX API's bovenop de Windows-kernel aanbieden.

POSIX-conformiteitsniveaus

POSIX-conformiteit is niet iets wat je met één druk op de knop kunt bereiken. Systemen claimen doorgaans conformiteit met een specifieke POSIX-editie (bijvoorbeeld POSIX.1) en claimen vervolgens optioneel aanvullende functionaliteitsgroepen. Sommige leveranciers gaan nog een stap verder en behalen een formele certificering. De niveaus van POSIX-conformiteit zijn:

POSIX-basisconformiteit (POSIX.1 / IEEE 1003.1)Het besturingssysteem biedt de vereiste POSIX-interfaces en -gedragingen zoals gedefinieerd in de basisstandaard, inclusief de kernsemantiek voor processen, bestanden en systeemoproepen, plus het basisgedrag van de shell en hulpprogramma's dat aan die editie van de specificatie is gekoppeld.
POSIX-conformiteit met optiegroepenNaast de basisfunctionaliteit definieert POSIX optionele functionaliteiten (optiegroepen). Een systeem kan "POSIX-conform" zijn en daarnaast opties claimen die het ondersteunt (bijvoorbeeld extra hulpprogramma's of aanvullende API-semantiek).
SUS/Single UNIX Specification (XSI + POSIX-basis). De Single UNIX Specification is een superset die extra interfaces en semantiek vereist bovenop de POSIX-basis, met name de XSI-optie (X/Open System Interfaces) die optioneel is in POSIX, maar vereist is voor UNIX-branding onder SUS.
POSIX-gecertificeerd (formeel certificeringsprogramma)Los van "claims" kunnen producten formeel gecertificeerd worden onder het "POSIX™: Certified by IEEE and The Open Group"-programma, een vastgesteld proces voor het registreren en valideren van conformiteitsclaims.
UNIX®-gecertificeerd (merknaamniveau)Systemen die volledig voldoen aan en gecertificeerd zijn volgens de Single UNIX Specification mogen het UNIX®-handelsmerk gebruiken. Dit is een sterker, door een handelsmerk ondersteund nalevingsniveau dan ondersteuning die lijkt op POSIX.

POSIX-normen

POSIX is geen enkel document, maar een verzameling verwante standaarden. Oudere POSIX-documenten werden gepubliceerd als afzonderlijke onderdelen (API's versus shell/tools), terwijl moderne POSIX wordt beheerd als één geconsolideerde specificatie die periodiek wordt herzien. De standaarden omvatten:

POSIX.1 (IEEE Std 1003.1)De kernstandaard die de fundamentele API's en gedragingen van het besturingssysteem definieert die door applicaties worden gebruikt (bijvoorbeeld processen en bestanden). I / O semantiek) als de basislijn voor de "draagbare OS-interface".
POSIX.2 (IEEE Std 1003.2). De standaard voor de opdrachtinterpreter (shell) en gewoon utilities, zodat scripts kunnen vertrouwen op consistente shelltaal en toolgedrag op compatibele systemen.
POSIX.1b (IEEE Std 1003.1b). Realtime-extensies die gestandaardiseerde interfaces en semantiek toevoegen die nodig zijn voor realtime-toepassingen (bijvoorbeeld realtime-signalen, klokken/timers, gedeeld geheugen, semaforen).
POSIX.1c (IEEE Std 1003.1c)Threading-extensies die het POSIX-threadmodel (pthreads) standaardiseerden, zodat multithreaded programma's over verschillende systemen heen kunnen worden gebruikt.
Geünificeerde POSIX.1-revisies (tijdperk van de Austin Group)Latere herzieningen consolideren wat voorheen afzonderlijke onderdelen waren tot één set "Basisspecificaties" (vaak gepresenteerd als delen zoals Basisdefinities, Systeeminterfaces en Shell & Hulpprogramma's) en werken deze in de loop der tijd bij, bijvoorbeeld: POSIX.1-2008, POSIX.1-2017, En de nieuwste POSIX.1-2024 (IEEE Std 1003.1-2024).

Voordelen en beperkingen van POSIX

POSIX brengt consistentie in UNIX-achtige systemen door een gemeenschappelijke set besturingssysteeminterfaces en toolgedragingen te definiëren. Inzicht in de voordelen en beperkingen ervan helpt te verduidelijken wanneer het gebruik van POSIX de portabiliteit en onderhoudbaarheid verbetert, en wanneer platformspecifieke functies of uitbreidingen nodig zijn om aan uw eisen te voldoen.

POSIX-voordelen

POSIX is vooral waardevol omdat het het verwachte gedrag van het besturingssysteem standaardiseert, waarop veel applicaties en scripts afhankelijk zijn. Dit vermindert platformspecifieke herschrijvingen en onverwachte problemen. De voordelen zijn onder andere:

Overdraagbaarheid tussen UNIX-achtige systemenCode geschreven volgens de POSIX API's (bestanden, processen, signalen, enz.) zal waarschijnlijk gemakkelijker compileren en draaien op verschillende besturingssystemen met minimale aanpassingen.
Voorspelbaar systeemgedragGestandaardiseerde semantiek voor zaken als bestandsdescriptors, exitstatussen, machtigingen en foutafhandeling zorgt ervoor dat programma's zich consistenter gedragen in verschillende omgevingen.
Script en tool interoperabiliteit. Een POSIX-shell en standaard hulpprogramma's maken draagbare shellscripts en betrouwbare commando-pipelines mogelijk voor verschillende distributies en leveranciers.
Eenvoudiger onderhoud en inbedrijfstelling. Een gemeenschappelijke basislijn vermindert het aantal voorwaardelijke codefragmenten en "speciale gevallen", waardoor projecten eenvoudiger te onderhouden zijn en gemakkelijker te begrijpen voor nieuwe bijdragers.
Bredere compatibiliteit met ecosystemen. Veel runtime-omgevingen, build-systemen en open source De tools gaan uit van POSIX-achtig gedrag, dus POSIX-ondersteuning verbetert de compatibiliteit met bestaande software.
Verkoper neutraliteitPOSIX biedt een stabiel doel dat voorkomt dat software vast komt te zitten aan de eigen interfaces van één enkele besturingssysteemleverancier.

POSIX-beperkingen

POSIX is een nuttige basis, maar het dekt niet alles wat moderne systemen bieden, en de naleving ervan in de praktijk kan variëren. De beperkingen zijn onder andere:

Geen complete set OS-functies. POSIX richt zich op de kern-API's en -tools, waardoor veel praktische behoeften (geavanceerde netwerkfuncties, moderne beveiligingsframeworks, containerprimitieven, enz.) vaak niet-POSIX-extensies vereisen.
Variatie in naleving in de praktijkSystemen kunnen verschillen in welke optionele functies ze implementeren en in hun gedrag in uitzonderlijke gevallen, dus "POSIX-achtig" betekent niet altijd identieke resultaten overal.
Kleinste gemene deler-beperkingenDoor strikt volgens de POSIX-richtlijnen te schrijven, kan het nodig zijn om platformspecifieke mogelijkheden te vermijden die de prestaties, observeerbaarheid of functionaliteit zouden kunnen verbeteren.
Verschillen in gereedschap buiten de standaardZelfs als hulpprogramma's overal beschikbaar zijn, kunnen implementaties vlaggen toevoegen of standaardwaarden wijzigen, waardoor scripts nog steeds kunnen vastlopen als ze afhankelijk zijn van niet-POSIX-opties (wat vaak voorkomt bij sed, awk, tar, enz.).
Certificering is niet universeel.Veel systemen ondersteunen POSIX in grote lijnen zonder formele certificering, dus mogelijk zijn testen en compatibiliteitscontroles nog steeds nodig in plaats van te vertrouwen op een conformiteitslabel.
Veranderende verwachtingen versus standaardtempo. De standaardupdates worden regelmatig bijgewerkt, maar populaire platforms en ecosystemen kunnen sneller evolueren, dus ontwikkelaars richten zich in de praktijk vaak op "POSIX + feitelijke uitbreidingen".

Is POSIX verouderd?

POSIX is als basislijn niet verouderd , ook al beschrijft het niet elke moderne besturingssysteemfunctie. Het is nog steeds belangrijk omdat het de kernprocessen, bestands-I/O en shell-/hulpprogrammagedragingen standaardiseert waarop een enorme hoeveelheid systeemsoftware en -tools vertrouwt. Bovendien wordt het actief onderhouden en herzien door de Austin Group, in plaats van dat het in de tijd bevroren is.

Het kan wat "verouderd" aanvoelen, omdat veel belangrijke functionaliteiten, zoals geavanceerde API's die alleen voor Linux beschikbaar zijn, macOS-specifieke frameworks, moderne beveiligingsmodellen, containers en enkele nieuwere netwerkfuncties, buiten POSIX vallen. Daarom richten echte projecten zich vaak op "POSIX plus platformuitbreidingen" en valideren ze het gedrag door middel van testen, in plaats van te verwachten dat de standaard op zichzelf alles dekt.