Gebruik van een Ramdisk onder Linux

ArticleCategory:

Applications

AuthorImage:

TranslationInfo:

AboutTheAuthor:

De schrijver (home page) werkt bij The Computer Underground, Inc. als archiefmedewerker en als professioneel consultant bij 800linux.com. In zijn vrije tijd doet hij vrijwilligerswerk, zoals het schrijven van dit artikel. Dit document werd gemaakt met behulp van Nedit en ispell.

Abstract:

Dit artikel laat zien hoe je RAM-geheugen als een virtuele harde schijf kan gebruiken.

ArticleIllustration:

ArticleBody:

Ramdisk introductie

Dit korte artikel behandelt het inrichten van een Ramdisk op een systeem van RedHat 6.0. Op andere systemen zou dit vrijwel hetzelfde moeten werken.

Wat is een Ramdisk? Een Ramdisk is een deel van het primaire geheugen, wat je gebruikt als een partitie (deel van een schijf). Met andere woorden: neem een deel van het geheugen, doe alsof het een disk is en schrijf er bestanden naar toe. Waarom een RAM disk? Welnu, als je weet dat er bestanden zijn die je véél gebruikt, dan zal het plaatsen van die bestanden in RAM (Random Access Memory of intern geheugen) een gunstige invloed hebben op de prestaties van het systeem, omdat geheugentoegang veel sneller is dan disktoegang. Dingen als webservers met veel data kunnen op die manier worden versneld. Of, als je een tik van de molen hebt en een PII 550 MHz met 1 Gb geheugen en ouwe 500 Mb harde schijf, dan kun je het geheugen gebruiken om alleen de capaciteit van je schijf te vergroten. Hoewel, als je een machine zonder al teveel schijfcapaciteit wilt gebruiken, dan is het misschien zo gek nog niet.

Hier wat aanwijzingen om je daarbij te helpen:

http://metalab.unc.edu/LDP/HOWTO/Kernel-HOWTO.html
http://metalab.unc.edu/LDP/HOWTO/mini/LILO.html
/usr/src/linux/Documentation/ramdisk.txt

Hoe een Ramdisk te gebruiken

Het is heel eenvoudig om een Ramdisk te gebruiken. Om te beginnen ondersteund de distributie van RedHat 6.0 een Ramdisk. Het enige wat nodig is, is het formatteren van de schijf en hem beschikbar maken onder een directory (mount). Om te ontdekken welke Ramdisks er zijn, moet je $ ls �al /dev/ram* uitvoeren. Dit laat je de beschikbare schijven zien, waaruit je kunt kiezen. Een dergelijke schijf gebruikt geen ruimte totdat je hem aanspreekt (zoals bij het formatteren). Hier een eenvoudig voorbeeld hoe de Ramdisk te gebruiken.

# maak een directory aan voor de schijf:
mkdir /tmp/ramdisk0
# maak het bestandssysteem aan:
mke2fs /dev/ram0
# maak de Ramdisk beschikbaar:
mount /dev/ram0 /tmp/ramdisk0

Deze drie commando's maken een directory aan voor de Ramdisk, formatteren de schijf (een bestandssysteem er op aanmaken) en maken hem beschikbaar onder de directory /tmp/ramdisk0. Je kunt nu de directory gebruiken als zijnde een partitie! Probeer maar en gebruik het als elke andere directory of partitie.
Als het formatteren van de schijf fout gaat, dan kan het zijn dat je geen ondersteuning in de kernel hiervoor hebt. De optie voor de kernel heet CONFIG_BLK_DEV_RAM.

De standaard grootte van de Ramdisk is 4 Mb=4096 blokken. De grootte van de schijf heb je kunnen zien tijdens het uitvoeren van mke2fs. Het commando $ mke2fs /dev/ram0 zou het volgende op moeten leveren:

mke2fs 1.14, 9-Jan-1999 for EXT2 FS 0.5b, 95/08/09
Linux ext2 filesystem format
Filesystem label=
1024 inodes, 4096 blocks
204 blocks (4.98%) 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
1024 inodes per group

Uitvoeren van het commando $ df �k /dev/ram0 geeft je de hoeveelheid die je daarvan werkelijk kan gebruiken (het bestandssysteem neemt ook wat ruimte in beslag):

>df -k /dev/ram0
Filesystem  1k-blocks  Used Available Use% Mounted on
/dev/ram0        3963    13      3746   0% /tmp/ramdisk0

Zitten er ook nadelen aan? Nou, als de computer herstart, ben je alles kwijt. Geen data neerzetten dus die ook niet ergens anders al staat. Als je veranderingen maakt in de directory die je wilt behouden dan moet je één of andere back-up zien te maken.

De Ramdisk vergroten of verkleinen

Om een Ramdisk te gebruiken heb je ondersteuning nodig vanuit de kernel of je moet het beschikbaar hebben als loadable module. De kernel configuratie optie heet CONFIG_BLK_DEV_RAM. Gecompileerd als loadable module heeft het voordeel dat je tijdens het laden kunt kiezen welke grootte de schijf moet hebben.

Ok, eerst via de moeilijke weg. Voeg de volgende regel toe aan het bestand lilo.conf:
Ramdisk_size=10000 (of Ramdisk=10000 voor oudere kernel versies)
Linux zal een 10 Mb Ramdisk aanmaken nadat je het lilo commando hebt gegeven en de machine vervolgens herstart. Hier een voorbeeld van mijn /etc/lilo.conf bestand.

boot=/dev/hda
map=/boot/map
install=/boot/boot.b
prompt
timeout=50
image=/boot/vmlinuz
	label=linux
	root=/dev/hda2
	read-only
	ramdisk_size=10000

In de praktijk heb ik 9 Mb ter beschikking, het bestandssysteem neemt ook wat ruimte.

Met Ramdisk ondersteuning gecompileerd als loadable module kan je tijdens het laden beslissen wat de grootte wordt. Dit kan door een regel op te geven in het bestand /etc/conf.modules:

options rd rd_size=10000

of als parameter van het commando insmod.

$ insmod rd rd_size=10000

Hier is een voorbeeld hoe de module te gebruiken:

Doe een umount van de Ramdisk die je in de vorige paragraaf beschikbaar hebt gemaakt; $ umount /tmp/ramdisk0
Maak de geladen module ongedaan (hij was in de vorige paragraaf automatisch geladen); $ rmmod rd
Laadt de Ramdisk module met een grootte van 20 Mb; $ insmod rd rd_size=20000
Maak het bestandssysteem aan; $ mke2fs /dev/ram0
Maak de Ramdisk beschikbaar; $ mount /dev/ram0 /tmp/ramdisk0

Voorbeeld gebruik Ramdisk voor een webserver

Ok, hier een voorbeeld hoe 3 Ramdisks te gebruiken voor een webserver. Laten we even aannemen dat je voor 99% zeker bent over het feit dat je standaard installatie van Apache voor RedHat 6.0 maximaal 9 Mb zal gebruiken voor zijn cgi- scripts, html en plaatjes. Dit is als volgt te installeren.
Voer ten eerste het commando uit om de originele document-directory van je webserver te verplaatsen. Maak verder de directories aan waarop je de Ramdisks beschikbaar kunt maken.

mv /home/httpd/ /home/httpd_real
mkdir /home/httpd
mkdir /home/httpd/cgi-bin
mkdir /home/httpd/html
mkdir /home/httpd/icons

Voeg dan de volgende commando's toe aan de startprocedure in /etc/rc.d/init.d/httpd.init (of dáár waar jouw httpd wordt gestart):


	### Maak de Ramdisk parities aan
/sbin/mkfs -t ext2 /dev/ram0
/sbin/mkfs -t ext2 /dev/ram1
/sbin/mkfs -t ext2 /dev/ram2

	### Maak ze beschikbaar op de juiste plaatsen

mount /dev/ram0 /home/httpd/cgi-bin
mount /dev/ram1 /home/httpd/icons
mount /dev/ram2 /home/httpd/html

	### Kopieer de originele directory naar de Ramdisk(data
  ### op Ramdisk verdwijnt na een herstart)
tar -C /home/httpd_real -c . | tar -C /home/httpd -x
  
  ### Nu kun je de webserver starten.

Toelichting

Onthoud vooral één ding; MAAK EEN BACKUP VAN JE DATA als je deze wijzigt en nog nodig hebt. Na een herstart van de computer ben je namelijk alles kwijt.
Hiervoor zou je een cron job kunnen gebruiken. Laat deze iedere 10 minuten controleren of er bestanden veranderd zijn en hiervoor een back-up uitvoeren. Een alternatief is om veranderingen in de originele directory door te voeren en deze vervolgens naar de schijf te kopiëren. Dit is een veel veiliger methode.
Een leuke toepassing is om een computer met 1 Gb geheugen uit te rusten met een 256 Mb schijf voor "/tmp". Wanneer je veel processen hebt die gebruik maken van /tmp dan kan dit de computer aardig versnellen. Tevens is alles weg uit /tmp als de computer herstart, wat een voordeel kan zijn.
Linux benut al het beschikbare geheugen dat niet in gebruik is door andere programma's voor algemene disk-cache, maar uit ervaring is gebleken dat een Ramdisk je toch nog meer versnelling oplevert.