De Unix en Internet Basis HOWTO
v1.7, 6 maart 2000Dit document beschrijft de praktische basis van PC-klasse computers, op
Unix lijkende besturingssystemen, en het Internet in een niet-technische taal.
Introductie
Doel van dit documentDit document is bestemd om Linux en Internet gebruikers, die al doende
leren, te helpen. Ondanks dat dit een geweldige manier is om specifieke
vaardigheden op te doen, laat het soms bijzondere hiaten in
iemands basiskennis -- hiaten die het moeilijk kunnen maken,
creatief of effectief problemen op te lossen, door een gebrek
aan een duidelijke denkwijze over wat er werkelijk aan de hand is.Ik zal proberen in een duidelijke, eenvoudige taal te beschrijven hoe
alles werkt. De presentatie zal worden afgestemd op mensen die Unix
of Linux op PC-klasse hardware gebruiken.
Niettemin zal ik hier meestal gewoon naar `Unix' verwijzen,
aangezien het meeste wat ik hier zal beschrijven gelijk
is voor alle platformen en Unix varianten.Ik ga ervan uit dat je een Intel PC gebruikt.
De details verschillen een beetje als je met een Alpha of PowerPC
of een andere Unix box werkt, maar de basisconcepten zijn hetzelfde.Ik zal niets herhalen, dus je zult op moeten letten, maar dat
betekent ook, dat je van ieder woord dat je leest, zult leren.
Het is een goed idee dit vluchtig door te nemen
als je dit voor het eerst leest; je zou eigenlijk terug moeten keren
en het een paar keer herlezen, nadat je in je op hebt genomen wat
je hebt geleerd.Dit is een document dat geleidelijk ontstaat. Het is mijn bedoeling als
reactie op feedback van gebruikers secties toe te voegen, dus je zou het
periodiek opnieuw moeten bekijken. Wat is nieuwNieuw in 1.2: De sectie `Hoe bewaart mijn computer dingen in het geheugen?'.
Nieuw in 1.3: De secties `Wat gebeurt er als je inlogt?' en `Eigenaarschap van
een bestand, permissies en beveiliging'.
Nieuw in 1.4: Wat preciezer geweest in wat de kernel doet vs. wat init doet.
Nieuw in 1.7: De sectie over bestandspermissies gecorrigeerd en uitgebreid.Andere versies bestonden uit het corrigeren van spelfouten en kleine
redactionele wijzigingen.
Gerelateerde bronnenAls je dit aan het lezen bent, om te leren hacken, zou je ook
de moeten lezen.
Er staan een aantal links in naar andere nuttige bronnen. Basis anatomie van je computerJe computer heeft binnenin een processorchip die het werkelijke
werk verricht. Het heeft intern geheugen (wat DOS/Windows mensen
``RAM'' noemen en Unix mensen vaak ``core'' noemen.
De processor en het geheugen bevinden zich op het
moederbord, het hart van je computer.Je computer heeft een scherm en toetsenbord. Het heeft harddisks en
diskettestations. Het scherm en je disks hebben
controllerkaarten die in het moederbord worden geplugd
en de computer helpen deze apparaten die zich niet direct op het moederbord
bevinden te besturen. (Je toetsenbord is te eenvoudig voor een aparte kaart;
de controller is in de toetsenbordombouw zelf ingebouwd.)We zullen later op een aantal details ingaan over hoe deze apparaten werken.
Voor nu, zijn hier een aantal basiszaken om in gedachten te houden hoe
ze samenwerken:Alle ingebouwde delen van je computer zijn verbonden via een
bus. Fysiek is de bus datgene waarin je je
controllerkaarten plugt (de videokaart, de diskcontroller, een geluidskaart
als je die hebt). De bus is de gegevenssnelweg tussen je processor,
je scherm, je disk, en al het andere.De processor, die ervoor zorgt dat al het andere aan de gang helpt, kan
in werkelijkheid geen van de andere delen direct zien; het moet met hen
via de bus communiceren. Het enige andere subsysteem waartoe het onmiddellijke
toegang heeft, is geheugen (de core). Om programma's te laten
draaien, moeten ze zich in core (in het geheugen) bevinden.Wat er in werkelijkheid gebeurt, als je computer een programma of
gegevens van disk leest, is dat de processor de bus gebruikt om een
diskleesverzoek naar je diskcontroller te zenden.
Wat later, gebruikt de diskcontroller de bus om de computer het sein
te geven dat het de gegevens heeft ingelezen en het in een bepaald
gebied in het geheugen heeft gezet. De processor kan dan de bus gebruiken
ook naar dat geheugen te kijken.Je toetsenbord en scherm communiceren ook via de bus met de processor,
maar op een eenvoudiger manier. We zullen deze later bespreken.
Voor nu weet je voldoende om te kunnen begrijpen wat er gebeurt als
je je computer aanzet.Wat gebeurt er als je een computer aanzet?Een computer zonder een draaiend programma is gewoonweg een logge homp
elektronica. Het eerste wat een computer moet doen als het wordt aangezet
is een speciaal programma opstarten dat een
besturingssysteem wordt genoemd.
De taak van het besturingssysteem is te helpen bij het aan het werk
krijgen van andere computerprogramma's door de lastige details met betrekking
tot het besturen van de computerhardware af te handelen.Het proces om het besturingssysteem aan de gang te krijgen wordt
booten genoemd.
(van origine was dit bootstrapping en zinsspeelde op
de moeilijkheid om jezelf ``aan je laarzen'' op te trekken). Je computer
weet hoe het moet booten omdat de instructies voor het booten in
één van z'n chips zijn ingebouwd,
de BIOS (of Basic Input/Output System) chip.De BIOS chip vertelt het op een vaste plaats op de laagst-genummerde
harddisk (de bootdisk) te zoeken naar een speciaal programma dat
een bootloader wordt genoemd (onder Linux wordt de bootloader
LILO genoemd). De bootloader wordt in het geheugen geladen en gestart.
De taak van de bootloader is het echte besturingssysteem op te starten.De loader doet dit door naar een kernel te zoeken,
deze in het geheugen te laden en het te starten. Als je Linux opstart en
je ziet op het scherm "LILO" gevolgd door een groep punten,
is het de kernel aan het laden. (Iedere punt betekent dat het
een ander diskblok van
de kernelcode heeft geladen.)(Het zou kunnen dat je je afvraagt waarom de BIOS de kernel niet direct
laadt -- waarom het twee-staps proces met de bootloader?
Dit komt omdat de BIOS niet erg slim is.
In feite is het erg dom, en Linux gebruikt het in het geheel niet
na het opstarten.
Het werd van origine geschreven voor primitieve 8-bits PC's met hele kleine
disks, en het kan letterlijk niet voldoende toegang tot de disk krijgen om
de kernel direct te kunnen laden.
De bootloader-stap laat je ook één van de verscheidene
besturingssystemen vanaf verschillende plaatsen van de disk opstarten,
(in het onwaarschijnlijke geval dat Unix niet goed genoeg voor je is.)Zodra de kernel opstart, moet het om zich heenzoeken om de rest van
de hardware te vinden, en zorgen dat het gereed is om programma's te draaien.
Het doet dit niet door rond te snuffelen in gewone geheugenlokaties
maar eerder via I/O poorten -- speciale bus
adressen waar zich naar alle waarschijnlijkheid device controllerkaarten kunnen
bevinden die luisteren in afwachting van commando's.
De kernel snuffelt niet willekeurig rond; het heeft een heleboel
ingebouwde kennis over wat het vermoedelijk waar kan vinden,
en hoe controllers zullen reageren als ze aanwezig zijn. Dit proces wordt
autoprobing genoemd.De meeste meldingen die je tijdens het booten ziet,
komen voort uit het autoprobing-proces van de hardware via de I/O poorten,
door de kernel, uitzoekend wat er beschikbaar is en het zichzelf aanpast
aan je computer, beter dan de meeste andere Unixes en veel beter
dan DOS of Windows. In feite, denken vele Linux gebruikers van de oude
stempel dat de slimheid van Linux's onderzoeken tijdens de systeemstart
(wat het relatief gemakkelijk maakt om het te installeren)
een belangrijke reden was voor de doorbraak van de vrije-Unix experimenten
door een kritische massa gebruikers aan te trekken.Maar de kernel volledig geladen en draaiend krijgen is niet het einde
van het bootproces; het is pas de eerste fase (soms run level 1
genoemd). Na deze eerste fase, geeft de kernel de controle over aan een
speciaal proces, genaamd `init', welke verscheidene beheertaken verricht.De eerste taak van het init-proces is meestal een controle
om er zeker van te zijn dat je disks OK zijn.
Disk bestandssystemen zijn kwetsbaar; als ze door een hardware-fiasco
of een plotselinge stroomuitval zijn beschadigd, zijn er goede redenen
om herstelstappen te ondernemen voordat je Unix weer helemaal in orde is.
We zullen later op enkele van deze details ingaan,
als we het gaan hebben over
.De volgende stap van init is het opstarten van verscheidene
daemons. Een daemon is een
programma zoals een print spooler, een mail listener of een WWW-server
die zich in de achtergrond verscholen houdt, in afwachting om iets te doen.
Deze speciale programma's moeten vaak verscheidene verzoeken die
met elkaar in conflict kunnen raken, coördineren.
Er zijn daemons, omdat het vaak makkelijker is om een programma te schrijven
dat continue draait en bekend is met alle verzoeken dan het zou zijn om
te proberen te voorkomen dat een schare kopieén (waarbij ieder een
verzoek verwerkt en ze allen tegelijkertijd draaien) elkaar niet in de weg
zitten. De bepaalde verzameling daemons die je systeem
start kan variëren, maar hier zal bijna altijd een print spooler bij zijn
(een portier daemon voor je printer).Zodra alle daemons zijn gestart, bevinden we ons op
run level 2. De volgende stap is de voorbereiding op gebruikers.
Init start een kopie van een programma met
de naam getty om je console in de gaten te houden (en misschien meer
kopieën om dial-in seriële poorten in de gaten te houden).
Dit programma zorgt dat de login-prompt op je console
te voorschijn komt. We zijn nu op run level 3 en gereed om
in te loggen en programma's te draaien.Wat gebeurt er als je inlogt?Als je inlogt (een naam en wachtwoord geeft) identificeer je jezelf aan
getty en de computer. Het draait vervolgens een programma met
de naam (natuurlijk genoeg) login, welke controleert of je
geautoriseerd bent om de computer te gaan gebruiken. Als dat niet zo is,
zal je poging om in te loggen worden verworpen. Als het wel zo is, zal
login een aantal huishoudelijke zaken verrichten en vervolgens een
commando-interpreter, de shell, opstarten.
(Ja, getty en
login zouden één programma kunnen zijn.
Ze zijn gescheiden om historische redenen waarvan het niet waard
is ze hier te vermelden).Bij deze wat meer over wat het systeem doet, voordat het je een shell
presenteert; je zal het voor het begrip later nodig hebben, wanneer we
het gaan hebben over bestandspermissies. Je identificeert jezelf met een
loginnaam en een wachtwoord. De loginnaam wordt opgezocht in een bestand
met de naam /etc/password, welke bestaat uit een reeks regels, waarvan ieder
een gebruikersaccount beschrijft.Één van deze velden is een versleutelde versie van het
account-wachtwoord. Datgene wat je invoert als een account-wachtwoord wordt
op exact dezelfde wijze versleuteld, en het login-programma
controleert of die twee overeenkomen. Terwijl de conversie van de
ingetikte versie naar de versleutelde versie eenvoudig is, hangt de
beveiliging van deze methode af van het feit, of het erg moeilijk is om dit
proces om te draaien. Dus ook al kan iemand de versleutelde versie van je
wachtwoord zien, ze kunnen je account niet gebruiken. (Als je je
wachtwoord vergeet, betekent dit bovendien dat er geen manier is waarop
je het kunt herstellen, je hebt alleen de mogelijkheid een ander wachtwoord
te kiezen). Zodra je succesvol bent ingelogd, krijg je alle privileges, welke met die
individuele account zijn verbonden. Misschien dat je ook als onderdeel
van een group (groep) wordt herkend. Een groep is een
door de systeembeheerder bij naam genoemde verzameling gebruikers. Een groep
kan privileges hebben, die onafhankelijk zijn van de privileges van de leden
van die groep. Een gebruiker kan onderdeel uitmaken van meerdere groepen.
(zie de sectie hieronder over , voor details over
hoe Unix-privileges werken).(Noot: alhoewel je normaal gesproken naar gebruikers en groepen bij naam
refereert, worden ze intern in werkelijkheid als numerieke ID's opgeslagen.
Het wachtwoordbestand deelt je gebruikersnaam in naar een gebruikers-ID;
het /etc/group bestand deelt de groepsnamen in naar
numerieke groep-ID's. Commando's die te maken hebben met accounts en
groepen zorgen automatisch voor de vertaling.Het record van je account bevat ook je home-directory,
de plaats in het Unix-bestandssysteem waar je persoonlijke bestanden
voorkomen. Tenslotte, stelt het record van je account ook je
shell in, de commando-interpreter dat door login
zal worden opgestart, om je commando's te accepteren.Wat gebeurt er als je programma's vanuit de shell draait?De shell is de interpreter voor de Unix-commando's die je intikt; het wordt
een shell genoemd omdat het omhulsel is van de kernel en het de kernel verbergt.
De normale shell geeft je de '$' prompt die je na het inloggen ziet
(tenzij je het hebt aangepast om iets anders te doen).
We zullen het hier niet over shell-syntax hebben en de makkelijke zaken die
je op het scherm kunt zien; in plaats daarvan zullen we een blik
achter de schermen werpen over wat er vanuit het gezichtspunt van de
computer gebeurt.Na het booten en voordat je een programma draait, kun je aan je computer
denken als een dierentuin vol met processen die allen wachten om iets
te kunnen doen. Ze wachten allemaal op events. Een event
kan zijn dat je een toets indrukt of een muis beweegt. Of een event kan een
datapakket zijn, dat via het netwerk binnenkomt, als je computer
op een netwerk is aangesloten.De kernel is één van deze processen.
Het is een speciale, omdat het bepaalt wanneer de andere
gebruikersprocessen kunnen draaien, en het is normaal gesproken
het enige proces met directe toegang tot de hardware van de computer.
In feite moeten gebruikersprocessen een verzoek indienen aan de kernel
als ze toetsenbordinvoer willen ophalen, naar je scherm willen schrijven,
van of naar disk willen schrijven, of gewoon alles willen doen anders dan
in het geheugen vermalen van bits.
Deze verzoeken staan bekend als system calls.Normaal gesproken gaat alle I/O via de kernel dus het kan de bewerkingen
regelen en voorkomen dat processen elkaar in de weg zitten.
Van een paar speciale gebruikersprocessen is het toegestaan dat ze
de kernel ongemerkt voorbijgaan, gewoonlijk doordat er directe toegang
tot I/O poorten wordt gegeven. X-servers (de programma's die op de
meeste Unix boxen grafische schermverzoeken van andere programma's
afhandelen) zijn hier het meest algemene voorbeeld van. Maar we zijn nog
niet bij de X server aangekomen; je kijkt naar een shell-prompt op een
character console.De shell is gewoon een gebruikersproces, en niet een bijzonder speciaal
proces. Het wacht op je toetsaanslagen, luistert (via de kernel) naar de
toetsenbord I/O poort. Als de kernel ze ziet, echoot hij ze naar je scherm
en geeft ze vervolgens door aan de shell. Als de kernel een `Enter' ziet
geeft het een regel tekst door aan de shell. De shell probeert deze
toetsaanslagen als commando's te interpreteren.Laten we ervan uitgaan dat je `ls' en Enter intikt om de Unix
directorylijst aan te roepen. De shell volgt zijn interne regels om
er achter te komen dat je het
uitvoerbare commando in het bestand `/bin/ls' wilt uitvoeren.
Het genereert een system call door de kernel /bin/ls als een nieuw
kind proces op te starten
en het toegang te geven tot het scherm en toetsenbord via de kernel.
Vervolgens gaat de shell slapen, in afwachting tot ls is beëindigd.Als /bin/ls klaar is, vertelt het de kernel dat het klaar is door een
exit system call aan te roepen. De kernel schudt vervolgens de
shell wakker en vertelt het dat het verder kan gaan met de uitvoering.
De shell roept een andere prompt aan en wacht op een andere regel invoer.Er kunnen zich echter andere dingen afspelen als `ls' wordt uitgevoerd,
(we moeten er van uit gaan dat je een zeer lange directorylijst laat weergeven).
Je zou bijvoorbeeld naar een andere virtuele console kunnen schakelen,
daar inloggen en het spel Quake opstarten.
Of, veronderstel dat je bent aangesloten op het Internet, dan zou je
computer mail kunnen verzenden of ontvangen op het moment dat
/bin/ls wordt uitgevoerd.Hoe werken apparaten en interrupts?Je toetsenbord is een zeer eenvoudig invoerapparaat; gewoonweg, omdat het
zeer langzaam kleine hoeveelheden gegevens genereert
(voor computerstandaards). Als je een toets indrukt of loslaat,
wordt die event doorgeseind aan de toetsenbordkabel om een
hardware interrupt te doen ontstaan.Het is de taak van het besturingssysteem om dergelijke interrupts in
de gaten te houden.
Voor iedere mogelijke soort interrupt, zal er een interrupt
handler zijn, een deel van het besturingssysteem welke
enige gegevens die ermee zijn geassocieerd verbergt
(zoals je toetsindruk/toetsloslaat waarde), totdat het kan worden verwerkt.Wat de interrupt handler voor je toetsenbord eigenlijk doet, is de
toetswaarde in een systeemgebied vlakbij de onderkant van het
geheugen posten. Daar zal het ter inzage beschikbaar zijn als
het besturingsssysteem de controle overgeeft aan het programma, waarvan
op dat moment verondersteld wordt dat het van het toetsenbord aan
het lezen is.Complexere invoerapparaten zoals disk- of netwerkkaarten werken op een
vergelijkbare manier. Hierboven refereerde we naar een diskcontroller
die de bus gebruikte om te seinen dat er aan een diskverzoek was
beantwoord. Wat er in werkelijkheid gebeurt, is dat de disk een interrupt
veroorzaakt. De disk interrupt handler kopieert de ontvangen gegevens
vervolgens naar het geheugen, voor later gebruik door het programma dat het
verzoek deed.Iedere soort interrupt heeft een geassocieerde prioriteiten
niveau. Lagere-prioriteit interrupts (zoals toetsenbord events)
moeten wachten op hogere-prioriteit interrupts (zoals kloktikken of
disk events). Unix is ontworpen om hoge prioriteit te geven aan de soort
events die snel moeten worden verwerkt om ervoor te zorgen dat de response
van de computer vlot verloopt.In de opstartmeldingen van je OS, zou het kunnen dat je verwijzingen
tegenkomt naar IRQ-nummers. Het kan zijn dat je je er
bewust van bent dat één van de algemene manieren om je hardware
onjuist te configureren is, dat twee verschillende apparaten dezelfde IRQ
proberen te gebruiken, zonder dat je exact begrijpt waarom.Hier is het antwoord. IRQ staat voor "Interrupt Request".
Het besturingssysteem moet bij het opstarten weten welke genummerde interrupts
elk hardware-apparaat zal gebruiken,
zodanig dat het de juiste handlers met ieder daarvan kan associëren.
Als twee verschillende apparaten dezelfde IRQ proberen te gebruiken,
zullen interrupts soms naar de verkeerde handler worden gezonden.
Dit zal gewoonlijk op z'n minst het apparaat doen vastlopen,
en kan het OS soms genoeg in de war brengen dat het vastloopt of crasht.Hoe doet mijn computer verscheidene dingen tegelijkertijd?Dat doet 't in werkelijkheid niet.
Computers kunnen slechts één taak (of proces)
tegelijkertijd verrichten.
Maar een computer kan zeer snel van taak wisselen, en langzame
menselijke wezens voor de gek houden door ze te laten denken dat het
verscheidene dingen tegelijkertijd doet. Dit wordt timesharing genoemd.Een van de taken van de kernel is het beheren van timesharing.
Het heeft een onderdeel dat de scheduler wordt genoemd,
die alle informatie intern bijhoudt
over alle andere (niet-kernel) processen in je dierentuin. Iedere 1/60 van een
seconde, gaat er in de kernel een tijdklok af die een klokinterrupt genereert.
De scheduler stopt het proces welke erop dat moment ook draait, onderbreekt
het op z'n plaats, en geeft de controle over aan een ander proces.1/60 van een seconde klinkt misschien niet als veel tijd. Maar voor de
tegenwoordige microprocessors is het voldoende om tienduizenden
machine-instructies uit te voeren, die flink wat werk kunnen verrichten.
Dus zelfs als je veel processen hebt lopen, kan ieder ervan heel wat in zijn
tijdsfragment volbrengen.In praktijk kan het zijn dat een programma niet zijn volledige tijdsfragment
krijgt. Als een interrupt
vanaf een I/O device binnenkomt, stopt de kernel in feite de huidige taak,
draait de interrupt handler, en keert daarna terug naar de huidige taak. Een
storm hoge-prioriteiten interrupts kan de normale verwerking verdringen; dit
wangedrag wordt thrashing genoemd en is gelukkig onder moderne
Unixes zeer moeilijk te forceren.In feite is de snelheid van programma's slechts zeer zelden beperkt
door de hoeveelheid machinetijd die ze kunnen krijgen
(er zijn een paar uitzonderingen op deze regel, zoals het genereren van
geluid of 3-D graphics). Veel vaker, worden vertragingen veroorzaakt
als het programma op gegevens van een diskdrive of netwerkverbinding
moet wachten.Een besturingssysteem dat volgens vaste regel veel gelijktijdige processen
kan ondersteunen, wordt "multitasking" genoemd. De Unix familie
besturingssystemen is vanaf
het begin af aan ontworpen voor multitasking en is daar erg goed in -- veel
effectiever dan Windows of de Mac OS, waarbij multitasking als een latere
overweging is ingesloten en ze dit nogal armzalig doen. Efficiënte,
betrouwbare multitasking is een belangrijk deel van wat Linux
superieur maakt voor netwerken, communicaties, en Web service.Hoe zorgt mijn computer ervoor dat processen elkaar niet in de
weg zitten?De scheduler van de kernel zorgt voor het verdelen van de tijd over de
processen. Je besturingssysteem moet ze ook qua ruimte verdelen,
zodanig dat processen niet in elkaars werkgeheugen kunnen gaan zitten.
Zelfs als je er van uit gaat dat alle programma's proberen samen te werken, wil
je niet dat een bug in het ene programma de andere programma's kan beschadigen.
Datgene dat je besturingssysteem doet om dit probleem op te lossen wordt
geheugenbeheer genoemd.Ieder proces in je dierentuin heeft z'n eigen gebied in het geheugen
nodig, als een plaats van waaruit het z'n code kan uitvoeren en variabelen en
resultaten in op kan slaan. Je kunt je dit voorstellen als een alleen leesbaar
code segment (waar de instructies van het proces in staan)
en een schrijfbaar data segment (waarin alle variabelen van
het proces zijn opgeslagen).
Het data segment is waarlijk uniek voor ieder proces, maar als twee
processen dezelfde code uitvoeren, herschikt Unix ze automatisch
zodanig dat ze een enkel codesegment delen als een efficiëntie maatregel.Efficiëntie is belangrijk, omdat geheugen duur is. Soms heb je
niet genoeg om het geheel aan programma's die op de computer worden gedraaid,
vast te houden, vooral als je een groot programma zoals een X server gebruikt.
Om dit te ontduiken, gebruikt Unix een strategie die
virtueel geheugen wordt genoemd.
Het probeert niet alle code en data voor een proces in het geheugen te behouden.
In plaats daarvan, blijft het werken met een relatief kleine
werkset;
de rest van de stand van het proces blijft achter
in een speciaal swap space gebied op je harddisk.Als het proces draait, probeert Unix vooruit te lopen op hoe de werkset
zal wijzigen en heeft slechts hetgeen het nodig heeft in het geheugen. Dit
doeltreffend doen is zowel gecompliceerd als lastig, dus ik zal niet
proberen het hier allemaal te beschrijven, -- maar het hangt af van het
feit dat code en dataverwijzingen geneigd zijn in clusters te gebeuren,
waarbij het aannemelijk is dat iedere nieuwe cluster naar een
oude cluster in de buurt ervan verwijst.
Dus als Unix de code of data die het vaakst (of meest recent) wordt
gebruikt, in de buurt houdt, zal het er gewoonlijk in slagen tijd
te besparen.Merk op dat in het verleden, dat "Soms" twee paragrafen terug "Bijna
altijd" was, -- de grootte van het geheugen was kenmerkend klein gerelateerd
aan de grootte van uitvoerende programma's, dus er werd frequent geswapt.
Geheugen is tegenwoordig veel minder duur en zelfs de goedkoopste computers
hebben er heel veel van. Op moderne single-user computers met 64MB of
meer geheugen, is het mogelijk om X te draaien en een typische mix taken
zonder ooit te swappen.Zelfs in deze gelukkige situatie, heeft het deel van het besturingssysteem
dat geheugenbeheer wordt genoemd, nog steeds belangrijk werk te doen.
Het moet ervoor zorgen dat programma's alleen hun eigen datasegmenten kunnen
wijzigen --dat wil zeggen, voorkomen dat door onjuiste of kwaadwillige
code in het ene programma de data in een ander programma overhoop wordt
gehaald. Om dit te doen, houdt het een tabel met gegevens en codesegmenten
bij. De tabel wordt bijgewerkt als een proces om meer geheugen verzoekt of
geheugen vrijgeeft (het laatste meestal als het stopt).Deze tabel wordt gebruikt om commando's door te geven naar een
gespecialiseerd deel van de onderliggende hardware met de naam
MMU of memory management unit.
MMU's zijn bovenop moderne processor chips gebouwd.
De MMU heeft de speciale mogelijkheid om geheugengebieden af te schermen, dus
een buiten-de-grens verwijzing zal worden geweigerd en een speciale interrupt
veroorzaken.Als je ooit een Unix melding "Segmentation fault", "core dumped" of iets
vergelijkbaars te zien krijgt,
is dit wat er precies is gebeurd; een poging van het uitvoerende programma
om toegang tot het geheugen (de core) buiten zijn segment te verkrijgen, heeft
een fatale interrupt veroorzaakt.
Dit duidt op een bug in de programmacode; de
core dump die het achterlaat bestaat uit diagnostische
informatie met de bedoeling de programmeur te helpen het op te sporen.Er is nog een aspect om ervoor te zorgen processen tegen elkaar te
beschermen, buiten het opdelen van het geheugen dat ze benaderen. Je zal
ook de toegankelijkheden van de bestanden willen beheren, zodat een programma
met fouten of een kwaadwillig programma kritieke delen van het systeem niet kan
beschadigen. Daarom bestaan er onder Unix , die we later zullen bespreken.Hoe bewaart mijn computer zaken in het geheugen?Waarschijnlijk weet je al dat alles op een computer als een reeks bits
(binary digits) wordt bewaard; je kunt je dit voorstellen als een heleboel
aan- en uitschakelingen). We zullen hier uitleggen hoe deze bits worden
gebruikt om de letters en nummers weer te geven.Voordat we hier op in kunnen gaan, moet je enig begrip hebben van de
woordgrootte van je computer. De woordgrootte is de voorkeursgrootte
van je computer voor het manoeuvreren van eenheden informatie; technisch
gezien is het de lengte van de registers van je processor,
wat de opslaggebieden zijn die je processor gebruikt voor de arithmetische en
logische berekeningen. Dit is wat mensen bedoelen, als ze schrijven over
computers met bit-grootte (waarbij ze het hebben over, bijvoorbeeld ``32-bit''
of ``64-bit''computers).De meeste computers (waaronder 386, 486, Pentium en Pentium II PC's) hebben
een woordgrootte van 32 bits. De oude 286 computers hadden een woordgrootte
van 16. Mainframes van de oude stijl hadden vaak 36-bit woorden. Een paar
processors (zoals de Alpha welke van DEC was en nu van Compaq) hebben
64-bit woorden. Het 64-bit woord zal de volgende vijf jaar meer algemeen
worden; Intel is van plan de Pentium II door een 64-bit chip met als
codenaam `Merced', en nu officieel genaamd de `Itanium', te vervangen.De computer ziet je geheugen als een reeks woorden genummerd van 0 tot
één of ander groot nummer, waarvan de waarde afhankelijk is
van de grootte van je geheugen. Die waarde is beperkt door je woordgrootte.
Daarom moeten oudere computers, zoals 286'rs, zich door moeizame bochten
wringen om grote hoeveelheden geheugen te adresseren. Ik zal ze hier niet
beschrijven; ze bezorgen oudere programmeurs nog steeds nachtmerries.
GetallenGetallen worden voorgesteld als woorden of stel woorden, afhankelijk van
de woordgrootte van je processor. Een 32-bit computerwoord is de meest
algemene grootte.Rekenkunde van gehele getallen (arithmetic integer) nadert, maar heeft niet
werkelijk een mathematisch grondtal twee.
Het minst significante bit is 1, vervolgens 2, dan 4 enzovoort als in zuiver
binair. Maar nummers met een teken worden voorgesteld in
twee-complement notatie. Het meest significante bit is
een tekenbit welke de kwantiteit negatief maakt,
en ieder negatief nummer kan worden verkregen uit de corresponderende positieve
waarde door alle bits om te draaien. Daarom komen integers op een 32-bit
computer voor in het bereik -2ˆ31 +1 tot 2ˆ31 -1 (waar ˆ de `machts'-bewerking
, 2ˆ3=8 is). Het 32e bit wordt gebruikt voor het teken.Een aantal computertalen geeft je toegang tot
unsigned arithmetic (rekenkunde zonder teken) welke
is gebaseerd op grondtal 2, met verder alleen positieve nummers en nul.De meeste processors en een aantal programmeertalen kunnen omgaan met
floating-point getallen (deze mogelijkheid is in alle
recente processor-chips ingebouwd). Floating-point getallen geven je een
veel breder bereik aan waarden dan gehele getallen (integers) en geven je
de mogelijkheid breuken uit te laten drukken. De wijze waarop dit wordt
gedaan verschilt en is te gecompliceerd om hier in detail te bespreken,
maar in het algemeen lijkt 't veel op de zogenoemde `wetenschappelijke
notatie', waarbij men op zou kunnen schrijven 1.234 * 10ˆ23; de codering van het
getal is geplitst in een mantisse (1.234) en een
exponent (23) voor een macht tot de tiende vermenigvuldiging. Hoe bewaart mijn computer zaken op disk?Als je een harddisk onder Unix bekijkt, zie je een
structuur met benoemde directory's en bestanden.
Normaal gesproken zul je niet dieper hoeven te kijken, maar het zou
handig zijn om te weten wat er zich afspeelt als er zich een diskcrash voordoet
en je bestanden moet proberen te redden. Helaas is er geen goede manier
om de diskorganisatie bekeken vanaf het bestandsniveau te beschrijven,
dus ik zal het vanaf de kant van de hardware moeten beschrijven.
Low-level disk en bestandssysteemstructuurHet oppervlaktegebied van je disk, waar de gegevens worden opgeslagen,
is onderverdeeld op iets dat lijkt op een dartbord,
-- in circulaire sporen die weer als taartstukken zijn onderverdeeld in
sectoren. Omdat sporen dichtbij de buitenrand uit een grotere oppervlakte
bestaan dan die dichtbij de as in het midden van de disk, bevinden er zich
op de buitenste sporen meer sectorstukken dan op de binnenste sporen.
Iedere sector (of diskblok) heeft dezelfde grootte,
die onder moderne
Unixes in het algemeen 1 binary K (1024 8-bit woord) groot is.
Ieder diskblok heeft een uniek adres of diskbloknummer.Unix verdeelt de disk in diskpartities. Iedere partitie
is een onafgebroken span blokken die gescheiden wordt gebruikt ten opzichte
van enige andere partitie, als een bestandssysteem of als swap space.
De oorspronkelijke redenen voor partities had te maken met het herstellen
bij een crash in een wereld van veel langzamere en veel meer fouten
bevattende disks; door de grenzen ertussen neemt vermoedelijk de kans af dat
het deel van je disk ontoegankelijk of beschadigd raakt door een willekeurige
slechte plek op de disk. Tegenwoordig is het veel belangrijker dat
partities voor alleen lezen kunnen worden gedeclareerd (om te voorkomen
dat een indringer kritieke systeembestanden kan wijzigen)
of met diverse bedoelingen over een netwerk kunnen worden gedeeld
wat we hier niet zullen bespreken. Met de laagst-genummerde
partitie wordt vaak speciaal omgegaan, als een boot partitie, waar je een kernel kunt plaatsen om te worden geboot.Iedere partitie bestaat óf uit swap space
(wordt gebruikt om aan te vullen óf
een bestandssysteem,
dat wordt gebruikt om bestanden vast te houden. Swap-space
partities worden behandeld als een lineaire reeks blokken. Aan de andere
kant hebben bestandssystemen een manier nodig om bestandsnamen naar
reeksen diskblokken in te delen.
Omdat bestanden groter worden, kleiner worden en gedurende de tijd
wijzigen, zullen de gegevensblokken van een bestand niet bestaan uit een
lineaire reeks maar het kan zijn dat ze over de partitie verspreid zijn
(waar het besturingssysteem dan ook een vrij blok kan vinden als het er
één nodig heeft). Hoe werken computertalen?We hebben reeds besproken .
Ieder programma moet uiteindelijk als een stroom bytes, die uit instructies
in de machinetaal van je computer bestaan, worden
uitgevoerd. Maar menselijke wezens kunnen niet zo erg goed met
machinetaal overweg; dit is inmiddels zelfs onder hackers een
zeldzame zwarte magie.Bijna alle Unix code behalve een kleine hoeveelheid directe
hardware-interface ondersteuning in de kernel zelf is tegenwoordig
geschreven in een hogere programmeertaal.
(Het `hogere' in deze term is een historisch overblijfsel om het te
onderscheiden van `lagere' assembleertalen, wat in wezen
doorzichtige verpakkingen om machinecode heen zijn.)Er zijn verscheidene verschillende soorten hogere programmeertalen.
Teneinde hierover te kunnen meepraten, is het handig om in gedachten te
houden dat de
broncode van een programma (de door de mens gemaakte, te
wijzigen versie) een soort vertaalslag moet ondergaan naar machinecode
om het door de machine uit te kunnen laten voeren.
Gecompileerde programmeertalenDe meest gebruikelijke soort programmeertaal is een gecompileerde
programmeertaal. Gecompileerde talen worden omgezet naar uitvoerbare
bestanden met uitvoerbare machinecode door een speciaal programma dat
(logisch genoeg) een compiler wordt genoemd.
Als het uitvoerbare bestand éénmaal is aangemaakt, kun je het
direct opstarten zonder nog naar de sourcecode te kijken.
(De meeste software wordt geleverd met gecompileerde uitvoerbare bestanden
aangemaakt aan de hand van code die je niet ziet.)Gecompileerde programmeertalen geven een uitstekende performance en hebben
complete toegang tot het OS, maar zijn ook moeilijk om in te programmeren.C, de programmeertaal waarin Unix zelf is geschreven, is hiervan verreweg
de belangrijkste (met z'n variant C++). FORTRAN is een andere
gecompileerde programmeertaal, nog steeds in gebruik door technici en
wetenschappers, maar jaren ouder en veel primitiever.
In de Unix wereld zijn er in belangrijke mate geen andere gecompileerde
programmeertalen in gebruik.
Daarbuiten wordt COBOL op velerlei gebied gebruikt voor financiële
en zakelijke software.Er werden veel andere gecompileerde programmeertalen gebruikt, maar de meeste
daarvan zijn uitgestorven of zijn strikte onderzoekshulpmiddelen.
Als je een nieuwe Unix ontwikkelaar bent die een gecompileerde
programmeertaal gebruikt, zal dit zeer waarschijnlijk C of C++ zijn. Hoe werkt het Internet?Om je te helpen begrijpen hoe het Internet werkt, zullen we datgene
bekijken wanneer je een typische Internet operatie uitvoert --
-- een browser richtend op de voorpagina van dit document op z'n
thuisbasis op het web bij het Linux Documentatie project.
Dit document ishttp://metalab.unc.edu/LDP/HOWTO/Fundamentals.htmlwat betekent dat het voorkomt in het bestand LDP/HOWTO/Fundamentals.html
onder de World Wide Web export-directory van de host metalab.unc.edu.
Namen en lokatiesHet eerste wat je browser moet doen is een netwerkverbinding tot
stand brengen met de computer waarop het document voorkomt.
Om dat te kunnen doen, moet het eerst de netwerklokatie
van de host metalab.unc.edu traceren
(`host' is een afkorting voor `host machine' of `netwerk host';
metalab.unc.edu is een typische hostname).
De corresponderende lokatie is in werkelijkheid een nummer dat
een IP-adres wordt genoemd (het `IP' deel van deze
term wordt later uitgelegd).Om dit te doen, ondervraagt je browser een programma dat een
name-server wordt genoemd. De name-server
kan zich op je computer bevinden, maar het is waarschijnlijker dat het
draait op een service machine waarmee de jouwe communiceert.
Als je je bij een ISP aanmeldt, zal een deel van je setupprocedure
bijna zeker inhouden dat je Internet software het IP-adres van een
name-server op het netwerk van de ISP bekend wordt gemaakt.De name-servers op verschillende computers praten met elkaar
over alle informatie die nodig is om hostnamen te herleiden, uit te wisselen
en up to date te houden (ze in te delen naar IP adressen).
Het zou kunnen dat je name-server drie of vier verschillende sites in het
netwerk ondervraagt tijdens het herleidingsproces van metalab.unc.edu,
maar dit gebeurt gewoonlijk erg snel (in minder dan een seconde).De name-server zal je browser laten weten dat het IP adres van Metalab
152.2.22.81 is; nu het dit weet, zal je computer in staat zijn om op
directe wijze bits met metalab uit te wisselen.