Date: oktober 1999 De Linux System Administrators' Guide Versie 0.6.2 Lars Wirzenius
liw@iki.fi
Joanna Oja
viu@iki.fi
Vertaald door: Ellen Bokhorst
bokkie@nl.linux.org
Een introductie systeembeheer van een Linux-systeem voor beginners. Copyright 1993--1998 Lars Wirzenius. Handelsmerken zijn in handen van hun eigenaren. Het is toegestaan letterlijke kopieën van dit handboek te maken en te distribueren op voorwaarde dat de copyright vermelding en deze permissie vermelding op alle kopieën behouden blijft. Het is toegestaan de code van de bron van dit document via TeX of andere formatters te verwerken en de resultaten af te drukken, en het afgedrukte document te distribueren, op voorwaarde dat het afgedrukte document is voorzien van een permissie vermelding die identiek is aan deze vermelding, inclusief de verwijzingen naar waar de broncode en de officiële homepage te vinden is. Het is toegestaan gewijzigde versies van dit handboek te kopiëren en te distribueren onder de condities van het letterlijke kopiëren, op voorwaarde dat het volledige resulterende afgeleide werk wordt gedistribueerd onder de voorwaarden van een permissie vermelding die identiek is aan deze vermelding. Het is toegestaan om vertalingen van dit handboek te kopiëren en distribueren, onder de bovengenoemde voorwaarden voor gewijzigde versies. De auteur zou het waarderen als hij op de hoogte wordt gesteld van gewijzigde, vertaalde, en afgedrukte versies. Dank u. Toewijding Deze plek is opgedragen aan een toekomstige toewijding. Beschikbare bron en voorgeformatteerde versies De broncode en andere leesbare formaten van dit boek zijn te vinden op het Internet via anonymous FTP op de homepage van het Linux Documentation Project http://sunsite.unc.edu/LDP/, of op de homepage van dit boek op http://www.iki.fi/viu/linux/sag/. Op z'n minst zijn de PostScript en TeX .DVI formaten beschikbaar. Introductie
In the beginning, the file was without form, and void; and emptiness was upon the face of the bits. And the Fingers of the Author moved upon the face of the keyboard. And the Author said, Let there be words, and there were words.
Dit handboek, de Linux System Administrators' Guide, beschrijft de aspecten van het systeembeheer voor het gebruik van Linux. Het is bedoeld voor die mensen die niets tot weinig weten over systeembeheer (zoals in ``wat is het?''), maar die zich reeds de beginselen voor het normaal gebruik eigen hebben gemaakt. Dit handboek vertelt je dan ook niet hoe je Linux moet installeren; dat wordt beschreven in het `Installation and Getting Started' document. Zie hieronder voor meer informatie over Linux handboeken. Systeembeheer is alles wat men moet doen om een computersysteem in bruikbare vorm te behouden. Hieronder bevinden zich zaken zoals het maken van een backup voor bestanden (en ze terug te zetten als dat nodig is), het installeren van nieuwe programma's, aanmaken van accounts voor gebruikers (en ze verwijderen wanneer ze niet langer nodig zijn), ervoor zorgen dat het bestandssysteem niet beschadigd raakt, enzovoort. Als een computer zeg maar een huis zou zijn, zou systeembeheer onderhoud worden genoemd, en zou bestaan uit het schoonmaken, herstellen van gebroken ramen en andere dergelijke zaken. Systeembeheer wordt geen onderhoud genoemd, omdat dat te eenvoudig zou zijn. Er zijn een aantal mensen die het zo noemen, maar dat is gewoon omdat ze dit handboek nooit hebben gelezen, de stumperds. De structuur van dit handboek is zodanig opgezet dat veel van de hoofdstukken onafhankelijk van elkaar bruikbaar zijn, zodat als je informatie over, laten we zeggen, backups nodig hebt, je gewoon dat hoofdstuk kunt lezen. Hopelijk maakt dit het boek eenvoudiger te gebruiken als een referentiehandboek, en wordt het hierdoor mogelijk om slechts een gedeelte te lezen, wanneer het nodig is, in plaats van alles te moeten lezen. Dit handboek is echter als eerste en voornaamste een tutorial, en slechts enkel door een gelukkige toevallige samenloop van omstandigheden een referentiehandboek. Het is niet de bedoeling dat dit handboek volledig op zichzelf wordt gebruikt. Veel van de rest van de Linux documentatie is ook belangrijk voor systeembeheerders. Per slot van rekening is een systeembeheerder gewoon een gebruiker met speciale privileges en verplichtingen. Een zeer belangrijke bron zijn de manual pages, die altijd geraadpleegd zouden moeten worden als een commando niet bekend is. Ondanks dat dit handboek op Linux is gericht, is de algemene stelregel geweest dat het bovendien ook bruikbaar zou moeten zijn voor andere besturingssystemen die op UNIX zijn gebaseerd. Helaas, aangezien er zoveel variatie is in de verschillende versies van UNIX in het algemeen, en systeembeheer in het bijzonder, is er weinig hoop om alle varianten te bestrijken. Zelfs het bestrijken van alle mogelijkheden van Linux is moeilijk, vanwege de aard van de ontwikkeling ervan. Er is geen officiële Linux-distributie, dus verschillende mensen hebben verschillende setups, en veel mensen hebben een setup die ze zelf hebben opgebouwd. Dit boek is niet op een specifieke distributie gericht, ik gebruik zelf echter bijna exclusief het Debian GNU/Linux systeem. Ik heb geprobeerd, daar waar mogelijk, op verschillen te wijzen, en verscheidene alternatieven uitgelegd. Ik heb getracht te beschrijven hoe zaken werken, in plaats van slechts ``vijf makkelijke stappen'' voor iedere taak op te sommen. Dit betekent dat hierin veel informatie staat die niet iedereen nodig heeft, maar die delen zijn als zodanig gemarkeerd en kunnen worden overgeslagen als je een voorgeconfigureerd systeem gebruikt. Alles lezen zal natuurlijk je begrip van het systeem verhogen en zou het gebruik en beheer prettiger moeten maken. Zoals met alle andere Linux gerelateerde ontwikkeling werd het werk op vrijwilligersbasis uitgevoerd. Ik deed het omdat ik dacht dat het misschien leuk zou zijn en omdat ik het gevoel had dat het gedaan zou moeten worden. Zoals echter met al het vrijwilligerswerk, is er een grens aan hoeveel moeite ik kan spenderen, en ook hoeveel kennis en ervaring ik heb. Dit betekent dat het handboek niet noodzakelijk zo goed is als het zou zijn geweest als een deskundige zou zijn betaald om het geleidelijk te schrijven en er een paar jaar aan had gespendeerd om het te perfectioneren. Ik denk, natuurlijk, dat het redelijk goed is, maar wees gewaarschuwd. Één bepaald punt waar ik de kantjes vanaf heb gelopen, is dat ik niet alles door en door heb behandeld, wat reeds goed is gedocumenteerd in andere vrij-verkrijgbare handboeken. Dit geldt vooral voor documentatie die specifiek is voor een programma, zoals alle details over het gebruik van mkfs. Ik beschrijf slechts het doel van het programma, en zoveel van het gebruik als nodig is voor het doel van dit handboek. Voor verdere informatie verwijs ik de vriendelijke lezer naar deze andere handboeken. Meestal maakt de documentatie waarnaar verwezen wordt, onderdeel uit van de volledige set Linux documentatie. Ondanks dat Lars heeft geprobeerd dit handboek zo goed mogelijk samen te stellen, zou ik, als de huidige beheerder, het goede werk in stand houden. Ik zou heel graag van je willen horen als je ideeën hebt hoe het beter gemaakt kan worden. Slecht taalgebruik, feitelijke fouten, ideeën voor verslag uitbrengen over nieuwe gebieden, herschreven secties, informatie over hoe de diverse UNIX versies het doen, ik ben er allemaal in geïnteresseerd. De informatie over hoe je contact met me op kunt nemen is beschikbaar via het World Wide Web op http://www.iki.fi/viu/mail-to-lasu.html. Veel mensen hebben me direct of indirect met dit boek geholpen. Ik zou in het bijzonder Matt Welsh voor de inspiratie en het LDP leiderschap willen bedanken, Andy Oram voor het me weer aan het werk krijgen en te voorzien in veel waardevolle feedback, Olaf Kirch voor dat hij aantoonde dat het ik het voor elkaar kon krijgen, en Adam Richter van Yggdrasil en anderen die me in lieten zien dat ook andere mensen het interessant kunnen vinden. Stephen Tweedie, H. Peter Anvin, Remy Card, Theodore Ts'o, en Stephen Tweedie hebben mij hun werk laten lenen (en dat heeft ervoor gezorgd dat dit boek er dikker en indrukwekkender uitziet): een vergelijking tussen het xia en ext2 bestandssysteem, de device list en een beschrijving van het ext2 bestandssysteem. Deze maken geen onderdeel meer uit van het boek. Ik ben hiervoor zeer dankbaar, en maak mijn excuses voor de eerdere versies waarin soms de juiste toekenningen ontbraken. Bovendien zou ik Mark Komarinski willen bedanken voor het verzenden van zijn materiaal in 1993 en de vele colums in Linux Journal over systeembeheer. Ze waren zeer informatief en inspirerend. Een groot aantal mensen hebben me veel bruikbare opmerkingen gestuurd. In mijn zeer kleine archief kan ik niet alle namen vinden, maar een aantal van hun zijn, in alfabetische volgorde: Paul Caprioli, Ales Cepek, Marie-France Declerfayt, Dave Dobson, Olaf Flebbe, Helmut Geyer, Larry Greenfield en zijn vader, Stephen Harris, Jyrki Havia, Jim Haynes, York Lam, Timothy Andrew Lister, Jim Lynch, Michael J. Micek, Jacob Navia, Dan Poirier, Daniel Quinlan, Jouni K Seppänen, Philippe Steindl, G.B. Stotte. Mijn verontschuldigingen voor iedereen die ik vergeten ben. META moet hier typografische conventies en LDP zaken toevoegen. Het Linux Documentatie Project Het Linux Documentatie Project, of LDP, bestaat uit een onsamenhangend team met schrijvers, proeflezers en editors die samenwerken om te voorzien in complete documentatie voor het besturingssysteem Linux. De overkoepelende coördinator van het project is Greg Hankins. Dit handboek is er één uit een set met verscheidene handboeken die door de LDP worden gedistribueerd, waaronder een Linux Users' Guide, System Administrators' Guide, Network Administrators' Guide, en een Kernel Hackers' Guide. Deze handboeken zijn allen beschikbaar in het bronformaat, .dvi formaat, en postscript uitvoer via anonymous FTP via sunsite.unc.edu, in de directory /pub/Linux/docs/LDP. We moedigen iedereen met een neiging tot schrijven of redigeren aan om zich bij ons aan te sluiten in het verbeteren van de Linux documentatie. Als je toegang hebt tot Internet e-mail, kun je contact opnemen met Greg Hankins via gregh@sunsite.unc.edu. Overzicht van een Linux-systeem
God looked over everything he had made, and saw that it was very good. (Genesis 1:31)
Dit hoofdstuk geeft een overzicht van een Linux-systeem. Als eerste worden de belangrijke services beschreven, waarin het besturingssysteem voorziet. Vervolgens worden de programma's die deze services implementeren beschreven, waarbij de details weloverwogen zijn weggelaten. Het doel van dit hoofdstuk is om begrip bij te brengen voor het systeem in zijn geheel, en dus ieder onderdeel elders in detail te beschrijven. Diverse onderdelen van een besturingssysteem Een UNIX besturingssysteem bestaat uit een kernel en een aantal systeemprogramma's. Er zijn ook een aantal applicatieprogramma's die het werk doen. De kernel is het hart van het besturingssysteem. In feite wordt vaak abusievelijk gedacht dat dit het besturingssysteem zelf is, maar dat is het niet. Een besturingssysteem voorziet in meer services dan een plain kernel. Het houdt de bestanden op de disks bij, start programma's en voert ze gelijktijdig uit, wijst geheugen en andere bronnen toe aan diverse processen, ontvangt pakketjes van en zendt pakketjes naar het netwerk, enzovoort. De kernel doet van zichzelf erg weinig, maar het voorziet in tools waarmee alle services kunnen worden gebouwd. Het voorkomt ook dat iedereen de hardware direct benadert, door van iedereen te verlangen de tools te gebruiken waarin het voorziet. Op deze manier zorgt de kernel ervoor dat een gebruiker wordt afgeschermd voor de andere gebruikers. De tools waarin door de kernel wordt voorzien, worden gebruikt via system calls; zie manual page sectie 2 voor meer informatie hierover. De systeemprogramma's gebruiken de tools waarin door de kernel is voorzien om de diverse services te implementeren die vereist zijn voor een besturingssysteem. Systeemprogramma's en alle andere programma's, draaien `bovenop de kernel' in wat een user mode wordt genoemd. Het verschil tussen systeem- en applicatieprogramma's is de bedoeling ervan: applicaties zijn bedoeld om bruikbare zaken gedaan te krijgen (of om te spelen, als het een spel is), terwijl systeemprogramma's daarentegen nodig zijn om het systeem te laten werken. Een tekstverwerker is een applicatie; telnet is een systeemprogramma. Het verschil is echter vaak wat onduidelijk, en is alleen belangrijk voor geobsedeerde categorie-indelers. Een besturingssysteem kan ook compilers en de corresponderende libraries bevatten (onder Linux zijn dit in het bijzonder de GCC en de C library), alhoewel niet alle programmeertalen onderdeel van het besturingssysteem hoeven te zijn. Documentatie, en soms zelfs spellen kunnen er ook deel van uitmaken. Volgens traditie wordt het besturingssysteem gedefinieerd door de inhoud van de installatie-tape of -disks; met Linux is dat niet duidelijk, aangezien het over de FTP-sites in de wereld is verspreid. Belangrijke onderdelen van de kernel De Linux-kernel bestaat uit verscheidene belangrijke onderdelen: procesbeheer, geheugenbeheer, devicedrivers voor de hardware, drivers voor het bestandssysteem, netwerkbeheer, en diverse andere stukjes en beetjes. toont er een aantal van.
Een aantal van de meer belangrijke onderdelen van de Linux-kernel
Waarschijnlijk zijn de belangrijkste onderdelen van de kernel (niets werkt zonder) het geheugenbeheer en procesbeheer. Geheugenbeheer zorgt voor het toewijzen van geheugengebieden en swapgebieden aan processen, delen van de kernel, en voor de buffer cache. Procesbeheer maakt processen aan, en implementeert multitasking door de actieve processen voor de processor te verwisselen. Op het laagste niveau bevat de kernel devicedrivers voor de hardware, voor iedere soort hardware die het ondersteunt. Aangezien er in de wereld zoveel verschillende soorten hardware zijn, is het aantal devicedrivers voor de hardware groot. Er zijn vaak veel andere vergelijkbare stukjes hardware die verschillen in hoe ze door software worden aangestuurd. De overeenkomsten maken het mogelijk om drivers die vergelijkbare bewerkingen ondersteunen, in algemene klassen in te delen; ieder lid van de klasse heeft dezelfde interface voor de rest van de kernel, maar verschilt in wat nodig is om ze te implementeren. Alle diskdrivers bijvoorbeeld, lijken voor de rest van de kernel op elkaar, d.w.z. ze hebben allen bewerkingen zoals `initialiseer de drive', `lees sector N', en `schrijf sector N'. Een aantal software services waarin door de kernel zelf wordt voorzien, hebben vergelijkbare eigenschappen, en kunnen daarom in klassen worden geabstraheerd. De diverse netwerkprotocollen zijn bijvoorbeeld geabstraheerd in één programmeer interface, de BSD socket library. Een ander voorbeeld is de Virtuele File System (VFS) laag, die de bestandssysteem bewerkingen abstraheert van hun implementatie. Ieder type bestandssysteem voorziet in een implementatie van iedere bestandssysteem bewerking. Wanneer één of andere entiteit een bestandssysteem probeert te gebruiken, gaat het verzoek via het VFS, die het verzoek naar de juiste driver van het bestandssysteem leidt. Belangrijke services in een UNIX systeem Deze sectie beschrijft een aantal van de belangrijkere UNIX services, maar zonder al te veel details. Ze worden in latere hoofdstukken grondiger beschreven. <command>init</command> De allerbelangrijkste service in een UNIX systeem wordt door init verzorgd. init wordt als het eerste proces op ieder UNIX-systeem gestart, als het laatste wat de kernel doet wanneer het boot. Wanneer init start, vervolgt dit het bootproces door diverse opstartkarweitjes uit te voeren (controleren en mounten van bestandssystemen, starten van daemons, enz). De exacte lijst met dingen die init doet, is afhankelijk van welke variant het is; er zijn er verscheidene om uit te kiezen. init voorziet meestal in het concept single user mode, waarin niemand in kan loggen en root een shell op de console gebruikt; de gebruikelijke modus wordt multiuser mode genoemd. Een aantal varianten generaliseren dit als run levels; single en multi-user modes worden geacht twee run levels te zijn, en er kunnen er bovendien nog meer van zijn, om bijvoorbeeld X op de console uit te voeren. Onder normale bewerking, zorgt init ervoor dat getty functioneert (om gebruikers toe te staan in te loggen), en om weesprocessen te adopteren (processen waarvan de ouder is overleden; in UNIX moeten alle processen in een enkele structuur voorkomen, dus wezen moeten worden geadopteerd). Wanneer het systeem wordt uitgezet, is init belast met het `killen' van alle andere processen, unmounten van alle besturingssystemen en het stoppen van de processor, samen met al het andere, waarvoor het is geconfigureerd. Logins vanaf terminals Logins vanaf terminals (via seriële lijnen) en de console (wanneer X niet draait) worden verschaft door het programma getty. init start voor iedere terminal, waarvoor logins zijn toegestaan een aparte instance van getty. getty leest de gebruikersnaam en voert het login programma uit, welke het wachtwoord inleest. Als de gebruikersnaam en het wachtwoord correct zijn, start login de shell op. Wanneer de shell eindigt, d.w.z. de gebruiker logt uit, of wanneer login eindigt, omdat de gebruikersnaam en het wachtwoord niet overeenkwamen, merkt init dit op en start een nieuwe instance van getty. De kernel heeft geen notie van logins, dit wordt allemaal door de systeemprogramma's afgehandeld. Syslog De kernel en veel systeemprogramma's produceren foutmeldingen, waarschuwingen en andere berichten. Vaak is het belangrijk dat deze meldingen later nog eens kunnen worden bekeken, zelfs veel later, zodat ze naar een bestand geschreven zouden moeten worden. Het programma dat dit doet, heet syslog. Het kan zodanig worden geconfigureerd dat het de meldingen naar diverse bestanden sorteert, naar gelang wie de schrijver is of de mate van belangrijkheid. Meldingen van de kernel worden vaak gescheiden van de andere meldingen en naar een apart bestand gestuurd, aangezien meldingen van de kernel vaak belangrijker zijn en regelmatig moeten worden gelezen om problemen te kunnen herkennen. Periodieke commando uitvoering: <command>cron</command> en <command>at</command> Zowel gebruikers als systeembeheerders moeten vaak periodiek commando's uitvoeren. De systeembeheerder wil misschien een commando uitvoeren om de directories met tijdelijke bestanden (/tmp en /var/tmp) van oude bestanden te schonen, of om te voorkomen dat de disks vollopen, aangezien niet alle programma's op de juiste wijze achter zich opruimen. De cron service is ingesteld om dit te doen. Iedere gebruiker heeft een crontab bestand, waarin hij de commando's zet die hij uit wil voeren en de tijden dat ze uitgevoerd zouden moeten worden. De cron daemon zorgt ervoor dat de commando's worden opgestart op die tijd die is aangegeven. De at service is vergelijkbaar met cron, maar het is slechts éénmalig: het commando wordt op de gegeven tijd uitgevoerd, maar het wordt niet herhaald. Grafische gebruikersinterface UNIX en Linux nemen de gebruikersinterface niet in de kernel op; in plaats daarvan, laten ze het door programma's op gebruikersniveau implementeren. Dit geldt voor zowel de tekstmodus als de grafische omgevingen. Deze regeling maakt het systeem flexibeler, maar heeft als nadeel dat het eenvoudig is om voor ieder programma een andere gebruikersinterface te implementeren, wat het moeilijker maakt om het systeem te leren. De grafische omgeving die primair onder Linux wordt gebruikt, wordt het X Window System (afgekort tot X) genoemd. X implementeert ook geen gebruikersinterface; het implementeert alleen een window systeem, d.w.z. tools waarmee een grafische interface kan worden geïmplementeerd. De drie populairste gebruikersinterface stijlen voor X zijn Athena, Motif, en Open Look. Netwerken Het gebruik maken van netwerken is de handeling, waarbij twee of meer computers met elkaar worden verbonden, zodat ze met elkaar kunnen communiceren. De eigenlijke methoden van het maken van de verbinding en het bewerkstelligen van de communicatie zijn wat gecompliceerd, maar het eindresultaat is zeer bruikbaar. UNIX besturingssystemen hebben veel netwerkeigenschappen. De meeste basis services (bestandssystemen, afdrukken, backups, enz.) kunnen over het netwerk worden gedaan. Dit kan het systeembeheer eenvoudiger maken, aangezien het een gecentraliseerde administratie toestaat en er nog steeds van de voordelen van het werken op microcomputers en een gedistribueerde gegevensverwerking wordt geprofiteerd, zoals een verlaging van de kosten en betere fout-tolerantie. Dit boek werpt echter slechts enkel een blik op het werken met netwerken; zie de Linux Network Administrators' Guide voor meer informatie, waaronder een basisbeschrijving van hoe netwerken functioneren. Netwerk logins Netwerklogins werken iets anders dan normale logins. Er is een aparte fysieke seriële lijn voor iedere terminal via welke het mogelijk is om in te loggen. Voor iedere persoon die via het netwerk inlogt, is er een aparte virtuele netwerkverbinding en er kunnen er een willekeurig aantal van zijn. Er kunnen er tenminste veel zijn. Omdat Netwerkbandbreedte nog steeds een schaarse bron is, is er een praktische bovengrens aan het aantal gemeenschappelijke logins via één netwerkverbinding. Het is daarom niet mogelijk om een apart getty voor iedere mogelijke virtuele verbinding te draaien. Er zijn ook diverse verschillende manieren om via een netwerk in te loggen, in TCP/IP netwerken zijn telnet en rlogin daarvan de belangrijkste. Netwerklogins hebben, in plaats van een hoop getty's, een enkele daemon per manier waarop wordt ingelogd, (telnet en rlogin hebben aparte daemons) die naar alle inkomende pogingen om in te loggen luisteren. Als het er één bemerkt, start het een nieuwe instance van zichzelf om die enkele poging af te handelen; de originele instance blijft vervolgens naar andere pogingen luisteren. De nieuwe instance werkt op vergelijkbare wijze als getty. Netwerk bestandssystemen Één van de meer nuttige dingen die met netwerkservices kunnen worden bewerkstelligd, is het delen van bestanden via een netwerk bestandssysteem. Datgene wat meestal wordt gebruikt, wordt het Network File System, of NFS genoemd, ontwikkeld door Sun. Met een netwerk bestandssysteem worden alle door een programma uitgevoerde bestandsbewerkingen op de ene computer via het netwerk verzonden naar een andere computer. Hiermee wordt het programma voor de gek gehouden, omdat het denkt dat alle bestanden op de andere computer zich eigenlijk op de computer bevinden, waarop het programma wordt uitgevoerd. Dit maakt het delen van informatie uitermate eenvoudig, aangezien het geen aanpassing aan programma's vereist. Mail Elektronische mail is meestal de belangrijkste methode om via de computer te communiceren. Een elektronische brief wordt in een bestand met een speciaal formaat opgeslagen, en er worden speciale mailprogramma's gebruikt om de brieven te verzenden en te lezen. Elke gebruiker heeft een inkomende mailbox (een bestand in het speciale formaat), waarin alle mail wordt opgeslagen. Als iemand mail verstuurt, lokaliseert het mailprogramma de mailbox van de ontvanger en voegt de brief toe aan het mailbox bestand. Als de mailbox van de ontvanger zich op een andere computer bevindt, dan wordt de brief naar de andere computer verzonden, die hem in de mailbox bezorgt, waarin deze het best past. Het mailsysteem bestaat uit heel wat programma's. De bezorging van mail naar lokale of remote mailboxen wordt gedaan door één programma (de mail transfer agent of MTA, b.v. sendmail of smail), terwijl er van de programma's, waar de gebruikers gebruik van maken, veel en gevarieerde (mail user agents of MUA's zijn, b.v., pine of elm). De mailboxen worden meestal in /var/spool/mail opgeslagen. Afdrukken Slechts één persoon tegelijkertijd kan een printer gebruiken, maar het is niet economisch om de printers niet tussen de gebruikers te delen. De printer wordt daarom beheerd door software die een afdrukwachtrij implementeert: alle afdruktaken worden in een wachtrij geplaatst en wanneer de printer met een taak klaar is, wordt de volgende er automatisch naar toegestuurd. Dit ontheft de gebruikers van het organiseren van de afdrukwachtrij en het gevecht om de zeggenschap over de printer. In plaats daarvan, vormen ze een nieuwe wachtrij bij de printer, wachtend op hun afdrukken, aangezien niemand ooit aan de weet schijnt te kunnen komen, wanneer de afdruk van iemand precies echt klaar is. Dit is een geweldige stimulans voor sociale relaties binnen een kantoor. De software voor de afdrukwachtrij spoolt ook de afdrukken naar de disks, d.w.z. de tekst wordt in een bestand bewaard ten tijde dat de taak zich in de wachtrij bevindt. Hierdoor kan een applicatieprogramma de afdruktaken snel naar de software van de afdrukwachtrij doorsluizen; de applicatie hoeft niet te wachten totdat de taak echt is afgedrukt om verder te kunnen gaan. Dit is echt heel prettig, aangezien het de mogelijkheid biedt de ene versie af te drukken, en het niet nodig is met afdrukken te wachten, voordat men een volledige gereviseerde nieuwe versie kan maken. De layout van het bestandssysteem Het bestandssysteem is in veel delen onderverdeeld; meestal over de gehele linie van een root bestandssysteem met /bin, /lib, /etc, /dev, en een paar anderen; een /usr bestandssysteem met programma's en niet veranderlijke data; een /var bestandssysteem met veranderlijke data (zoals logbestanden); en een /home bestandssysteem voor ieders persoonlijke bestanden. Afhankelijk van de hardwareconfiguratie en de beslissingen van de systeembeheerder, kan de onderverdeling anders zijn; het kan zelfs allemaal in één bestandssysteem. beschrijft de layout van het bestandssysteem in iets meer detail; de Linux Filesystem Standard behandelt het in wat meer detail. Overzicht van de Directory Structuur
Two days later, there was Pooh, sitting on his branch, dangling his legs, and there, beside him, were four pots of honey... (A.A. Milne)
Dit hoofdstuk beschrijft de belangrijke delen van een standaard Linux directory-structuur, gebaseerd op de FSSTND bestandssysteemstandaard. Het geeft in grote lijnen de normale manier aan, waarop de directory-structuur in aparte bestandssystemen met verschillende doeleinden wordt opgesplitst en het geeft de motivatie achter deze bepaalde opsplitsing. Er worden ook wat alternatieve manieren voor het opsplitsen beschreven. Achtergrond Dit hoofdstuk is oppervlakkig gebaseerd op de Linux Filesystem Standard, FSSTND, versie 1.2 (zie de bibliografie), welke een standaard probeert in te stellen voor hoe de directory-structuur in een Linux systeem is georganiseerd. Een dergelijke standaard heeft als voordeel dat het eenvoudiger zal zijn om software voor Linux te schrijven of te porten, en om Linux-machines te beheren, aangezien alles op de gebruikelijke plaatsen zal staan. Er is achter de standaard geen autoriteit die iemand dwingt er aan te voldoen, maar het wordt door de meeste, zo niet alle Linux distributies, ondersteund. Het is niet verstandig zonder zeer dwingende redenen met de FSSTND te breken. De FSSTND probeert de Unix traditie en huidige trends te volgen, zodat de Linux-systemen bekend zijn voor degene die ervaring hebben met andere Unix-systemen, en vice versa. Dit hoofdstuk is niet zo gedetailleerd als de FSSTND. Een systeembeheerder zou ook de FSSTND moeten lezen voor het verkrijgen van een volledig begrip. Dit hoofstuk beschrijft niet alle bestanden in detail. De bedoeling is niet om ieder bestand te beschrijven, maar om een overzicht te geven van het systeem met als uitgangspunt het bestandssysteem. Verdere informatie over ieder bestand is elders beschikbaar in dit handboek of in de manual pages. De volledige directory-structuur moet in kleinere delen worden opgebroken, ieder daarvan op zijn eigen disk of partitie, om te accomoderen aan de limieten van diskgroottes en het maken van een backup en ander systeembeheer te vereenvoudigen. De belangrijke delen bestaan uit de root, /usr, /var, en /home bestandssystemen (zie ). Ieder onderdeel heeft een ander doel. De directory-structuur is zodanig ontworpen dat het goed werkt in een netwerk van Linux computers die een aantal delen van de bestandssystemen over een read-only device kunnen delen (b.v. een CD-ROM), of over het netwerk met NFS.
Onderdelen van een Unix directory-structuur. Onderbroken lijnen duiden op partitie limieten.
De regels van de verschillende delen van de directory-structuur worden hieronder beschreven. Het /root bestandssysteem is voor iedere computer specifiek (het wordt gewoonlijk op een lokale disk bewaard, alhoewel het ook een ramdisk of netwerkdrive zou kunnen zijn) en bevat de bestanden die nodig zijn om het systeem te booten, en het in een dusdanige staat te brengen dat de andere bestandssystemen kunnen worden gemount. De inhoud van het root bestandssysteem zal daarom voldoende zijn voor de single user toestand. Het zal ook tools bevatten voor het herstellen van een gebrekkig systeem, en voor het vanaf backups terugzetten van verloren gegane bestanden. Het /usr bestandssysteem bevat alle commando's, libraries, manual pages, en andere onveranderlijke bestanden die nodig zijn gedurende de normale werking. Er zouden in /usr geen bestanden moeten voorkomen die voor een gegeven computer specifiek zijn, noch zouden ze tijdens het normale gebruik moeten worden gewijzigd. Dit staat toe dat de bestanden over het netwerk kunnen worden gedeeld, wat kostenbesparend kan zijn, aangezien het diskruimte bespaart (er kunnen makkelijk honderden megabytes in /usr), en kan het beheer eenvoudiger maken (alleen het origineel /usr hoeft te worden gewijzigd, wanneer een update van een applicatie wordt uitgevoerd, niet iedere computer afzonderlijk). Zelfs als het bestandssysteem zich op een lokale disk bevindt, zou het read-only gemount kunnen worden, om de kans te verminderen dat het bestandssysteem tijdens een crash beschadigd raakt. Het /var bestandssysteem bevat bestanden die veranderen, zoals spool directories (voor mail, news, printers, enz.), logbestanden, opgemaakte manual pages, en tijdelijke bestanden. Volgens traditie bevond alles in /var zich ergens onder /usr, maar dat maakte het onmogelijk om /usr read-only te mounten. Het /home bestandssysteem bevat de homedirectories van de gebruikers, d.w.z. alle werkelijke data op het systeem. Het scheiden van homedirectories in hun eigen directory-structuur of bestandssysteem maakt het maken van een backup eenvoudiger; van de andere delen hoeft vaak geen backup te worden gemaakt, of in ieder geval niet zo vaak (ze veranderen zelden). Een grote /home kan in verscheidene bestandssystemen moeten worden opgebroken, wat het toevoegen van een extra niveau aan namen onder /home vereist, b.v. /home/students en /home/staff. Alhoewel de verschillende onderdelen hierboven bestandssystemen werden genoemd, is er geen vereiste dat ze zich werkelijk op aparte bestandssystemen bevinden. Ze zouden makkelijk in een enkel bestandssysteem kunnen worden gehouden als het systeem een klein single-user systeem is en de gebruiker het eenvoudig wil houden. De directory kan ook in verschillende bestandssystemen worden onderverdeeld, afhankelijk van hoe groot de disks zijn, en hoeveel ruimte aan diverse doelen is toegekend. Het belangrijkste deel is echter dat alle standaardnamen werken; zelfs als, laten we zeggen, /var en /usr zich in werkelijkheid op dezelfde partitie bevinden, moeten de namen /usr/lib/libc.a en /var/log/messages werken, bijvoorbeeld door de bestanden onder /var naar /usr/var te verplaatsen, en een symlink /var naar /usr/var te maken. De structuur van een Unix bestandssysteem groepeert de bestanden overeenkomstig naar hun doel, d.w.z. alle commando's staan op één plaats, alle gegevensbestanden op een andere, documentatie op een derde plaats, enzovoort. Een alternatief zou zijn om de bestanden te groeperen naar gelang het programma waar ze toe behoren, d.w.z. alle Emacs bestanden zouden zich in één directory bevinden, alle TeX bestanden in een andere directory, enzovoort. Het probleem met de laatste benadering is dat dit het moeilijk maakt om bestanden te delen (de programmadirectory bevat vaak zowel statische als gemeenschappelijk te gebruiken, veranderlijke en niet gemeenschappelijk te gebruiken bestanden), en soms om de bestanden te kunnen vinden (b.v. manual pages op een groot aantal plaatsen, en ervoor zorgen dat de programma's voor de manual pages ze allemaal kan vinden is een nachtmerrie voor het onderhoud). Het root bestandssysteem Het root bestandssysteem zou in het algemeen klein moeten zijn, aangezien het zeer kritieke bestanden bevat, en een klein, niet frequent, wijzigend bestandssysteem heeft een betere kans om niet beschadigd te raken. Een beschadigd root bestandssysteem zal in het algemeen betekenen dat het systeem niet meer te booten zal zijn, behalve dan met speciale maatregelen (b.v. vanaf een diskette), iets dat je niet zal willen riskeren. De root directory bevat in het algemeen geen bestanden, behalve misschien de standaard boot-image voor het systeem, meestal met de naam /vmlinuz. Alle andere bestanden bevinden zich in de subdirectories van het root bestandssysteem: /bin Commando's die gedurende de systeemstart door normale gebruikers kunnen worden gebruikt (waarschijnlijk na de systeemstart). /sbin Net als /bin, maar de commando's zijn niet voor normale gebruikers bedoeld, alhoewel ze deze wel kunnen gebruiken als dat nodig is en is toegestaan. /etc Configuratiebestanden specifiek voor de computer. /root De homedirectory voor gebruiker root. /lib Gezamenlijke libraries die nodig zijn voor de programma's op het root bestandssysteem. /lib/modules Laadbare kernelmodules, vooral die nodig zijn om het systeem te booten bij het herstellen van calamiteiten (b.v. netwerk en bestandssysteem drivers). /dev Devicebestanden. /tmp Tijdelijke bestanden. Programma's die na de systeemstart draaien, zouden gebruik moeten maken van /var/tmp, niet /tmp, aangezien de eerste zich waarschijnlijk op een disk met meer ruimte bevindt. /boot Bestanden die door de bootstrap loader worden gebruikt, b.v. LILO. Kernel-images worden heel vaak hier bewaard in plaats van in de root directory. Als er veel kernel-images zijn, kan de directory makkelijk nogal groot worden, en het kan beter zijn om ze in een apart bestandssysteem te houden. Een andere reden zou kunnen zijn om er zeker van te zijn dat de kernel-images zich binnen de eerste 1024 cylinders van een IDE-disk bevinden. /mnt Mount point voor tijdelijke mounts voor de systeembeheerder. Van programma's wordt niet verondersteld dat ze automatisch op /mnt mounten. /mnt zou in subdirectories kunnen zijn onderverdeeld (b.v. /mnt/dosa zou een diskettestation kunnen zijn die gebruik maakt van een MS-DOS bestandssysteem, en /mnt/exta kan hetzelfde zijn, maar waarbij een ext2 bestandssysteem wordt gebruikt). /proc, /usr, /var, /home Mount points voor de andere bestandssystemen. De <filename>/etc</filename> directory De /etc directory bevat een heleboel bestanden. Een aantal daarvan wordt hieronder beschreven. Voor anderen zou je vast moeten kunnen stellen aan welk programma ze toebehoren, en de manual page voor dat programma moeten lezen. Bovendien komen er veel netwerkconfiguratiebestanden in /etc voor, en ze worden beschreven in de Networking Administrators' Guide. /etc/rc of /etc/rc.d of /etc/rc?.d Scripts of directories met scripts om bij de systeemstart te draaien of wanneer het run level wordt gewijzigd. Zie het hoofdstuk over init voor verdere informatie. /etc/passwd De gebruikersdatabase, met velden die informatie geven over de gebruikersnaam, de werkelijke naam, de homedirectory, het versleutelde wachtwoord, en andere informatie over iedere gebruiker. Het formaat is gedocumenteerd in de passwd manual page. /etc/fdprm Floppy disk parameter tabel. Beschrijft hoe de verschillende disketteformaten eruitzien. Wordt gebruikt door setfdprm. Zie de setfdprm manual page voor meer informatie. /etc/fstab Een opsomming van de bestandssystemen die bij de systeemstart automatisch worden gemount door het mount -a commando (in /etc/rc of een equivalent opstartbestand). Onder Linux, bevat het ook informatie over swapgebieden die automatisch worden gebruikt door swapon -a. Zie en de mount manual page voor meer informatie. /etc/group Vergelijkbaar met /etc/passwd, maar beschrijft groepen in plaats van gebruikers. Zie de group manual page voor meer informatie. /etc/inittab Configuratiebestand voor init. /etc/issue Uitvoer door getty voor de loginprompt. Bevat meestal een korte beschrijving of welkomstbericht op het systeem. De inhoud wordt bepaald door de systeembeheerder. /etc/magic Het configuratiebestand voor file. Bevat de beschrijvingen van diverse bestandsformaten aan de hand waarvan file het type bestand raadt. Zie de magic en file manual pages voor meer informatie. /etc/motd De melding van de dag, automatische uitvoer na een succesvolle login. De inhoud is aan de systeembeheerder. Wordt vaak gebruikt om informatie aan iedere gebruiker te verstrekken, zoals waarschuwingen over geplande tijden dat het systeem down gaat. /etc/mtab Lijst met thans gemounte bestandssystemen. Als eerste door de opstartscripts ingesteld, en automatisch door het mount commando bijgewerkt. Wordt gebruikt wanneer een lijst met gemounte bestandssystemen nodig is, b.v. door het commando df. /etc/shadow Shadow password bestand op systemen met shadow password software geïnstalleerd. Shadow passwords verplaatst het versleutelde wachtwoord vanuit /etc/passwd naar /etc/shadow; de laatste is niet voor iemand leesbaar, behalve voor root. Dit maakt het moeilijker om wachtwoorden te kraken. /etc/login.defs Configuratiebestand voor het login commando. /etc/printcap Als /etc/termcap, maar dan bedoeld voor printers. Andere syntax. /etc/profile, /etc/csh.login, /etc/csh.cshrc Bestanden die bij de login of de systeemstart door de Bourne of C-shells worden uitgevoerd. Deze staan de systeembeheerder toe om globale standaards voor alle gebruikers in te stellen. Zie de manual pages voor de respectievelijke shells. /etc/securetty Identificeert secure terminals, d.w.z. de terminals waar vanaf root in mag loggen. Kenmerkend is dat alleen de virtuele consoles worden opgesomd, zodat het onmogelijk wordt (of op z'n minst moeilijker) om superuser privileges te verkrijgen door via een modem of een netwerk op het systeem in te breken. /etc/shells Een opsomming van de betrouwbare shells. Het chsh commando staat gebruikers toe om hun login shell te wijzigen naar alleen die shells die in dit bestand worden opgesomd. ftpd, het serverproces dat in FTP-services voor een computer voorziet, zal nagaan of de shell van de gebruiker in het bestand /etc/shells voorkomt, en zal mensen niet in laten loggen tenzij hun shell hierin staat vermeld. /etc/termcap De terminal capaciteiten database. Beschrijft via welke ``escape sequences'' de diverse terminals kunnen worden bestuurd. Programma's zijn zodanig geschreven dat ze, in plaats van het direct uitvoeren van een escape sequence die alleen op een bepaald merk terminal werkt, de juiste sequence opzoeken in /etc/termcap om te doen wat ze moeten doen. Als resultaat werken de meeste programma's met de meeste soorten terminals. Zie de termcap, curs_termcap, en terminfo manual pages voor meer informatie. De <filename>/dev</filename> directory De /dev directory bevat de speciale devicebestanden voor alle devices. De device bestanden zijn benoemd door gebruik te maken van speciale conventies; deze zijn beschreven in de Device list (zie XXX). De devicebestanden worden óf tijdens de installatie óf later met het script /dev/MAKEDEV aangemaakt. /dev/MAKEDEV.local is een script geschreven door de systeembeheerder waarmee slechts de lokale devicebestanden of links worden aangemaakt. (d.w.z. die geen onderdeel uitmaken van de standaard MAKEDEV, zoals devicebestanden voor een aantal niet-standaard devicedrivers). Het <filename>/usr</filename> bestandssysteem Het /usr bestandssysteem is vaak groot, aangezien hier alle programma's in zijn geïnstalleerd. Alle bestanden in /usr zijn normaal gesproken afkomstig van een Linux-distributie; lokaal geïnstalleerde bestanden en andere zaken gaan onder /usr/local. Dit maakt het mogelijk om een update van het systeem uit te voeren met een nieuwe versie van de distributie of zelfs een compleet nieuwe distributie te installeren, zonder alle programma's opnieuw te moeten installeren. Een aantal van de subdirectories van /usr worden hieronder opgesomd (een aantal van de minder belangrijke directories zijn komen te vervallen; zie de FSSTND voor meer informatie). /usr/X11R6 Het X Window System, alle bestanden. Om de ontwikkeling en installatie van X te vereenvoudigen, zijn de X-bestanden niet in de rest van het systeem geïntegreerd. Er bevindt zich een directory-structuur onder /usr/X11R6 die vergelijkbaar is met die onder /usr zelf. /usr/X386 Vergelijkbaar met /usr/X11R6, maar voor X11 Release 5. /usr/bin Bijna alle gebruikerscommando's. Een aantal commando's staan in /bin of in /usr/local/bin. /usr/sbin Systeembeheer commando's die niet nodig zijn op het root bestandssysteem, b.v. de meeste serverprogramma's. /usr/man, /usr/info, /usr/doc Respectievelijk de manual pages, GNU Info documenten, en diverse andere documentbestanden. /usr/include Header files voor de programmeertaal C. Deze zouden zich volgens vaste lijn eigenlijk onder /usr/lib moeten bevinden, maar de traditie is overweldigend om voor deze naam te kiezen. /usr/lib Onveranderlijke gegevensbestanden voor programma's en subsystemen, inclusief een aantal site-wide configuratiebestanden. De naam lib is afkomstig van library; originele libraries van programmeer subroutines werden in /usr/lib opgeslagen. /usr/local De plaats voor lokaal geïnstalleerde software en andere bestanden. Het <filename>/var</filename> bestandssysteem De /var directory bevat data die wijzigt als het systeem onder normale omstandigheden wordt gedraaid. Het is specifiek voor ieder systeem, d.w.z. niet gedeeld over het netwerk met andere computers. /var/catman Een cache voor man pages, welke op verzoek zijn geformatteerd. De source voor manual pages wordt meestal bewaard in /usr/man/man*; het kan zijn dat een aantal manual pages met een voorgeformatteerde versie worden geleverd, die in /usr/man/cat* is opgeslagen. Andere manual pages moeten worden geformatteerd wanneer ze voor het eerst worden bekeken; de geformatteerde versie wordt dan in /var/man opgeslagen, waardoor de volgende persoon, die dezelfde pagina bekijkt, niet hoeft te wachten, totdat het geformatteerd zal zijn. (/var/catman wordt vaak op dezelfde wijze opgeschoond zoals tijdelijke directories worden opgeschoond.) /var/lib Bestanden die veranderen tijdens normaal gebruik van het systeem. /var/local Variabele data voor programma's die in /usr/local zijn geïnstalleerd (d.w.z., programma's die door de systeembeheerder zijn geïnstalleerd). Merk op dat zelfs lokaal geïnstalleerde programma's de andere /var directories zouden moeten gebruiken, als ze passend zijn, b.v. /var/lock. /var/lock Lock bestanden. Veel programma's volgen een conventie om een lockbestand in /var/lock aan te maken om aan te geven dat ze een bepaald device of een bepaald bestand in gebruik hebben. Andere programma's zullen het lockbestand opmerken en niet proberen om het device of het bestand te gebruiken. /var/log Logbestanden van diverse programma's vooral login (/var/log/wtmp, welke alle logins en logouts op het systeem logt) en syslog (/var/log/messages, waarin meestal alle meldingen van de kernel en systeemprogramma's worden opgeslagen). Bestanden in /var/log kunnen onbegrensd groter worden en het kan zijn dat ze geregeld moeten worden opgeschoond. /var/run Bestanden met informatie over het systeem, welke geldig zijn totdat het systeem weer wordt geboot. /var/run/utmp bevat bijvoorbeeld informatie over de mensen die thans zijn ingelogd. /var/spool Directories voor mail, news, afdrukwachtrijen, en andere in een wachtrij geplaatst werk. Ieder andere spool heeft onder /var/spool zijn eigen subdirectory, b.v., de mailboxen van de gebruikers staan in /var/spool/mail. /var/tmp Tijdelijke bestanden die nogal groot zijn of die een langere tijd moeten bestaan dan wat voor /tmp is toegestaan. (Alhoewel het kan zijn dat de systeembeheerder ook de zeer oude bestanden in /var/tmp niet toestaat). Het <filename>/proc</filename> bestandssysteem Het /proc bestandssysteem bevat een bestandssysteem gebaseerd op een illusie. Het bestaat niet op de disk. In plaats daarvan maakt de kernel het in het geheugen aan. Het wordt gebruikt om in informatie over het systeem te voorzien (van origine over processen, vandaar de naam). Een aantal van de belangrijkere bestanden en directories worden hieronder uitgelegd. Het /proc bestandssysteem wordt in meer detail in de proc manual page beschreven. /proc/1 Een directory met informatie over procesnummer 1. Ieder proces heeft een directory onder /proc met als naam zijn proces identificatie nummer. /proc/cpuinfo Informatie over de processor, zoals het type, merk, model, en performance. /proc/devices Lijst met devicedrivers die in de huidige draaiende kernel zijn geconfigureerd. /proc/dma Toont welke DMA kanalen op dit moment worden gebruikt. /proc/filesystems In de kernel geconfigureerde bestandssystemen. /proc/interrupts Toont welke interrupts in gebruik zijn, en hoeveel van ieder er zijn. /proc/ioports Welke I/O poorten op het moment in gebruik zijn. /proc/kcore Een afbeelding van het fysieke geheugen in het systeem. Dit is exact dezelfde grootte als het fysiek aanwezige geheugen, maar neemt in werkelijkheid niet zoveel geheugen in beslag; het wordt tijdens het werken gegenereerd als programma's het benaderen. (Denk eraan: tenzij je het naar elders kopieert, neemt geheel niets onder /proc enige diskruimte in beslag). /proc/kmsg Uitvoer van meldingen door de kernel. Deze worden ook naar syslog gestuurd. /proc/ksyms Symbolentabel voor de kernel. /proc/loadavg De `load average' van het systeem; drie betekenisloze indicators van hoeveel werk het systeem op het moment te doen heeft. /proc/meminfo Informatie over geheugengebruik, zowel fysiek als swap. /proc/modules Welke kernelmodules op het moment zijn geladen. /proc/net Status informatie over netwerkprotocollen. /proc/self Een symbolische link naar de procesdirectory van het programma dat naar /proc kijkt. Als twee processen naar /proc aan het kijken zijn, krijgen ze verschillende links. Dit is voornamelijk om het voor programma's eenvoudiger te maken om hun eigen procesdirectory te bereiken. /proc/stat Diverse statistische gegevens over het systeem, zoals het aantal page faults vanaf het moment dat het systeem werd opgestart. /proc/uptime De tijd dat het systeem actief is. /proc/version De versie van de kernel. Merk op dat ondanks dat de bovenstaande bestanden meestal makkelijk te lezen bestanden zijn, ze soms op een dusdanige manier zijn opgemaakt, dat ze niet makkelijk zijn samen te vatten. Er zijn veel commando's die iets meer doen dan de bovenstaande bestanden inlezen, en ze zodanig indelen dat ze eenvoudiger te begrijpen zijn. Het programma free bijvoorbeeld, leest /proc/meminfo in en converteert de gegeven hoeveelheden bytes naar kilobytes (en voegt bovendien wat meer informatie toe). Disks en Andere Opslagmedia Gebruiken
On a clear disk you can seek forever.
Wanneer je je systeem installeert of een upgrade uitvoert, moet je een tamelijke hoeveelheid werk op je disks verrichten. Je moet bestandssystemen op je disk aanmaken, zodat er bestanden op kunnen worden bewaard, en ruimte reserveren voor de verschillende onderdelen van je systeem. Dit hoofdstuk legt al deze initiële activiteiten uit. Gewoonlijk hoef je al dit werk niet nogmaals te doen, als je je systeem éénmaal hebt ingesteld, behalve dan voor het gebruik van diskettes. Je kunt naar dit hoofdstuk terugkeren als je een nieuwe disk toevoegt of je diskgebruik beter af wilt stemmen. De basistaken bij het beheren van disks zijn: Formatteren van de disk. Dit doet van alles om het voor het gebruik voor te bereiden, zoals het controleren op slechte sectoren. (Formatteren is tegenwoordig voor de meeste harddisks niet nodig). Partitioneer een harddisk, als je het voor verscheidene activiteiten wilt gebruiken, waarvan wordt verondersteld dat ze elkaar niet in de weg zitten. Een reden om te partitioneren is om verschillende besturingssystemen op dezelfde disk op te slaan. Een andere reden is om gebruikersbestanden gescheiden te houden van systeembestanden, wat het maken van de backups vereenvoudigt en helpt bij het beschermen tegen beschadigingen van de systeembestanden. Maak op iedere disk of partitie een bestandssysteem (van een geschikt type) aan. De disk betekent niks voor Linux totdat je er een bestandssysteem op aanmaakt; dan kunnen de bestanden worden aangemaakt en erop worden benaderd. Mount verschillende bestandssystemen om een enkele directory-structuur mee te vormen, of automatisch of handmatig als het nodig is. (Voor handmatig gemounte bestandssystemen moet meestal ook handmatig het umount commando gegeven worden). bevat informatie over virtueel geheugen en diskcaching, waarvan je ook op de hoogte moet zijn, als je van disks gebruik maakt. Twee soorten apparaten UNIX, en daarom Linux, herkent twee verschillende soorten apparaten: willekeurig-toegankelijke block devices (zoals disks), en character devices (zoals tapes en seriële lijnen). Een aantal daarvan zijn serieel en een aantal daarvan willekeurig toegankelijk. Ieder ondersteund apparaat wordt in het bestandssysteem als een devicebestand voorgesteld. Als je van een devicebestand leest of ernaar schrijft, gaat de data van of naar het device dat het voorstelt. Op deze manier zijn er geen speciale programma's (en geen speciale applicatie programmeermethodieken, zoals het afvangen van interrupts of het ondervragen van een seriële poort) nodig om de devices te benaderen; om bijvoorbeeld een bestand naar de printer te sturen, zou men gewoon kunnen opgeven $ cat filename > /dev/lp1 $ en de inhoud van het bestand wordt afgedrukt (het bestand moet natuurlijk wel in een vorm staan die de printer begrijpt). Aangezien het echter geen goed idee is om verscheidene mensen tegelijkertijd met cat hun bestanden naar de printer te laten sturen, maakt men meestal gebruik van een speciaal programma om de af te drukken bestanden te versturen (meestal lpr). Dit programma zorgt ervoor dat er slechts één programma tegelijkertijd wordt afgedrukt en zal bestanden automatisch naar de printer sturen zodra het klaar is met het voorgaande bestand. Iets vergelijkbaars is voor de meeste devices nodig. In feite hoeft men zich zelden druk te maken om devicebestanden. Aangezien devices in het bestandssysteem als bestanden naar voren komen (in de /dev directory), is het makkelijk te zien welke devicebestanden er bestaan, door ls of een ander passend commando te gebruiken. In de uitvoer van ls -l, bevat de eerste kolom het type bestand en zijn permissies. Het inspecteren van een serieel device bijvoorbeeld, geeft op mijn systeem $ ls -l /dev/cua0 crw-rw-rw- 1 root uucp 5, 64 Nov 30 1993 /dev/cua0 $ Het eerste karakter in de eerste kolom, d.w.z. `c' in crw-rw-rw- hierboven, vertelt een geïnformeerde gebruiker het type bestand, in dit geval een character device. Het eerste teken van gewone bestanden is een `-', voor directories is het een `d', en voor block devices een `b'; zie de ls man page voor verdere informatie. Merk op dat alle devicebestanden gewoonlijk wel voorkomen, zelfs al is het apparaat zelf niet geïnstalleerd. Dus ook al heb je een bestand /dev/sda, dan wil dat nog niet zeggen dat je werkelijk een SCSI-harddisk hebt. Het maakt de installatieprogramma's eenvoudiger als alle devicebestanden beschikbaar zijn, en het maakt het makkelijker nieuwe hardware toe te voegen (het is niet nodig om uit te zoeken wat de juiste parameters zijn en de devicebestanden voor het nieuwe apparaat aan te maken). Harddisks Deze subsectie introduceert terminologie gerelateerd aan harddisks. Als je reeds bekend bent met de termen en concepten, kun je deze subsectie overslaan. Zie voor een schematische afbeelding van de belangrijkste onderdelen van een harddisk. Een harddisk bestaat uit één of meer circulaire schijven, De schijven zijn van een harde substantie gemaakt, b.v. aluminium, waaraan de harddisk zijn naam te danken heeft. waarvan beide oppervlakken met een magnetische substantie zijn bedekt, die worden gebruikt voor het opnemen van de gegevens. Voor elk oppervlak is er een lees/schrijf-kop die de opgenomen gegevens onderzoekt of wijzigt. De schijven draaien rondom een gewone as; een typische rotatie-snelheid is 3600 rotaties per minuut, alhoewel high-performance harddisks hogere snelheden halen. De koppen bewegen langs de straal van de schijven; deze beweging gecombineerd met de rotatie van de schijven maakt dat de kop alle delen van de oppervlakken kan benaderen. De processor (CPU) en de feitelijke disk communiceren via een disk controller. Dit zorgt dat de rest van de computer niet bekend hoeft te zijn met hoe de disk moet worden gebruikt, aangezien de controllers voor verschillende typen disks zodanig kan worden gemaakt, dat ze dezelfde interface jegens de rest van de computer gebruiken. Daarom kan de computer gewoon zeggen ``hé disk, geef me wat ik wil'', in plaats van een lange en complexe reeks elektronische signalen om de kop naar de juiste lokatie te verplaatsen en te wachten totdat de juiste positie zich onder de kop bevindt en al het andere onplezierige dat anders nodig zou zijn. (In werkelijkheid is de interface naar de controller nog steeds complex, maar veel minder dan het anders zou zijn). De controller kan ook nog wat anders doen, zoals caching, of het automatisch vervangen van slechte sectoren. Het bovenstaande is meestal voldoende om iets van de hardware te begrijpen. Er is nog veel meer, zoals de motor die de schijven laat draaien en de koppen verplaatst, en de electronica die de werking van de mechanische delen bestuurt, maar het meeste daarvan is niet relevant voor het begrip van de werkende principes van een harddisk. De oppervlakten worden gewoonlijk in concentrische ringen onderverdeeld, die sporen worden genoemd, en deze worden op hun beurt weer onderverdeeld in sectoren. Deze onderverdeling wordt gebruikt om lokaties op de harddisk aan te geven en om diskruimte aan bestanden toe te wijzen. Om een gegeven plaats op de harddisk te vinden zou men kunnen zeggen ``oppervlak 3, spoor 5, sector 7''. Meestal is het aantal sectoren gelijk voor alle sporen, maar een aantal harddisks plaatsen meer sectoren in de buitenste sporen (alle sectoren hebben dezelfde fysieke grootte, dus er passen er meer op de langere buitenste sporen). Een sector bevat 512 bytes aan gegevens. De disk zelf kan geen kleinere hoeveelheden data dan een sector aan.
Een schematische afbeelding van een harddisk.
Ieder oppervlak is op dezelfde manier in sporen (en sectoren) onderverdeeld. Dit betekent dat wanneer de kop voor één oppervlak zich op een spoor bevindt, de koppen van de andere oppervlakten zich ook op de corresponderende sporen bevinden. Alle corresponderende sporen bijelkaar wordt een cylinder genoemd. Het kost tijd om de koppen van het ene naar het andere spoor (cylinder) te verplaatsen, dus door de bijelkaarhorende gegevens die vaak worden benaderd (zoals bijvoorbeeld een bestand) zo te plaatsen dat het zich binnen één cylinder bevindt, is het niet nodig om de koppen te bewegen om alles ervan te kunnen lezen. Dit verbetert de performance. Het is niet altijd mogelijk om bestanden op deze manier te plaatsen; bestanden die op verscheidene plaatsen op de disk worden opgeslagen, worden gefragmenteerd genoemd. Het aantal oppervlakten (of koppen, wat hetzelfde is), cylinders en sectoren variëren nogal; de specificatie van het aantal van ieder wordt de geometrie van een harddisk genoemd. De geometrie wordt gewoonlijk in een speciaal, door een batterij gevoed, geheugengebied opgeslagen dat het CMOS RAM wordt genoemd, vanwaar het besturingssysteem het tijdens de systeemstart of initialiseren van de driver op kan halen. Helaas, de BIOS De BIOS is ingebouwde software die op ROM chips is opgeslagen. Het zorgt onder andere voor de initiële fasen van het booten. heeft een beperking in het ontwerp, wat het onmogelijk maakt om een spoornummer groter dan 1024 in het CMOS RAM te specificeren, wat te weinig is voor een grote harddisk. Om hier iets aan te doen, liegt de harddisk-controller over de geometrie, en vertaalt de adressen die door de computer zijn gegeven in iets dat in de werkelijkheid past. Een harddisk heeft bijvoorbeeld 8 koppen, 2048 sporen, en 55 sectoren per spoor. De nummers zijn compleet imaginair. De controller zou tegen de computer kunnen liegen en beweren dat het 16 koppen, 1024 sporen, en 35 sectoren per spoor heeft, dus de limiet voor sporen niet overschrijdt, en vertaalt het adres dat de computer geeft, door het nummer van de kop te halveren, en het nummer van het spoor te verdubbelen. In werkelijkheid kan de berekening gecompliceerder zijn, omdat de nummers niet zo comfortabel zijn als hier (maar nogmaals, de details zijn voor het begrijpen van het principe niet relevant). Deze vertaling vervormt de kijk van het besturingssysteem op hoe de disk is georganiseerd, wat het dus onmogelijk maakt om de alle-data-op-één-cylinder truc te gebruiken om de performance een zetje te geven. De vertaling is alleen voor IDE-disks een probleem. SCSI disks gebruiken een sequentieel sectornummer (d.w.z. de controller vertaalt een sequentieel sectornummer naar een kop, cylinder, en sector drietal), en een compleet andere methode voor de CPU om met de controller te communiceren, dus ze zijn van het probleem geïsoleerd. Het kan zijn dat de computer echter ook niet bekend is met de werkelijke geometrie van een SCSI-disk. Aangezien Linux de werkelijke geometrie van de disk niet kent, proberen de bestandssystemen zelfs niet eens om de bestanden binnen een enkele cylinder te houden. In plaats daarvan, probeert het sequentieel genummerde sectoren aan bestanden toe te wijzen, wat bijna altijd een vergelijkbare performance oplevert. Dit wordt nog gecompliceerder door on-controller caches, en automatische prefetches die door de controller worden gedaan. Iedere harddisk wordt door een apart devicebestand voorgesteld. Er kunnen (meestal) slechts twee of vier IDE-harddisks zijn. Deze zijn respectievelijk bekend als /dev/hda, /dev/hdb, /dev/hdc, en /dev/hdd. SCSI-harddisks zijn bekend als /dev/sda, /dev/sdb, enzovoort. Er bestaan vergelijkbare conventies voor de namen van andere typen harddisks; zie XXX (device list) voor meer informatie. Merk op dat de devicebestanden voor de harddisks toegang geven tot de gehele disk, zonder rekening te houden met de partities (die hieronder zullen worden besproken), en als je niet voorzichtig bent, is het niet zo moeilijk om de partities of de gegevens die erin staan te ruïneren. De devicebestanden van de disks worden gewoonlijk alleen gebruikt om toegang tot de master boot record te verkrijgen (die ook hierna zal worden besproken). Diskettes Een diskette bestaat uit een flexibel schijfje dat op één of beide zijden is bedekt met een vergelijkbare substantie als een harddisk. De diskette zelf heeft geen lees/schrijfkop, die is in de drive opgenomen. Een diskette correspondeert met één schijf in een harddisk, maar is verwijderbaar en één drive kan worden gebruikt om verschillende diskettes te benaderen, terwijl de harddisk één ondeelbare unit is. Net als een harddisk, is een diskette in sporen en sectoren onderverdeeld (en de twee corresponderende sporen op beide zijden van een diskette vormen een cylinder), maar er zijn er veel minder van dan op een harddisk. Een diskettestation kan meestal voor verscheidene verschillende typen disks gebruikt worden; bijvoorbeeld, een 3.5 inch drive kan gebruikt worden voor 720 kB en 1.44 MB disks. Aangezien de drive iets anders moet werken en het besturingssysteem moet weten hoe groot de disk is, zijn er diverse devicebestanden voor diskettestations, één per combinatie van drive en disktype. Daarom is /dev/fd0H1440 het eerste diskettestation (fd0), wat een 3.5 inch drive moet zijn, waarbij gebruik wordt gemaakt van een 3.5 inch, high density disk (H) of grootte 1440 kB (1440), d.w.z. een normale 3.5 inch HD diskette. Voor meer informatie over de naamgeving voor de floppy-devices, zie XXX (device list). De namen voor diskettestations zijn echter complex, en Linux heeft daarom een speciaal type diskettedevice dat het type disk in de drive automatisch detecteert. Het probeert van een nieuw ingevoegde diskette de eerste sector te lezen, waarbij verschillende typen diskettes worden gebruikt, totdat het correcte type wordt gevonden. Dit vereist natuurlijk wel dat de diskette eerst is geformatteerd. De automatische devices worden /dev/fd0, /dev/fd1, enzovoort, genoemd. De parameters die het automatische device gebruikt om de disk te benaderen, kunnen ook met behulp van het programma setfdprm worden ingesteld. Dit kan handig zijn als je disks moet gebruiken die niet voldoen aan enige gebruikelijke diskformaten, d.w.z. als ze een ongewoon aantal sectoren heeft, of als de automatische detectie om één of andere reden mislukt en het juiste devicebestand ontbreekt. Linux kan veel niet-standaard disketteformaten hanteren in aanvulling op alle standaard disketteformaten. Een aantal hiervan vereisen speciale formatteringsprogramma's. We zullen deze disktypen nu overslaan, maar in de tussentijd kun je het bestand /etc/fdprm onderzoeken. Het specificeert de instellingen die setfdprm herkent. Het besturingssysteem moet weten wanneer er van disk in het diskettestation is verwisseld, bijvoorbeeld om te voorkomen dat gegevens van de vorige disk die in de cache zijn geplaatst, worden gebruikt. Helaas is de signaallijn, die hiervoor wordt gebruikt, soms wat gebrekkig, en wat nog erger is, dit zal niet altijd worden opgemerkt als de drive onder MS-DOS wordt gebruikt. Als je vreemde problemen ervaart bij het gebruik van diskettes, zou dit de reden kunnen zijn. De enige manier om dit te corrigeren, is om je diskettestation te repareren. CD-ROM's Een CD-ROM drive gebruikt een optisch leesbare met plastic bedekte disk. De informatie wordt op het oppervlak van de disk opgenomen Dat wil zeggen, het oppervlak in de disk, op de metalen disk onder de plastic laag. in kleine `openingen' die langs een spiraal vanaf het midden tot aan de rand zijn gecentreerd. De drive stuurt een laserstraal langs de spiraal om de disk te lezen. Als de laser een opening raakt, kaatst de laser op de ene manier terug; wanneer het glad oppervlak raakt, wordt het op een andere manier teruggekaatst. Op deze manier is het makkelijk om bits, en daarom informatie, te coderen. De rest is eenvoudig, niets anders dan mechanica. CD-ROM drives zijn vergeleken met harddisks langzaam. Terwijl een typische harddisk een gemiddelde zoektijd heeft die minder is dan 15 milliseconden, kan een snelle CD-ROM drive tienden van seconden voor het zoeken gebruiken. De eigenlijke snelheid van het gegevenstransport is tamelijk hoog met honderden kilobytes per seconde. De traagheid betekent dat CD-ROM drives niet zo plezierig zijn om te gebruiken dan harddisks (een aantal Linux distributies voorzien in `live' bestandssystemen op CD-ROM's, wat het onnodig maakt om de bestanden naar de harddisk te kopiëren, wat de installatie eenvoudiger maakt en een hoop harddiskruimte bespaart), alhoewel het nog steeds mogelijk is. CD-ROM's zijn voor het installeren van nieuwe software erg goed, aangezien de maximumsnelheid tijdens de installatie niet essentieel is. Er zijn verscheidene manieren om gegevens op een CD-ROM te arrangeren. De populairste is gespecificeerd door de internationale standaard ISO 9660. Deze standaard specificeert een zeer minimaal bestandssysteem, welke zelfs nog primitiever is dan die van MS-DOS. Aan de andere kant, is het zo minimaal dat ieder besturingssysteem het in het daarbij behorend systeem zou moeten kunnen indelen. Voor normaal UNIX gebruik, is het ISO 9660 bestandssysteem niet bruikbaar, dus werd er een uitbreiding op de standaard ontwikkeld, die de Rock Ridge extensie wordt genoemd. Rock Ridge staat langere bestandsnamen, symbolische links en een heleboel ander moois toe, wat maakt dat een CD-ROM min of meer op ieder UNIX bestandssysteem van deze tijd lijkt. Zelfs beter, een Rock Ridge bestandssysteem is nog steeds een geldig ISO 9660 bestandssysteem, waardoor het bovendien ook bruikbaar is voor niet-UNIX systemen. Linux biedt ondersteuning voor zowel ISO 9660 als de Rock Ridge extensies; de extensies worden automatisch herkend en gebruikt. Het bestandssysteem is echter slechts de helft van de overwinning. De meeste CD-ROM's bevatten gegevens waarvoor een speciaal programma is vereist om ze te benaderen, en de meeste programma's hiervan draaien niet onder Linux (behalve, mogelijk onder dosemu, de Linux MS-DOS emulator). Een CD-ROM drive wordt via een corresponderend devicebestand benaderd. Er zijn verscheidene manieren om een CD-ROM drive met de computer te verbinden: via SCSI, via een geluidskaart, of via EIDE. Het hardware gedeelte dat nodig was om dit te doen, valt buiten het kader van dit boek, maar het type verbinding bepaalt het devicebestand. Zie XXX (device-list) voor verduidelijking. Tapes Een tape drive gebruik een tape, zoals Maar natuurlijk compleet anders. cassettes voor muziek worden gebruikt. Een tape is van nature serieel, wat betekent dat om enig deel ervan te krijgen, je eerst alle andere delen die ertussen staan, moet doorlopen. Een disk kan willekeurig worden benaderd, d.w.z. dat je direct naar iedere plaats op de disk kunt gaan. De seriële toegang op tapes maakt ze langzaam. Aan de andere kant zijn tapes relatief goedkoop te maken, aangezien ze niet snel hoeven te zijn. Ze kunnen ook makkelijk erg lang worden gemaakt, en kunnen daarom een grote hoeveelheid data bevatten. Dit maakt tapes zeer geschikt voor zaken zoals archivering en backups, welke geen grote snelheden vereisen, maar waar wel wordt geprofiteerd van de lage kosten en grote opslagcapaciteit. Formatteren Formatteren is het proces waarbij markeringen op de magnetische media worden geschreven, die worden gebruikt om sporen en sectoren te markeren. Voordat een disk wordt geformatteerd, is het magnetische oppervlak een chaos van magnetische signalen. Als het is geformatteerd, is er een volgorde in de chaos aangebracht door werkelijk lijnen te tekenen daar waar de sporen gaan, en waar ze in sectoren worden ingedeeld. De eigenlijke details zijn niet helemaal zoals het hier is beschreven, maar dat is irrelevant. Wat belangrijk is, is dat een disk niet kan worden gebruikt, tenzij het is geformatteerd. De terminologie is hier wat verwarrend: in MS-DOS wordt het woord formattering gebruikt om ook het proces, waarbij een bestandssysteem (wat hieronder zal worden besproken) wordt aangemaakt, te omvatten. Daar worden de twee processen, vooral voor diskettes, vaak gecombineerd. Als er onderscheid moet worden gemaakt, wordt de werkelijke formattering low-level formattering genoemd, terwijl het maken van het bestandssysteem high-level formattering wordt genoemd. In UNIX kringen worden deze twee formatteren en het aanmaken van een bestandssysteem genoemd, dus dat is wat dan ook in dit boek wordt gebruikt. Voor IDE en een aantal SCSI-disks vindt de formattering in feite in de fabriek plaats en hoeft dit niet te worden herhaald; vandaar dat de meeste mensen zich er niet om hoeven te bekommeren. In feite kan het formatteren van een harddisk veroorzaken dat het minder goed werkt, bijvoorbeeld omdat het kan zijn dat een disk op één of andere speciale manier moet worden geformatteerd, om automatische vervanging van slechte sectoren toe te kunnen staan. Disks die moeten of kunnen worden geformatteerd, vereisen vaak hoe dan ook een speciaal programma, omdat de interface naar de formatterings logica binnenin de drive van drive tot drive verschillend is. Het formatteringsprogramma bevindt zich of op de controller BIOS, of wordt als een MS-DOS programma meegeleverd; geen van beiden kunnen onder Linux op eenvoudige wijze worden gebruikt. Het kan zijn dat er tijdens het formatteren slechte plekken op de disk worden geconstateerd, die bad blocks of bad sectors worden genoemd. Deze worden soms door de drive zelf afgehandeld, maar zelfs dan, als er zich meer van ontwikkelen, moet er soms iets worden gedaan om te voorkomen dat die delen van de disk worden gebruikt. De logica om dit te doen is in het bestandssysteem ingebouwd; hoe je de informatie aan het bestandssysteem toe kunt voegen, wordt hieronder beschreven. Als alteratief zou men een kleine partitie aan kunnen maken, die slechts het slechte deel van de disk bedekt; deze benadering zou een goed idee kunnen zijn als de slechte plek erg groot is, aangezien bestandssystemen soms problemen hebben met zeer grote slechte gebieden. Diskettes worden met fdformat geformatteerd. Het devicebestand voor de diskette moet als een parameter worden gebruikt. Het volgende commando zou bijvoorbeeld een high density 3.5 inch diskette in het eerste diskettestation formatteren: $ fdformat /dev/fd0H1440 Double-sided, 80 tracks, 18 sec/track. Total capacity 1440 kB. Formatting ... done Verifying ... done $ Noot: als je een device wilt gebruiken dat de diskette automatisch detecteert (b.v. /dev/fd0), moet je eerst de parameters van het device met setfdprm instellen. Om hetzelfde effect als hierboven te verkrijgen, zou men het volgende moeten doen: $ setfdprm /dev/fd0 1440/1440 $ fdformat /dev/fd0 Double-sided, 80 tracks, 18 sec/track. Total capacity 1440 kB. Formatting ... done Verifying ... done $ Het is meestal beter om het juiste devicebestand te kiezen dat met het type diskette overeenkomt. Noot: het is niet verstandig om diskettes te formatteren zodanig dat er meer informatie op past dan waar ze voor zijn ontworpen. fdformat zal de diskette ook valideren; d.w.z. controleren op slechte blokken. Het zal een slecht blok verscheidene keren proberen (je kunt dit meestal horen, doordat de geluiden die de drive produceert, dramatisch wijzigen). Als de diskette slechts marginaal slecht is (vanwege vuil op de lees/schrijfkop, een aantal fouten zijn onjuiste signalen), zal fdformat hier niet over klagen, maar een echte fout zal het valideringsproces afbreken. De kernel zal voor iedere I/O error die het vindt, logmeldingen afdrukken; deze zullen naar de console gaan of, als syslog in gebruik is, naar het bestand /usr/log/messages. fdformat zal zelf niet vertellen waar de fout in zit (meestal is men hier niet in geïnteresseerd, diskettes zijn goedkoop genoeg dat een slechte diskette al automatisch wordt weggegooid). $ fdformat /dev/fd0H1440 Double-sided, 80 tracks, 18 sec/track. Total capacity 1440 kB. Formatting ... done Verifying ... read: Unknown error $ Het commando badblocks kan worden gebruikt om iedere disk of partitie te doorzoeken op slechte blokken (inclusief een diskette). De disk wordt niet geformatteerd, dus het kan zelfs worden gebruikt om bestaande bestandssystemen te controleren. Het voorbeeld hieronder controleert een 3.5 inch diskette met twee slechte blokken. $ badblocks /dev/fd0H1440 1440 718 719 $ badblocks geeft als uitvoer de slechte blokken die het gevonden heeft. De meeste bestandssystemen kunnen dergelijke slechte blokken omzeilen. Er wordt een lijst beheerd met bekende slechte blokken, die wordt geïnitialiseerd als het bestandssysteem wordt gemaakt, en kan later worden gewijzigd. Het initiële onderzoek naar slechte blokken kan met het commando mkfs worden gedaan (die het bestandssysteem initialiseert), maar latere controles zouden met badblocks moeten worden gedaan en de nieuwe blokken zouden met fsck moeten worden toegevoegd. We zullen mkfs en fsck later bespreken. Veel moderne harddisks constateren de slechte blokken automatisch, en proberen ze door een speciaal gereserveerd goed blok te herstellen. Voor het besturingssysteem is dit niet zichtbaar. Deze eigenschap zou in het handboek van de disk moeten zijn gedocumenteerd, mocht je benieuwd zijn of hier sprake van is. Zelfs dergelijke disks kunnen in gebreke blijven, als het aantal slechte blokken teveel wordt, alhoewel de kans bestaat dat de disk tegen die tijd zo slecht is dat ze niet meer bruikbaar is. Partities Een harddisk kan in verscheidene partities worden onderverdeeld. Iedere partitie functioneert alsof het een aparte harddisk is. De gedachte hierachter is, dat als je één harddisk hebt, en je wilt er, laten we zeggen, twee besturingssystemen op, dan kun je de disk in twee partitities verdelen. Ieder besturingssysteem gebruikt zijn eigen partitie zoals dat het wenst en komt niet aan die van de ander. Op deze manier kunnen de twee besturingssystemen op dezelfde harddisk gerust naast elkaar bestaan. Zonder partities zou men voor ieder besturingssysteem een harddisk moeten kopen. Diskettes zijn niet gepartitioneerd. Er is hier geen technische reden voor, maar aangezien ze zo klein zijn, zouden partities slechts zeer zelden van nut zijn. CD-ROM's worden gewoonlijk ook niet gepartitioneerd, aangezien het eenvoudiger is om ze te gebruiken als één grote disk, en het zelden nodig is om verscheidene besturingssystemen op één CD-ROM te hebben. De MBR, bootsector en partitietabel De informatie over hoe een harddisk is gepartitioneerd, wordt in de eerste sector van de harddisk opgeslagen (dat wil zeggen, op de eerste sector van het eerste spoor op het eerste diskoppervlak). De eerste sector is de master boot record (MBR) van de disk; dit is de sector die de BIOS inleest en start wanneer de computer voor het eerst wordt opgestart. De master boot record bevat een klein programma dat de partitietabel inleest, controleert welke partitie actief is (d.w.z. als opstartbaar is gemarkeerd), en leest de eerste sector van die partitie in, de boot sector van de partitie. (De MBR is ook een bootsector, maar het heeft een speciale status en heeft daarom een speciale naam). Deze bootsector bevat een ander klein programma dat het eerste deel van het besturingssysteem inleest, die op die partitie is opgeslagen (in de veronderstelling dat het opstartbaar is), en start het dan op. Het partitioneringsschema is niet in de hardware en zelfs niet in de BIOS ingebouwd. Het is slechts een conventie die veel besturingssystemen volgen. Niet alle besturingssystemen volgen het, maar dat zijn de uitzonderingen. Een aantal besturingssystemen ondersteunen partities, maar ze nemen slechts één partitie op de harddisk in beslag, en gebruiken binnen die partitie hun eigen interne partioneringsmethode. Het laatste type kan gerust naast andere besturingssystemen (waaronder Linux) bestaan, en vereist geen speciale maatregelen, maar een besturingssysteem dat geen partities ondersteunt, kan niet op dezelfde disk met andere besturingssystemen bestaan. Als voorzorgsmaatregel is het een goed idee om de partitietabel op een stukje papier te schrijven, zodat als het ooit beschadigd, je niet al je bestanden hoeft kwijt te raken. (Een slechte partitietabel kan met fdisk worden hersteld). De relevante informatie wordt gegeven door het commando fdisk -l: $ fdisk -l /dev/hda Disk /dev/hda: 15 heads, 57 sectors, 790 cylinders Units = cylinders of 855 * 512 bytes Device Boot Begin Start End Blocks Id System /dev/hda1 1 1 24 10231+ 82 Linux swap /dev/hda2 25 25 48 10260 83 Linux native /dev/hda3 49 49 408 153900 83 Linux native /dev/hda4 409 409 790 163305 5 Extended /dev/hda5 409 409 744 143611+ 83 Linux native /dev/hda6 745 745 790 19636+ 83 Linux native $ Extended en logische partities Het originele partitioneringsschema voor PC harddisks stond slechts vier partities toe. Dit bleek in het echte leven al snel te weinig te zijn, deels omdat een aantal mensen meer dan vier besturingssystemen wilde (Linux, MS-DOS, OS/2, Minix, FreeBSD, NetBSD, of Windows/NT, om er maar een paar te noemen), maar in de eerste plaats omdat het soms goed is om verscheidene partities voor één besturingssysteem te hebben. Swap space voor Linux bijvoorbeeld, kan het beste in een eigen partitie worden geplaatst in plaats van in de Linux hoofdpartitie om redenen van snelheid (zie hieronder). Om iets aan dit ontwerpprobleem te doen, werden er extended partities uitgevonden. Deze truc staat het toe dat een primaire partitie in sub-partities wordt onderverdeeld. De primaire partitie die wordt onderverdeeld is dus de extended partitie; de subpartities zijn de logische partities. Ze gedragen zich als primaire Onlogisch? partities, maar worden anders aangemaakt. Er zit geen verschil in snelheid tussen. De partitiestructuur van een harddisk kan er ongeveer zo uitzien als in . De disk is in drie primaire partities onderverdeeld, de tweede daarvan is in twee logische partities verdeeld. Een deel van de disk is in het geheel niet gepartitioneerd. De disk in z'n geheel en iedere primaire partitie heeft een bootsector.
Een voorbeeld van een harddisk partitionering.
Partitie typen De partitietabellen (degene in de MBR, en die voor de extended partities) bevatten per partitie één byte waarin het type van die partitie wordt aangegeven. Hiermee wordt geprobeerd het besturingssysteem te identificeren, dat van de partitie gebruik maakt of waar het de partitie voor gebruikt. Het doel is om het mogelijk te maken te voorkomen dat twee besturingssystemen per ongeluk dezelfde partitie gebruiken. In werkelijkheid doet het type partitie er voor besturingssystemen niet zoveel toe; b.v. Linux maakt het helemaal niet uit wat het is. Wat nog erger is, is dat een aantal ervan het onjuist gebruiken; b.v. op z'n minst negeren een aantal versies van DR-DOS het meest sigificante bit van de byte, terwijl andere dat niet doen. Er is geen instelling voor de standaardisering om aan te geven wat iedere waarde van een byte betekent, maar een aantal algemeen geaccepteerde bytes staan in . Dezelfde lijst is beschikbaar in het Linux programma fdisk. Partitie typen (van het Linux programma <command>fdisk</command> ). 0 Empty 40 Venix 80286 94 Amoeba BBT 1 DOS 12-bit FAT 51 Novell? a5 BSD/386 2 XENIX root 52 Microport b7 BSDI fs 3 XENIX usr 63 GNU HURD b8 BSDI swap 4 DOS 16-bitf <32M 64 Novell c7 Syrinx 5 Extended 75 PC/IX db CP/M 6 DOS 16-bit >=32M 80 Old MINIX e1 DOS access 7 OS/2 HPFS 81 Linux/MINIX e3 DOS R/O 8 AIX 82 Linux swap f2 DOS secondary 9 AIX bootable 83 Linux native ff BBT a OS/2 Boot Manag 93 Amoeba
Partitioneren van een harddisk Er zijn veel programma's voor het aanmaken en verwijderen van partities. De meeste besturingsprogramma's hebben hun eigen programma's, en het kan een goed idee zijn om het bij het besturingsprogramma behorende programma te gebruiken, gewoon voor het geval er zich iets ongewoons voordoet dat de andere programma's niet kennen. Veel van de programma's worden fdisk genoemd, inclusief die van Linux, of variaties daarop. Details over het gebruik van Linux fdisk worden gegeven in de man page van fdisk. Het cfdisk commando is vergelijkbaar met fdisk, maar heeft een mooiere (schermvullende) gebruikersinterface. Bij gebruik van IDE-disks, moet de bootpartitie (de partitie met de startbare kernel image bestanden) zich volledig binnen de eerste 1024 cylinders bevinden. Dit is omdat de disk tijdens het booten via de BIOS wordt gebruikt (voordat het systeem naar de protected mode overgaat), en de BIOS kan niet meer dan 1024 cylinders hanteren. Soms is het mogelijk om een bootpartitie te gebruiken die zich slechts gedeeltelijk binnen de eerste 1024 cylinders bevindt. Dit werkt zolang alle bestanden die door de BIOS worden ingelezen binnen de eerste 1024 voorkomen. Aangezien dit moeilijk te regelen valt, is het een zeer slecht idee om dit te doen; je weet nooit of een update van de kernel of het defragmenteren van een disk in een systeem resulteert waarmee niet meer kan worden opgestart. Zorg er daarom voor dat je bootpartitie zich volledig binnen de eerste 1024 cylinders bevindt. Een aantal nieuwere versies van de BIOS en IDE-disks kunnen, in feite, disks met meer dan 1024 cylinders hanteren. Als je een dergelijk systeem hebt kun je het probleem vergeten; als je er niet helemaal zeker van bent, plaats het dan binnen de eerste 1024 cylinders. Iedere partitie zou uit een even aantal sectoren moeten bestaan, aangezien de Linux bestandssystemen een blokgrootte van 1 kilobyte gebruiken, d.w.z. twee sectoren. Een oneven aantal sectoren zal er in resulteren dat de laatste sector niet zal worden gebruikt. Dit zal niet in enige problemen resulteren, maar het is lelijk, en een aantal versies van fdisk zal hier een waarschuwing over geven. Het wijzigen van de grootte van een partitie vereist normaal gesproken dat je een backup maakt van alles wat je van die partitie wilt bewaren (bij voorkeur van de gehele disk, voor het geval dat), de partitie verwijdert, een nieuwe partitie aanmaakt, en dan alles op de nieuwe partitie terugzet. Als de partitie groter wordt, kan het zijn dat je bovendien ook de groottes van de aangrenzende partities aan moet passen (en er een backup van moet maken en de gegevens terug moet zetten). Aangezien het veranderen van de grootte van een partitie nogal pijnlijk is, heb je bij voorkeur de partities gelijk de eerste keer goed, of heb je een effectief en makkelijk te gebruiken backupsysteem. Als je vanaf media installeert, waarbij niet veel menselijke interactie is vereist (zoals bijvoorbeeld vanaf CD-ROM, in tegenstelling tot diskettes), is het vaak makkelijker om eerst met verschillende configuraties te spelen. Aangezien je er toch nog geen gegevens op hebt staan, is het niet zo pijnlijk om de grootte van de partitie verscheidene malen te wijzigen. Er is een programma voor MS-DOS, met de naam fips, welke de grootte van een MS-DOS partitie wijzigt zonder dat het maken van een backup en het terugzetten van de gegevens is vereist, maar voor andere bestandssystemen is het nog steeds nodig. Devicebestanden en partities Iedere partitie en extended partitie heeft een eigen devicebestand. De naamgeving voor deze bestanden bestaat hieruit dat het nummer van een partitie aan de naam van de gehele disk wordt toegevoegd, met de afspraak dat 1-4 primaire partities zijn (ongeacht hoeveel primaire partities er zijn) en 5-8 logische partities (ongeacht binnen welke primaire partitie ze voorkomen). Bijvoorbeeld, /dev/hda1 is de eerste partitie op de eerste IDE harddisk, en /dev/sdb7 is de derde extended partitie op de tweede SCSI harddisk. De device lijst in XXX (device list) geeft meer informatie. Bestandssystemen Wat zijn bestandssystemen? Een bestandssysteem bestaat uit de methode en gegevensstructuren die een besturingssysteem gebruikt om bestanden op een disk of partitie bij te houden; d.w.z. de manier waarop bestanden op de disk zijn georganiseerd. Het woord wordt ook gebruikt om naar een partitie of disk te refereren, die wordt gebruikt om de bestanden of het type bestandssysteem op te slaan. Dus men zou kunnen zeggen: ``Ik heb twee bestandssystemen'', met de betekenis dat men twee partities heeft waarop bestanden worden opgeslagen, of dat men het ``extended bestandssysteem gebruikt'' met de betekenis van het type bestandssysteem. Het verschil tussen een disk of partitie en het bestandssysteem dat het bevat is belangrijk. Een paar programma's (waaronder, voor voldoende redenering vatbaar, programma's die bestandssystemen aanmaken) werken direct met de onbewerkte sectoren van een disk of partitie; als er een bestaand bestandssysteem op voorkomt, zal het worden vernietigd of ernstig worden beschadigd. De meeste programma's werken op een bestandssysteem, en zullen daarom niet functioneren op een partitie, waarop er zich geen bevindt (of waarop zich er één bevindt van het verkeerde type). Voordat een partitie of disk als een bestandssysteem kan worden gebruikt, moet het worden geïnitialiseerd en de gegevensstructuren voor het beheer moeten naar disk worden geschreven. Dit proces wordt het maken van een bestandssysteem genoemd. De meeste UNIX typen bestandssystemen hebben een vergelijkbare algemene structuur, alhoewel de exacte details nogal variëren. De centrale concepten zijn superblock, inode, data block, directory block, en indirection block. In het superblock staat informatie over het bestandssysteem in zijn geheel, zoals de grootte (de exacte informatie hangt hier af van het bestandssysteem). In een inode staat alle informatie over een bestand, behalve de naam van het bestand. De naam is in de directory opgeslagen, samen met het nummer van de inode. Een directory-ingang bestaat uit een bestandsnaam en het nummer dat het bestand voorstelt. De inode bevat de nummers van verscheidene gegevensblokken, die worden gebruikt om de gegevens in het bestand op te slaan. Er is in de inode slechts ruimte voor een paar data block nummers, als er echter meer nodig zijn, wordt meer ruimte voor verwijzingen naar de gegevensblokken dynamisch toegekend. Deze dynamisch toegekende blokken zijn indirecte blokken; de naam geeft aan dat, om het data block te kunnen vinden, men eerst het nummer in het indirecte block moet opzoeken. UNIX bestandssystemen staan gewoonlijk toe dat er een hole in een bestand kan worden aangemaakt (dit wordt met lseek gedaan; kijk de manual page er op na), wat betekent dat het bestandssysteem doet alsof er een bepaalde plaats in het bestand met slechts nul bytes is, maar er worden geen feitelijke disksectoren gereserveerd voor die plaats in het bestand (dit betekent dat het bestand wat minder diskruimte zal gebruiken). Dit gebeurt vooral vaak met kleine uitvoerbare bestanden, Linux shared libraries, een aantal databases en in een paar andere gevallen. (``Holes'' worden geïmplementeerd door een speciale waarde als het adres van het gegevensblok in het indirecte blok of de inode op te slaan). Dit speciale adres betekent dat er geen datablock voor dat deel van het bestand is toegekend, derhalve is er een ``hole'' in een bestand). Holes zijn beperkt bruikbaar. Op het systeem van de auteur toonde een eenvoudige maatregel een potentieel van ongeveer 4 MB aan besparing door holes van ongeveer 200 MB totaal gebruikte diskruimte. Dat systeem bevat echter relatief weinig programma's en geen databasebestanden. Bestandssystemen in overvloed Linux ondersteunt verscheidene typen bestandssystemen. Tijdens dit schrijven zijn de belangrijkste: minix Het oudste, vermoedelijk betrouwbaarste besturingssysteem, maar het is zeer beperkt qua mogelijkheden. Een deel van de tijdregistratie ontbreekt, bestandsnamen mogen uit maximaal 30 tekens bestaan en het is beperkt in capaciteit (maximaal 64 MB per bestandssysteem). xia Een gewijzigde versie van het minix bestandssysteem, dat de beperkingen betreffende de bestandsnamen en de grootte van bestandsnamen elimineert, maar op geen enkele andere wijze nieuwe mogelijkheden introduceert. Het is niet erg populair, maar er is van gerapporteerd dat het erg goed werkt. ext2 Het native Linux bestandssysteem met de meeste mogelijkheden, en op het moment ook het populairste. Het is ontworpen om upwards compatibel te zijn, zodat nieuwe versies van de code van het bestandssysteem niet vereisen dat bestaande bestandssystemen opnieuw moeten worden gemaakt. ext Een oudere versie van ext2 dat niet upwards compatibel was. Het wordt nog nauwelijks gebruikt in nieuwe installaties, en de meeste mensen zijn op ext2 overgegaan. Bovendien is er ondersteuning voor verscheidene niet bij Linux behorende bestandssystemen, om het makkelijker te maken bestanden uit te wisselen met andere besturingssystemen. Deze niet bij Linux behorende bestandssystemen werken net als native bestandssystemen, behalve dat er misschien een aantal gebruikelijke UNIX eigenschappen in ontbreken, of dat ze vreemde beperkingen of andere rariteiten hebben. msdos Compatibiliteit met MS-DOS (en OS/2 en Windows NT) FAT bestandssystemen. usmdos Breidt het MS-DOS bestandssysteem onder Linux uit met lange bestandsnamen, eigenaren, permissies, links en devicebestanden. Hierdoor kan een normaal MS-DOS bestandssysteem worden gebruikt alsof het een Linux bestandssysteem is, dus waarbij de noodzaak voor een aparte partitie voor Linux wordt weggenomen. iso9660 Het standaard CD-ROM bestandssysteem; de populaire Rock Ridge extensie op de CD-ROM standaard, die langere bestandsnamen toestaat, wordt automatisch ondersteund. nfs Een netwerk bestandssysteem, dat toestaat dat een bestandssysteem tussen vele computers wordt gedeeld om eenvoudig toegang tot de bestanden op alle computers te verkrijgen. hpfs Het OS/2 bestandssysteem. sysv SystemV/386, Coherent, en Xenix bestandssystemen. De keuze van het te gebruiken bestandssysteem hangt van de situatie af. Als compatibiliteit of andere redenen één van de niet-native bestandssystemen noodzakeljk maakt, dan moet dat worden gebruikt. Als men vrij kan kiezen, dan is het waarschijnlijk het verstandigst om ext2 te gebruiken, aangezien het alle eigenschappen heeft, maar geen schade lijdt door een gebrek aan performance. Er is ook nog het proc bestandssysteem, meestal toegankelijk als de /proc directory, wat eigenlijk helemaal geen bestandssysteem is, ook al lijkt het er op. Het proc bestandssysteem maakt het makkelijk om bepaalde gegevensstructuren van de kernel te benaderen, zoals de lijst met processen (vandaar de naam). Het maakt dat deze gegevensstructuren op een bestandssysteem lijkt, en dat het bestandssysteem met alle gebruikelijke tools voor bestanden kan worden gemanipuleerd. Om bijvoorbeeld een lijst met alle processen te krijgen, kan men het volgende commando gebruiken: $ ls -l /proc total 0 dr-xr-xr-x 4 root root 0 Jan 31 20:37 1 dr-xr-xr-x 4 liw users 0 Jan 31 20:37 63 dr-xr-xr-x 4 liw users 0 Jan 31 20:37 94 dr-xr-xr-x 4 liw users 0 Jan 31 20:37 95 dr-xr-xr-x 4 root users 0 Jan 31 20:37 98 dr-xr-xr-x 4 liw users 0 Jan 31 20:37 99 -r--r--r-- 1 root root 0 Jan 31 20:37 devices -r--r--r-- 1 root root 0 Jan 31 20:37 dma -r--r--r-- 1 root root 0 Jan 31 20:37 filesystems -r--r--r-- 1 root root 0 Jan 31 20:37 interrupts -r-------- 1 root root 8654848 Jan 31 20:37 kcore -r--r--r-- 1 root root 0 Jan 31 11:50 kmsg -r--r--r-- 1 root root 0 Jan 31 20:37 ksyms -r--r--r-- 1 root root 0 Jan 31 11:51 loadavg -r--r--r-- 1 root root 0 Jan 31 20:37 meminfo -r--r--r-- 1 root root 0 Jan 31 20:37 modules dr-xr-xr-x 2 root root 0 Jan 31 20:37 net dr-xr-xr-x 4 root root 0 Jan 31 20:37 self -r--r--r-- 1 root root 0 Jan 31 20:37 stat -r--r--r-- 1 root root 0 Jan 31 20:37 uptime -r--r--r-- 1 root root 0 Jan 31 20:37 version $ (Er zullen echter een paar extra bestanden zijn, die niet met processen corresponderen. Het voorbeeld hierboven is ingekort.) Noot: zelfs al wordt het een bestandssysteem genoemd, geen enkel deel van het proc bestandssysteem raakt enige disk aan. Het bestaat alleen in de verbeelding van de kernel. Wanneer iemand ooit naar enig onderdeel van het proc bestandssysteem probeert te kijken, zorgt de kernel ervoor dat het erop lijkt alsof het onderdeel ergens bestaat, zelfs al is dit niet zo. Dus zelfs als er een uit meerdere megabytes bestaand /proc/kcore bestand is, neemt het geen enkele diskruimte in beslag. Welk bestandssysteem zou moeten worden gebruikt? Het heeft meestal weinig zin om verschillende bestandssystemen te gebruiken. Op het moment is ext2fs de populairste en is het waarschijnlijk de verstandigste keuze. Afhankelijk van de overhead voor het bijhouden van de structuren, de snelheid, (waargenomen) betrouwbaarheid, compabiliteit, en diverse andere redenen, kan het aan te raden zijn om een ander bestandssysteem te gebruiken. Dit moet van geval-tot-geval worden beslist. Aanmaken van een bestandssysteem Bestandssystemen worden aangemaakt, d.w.z. geïnitialiseerd met het commando mkfs. Er is in feite voor ieder type bestandssysteem een apart programma. mkfs is slechts een front end dat het passende programma uitvoert, afhankelijk van het gewenste type bestandssysteem. Het type wordt met de optie geselecteerd. De programma's die door mkfs worden aangeroepen hebben een iets andere commando-regel interface. De algemene en belangrijkste opties worden hieronder samengevat; zie de manual pages voor meer informatie. Selecteer het type bestandssysteem. Zoek naar slechte blokken en inititaliseer de lijst met slechte blokken dienovereenkomstig. -l filename Lees de lijst met initiële slechte blokken vanuit het bestand met de opgegeven naam. Om een ext2 bestandssysteem op een diskette aan te maken, zou men de volgende commando's op kunnen geven: $ fdformat -n /dev/fd0H1440 Double-sided, 80 tracks, 18 sec/track. Total capacity 1440 kB. Formatting ... done $ badblocks /dev/fd0H1440 1440 $>$ bad-blocks $ mkfs -t ext2 -l bad-blocks /dev/fd0H1440 mke2fs 0.5a, 5-Apr-94 for EXT2 FS 0.5, 94/03/10 360 inodes, 1440 blocks 72 blocks (5.00%) reserved for the super user First data block=1 Block size=1024 (log=0) Fragment size=1024 (log=0) 1 block group 8192 blocks per group, 8192 fragments per group 360 inodes per group Writing inode tables: done Writing superblocks and filesystem accounting information: done $ Ten eerste werd de diskette geformatteerd (de optie voorkomt validatie, d.w.z. controle op slechte blokken). Vervolgens werd er met badblocks naar slechte blokken gezocht, waarbij de uitvoer naar een bestand bad-blocks werd gestuurd. Tenslotte werd het bestandssysteem aangemaakt, waarbij de lijst met welke slechte blokken badblocks dan ook vond, werd geïnitialiseerd. De optie had met mkfs kunnen worden gebruikt, in plaats van met badblocks en een apart bestand. Dat is wat het voorbeeld hieronder doet. $ mkfs -t ext2 -c /dev/fd0H1440 mke2fs 0.5a, 5-Apr-94 for EXT2 FS 0.5, 94/03/10 360 inodes, 1440 blocks 72 blocks (5.00%) reserved for the super user First data block=1 Block size=1024 (log=0) Fragment size=1024 (log=0) 1 block group 8192 blocks per group, 8192 fragments per group 360 inodes per group Checking for bad blocks (read-only test): done Writing inode tables: done Writing superblocks and filesystem accounting information: done $ De optie is makkelijker dan een apart gebruik van badblocks, maar badblocks is nodig voor de controle nadat het bestandssysteem werd aangemaakt. Het proces om bestandssystemen op harddisks of partities voor te bereiden is hetzelfde als voor diskettes, behalve dat de formattering niet nodig is. Mounten en unmounten Voordat men een bestandssysteem kan gebruiken, moet het worden gemount. Het besturingssysteem verricht dan diverse administratieve taken om er zeker van te zijn dat alles werkt. Aangezien alle bestanden onder UNIX zich in een enkele directory-structuur bevinden, zal de mount bewerking de inhoud van het nieuwe bestandssysteem er uit laten zien alsof het de inhoud van een bestaande subdirectory in één of ander reeds gemount bestandssysteem is. Bijvoorbeeld: toont drie aparte bestandssystemen, ieder met een eigen rootdirectory. Als de laatste twee bestandssystemen respectievelijk onder /home en /usr van het eerste bestandssysteem worden gemount, krijgen we een enkele directory-structuur, zoals in .
Drie aparte bestandssystemen.
<filename>/home</filename> en <filename>/usr</filename> zijn gemount.
De mounts zouden zoals in het volgende voorbeeld kunnen worden bewerkstelligd: $ mount /dev/hda2 /home $ mount /dev/hda3 /usr $ Het mount commando neemt twee argumenten. Het eerste argument is het devicebestand corresponderend met de disk of de partitie met het bestandssysteem. Het tweede argument is de directory waaronder het zal worden gemount. Na deze commando's lijkt de inhoud van de twee bestandssystemen net als de inhoud van respectievelijk de /home en /usr directories. Men zou kunnen stellen dat ``/dev/hda2 gemount is op /home'', en vergelijkbaar voor /usr. Om naar elk bestandssysteem te kijken, zou men de inhoud van de directory waarop het is gemount bekijken, net als bij iedere andere directory. Merk het verschil op tussen het devicebestand, /dev/hda2, en de directory waarop het is gemount, /home. Het devicebestand geeft toegang tot de onbewerkte inhoud van de disk, de directory waarop is gemount geeft toegang tot de bestanden op de disk. De directory waarop is gemount wordt het mount point genoemd. Linux biedt ondersteuning voor vele typen bestandssystemen. mount probeert het type bestandssysteem te gissen. Je kunt ook de optie gebruiken om het type direct te specificeren; dit is soms nodig, aangezien het heuristische mount gebruik niet altijd werkt. Om bijvoorbeeld een MS-DOS diskette te mounten, zou je het volgende commando kunnen gebruiken: $ mount -t msdos /dev/fd0 /floppy $ De directory waarop wordt gemount, hoeft niet leeg te zijn, alhoewel het wel moet bestaan. Als het bestandssysteem is gemount, zullen alle bestanden erin echter niet toegankelijk zijn. (De bestanden die reeds geopend zijn, zullen nog steeds toegankelijk zijn. Bestanden die hard links hebben vanuit andere directories kunnen nog steeds worden benaderd door die namen te gebruiken). Het kan geen kwaad om dit te doen, en het kan zelfs handig zijn. Een paar mensen willen bijvoorbeeld graag dat /tmp en /var/tmp aan elkaar gelijk zijn, en maken /tmp als een symbolische link naar /var/tmp. Als het systeem wordt geboot, voordat het /var bestandssysteem is gemount, wordt in plaats daarvan een /var/tmp directory op het root bestandssysteem gebruikt. Als /var wordt gemount, zal het de /var/tmp directory op het root bestandssysteem ontoegankelijk maken. Als /var/tmp niet op het root bestandssysteem voorkwam, zou het onmogelijk zijn om voor het mounten van /var tijdelijke bestanden te gebruiken. Als je niet van plan bent om iets naar het bestandssysteem te schrijven, gebruik dan de switch bij mount voor een read-only mount. Dit zal er voor zorgen dat de kernel pogingen om naar het bestandssysteem te schrijven zal beletten en er ook voor zal zorgen dat de kernel de toegangstijden van de bestanden in de inode niet bijwerkt. Read-only mounts zijn nodig voor onbeschrijfbare media, b.v. CD-ROM's. De oplettende lezer zal reeds een logistiek probleempje hebben opgemerkt. Hoe wordt het eerste bestandssysteem (genaamd root bestandssysteem, want het bevat de root directory) gemount, aangezien het uiteraard niet op een ander bestandssysteem kan worden gemount? Dit is magie. Zie de kernel source of de Kernel Hackers' Guide voor meer informatie. Het root bestandssysteem wordt tijdens de systeemstart magisch gemount en men kan er op vertrouwen dat het altijd zal zijn gemount. Als het root bestandssysteem niet kan worden gemount, boot het systeem niet. De naam van het bestandssysteem dat magisch als root is gemount, is óf in de kernel gecompileerd, óf met LILO of rdev ingesteld. Het root bestandssysteem wordt meestal eerst read-only gemount. Met de opstartscripts zal vervolgens fsck worden opgestart om de deugdelijkheid te valideren, en als er geen problemen zijn, wordt het opnieuw gemount, en wel zodanig dat ook schrijfopdrachten. zijn toegestaan. fsck mag niet op een gemount bestandssysteem worden uitgevoerd, aangezien alle wijzigingen aan het bestandssysteem ten tijde dat fsck draait, problemen zullen veroorzaken. Aangezien het root bestandssysteem tijdens de controle read-only is gemount, kan fsck eventuele problemen gerust herstellen. De bewerking waarbij het opnieuw wordt gemount, zal alle metagegevens die het bestandssysteem in het geheugen houdt, verwijderen. Op veel systemen komen er nog andere bestandssystemen voor die ook tijdens de systeemstart automatisch zouden moeten worden gemount. Deze worden in het bestand /etc/fstab gespecificeerd; zie de fstab man page voor details over het formaat. Het hangt van diverse factoren af wanneer de extra bestandssytemen exact worden gemount, en dit kan zonodig door iedere beheerder worden geconfigureerd, zie . Als een bestandssysteem niet langer gemount hoeft te zijn, kan het unmounten worden bewerkstelldigd met het commando umount. Het zou natuurlijk unmount moeten zijn, maar de 'n' is in de 70'er jaren mysterieus verdwenen, en sindsdien weggebleven. Retourneer hem alsjeblieft aan Bell Labs, NJ, als je hem vindt. umount accepteert één argument: óf het devicebestand óf het mount point. Om bijvoorbeeld de gemounte directories uit het vorige voorbeeld te unmounten, zou men de volgende commando's kunnen gebruiken: $ umount /dev/hda2 $ umount /usr $ Zie de man page voor verdere instructies hoe je het commando kunt gebruiken. Het is verplicht dat je een gemounte diskette altijd unmount, vóórdat je de diskette uit de drive haalt. Haal de diskette niet zomaar uit de drive! Vanwege disk caching, hoeft het niet noodzakelijk zo te zijn dat de gegevens naar de diskette zijn geschreven totdat je het unmount, dus het te vroeg verwijderen van de diskette uit de drive kan er voor zorgen dat de inhoud verminkt raakt. Dit is niet erg waarschijnlijk als je alleen gegevens vanaf een diskette inleest, maar als je, zelfs per ongeluk, gegevens ernaar wegschrijft, kan het resultaat rampzalig zijn. Het mounten en unmounten vereist superuser privileges, d.w.z. alleen root kan het. De reden hiervoor is dat als iedere gebruiker een diskette op iedere directory kan mounten, het nogal makkelijk is om een diskette met bijvoorbeeld een Trojan horse te mounten, dat als /bin/sh of enig ander vaak gebruikt programma wordt vermomd. Het is echter vaak nodig om gebruikers in de gelegenheid te stellen diskettes te gebruiken en er zijn verscheidene manieren voor: Geef de gebruikers het root wachtwoord. Dit is uiteraard slecht voor de beveiliging, maar het is de eenvoudigste oplossing. Het werkt goed als er geen beveiliging nodig is, wat het geval is op veel persoonlijke systemen die niet op een netwerk zijn aangesloten. Gebruik een programma zoals sudo om gebruikers toe te staan te mounten. Dit is nog steeds een slechte beveiliging, maar het geeft iedereen niet direct superuser privileges. Aan de kant van de gebruikers, vereist het in ieder geval dat er een paar seconden diep na moet worden gedacht. Zorg dat de gebruikers het package mtools kunnen gebruiken. Dit is een package voor het manipuleren van MS-DOS bestandssystemen, zonder ze te mounten. Dit werkt goed als er alleen MS-DOS diskettes nodig zijn, maar het is anders nogal lastig. Geef een opsomming van de disk-devices en de daarbijbehorende toegestane mount points met de geschikte opties in /etc/fstab. Het laatste alternatief kan worden geïmplementeerd door aan het bestand /etc/fstab een regel als de volgende toe te voegen: /dev/fd0 /floppy msdos user,noauto 0 0 De kolommen zijn: te mounten devicebestand, directory om op te mounten, type bestandssysteem, opties, backup frequentie (gebruikt door dump), en fsck passeernummer (om de volgorde aan te geven waarin bestandssystemen tijdens de systeemstart moeten worden gecontroleerd; 0 betekent geen controle). De optie zorgt ervoor dat deze mount tijdens de systeemstart niet automatisch wordt uitgevoerd (d.w.z. het stopt mount -a om het te mounten). De optie staat iedere gebruiker toe het bestandssysteem te mounten, en vanwege beveiligingsredenen staat het de uitvoering van programma's (normaal of setuid) en interpretatie van devicebestanden vanaf het gemounte bestandssysteem niet toe. Hierna kan een gebruiker een diskette met een msdos bestandssysteem met het volgende commando mounten: $ mount /floppy $ Het unmounten van de diskette kan (en moet natuurlijk ook) met het corresponderende umount commando. Als je toegang wilt geven aan verscheidene typen diskettes, zul je verscheidene mount points aan moeten geven. De instellingen kunnen voor ieder mount point anders zijn. Om bijvoorbeeld toegang te geven tot zowel MS-DOS als ext2 diskettes, zou je de volgende regel hiervoor in /etc/fstab kunnen plaatsen: /dev/fd0 /dosfloppy msdos user,noauto 0 0 /dev/fd0 /ext2floppy ext2 user,noauto 0 0 Voor MS-DOS bestandssystemen (niet alleen diskettes), wil je waarschijnlijk de toegang er toe beperken door gebruik te maken van de , , en bestandssysteem opties, die in detail staan beschreven in de manual page van mount. Als je niet oppast, geeft het mounten van een MS-DOS bestandssysteem iedereen op z'n minst leestoegang voor de bestanden die er op voorkomen, wat niet zo verstandig is. Controleren van de integriteit van een bestandssysteem met <command>fsck</command> Bestandssystemen zijn complex, en zijn als zodanig vatbaar voor fouten. De juistheid en validiteit van een bestandssysteem kan met het commando fsck worden gecontroleerd. Het kan worden geïnstrueerd om kleine problemen die het vindt te repareren en de gebruiker te waarschuwen als er zich niet te repareren problemen voordoen. Gelukkig is de code om bestandssystemen te implementeren zeer effectief vrijgemaakt van fouten, dus er treden zelden problemen op. Als er fouten optreden worden deze meestal veroorzaakt door stroomstoringen, ingebreke blijvende hardware of fouten van de operator; door bijvoorbeeld het niet juist afsluiten van het systeem. De meeste systemen zijn zo ingesteld dat ze fsck automatisch tijdens de systeemstart uitvoeren, zodat eventuele fouten worden gedetecteerd (en hopelijk gecorrigeerd) nog voor het systeem wordt gebruikt. Gebruik van een beschadigd systeem maakt de situatie vaak alleen maar erger: als de bestandssystemen verknoeid zijn, zal het gebruiken van het bestandssysteem dit waarschijnlijk alleen maar verergeren, wat kan resulteren in meer verlies aan gegevens. De uitvoering van fsck kan op grotere bestandssystemen echter een tijd duren en aangezien fouten bijna nooit voorkomen als het systeem goed is afgesloten, worden er een aantal trucs gebruikt die in een dergelijke situatie de controle's voorkomen. De eerste is, dat als er een bestand /etc/fastboot bestaat, er geen controle's worden uitgevoerd. De tweede is dat het ext2 bestandssysteem een speciale markering in het superblok heeft dat aangeeft of het bestandssysteem na de vorige mount het unmounten juist is uitgevoerd. Hierdoor kan e2fsck (de versie van fsck voor het ext2 bestandssysteem) voorkomen dat het bestandssysteem wordt gecontroleerd als de flag aangeeft dat het unmounten werd uitgevoerd. (in de veronderstelling dat het juist unmounten geen problemen betekent). Of de truc met /etc/fastboot op je systeem werkt, hangt af van je opstartscripts, maar de ext2 truc werkt iedere keer dat je e2fsck gebruikt. Het moet expliciet worden doorgegeven met een optie aan e2fsck om te worden voorkomen. (Zie de e2fsck man page voor details hoe je dit kunt doen). De automatische controle werkt alleen voor de bestandssystemen die tijdens de systeemstart automatisch worden gemount. Gebruik fsck handmatig om andere bestandssystemen te controleren, b.v. diskettes. Als fsck niet te repareren problemen constateert, heb je óf grondige kennis nodig van hoe bestandssystemen in het algemeen en het type beschadigde bestandssysteem in het bijzonder werken, óf goede backups. Het laatste is makkelijk (alhoewel soms vervelend) te regelen, het eerste kan soms via een vriend, de nieuwsgroepen en mailinglijsten voor Linux, of één of andere bron van ondersteuning worden geregeld, als je de knowhow zelf niet hebt. Ik zou je er graag meer over vertellen, maar mijn gebrek aan opleiding en ervaring hieromtrent verhindert me dat. Het programma debugfs van Theodore T'so zou van nut kunnen zijn. fsck moet alleen worden uitgevoerd op niet gemounte bestandssystemen, nooit op gemounte bestandssystemen (met uitzondering van de read-only root tijdens de systeemstart). Dit omdat het de onbewerkte disk benadert, en het bestandssysteem daarom kan wijzigen, zonder dat het besturingssysteem zich dit realiseert. Als het besturingssysteem van slag raakt, zal dit zeker problemen geven. Controleren op diskfouten met <command>badblocks</command> Je doet er verstandig aan periodiek op slechte blokken te controleren. Dit wordt gedaan met het commando badblocks. Het geeft als uitvoer een lijst met alle slechte blokken die het kan vinden. Deze lijst kan aan fsck worden doorgegeven om het op te laten nemen in de gegevensstructuur van het bestandssysteem, zodat het besturingssysteem niet zal proberen om de slechte blokken te gebruiken voor het opslaan van data. Het volgende voorbeeld toont hoe dit gedaan kan worden. $ badblocks /dev/fd0H1440 1440 > bad-blocks $ fsck -t ext2 -l bad-blocks /dev/fd0H1440 Parallelizing fsck version 0.5a (5-Apr-94) e2fsck 0.5a, 5-Apr-94 for EXT2 FS 0.5, 94/03/10 Pass 1: Checking inodes, blocks, and sizes Pass 2: Checking directory structure Pass 3: Checking directory connectivity Pass 4: Check reference counts. Pass 5: Checking group summary information. /dev/fd0H1440: ***** FILE SYSTEM WAS MODIFIED ***** /dev/fd0H1440: 11/360 files, 63/1440 blocks $ Als badblocks rapporteert dat een blok reeds in gebruik is, zal e2fsck proberen het blok naar een andere plek te verplaatsen. Als het blok echt slecht was, niet slechts marginaal, kan het zijn dat de inhoud van het bestand beschadigd is. Fragmentatie te lijf gaan Wanneer een bestand naar disk wordt geschreven, kan het niet altijd in aaneengesloten blokken worden weggeschreven. Een bestand dat niet in aaneengesloten blokken wordt opgeslagen, is gefragmenteerd. Het duurt langer om een gefragmenteerd bestand in te lezen, aangezien de lees/schrijf-kop van de disk meer bewegingen zal moeten maken. Het is wenselijk om fragmentatie te voorkomen, alhoewel het minder een probleem is in een systeem met een goede buffer cache met read-ahead. Het ext2 bestandssysteem probeert fragmentatie tot een minimum te beperken, door alle blokken in een bestand dichtbij elkaar te houden, zelfs als ze niet in aaneengesloten sectoren kunnen worden opgeslagen. Ext2 kent het vrije blok altijd effectief toe aan de dichtstbijzijnde andere blokken van een bestand. Voor ext2 is het daarom zelden nodig om je zorgen te maken over defragmentatie. Er is een programma voor het defragmenteren van een ext2 bestandssysteem, zie XXX (ext2-defrag) in de bibliografie. Er zijn veel MS-DOS defragmentatieprogramma's die blokken in het bestandssysteem manoeuvreren om de fragmentatie te verwijderen. Voor andere bestandssystemen moet defragmentatie worden gedaan door een backup te maken van het bestandssysteem, het opnieuw aan te maken en de bestanden vanaf backups terug te plaatsen. Het is zo ie zo een goed plan voor alle bestandssystemen om vóór het defragmenteren een backup te maken, aangezien er tijdens de defragmentatie veel mis kan gaan. Andere tools voor alle bestandssystemen Er zijn nog een aantal andere tools die van nut kunnen zijn bij het beheren van bestandssystemen. df toont de vrije diskruimte van één of meer bestandssystemen; du toont hoeveel diskruimte een directory en alle bestanden daarin in beslag nemen. Deze kunnen worden gebruikt om verspilling van diskruimte tegen te gaan. sync forceert dat alle ongeschreven blokken in de buffercache (zie ) naar disk worden geschreven. Het is zelden nodig om dit met de hand te doen; het daemonproces update doet dit automatisch. Het kan in noodgevallen handig zijn, bijvoorbeeld als update of het helpproces bdflush het begeeft, of je de stroom nu af moet sluiten en niet kan wachten totdat update wordt uitgevoerd. Andere tools voor het ext2 bestandssysteem In aanvulling op mke2fs, waarmee het bestandssysteem wordt aangemaakt, en e2fsck, waarmee het bestandssysteem wordt gecontroleerd, die direct of via de onafhankelijke front ends van het bestandssysteem toegankelijk zijn, heeft het ext2 bestandssysteem een aantal extra tools die van nut kunnen zijn. tune2fs past parameters van het bestandssysteem aan. Een aantal van de interessantste parameters zijn: Een maximale mount count. e2fsck forceert een controle als het bestandssysteem te vaak werd gemount, zelfs als de clean flag is gezet. Voor een systeem dat voor het ontwikkelen of het testen van het systeem wordt gebruikt, kan het een goed idee zijn om deze limiet te verlagen. Maximale tijd tussen controle's. e2fsck kan een maximale tijd tussen twee controles ook afdwingen, zelfs als de clean flag is gezet, en het bestandssysteem nog niet zo vaak is gemount. Dit kan echter worden gedeactiveerd. Aantal blokken dat voor root is gereserveerd. Ext2 reserveert een aantal blokken voor root, waardoor het nog steeds mogelijk is om systeembeheer te verrichten, zonder iets te moeten verwijderen, als het bestandssysteem volraakt. De gereserveerde hoeveelheid is standaard 5 procent, wat op de meeste disks geen verspilling is. Voor diskettes heeft het echter geen zin om blokken te reserveren. Zie de tune2fs manual page voor meer informatie. dumpe2fs toont informatie over een ext2 bestandssysteem, voornamelijk van het superblock. toont een voorbeelduitvoer. Wat van de informatie in de uitvoer is technisch en vereist begrip van hoe het bestandssysteem werkt (zie appendix XXX ext2fspaper), maar veel ervan is zelfs voor beginnende beheerders gemakkelijk te begrijpen.
Voorbeelduitvoer van <command>dumpe2fs</command> dumpe2fs 0.5b, 11-Mar-95 for EXT2 FS 0.5a, 94/10/23 Filesystem magic number: 0xEF53 Filesystem state: clean Errors behavior: Continue Inode count: 360 Block count: 1440 Reserved block count: 72 Free blocks: 1133 Free inodes: 326 First block: 1 Block size: 1024 Fragment size: 1024 Blocks per group: 8192 Fragments per group: 8192 Inodes per group: 360 Last mount time: Tue Aug 8 01:52:52 1995 Last write time: Tue Aug 8 01:53:28 1995 Mount count: 3 Maximum mount count: 20 Last checked: Tue Aug 8 01:06:31 1995 Check interval: 0 Reserved blocks uid: 0 (user root) Reserved blocks gid: 0 (group root) Group 0: Block bitmap at 3, Inode bitmap at 4, Inode table at 5 1133 free blocks, 326 free inodes, 2 directories Free blocks: 307-1439 Free inodes: 35-360
debugfs is een debugger voor een bestandssysteem. Het staat toe dat er directe toegang tot de gegevenstructuren op een bestandssysteem, die op de disk zijn opgeslagen, kan worden verkregen, en kan dus worden gebruikt om een disk te repareren, die zo gebrekkig is dat fsck het niet automatisch kan herstellen. Het is ook bekend om het te gebruiken verwijderde bestanden terug te krijgen. debugfs vereist echter dat je beslist begrijpt waar je mee bezig bent; een gebrek aan kennis kan al je gegevens vernietigen. dump en restore kunnen worden gebruikt om een backup van een ext2 bestandssysteem te maken. Het zijn ext2 specifieke versies van de traditionele UNIX backup tools. Zie voor meer informatie over backups. Disks zonder bestandssystemen Niet alle disks of partities worden als bestandssystemen gebruikt. Op bijvoorbeeld een swappartitie bevindt zich geen bestandssysteem. Veel diskettes worden op een tape gestuurde wijze geëmuleerd, zodat een tar of ander bestand direct naar de raw disk wordt geschreven. Linux startdiskettes bevatten geen bestandssysteem, alleen de raw kernel. Het vermijden van een bestandssysteem heeft als voordeel dat er meer van de disk bruikbaar is, aangezien een bestandssysteem altijd wat administratieve overhead vergt. Het maakt de disks ook makkelijker compatibel met andere systemen: tar is bijvoorbeeld op alle systemen gelijk, terwijl bestandssystemen op de meeste systemen anders zijn. Je zal snel gewend raken aan disks zonder bestandssystemen als je ze nodig hebt. Startbare Linux diskettes hebben ook niet noodzakelijk een bestandssysteem, alhoewel ook dat mogelijk is. Één reden om raw disks te gebruiken is om er image kopieën van te maken. Als de disk bijvoorbeeld een deels beschadigd bestandssysteem bevat, is het een goed idee om er een exacte kopie van te maken voordat je het probeert te herstellen, aangezien je dan opnieuw kunt beginnen als er door je herstelpoging meer beschadigd raakt. Één manier om dit te doen is met dd: $ dd if=/dev/fd0H1440 of=floppy-image 2880+0 records in 2880+0 records out $ dd if=floppy-image of=/dev/fd0H1440 2880+0 records in 2880+0 records out $ De eerste dd maakt een exacte afbeelding van de diskette naar het bestand floppy-image, de tweede schrijft de afbeelding naar de diskette. (De gebruiker heeft vermoedelijk de diskette voor het tweede commando verwisseld. Anders is het commando-paar van twijfelachtige bruikbaarheid). Toewijzen van diskruimte Partitioneringsschema's Het is niet eenvoudig een disk op de best mogelijke manier te partitioneren. Erger nog, er is geen universeel juiste manier om het te doen; er zijn teveel factoren bij betrokken. Volgens de traditie wordt er voor het root bestandssysteem een (relatief) klein bestandssysteem gebruikt, waarin zich de /bin, /etc, /dev, /lib, /tmp, en andere zaken bevinden die nodig zijn om het systeem aan de gang en draaiend te krijgen. Op deze manier heb je voldoende aan het root bestandssysteem (in een eigen partitie of op een eigen disk) om het systeem aan de gang te krijgen. De reden hiervoor is, dat als het root bestandssysteem klein is en niet zo veel wordt gebruikt, het minder waarschijnlijk is dat het beschadigd raakt als het systeem crasht, en je zal het daarom makkelijker vinden om eventuele problemen veroorzaakt door de crash te herstellen. Vervolgens maak je aparte partities aan of gebruik je aparte disks voor de directory-structuur onder /usr, de homedirectories van de gebruikers (vaak onder /home), en de swap space. Het scheiden van de homedirectories (met de bestanden van de gebruikers) in een eigen partitie maakt het maken van een backup makkelijker, aangezien het meestal niet nodig is om backups van programma's te maken (die voorkomen onder /usr). In een netwerkomgeving is het ook mogelijk om /usr tussen verscheidene computers te delen (b.v. door gebruik te maken van NFS), waardoor de totale diskruimte, tot verscheidene tientallen of honderden megabytes maal het aantal computers, wordt teruggebracht. Het probleem met veel partities is, dat het de totale hoeveelheid vrije diskruimte in vele kleine stukken splitst. Tegenwoordig zijn disks en (hopelijk) besturingssystemen betrouwbaarder, en veel mensen geven de voorkeur aan slechts één partitie met daarin alle bestanden. Aan de andere kant kan het minder pijnlijk zijn om een backup te maken van een kleine partitie (en deze terug te zetten). Voor een kleine harddisk (er van uitgaande dat je je niet bezig houdt met de ontwikkeling van de kernel), is de beste manier waarschijnlijk dat je slechts één partitie hebt. Voor grote harddisks is het waarschijnlijk beter dat je een paar grote partities hebt, slechts voor het geval er iets mis gaat. (Noot: `klein' en `groot' zijn hier relatief gebruikt; je benodigdheden voor diskruimte maken uit wat de grens is). Als je verscheidene disks hebt, kan het zijn dat je het root bestandssysteem (waaronder /usr) op één partitie en de homedirectories van de gebruikers op een andere partitie wilt. Je kunt er maar beter op voorbereid zijn, te experimenteren met verschillende partitie-schema's (mettertijd, niet slechts als je het systeem voor de eerste keer installeert). Dit vereist wel wat werk, aangezien het in essentie vereist dat je het systeem verscheidene keren van het begin af aan opnieuw installeert, maar het is de enige manier om er zeker van te zijn dat je het goed doet. Ruimte benodigdheden De Linux-distributie die je installeert zal je een indicatie geven van de hoeveelheid ruimte die je voor de diverse configuraties nodig hebt. Mogelijk geldt dit ook voor de programma's die je apart installeert. Dit zal je helpen om het gebruik van de diskruimte te plannen, maar je zou op de toekomst voorbereid moeten zijn en wat extra ruimte voor zaken moeten reserveren waarvan je later merkt dat je ze nodig hebt. De benodigde hoeveelheid voor gebruikersbestanden is afhankelijk van wat je gebruikers willen doen. De meeste mensen schijnen zoveel mogelijk ruimte voor hun bestanden nodig te hebben, maar de hoeveelheid waarmee ze zich goed kunnen redden, varieert nogal. Een aantal mensen houdt zich slechts bezig met wat lichte tekstverwerkings werkzaamheden en zal het prima kunnen redden met een paar megabytes, anderen doen aan beeldbewerking en zullen gigabytes nodig hebben. Tussen twee haakjes, als je bestandsgroottes in kilobytes of megabytes met diskruimte gegeven in megabytes met elkaar vergelijkt, kan het belangrijk zijn te weten dat de twee eenheden verschillend kunnen zijn. Een aantal fabrikanten schijnen graag voor te willen doen dat een kilobyte gelijk is aan 1000 bytes en een megabyte gelijk is aan 1000 kilobytes, terwijl de rest van de wereld die een computer gebruikt voor beide factoren 1024 gebruikt. Daarom was mijn 345 MB harddisk in werkelijkheid een 330 MB harddisk. Sic transit discus mundi. De toewijzing van swap space wordt besproken in . Voorbeelden van een harddisk toewijzing Ik had een harddisk van 109 MB. Nu maak ik gebruik van een harddisk van 330 MB. Ik zal uitleggen hoe en waarom ik deze disks partitioneerde. Ik partitioneerde de 109 MB disk op heel veel manieren; als mijn behoeften en het besturingssysteem dat ik gebruikte veranderden. Ik zal twee typische scenario's uitleggen. Ten eerste gebruikte ik MS-DOS samen met Linux. Daarvoor gebruikte ik ongeveer 20 MB harddisk, of net genoeg voor MS-DOS, een C-compiler, een editor, een paar andere utilities, het programma waar ik aan werkte, en voldoende vrije ruimte om geen claustrofobische gevoelens te krijgen. Ik had voor Linux een swappartitie van 10 MB, en de rest, 79 MB was een enkele partitie met alle bestanden die ik onder Linux had. Ik experimeerde met aparte root, /usr, en /home partities, maar er was nooit genoeg vrije diskruimte aan één stuk om veel interessants te doen. Toen ik MS-DOS niet meer nodig had, partitioneerde ik de disk zodanig opnieuw dat ik een swappartitie had van 12 MB, en weer de rest als een enkel bestandssysteem. De 330 MB disk is als volgt in verscheidene partities onderverdeeld: 5 MB root bestandssysteem 10 MB swap partitie 180 MB /usr bestandssysteem 120 MB /home bestandssysteem 15 MB scratch partitie De scratch partitie is om met zaken te kunnen experimenteren die een eigen partitie vereisen, b.v. het uitproberen van verschillende Linux distributies, of het vergelijken van snelheden tussen bestandssystemen. Wanneer het niet voor iets anders benodigd is, wordt het als swap space gebruikt. (Ik heb graag een heleboel vensters open). Meer diskruimte voor Linux toevoegen Het is makkelijk om meer diskruimte aan Linux toe te voegen, tenminste nadat de hardware juist is geïnstalleerd (de installatie van de hardware valt buiten het kader van dit boek). Je formatteert het als dat nodig is, vervolgens maak je de partities en het bestandssysteem zoals hierboven is beschreven, en voeg je de juiste regel toe aan /etc/fstab zodat het automatisch wordt gemount. Tips voor het besparen van diskruimte De beste tip voor het besparen van diskruimte is het voorkomen van de installatie van onnodige programma's. De meeste Linux distributies hebben een optie om alleen een deel van de packages te installeren, en door je behoeften te analyseren, kan het zijn dat je bemerkt dat je het meeste ervan niet nodig hebt. Dit zal helpen om heel wat diskruimte te besparen, aangezien veel programma's nogal groot zijn. Zelfs als je een bepaald package nodig hebt, heb je misschien niet alles ervan nodig. Wat van de on-line documentatie kan bijvoorbeeld onnodig zijn, als ook misschien wat van de Elisp bestanden voor GNU Emacs, of wat van de lettertypen voor X, of een aantal libraries voor het programmeren. Als je geen packages kunt de-installeren, zou je eens kunnen kijken naar compressie. Compressie programma's zoals gzip of zip zullen individuele bestanden of groepen bestanden comprimeren (en decomprimeren). Het gzexe systeem zal programma's onzichtbaar voor de gebruiker comprimeren en decomprimeren (ongebruikte programma's zijn gecomprimeerd, en worden gedecomprimeerd als ze worden gebruikt). Het experimentele DouBle systeem zal alle bestanden in een bestandssysteem onzichtbaar voor de programma's die ze gebruiken, comprimeren. (Als je bekend bent met producten zoals Stacker voor MS-DOS: het principe is hetzelfde). Geheugenbeheer
Minnet, jag har tappat mitt minne, är jag svensk eller finne, kommer inte ihåg... (Bosse Österberg)
Deze sectie beschrijft de eigenschappen van het geheugenbeheer onder Linux, d.w.z. virtueel geheugen en de diskbuffer cache. Het doel en de werking en datgene wat de systeembeheerder in overweging moet nemen, worden hier beschreven. Wat is virtueel geheugen? Linux ondersteunt virtueel geheugen, dat wil zeggen, het gebruiken van een disk als uitbreiding op RAM, zodat de effectieve grootte van bruikbaar geheugen corresponderend groeit. De kernel zal de inhoud van een thans ongebruikt blok geheugen naar harddisk wegschrijven, zodat het geheugen voor andere doelen kan worden gebruikt. Als de originele inhoud weer nodig is, wordt het weer in het geheugen gelezen. Voor de gebruiker is dit volledig transparant; programma's die onder Linux draaien zien slechts de grotere hoeveelheid beschikbaar geheugen en merken niet op dat delen daarvan van tijd tot tijd op de disk voorkomen. Natuurlijk is het inlezen vanaf en het schrijven naar de harddisk langzamer (in grootte van duizend maal langzamer) dan dat er gebruik wordt gemaakt van echt geheugen, dus programma's draaien niet zo snel. Het deel van de harddisk dat als virtueel geheugen wordt gebruikt, wordt swap space genoemd. Linux kan voor swap space ófwel gebruik maken van een gewoon bestand in het bestandssysteem of van een aparte partitie. Een swap partitie is sneller, maar het is eenvoudiger om de grootte van een swapbestand te veranderen (het is niet nodig om de gehele harddisk opnieuw te partitioneren, en mogelijk alles vanaf het begin opnieuw te installeren). Wanneer je weet hoeveel swap space je nodig hebt, zou je voor een swap partitie moeten kiezen, maar als je het niet zeker weet, kun je als eerste een swapbestand gebruiken, het systeem een tijdje gebruiken, zodat je een indruk kunt krijgen hoeveel swap space je nodig hebt, en vervolgens een swap partitie aan kunnen maken, zodra je overtuigd bent van de grootte. Je zou ook moeten weten dat Linux het toestaat als er één of meer partities en/of swapbestanden tegelijkertijd worden gebruikt. Dit betekent dat je een extra swapbestand in kunt stellen, als je slechts zo nu en dan een ongebruikelijke hoeveelheid swap space nodig hebt, in plaats van continue de gehele hoeveelheid toe te moeten kennen. Een opmerking over besturingssysteem terminologie: de computerwetenschap maakt gewoonlijk onderscheid in swapping (waarbij het gehele proces naar swap space wordt weggeschreven) en paging (waarbij alleen vastgestelde groottes worden weggeschreven, dit zijn meestal een paar kilobytes per keer). Paging is meestal efficiënter, en dat is wat Linux doet, maar de traditionele Linux terminologie heeft het in ieder geval over swapping. Aanmaken van swap space Een swapbestand is een gewoon bestand; het is voor de kernel op geen enkele manier speciaal. Het enige dat er voor de kernel toe doet is, dat het geen ``holes'' heeft, en dat het is voorbereid voor gebruik met mkswap. Het moet echter op een lokale disk voorkomen, vanwege redenen van implementatie kan het niet op een bestandssysteem voorkomen dat via NFS is gemount. Hetgeen over ``holes'' is belangrijk. Het swapbestand reserveert de diskruimte zodanig dat de kernel een pagina snel kan swappen zonder zich hoeven bezig te houden met alles wat nodig is wanneer een disksector aan een bestand wordt toegekend. De kernel gebruikt enkel enige sectoren die reeds aan het bestand zijn toegekend. Omdat een ``hole'' in een bestand betekent dat er geen disksectoren zijn toegekend (voor die plaats in het bestand), is het niet goed als de kernel ze probeert te gebruiken. Een juiste manier om het swapbestand zonder ``holes'' te maken is met behulp van het volgende commando: $ dd if=/dev/zero of=/extra-swap bs=1024 count=1024 1024+0 records in 1024+0 records out $ waar /extra-swap de naam is van het swapbestand, en de grootte ervan na count= wordt opgegeven. Het is het beste als de grootte een veelvoud van 4 is, omdat de kernel geheugenpagina's wegschrijft ter grootte van 4 kilobytes. Als de grootte geen veelvoud van 4 is, kan het zijn dat de laatste paar kilobytes niet worden gebruikt. Ook een swappartitie is op geen enkele wijze speciaal. Je maakt het gewoon net als iedere andere partitie aan; het enige verschil is dat het als een raw partitie wordt gebruikt, dat wil zeggen, dat het in het geheel geen bestandssysteem bevat. Het is een goed idee om swappartities als type 82 te markeren (Linux swap); dit maakt de partitie listing wat duidelijker, ook al is het voor de kernel niet echt noodzakelijk. Nadat je een swapbestand of swappartitie hebt aangemaakt, zul je aan het begin ervan een teken moeten toekennen; hierin staat wat administratieve informatie en het wordt door de kernel gebruikt. Het commando om dit te doen is mkswap, en het wordt als volgt gebruikt: $ mkswap /extra-swap 1024 Setting up swapspace, size = 1044480 bytes $ Merk op dat de swapspace nog steeds niet in gebruik is: het bestaat, maar de kernel gebruikt het niet om in virtueel geheugen te voorzien. Je zal op moeten passen als je gebruik maakt van mkswap, aangezien het niet controleert of het bestand of de partitie al niet voor iets anders wordt gebruikt. Je kunt makkelijk belangrijke bestanden en partities overschrijven met mkswap! Gelukkig hoef je mkswap alleen te gebruiken wanneer je je systeem installeert. De Linux geheugenbeheerder beperkt de grootte van iedere swap space tot ongeveer 127 MB (om diverse technische redenen, de werkelijke limiet is (4096-10) * 8 * 4096 = 133890048$ bytes, of 127.6875 megabytes). Je kunt echter tot 8 swap spaces gelijktijdig gebruiken, tot een totaal van bijna 1 GB. Een gigabyte hier, een gigabyte daar, nog even en we gaan het hebben over echt geheugen. Gebruiken van swap space Geïnitialiseerde swap space wordt in gebruik genomen met swapon. Dit commando vertelt de kernel dat de swap space kan worden gebruikt. Het path naar de swap space wordt als argument opgegeven, dus het swappen naar een tijdelijk swapbestand kan met behulp van het volgende commando: $ swapon /extra-swap $ Door een opsomming van de swap spaces in het bestand /etc/fstab te geven, kunnen ze automatisch worden gebruikt. /dev/hda8 none swap sw 0 0 /swapfile none swap sw 0 0 De opstartscripts zullen het commando swapon -a opstarten, waardoor alle swap spaces zullen worden geactiveerd die in het bestand /etc/fstab staan. Daarom wordt het commando swapon meestal alleen gebruikt wanneer er extra swap nodig is. Je kunt het gebruik van swap spaces met het commando free controleren. Hiermee wordt de totale hoeveelheid gebruikte swap space getoond. $ free total used free shared buffers Mem: 15152 14896 256 12404 2528 -/+ buffers: 12368 2784 Swap: 32452 6684 25768 $ De eerste regel uitvoer (Mem:) toont het fysiek aanwezige geheugen. De kolom `total' toont niet het fysiek door de kernel gebruikt geheugen, wat meestal ongeveer een megabyte is. De kolom `used' toont de hoeveelheid gebruikt geheugen (de tweede regel telt de buffers niet mee). De kolom `free' toont al het ongebruikte geheugen. De kolom `shared' toont de hoeveelheid geheugen die door verscheidene processen wordt gedeeld; hoe meer, hoe beter. De kolom `buffers' toont de huidige grootte van de diskbuffer cache. Die laatste regel (Swap:) toont vergelijkbare informatie voor de swap spaces. Als deze regels uit alleen maar nullen bestaan, dan is je swap space niet geactiveerd. Dezelfde informatie is beschikbaar via top, of door gebruik te maken van het proc bestandssysteem in het bestand /proc/meminfo. Het is thans moeilijk om informatie te verkrijgen over het gebruik van een specifiek swap space. Een in gebruik zijnde swap space kan met swapoff worden gedeactiveerd. Normaal gesproken is dit niet nodig, behalve dan voor tijdelijke swap spaces. Eventueel in gebruik zijnde pagina's worden als eerste ingeswapt; als er niet voldoende fysiek geheugen voor is, zullen ze weer worden uitgeswapt (naar andere swap space). Als er niet voldoende virtueel geheugen is om alle pagina's vast te houden, zal Linux het gaan verwijderen; na een lange periode zou dit hersteld moeten worden, maar in de tussentijd is het systeem niet bruikbaar. Je zou voordat je een swap space deactiveert, moeten controleren (b.v. met free), of er voldoende geheugen is. Alle met swapon -a automatisch in gebruik gestelde swap spaces, kunnen met swapoff -a worden gedeactiveerd; het kijkt hiervoor in het bestand /etc/fstab om te zien wat er moet worden verwijderd. Eventuele in gebruik zijnde swap spaces die handmatig zijn ingesteld, zullen in gebruik blijven. Soms kan er heel wat swap space in gebruik zijn, zelfs al is er heel veel fysiek geheugen. Dit kan bijvoorbeeld voorkomen als het op een bepaald punt nodig is om te swappen, maar later door een groot proces, dat veel van het fysieke geheugen in beslag nam, eindigt en het geheugen vrijgeeft. De naar disk geswapte gegevens worden niet automatisch weer in het geheugen geplaatst, totdat het weer nodig is, dus het fysieke geheugen kan voor een lange tijd vrij blijven. Je hoeft je hier geen zorgen om te maken, maar het kan geruststellend zijn te weten wat er aan de hand is. Het delen van swap spaces met andere besturingssystemen Virtueel memory is in veel besturingssystemen ingebouwd. Aangezien het alleen nodig is wanneer het systeem draait, d.w.z. nooit tegelijkertijd, zijn de swap spaces behalve die van het systeem dat op dat moment draait, een verspilling. Het zou efficiënter zijn om een enkele swap space gezamelijk te gebruiken. Dit is mogelijk, maar hier kan wat hacking voor nodig zijn. In de Tips-HOWTO staat wat advies over hoe dit geïmplementeerd kan worden. Toewijzen van swap space Een aantal mensen zal je zeggen dat je tweemaal zoveel swap space toe moet wijzen als je fysiek geheugen hebt, maar dit is een verzonnen regel. Zo kun je het op de juiste wijze doen: Maak een raming van wat je in totaal aan geheugen nodig hebt. Dit is de grootste hoeveelheid geheugen die je waarschijnlijk ooit nodig zal hebben, dat is het totaal aan geheugenvereisten van alle programma's die je tegelijkertijd uit wilt voeren. Dit kan worden bewerkstelligd door tegelijkertijd alle programma's te draaien die je naar alle waarschijnlijkheid ooit in de toekomst tegelijkertijd zal draaien. Als je bijvoorbeeld X wilt draaien, zou je hiervoor ongeveer 8 MB moeten reserveren, gcc verlangt verscheidene megabytes (een aantal bestanden hebben een ongebruikelijke grote hoeveelheid nodig, tot wel tientallen megabytes, maar meestal zal vier megabytes wel voldoende zijn), enzovoort. De kernel zelf zal ongeveer een megabyte in beslag nemen, en de gewone shells en andere kleine utilities misschien iets als honderd kilobytes (zo ongeveer één megabyte bijelkaar). Het is niet nodig om de exacte hoeveelheid te bepalen, globale ramingen zijn prima, maar je kunt het maar beter pessimistisch inschatten. Denk er aan dat in een situatie waarbij verscheidene mensen tegelijkertijd van het systeem gebruik zullen maken, ze allen geheugen zullen gaan gebruiken. Als echter twee mensen tegelijkertijd hetzelfde programma draaien, wordt de totale geheugenconsumptie meestal niet verdubbeld, aangezien code pages en gedeelde libraries slechts éénmaal voorkomen. De commando's free en ps zijn handig voor het ramen van de geheugenbenodigdheden. Voeg veiligheidshalve wat toe aan de raming in stap 1. Dit omdat de ramingen met betrekking tot de grootte van programma's waarschijnlijk onjuist zijn, omdat je vermoedelijk een aantal uit te voeren programma's zal vergeten en om er zeker van te zijn dat je, voor het geval dat, wat extra ruimte hebt. Een paar megabytes zal wel volstaan. (Je kunt maar beter teveel swap space dan te weinig hebben, maar het is niet nodig het te overdrijven en de gehele disk toe te wijzen, aangezien ongebruikte swap space verspilde ruimte is; zie verderop over het toevoegen van meer swap). Bovendien kun je de waarde tot de eerstvolgende volledige megabyte afronden, aangezien het netter is met even nummers om te gaan. Gebaseerd op de hiervoor gemaakte berekeningen, weet je nu hoeveel geheugen je in totaal nodig zal hebben. Dus om de swap space toe te wijzen, zul je nu de grootte van je fysieke geheugen moeten aftrekken van het totaal benodigde geheugen. Hieruit volgt dan de hoeveelheid benodigde swap space. (Bij een aantal UNIX-versies moet je bovendien ruimte toewijzen voor een image van het fysieke geheugen, en dan heb je dus de hoeveelheid nodig die in stap 2 werd berekend). Als je berekende swapspace veel groter is dan je fysieke geheugen (meer dan een aantal malen groter), zou je er waarschijnlijk goed aan doen om in meer fysiek geheugen te investeren, anders zal de performance te laag zijn. Het is verstandig om op z'n minst wat swap space te hebben, zelfs als je berekeningen aangeven dat je niets nodig hebt. Linux maakt wat dynamisch gebruik van swap space, zodat er zoveel mogelijk van het fysiek geheugen vrij kan blijven. Linux zal geheugenpagina's die niet gebruikt worden naar disk swappen, zelfs als het geheugen nog nergens anders voor nodig is. Hiermee wordt voorkomen dat er door het swappen moet worden gewacht als het geheugen wel nodig is: het swappen kan dus eerder worden gedaan, wanneer de disk anderszins ongebruikt is. Swap space kan over verscheidene disks worden verdeeld. Dit kan de performance afhankelijk van de relatieve snelheden van de disks en de toegangspatronen van de disks soms verbeteren. Misschien dat je met een paar schema's wilt experimenteren, maar houd in de gaten dat het nogal moeilijk is om de experimenten op juiste wijze uit te voeren. Je zou beweringen dat het ene schema superieur is aan het andere niet voor waar aan moeten nemen, aangezien dit niet altijd zo is. De buffer cache Lezen vanaf een disk Behalve vanaf een RAM disk, om vanzelfsprekende redenen. is in vergelijking met het benaderen van (echt) geheugen erg langzaam. Bovendien is het heel gewoon om gedurende relatief korte perioden hetzelfde deel van een disk verscheidene malen te lezen. Men zou bijvoorbeeld eerst een e-mail bericht kunnen lezen, vervolgens de brief in een editor kunnen laden om er antwoord op te geven, en het dan nog eens in het mailprogramma in kunnen lezen als het naar een folder wordt gekopieerd. Of overweeg eens hoevaak het commando ls op een systeem met meerdere gebruikers zou kunnen worden opgestart. Door de informatie slechts éénmaal vanaf disk in te lezen en het dan in het geheugen te houden totdat het niet langer nodig is, kan het allemaal, behalve de eerste keer dat het wordt ingelezen, worden versneld. Dit wordt disk buffering genoemd, en het geheugen dat voor dit doel wordt gebruikt, wordt de buffer cache genoemd. Aangezien geheugen helaas een eindig, ja zelfs schaarse bron is, kan de buffer cache meestal niet groot genoeg zijn (het kan alle gegevens die men wil gebruiken, niet vasthouden). Als de cache vol is, worden de gegevens die het langst niet zijn gebruikt, verworpen en wordt het zojuist vrijgegeven geheugen voor de nieuwe gegevens gebruikt. Disk buffering werkt tevens voor het schrijven. Aan de ene kant worden de weggeschreven gegevens vaak spoedig weer ingelezen (b.v. de source code die in een bestand wordt opgeslagen en vervolgens door de compiler wordt ingelezen), dus het in de cache plaatsen van weggeschreven gegevens is een goed plan. Aan de andere kant, door de gegevens alleen in de cache te plaatsen en ze niet onmiddellijk naar disk weg te schrijven, draait het programma dat wegschrijft, sneller. De schrijfopdrachten kunnen dan in de achtergrond worden uitgevoerd, zonder de andere programma's te vertragen. De meeste besturingssystemen hebben buffercaches (alhoewel ze anders genoemd kunnen worden), maar ze werken niet allen overeenkomstig de hiervoor beschreven principes. Een aantal zijn write-through: de gegevens worden onmiddellijk naar disk weggeschreven (ze worden natuurlijk ook in de cache bewaard). Als het wegschrijven op een later tijdstip plaatsvindt, wordt de cache write-back genoemd. Write-back is efficiënter dan write-through, maar het is ook wat vatbaarder voor fouten; als de computer crasht of de stroom op een slecht moment uitvalt, of de diskette wordt uit de diskdrive verwijderd voordat de gegevens in de cache naar de disk zijn weggeschreven, gaan de wijzigingen in de cache meestal verloren. Dit kan zelfs betekenen dat het bestandssysteem (als er één is) niet meer volledig werkt, misschien omdat de nog niet weggeschreven gegevens belangrijke administratieve informatie bevatten. Daarom zou je de stroom nooit uit moeten schakelen zonder een juiste shutdown procedure te gebruiken (zie ), of een diskette uit het diskettestation moeten verwijderen voordat het umount commando is toegepast (als het was gemount) of nadat om 't even welk programma je gebruikte, heeft gesignaleerd dat het is beëindigd en de led van het diskettestation niet meer oplicht. Het commando sync leegt de buffer, d.w.z. het forceert dat alle ongeschreven gegevens naar disk worden geschreven en kan worden gebruikt, wanneer men er zeker van wil zijn dat alles veilig is weggeschreven. Onder traditionele UNIX-systemen bestaat een programma genaamd update, welke in de achtergrond draait, die iedere 30 seconden een sync uitvoert, dus meestal is het niet nodig om het commando sync te gebruiken. Linux heeft nog een extra daemon, bdflush, welke een meer onvolkomen sync frequenter uitvoert om een plotseling stopzetten ten gevolge van zwaar disk I/O te voorkomen, welke het commando sync soms veroorzaakt. Onder Linux wordt bdflush door update gestart. Er is meestal geen reden om je er zorgen om te maken, maar als bdflush het om één of andere reden begeeft, zal de kernel hierover waarschuwen, en zou je het met de hand op moeten starten (/sbin/update). In werkelijkheid worden er in de cache geen bestanden gebufferd, maar blokken, wat de kleinste eenheden zijn van disk I/O (ze zijn onder Linux meestal 1 kB). Op deze manier worden ook directories, super blocks en andere administratieve gegevens van een bestandssysteem en disks zonder bestandssysteem in de cache geplaatst. De doeltreffendheid van een cache wordt voornamelijk bepaald door de grootte ervan. Een kleine cache is vrijwel nutteloos: het zal zo weinig gegevens bevatten dat alle in de cache geplaatste gegevens uit de cache zullen worden verwijderd nog voor het opnieuw gebruikt kan worden. De kritieke grootte hangt af van de hoeveelheid ingelezen en weggeschreven gegevens, en hoevaak dezelfde gegevens worden benaderd. De enige manier om daar achter te komen, is door ermee te experimenteren. Als de cache van een vastgestelde grootte is, is het ook niet verstandig dat deze te groot is, omdat het mogelijk is dat het vrije geheugen daardoor te klein zal zijn en het swappen zal veroorzaken (wat ook langzaam is). Om zo efficiënt mogelijk gebruik te maken van het echte geheugen, maakt Linux automatisch van al het vrije RAM gebruik voor de buffer cache, maar het maakt de cache ook kleiner als programma's meer geheugen nodig hebben. Onder Linux hoef je niets te doen om van de cache gebruik te maken, het gebeurt volledig automatisch. Behalve voor de hieropvolgende juiste procedures voor shutdown en het verwijderen van diskettes hoef je je er geen zorgen om te maken. Boot En Shutdown
Start me up Ah... you've got to... you've got to Never, never never stop Start it up Ah... start it up, never, never, never You make a grown man cry, you make a grown man cry (Rolling Stones)
Deze sectie legt uit wat er gebeurt als een Linux systeem wordt opgestart en wordt afgesloten, en hoe het op de juiste wijze zou moeten worden gedaan. Als de juiste procedures niet worden opgevolgd, kan het zijn dat er bestanden beschadigd raken of verloren gaan. Een overzicht van boots en shutdowns De handeling waarbij een computersysteem wordt aangezet en het besturingssysteem wordt geladen, Bij eerdere computers was het niet genoeg om louter de computer aan te zetten, je moest bovendien handmatig het besturingssysteem laden. wordt booten genoemd. De naam is afkomstig van een afbeelding, waarbij de computer zichzelf aan zijn laarzen probeert op te trekken, maar de handeling zelf is iets realistischer. Tijdens bootstrapping laadt de computer als eerste een klein stukje code dat een bootstrap loader wordt genoemd, dat op zijn beurt het besturingssysteem laadt en start. De bootstrap loader wordt meestal op een vaste plaats op een harddisk of diskette opgeslagen. De reden voor dit twee-staps proces is dat het besturingssysteem te groot en gecompliceerd is, en het eerste stukje code dat de computer laadt, zeer klein moet zijn (een paar honderd bytes), om te voorkomen dat de firmware onnodig gecompliceerd wordt. Verschillende computers doen de bootstrapping anders. Bij PC's leest de computer (de BIOS) de eerste sector (genaamd boot sector) van een diskette of harddisk in. In deze sector bevindt zich de bootstrap loader. Het laadt het besturingssysteem elders vanaf de disk (of vanaf één of andere, andere plaats). Nadat Linux is geladen, initialiseert het de hardware en device drivers, en start vervolgens init op. init start andere processen waardoor gebruikers in kunnen loggen, en iets kunnen doen. De details hierover zullen hieronder worden besproken. Om een Linux-systeem af te kunnen sluiten, zal eerst alle processen moeten worden verteld dat ze ermee moeten stoppen (dit maakt dat ze eventuele bestanden sluiten en andere zaken die nodig zijn om het op orde te houden), vervolgens gebeurt het unmounten van bestandssystemen en swapgebieden, en uiteindelijk wordt er een melding op de console afgedrukt dat de computer kan worden uitgezet. Als de juiste procedure niet is gevolgd, kunnen en zullen er verschrikkelijke dingen gebeuren; als belangrijkste kan het zijn dat de inhoud van de buffer cache niet is geleegd, wat betekent dat alle gegevens in de buffer cache verloren zijn gegaan en het bestandssysteem niet constant is, en daarom mogelijk onbruikbaar. Het bootproces nader bekeken Je kunt Linux óf vanaf een diskette óf vanaf de harddisk booten. De installatie-sectie in de `Installation and Getting Started guide' (XXX citaat) legt je uit hoe je Linux zodanig kunt installeren, dat je het kunt booten zoals je dat wilt. Als een PC wordt geboot, voert de BIOS diverse testen uit om te controleren of alles in orde lijkt, Dit wordt de power on self test, afgekort tot POST genoemd. en zal dan het werkelijke bootproces beginnen. Het zal een diskdrive selecteren (meestal is dit het eerste diskettestation als er een diskette inzit, anders de eerste harddisk, als er één in de computer is geïnstalleerd; de volgorde kan echter configureerbaar zijn) en vervolgens daarvan de eerste sector inlezen. Dit wordt de boot sector genoemd; bij een harddisk wordt het ook wel de master boot record genoemd, aangezien er op een harddisk verscheidene partities voor kunnen komen, elk met een eigen bootsector. In de bootsector staat een klein programma (klein genoeg om in één sector te passen) wiens verantwoordelijkheid het is om het werkelijke besturingssysteem van disk te lezen en het te starten. Als Linux vanaf een diskette wordt opgestart, bevat de bootsector code die slechts de eerste paar honderd blokken inleest (afhankelijk van de werkelijke kernelgrootte natuurlijk) naar een van te voren vastgestelde plek in het geheugen. Op een Linux bootdiskette komt geen bestandssysteem voor, de kernel is gewoon in aaneengesloten sectoren opgeslagen, aangezien dit het bootproces vereenvoudigt. Het is echter mogelijk om vanaf een diskette te booten met een bestandssysteem door gebruik te maken van LILO, de LInux LOader. Wanneer er vanaf de harddisk wordt geboot, zal de code in het master boot record de partitietabel onderzoeken (ook die in de master boot record), de actieve partitie identificeren (de partitie die als opstartbaar is gemarkeerd), de bootsector vanaf die partitie inlezen, en vervolgens de code in deze bootsector starten. De code in de bootsector van de partitie doet wat de bootsector van een diskette doet: het zal de kernel vanaf de partitie inlezen en starten. De details variëren echter, aangezien het in het algemeen niet nuttig is om een aparte partitie voor alleen de kernel image te hebben. De code in de bootsector van de partitie kan gewoon de disk niet in opeenvolgende volgorde inlezen, het moet de sectoren kunnen vinden waar het bestandssysteem ze heeft geplaatst. Er zijn verscheidene manieren om hier iets aan te doen, maar de meest algemene manier is om LILO te gebruiken. (De details over hoe je dit kunt doen zijn echter voor deze bespreking niet relevant; zie de LILO documentatie voor meer informatie; het is zeer volledig.) Wanneer er met LILO wordt geboot, zal het normaal gesproken de standaardkernel rechtstreeks inlezen en booten. Het is ook mogelijk om LILO zodanig te configuren dat het één van verscheidene kernels, of zelfs andere besturingssystemen dan Linux kan booten, en het is mogelijk dat de gebruiker tijdens de systeemstart kan kiezen welke kernel of welk besturingssysteem moet worden geboot. LILO kan zo worden geconfigureerd dat als de alt, ctrl of shift-toets tijdens de systeemstart wordt ingedrukt (wanneer LILO wordt geladen), LILO erom zal vragen wat er moet worden geboot en niet direct de standaard boot. Als alternatief kan LILO zo worden geconfigureerd dat dit het altijd zal vragen, en optioneel dat er na het verstrijken van een bepaalde opgegeven tijd de standaardkernel zal worden geboot. Het is met LILO ook mogelijk om een kernel commandoregel argument na de naam van de kernel of het besturingssysteem op te geven. Zowel het booten vanaf een diskette als vanaf een harddisk heeft voordelen, maar in het algemeen is het prettiger om vanaf de harddisk te booten, aangezien hiermee het gedoe met de diskettes wordt vermeden. Bovendien is het sneller. Het kan echter wat lastiger zijn om het systeem zodanig te installeren dat er vanaf de harddisk wordt geboot, dus veel mensen zullen er in eerste instantie voor kiezen om vanaf een diskette te booten, en als het systeem op een andere wijze wordt geïnstalleerd en het goed werkt, LILO installeren en vanaf de harddisk booten. Nadat de Linux-kernel in het geheugen is gelezen, en echt is opgestart, gebeurt er globaal het volgende: De Linux kernel wordt gecomprimeerd geïnstalleerd, dus het zal zichzelf eerst decomprimeren. Aan het begin van de kernel bevindt zich een programma'tje dat dit doet. Als je een super-VGA-kaart hebt die door Linux wordt herkend en een aantal speciale tekstmodes heeft (zoals 100 kolommen bij 40 rijen), dan vraagt Linux je welke mode je wilt gebruiken. Het is mogelijk om tijdens het compileren van de kernel, van te voren een video-mode in te stellen, zodat dit nooit zal worden gevraagd. Dit kan ook met LILO of rdev. Hierna controleert de kernel welke andere hardware er is (harddisks, diskettes, netwerkadapters, enz), en configureert het een aantal daarvoor geschikte device-drivers; terwijl het dit doet, geeft het de meldingen weer van zijn bevindingen. Als ik bijvoorbeeld boot, ziet het er ongeveer zo uit: LILO boot: Loading linux. Console: colour EGA+ 80x25, 8 virtual consoles Serial driver version 3.94 with no serial options enabled tty00 at 0x03f8 (irq = 4) is a 16450 tty01 at 0x02f8 (irq = 3) is a 16450 lp_init: lp1 exists (0), using polling driver Memory: 7332k/8192k available (300k kernel code, 384k reserved, 176k data) Floppy drive(s): fd0 is 1.44M, fd1 is 1.2M Loopback device init Warning WD8013 board not found at i/o = 280. Math coprocessor using irq13 error reporting. Partition check: hda: hda1 hda2 hda3 VFS: Mounted root (ext filesystem). Linux version 0.99.pl9-1 (root@haven) 05/01/93 14:12:20 De exacte teksten zijn op de diverse systemen, afhankelijk van de hardware, de in gebruik zijnde Linux-versie, en hoe het werd geconfigureerd, verschillend. Vervolgens zal de kernel proberen het root bestandssysteem te mounten. De plaats is tijdens het compileren of op enig moment met rdev of LILO configureerbaar. Het type bestandssysteem wordt automatisch gedetecteerd. Als het mounten van het root bestandssysteem mislukt, bijvoorbeeld omdat je vergat de corresponderende driver voor het bestandssysteem in de kernel te compileren, genereert de kernel een `panic' en stopt het systeem (er is toch niet veel dat 't kan doen). Het root bestandssysteem wordt gewoonlijk read-only gemount (dit kan op dezelfde manier worden ingesteld als de plaats). Dit maakt het mogelijk het bestandssysteem te controleren terwijl het is gemount: het is geen goed idee om een bestandssysteem te controleren als het read-write is gemount. Hierna start de kernel in de achtergrond het programma init (te vinden in /sbin/init) (dit zal altijd procesnummer 1 zijn). init doet diverse opstartkarweitjes. Wat het exact doet, hangt af van de wijze waarop het is geconfigureerd; zie voor meer informatie (nog niet geschreven). Het zal op z'n minst een aantal essentiële daemons in de achtergrond opstarten. init schakelt dan over op multi-user mode, en start een getty voor virtuele consoles en seriële lijnen. getty is het programma waardoor mensen via virtuele consoles en seriële terminals in kunnen loggen. Het kan zijn dat init ook nog wat andere programma's opstart, maar dit is afhankelijk van hoe het is geconfigureerd. Hierna is de boot compleet, en is het systeem normaal beschikbaar en werkend. Meer over shutdowns Het is belangrijk de juiste procedures te volgen wanneer je je Linux systeem afsluit. Als dit mislukt, zullen je bestandssystemen waarschijnlijk worden geruïneerd en de bestanden zullen waarschijnlijk door elkaar worden gehusseld. Linux maakt namelijk gebruik van een diskcache waarbij de gegevens niet onmiddelijk naar disk worden geschreven, maar alleen bij tussenpozen. Dit verbetert de performance enorm, maar betekent ook dat als je de computer zomaar ineens gewoon uitzet, er zich in de cache nog een heleboel gegevens kunnen bevinden, en datgene op de disk geen volledig werkend bestandssysteem is (omdat er slechts een aantal zaken naar de disk zijn geschreven). Een andere reden tegen het indrukken van de aan/uit-knop is dat er in een multi-tasking systeem heel wat andere dingen in de achtergrond aan de gang kunnen zijn, en het uitzetten van je computer kan nogal rampzalig zijn. Door de juiste procedure te volgen bij het uitzetten van de computer, ben je ervan verzekerd dat alle achtergrondprocessen hun gegevens op kunnen slaan. Het commando voor het juist afsluiten van een Linux-systeem is shutdown. Het wordt gewoonlijk op één van de volgende twee manieren gebruikt: Als je op je systeem de enige gebruiker bent, is de gebruikelijke manier om shutdown te gebruiken door alle nog draaiende programma's af te sluiten, op alle virtuele consoles uit te loggen, als root op één van de virtuele consoles in te loggen (of als root ingelogd blijven als je al ingelogd was, maar je zou naar de homedirectory van root moeten gaan of problemen met het unmounten te voorkomen), en vervolgens het commando shutdown -h now moeten geven (vervang now door een plus-teken en een nummer in minuten als je een onderbreking in wilt lassen, alhoewel je dit op een single user system meestal niet zal doen). Je kunt als alternatief het commando shutdown -h +time message gebruiken, als je systeem voor meerdere gebruikers is bestemd. time is hier de tijd in minuten totdat het systeem zal worden gestopt, en message is een korte uitleg waarom het systeem zal worden afgesloten. # shutdown -h +10 'We zullen een nieuwe disk installeren. Het systeem zou binnen drie uur weer on-line moeten zijn.' # Dit zal iedereen waarschuwen dat het systeem over tien minuten zal worden afgesloten, en dat ze beter af kunnen sluiten of anders gegevens verliezen. De waarschuwing wordt op iedere terminal afgedrukt waarop iemand is ingelogd, inclusief alle xterm's: Broadcast message from root (ttyp0) Wed Aug 2 01:03:25 1995... We zullen een nieuwe disk installeren. Het systeem zou over drie uur weer beschikbaar moeten zijn. Het systeem zal over 10 minuten worden AFGESLOTEN !! De waarschuwing wordt automatisch een aantal malen voor de boot herhaald, met steeds kortere intervals naarmate de tijd verstrijkt. Als na enige onderbrekingen het werkelijke afsluiten van het systeem begint, wordt op alle bestandssystemen het umount commando toegepast (behalve voor het root bestandssysteem), gebruikersprocessen worden `gekild' (als er nog steeds iemand is ingelogd), daemons worden gestopt, alle bestandssystemen zijn ontkoppeld en in het algemeen is dan alles afgesloten. Vervolgens drukt init een melding af dat je de computer uit kunt zetten. En dan, en slechts dán pas, zou je je vingers richting de aan/uit-knop kunnen bewegen. Soms, alhoewel dit zeldzaam is op ieder goed systeem, is het onmogelijk om op de juiste wijze af te sluiten. Als bijvoorbeeld de kernel een panic veroorzaakt en crasht en zich in het algemeen misdraagt, zou het volledig onmogelijk kunnen worden, dat er nog nieuwe commando's gegeven kunnen worden, daardoor wordt het juist afsluiten wat moeilijk, en zo'n beetje alles dat je kunt doen, is hopen dat er niets al te erg is beschadigd en de computer uit te zetten. Als de problemen niet al te erg zijn (laten we zeggen dat iemand je toetsenbord met een bijl heeft geraakt), en de kernel en het programma update nog steeds normaal draaien, is het waarschijnlijk beter om een paar minuten te wachten om update de kans te geven de buffer cache te legen en de stroom pas daarna af te sluiten. Een aantal mensen sluit hun systeem liever af door drie maal het commando sync op te geven, sync leegt de buffer cache. wachten totdat de disk I/O stopt, en zetten dan de computer uit. Dit is ongeveer gelijk aan het commando shutdown, als er geen programma's meer worden uitgevoerd. Het unmounten van bestandssystemen gebeurt echter niet en dit kan tot problemen leiden met de ext2fs ``clean filesystem'' flag. De drievoudige-sync methode is niet aan te bevelen. (Voor het geval je je dit afvraagt: de reden voor de drie syncs is dat de commando's in de begintijd van UNIX apart werden ingetypt, en daardoor was er voor de disk I/O meestal genoeg tijd om te beëindigen). Rebooten Rebooten betekent het systeem opnieuw booten. Dit kan worden bewerkstelligd door het eerst compleet af te sluiten, de computer uit te zetten, en het dan weer aan te zetten. Een eenvoudiger manier is om shutdown te vragen het systeem te rebooten, in plaats van het enkel te laten stoppen. Dit kan worden bewerkstelligd door met shutdown de optie te gebruiken, bijvoorbeeld door het commando shutdown -r now op te geven. De meeste Linux systemen voeren shutdown -r now uit wanneer er op het toetsenbord op ctrl-alt-del wordt gedrukt. Hiermee wordt het systeem opnieuw opgestart. De actie van ctrl-alt-del is echter configureerbaar, en het kan beter zijn om op een computer met meerdere gebruikers vóór de reboot een onderbreking in te lassen. Systemen die voor iedereen fysiek toegankelijk zijn, kunnen zelfs beter zodanig worden geconfigureerd, dat ze niets doen wanneer ctrl-alt-del wordt ingedrukt. Single user mode Het shutdown commando kan ook worden gebruikt om het systeem terug te brengen in single user mode, waarin niemand in kan loggen, maar root de console kan gebruiken. Dit is handig voor systeembeheertaken, die niet kunnen worden uitgevoerd als het systeem normaal draait. Nood opstartdiskettes Het is niet altijd mogelijk om een computer vanaf de harddisk op te starten. Als je bijvoorbeeld een fout maakt bij het configureren van LILO, kan het zijn dat je systeem niet meer op te starten is. Voor deze situaties heb je een alternatieve manier nodig om op te starten die altijd functioneert (zolang de hardware functioneert). Voor typische PC's, betekent dit om via het diskettestation op te starten. De meeste Linux-distributies stellen je tijdens de installatie in de gelegenheid om een nood opstartdisk aan te maken. Het is een goed idee om dit te doen. Een aantal van dergelijke disks bevatten echter slechts de kernel, en gaan er vanuit dat je de programma's op de installatiedisks van de distributie zal gebruiken om welk probleem je ook hebt, te herstellen. Soms zijn die programma's niet voldoende; het kan bijvoorbeeld zijn, dat je een aantal bestanden van een backup terug moet zetten, en je de backup hebt gemaakt met programma's, die niet op de installatiedisks staan. Dus het kan bovendien nodig zijn dat je een aangepaste root diskette moet maken. De Bootdisk HOWTO door Graham Chapman (XXX citaat) bevat hiervoor de instructies. Je moet er natuurlijk om denken dat je de nood boot- en root diskettes bijgewerkt houdt. Je kunt de diskdrive die je gebruikt om de rootdisk te mounten niet voor iets anders gebruiken. Dit kan onhandig zijn als je slechts één diskdrive hebt. Als je echter voldoende geheugen hebt, kun je de bootdisk zodanig configureren dat het de rootdisk in een ramdisk laadt (de kernel op de bootdisk moet hiervoor speciaal worden geconfigureerd). Zodra de rootdisk in de ramdisk is geladen, is de diskdrive vrij om andere disks te mouten. <command>init</command>
Uuno on numero yksi (Slogan voor een serie Finse films).
 Dit hoofdstuk beschrijft het init proces, wat het eerste proces op gebruikersniveau is dat door de kernel wordt gestart. Het init proces heeft veel belangrijke taken, zoals het opstarten van getty (zodat gebruikers in kunnen loggen), runlevels implementeren, en zorg dragen voor weesprocessen. Dit hoofdstuk legt uit hoe init is geconfigureerd en hoe je gebruik kunt maken van de verschillende runlevels. <command>init</command> is als eerste aan de beurt init is één van die programma's die absoluut essentieel zijn voor de werking van een Linux-systeem, maar je kunt nog steeds het meeste negeren. Een goede Linux-distributie zal met een configuratie voor init worden geleverd die voor de meeste systemen zal functioneren, en op deze systemen is er niets dat je zou moeten doen aan init. Gewoonlijk hoef je je niet druk te maken om init als je seriële terminals, dial-in (niet dial-out) modems aansluit, of als je het standaard runlevel wilt wijzigen. Wanneer de kernel zichzelf heeft gestart (in het geheugen is geladen, de uitvoering is gestart, en alle devicedrivers en gegevenstructuren en dergelijke heeft geïnitialiseerd), eindigt het zijn deel van het opstartproces door een programma op gebruikersniveau op te starten, te weten init. Dus init is altijd het eerste proces (het procesnummer is altijd 1). De kernel zoekt op een paar lokaties naar init die daar historisch voor werden gebruikt, maar de juiste lokatie (op een Linux-systeem) ervoor is /sbin/init. Als de kernel init niet kan vinden, probeert het /bin/sh op te starten, en als ook dat niet lukt, mislukt het opstarten van het systeem. Wanneer init start, beëindigt dit het bootproces door een aantal administratieve taken uit te voeren, zoals het controleren van de bestandssystemen, het opschonen van /tmp, het starten van diverse services, en het starten van een getty voor iedere terminal en virtuele console waar gebruikers op in kunnen loggen (zie ). Nadat het systeem juist is ingesteld, herstart init getty voor iedere terminal nadat een gebruiker is uitgelogd (zodat de volgende gebruiker in kan loggen). init adopteert ook weesprocessen: wanneer een proces een kindproces start en het begeeft het voor het kindproces, wordt het kindproces onmiddellijk een kind van init. Dit is om diverse technische redenen belangrijk, maar het is goed er van op de hoogte te zijn, aangezien dit het eenvoudiger maakt de lijst met processen en grafische weergave van de processen te begrijpen. init zelf mag niet worden gekild. Je kunt init zelfs niet met SIGKILL `killen'. Er zijn een paar varianten op init beschikbaar. Bij de meeste Linux-distributies wordt gebruik gemaakt van sysvinit (geschreven door Miquel van Smoorenburg), welke is gebaseerd op het System V init ontwerp. De BSD versies van Unix hebben een verschillende init. Het voornaamste verschil is runlevels: System V heeft ze, BSD heeft ze niet (tenminste volgens de traditie) Dit verschil is niet essentieel. We zullen alleen sysvinit bekijken. Configureren van <command>init</command> om <command>getty</command> te starten: het bestand <filename>/etc/inittab</filename> Als het opstart, leest init het configuratiebestand /etc/inittab. Terwijl het systeem draait, zal het dit opnieuw inlezen, als het HUP signaal wordt gezonden; Bijvoorbeeld door als root het commando kill -HUP 1 te gebruiken. deze eigenschap maakt het onnodig om het systeem te booten voor het gewenste effect, nadat er wijzigingen aan de init configuratie zijn aangebracht. Het bestand /etc/inittab is een beetje gecompliceerd. We zullen beginnen met een eenvoudige situatie om getty regels te configureren. Regels in /etc/inittab bestaan uit vier door dubbele punten gescheiden velden: id:runlevels:actie:proces De velden worden hieronder beschreven. Bovendien kan /etc/inittab lege velden bevatten, en regels die beginnen met een hekje (`#'); deze worden beiden genegeerd. id Hiermee wordt de regel in het bestand geïdentificeerd. Voor getty regels, geeft het de terminal aan waarop het draait (de tekens na /dev/tty in de naam van het devicebestand). Voor andere regels, maakt het niet uit (afgezien van de lengte-beperkingen), maar het zou wel uniek moeten zijn. runlevels De run levels waarop de regel betrekking heeft. De run levels worden als enkele cijfers, zonder scheidingstekens opgegeven. (Run levels worden in de volgende sectie beschreven). actie Welke actie door de regel zou moeten worden genomen, b.v., respawn om het commando in het volgende veld nogmaals uit te voeren, als het wordt beëindigd, of once om het slechts éénmaal uit te voeren. proces Het uit te voeren commando. Om een getty op de eerste virtuele terminal te starten (/dev/tty1), in alle normale multi-user run levels (2-5), zou men de volgende regel schrijven: 1:2345:respawn:/sbin/getty 9600 tty1 Het eerste veld wil zeggen dat dit de regel is voor /dev/tty1. Het tweede veld wil zeggen dat het voor de run levels 2, 3, 4 en 5 geldt. Het derde veld betekent dat het commando weer zou moeten uitgevoerd, nadat het is gestopt (zodat men in kan loggen, uit kan loggen en weer in kan loggen). Het laatste veld is het commando dat getty op de eerste virtuele terminal opstart. Verschillende versies van getty worden anders uitgevoerd. Raadpleeg je manual page, en zorg ervoor dat je er zeker van bent, dat dit de juiste manual page is. Als je terminals of dial-in modemlijnen aan het systeem toe wilt voegen, voeg je meer regels toe aan /etc/inittab, één voor iedere terminal of dial-in lijn. Zie de manual pages init, inittab, en getty voor wat meer details. Als een commando bij het opstarten mislukt, en init is zo geconfigureerd dat het dit herstart, zal het een heleboel systeembronnen gebruiken: init start het, het mislukt, init start het, het mislukt, init start het, het mislukt, enzovoort, ad infinitum. Om dit te voorkomen, zal init bijhouden hoevaak het een commando opnieuw start, en als de frequentie te hoog wordt, zal het een onderbreking van vijf minuten inlassen voordat het weer opnieuw start. Run levels Een run level is een toestand van init en het gehele systeem dat definieert welke systeemservices in werking zijn. Run levels worden geïdentificeerd door nummers, zie . Er is geen éénstemmigheid hoe de gebruikersgedefinieerde runlevels (2 tot 5) te gebruiken. Een aantal systeembeheerders gebruiken run levels om te definiëren welke subsystemen werken, b.v., of X draait, of het netwerk operationeel is, enzovoort. Anderen hebben alle subsystemen altijd draaien of starten en stoppen ze individueel, zonder de run levels te wijzigen, aangezien run levels te grof zijn voor het beheren van hun systemen. Je zal het voor jezelf moeten beslissen, maar misschien dat het 't makkelijkst is, om navolging te geven aan hoe je Linux-distributie het doet. Run level nummers 0 Stop het systeem. 1 Single-user mode (voor speciaal beheer). 2-5 Normale werking (gebruikersgedefinieerd). 6 Reboot.
Run levels worden geconfigureerd in /etc/inittab door regels zoals de volgende regel: l2:2:wait:/etc/init.d/rc 2 Het eerste veld is een willekeurig label, het tweede veld betekent dat het voor runlevel 2 geldt. Het derde veld betekent dat init het commando in het vierde veld éénmaal uit zou moeten voeren, als naar het run level wordt gegaan, en dat init moet wachten tot het voltooid is. Het commando /etc/init.d/rc voert de commando's uit die nodig zijn om services te starten en stoppen om naar run level 2 te gaan. Het commando in het vierde veld doet al het moeilijke werk bij het instellen van een run level. Het start services die nog niet draaien, en stopt services die in het nieuwe run level niet meer zouden moeten draaien. Wat het commando exact is, en hoe levels worden geconfigureerd, is afhankelijk van de Linux-distributie. Als init start, zoekt het naar een regel in /etc/inittab dat het standaard run level aangeeft: id:2:initdefault: Je kunt tijdens het opstarten aan init opgeven dat het moet opstarten in een niet-standaard run level door op de commando-regel van de kernel een argument single of emergency in te voeren. De argumenten op de commando-regel van de kernel kunnen bijvoorbeeld via LILO worden opgegeven. Dit geeft je de mogelijkheid de single user mode (run level 1) te selecteren. Als het systeem al draait, kun je met het commando telinit het run level wijzigen. Als het run level wordt gewijzigd, voert init de relevante commando's vanuit /etc/inittab uit. Speciale configuratie in <filename>/etc/inittab</filename> De /etc/inittab heeft een aantal speciale features die ervoor zorgen dat init op speciale omstandigheden reageert. Deze speciale features worden in het derde veld door speciale sleutelwoorden gemarkeerd. Een aantal voorbeelden: powerwait Staat toe dat met init het systeem kan worden afgesloten, als er een stroomstoring is. Hierbij wordt uitgegaan van het gebruik van een UPS, en software die de UPS in de gaten houdt en init informeert dat de stroom is uitgevallen. ctrlaltdel Staat toe dat met init het systeem opnieuw kan worden opgestart, als de gebruiker onder de console de toetsencombinatie ctrl-alt-del indrukt. Merk op dat de systeembeheerder de reactie van ctrl-alt-del in plaats daarvan naar iets anders kan configureren. b.v. om te worden genegeerd, als het systeem zich op een publieke lokatie bevindt. (Of om nethack op te starten.) sysinit Commando dat wordt gedraaid als het systeem wordt geboot. Dit commando schoont bijvoorbeeld gewoonlijk /tmp op. De lijst hierboven is niet volledig. Zie de manual page van inittab voor alle mogelijkheden, en voor details over hoe je de bovengenoemde mogelijkheden kunt gebruiken. Booten in single user mode Een belangrijk run level is single user mode (run level 1), waarin alleen de systeembeheerder de computer kan gebruiken, met zo min mogelijk systeemservices, waaronder logins, draaien. Single user mode is noodzakelijk voor het uitvoeren van een paar beheertaken, Het zou waarschijnlijk niet moeten worden gebruikt om voor nethack te spelen. zoals met het uitvoeren van een fsck op een /usr partitie, aangezien dit vereist dat de partitie niet gemount is, en dat is niet mogelijk, tenzij zo'n beetje alle systeemservices zijn `gekild'. Een draaiend systeem kan in single user mode worden gebracht door het commando telinit te verzoeken naar run level 1 te gaan. Tijdens het opstarten van het systeem, kan het worden ingevoerd door het woord single of emergency op de commando-regel van de kernel op te geven: de kernel geeft de commando-regel ook door aan init en init maakt uit dat woord op dat dit het standaard run level niet moet gebruiken. (Hoe de commando-regel van de kernel moet worden ingevoerd, is afhankelijk van de wijze waarop je het systeem boot). Booten in single user mode is soms nodig om fsck met de hand uit te kunnen voeren, voordat iets wordt gemount of iets anders dat een gebrekkige /usr partitie aanroert (iedere activiteit op een gebrekkig bestandssysteem kan de situatie verergeren, dus het beste is om fsck zo spoedig mogelijk op te starten). De opstartscripts die init uitvoert, zullen automatisch naar single user mode gaan, als de automatische fsck tijdens de systeemstart mislukt. Dit is een poging om te voorkomen dat het systeem een bestandssysteem gebruikt dat zo gebrekkig is, dat fsck het niet automatisch kan herstellen. Een dergelijke beschadiging is relatief zeldzaam en meestal gaat het om een defecte harddisk of een experimentele kernel-release, maar het kan maar beter worden hersteld. Als een beveiligingsmaatregel, zal een juist geconfigureerd systeem vragen om het root wachtwoord, voordat het de shell in single user modus opstart. Anders zou het nogal eenvoudig zijn om gewoon een passende regel aan LILO op te geven om als root in te kunnen loggen. (Dit werkt natuurlijk niet als /etc/passwd beschadigd is door problemen met het bestandssysteem, en in dat geval kun je maar beter een diskette bij de hand hebben). In- en uitloggen
I don't care to belong to a club that accepts people like me as a member. (Groucho Marx)
Deze sectie beschrijft wat er gebeurt als een gebruiker in- of uitlogt. De diverse interacties met achtergrondprocessen, logbestanden, configuratiebestanden, enzovoort worden in detail beschreven. Logins via terminals toont hoe de logins via terminals plaatsvinden. Als eerste zorgt init dat er een getty programma is voor de terminalverbinding (of console). getty luistert naar de terminal en wacht op de gebruiker totdat hij er klaar voor is om in te loggen (dit betekent meestal dat de gebruiker iets in moet typen). Als het een gebruiker opmerkt, toont getty een welkomstbericht (opgeslagen in /etc/issue), en vraagt om de gebruikersnaam, en start als laatste het login programma op. login krijgt de gebruikersnaam als een parameter, en vraagt de gebruiker om het wachtwoord. Als deze overeenkomen, start login de voor de gebruiker geconfigureerde shell; anders eindigt het en stopt het dit proces (misschien nadat het de gebruiker nog een andere kans heeft gegeven bij het invoeren van de gebruikersnaam en het wachtwoord). init merkt dat het proces werd beëindigd, en start een nieuwe getty voor de terminal.
Logins via terminals: de interactie van <command>init</command>, <command>getty</command>, <command>login</command>, en de shell.
Het enige nieuwe proces is het proces dat door init wordt aangemaakt (door gebruik te maken van de fork system call); getty en login vervangen alleen het programma dat in het proces wordt uitgevoerd (door gebruik te maken van de exec system call). Voor seriële lijnen is een apart programma nodig om de gebruiker op te merken, aangezien het gecompliceerd kan zijn (en dit het traditioneel was) om op te merken wanneer een terminal actief wordt. getty past ook de snelheid en de andere instellingen van de verbinding aan, wat vooral belangrijk is voor dial-in verbindingen, waar deze parameters van aanroep tot aanroep kunnen veranderen. Er zijn verscheidene versies van getty en init in gebruik, allen met hun goede en slechte kanten. Het is een goed idee om bekend te raken met de versies op je systeem, en ook met de andere versies (je zou de Linux Software Map kunnen gebruiken om ze op te zoeken). Als je geen dial-in's hebt, hoef je je waarschijnlijk niet druk te maken om getty, maar init is nog steeds belangrijk. Logins via het netwerk Twee computers aangesloten op hetzelfde netwerk worden gewoonlijk via een enkele fysieke kabel gekoppeld. Wanneer ze via het netwerk communiceren, zijn de programma's in iedere computer die aan de communicatie deelnemen via een virtuele connectie gekoppeld, een soort imaginaire kabel. Zover als het de programma's aan beiden kanten van de virtuele connectie betreft, hebben ze een monopolie op hun eigen kabel. Aangezien de kabel echter niet echt is, slechts imaginair, kunnen de besturingssystemen van beide computers verscheidene virtuele connecties hebben, die dezelfde fysieke kabel delen. Op deze manier kunnen verscheidene programma's, door van slechts een enkele kabel gebruik te maken, communiceren zonder dat ze weten of zich bezig houden met de andere communicaties. Het is zelfs mogelijk dat verscheidene computers dezelfde kabel gebruiken; de virtuele connecties bestaan tussen twee computers, en de andere computers negeren die verbindingen waar ze geen deel aan nemen. Dat is een gecompliceerde en overtrokken beschrijving van de werkelijkheid. Het kan echter goed genoeg zijn om de belangrijke reden te begrijpen waarom netwerklogins iets anders werken dan normale logins. De virtuele connecties worden tot stand gebracht wanneer er twee programma's op verschillende computers met elkaar wensen te communiceren. Aangezien het in principe mogelijk is vanaf iedere andere computer in een netwerk op iedere andere computer in te loggen, zijn er een groot aantal potentiële virtuele communicaties. Daarom is het niet praktisch voor iedere potentiële login een getty te starten. Er is een enkel proces inetd (corresponderend met getty) dat alle netwerklogins afhandelt. Wanneer het een inkomende netwerklogin in de gaten krijgt, (d.w.z., het merkt dat het een nieuwe virtuele connectie met een andere computer krijgt), start het een nieuw proces om die enkele login af te handelen. Het originele proces blijft gehandhaafd in afwachting van nieuwe logins. Om het nog wat gecompliceerder te maken, zijn er meerdere communicatieprotocollen voor netwerklogins. De twee belangrijkste zijn telnet en rlogin. In aanvulling op logins, zijn er vele andere virtuele connecties die tot stand kunnen worden gebracht (voor FTP, Gopher, HTTP, en andere netwerkservices). Het zou niet doeltreffend zijn als een apart proces, in afwachting van een bepaald type verbinding, nodig zou zijn, dus in plaats daarvan is er slechts één die het type verbinding kan herkennen en het juiste type programma kan starten om in de service te voorzien. Deze enkele listener wordt inetd genoemd; zie de Linux Network Administrators' Guide voor meer informatie. Wat <command>login</command> doet Het login programma zorgt voor de authenticiteit van de gebruiker (dus dat de gebruikersnaam en het wachtwoord overeenkomen), en om de initiële omgeving voor de gebruiker in te stellen door de permissies voor de seriële lijn in te stellen en de shell op te starten. Een deel van de initiële setup toont als uitvoer de inhoud van het bestand /etc/motd (`motd' staat voor `message of the day' ofwel `melding van de dag') en controleert op elektronische mail. Dit kan worden gedeactiveerd door een bestand met de naam .hushlogin in de homedirectory van de gebruiker aan te maken. Als het bestand /etc/nologin stopt, worden logins gedeactiveerd. Dat bestand wordt door shutdown, en die daaraan verwant zijn, aangemaakt. login controleert op dit bestand, en zal weigeren een login te accepteren als het bestaat. Als het bestaat, toont login als uitvoer de inhoud ervan naar de terminal voordat het stopt. login logt alle mislukte pogingen om in te loggen naar een systeemlogbestand (via syslog). Het logt ook alle logins door root. Beide bestanden kunnen handig zijn voor het opsporen van indringers. Thans ingelogde mensen staan in /var/run/utmp. Dit bestand is geldig totdat het systeem weer wordt geboot of wordt afgesloten; het wordt opgeschoond als het systeem wordt geboot. Het geeft een opsomming van iedere gebruiker en de terminal (of netwerkverbinding) waar deze gebruiker gebruik van maakt, samen met nog wat andere nuttige informatie. De who, w, en andere vergelijkbare commando's kijken in utmp om te zien wie er zijn ingelogd. Alle successvolle logins worden opgenomen in /var/log/wtmp. Dit bestand zal zonder beperking groter worden, dus het moet periodiek worden opgeschoond, bijvoorbeeld door een wekelijkse cron taak om het op te schonen. Goede Linux-distributies doen dit direct als ze uit de verpakking zo worden geïnstalleerd. Het commando last bladert door wtmp. Zowel utmp als wtmp zijn in binair formaat (zie de utmp manual page); het is helaas niet handig om ze zonder speciale programma's te onderzoeken. X en xdm XXX X implementeert logins via xdm; ook: xterm -ls Toegangsbeheer De gebruikersdatabase is volgens traditie in het bestand /etc/passwd te vinden. Een aantal systemen maken gebruik van shadow passwords, en hebben de wachtwoorden naar /etc/shadow verplaatst. Sites met veel computers die de accounts delen gebruiken NIS of één of andere methode om de gebruikersdatabase op te slaan; het kan zelfs zijn dat ze de database vanaf een centrale lokatie naar alle andere computers kopiëren. In de gebruikersdatabase staan niet alleen de wachtwoorden, maar ook nog wat aanvullende informatie over de gebruikers, zoals hun echte namen, homedirectories en login-shells. Deze andere informatie moet openbaar toegankelijk zijn, zodat iedereen het kan lezen. Daarom wordt het wachtwoord versleuteld opgeslagen. Dit heeft de keerzijde dat iedereen met toegang tot het versleutelde wachtwoord diverse cryptografische methoden kan gebruiken om het te raden, zonder echt op de computer proberen in te loggen. Met Shadow passwords wordt geprobeerd dit te voorkomen door het wachtwoord naar een ander bestand te verplaatsen, welke alleen root kan lezen (het wachtwoord wordt nog steeds versleuteld opgeslagen). Het kan echter moeilijk zijn om shadow passwords later op een systeem te installeren waarop het niet werd ondersteund. Het is belangrijk om, met of zonder wachtwoorden, ervoor te zorgen dat alle wachtwoorden voor een systeem goed zijn, d.w.z. niet makkelijk te raden. Het programma crack kan worden gebruikt om wachtwoorden te kraken; ieder wachtwoord dat het kan vinden is per definitie geen goed wachtwoord. Terwijl crack door indringers kan worden uitgevoerd, kan het ook door de systeembeheerder worden gebruikt om slechte wachtwoorden te voorkomen. Goede wachtwoorden kunnen ook worden afgedwongen door het programma passwd; dit is in feite in CPU cyclussen effectiever, aangezien het kraken van wachtwoorden heel veel werk voor een computer vereist. De database voor gebruikersgroepen wordt bewaard in /etc/group; voor systemen met shadow passwords, kan er een /etc/shadow.group zijn. root kan gewoonlijk niet via de meeste terminals of het netwerk inloggen, alleen via terminals die in het bestand /etc/securetty zijn opgesomd. Dit maakt het nodig om fysiek toegang te verkrijgen tot één van deze terminals. Het is echter mogelijk om via iedere terminal als iedere andere gebruiker in te loggen, en het su commando te gebruiken, om root te worden. Opstarten van de Shell Wanneer een interactieve login-shell start, voert het automatisch één of meer voorgedefinieerde bestanden uit. Verschillende shells voeren verschillende bestanden uit; zie de documentatie van iedere shell voor verdere informatie. De meeste shells voeren eerst één of ander globaal bestand uit, de Bourne shell (/bin/sh) en shells die daarvan zijn afgeleid voeren het bestand /etc/profile uit; bovendien, voeren ze het bestand .profile in de homedirectory van de gebruiker uit. /etc/profile staat de systeembeheerder toe om een algemene gebruikersomgeving in te stellen, vooral door het instellen van PATH om lokale directories met commando's op te nemen in aanvulling op de normale directories met commando's. Aan de andere kant staat .profile de gebruiker toe om de omgeving naar eigen smaak aan te passen, zonodig door de standaardomgeving te overschrijven. Beheren van gebruikersaccounts
The similarities of sysadmins and drug dealers: both measure stuff in K's, and both have users. (Old, tired computer joke.)
Dit hoofdstuk legt uit hoe je gebruikersaccounts aan kunt maken, hoe de eigenschappen van die accounts gewijzigd kunnen worden en hoe de accounts verwijderd kunnen worden. De verschillende Linux-systemen hebben verschillende tools om dit te doen. Wat is een account? Wanneer een computer door veel mensen wordt gebruikt, is het meestal nodig om onderscheid te maken tussen de gebruikers, bijvoorbeeld, zodanig dat hun privé bestanden privé gehouden kunnen worden. Dit is zelfs belangrijk als de computer slechts door één persoon tegelijkertijd gebruikt kan worden, zoals dit met de meeste microcomputers 't geval is. Het kan nogal beschamend zijn als mijn zus mijn liefdesbrieven zou kunnen lezen. Dus aan iedere gebruiker wordt een unieke gebruikersnaam gegeven en die naam wordt gebruikt om in te loggen. Er is echter meer aan een gebruiker dan slechts een naam. Een account bestaat uit alle bestanden, bronnen en informatie die aan één gebruiker toebehoren. De term zinspeelt op banken, en in een commercieel systeem is aan iedere account meestal wat geld verbonden, en dat geld verdwijnt met verschillende snelheden, afhankelijk van hoeveel de gebruiker het systeem opjaagt. Het is bijvoorbeeld mogelijk dat diskruimte een prijs per megabyte en dag heeft, en verwerkingstijd een prijs per seconde. Aanmaken van een gebruiker De Linux kernel zelf behandelt gebruikers slechts als nummers. Iedere gebruiker wordt door een unieke integer geïdentificeerd, het user id of uid, omdat nummers voor een computer sneller en eenvoudiger zijn te verwerken. Een aparte database buiten de kernel kent een tekstuele naam toe aan de username, aan ieder user id. In de database staat bovendien nog wat extra informatie. Om een gebruiker aan te maken, moet je informatie over de gebruiker aan de gebruikersdatabase toevoegen, en een homedirectory voor hem aanmaken. Mogelijk is het ook nodig de gebruiker te onderwijzen, en een passende initiële omgeving voor hem op te zetten. De meeste Linux distributies worden met een programma geleverd waarmee accounts kunnen worden aangemaakt. Er zijn er diverse van beschikbaar. Twee commandoregel alternatieven zijn adduser en useradd; het kan zijn dat er bovendien een GUI tool is. Welk programma dan ook, het resultaat is dat er een beetje handmatig werk moet worden gedaan. Zelfs als er veel en ingewikkelde details zijn, zorgen deze programma's dat het een alledaagse taak lijkt. Echter de beschrijft hoe je het met de hand kunt doen. <filename>/etc/passwd</filename> en andere informatieve bestanden De basis gebruikersdatabase in een Linux-systeem is het tekstbestand /etc/passwd (wordt het wachtwoordbestand genoemd), welke alle geldige gebruikersnamen en de daarmee overeenkomende informatie bevat. Het bestand heeft één regel per gebruikersnaam, en is in zeven door dubbele punten gescheiden velden onderverdeeld: Gebruikersnaam. Wachtwoord, in versleutelde vorm. Numeriek gebruikers-id. Numeriek groeps-id. Volledige naam of andere beschrijving van het account. Homedirectory. Login shell (programma dat bij het inloggen wordt gestart). Het formaat wordt in detail uitgelegd in de passwd manual page. Iedere gebruiker op het systeem mag het bestand passwd lezen, waardoor ze bijvoorbeeld achter de naam van de andere gebruiker kunnen komen. Dit betekent dat het wachtwoord (het tweede veld) ook voor iedereen beschikbaar is. Het wachtwoordbestand versleutelt de wachtwoorden, zodat er in theorie geen probleem is. De versleuteling is echter te kraken, vooral als het wachtwoord zwak is (b.v., het is kort en het kan in een woordenboek worden gevonden). Daarom is het geen goed idee om het wachtwoord in het bestand passwd op te slaan. Op veel Linux-systemen zijn shadow passwords ingesteld. Dit is een alternatieve manier om het wachtwoord in te bewaren: het versleutelde wachtwoord wordt in een apart bestand /etc/shadow opgeslagen, welke alleen door root kan worden gelezen. Het bestand /etc/passwd bevat alleen een speciale markering in het tweede veld. Ieder programma waarvoor het nodig is dat een gebruiker wordt geverifieerd, is setuid, en kan daarom het shadow password bestand benaderen. Normale programma's, welke alleen gebruik maken van de andere velden in het wachtwoordbestand, kunnen niet aan het wachtwoord komen. Ja, dit betekent dat het wachtwoordbestand alle informatie over een gebruiker bevat behalve zijn wachtwoord. Het wonder van de ontwikkeling. Uitkiezen van numerieke gebruikers- en groep id's Op de meeste systemen doet het er niet toe wat de numerieke gebruikers- en groep-id's zijn, maar als je gebruik maakt van het Network filesystem (NFS), heb je op alle systemen dezelfde uid en gid nodig. Dit omdat NFS ook de gebruikers met numerieke uid's identificeert. Als je geen gebruik maakt van NFS, kun je de tool waarmee je de accounts aanmaakt, ze automatisch voor je uit laten kiezen. Als je wel gebruik maakt van NFS, zul je een mechanisme uit moeten vinden voor het synchroniseren van de account informatie. Één alternatief is via het NIS systeem (zie XXX network-admin-guide). Je zou echter moeten proberen te voorkomen om numerieke uid's (en tekstuele gebruikersnamen) te hergebruiken, omdat de nieuwe eigenaar van het uid (of gebruikersnaam) toegang kan krijgen tot de bestanden van de oude eigenaar (of mail, of wat dan ook). Initiële omgeving: <filename>/etc/skel</filename> Als de homedirectory voor een nieuwe gebruiker is aangemaakt, wordt het met bestanden vanuit de /etc/skel directory geïnitialiseerd. De systeembeheerder kan bestanden in /etc/skel aanmaken die voor een prettige standaardomgeving voor gebruikers zorgen. Hij kan bijvoorbeeld een /etc/skel/.profile aanmaken waarmee de EDITOR omgevingsvariabele wordt ingesteld op een editor die voor nieuwe gebruikers gebruikersvriendelijk is. Het is echter meestal het beste om /etc/skel zo klein mogelijk te houden, aangezien het vrijwel onmogelijk zal zijn om bestaande bestanden van gebruikers bij te werken. Als bijvoorbeeld de naam van een gebruikersvriendelijke editor wijzigt, zouden alle bestaande gebruikers hun .profile moeten wijzigen. De systeembeheerder zou kunnen proberen om dit automatisch met een script te doen, maar dat zal bijna zeker het bestand van iemand breken. Wanneer het maar mogelijk is, is het beter om globale configuraties in globale bestanden te plaatsen, zoals in /etc/profile. Op deze manier is het mogelijk om het bij te werken zonder de eigen setups van gebruikers te breken. Met de hand aanmaken van een gebruiker Volg de volgende stappen om handmatig een account aan te maken: Wijzig /etc/passwd met vipw en voeg een nieuwe regel toe voor de nieuwe account. Wees voorzichtig met de syntax. Wijzig het niet direct met een editor! vipw blokkeert het bestand, zodat andere commando's het niet tegelijkertijd zullen proberen bij te werken. Je zou een `*', in het veld met het wachtwoord moeten plaatsen, waardoor het onmogelijk wordt om in te loggen. Wijzig op vergelijkbare wijze het /etc/group bestand met vigr, als je tevens een nieuwe groep aan moet maken. Maak de homedirectory van de gebruiker aan met mkdir. Kopieer de bestanden vanuit /etc/skel naar de nieuwe homedirectory. Corrigeer met chown en chmod respectievelijk de eigenaar van de bestanden en de permissies. De optie is erg handig. De correcte permissies variëren wat van de ene tot de andere plaats, maar gewoonlijk doen de volgende commando's het juiste: cd /home/newusername chown -R username.group . chmod -R go=u,go-w . chmod go= . Stel het wachtwoord in met passwd. Nadat je in de laatste stap het wachtwoord hebt ingesteld, zal de account werken. Je zou het niet in moeten stellen totdat al het andere is gedaan, anders kan het zijn dat de gebruiker per abuis inlogt, terwijl je de bestanden nog aan het kopiëren bent. Soms is het nodig om een dummy account aan te maken die Surrogaat gebruikers? niet door mensen wordt gebruikt. Om bijvoorbeeld een anonymous FTP-server in te stellen (zodat iedereen er bestanden vanaf kan dowloaden, zonder eerst een account te moeten hebben), heb je een account met de naam ftp nodig. In dergelijke gevallen is het meestal niet nodig om het wachtwoord in te stellen (laatste stap hierboven). Inderdaad is het beter om dat niet te doen, zodat niemand de account kan gebruiken, tenzij ze eerst root worden, aangezien root iedere gebruiker kan worden. Veranderen van de eigenschappen van een gebruiker Er zijn een paar commando's voor het veranderen van de diverse eigenschappen van een account (d.w.z. de relevante velden in /etc/passwd): chfn Wijzig het veld met de volledige naam. chsh Wijzig de login-shell passwd Wijzig het wachtwoord. De superuser kan deze commando's gebruiken om de eigenschappen van iedere account te veranderen. Normale gebruikers kunnen alleen de eigenschappen van hun eigen account veranderen. Soms kan het nodig zijn om deze commando's voor normale gebruikers te deactiveren (met chmod) in bijvoorbeeld een omgeving met veel beginnende gebruikers. Andere taken moeten met de hand worden gedaan. Om bijvoorbeeld de gebruikersnaam te wijzigen, moet je het bestand /etc/passwd direct (met vipw, denk eraan) met de hand wijzigen. Om een gebruiker aan meerdere groepen toe te voegen en eruit te verwijderen, zul je eveneens /etc/group (met vigr) moeten wijzigen. Dergelijke taken komen echter zelden voor, en zouden met beleid moeten worden gedaan: als je bijvoorbeeld de gebruikersnaam wijzigt, zal de gebruiker niet meer bij zijn mail kunnen komen, tenzij je ook een mail alias aanmaakt. De naam van de gebruiker kan bijvoorbeeld wijzigen door een huwelijk, en het kan zijn dat hij in zijn gebruikersnaam zijn nieuwe naam weergegeven wil zien. Verwijderen van een gebruiker Om een gebruiker te verwijderen, verwijder je eerst al zijn bestanden, mailboxen, mail aliassen, afdruktaken, cron en at taken, en alle andere verwijzingen naar de gebruiker. Dan verwijder je de relevante regel uit /etc/passwd en /etc/group (denk eraan dat je de gebruikersnaam uit alle groepen verwijderd waaraan het was toegevoegd). Het kan een goed idee zijn om de account eerst te deactiveren (zie hieronder), voordat je begint met het verwijderen van alles, om te voorkomen dat de gebruiker de account gaat gebruiken terwijl het wordt verwijderd. Denk eraan dat gebruikers bestanden kunnen hebben, die zich buiten hun homedirectory bevinden. Het commando find kan ze opsporen: find / -user username Let echter op dat het hierboven genoemde commando een lange tijd kan duren, als je disks groot zijn. Als je netwerkdisks mount, zul je op moeten passen dat je het netwerk of de server niet ruïneert. Een aantal Linux-distributies worden met speciale commando's geleverd om dit te doen; zoek naar deluser of userdel. Het is echter ook makkelijk om het met de hand te doen, en het kan zijn dat de commando's niet alles doen. Een gebruiker tijdelijk deactiveren Het is soms nodig om een gebruikersaccount tijdelijk te deactiveren, zonder het te verwijderen. Het kan bijvoorbeeld zijn dat een gebruiker zijn contributie niet heeft betaald, of dat de systeembeheerder vermoedt dat een kraker het wachtwoord van een dergelijk account in zijn bezit heeft. De beste manier om een account te deactiveren is om zijn shell in een speciaal programma te wijzigen, waarmee slechts een melding wordt afdrukt. Op deze manier zal het, voor wie er dan ook met het account probeert in te loggen, niet lukken, en degene zal weten waarom niet. In het bericht kan worden aangegeven dat er contact moet worden gezocht met de systeembeheerder zodat eventuele problemen kunnen worden opgelost. Het zou ook mogelijk zijn om de gebruikersnaam of het wachtwoord in iets anders te veranderen, maar dan weet de gebruiker niet wat er aan de hand is. Van slag geraakte gebruikers betekent meer werk. Een eenvoudige manier om de speciale programma's aan te maken is door `tail scripts' te schrijven: #!/usr/bin/tail +2 Deze account is vanwege inbreuk op de beveiliging opgeheven. Bel alsjeblieft 555-1234 en wacht op de man in 't zwart. De eerste twee tekens (`#!') geven voor de kernel aan dat de rest van de regel uit een commando bestaat dat moet worden uitgevoerd om dit bestand te interpreteren. In dit geval toont het commando tail de eerste regel op het standaarduitvoerapparaat. Als gebruiker billg van een inbreuk op de beveiliging wordt verdacht, zou de systeembeheerder iets dergelijks doen als: # chsh -s /usr/local/lib/no-login/security billg # su - tester Deze account is vanwege een inbreuk op de beveiliging opgeheven. Bel alsjeblieft 555-1234 en wacht op de man in 't zwart. # Het doel van su is uiteraard om te testen dat de verandering functioneerde. Tail scripts zouden in een aparte directory moeten worden bewaard, zodat de namen ervan de gewone gebruikerscommando's niet verstoren. Backups
Hardware is indeterministically reliable. Software is deterministically unreliable. People are indeterministically unreliable. Nature is deterministically reliable.
Dit hoofdstuk legt uit waarom, hoe en wanneer je backups maakt, en hoe je zaken vanaf backups terugzet. Het belang van backups Je data is waardevol. Het zal tijd en moeite kosten om het opnieuw aan te maken, en dat kost geld of op z'n minst persoonlijk hartzeer en tranen; soms kan het zelfs niet opnieuw worden aangemaakt, b.v. als het 't resultaat is van een aantal experimenten. Aangezien het een investering is, zou je het moeten beschermen en stappen moeten ondernemen om te voorkomen dat je het verliest. Er zijn in 't beginsel vier redenen waarom je gegevens zou kunnen verliezen: hardware gebreken, software bugs, menselijke actie, of natuurrampen. De vijfde reden is ``iets anders''. Alhoewel moderne hardware ernaar streeft zeer betrouwbaar te zijn, kan het nog steeds schijnbaar spontaan defect raken. Het meest kritieke stukje hardware voor het opslaan van gegevens is de harddisk, wat aan moet kunnen op intact blijvende kleine magnetische velden in een wereld vol met electromagnetische ruis. Moderne software streeft er zelfs niet naar betrouwbaar te zijn; een door en door solide programma is een uitzondering, geen regel. Mensen zijn zeer onbetrouwbaar, ze zullen óf een fout maken, óf ze zijn kwaadaardig en vernietigen met opzet gegevens. De natuur hoeft niet slecht te zijn, maar het kan zich wreken zelfs als het goed is. Alles samengenomen, is het een klein wonder dat er ook maar enigszins iets werkt. Een backup is een manier om de investering in gegevens te beschermen. Als je verscheidene kopieën van de gegevens hebt, doet het er niet zoveel toe als er één geruïneerd is (de kosten bestaan alleen hieruit dat de verloren gegane gegevens weer vanaf de backup teruggezet moeten worden). Het is belangrijk de backups goed te doen. Zoals al het andere dat gerelateerd is aan de fysieke wereld, zullen backups vroeg of laat mislukken. Een deel van het goed doen van de backups bestaat daaruit dat je er zeker van bent dat ze werken; je zal niet willen bemerken dat je backups niet goed zijn. Lach niet. Dit is verscheidene mensen overkomen. Toegebrachte schade door hoon nog verergeren, het kan zijn dat je een nare crash had net toen je de backup aan het maken was; als je slechts één backupmedium hebt, kan het bovendien ook geruïneerd zijn, je achterlatend met de smeulende as van het harde werk. Daar geweest, dat gedaan... Of je kan bemerken, dat je iets belangrijks vergat te backuppen, wanneer je het probeert terug te zetten, zoals de gebruikersdatabase op een site met 15000 gebruikers. In het beste geval, kan het zijn dat al je backups perfect werken, maar de laatst bekende tape drive die de soort tapes die je gebruikte kon lezen, was degene met nu een emmervol water erin. Kiezen van het backupmedium De belangrijkste beslissing betreffende backups is de keuze van het backupmedium. Je moet de kosten, betrouwbaarheid, snelheid, beschikbaarheid en bruikbaarheid overwegen. De kosten zijn belangrijk, aangezien je bijvoorkeur verscheidene keren meer backupopslag zou willen, dan wat je voor de data nodig hebt. Een goedkoop medium is meestal een verplichting. Betrouwbaarheid is uitermate belangrijk, aangezien een beschadigde backup een volwassen man aan het huilen kan maken. De gegevens moeten gedurende jaren zonder beschadigingen op een backup medium bewaard blijven. De wijze waarop je het medium gebruikt, is van invloed op de betrouwbaarheid van het backup medium. Een harddisk heeft als kenmerk dat het zeer betrouwbaar is, maar het is als een backup medium niet erg betrouwbaar, als het zich op dezelfde computer bevindt, als die waarop je de backup aan het maken bent. Snelheid is meestal niet zo belangrijk, als de backups zonder interactie kunnen worden gemaakt. Het doet er niet zoveel toe of een backup twee uur duurt, zolang er geen supervisie voor nodig is. Aan de andere kant doet de snelheid er wel toe, als de computer niet kan worden gebruikt ten tijde dat de backup wordt gemaakt. Beschikbaarheid is uiteraard noodzakelijk, aangezien je geen backupmedium kunt gebruiken als het er niet is. Het is minder vanzelfsprekend dat het medium zelfs in de toekomst beschikbaar moet zijn, en op andere computers dan die van jezelf. Anders heb je niet de mogelijkheid om je backups na een calamiteit terug te zetten. Bruikbaarheid speelt een grote factor in hoevaak backups worden gemaakt. Hoe eenvoudiger het is om backups te maken, hoe beter. Een backup medium mag niet moeilijk of vervelend in het gebruik zijn. De typische alternatieven zijn diskettes en tapes. Diskettes zijn goedkoop, tamelijk betrouwbaar, niet erg snel, ruim beschikbaar, maar voor grote hoeveelheden gegevens niet bruikbaar. Tapes zijn goedkoop tot wat duur, tamelijk betrouwbaar, tamelijk snel, ruim beschikbaar, en, afhankelijk van de grootte van de tape, zeer comfortabel. Er zijn andere alternatieven. Ze zijn meestal niet zo erg goed beschikbaar, maar dat is geen probleem, aangezien ze op andere vlakken beter kunnen zijn. Magneto-optische disks bijvoorbeeld, kunnen zowel de goede kanten van diskettes hebben (ze zijn willekeurig toegankelijk, wat het herstellen van een enkel bestand snel maakt) als van tapes (bevatten veel gegevens). Uitkiezen van een backup tool Er zijn veel tools die voor het maken van backups kunnen worden gebruikt. De traditionele UNIX-tools die voor backups worden gebruikt, zijn tar, cpio, en dump. Bovendien zijn er een groot aantal packages van derden (zowel freeware als commercieel) die gebruikt kunnen worden. De keuze van een backupmedium kan de keuze van de tool beïnvloeden. tar en cpio zijn vergelijkbaar, en gezien vanuit het oogpunt van een backup equivalent. Beiden zijn in staat om bestanden op tapes op te slaan, en de bestanden er vanaf te halen. Beiden zijn capabel om bijna elke media te gebruiken, aangezien de devicedrivers van de kernel zorg dragen voor de afhandeling van het low level device en de devices voor programma's op gebruikersniveau op elkaar lijken. Een aantal UNIX-versies van tar en cpio kunnen problemen hebben met ongebruikelijke bestanden (symbolische links, devicebestanden, bestanden met zeer lange padnamen, enzovoort), maar de Linux-versies zouden alle bestanden op de juiste wijze af moeten handelen. dump is anders in dat dit het bestandssysteem direct inleest en niet via het bestandssysteem. Bovendien is het speciaal voor backups geschreven; tar en cpio zijn eigenlijk bedoeld voor het archiveren van bestanden, alhoewel ze ook voor backups gebruikt kunnen worden. Het direct inlezen van bestandssystemen heeft een aantal voordelen. Het maakt het mogelijk om een backup te maken van de bestanden zonder dat dit effect heeft op de tijdregistratie van de bestanden; voor tar en cpio, zou je het bestandssysteem eerst read-only moeten mounten. Het direct inlezen van het bestandssysteem is ook effectiever, als van alle gegevens een backup moet worden gemaakt, aangezien dit met veel minder beweging van de diskkop kan worden gedaan. Het belangrijkste nadeel is dat dit het backupprogramma specifiek maakt voor één type bestandssysteem; het Linux dump programma begrijpt slechts het ext2 bestandssysteem. dump ondersteunt ook direct backuplevels (die we hieronder zullen bespreken); met tar en cpio moet dit met andere tools worden geïmplementeerd. Een vergelijking van de backuptools van derden valt buiten het kader van dit boek. In de Linux Software Map staan er een heleboel uit het freeware circuit. Eenvoudige backups Een eenvoudig backupschema bestaat hieruit om van alles éénmaal een backup te maken, en vervolgens van alles dat is gewijzigd sinds de vorige backup een backup te maken. De eerste backup wordt een volledige backup genoemd, de daaropvolgende backups incrementele backups. Een volledige backup is vaak wat bewerkelijker dan incrementele backups, aangezien er meer gegevens naar de tape moeten worden geschreven en de volledige backup mogelijk niet op één tape (of diskette) past. Herstellen van incrementele backups kan heel wat meer werk inhouden dan vanaf een volledige backup. Het terugzetten kan zodanig worden geoptimaliseerd dat je altijd van alles een backup maakt, sinds de vorige volledige backup; op deze manier, kost het maken van een backup wat meer werk, maar er zou nooit meer dan een volledige backup en een incrementele backup hoeven te worden hersteld. Als je iedere dag backups wilt maken en je hebt zes tapes, zou je tape 1 voor de eerste volledige backup kunnen gebruiken (laten we zeggen op vrijdag), en tapes 2 tot en met 5 voor de incrementele backups (maandag tot en met donderdag). Vervolgens maak je op tape 6 een nieuwe volledige backup (tweede vrijdag), en begint weer opnieuw met het maken van de incrementele backups met tapes 2 tot en met 5. Je zal tape 1 niet willen overschrijven totdat je een nieuwe volledige backup hebt, voor het geval er iets gebeurt terwijl je de volledige backup aan het maken bent. Nadat je een volledige backup op tape 6 hebt gemaakt, wil je tape 1 ergens anders bewaren, zodat wanneer je andere backup tapes door brand worden verwoest, nog steeds iets over hebt. Wanneer je de volgende volledige backup moet maken, pak je tape 1 en leg je tape 6 daarvoor in de plaats. Als je meer dan zes tapes hebt, kun je de extra tapes voor volledige backups gebruiken. Iedere keer dat je een volledige backup maakt, gebruik je de oudste tape. Op deze manier heb je de beschikking over volledige backups van verscheidene voorgaande weken, wat goed is als je een inmiddels oud verwijderd bestand, of een oude versie van een bestand op wilt zoeken. Backups maken met <command>tar</command> Een volledige backup kan makkelijk worden gemaakt met tar: # tar --create --file /dev/ftape /usr/src tar: Removing leading / from absolute path names in the archive # Het voorbeeld hierboven maakt gebruik van de GNU versie van tar met de lange namen optie. De traditionele versie van tar begrijpt alleen de enkelvoudige karakteropties. De GNU versie kan ook backups afhandelen die niet op één tape of diskette passen, en ook met zeer lange padnamen omgaan; niet alle traditionele versies kunnen dit. (Linux maakt alleen gebruik van GNU tar.) Als je backup niet op één tape past, moet je de optie () gebruiken: # tar -cMf /dev/fd0H1440 /usr/src tar: Removing leading / from absolute path names in the archive Prepare volume #2 for /dev/fd0H1440 and hit return: # Merk op dat je de diskettes voordat je aan de backup begint, zou moeten formatteren of anders een ander venster of virtuele terminal daarvoor gebruikt, wanneer tar om een nieuwe diskette vraagt. Nadat je een backup hebt gemaakt, zou je het moeten controleren om er zeker van te zijn dat het OK is, dit kan met de optie (): # tar --compare --verbose -f /dev/ftape usr/src/ usr/src/linux usr/src/linux-1.2.10-includes/ .... # Als je het nalaat een backup te controleren, zal je het niet opmerken als je backups niet werken, totdat je de originele gegevens kwijtraakt. Een incrementele backup kan worden gemaakt met tar met de optie () : # tar --create --newer '8 Sep 1995' --file /dev/ftape /usr/src --verbose tar: Removing leading / from absolute path names in the archive usr/src/ usr/src/linux-1.2.10-includes/ usr/src/linux-1.2.10-includes/include/ usr/src/linux-1.2.10-includes/include/linux/ usr/src/linux-1.2.10-includes/include/linux/modules/ usr/src/linux-1.2.10-includes/include/asm-generic/ usr/src/linux-1.2.10-includes/include/asm-i386/ usr/src/linux-1.2.10-includes/include/asm-mips/ usr/src/linux-1.2.10-includes/include/asm-alpha/ usr/src/linux-1.2.10-includes/include/asm-m68k/ usr/src/linux-1.2.10-includes/include/asm-sparc/ usr/src/patch-1.2.11.gz # Helaas merkt tar er niets van als de inode informatie is gewijzigd, zoals bijvoorbeeld gewijzigde permissie bits of wanneer de naam ervan is gewijzigd. Dit kan worden opgelost door gebruik te maken van find en de huidige status van het bestandssysteem te vergelijken met lijsten van bestanden waarvan voorheen een backup werd gemaakt. Op Linux ftp-sites zijn hiervoor scripts en programma's te vinden. Terugzetten van bestanden met <command>tar</command> De () optie voor tar extraheert de bestanden: # tar --extract --same-permissions --verbose --file /dev/fd0H1440 usr/src/ usr/src/linux usr/src/linux-1.2.10-includes/ usr/src/linux-1.2.10-includes/include/ usr/src/linux-1.2.10-includes/include/linux/ usr/src/linux-1.2.10-includes/include/linux/hdreg.h usr/src/linux-1.2.10-includes/include/linux/kernel.h ... # Door de bestanden op de commandoregel te benoemen, extraheer je alleen de specifieke bestanden of directories (met alle daarin voorkomende bestanden en directories): # tar xpvf /dev/fd0H1440 usr/src/linux-1.2.10-includes/include/linux/hdreg.h usr/src/linux-1.2.10-includes/include/linux/hdreg.h # Gebruik de optie (), als je alleen wilt zien welke bestanden zich in een backup volume bevinden: # tar --list --file /dev/fd0H1440 usr/src/ usr/src/linux usr/src/linux-1.2.10-includes/ usr/src/linux-1.2.10-includes/include/ usr/src/linux-1.2.10-includes/include/linux/ usr/src/linux-1.2.10-includes/include/linux/hdreg.h usr/src/linux-1.2.10-includes/include/linux/kernel.h ... # Merk op dat tar het backup volume altijd sequentieel inleest, dus voor grote volumes is dit tamelijk traag. Het is echter niet mogelijk gebruik te maken van een willekeurige database-toegangstechniek bij het gebruik van een tape drive, of één of ander, ander sequentieel medium. tar hanteert verwijderde bestanden niet op de juiste wijze. Als je een bestandssysteem terug moet zetten vanaf een volledige en een incrementele backup, en je hebt tussen de twee backups door een bestand verwijderd, zal dit bestand na het terugzetten van de backup weer voorkomen. Dit kan een groot probleem opleveren, als er zich gevoelige gegevens in het bestand bevinden, die niet langer beschikbaar zou moeten zijn. Multilevel backups De eenvoudige backupmethode die in de vorige sectie werd geschetst, is voor persoonlijk gebruik of kleine sites vaak heel adequaat. Voor het wat zwaardere gebruik, zijn multi-level backups beter geschikt. De eenvoudige methode bestaat uit twee backuplevels: volledige en incrementele backups. Dit kan worden gegeneraliseerd tot ieder aantal levels. Een volledige backup zou level 0 zijn, en de verschillende levels, incrementele backups levels 1, 2, 3, enz. Bij ieder incrementeel backup level maak je een backup van al hetgeen dat sinds de vorige backup of een vorig level is gewijzigd. Het doel hiervan is dat het goedkoop een langere backup historie toestaat. In het voorbeeld van de vorige sectie ging de backup historie terug tot de vorige volledige backup. Dit zou met meer tapes kunnen worden uitgebreid, naar een nieuwe tape voor slechts één week, wat mogelijk weer te duur is. Een langere backup historie is nuttig, aangezien het vaak lang niet wordt opgemerkt als bestanden zijn verwijderd of beschadigd. Een versie van een bestand dat niet zo up to date is, is vaak nog beter dan helemaal geen bestand. Met meerdere levels kan de backup-historie goedkoper worden uitgebreid. Als we bijvoorbeeld tien tapes kopen, zouden we tape 1 en 2 voor maandelijkse backups kunnen gebruiken (eerste vrijdag van iedere maand), tape 3 tot 6 voor wekelijkse backups (de andere vrijdagen; merk op dat er vijf vrijdagen in één maand voor kunnen komen, dus we hebben er vier tapes voor nodig), en tape 7 tot 10 voor dagelijkse backups (maandag tot en met vrijdag). Met slechts vier tapes meer, kunnen we de backup historie van twee weken (nadat alle dagelijkse tapes zijn gebruikt) uitbreiden naar twee maanden. Het is waar dat we niet iedere versie van ieder bestand gedurende die twee maanden terug kunnen halen, maar wat we wel kunnen herstellen, is vaak goed genoeg. toont welk backup level iedere dag wordt gebruikt, en welke backups vanaf het einde van de maand kunnen worden teruggezet.
Een voorbeeld multi-level backupschema.
Backuplevels kunnen ook worden gebruikt om het herstellen van een bestandssysteem tot een minimum te beperken. Als je veel incrementele backups hebt met monotoon verhogende levelnummers, moet je ze allen herstellen, als je het gehele bestandssysteem opnieuw op moet bouwen. In plaats daarvan kun je levelnummers gebruiken, die niet monotoon zijn, en het aantal backups laag houden dat je terug moet zetten. Om het aantal tapes welke nodig zijn voor herstel, te minimaliseren, zou je een kleiner level voor iedere incrementele tape kunnen gebruiken. Echter dan vermindert de tijd om de backup te maken (iedere backup kopieert alles sinds de vorige volledige backup). Een beter schema wordt aangegeven in de dump manual page en beschreven door de tabel XX (efficient-backup-levels). Gebruik de volgende opeenvolging van backuplevels: 3, 2, 5, 4, 7, 6, 9, 8, 9, enz. Dit houdt zowel de backup als de hersteltijd laag. Op z'n hoogst moet je een backup maken van wat twee dagen werk waard is. Het aantal tapes voor een restore hangt af van hoeveel tijd je tussen volledige backups houdt, maar het is minder dan in de eenvoudige schema's. Efficiënt backupschema met meerdere backuplevels Tape Niveau Backup (dagen) Restore tapes1 0 n/a 12 3 1 1, 23 2 2 1, 34 5 1 1, 2, 45 4 2 1, 2, 56 7 1 1, 2, 5, 67 6 2 1, 2, 5, 78 9 1 1, 2, 5, 7, 89 8 2 1, 2, 5, 7, 910 9 1 1, 2, 5, 7, 9, 1011 9 1 1, 2, 5, 7, 9, 10, 11... 9 1 1, 2, 5, 7, 9, 10, 11, ...
Een willekeurig schema kan de benodigde hoeveelheid werk verminderen, maar het betekent wel dat er meer dingen moeten worden bijgehouden. Je moet beslissen of dat 't waard is. dump heeft ingebouwde support voor backup levels. Bij tar en cpio moet het met shell-scripts worden geïmplementeerd. Waarvan maak je een backup Je wilt van zoveel mogelijk een backup maken. De belangrijke uitzondering is software die gemakkelijk opnieuw kan worden geïnstalleerd, Je zal moeten beslissen wat het eenvoudigst is. Een aantal mensen vinden het installeren vanaf een aantal dozijn diskettes makkelijk. maar zelfs daarvan kunnen configuratiebestanden voorkomen waarvan het belangrijk is dat er een backup van wordt gemaakt, op z'n minst moet je al het werk opnieuw doen om ze helemaal opnieuw te configureren. Een andere belangrijke uitzondering is het /proc bestandssysteem; aangezien dat het enige is dat gegevens bevat dat altijd automatisch door de kernel wordt gegenereerd, is het geen goed idee er een backup van te maken. Vooral het bestand /proc/kcore is onnodig, aangezien het slechts een image is van je huidige fysieke geheugen; het is bovendien tamelijk groot. Grijze gebieden bestaan uit de news spool, logbestanden, en vele andere zaken in /var. Je moet in overweging nemen wat je belangrijk vindt. Waar je uiteraard een backup van zal maken, zijn de gebruikersbestanden in (/home) en systeem-configuratiebestanden in (/etc, maar mogelijk ook andere zaken die over het bestandssysteem zijn verspreid). Gecomprimeerde backups Backups nemen een hoop ruimte in, wat heel veel geld kan kosten. Om de benodigde ruimte te verminderen, kunnen de backups worden gecomprimeerd. Er zijn verscheidene manieren om dit te doen. Een aantal programma's hebben ondersteuning voor compressie ingebouwd: bijvoorbeeld de () optie voor GNU tar stuurt de gehele backup door naar het gzip compressieprogramma, voordat het 't naar het backupmedium schrijft. Helaas kunnen gecomprimeerde backups moeilijkheden veroorzaken. Als er een enkele bit onjuist is, zullen, vanwege de wijze waarop compressie werkt, de rest van de gecomprimeerde gegevens onbruikbaar zijn. Een aantal backupprogramma's hebben wat ingebouwde foutdetectie, maar geen enkele methode kan een groot aantal fouten hanteren. Dit betekent dat de wijze waarop GNU tar de backup comprimeert, waarbij de gehele uitvoer als een eenheid wordt gecomprimeerd, bij een enkele fout de rest van de backup verloren gaat. Backups moeten betrouwbaar zijn en deze compressie-methode is dus niet zo verstandig. Een alternatieve manier is, ieder bestand apart te comprimeren. Dit betekent nog steeds dat dat ene bestand verloren gaat, maar dat kan dan geen kwaad voor alle andere bestanden. Het verloren gegane bestand zou hoe dan ook toch beschadigd zijn geweest, dus deze situatie is niet veel erger dan helemaal geen compressie gebruiken. Het programma afio (een variant op cpio) kan dit. Compressie duurt even, en het kan gebeuren dat het backupprogramma daardoor voor een tape drive niet snel genoeg is om de gegevens weg te schrijven. Als een tape drive de gegevens niet snel genoeg krijgt, moet het stoppen; dit maakt backups zelfs langzamer, en het kan slecht zijn voor zowel de tape als de drive. Dit kan worden voorkomen door de uitvoer te bufferen (of intern, als het backupprogramma slim genoeg is, of door gebruik te maken van een ander programma), maar het kan zijn dat zelfs dat niet goed genoeg werkt. Dit zou alleen een probleem moeten zijn met langzame computers. Bijhouden van de Tijd
Time is an illusion. Lunchtime double so. (Douglas Adams.)
Dit hoofdstuk legt uit hoe het systeem de tijd bijhoudt, en wat je moet doen om moeilijkheden te voorkomen. Meestal hoef je niets aan de tijdsinstelling te doen, maar het is in ieder geval goed om het te begrijpen. Tijdzones Tijdsmeting is voornamelijk gebaseerd op natuurlijke verschijnselen, zoals het aanpassen van de lichte en donkere perioden die door de rotatie van de planeet worden veroorzaakt. De totale tijd van twee opeenvolgende perioden is constant, maar de lengte van de lichte en donkere perioden varieert. Een eenvoudige constante is 12 uur 's-middags. 's-Middags 12 uur is de tijd van de dag dat de zon op zijn hoogtepunt is. Aangezien de aarde rond is, Volgens recent onderzoek. is het op verschillende plaatsen op verschillende tijden 12 uur 's-middags. Dit leidt tot het concept lokale tijd. Mensen meten de tijd in vele eenheden, de meeste daarvan zijn verbonden met natuurlijke verschijnselen zoals 12 uur 's-middags. Zolang je in dezelfde plaats blijft, doet het er niet toe dat de lokale tijden verschillen. Zodra je met plaatsen moet gaan communiceren die zich op afstand van elkaar bevinden, zul je de noodzaak voor een algemene tijd bemerken. In moderne tijden, communiceren de meeste plaatsen in de wereld met de meeste andere plaatsen in de wereld, dus er is een globale standaard voor het meten van de tijd gedefinieerd. Deze tijd wordt universele tijd genoemd (UT of UTC, voorheen bekend als Greenwich Mean Time of GMT, aangezien het de lokale tijd in Greenwich, Engeland was). Wanneer mensen met verschillende lokale tijden met elkaar moeten communiceren, kunnen zij de tijden in universele tijd uitdrukken, waardoor er geen verwarring ontstaat over wanneer er iets moet gebeuren. Iedere lokale tijd wordt een tijdzone genoemd. Ondanks dat de geografie het toe zou staan dat het op alle plaatsen met dezelfde tijdzone op dezelfde tijd `s-middags 12 uur is, maakt de politiek het moeilijk. Om diverse redenen maken veel landen gebruik van daylight savings time, dat wil zeggen dat ze de klokken verzetten voor meer natuurlijk licht als ze werken, en de klokken tijdens de winter weer terugzetten. Andere landen doen dit weer niet. De landen die dit wel doen, zijn het er niet mee eens wanneer de klokken zouden moeten worden verzet, en zij veranderen de regels van jaar tot jaar. Dit maakt tijdzone conversies beslist niet tot iets alledaags. Tijdzones kunnen het best worden benoemd naar de lokatie of door het verschil tussen de lokale en universele tijd aan te geven. In de US en een aantal andere landen, hebben de lokale tijdzones een naam en een afkorting bestaande uit drie letters. De afkortingen zijn echter niet uniek, en zouden niet moeten worden gebruikt, tenzij ook het land wordt genoemd. Je kunt het maar beter over de lokale tijd in, laten we zeggen, Helsinki hebben, dan over de East European time, aangezien niet alle landen in Oost-Europa dezelfde regels volgen. Linux heeft een tijdzone package dat bekend is met alle bestaande tijdzones, en dat makkelijk kan worden bijgewerkt als de regels veranderen. Het enige dat de systeembeheerder hoeft te doen is de geschikte tijdzone te selecteren. Bovendien kan iedere gebruiker zijn eigen tijdzone instellen; dit is belangrijk aangezien veel mensen met computers in verschillende landen via het Internet werken. Zorg ervoor dat je op z'n minst dat deel van je Linux-systeem bijwerkt, als de regels voor `daylight savings time' in je lokale tijdzone wijzigen. Meer dan het instellen van de tijdzone op je systeem en het bijwerken van de gegevensbestanden met de tijdzones, is er geen noodzaak om je bezig te houden met de tijd. De hardware- en software-klok Een personal computer heeft een batterij gestuurde hardware-klok. De batterij zorgt ervoor dat de klok zelfs blijft functioneren ook als de rest van de computer zonder elektriciteit zit. De hardware-klok kan vanuit het setupscherm van de BIOS, of vanuit wat voor besturingssysteem je ook draait, worden ingesteld. De Linux-kernel houdt onafhankelijk van de hardware-klok de tijd bij. Tijdens het booten, stelt Linux een eigen klok in, op dezelfde tijd als de hardware-klok. Hierna lopen beide klokken onafhankelijk van elkaar. Linux beheert zijn eigen klok omdat het kijken naar de hardware langzaam en gecompliceerd is. De kernel-klok toont altijd de universele tijd. Op deze manier hoeft de kernel niks te weten over tijdzones. De eenvoud resulteert in een betere betrouwbaarheid en maakt het eenvoudiger om de tijdzone informatie bij te werken. Ieder proces handelt zelf de tijdzone conversie af. (door gebruik te maken van de standaardtools die deel uitmaken van het tijdzone package). De hardware-klok kan op lokale tijd of in de universele tijd zijn ingesteld. Het is gewoonlijk beter als het op universele tijd is ingesteld, omdat je de hardware-klok dan niet hoeft aan te passen, wanneer de `daylight savings time' begint of eindigt (UTC heeft geen DST). Helaas gaan een aantal besturingssystemen voor de PC, waaronder MS-DOS, Windows, en OS/2, er vanuit, dat de hardware-klok de lokale tijd toont. Linux kan beiden, maar als de hardware-klok de lokale tijd toont, dan moet het worden aangepast, als de `daylight savings time' begint of eindigt (anders zou het de lokale tijd niet tonen). Tonen en instellen van de tijd Onder het Debian systeem, wordt de tijdzone van het systeem vastgesteld door de symbolische link /etc/localtime. Deze link verwijst naar een tijdzone gegevensbestand die de lokale tijdzone beschrijft. De tijdzone gegevensbestanden zijn in /usr/lib/zoneinfo opgeslagen. Het kan zijn dat andere Linux-distributies dit anders doen. Een gebruiker kan zijn privé tijdzone wijzigen door het instellen van de omgevingsvariabele TZ. Als het niet is ingesteld, wordt uitgegaan van de tijdzone van het systeem. De syntax van de TZ variabele wordt in de manual page van tzset beschreven. Het date commando toont de huidige datum en tijd. Denk erom dat het commando time niet de huidige tijd toont. Bijvoorbeeld: $ date Sun Jul 14 21:53:41 EET DST 1996 $ Dat is op een Zondag, 14 juli 1996, om ongeveer tien voor tien in de morgen, in de tijdzone genaamd ``EET DST'' (wat de East European Daylight Savings Time kan zijn). date kan ook de universele tijd laten zien: $ date -u Sun Jul 14 18:53:42 UTC 1996 Sun Jul 14 18:53:42 UTC 1996 $ date wordt ook gebruikt om de software klok van de kernel in te stellen: # date 07142157 Sun Jul 14 21:57:00 EET DST 1996 # date Sun Jul 14 21:57:02 EET DST 1996 # Zie de date manual page voor meer details; de syntax is een beetje geheimzinnig. Alleen root kan de tijd instellen. Terwijl iedere gebruiker zijn eigen tijdzone kan hebben ingesteld, is de klok voor iedereen gelijk. date toont of stelt alleen de software klok in. De clock commando's synchroniseren de hardware- en software klokken. Het wordt gebruikt wanneer het systeem boot, om de hardware-klok uit te lezen en de software-klok in te stellen. Als je beiden klokken in moet stellen, stel je eerst de software-klok in met date, en vervolgens de hardware-klok met clock -w. De optie van clock geeft aan dat de hardware klok in de universele tijd staat. Je moet de optie correct gebruiken. Als je dit niet doet, zal je computer nogal van slag raken over wat de tijd is. De klokken zouden met zorg moeten worden gewijzigd. Veel onderdelen van een Unix-systeem vereisen dat de klokken juist functioneren. De cron daemon bijvoorbeeld, start periodiek commando's op. Als je de klok wijzigt, kan het verwarrend zijn, of het nu wel of niet de commando's moet draaien. Op een eerder Unix-systeem, stelde iemand de klok in op twintig jaar in de toekomst, en cron wilde alle periodieke commando's in die periode van twintig jaar allemaal tegelijkertijd uitvoeren. Huidige versies van cron kunnen dit correct afhandelen, maar je zou nog steeds op moeten passen. Grote sprongen voor- of achterwaarts zijn gevaarlijker dan kleinere sprongen. Wanneer de klok niet goed staat De Linux software-klok is niet altijd accuraat. Het blijft lopen door een periodieke timer interrupt die door hardware in de PC wordt gegenereerd. Als het systeem teveel processen heeft draaien, kan het te lang duren de timer interrupt te dienen, en de software klok begint achter te lopen. De hardware klok draait onafhankelijk en is meestal accurater. Als je de computer vaak opstart (zoals met de meeste systemen welke geen server zijn), zal het de tijd meestal tamelijk accuraat bijhouden. Als je de hardware-klok aan moet passen, is het vaak het eenvoudigst het systeem opnieuw op te starten, naar het setup scherm van de BIOS te gaan, en het van daaruit te doen. Dit voorkomt alle moeilijkheden die het wijzigen van de systeemtijd kan veroorzaken. Als het geen optie is, om het vanuit de BIOS te regelen, stel de nieuwe tijd dan in met date en clock (in die volgorde), maar wees erop voorbereid dat je het systeem opnieuw op moet starten, als één of ander deel van het systeem zich vreemd begint te gedragen. Een netwerkcomputer (zelfs als 't slechts via het modem is) kan zijn eigen klok automatisch controleren, door het te vergelijken met de tijd van een andere computer. Als van de andere computer bekend is dat het de tijd zeer accuraat bijhoudt, dan zullen beide computers de tijd accuraat bijhouden. Dit kan worden bewerkstelligd door de commando's rdate en netdate te gebruiken. Beiden controleren de tijd van een remote computer. (netdate kan verscheidene remote computers hanteren), en stellen de tijd op de lokale computer op die tijd in. Door deze commando's regelmatig op te starten, zal je computer de tijd even accuraat bijhouden als de remote computer. XXX zeg iets intelligents over NTP Woordenlijst (DRAFT)
The Librarian of the Unseen University had unilaterally decided to aid comprehension by producing an Orang-utan/Human Dictionary. He'd been working on it for three months. It wasn't easy. He'd got as far as `Oook.' (Terry Pratchett, ``Men At Arms'')
Dit is een beknopte lijst met woorden en definities van concepten gerelateerd aan Linux en systeembeheer. ambition De handeling waarbij grappige zinnen worden geschreven in de hoop dat ze in het Linux cookie bestand terechtkomen. applicatieprogramma Software dat iets nuttigs doet. Het resultaat van het gebruik van een applicatieprogramma is waarvoor de computer werd gekocht. Zie ook systeemprogramma, besturingssysteem. daemon Een proces dat in de achtergrond latent aanwezig is, wordt meestal niet opgemerkt, totdat er iets gebeurt waardoor het in actie komt. Bijvoorbeeld: de daemon update wordt iedere dertig seconden of zo actief om de inhoud van de buffer cache naar disk te schrijven, en de daemon sendmail wordt actief als iemand mail verstuurt. bestandssysteem De methoden en gegevensstructuren die een besturingssysteem gebruikt om bestanden op een disk of partitie bij te houden; de manier waarop de bestanden op de disk worden georganiseerd. Wordt ook gebruikt voor een partitie of disk die wordt gebruikt om de bestanden of het type bestandssysteem op te slaan. woordenlijst Een lijst met woorden en uitleg over de opgenomen woorden. Niet te verwarren met een woordenboek, welke ook bestaat uit een lijst met woorden met de daarbij behorende uitleg. kernel Deel van het besturingssysteem dat de interactie tussen hardware en het delen van bronnen implementeert. Zie ook systeemprogramma. besturingssysteem Software die de systeembronnen (de processor, het geheugen, de diskruimte, netwerkbandbreedte, enzovoort) op een computer deelt tussen gebruikers en de applicatieprogramma's die ze uitvoeren. Beheert toegang tot het systeem om te voorzien in beveiliging. Zie ook kernel, systeemprogramma, applicatieprogramma. system call De services die door de kernel aan applicatieprogramma's worden geleverd en de manier waarop ze worden aangeroepen. Zie sectie 2 van de manual pages. systeemprogramma Programma's die op hoog niveau functionaliteit van een besturingssysteem implementeren, d.w.z. zaken die niet direct afhankelijk zijn van de hardware. Dit kan soms speciale privileges vereisen om ze op te starten (b.v. voor het ontvangen van elektronische mail), maar worden vaak gewoon als een deel van het systeem gezien (b.v. een compiler). Zie ook applicatieprogramma, kernel, besturingssysteem.