SET-B-FREE
EEN ‘HAMMOND ORGAN’ VOOR IEDEREEN (3)

Tekst en technische afbeeldingen: Marjan Waldorp
Artikel uit Turning Wheel 2024-1

In deel 2 hebben we de schijnwerper gericht op digitaal geluid en de rol van de geluidskaart (of chip) in een computer. Maar hoe sturen we nu digitaal geluid (PCM) vanuit een programma, zoals setBfree, naar de geluidskaart? Dat brengt ons op het voor de doorsnee computergebruiker schimmige onderwerp 'besturingssystemen'. Ik zal proberen wat licht in de duisternis te laten schijnen, zodat de puzzelstukjes op hun plaats vallen en we tevens over de benodigde kennis beschikken om een SBC (Single Board System) te installeren en te gebruiken.

Korte geschiedenis van het 'Operating System' (besturingssysteem)

Wie vandaag zijn computer aanzet, verwacht door het besturingssysteem begroet te worden. Dat is niet altijd zo geweest! In de begintijd was een computer een programmeerbaar apparaat, voorzien van een verwerkingseenheid (processor) en werkgeheugen (RAM), zonder software. Meestal hoog in het geheugen had de operator met de hand instructie voor instructie een 'loader' ingeklopt, een klein hulpprogramma waarmee programma's van een ponsband of aanstreepkaarten in het geheugen konden worden geladen. Wanneer een gebruikersprogramma moest worden uitgevoerd, laadde de operator het programma via de loader in het geheugen en liet de processor het programma uitvoeren. De uitgeprinte uitvoer belandde vervolgens via de interne post op het bureau van de gebruiker. De gebruikers bedienden de computer dus in de regel niet zelf! Dat deed de operator. Het klinkt nogal primitief en dat was het ook, maar met een werkgeheugen van slechts enkele kilobytes was er niet veel meer mogelijk! Pas toen de werkgeheugens groter werden, werd het mogelijk een computer standaard van een 'Operating System' (besturingssysteem) te voorzien, een geautomatiseerde operator, waarmee de gebruiker nu zelf eenvoudig programma's kon uitvoeren.

Zo begon in de jaren '60 van de vorige eeuw het tijdperk van de besturingssystemen. Er ontstond een oerwoud van elkaar beconcurrerende besturingssystemen. Iedere zichzelf respecterende computerfabrikant had zijn eigen besturingssysteem, nauw verbonden met de eigen computerhardware en qua reputatie zeker zo belangrijk als de eigen hardware! Terugkijkend zou één besturingssysteem een kat met negen levens blijken! Nee, niet ontwikkeld door een computerfabrikant, maar door Bell Labs, het lab van de Amerikaanse telefoonmaatschappij AT&T. We hebben het over UNICS (UNiplexed Information and Computing Service, 1969), later geschreven als UNIX. Van geen enkel ander besturingssysteem werden er zoveel varianten uitgebracht: HP-UX, Solaris, AIX, Sinix, NeXTSTEP, enz. En als we naar het huidige landschap kijken, dan zijn de populaire besturingssystemen van nu of een afgeleide van UNIX, zoals Linux, Android, MacOS, of UNIX diende als inspiratiebron.

Componenten van een besturingssysteem

De twee hoofdcomponenten van een besturingssysteem zijn:

• utilities (hulpprogramma's)
• kernel (vaste codekern)

Het belangrijkste hulpprogramma is wat in UNIX een 'Shell' wordt genoemd, een hulpprogramma waarmee we een programma kunnen laten uitvoeren door eenvoudig de naam van het programma in te typen. (Welk een vooruitgang!) Een ander belangrijk hulpprogramma is een teksteditor, waarmee we bijv. een 'script' kunnen schrijven om een reeks programma's in 'batch' (achtereenvolgens) te laten uitvoeren. Dat is handig! Dan kunnen we gaan koffiedrinken, terwijl de computer het werk doet, of gaan slapen.

De 'kernel', de vaste codekern van het besturingssysteem, is even belangrijk als onzichtbaar! Wanneer de kernel zijn werk doet, merk je er niets van. Maar als de kernel "crasht", is de computer "dood" en rest opnieuw opstarten! De kernel omvat een bonte verzameling programmacode, die puur intern dienstverlenend werkt. De kernel bevat geen toepassingsprogramma's! De belangrijkste onderdelen zijn:

• process management (procesbeheer)
• memory management (geheugenbeheer)
• filesystem support (bestandssysteem ondersteuning)
• device drivers (stuurcode voor perifere hardware)

Het 'process management' beheert de processen in de computer. (Processen zijn programma's in uitvoering.) Het process management start, stopt, pauzeert de processen en verdeelt de beschikbare processorcapaciteit over de processen (process schedular).

Het 'memory management' beheert het werkgeheugen (RAM) van de computer. Op verzoek geeft het memory management geheugen uit en neemt geheugen in, wanneer dit niet meer nodig is.

De 'filesystem support' regelt het opslaan en opvragen van bestanden op een opslagmedium, zoals een harddisk of een geheugenstick.

De 'device drivers' zijn softwaremodules, die de communicatie regelen tussen een programma en perifere hardware, zoals een harddisk controller, een netwerkkaart of -jawel!- een geluidskaart. In de "oertijd" diende de programmeur van een programma zelf de sturing van perifere hardware te regelen. Nu, met een besturingssysteem, verhuisde die code als 'device driver' naar de kernel voor algemeen gebruik.

De kernel wordt tijdens de opstart van de computer (bootstrap) als eerste in het werkgeheugen geladen en blijft daar zolang de computer draait. Waar kernelcode in het geheugen is geladen, kan echter niets anders zijn. Om je de luxe van een kernel te kunnen veroorloven, heb je dus voldoende werkgeheugen nodig! Serieuze besturingssystemen werden zodoende pas breed toepasbaar, toen het technisch mogelijk was voldoende grote werkgeheugens te produceren. Voor UNIX was toch wel minimaal 32k x 16bit nodig! Voor de eerste PC's was o.a. hierom UNIX geen haalbare kaart! Moderne besturingssystemen, zoals Linux, kunnen overigens in een draaiend systeem naar behoefte modules in de kernel laden. De basis kernelcode kan zo relatief klein blijven.

Device files (apparaat bestanden)

Met de verhuizing van de device drivers naar de kernel ontstond er wel een nieuw probleem. Waar eerst het aansturen van perifere hardware een zaak was van de programmeur, was er nu een protocol nodig om vanuit een programma een device driver aan te roepen. De programmeurs van MULTICS (de voorloper van UNIX) bedachten hiervoor een lumineuze oplossing, die brede navolging zou krijgen!

 C> COPY ATEXT.TXT LPT1

Nee, dit is geen UNIX, maar good old MS-DOS! In deze opdrachtregel kopiëert de gebruiker de inhoud van het bestand 'ATEXT.TXT' naar 'LPT1'. Echter 'LPT1' is geen gewoon bestand, maar een zgn. 'device file' (apparaat bestand). Een device file is een doorgeefluik naar een device driver. Wanneer we een device file openen, leidt de kernel ons door naar de betreffende device driver, die een hardware device aanstuurt, in dit geval 'parallel port 1'. Wanneer daar een printer aanhangt, zal deze opdrachtregel dus de inhoud van 'ATEXT.TXT' uitprinten. Lumineus! Je hoeft dus zelfs niet te kunnen programmeren, om via een device driver een randapparaat te kunnen aansturen!

Opslag van digitale data

Voor de langdurige opslag van digitale data werden van oudsher dragers gebruikt voorzien van een magnetiseerbare laag (bijv. ijzeroxide). Het bekendste voorbeeld is de harddisk met magnetiseerbare schijven. De laatste jaren zijn daar opslagmedia bijgekomen op basis van flash-geheugens.

Wanneer je de informatie op een opslagmedium wilt kunnen wijzigen, zonder alles te overschrijven, dan ligt het voor de hand de beschikbare ruimte in logische blokken (sectoren) op te delen. Vanuit de historie is de sectorgrootte 512 bytes. Het indelen van een opslagmedium in sectoren heet 'formatteren' (low-level format). Moderne harddisks zijn overigens in de fabriek op ingenieuze wijze geformatteerd en kunnen we niet meer zelf formatteren! Ook flash-geheugens zijn af fabriek geformatteerd in sectoren.

Partitioneren

Zeker wanneer het opslagmedium relatief veel ruimte biedt, is het gebruikelijk het opslagmedium te verdelen in onafhankelijk van elkaar te gebruiken delen (partitities). Dat biedt bijv. de mogelijkheid om de bestanden van de gebruikers te scheiden van het besturingssysteem. Het is dan mogelijk om het besturingssysteem volledig opnieuw te installeren zonder de gebruikersbestanden te verliezen.

Partitioneren is geen ingewikkelde techniek. Het partitioneringshulpprogramma plaatst aan het begin van het opslagmedium (1ste sector) een tabel, waarin voor elke partitie het begin en het einde staat vermeld. Tijdens de opstart leest de kernel de partitietabel en weet waar de partities beginnen en eindigen. Dus na herpartitioneren moeten we de computer opnieuw opstarten!

Devices files geven toegang tot de opslagmedia en hun partities. Stel dat we de eerste harddisk "a" in twee partities hebben ingedeeld, dan hebben we de volgende device files:

• /dev/sda (de gehele disk zonder partities!)
• /dev/sda1 (1ste partitie)
• /dev/sda2 (2de partitie)

Merk op dat wanneer je '/dev/sda' nu zou gebruiken voor data opslag, je de partitietabel overschrijft en geheel of gedeeltelijk de sectoren van de partities!

File Systems (Bestandssystemen)

Via device files kunnen we sectoren lezen en schrijven van en naar opslagmedia of hun partities. Van het lezen en schrijven van diskblokken worden echter alleen computernerds blij. Wat gewone gebruikers willen, is een verzameling databytes in een logische container (bestand) stoppen met een label (bestandsnaam) er aan. Maar hoe maken we van een verzameling diskblokken een opslagplaats van bestanden?

Het antwoord op dit best wel ingewikkelde probleem is 'bestandssysteem' (filesystem). Een bestandssysteem bestaat uit twee componenten:

• filesystem structure (administratieve datastructuur)
• filesystem support (software)

De administratieve structuur moet vooraf op het opslagmedium worden aangelegd (high-level format). De diskblokken die voor de administratie van het bestandssysteem worden gebruikt gaan ten koste van de ruimte voor opslag van data. Dus een bestandssysteem brengt 'overhead' met zich mee.

In de afgelopen decennia zijn er vele bestandssystemen en varianten ontwikkeld, deels toe te schrijven aan de concurrentie tussen de diverse besturingssystemen en het "not invented by us" syndroom, maar er vond ook echte innovatie plaats! Een van de problemen is, hoe je dataverlies en inconsistenties vermijdt, wanneer plotseling de stroom uitvalt en het dus niet mogelijk is de administratieve structuur orderlijk af te sluiten. De belangrijkste criteria van een bestandssysteem zijn snelheid en robuustheid. Moderne bestandssystemen, zoals Linux 'ext4', scoren op beide punten goed en zijn ook in staat eventuele inconsistenties van de administratieve structuur snel te herstellen.

Hoewel er ook in de UNIX-wereld diverse bestandssystemen werden ontwikkeld, is het basisconcept steeds hetzelfde gebleven! Het centrale element is de 'index node' (inode). Aan elk bestand is een index node gekoppeld. De index node begint met een header, waarin o.a. de toegangsrechten staan en het type bestand. Een bestand kan een 'gewoon' bestand (regular file) zijn, maar ook een directory of een device file. De rest van de index node zijn pointers naar de diskblokken van het bestand. (Zie figuur "UNIX Filesystem Concept")

Directories zijn in een UNIX bestandssysteem heel eenvoudig van structuur. Er staan alleen maar bestandsnamen en index node nummers in. Dit concept van directories met bestandsnamen verwijzend naar index nodes met alle attributen van het bestand maakt het mogelijk een bestand meer namen te geven. In het voorbeeld verwijzen de bestandsnamen "Jimmy_Smith" en "Smith_Jimmy" naar dezelfde index node en zijn dus hetzelfde bestand! Er wordt wel gezegd: "The inode is the file!"

Wie Jimmy Smith alias Smith Jimmy was hoef ik hier niet uit te leggen!