<!doctype linuxdoc system>
<linuxdoc>
<article>
<titlepag>

<title>From Power Up To Bash Prompt</title>
<author><name>Greg O'Keefe, <tt>gcokeefe_GEEN_SPAM_AUB_@postoffice.utas.edu.au</tt>
<newline>
Vertaald door: Ellen Bokhorst <tt>bokkie_GEEN_SPAM_AUB_@nl.linux.org</tt></name></author>
<date>v0.6, februari 2000</date>

<abstract>
Dit is een beknopte beschrijving van wat er gebeurt op een Linux-systeem,
vanaf het moment dat je de stroom inschakelt tot het moment waarop je inlogt
en een bash-prompt krijgt. Het is per pakket georganiseerd om het eenvoudiger
te maken voor die mensen die hun systeem vanaf de broncode op willen bouwen.
Dit begrijpen zal van hulp zijn bij het oplossen van problemen of
configureren van je systeem.
</abstract>
</titlepag>

<toc>


<sect><heading>Introductie</heading>
<p>
Ik vind het frustrerend dat er heel veel gebeurt binnenin mijn Linux-computer
wat ik niet begrijp. Als je net als ik, je systeem werkelijk wilt begrijpen
in plaats van alleen weten hoe je het moet gebruiken, dan zou dit een goede
plaats kunnen zijn om van start te gaan. Dit soort achtergrondkennis is
ook nodig als je een topper wilt zijn in het oplossen van Linux-problemen.
</p>

<p>
Ik ga er vanuit dat je een functionerende Linux-box hebt, en wat basiskennis
hebt van Unix en PC-hardware. Als dit niet zo is, is <URL
URL="http://mirror.aarnet.edu.au/linux/LDP/HOWTO/Unix-Internet-Fundamentals-HOWTO.html" NAME ="De Unix en Internet Fundamentals HOWTO" > van Eric S. Raymond een
uitstekende bron om te beginnen het te leren.
Het is kort, zeer leesbaar en behandelt de gehele basis.
</p>

<p>
De rode draad in dit document is hoe Linux zichzelf opstart.
Maar het probeert ook een wat uitgebreidere leerbron te zijn.
Ik heb in iedere sectie oefeningen opgenomen. Als je er hier echt een paar
van doet, zal je veel meer leren dan wanneer je dit zou kunnen door het
slechts te lezen. Er zijn ook een aantal verwijzingen naar te downloaden
source code. De reden hiervoor is dat ik hoop dat een aantal lezers
het zullen wagen op de beste Linux leeroefening die ik ken, het vanaf
de broncode bouwen van een systeem, of ``rolling your own''.
Giambattista Vico, zoals een Italiaanse filosoof (1668-1744) 't zei 
``verum ipsum factum'', begrip ontstaat door het maken.
Met dank aan Alex (zie <REF ID="acknowledge">) voor dit citaat.
</p>

<p>
Packages worden in die volgorde gepresenteerd als waarin ze in het
opstartproces van het systeem verschijnen. Dit betekent dat als je de
pakketten in deze volgorde installeert, je na iedere installatie, opnieuw
op kan starten, en het systeem iedere keer iets dichterbij ziet komen dat
het je een bash-prompt geeft. Hier zit een geruststellend besef van 
voortgang in.
</p>

<p>
Bij het samenstellen van een Linux systeem moeten een aantal keuzes worden
gemaakt. Dit zijn dezelfde keuzes die mensen van Red Hat of Debian moeten
maken wanneer ze een distributie cre&euml;ren. Er zijn vaak verscheidene
vrij verkrijgbare pakketten beschikbaar die deze taak uitvoeren.
Wat ik hier beschrijf zijn de componenten die onderdeel uitmaken van
de grotere Linux distributies. Ik koos voor GNU-software wanneer 
het beschikbaar was, omdat het beter is gedocumenteerd en het minder 
hoofdpijn veroorzaakt. Wellicht dat het mogelijk is een bashprompt te
krijgen zonder alles te installeren wat ik hierin vermeld. Ik wilde echter
een basissysteem beschrijven waarop makkelijk kan worden verder gebouwd,
zonder lelijke oplossingen.
In een van de init-scripts bijvoorbeeld wordt gebruik gemaakt van awk.
(Maak je geen zorgen als je niet weet wat awk is). In plaats van dit
uit het script te hacken, besloot ik gewoon awk te installeren.
</p>

<p>
Ik raad je aan eerst de hoofdtekst van iedere sectie te lezen, waarbij je
de oefeningen en referenties overslaat.
Neem dan een beslissing tot hoever je je begrip wilt ontwikkelen, en hoeveel
moeite je bereid bent er in te steken. Begin dan weer bij
het begin, maak onderwijl de oefeningen en lees de extra leesstof.
</p>
</sect>


<sect><heading>Hardware</heading>
<p>
Wanneer je voor het eerst je computer aanzet, test het zichzelf om er zeker
van te zijn dat alles juist werkt. Dit wordt de ``Power on self test'' 
genoemd. Dat zoekt een programma te vinden in het ROM BIOS, genaamd de
bootstrap loader naar een bootsector. Een bootsector is de eerste sector van
een disk en het bevat een klein programma dat een besturingssysteem kan laden.
Bootsectors zijn met een magic nummer 0xAA55 = 43603 op byte 0x1FE = 500
gemarkeerd. Zo kan de hardware vertellen of de sector een bootsector is of
niet.
</p>

<p>
De bootstrap loader bevat een lijst met lokaties waar het op zoek kan gaan
naar een bootsector. Mijn oude machine kijkt eerst op de diskette in het
primaire diskettestation, dan op de primaire harddisk. Modernere
machines zijn ook in staat naar een bootsector op een CD-ROM te zoeken.
Treft het een bootsector aan, dan laadt het deze in het geheugen en geeft
het de besturing door aan het programma dat het besturingssysteem laadt.
Op een typisch Linux systeem, is dit LILO's eerste fase bootloader.
Er zijn echter veel verschillende manieren waarop je systeem kan worden
ingesteld hoe het boot. Zie de <EM>LILO User's Guide</EM> voor details. 
Zie sectie <REF ID="lilo-links" NAME="LILO"> voor een URL.
</p>

<p>
Uiteraard valt er heel wat meer te zeggen over wat PC-hardware doet. Maar dit
is daar niet de plek voor. Zie &eacute;&eacute;n van de vele goede boeken
over PC-hardware.
</p>

<sect1><heading>Configuratie</heading>
<p>
De computer bewaart wat informatie over zichzelf in CMOS. Hieronder vallen
welke disks en RAM zich in het systeem bevinden.
De BIOS van de computer bevat een programma waarmee je deze instellingen kunt
wijzigen. Bekijk de meldingen op je scherm als de computer is aangezet
om te kunnen zien hoe je er toegang toe kunt krijgen. Op mijn computer druk je
de delete-toets in voordat het 't besturingssysteem begint te laden.
</p>
</sect1>

<sect1><heading>Oefeningen<label id="hardware-ex"></heading>
<p>
Een goede manier om over PC-hardware te leren is een computer bestaande uit
tweedehands onderdelen te bouwen. Zorg dat je op z'n minst aan een 386'r komt
zodat je er makkelijk Linux op kunt draaien.
Het zal niet veel kosten. Vraag eens rond, misschien dat iemand je wat
onderdelen kan geven die je kunt gebruiken.
</p>

<p>
Download, compileer en maak een bootdisk voor
<URL URL="http://www.unios.org" NAME=Unios>. Dit is gewoon een opstartbaar
"Hello World!" programma, bestaande uit slechts meer dan 100 regels
assembleercode. Het is goed te zien hoe het wordt geconverteerd naar een
formaat dat de GNU assembler <tt>as</tt> begrijpt.
</p>

<p>
Bekijk de broncode van LILO's bootloader.
</p>
</sect1>

<sect1><heading>Meer informatie</heading>
<p>
<itemize>
<item><EM>De Unix and Internet Fundamentals HOWTO</EM>, door Eric S. Raymond,
<URL URL="http://mirror.aarnet.edu.au/linux/LDP/HOWTO/Unix-Internet-Fundamentals-HOWTO.html">
vooral sectie 3, <em>Wat gebeurt er als je de computer aanzet?</em>
</item>

<item>Het eerste hoofdstuk van <EM>De LILO User's Guide</EM> geeft een 
uitstekende uitleg over PC disk-partities en het booten.
Zie <REF ID="lilo-links" NAME="LILO"> voor een URL.
</item>

<item><EM>De NIEUWE Peter Norton Programmer's Guide to the IBM PC & PS/2</EM>, 
van Peter Norton en Richard Wilton, Microsoft Press 1988 
Er is een nieuwer Norton-boek, het ziet er goed uit, maar ik kan het me
op 't moment niet veroorloven!
</item>

<item>&Eacute;&eacute;n van de vele beschikbare boeken over het upgraden
van PC's.
</item>
</itemize>
</p>
</sect1>
</sect>

<sect><heading>Lilo</heading>
<p>
Wanneer de computer op een normaal Linux systeem een bootsector laadt,
laadt het in feite een deel van lilo, genaamd de ``eerste fase bootloader''.
Dit is een klein programma met als taak het laden en opstarten van
de ``tweede fase bootloader''.
</p>

<p>
De tweede fase loader geeft je een prompt (als het op deze wijze werd 
ge&iuml;nstalleerd) en laadt het gekozen besturingssysteem.
</p>

<p>
Wanneer je systeem beschikbaar en werkend is, en je <tt>lilo</tt> uitvoert,
ben je in feite de ``map installer'' aan het uitvoeren.
Dit leest het configuratiebestand <tt>/etc/lilo.conf</tt> in en het 
schrijft de bootloaders en informatie over de besturingssystemen die het 
kan laden naar de harddisk.
</p>

<p>
Er zijn veel verschillende manieren om in te stellen hoe je systeem boot.
Wat ik zojuist heb uitgelegd is de meest vanzelfsprekende en ``normale''
manier, in ieder geval voor een systeem met als hoofdbesturingssysteem Linux.
In de Lilo Users' Guide worden verscheidene voorbeelden gegeven van
``bootconcepten''. Het is het lezen waard en er wat van uit te proberen.
</p>

<sect1><heading>Configuratie</heading>
<p>
Het configuratiebestand voor lilo is <tt>/etc/lilo.conf</tt>. Hier bestaat
een manual page voor: typ <tt>man lilo.conf</tt> in een shell om het te
bekijken. Het belangrijkste in lilo.conf is een record voor hetgeen
lilo is ingesteld te booten. Voor een Linux record, houdt dit in waar
de kernel is te vinden, en welke diskpartitie te mounten als het
root bestandssysteem. Bij andere besturingssystemen is de belangrijkste
informatie vanaf welke partitie te booten.
</p>
</sect1>


<sect1><heading>Oefeningen</heading>
<p>
<EM>GEVAARLIJK:</EM> wees voorzichtig bij deze oefeningen. 
Er gaat makkelijk iets mis en het is niet moeilijk je masterbootrecord
te ru&iuml;neren en je systeem onbruikbaar te maken.
Zorg dat je een werkende rescuedisk bij de hand hebt, en weet hoe het
te gebruiken om fouten te corrigeren. Zie verderop voor een link naar
tomsrtbt, de rescuedisk die ik gebruik en je kan aanbevelen. De beste
voorzorgsmaatregel is een machine te gebruiken die er niet toe doet.
</p>

<p>
Stel lilo in op een diskette. Het doet er niet toe als er niets anders
op de diskette staat dan een kernel, je zult een ``kernel panic'' krijgen
wanneer de kernel zover is dat het init laadt, maar dan weet je in ieder
geval of lilo werkt.
</p>

<p>
Als je wilt kun je aandringen en bekijken hoeveel van een systeem je
op de diskette aan de gang krijgt. Dit is waarschijnlijk de tweede beste
Linux leeractiviteit.
Zie de Bootdisk HOWTO (url verderop), en tomsrtbt (url verderop) 
voor aanwijzingen.
</p>

<p>
Laat lilo unios booten (zie sectie <REF ID="hardware-ex" NAME="hardware
exercises"> voor een URL). Als extra uitdaging kun je kijken of je dit op 
een diskette kunt doen.
</p>

<p>
Maak een boot-loop. Plaats lilo in het masterbootrecord om lilo te laten
booten in &eacute;&eacute;n van de primaire partitiebootsectoren, en
laat dat lilo booten in het masterbootrecord... Of gebruik wellicht
het masterbootrecord en alle vier primaire partities om een vijfpunts
loop te maken. Leuk!
</p>
</sect1>

<sect1><heading>Meer informatie<label id="lilo-links"></heading>
<p>
<itemize>
<item>De lilo man page. 
</item>
<item>Lilo <URL URL="ftp://lrcftp.epfl.ch/pub/linux/local/lilo/" 
	NAME="download">,
	Australi&euml; <URL URL="ftp://mirror.aarnet.edu.au/pub/linux/metalab/system/boot/lilo/"
	NAME="mirror">.
	Deze directory's bevatten ook de ``LILO User's Guide'' 
	<tt>lilo-u-21.ps.gz</tt> (of een latere versie).
	Je hebt dit document wellicht al.
	Kijk in <tt>/usr/doc/lilo</tt> of daar in de buurt.
	De postscriptversie is beter dan de tekstversie,
	aangezien er diagrammen en tabellen in staan.
</item>
<item><URL URL="http://www.toms.net/rb" NAME="tomsrtbt"> de meest geweldig
linux op een enkele diskette. Is een geweldige nooddisk.
</item>
<item><URL URL="http://mirror.aarnet.edu.au/linux/LDP/HOWTO/Bootdisk-HOWTO.html"
	 NAME="De Bootdisk HOWTO"> 
</item>
</itemize>
</p>
</sect1>
</sect>

<sect><heading>De Linux Kernel</heading>
<p>
De kernel doet tamelijk veel. Ik denk dat een duidelijke manier om het
samen te vatten is dat het de hardware eerlijk en effici&euml;nt laat doen 
wat de programma's willen.
</p>

<p>
De processor kan slechts &eacute;&eacute;n instructie per keer uitvoeren,
maar Linux systemen lijken veel dingen gelijktijdig uit te voeren.
De kernel bereikt dit door heel snel van de ene naar de andere taak
over te schakelen.  Het maakt zo goed mogelijk gebruik van de processor
door bij te houden welke processen klaar zijn om te gaan, en welke op iets
wachten zoals een record uit een harddiskbestand, of toetsenbordinvoer.
Deze taak van de kernel wordt scheduling genoemd.
</p>

<p>
Als een programma niet iets doet, dan hoeft het niet in RAM te zijn geladen.
Zelfs als een programma iets doet, dan kan het zijn dat er onderdelen van
niet iets doen. De adresruimte van elk proces is in pagina's onderverdeeld.
De kernel houdt bij welke pagina's van welke processen het meeste worden
gebruikt. De pagina's die niet veel worden gebruikt, kunnen worden verplaatst
naar de swappartitie. Wanneer ze weer nodig zijn, kan een andere ongebruikte
pagina worden verplaatst om ruimte vrij te maken. Dit is het virtueel
geheugenbeheer.
</p>

<p>
Als je ooit je eigen kernel compileerde, dan zal je zijn opgevallen dat
er erg veel opties voor specifieke devices zijn. De kernel bevat een heleboel
specifieke code om met de diverse soorten hardware te communiceren, 
en presenteert het allemaal op een fraaie uniforme wijze aan de 
toepassingsprogramma's.
</p>

<p>
De kernel beheert ook het bestandssysteem, interprocescommunicatie, 
en een heleboel networking stuff.
</p>

<p>
Zodra de kernel is geladen, zoekt het als eerste naar een uit te voeren
<tt>init</tt> programma.
</p>

<sect1><heading>Configuratie</heading>
<p>
De meeste configuratie van de kernel wordt tijdens het bouwen gedaan met
behulp van
<tt>make menuconfig</tt>, of <tt>make xconfig</tt> in <tt>/usr/src/linux/</tt>
(of waar je Linux kernelbroncode dan ook is). Je kunt met <tt>rdev</tt>
de standaardvideomodus, het root bestandssysteem, het swapdevice en de RAM
diskomvang resetten. Deze parameters en nog anderen kunnen ook via lilo aan de
kernel worden doorgegeven. Je kunt lilo parameters om aan de kernel door
te geven in lilo.conf of achter de liloprompt opgeven.
Als je bijvoorbeeld wilde dat hda3 als je root bestandssysteem zou worden
gebruikt in plaats van hda2, dan zou je kunnen typen:
</p>

<p>
<verb>
	LILO: linux root=/dev/hda3
</verb>

</p>

<p>
Als je een systeem vanaf de broncode opbouwt, dan kun je het jezelf er een
stuk simpeler op maken door een ``monolithic'' kernel te cre&euml;eren.
Dat is een kernel zonder modules.
Dan hoef je geen kernelmodules naar het doelsysteem te kopi&euml;ren.
</p>

<p>
NOOT: Het <tt>System.map</tt> bestand wordt door de kernellogger gebruikt
de module namen die meldingen genereren vast te stellen.
Het programma <tt>top</tt> maakt ook
gebruik van deze informatie. Kopieer <tt>System.map</tt> mee wanneer je 
de kernel naar het doelsysteem kopieert.
</p>
</sect1>

<sect1><heading>Oefeningen</heading>
<p>Denk hier over na: <tt>/dev/hda3</tt> is een speciaal type bestand dat
een harddiskpartitie beschrijft. Maar het is net als alle andere bestanden
te vinden op een bestandssysteem. De kernel wil weten welke partitie te
mounten als het rootbestandssysteem, het heeft nog geen bestandssysteem.
Dus hoe kan het /dev/hda3 lezen om erachter te komen welke partitie te mounten?
</p>

<p>
Bouw je eigen kernel als je dit nog niet hebt gedaan: Lees bij elke optie de
helpinformatie.
</p>

<p>
Kijk hoe klein je een kernel kunt maken die nog steeds werkt. Je kunt
heel veel leren door er de verkeerde dingen uit te laten!
</p>

<p>
Lees ``De Linux Kernel'' (URL verderop) en als je dat doet, zoek dan naar
de delen van de kernelbroncode waarnaar het verwijst. Het boek refereert
(tijdens dit schrijven) naar kernelversie 2.0.33, welke tamelijk oud is.
Het is wellicht makkelijker te volgen als je deze oude versie download
en die broncode leest. Het is verbazingwekkend stukjes C code aan te treffen
genaamd ``process'' en ``page''.
</p>

<p>
Hack! Kijk of je het wat extra meldingen kan laten genereren of iets 
dergelijks.
</p>
</sect1>

<sect1><heading>Meer informatie</heading>
<p>
<label id="Kernel">
<itemize>
<item><tt>/usr/src/linux/README</tt> en de inhoud van 
	<tt>/usr/src/linux/Documentation/</tt> 
	(Het kan zijn dat deze op een andere lokatie op je systeem zijn
         te vinden)
</item>
<item> <URL URL="http://mirror.aarnet.edu.au/linux/LDP/HOWTO/Kernel-HOWTO.html"
	 NAME="De Kernel HOWTO"> 
</item>
<item>De help die beschikbaar is wanneer je een kernel configureert met
	<tt>make menuconfig</tt> of <tt>make xconfig</tt> 
</item>
<item> <URL URL="http://mirror.aarnet.edu.au/linux/LDP/LDP/" 
	NAME="De Linux Kernel (en andere LDP Guides)">
</item>
<item> Kernel source download - Australi&euml;
	<URL URL="http://kernel.mirror.aarnet.edu.au/pub/linux/kernel/" 
	NAME="mirror"> 
</item>
<item>De Linux Kernel 
	<URL URL="http://www.kernel.org" NAME="home page">
	<URL URL="ftp://ftp.kernel.org/pub/linux/kernel" NAME="download">
	Gebruik &eacute;&eacute;n van de weergegeven mirrors op 
<tt>kernel.org</tt>, want ze zijn altijd overbelast.
</item>
</itemize>
</p>
</sect1>
</sect>

<sect><heading>De GNU C Library</heading>
<p>
Het volgende wat er gebeurt als je computer opstart is dat init wordt
geladen en uitgevoerd. Echter init maakt zoals bijna alle programma's
gebruik van functies uit library's.
</p>
<p>
Je hebt wellicht al eens een voorbeeldprogramma in C zoals het volgende gezien:
</p>
<p>
<verb>
	main() {
        	printf("Hello World!\n");
	}
</verb>

Het programma bevat geen definitie van <tt>printf</tt>, dus waar komt het
vandaan? Het komt uit de standaard C library's, op een GNU/Linux systeem, glibc.
Als je het onder Visual C++ compileert, dan komt het uit een Microsoft
implementatie met dezelfde standaardfuncties. Er zijn een onbepaald groot
aantal van dergelijke standaardfuncties, voor berekeningen, tekenreeksen,
datums/tijden, geheugentoekenning, enzovoort.
Alles onder Unix (inclusief Linux) is of geschreven in C of heeft met veel
moeite getracht het voor te doen alsof het zo is, dus iedereen maakt gebruik 
van deze functies.
</p>
<p>	
Als je op je Linux systeem in <tt>/lib</tt> kijkt, dan zie je heel veel
bestanden met de naam <tt>lib-en-nog-wat.so</tt> of <tt>lib-en-nog-wat.a</tt> 
enz. Het zijn library's met deze functies. Glibc is gewoon de GNU implementatie
van deze functies.
</p>
<p>
Er zijn twee manieren waarop programma's deze libraryfuncties kunnen
gebruiken. Als je een programma <em>statisch</em> linkt, dan worden
deze libraryfuncties gekopieerd in het uitvoerbare bestand dat wordt
aangemaakt. Hier zijn de <tt>lib-en-nog-wat.a</tt> library's voor.
Link je een programma <em>dynamisch</em> (wat standaard gebeurt), dan
wordt de librarycode aangeroepen door het programma zodra het programma
deze code nodig heeft. Het wordt dan aangeroepen uit het 
<tt>lib-en-nog-wat.so</tt> bestand.
</p>

<p>
De opdracht <tt>ldd</tt> is je vriend wanneer je erachter wilt zien te
komen welke library's nodig zijn voor een bepaald programma.
Hier zijn bijvoorbeeld de library's waar <tt>bash</tt> gebruik van maakt:
</p>
<p>
<verb>
	[greg@Curry power2bash]$ ldd /bin/bash
        	libtermcap.so.2 => /lib/libtermcap.so.2 (0x40019000)
        	libc.so.6 => /lib/libc.so.6 (0x4001d000)
        	/lib/ld-linux.so.2 => /lib/ld-linux.so.2 (0x40000000)
</verb>
</p>

<sect1><heading>Configuratie</heading>
<p>
De werking van een aantal functies in de library's hangen af van waar je 
je bevindt. In Australi&euml; schrijven we de datum bijvoorbeeld in de 
opmaak dd/mm/yy, maar Amerikanen schrijven het als mm/dd/yy. Er wordt een
programma meegeleverd met de <tt>glibc</tt> distributie genaamd 
<tt>localedef</tt> die het je mogelijk maakt dit in te stellen.
</p>
</sect1>

<sect1><heading>Oefeningen</heading>
<p>
Gebruik <tt>ldd</tt> om uit te zoeken welke library's je favoriete toepassingen
gebruiken.
</p>
<p>
Gebruik <tt>ldd</tt> om uit te zoeken welke library's <tt>init</tt> gebruikt.
</p>
<p>
Maak een library om mee te spelen, met daarin slechts &eacute;&eacute;n 
of twee functies. Het programma <tt>ar</tt> wordt gebruikt om ze aan te maken, 
de manpage van <tt>ar</tt> is wellicht een goed begin om te onderzoeken hoe
dit werkt. Schrijf, compileer en link een programma dat gebruik maakt van
deze library.
</p>
</sect1>

<sect1><heading>Meer informatie</heading>
<p>
<itemize>
<item>Australi&euml; GNU libc 
	<URL URL="http://mirror.aarnet.edu.au/pub/gnu/glibc"
	NAME="mirror">. Je zult ook de linuxthreads en libcrypt addons nodig
hebben. Als libcrypt niet voorkomt, dan is dit vanwege een of andere
US exportwet. Er is dan een README of iets dergelijks waarin wordt aangegeven waar je het vandaan kunt halen.
</item>
<item>Australi&euml; GNU ncurses
	<URL URL="http://mirror.aarnet.edu.au/pub/gnu/ncurses"
	NAME="mirror">. Ncurses is een library die voorziet in een boek
tekstscherm mogelijkheden. Het bevat de  terminfo database, welke het termcap
bestand vervangt. Je kan (en zou waarschijnlijk) ncurses kunnen compileren als
een glibc addon.
</item>	
</itemize>
</p>
</sect1>
</sect>


<sect><heading>Init</heading>
<p>
Ik zal hier alleen de ``System V'' stijl van init behandelen die door de
meeste Linux systemen wordt gebruikt.
Er zijn alternatieven. In wezen kun je elk programma dat je wilt in
<tt>/sbin/init</tt> plaatsen, en de kernel zat dit uitvoeren zodra het
is geladen.
</p>
<p>
Het is de taak van init alles werkend te krijgen zoals het zou moeten.
Het controleert of bestandssystemen in orde zijn en mount ze. Het start
de ``daemons'' voor het loggen van systeemmeldingen, uitvoeren van
netwerkzaken, leveren van webpages, luisteren naar je muis, enzovoort.
Het start tevens de getty processen die de loginprompts op je virtuele
terminals plaatsen.
</p>
<p>
Er bestaat een heel gecompliceerd verhaal over het schakelen tussen
``runlevels'', maar
dat sla ik grotendeels over, en ga het slechts hebben over de systeemstart.
</p>
<p>
Init leest het bestand <tt>/etc/inittab</tt>, waarin staat wat het moet doen.
Als eerste zal het een initialisatiescript draaien.
Het programma dat dit script uitvoert (of interpreteert) is <tt>bash</tt>,
hetzelfde programma dat je een opdrachtprompt geeft.
Onder Debian systemen is <tt>/etc/init.d/rcS</tt> het initialisatiescript, 
onder Red Hat is dit <tt>/etc/rc.d/rc.sysinit</tt>. Hierin staan de
opdrachten om de bestandssystemen te controleren en te mounten, de klok
in te stellen, swapspace te activeren, de hostnaam in te stellen, enzovoort.
</p>
<p>
Vervolgens wordt een ander script aangeroepen om ons in het
standaard runlevel te brengen. Dit betekent dat een set subsystemen zal
worden opgestart. In RedHat bestaan hiervoor een aantal directory's, te weten
<tt>/etc/rc.d/rc0.d</tt>, <tt>/etc/rc.d/rc1.d</tt>, ..., 
<tt>/etc/rc.d/rc6.d</tt> in Red Hat, of <tt>/etc/rc0.d</tt>,
<tt>/etc/rc1.d</tt>, ..., <tt>/etc/rc6.d</tt> onder Debian, welke
met de runlevels corresponderen. Als we op een Debian-systeem runlevel 3
ingaan, dan voert het script alle scripts uit in
<tt>/etc/rc3.d</tt> die met een `S' (voor start) beginnen.
Deze scripts bestaat in werkelijkheid uit verwijzingen naar scripts in
een andere directory gewoonlijk met de naam <tt>init.d</tt>. 
</p>
<p>
Dus ons runlevel script werd door init aangeroepen, en het zoekt naar scripts
beginnend met een `S' in een directory. Wellicht dat het als eerste
<tt>S10syslog</tt> aantreft. De getallen vertellen het runlevelscript 
in welke volgorde ze uit te voeren. Dus in dit geval wordt <tt>S10syslog</tt> 
als eerste uitgevoerd, gezien er verder geen scripts meer zijn die
beginnen met S00...S09. Maar <tt>S10syslog</tt> is in werkelijkheid een
link naar <tt>/etc/init.d/syslog</tt>, een script om de systeemlogger
te starten en stoppen. Omdat de link met een `S' begint, weet het
<tt>syslog</tt> script dat het moet starten met de ``start'' parameter.
Er bestaan tevens corresponderende links beginnend met een `K', waarmee
wordt aangegeven af te sluiten en in welke volgorde het runlevel te verlaten.
</p>
<p>
Om te wijzigen welke subsystemen standaard opstarten, moet je deze links
in de directory <tt>rcN.d</tt> instellen, waarbij N het
standardrunlevel is, ingesteld in het bestand <tt>inittab</tt>.
</p>
<p>
Een laatste belangrijke taak van init is het opstarten van een aantal
<tt>getty</tt>'s.
Ze staan ingesteld als ``respawned'' wat betekent dat als ze stoppen, 
<tt>init</tt> ze gewoon weer start. De meeste distributies worden opgeleverd 
met zes virtuele terminals. Je kunt om geheugen te besparen er hier wellicht 
minder van instellen, of juist meer zodat je meer actief kunnen hebben en hier
snel tussen kunt schakelen als je het nodig hebt. Je kunt tevens een getty
voor een tekstterminal of een inbelmodem willen hebben draaien.
In dat geval zul je het bestand <tt>inittab</tt> moeten bewerken.
</p>


<sect1><heading>Configuratie</heading>
<p>
<tt>/etc/inittab</tt> is het configuratiebestand voor init.

De directory's <tt>rcN.d</tt>, waarbij N = 0, 1, ..., 6 bepalen welke
subsystemen worden opgestart.
</p>

<p>
Ergens in een van de scripts aangeroepen door init, zal de opdracht
<tt>mount -a</tt> worden uitgevoerd. Hiermee worden alle bestandssystemen
gemount die verondersteld worden te worden gemount. Het bestand
<tt>/etc/fstab</tt> definieert wat is verondersteld te worden gemount.
Als je wilt wijzigen wat wordt gemount wanneer je systeem opstart, dan zul
je dit bestand moeten bewerken. Er bestaat een manpage voor <tt>fstab</tt>.
</p>
</sect1>

<sect1><heading>Oefeningen</heading>
<p>
Zoek naar de directory <tt>rcN.d</tt> voor het standaard runlevel
van je systeem en geef de opdracht <tt>ls -l</tt> om te bekijken waarnaar
de links verwijzen.
</p>

<p>
Wijzig het aantal getty's dat op je systeem draait.
</p>

<p>
Verwijder alle subsystemen uit de directory van het standaardrunlevel
die je niet nodig hebt.
</p>

<p>
Kijk met hoe weinig je op kunt starten.
</p>

<p>
Maak een diskette met lilo, een kernel en een statisch gelinkt
"hello world" programma genaamd <tt>/sbin/init</tt> en bekijk het booten
en "hello world" zeggen.
</p>

<p>
Bekijk het zorgvuldig als je systeem opstart, en maak notities over wat het
je vertelt wat er gebeurt. Of druk een deel af van je systeemlog
<tt>/var/log/messages</tt> van de systeemstart. Dan beginnend bij
<tt>inittab</tt>, doorloop alle scripts en bekijk welk code wat doet.
Je kunt er ook extra opstartmeldingen inplaatsen, zoals


<verb>
	echo "Hello, ik ben rc.sysinit"
</verb>

Dit is tevens een goede oefening in het leren schrijven van Bash-scripts,
een aantal van de scripts zijn nogal gecompliceerd. Houd een goede
Bash-referentie bij de hand.
</p>
</sect1>

<sect1><heading>Meer informatie</heading>
<p>
<itemize>
<item>Australi&euml; Sys V init 
	<URL URL="http://mirror.aarnet.edu.au/pub/linux/metalab/system/daemons/init"
 	 NAME="mirror"> 
</item>
<item>Sys V init 
	<URL URL="http://sunsite.unc.edu/pub/Linux/system/daemons/init"
 	 NAME="download"> 
</item>
<item>Er zijn manpages voor de bestanden <tt>inittab</tt> en <tt>fstab</tt>.
	Typ (bv) <tt>man inittab</tt> in een shell en bekijk het.
</item>
<item>De Linux System Administrators Guide bevat een prima
	<URL URL="http://mirror.aarnet.edu.au/linux/LDP/LDP/" 
	NAME="sectie"> over init.
</item>
</itemize>
</p>
</sect1>
</sect>

<sect><heading>Het bestandssysteem</heading>
<p>
In deze sectie zal ik het woord ``bestandssysteem'' op twee verschillende
manieren gebruiken. Je hebt bestandssystemen op diskpartities en andere
devices,
en je hebt het bestandssysteem zoals het wordt gepresenteerd door een
draaiend Linux systeem. Onder Linux, ``koppel'' je een diskbestandssysteem
aan het bestandssysteem van het systeem.
</p>

<p>
In de vorige sectie gaf ik al aan dat initscripts de bestandssystemen
controleren en mounten. De opdrachten die dit doen zijn respectievelijk
<tt>fsck</tt> en <tt>mount</tt>.
</p>


<p>
Een harddisk bestaat uit &eacute;&eacute;n grote ruimte welke je met
enen en nullen kunt beschrijven. Een bestandssysteem legt hier een structuur
op aan, en maakt het lijken als bestanden binnen directory's binnen 
directory's... Elk bestand wordt voorgesteld door een inode,
wat aangeeft van wie het bestand is, wanneer het werd aangemaakt en waar de
inhoud is te vinden. Ook directory's worden voorgesteld door inodes, maar
deze geven aan waar de inodes van de bestanden te vinden in die directory.
Als het systeem <tt>/home/greg/bigboobs.jpeg</tt> wil inlezen, dan zoekt het
eerst naar de inode voor de rootdirectory <tt>/</tt> in het ``superblock'', 
dan zoekt het naar de inode voor de directory
<tt>home</tt> in de inhoud van <tt>/</tt>, vervolgens zoekt het naar de
inode voor de directory <tt>greg</tt>, dan de inode voor 
<tt>bigboobs.jpeg</tt> wat het zal aangeven welke diskblokken in te lezen.
</p>

<p>
Als we wat data aan het einde van een bestand toevoegen, kan het gebeuren
dat de data is geschreven nog voor de inode is bijgewerkt om aan te geven dat
de nieuwe blokken toebehoren aan het bestand, of vice versa. Als op dat moment
de stroom uitvalt, zal het bestandssysteem beschadigd zijn. Dit is wat
<tt>fsck</tt> tracht te detecteren en repareren.
</p>

<p>
De opdracht mount accepteert een bestandssysteem op een device, en voegt het
toe aan de hi&euml;rarchie die je ziet wanneer je het systeem gebruikt.
Gewoonlijk mount de kernel zijn root bestandssysteem voor alleen-lezen.
De opdracht mount wordt gebruikt om het opnieuw te mounten voor 
lezen en schrijven nadat <tt>fsck</tt> heeft gecontroleerd dat het in orde is.
</p>

<p>
Linux biedt ook ondersteuning voor andere soorten bestandssystemen:
msdos, vfat, minix enzovoort. De details van het specifieke soort
bestandssysteem zijn afgeleid door het virtuele
file system (VFS). Ik zal hier echter niet in detail op ingaan.
Het wordt besproken in ``De Linux Kernel'' 
(zie <REF ID="Kernel" NAME="De Linux Kernel"> voor een url)
</p>

<sect1><heading>Configuratie</heading>
<p>
Er zijn parameters voor de opdracht <tt>mke2fs</tt> waarmee ext2
bestandssystemen kunnen worden aangemaakt. Deze besturen de omvang
van de blokken, het aantal inodes, enzovoort. Kijk in de manpage van
<tt>mke2fs</tt> voor verdere details.
</p>
<p>
Wat waar op je bestandssysteem wordt gemount, wordt bestuurd door het
bestand <tt>/etc/fstab</tt>. Ook hier is een manpage voor.
</p>
</sect1>

<sect1><heading>Oefeningen</heading>
<p>
Maak een zeer klein bestandssysteem aan, en bekijk het met een hex-viewer.
Identificeer inodes, superblocks en bestandsinhoud.
</p>

<p>
Ik meen dat er tools bestaan die je een bestandssysteem grafisch tonen.
Zoek er naar &eacute;&eacute;n, probeer het uit en email me de url
en een voorbeschouwing!
</p>

<p>
Bekijk de code in de kernel van het ext2 bestandssysteem.
</p>
</sect1>

<sect1><heading>Meer informatie</heading>
<p>
<itemize>
<item>In hoofdstuk 9 van het LDP boek ``De Linux Kernel'' staat een
uitstekende beschrijving van bestandssystemen. Je kunt het vinden
	op de Australische LDP
	<URL URL="http://mirror.aarnet.edu.au/linux/LDP/LDP/" 
	NAME="mirror">
</item>
<item>De opdracht <tt>mount</tt> maakt onderdeel uit van het pakket
util-linux, er staat een link in naar 
	<REF ID="util-linux" NAME="Login en Getty">.
</item>
<item>manpages voor <tt>mount</tt>, <tt>fstab</tt>, <tt>fsck</tt> en 
<tt>mke2fs</tt>
</item>
<item>EXT2 File System Utilities
	<URL URL="http://web.mit.edu/tytso/www/linux/e2fsprogs.html"
	NAME="ext2fsprogs"> home page
	<URL URL="ftp://mirror.aarnet.edu.au/pub/linux/metalab/system/filesystems/ext2/"
	NAME="ext2fsprogs"> Australische mirror. 
Daar is ook nog een document Ext2fs-overview te vinden. Het is echter
verouderd en niet zo leesbaar als hoofdstuk 9 van ``De Linux Kernel''. 
</item>
<item> <URL URL="ftp://mirror.aarnet.edu.au/pub/linux/metalab/system/admin/"
	NAME="MAKEDEV"> Dit is een script om alle stuurbestanden in
	<tt>/dev</tt> aan te maken.
</item>
<item> <label ID="FHS">
	<URL URL="ftp://tsx-11.mit.edu/pub/linux/docs/linux-standards/fsstnd/" 
	NAME="Unix File System Standard"> Hierin wordt beschreven wat 
op een Unix bestandssysteem waar thuishoort, en waarom dit zo is.
	Hierin staan ook de minimumvereisten voor de inhoud van 
<tt>/bin</tt>, <tt>/sbin</tt> enzovoort in. Dit is een prima referentie
	als je doel het maken van een minimaal maar compleet systeem is.
</item>
</itemize>
</p>
</sect1>
</sect>

<sect><heading>Kernel Daemons</heading>
<p>
Helaas bevat deze sectie meer vermoedens en vragen dan feiten.
Misschien dat je kunt helpen?
</p>
<p>
Als je de opdracht <tt>ps aux</tt> aanroept, dan zul je iets te zien
krijgen als het volgende:
</p>
<p>
<verb>
USER       PID %CPU %MEM  SIZE   RSS ttY STAT START   TIME COMMAND
root         1  0.1  8.0  1284   536   ? S    07:37   0:04 init [2] 
root         2  0.0  0.0     0     0   ? SW   07:37   0:00 (kflushd)
root         3  0.0  0.0     0     0   ? SW   07:37   0:00 (kupdate)
root         4  0.0  0.0     0     0   ? SW   07:37   0:00 (kpiod)
root         5  0.0  0.0     0     0   ? SW   07:37   0:00 (kswapd)
root        52  0.0 10.7  1552   716   ? S    07:38   0:01 syslogd -m 0 
root        54  0.0  7.1  1276   480   ? S    07:38   0:00 klogd 
root        56  0.3 17.3  2232  1156   1 S    07:38   0:13 -bash 
root        57  0.0  7.1  1272   480   2 S    07:38   0:01 /sbin/agetty 38400 tt
root        64  0.1  7.2  1272   484  S1 S    08:16   0:01 /sbin/agetty -L ttyS1
root        70  0.0 10.6  1472   708   1 R   Sep 11   0:01 ps aux 
</verb>
</p>
<p>
Dit is een lijst met de processen die op het systeem draaien.
Hiervan is <tt>init</tt> procesnummer &eacute;&eacute;n. De processen
2, 3, 4 en 5 zijn kflushd, kupdate, kpiod en kswapd. 
Hier doet zich echter iets vreemds voor: merk op dat bij deze processen
in de kolom met de virtuele opslagomvang (SIZE) als ook de werkelijke 
opslagomvang (RSS) een nul staat. Hoe kan een proces geen geheugen gebruiken?
Deze processen maken werkelijk deel uit van de kernel. De kernel staat
helemaal niet in de lijst met processen, en je kunt er alleen achter komen
hoeveel geheugen het gebruikt door het beschikbare geheugen af te trekken
van de hoeveelheid op je systeem. Zouden de haakjes rondom de opdrachtnaam 
kunnen betekenen dat dit kernelprocessen zijn (?).
</p>
<p>
<tt>kswapd</tt> verplaatst delen van programma's die thans niet worden
gebruikt uit de echte opslag (dwz RAM) naar swapspace (dwz harddisk).
 <tt>kflushd</tt> schrijft data vanuit buffers naar disk. Hierdoor draait
het sneller. Wat programma's schrijven kan in het geheugen worden bewaard,
in een buffer, en dan naar disk worden geschreven en grotere effici&euml;ntere
brokken. Ik weet niet waar <tt>kupdate</tt> en <tt>kpiod</tt> voor dienen.
</p>
<p>
Hier eindigt mijn kennis. Wat doen die laatste twee daemons? Waarom krijgen
kerneldaemons expliciete procesnummers in plaats van dat het gewoon
anonieme bits met kernelcode zijn?
Start init ze werkelijk op, of draaien ze al als
init in beeld verschijnt?
</p>
<p>
Ik plaatste een script voor het mounten van <tt>/proc</tt> en uitvoeren van
<tt>ps aux</tt> in <tt>/sbin/init</tt>. Proces 1 was het script zelf, en
de processen 2, 3, 4 en 5 waren de kerneldaemons net als onder de echte
init. De kernel moet deze processen daar plaatsen, omdat mijn script het
beslist niet deed!
</p>

<sect1><heading>Configuratie</heading>
<p>
Ik ben niet bekend met enige configuratie voor deze kerneldaemons.
</p>
</sect1>

<sect1><heading>Oefeningen</heading>
<p>
Zoek uit waar deze processen voor zijn, en schrijf een nieuwe
``Kernel daemons'' sectie voor dit document, en stuur dat naar me op!
</p>
</sect1>

<sect1><heading>Meer informatie</heading>
<p>
De ``Linux Kernel'' van het Linux Documentatie Project (zie 
<REF ID="Kernel" NAME="De Linux Kernel"> voor een url), en de broncode van
de kernel is alles wat ik kan bedenken.
</p>
</sect1>
</sect>

<sect><heading>Systeem Logger</heading>
<p>
Init start de <tt>syslogd</tt> en <tt>klogd</tt> daemons. Ze schrijven
meldingen naar logs. De meldingen van de kernel worden afgehandeld door
<tt>klogd</tt>, terwijl <tt>syslogd</tt> de logmeldingen van andere processen
afhandelt. Het hoofdlog is <tt>/var/log/messages</tt>. Dit is een prima
lokatie om te kijken als er iets misgaat met je systeem. Vaak staat hierin
een waardevolle aanwijzing.
</p>

<sect1><heading>Configuratie</heading>
<p>
Het bestand <tt>/etc/syslog.conf</tt> vertelt de loggers welke meldingen
waar te plaatsen. Meldingen worden ge&iuml;dentificeerd door waar
ze vandaan komen en welk prioriteitenniveau ze hebben. Dit configuratiebestand
bestaat uit regels waarin staat aangegeven dat meldingen van stel
service x met prioriteit y naar z gaan, waarbij z een bestand, tty, printer,
remote host of iets dergelijks is.
</p>

<p>
NOOT: Syslog vereist dat het bestand <tt>/etc/services</tt> aanwezig is.
Het bestand services kent poorten toe. Ik weet niet zeker of syslog een
toegekende poort nodig heeft, zodat het remote kan loggen, of zelfs dat
het loggen via een poort wordt gedaan.
</p>
</sect1>

<sect1><heading>Oefeningen</heading>
<p>
Bekijk je systeemlog. Zoek naar een melding die je niet begrijpt,
en zoek uit wat het betekent.
</p>
<p>
Stuur al je logmeldingen naar een tty. (zet het terug op de oude instelling
zodra je daarmee klaar bent)
</p>
</sect1>

<sect1><heading>Meer informatie</heading>
<p>Australi&euml; sysklogd <URL URL="http://mirror.aarnet.edu.au/pub/linux/metalab/system/daemons/"
	NAME="Mirror">
</p>
</sect1>
</sect>

<sect><heading>Getty en Login</heading>
<p>
Getty is het programma die het je mogelijk maakt via een serieel device,
zoals een virtuele terminal, een tekstterminal, of een modem in te loggen.
Het toont de loginprompt. Zodra je je gebruikersnaam invoert, overhandigt getty
dit aan <tt>login</tt> die om een wachtwoord vraagt, dit controleert en je 
een shell geeft.
</p>

<p>
Er zijn vele getty's beschikbaar, maar het pakket util-linux, waarin
<tt>login</tt> is opgenomen, heeft er &eacute;&eacute;n met de naam
<tt>agetty</tt>, welk prima werkt. Dit pakket bevat ook
<tt>clock</tt>, <tt>fdformat</tt>, <tt>mkswap</tt>, <tt>fdisk</tt>,
<tt>passwd</tt>, <tt>kill</tt>, <tt>setterm</tt>, <tt>mount</tt>,
<tt>swapon</tt>, <tt>rdev</tt>, <tt>renice</tt>, <tt>hexdump</tt>,
<tt>more</tt> (het programma) en more (dwz meer programma's).
Om het simpel te houden door het aantal pakketten dat je moet installeren
tot een minimum te beperken, raad ik je aan gebruik te maken van
<tt>agetty</tt>.
</p>

<sect1><heading>Configuratie</heading>
<p>
Het bericht dat bovenaan je scherm verschijnt tesamen met je loginprompt
komt uit <tt>/etc/issue</tt>. Getty's worden gewoonlijk gestart vanuit
<tt>/etc/inittab</tt>. Login controleert de gebruikersdetails met
<tt>/etc/passwd</tt>, en als je gebruik maakt van password shadowing,
<tt>/etc/shadow</tt>.
</p>
</sect1>

<sect1><heading>Oefeningen</heading>
<p>
Maak met de hand een <tt>/etc/passwd</tt> bestand aan. 
Wachtwoorden kunnen op null worden ingesteld en gewijzigd met het
programma <tt>passwd</tt> als je eenmaal bent ingelogd. Zie de manpage
van dit bestand, gebruik hiervoor <tt>man 5 passwd</tt> om de manpage
voor het bestand te krijgen in plaats van de manpage voor het programma.
</p>
</sect1>

<sect1><heading>Meer informatie</heading>
<p>
<label ID="util-linux">
Het pakket 	
<URL URL="ftp://mirror.aarnet.edu.au/pub/linux/metalab/system/misc" NAME="util-linux">
	bevat login en agetty, en nog heel wat meer dat je nodig zult hebben.
</p>
<p>Er zijn heel veel andere getty's te vinden op
	<URL URL="ftp://mirror.aarnet.edu.au/pub/linux/metalab/system/serial/getty"
	NAME="Many getty's!">. getty_ps is de meest gebruikelijke, mingetty
is alleen voor virtuele terminals. Echter het pakket util-linux wat je nodig
hebt voor het <tt>inloggen</tt> bevat tevens <tt>agetty</tt> wat prima werkt.
</p>
</sect1>
</sect>

<sect><heading>Bash</heading>
<p>
Als je <tt>login</tt> een geldige gebruikersnaam en wachtwoordcombinatie
geeft, zal het nagaan in <tt>/etc/passwd</tt> welke shell je aan te bieden.
In de meeste gevallen is die op een Linux systeem <tt>bash</tt>. Het is de
taak van <tt>bash</tt> je opdrachten in te lezen en te zien waarop ze moeten
worden toegepast. Het is gelijktijdig een gebruikersinterface en een
programmeertaalinterpreter.
</p>

<p>
Als gebruikersinterface leest het je opdrachten in en voert ze zelf uit als
het ``interne'' opdrachten zijn, zoals <tt>cd</tt>, of zoekt het naar en
voert een programma uit als het ``externe'' opdrachten zijn, zoals
<tt>cp</tt> of <tt>startx</tt>. Het doet ook nog zoiets als
het bijhouden van een opdrachthistory en voltooien van bestandsnamen.
</p>

<p>
We hebben <tt>bash</tt> reeds in actie gezien als programmeertaalinterpreter.
De scripts die <tt>init</tt> uitvoert om het systeem op te starten zijn
gewoonlijk shellscripts, en ze worden door <tt>bash</tt> uitgevoerd.
Een zuivere programmeertaal gecombineerd met de gebruikelijke systeemutility's
beschikbaar op de opdrachtregel maakt het een zeer krachtige combinatie,
als je weet wat je aan het doen bent. Ik moest bijvoorbeeld een boel
``patches'' toepassen op een directory met broncode. Dit lukte met de
volgende opdracht:
</p>

<p>
<verb>
for f in /home/greg/sh-utils-1.16*.patch; do patch -p0 < $f; done;
</verb>
</p>
<p>
Hiermee worden alle bestanden in mijn homedirectory bekeken waarvan de naam
begint met <tt>sh-utils-1.16</tt> en eindigt op <tt>.patch</tt>. 
Het accepteert dan elk hiervan op z'n beurt
en stelt de variabele <tt>f</tt> hierop in en voert de opdrachten
tussen <tt>do</tt> en <tt>done</tt> uit. In dit geval waren er 11 
patch bestanden, maar het hadden er evengoed 3000 kunnen zijn.
</p>

<sect1><heading>Configuratie</heading>
<p>
Het bestand <tt>/etc/profile</tt> bestuurt het systeemomvattende
functioneren van bash. Wat je hierin zet is van invloed op iedereen die
op je systeem gebruik maakt van bash. Het voert zaken uit als het
toevoegen van directory's aan het <tt>PATH</tt>, en het stelt de
<tt>MAIL</tt> directoryvariabele in.
</p>
<p>
Het standaardfunctioneren van het toetsenbord laat vaak veel te wensen over.
In feite is het readline die dit afhandelt. Readline is een apart pakket
dat opdrachtregelinterfaces afhandelt, voorziet in de opdrachthistorie en
bestandsnaamvoltooiing, als ook nog een aantal geavanceerde
regelbewerkingsfeatures. Het is in bash gecompileerd. Standaard is
readline zo geconfigureerd dat het 't bestand <tt>.inputrc</tt> in
je homedirectory gebruikt. De bash-variabele INPUTRC kan worden gebruikt
om dit voor bash te overschrijven. Onder bijvoorbeeld RedHat 6, is
<tt>INPUTRC</tt> in <tt>/etc/profile</tt> ingesteld op <tt>/etc/inputrc</tt>.
Dit betekent dat de backspace, delete, home en end toetsen voor iedereen
goed werken.
</p>

<p>
Zodra bash het systeemomvattende configuratiebestand heeft ingelezen,
zoekt het naar je persoonlijke configuratiebestand. Het controleert je
homedirectory op de bestanden
<tt>.bash_profile</tt>, <tt>.bash_login</tt> en <tt>.profile</tt>. 
Het voert het eerste dat het hiervan vindt, uit. Als je de wijze waarop
bash functioneert voor jezelf wilt wijzigen, zonder deze wijzigingen door
te voeren voor anderen, doe dit dan hier. Bijvoorbeeld: veel toepassingen
maken gebruik van omgevingsvariabelen ter besturing van de wijze waarop
ze werken. Ik heb de variabele <tt>EDITOR</tt> ingesteld op <tt>vi</tt> 
zodat ik vi kan gebruiken in Midnight Commander (een uitstekende
console-gebaseerde bestandsbeheerder) in plaats van de eigen editor.
</p>
</sect1>
<!-- bokkie -->
<sect1><heading>Oefeningen</heading>
<p>
De basisbeginselen van bash zijn makkelijk te leren. 
Maar laat het hier niet bij: er zit flink wat diepgang in.
Leer jezelf de gewoonte aan naar betere manieren op zoek te gaan.
</p>

<p>
Lees shellscripts, en zoek datgene op wat je niet begrijpt.
</p>
</sect1>

<sect1><heading>Meer informatie</heading>
<p>
<itemize>
<item> Australi&euml; Bash <URL URL="http://mirror.aarnet.edu.au/pub/gnu/bash"
	NAME="mirror"> 
</item>
<!-- Bokkie -->
<item>There is a ``Bash Reference Manual'' with this, 
which is comprehensive, but heavy going. 
</item>
<item> Australi&euml; readline <URL URL="http://mirror.aarnet.edu.au/pub/gnu/readline"
	NAME="mirror"> Je zult readline apart moeten downloaden 
((is it an addon type thingy?))
</item>
<item>(bash tutorials? - als er geen in omloop is, stel er dan 
&eacute;&eacute;n samen!)
</item>
<item>Er bestaat een boek over Bash van O'Reilly, ik ben er niet zeker van
of het goed is.
</item>
</itemize>
</p>
</sect1>
</sect>


<sect><heading>Basisopdrachten</heading>
<p>
Het belangrijkste wat je onder Bash doet is het aanroepen van opdrachten.
De meeste opdrachten bestaan uit kleine programma's. Ik zal hier niet al 
te veel over zeggen. Ik heb slechts een opsomming gegeven van de pakketten
die ik nodig had. Ik vrees iets van het spoor te zijn afgeweken in wat
echt nodig was en wat niet. Ik zal dit corrigeren zodra
ik mijn systeem weer heb opgebouwd om dit document te testen. 
Al te veel rommel komt niet in de lijst voor.
Het meeste is toch alleen maar nodig voor een volledig functioneel 
Linux-systeem.
</p>

<p>
Ideaal gezien, zou deze opsomming alle opdrachten moeten bevatten die
zijn gespecificeerd in De Unix <REF ID="FHS" NAME="File Hierarchy Standard"> 
en alles dat nodig is om de basisinitscripts die bij de sysvinit distributie
wordt geleverd.
</p>

<p>
<itemize>
<item>GNU fileutils
	<URL URL="http://mirror.aarnet.edu.au/pub/gnu/fileutils/"
	NAME="fileutils"> opdrachten zoals cp, dd, ls, ln, mkdir enzovoort.
</item>
<item>GNU findutils
	<URL URL="http://mirror.aarnet.edu.au/pub/gnu/findutils/"
	NAME="findutils"> find en locate opdrachten. Find is nodig in een
initscript (controleer dit met je notities).
</item>
<item>textutils? was dat nodig?? het bevat <tt>cat</tt>, wat prettig is
om te hebben, zodat je bestanden kunt bekijken.
</item>
<item>Gawk
	<URL URL="http://mirror.aarnet.edu.au/pub/gnu/gawk/"
	NAME="gawk"> GNU's implementatie van de taal awk. Awk
	is goed voor het verwerken van records in tekstbestanden zoals de
systeemlog. Het is nodig in een initscript (controleer dit met je notities).
</item>
<item>grep
	<URL URL="http://mirror.aarnet.edu.au/pub/gnu/grep/"
	NAME="grep">
	Het is nodig in een initscript (controleer dit met je notities).
</item>
<item>sed?? was dat nodig?? het is een GNU-pakket
</item>
<item><tt>sh-utils</tt> bevat <tt>hostname</tt>, <tt>stty</tt>, <tt>true</tt>,
	<tt>false</tt>, <tt>yes</tt>, <tt>who</tt>, <tt>sleep</tt>
</item>

<item>Net Tools: is waarschijnlijk niet echt nodig, gezien
<tt>hostname</tt> onderdeel uitmaakt van de <tt>sh-utils</tt>
	<URL URL="ftp://mirror.aarnet.edu.au/pub/linux/metalab/?????????????????"
	NAME="net-tools">. Het enig dat je *echt* nodig hebt uit dit pakket,
voor een basissysteemsetup is hostname. Al het andere, zoals ifconfig, netstat,
en route, heb je nodig wanneer je je systeem ergens mee wilt verbinden.
</item>
<item>Monitoren van processen
	<URL URL="ftp://mirror.aarnet.edu.au/pub/linux/metalab/system/status/ps/"
	NAME="procps">. De belangrijkste opdrachten in dit pakket zijn
ps en top. Je kunt hiermee bekijken wat er op je systeem draait. Dit is
nuttig als leeroefening.
</item>
</itemize>
</p>
</sect>

<sect><heading>Software vanuit de broncode opbouwen</heading>
<p>
Tot dusverre heb ik de aandacht gericht op wat de pakketten doen. 
Hier geef ik je wat aanwijzingen over het vanuit de broncode samenstellen
van een minimaal Linux-systeem.
</p>

<sect1><heading>Hoe ik mijn systeem opbouw</heading>
<p>
Er zijn meer manieren om een systeem op te bouwen. Maar de wijze waarop
ik het deed scheen te werken, dus wellicht dat je er iets aan hebt.
</p>

<p>
Ik maakte gebruik van een speciaal daarvoor bestemde machine, een oude
Wang 386sx van vrijwel geen enkele waarde meer. Ik voerde een
installatie van RedHat 6.0 uit als ``bron'' systeem, en kende een
``doel'' partitie toe waarop ik het systeem bouwde. In de oude Wang,
heb ik een 3G harddisk als volgt gepartitioneerd:
</p>

<p>
<verb>
	hda1     480M   waarop ik het systeem bouwde (``doel'')
	hda2      20M   bootpartitie voor het RedHat-systeem
	hda3      50M   swap
	hda4    2500M   extended partitie als hda5
	hda5    2500M   Red Hat 6.0 rootfile system (``bron'')
</verb>	
</p>

<p>
In wezen heeft het niet zoveel zin de logische partitie hda5 hinnen een 
extended partitie, hda4, te hebben. Dat is nu eenmaal wat Disk Druid van
RedHat er tijdens de installatie van maakte. Je hebt slechts het basissysteem
van RedHat nodig, plus nog de development tools en library's. Het nam
ongeveer 250M diskruimte in beslag. Je zou deze oefening uit kunnen voeren
met een 1G disk of 2 disks van 500M.
</p>

<p>
Oudere PC-hardware, voornamelijk 486'rs en eerder, hebben een ergelijke
beperking in hun BIOS. Ze kunnen niet van een harddisk lezen voorbij de
eerste 512M. Voor Linux is dit niet zo'n probleem, omdat het zijn eigen
disk io doet, zodra het is opgestart. Maar om Linux op deze oude machines
te laden, moet het ergens onder die 512M voorkomen. Daarom heb ik zowel de
gehele doelpartitie als de kleine bootpartitie voor het bronsysteem
onder de 512M grens.
</p>

<p>
Wellicht dat je het doelsysteem daadwerkelijk wilt gebruiken, in plaats
van voor het simpelweg bouwen als leerervaring. In dit geval zou je wat
verder moeten gaan dan wat in dit document is beschreven. Je zou 
<tt>gcc</tt> en andere development tools moeten installeren, zodat het 
systeem zichzelf zou kunnen bouwen. Zodra je hiermee klaar bent, zou je
het ``bron''-systeem kunnen verwijderen en deze ruimte op het doel kunnen
gebruiken. Misschien dat je er de <tt>/usr</tt> directory naartoe kunt
kopi&euml;ren.
</p>

<p>
In de Wang zit slechts 8M RAM. Ik denk dat dit de belangrijkste reden
is waarom het compileren van <tt>glibc</tt> 90 uur duurde
Op mijn 486'r met 32M duurde het ``slechts'' 6 uur. Ik gok dat het
24 tot 48 uur geduurd zou hebben als ik 16M in de Wang had.
De compilatie van de kernel duurde ongeveer 8 uur.
</p>

<p>
Ik maakte met <tt>mke2fs</tt> een ext2 bestandssysteem aan op de 
target partitie, en maakte met <tt>mkdir</tt> handmatig de directory's
aan. Ik had het toendertijd niet bij de hand, maar het zou goed zijn
de <REF ID="FHS" NAME="Filesystem Heirarchy Standard"> te volgen.
</p>

<p>
In het bestand <tt>fstab</tt> van het bronsysteem, stelde ik de doelpartitie
zo in dat ze werd gemount op <tt>/mnt/target</tt>. Voor de meeste pakketten 
is een configuratie-optie beschikbaar waar ze moeten worden ge&iuml;nstalleerd.
Standaard is de ``basis'' directory voor de installatie van een pakket
<tt>/</tt>, dat wil zeggen dat je het wilt installeren op het systeem
waarop het wordt samengesteld. Ik gebruikte deze opties om de 
basisinstallatiedirectory in te stellen op <tt>/mnt/target</tt>. 
Om bijvoorbeeld een GNU-pakket in <tt>/mnt/target</tt> te installeren,
configureer je het als volgt:
</p>

<p>
<verb>
	./configure --prefix=/mnt/target
</verb>
</p>

<p>
Er treedt een probleem op bij deze benadering als een aantal van de
pakketten op het doelsysteem recenter zijn dan de equivalente pakketten
op het bronsysteem. Ik installeerde bijvoorbeeld ncurses 5 op het doelsysteem,
maar op de bron stond versie 4. Bij het compileren worden standaard de
headers en library's van het bronsysteem gebruikt. Om dit te herstellen
moet je variabelen of configuratieparameters instellen waarmee je het
vertelt waar het de headers en library's kan vinden, die je wilt gebruiken.
Soms is het enige dat je kunt doet het bestand <tt>Makefile</tt> hacken.
Als je de uitvoer bekijkt die wordt geproduceerd onderwijl een programma
wordt gecompileerd, vertellen de <tt>-I</tt> vlaggen waar op zoek te gaan naar
headers, en de <tt>-L</tt> vertellen het waar op zoek te gaan naar
library's. Zoek naar een variabele genaamd <tt>LDFLAGS</tt>. 
Dit is waarschijnlijk waar je een paar van deze vlaggen in kunt voegen, en
het kunt laten zoeken naar waar je wilt. Bijvoorbeeld in de
<tt>Makefile</tt> voor het pakket <tt>procps</tt> kreeg ik het voor elkaar
gebruik te maken van de juiste library's door 
</p>

<p>
<verb>
	-L /mnt/target/lib
</verb>
</p>

<p>
toe te voegen.
Door RedHat wordt LILO in het masterbootrecord ge&iuml;nstalleerd. 
Voor het doelsysteem installeerde ik LILO in de bootsector van de
doelpartitie. Vervolgens voegde ik in <tt>/etc/lilo.conf</tt> het
volgende toe op het bronsysteem

<verb>
other=/dev/hda1
	label=doel
</verb>

en herstartte <tt>lilo</tt>. Dit heeft als effect dat ``doel''
&eacute;&eacute;n van de opties is, die LILO je bij de eerste keer booten geeft.
Selecteer je dit, dan krijg je een second instance van LILO die het 
doelsysteem boot. Dit lijkt misschien gek, maar het biedt je de mogelijkheid 
het systeem dat je aan het opbouwen bent te scheiden van het systeem dat 
je gebruikt om het op te bouwen.
</p>
</sect1>

<sect1><heading>Diverse Tips</heading>
<p>
Als je een opdracht hebt met de naam <tt>thingy</tt> op een Linux-systeem
met RPM, en wilt weten waar de broncode vandaan te halen, dan kun je de
opdracht:
</p>

<p>
<verb>
	rpm -qif `which thingy`
</verb>
</p>

<p>
gebruiken.
En als je een RedHat broncode CD hebt, dan kun je de broncode installeren met
</p>

<p>
<verb>
	rpm -i /mnt/cdrom/SRPMS/what.it.just.said-1.2.srpm
</verb>
</p>

<p>
Zodra je een bashprompt hebt, the next stage is to get your system able to 
self replicate. Ik heb dit nog niet gedaan, maar hieronder staan een 
aantal zaken die je hiervoor zult moeten installeren.

<itemize>
<item>GNU make
</item>
<item>GNU egcs
</item>
<item>gdb
</item>
<item>binutils - assembler, linker, enz; bin86 - intel specifieke versies
</item>
<item>tar, gzip, bzip2
</item>
<item>diff is afkomstig uit diffutils, patch is afkomstig uit patch, hehe
</item>
</itemize>
</p>
</sect1>

<sect1><heading>Meer informatie</heading>
<p>
<itemize>
<item> Er is een mini-howto over het vanuit de broncode bouwen van software,
de <URL URL="http://mirror.aarnet.edu.au/linux/LDP/HOWTO/mini/Software-Building.html"
	NAME="Software Building mini-HOWTO">.
</item>
<item> Er is ook een HOWTO over het vanaf de grond opbouwen van een Linux
systeem. Het richt zich veel meer op hoe het systeem zo kan worden opgebouwd,
dat het kan worden gebruikt, in plaats van gewoon als een leeroefening.
	<URL URL="http://mirror.aarnet.edu.au/pub/linux/LDP/HOWTO/Linux-From-Scratch-HOWTO.html" NAME="De Linux From Scratch HOWTO">
</item>
</itemize>
</p>
</sect1>
</sect>


<sect><heading>Conclusie</heading>
<p>
Het beste van Linux, naar mijn mening, is dat je het kunt onderzoeken
en er werkelijk achter kunt komen hoe het werkt. Ik hoop dat je hier net zoveel
plezier in hebt als ik. En ik hoop dat ik je hiermee op weg heb kunnen
helpen.
</p>
</sect>

<sect><heading>Administratieve zaken</heading>
<sect1><heading>Copyright</heading>
<p>
Dit document valt onder het copyright (c) 1999, 2000 Greg O'Keefe. 
Je mag het gerust gebruiken, kopi&euml;ren, distribueren of aanpassen, zonder
kosten, onder voorwaarden van de
<URL URL="http://www.gnu.org/copyleft/gpl.html" 
	NAME="GNU General Public Licence">.
Stel me er alsjeblieft van in kennis als je delen van dit document in een
ander document gebruikt.
</p>
</sect1>

<sect1><heading>Homepage</heading>
<p>
De laatste versie van dit document is te vinden op
<URL URL="http://learning.taslug.org.au/power2bash" 
	NAME="From Powerup To Bash Prompt"> 
</p>
</sect1>

	
<sect1><heading>Feedback</heading>
<p>
Graag zou ik op de hoogte worden gebracht van op- en aanmerkingen, kritiek
en suggesties voor verbetering van dit document. Stuur ze alsjeblieft naar
<URL URL="mailto:gcokeefe@postoffice.utas.edu.au" NAME="Greg O'Keefe">
</p>
</sect1>

<sect1><heading>Erkenningen</heading>
<p>
<label ID="acknowledge">
Productnamen zijn handelsmerken van de respectieve houders, en worden
hierbij beschouwd voldoende te zijn erkend.
</p>

<p>
Er zijn een paar mensen die ik wil bedanken, voor hun hulp dit mogelijk
te maken.
</p>

<p>
<descrip>
<tag>Iedereen op de discussielijst learning@TasLUG</tag>
<p>Bedankt voor het lezen van al mijn mailtjes en het stellen van 
interessante vragen. Je kunt je bij deze lijst aansluiten door een bericht
te sturen naar <URL URL="mailto:majordomo@taslug.org.au" NAME="majordomo"> met
<verb>
	subscribe learning
</verb>
in het berichtenvenster.
</p>
</descrip>

<descrip>	
<tag>Michael Emery</tag>
<p>Om me te wijzen op Unios.</p>
</descrip>

<descrip>
<tag>Tim Little</tag>
<p>Voor wat aanwijzingen over <tt>/etc/passwd</tt></p>
</descrip>

<descrip>
<tag>sPaKr on #linux in efnet</tag>
<p>Die bevestigde dat syslogd <tt>/etc/services</tt> nodig heeft,
en me introduceerde in de phrase "rolling your own" om het
bouwen van een systeem vanuit de broncode te beschrijven.
</p>
</descrip>

<descrip>
<tag>Alex Aitkin</tag>
<p>Voor het onder mijn aandacht brengen van Vico en zijn ``verum ipsum factum'' 
(understanding arises through making).
</p>
</descrip>
</p>
</sect1>


<sect1><heading>Historie</heading>
<sect2><heading>0.5 -> 0.6</heading>
<p>
<itemize>
<item>historie toegevoegd
</item>
<item>wat tedoens toegevoegd
</item>
</itemize>
</p>
</sect2>
</sect1>

<sect1><heading>TEDOEN</heading>
<p>
<itemize>
<item>voeg verwijzingen toe naar homesites, niet alleen naar de aarnet
mirror
</item>
<item>voeg meer oefeningen toe
</item>
<item>verwijder het doelsysteem op de Wang, deze notities nauwgezet
volgend als een test
</item>
<item>controleer of alle opgegeven pakketten als kernelvereisten 
(statusversie) zijn opgenomen
</item>
</itemize>
</p>
</sect1>
</sect>
</article>
</linuxdoc>