Idiote gebruiksmogelijkheden voor Raid, /dev/ram, en ramfs

ArticleCategory:

Kernel Corner

AuthorImage:

[Mark Nielsen]

TranslationInfo:[Author and translation history]

original in en Mark Nielsen

en to nl Hendrik-Jan Heins

AboutTheAuthor:

Mark is een onafhankelijke consultant die tijd vrijmaakt voor zaken als GNUJobs.com, het schrijven van artikelen, het schrijven van gratis software, en hij werkt als vrijwilliger bij eastmont.net.

Abstract:

RamFs is een zeer eenvoudig bestandssysteem met enkele interessante mogelijkheden. Het is een van de nieuwe features van de 2.4 Kernel.

ArticleIllustration:[This is the title picture for your article]

[illustratie]

ArticleBody:

Introductie in RamDisk

Kijk hiervoor naar mijn originele artikel over de oude ramdisk. Ik zal in dit artikel niet de details van de oude ramdisk bespreken.

Wat is een RamDisk? Een RamDisk is een deel van het geheugen dat je voor gebruik als een partitie alloceert. Met andere woorden: je neemt een deel van je geheugen en doet alsof het een harde schijf is die je kan formatteren, mounten, bestanden naar weg kan schrijven enz.

Er zijn twee typen ramdisks waar we over zullen praten. De eerste is een ramdisk die je kunt formatteren en mounten. De tweede is een ramdisk die je niet kunt formatteren, maar deze heeft enkele andere leuke features. Hier is een uitleg:

De oude /dev/ram1 benadering:

  1. SLECHT: Het formaat van de ramdisk wordt bij het opstarten bepaald.
  2. GOED: Je kunt de ramdisk op iedere manier die je wilt formatteren.
  3. SLECHT: Zodra hij geformatteerd is (ik geloof dat je hem niet hoeft te mounten), neemt hij een deel van het geheugen in beslag en ik weet niet hoe je dat terug kunt krijgen.
  4. GOED: Je kunt meer dan 1 ramdisk tegelijkertijd draaien.
De nieuwe ramdisk "ramfs":
  1. SLECHT: Ik kan hem niet anders formatteren dan waarop hij standaard is ingesteld. Hij zit op de VFS laag, wat dat dan ook mag zijn.
  2. GOED: Je kunt er meer dan 1 aanmaken.
  3. GOED: Je kunt de maximum grootte bijstellen met een commandoregel opdracht.
  4. ZEER GOED: Alleen de geheugenruimte die nodig is wordt ook daadwerkelijk gerbruikt. Met andere woorden: je kunt 64 MB RAM toewijzen, maar als er slechts 2k an bestanden in staat, zal er niet meer dan 2k aan geheugen gebruikt worden. Zodra je een bestand vewijdert, heb je onmiddelijk meer geheugen tot je beschikking voor andere taken op je pc.
  5. SLECHT: Ach, hier kan het programma eigenlijk niets aan doen. Trap niet in de val van het vullen van twee ramfs ramdisks tegelijkertijd, dan houd je namelijk geen geheugen meer over. Meer hierover verderop.

Hoe gebruik je RamDisk "oude stijl"

Lees hiervoor het eerder vermelde artikel Gebruik van een Ramdisk onder Linux.

Typ om ramdisks van het type van kernel 2.0/2.2 te gebruiken de volgende drie commando's (als root):

mkfs -t ext2 /dev/ram1
mkdir -p /RAM1
mount /dev/ram1 /RAM1
En klaar is de ramdisk. Op de meeste systemen is de maximum grootte beperkt tot 4 meg. Dit kan veranderd worden bij het booten of door de kernel opnieuw te compileren, maar zie ook daarvoor mijn oude artikel. Je kunt er op de volgende manier ook meerdere aanmaken:
mkfs -t ext2 /dev/ram2
mkdir -p /RAM2
mount /dev/ram2 /RAM2

Hoe RamDisk te gebruiken met ramfs voor kernel 2.4

Ik ga er allereerst van uit dat je kernel 2.4 hebt met ramfs meegecompileerd. De meeste grotere distributies die gebruik maken van de nieuwe 2.4 kernel hebben ramfs meegecompileerd. Voor dit artikel heb ik gebruik gemaakt van RedHat 7.1.

Het gebruik is heel eenvoudig. Maak een directory en mount ramfs daarop.

mkdir -p /RAM1
mount -t ramfs none /RAM1
Als je er nog een nodig hebt, is dat heel eenvoudig. Maak nog een directory aan en mount ramfs daarop.
mkdir -p /RAM2
mount -t ramfs none /RAM2

Het veranderen van de grootte van de ramdisks en andere opties

Hier is een voorbeeld om te illustreren hoe je een 10 meg ramdisk maakt.

mkdir -p /RAM1
mount -t ramfs none /RAM1 -o maxsize=10000
Het volgende komt letterlijk uit: http://www.linuxhq.com/kernel/v2.4/patch/patch-2.4.3-ac2/linux.ac_Documentation_filesystems_ramfs.txt.html
+       ramfs - An automatically resizing memory based filesystem
+
+
+  Ramfs is a file system which keeps all files in RAM. It allows read
+  and write access. In contrast to RAM disks, which get allocated a
+  fixed amount of RAM, ramfs grows and shrinks to accommodate the
+  files it contains.
+
+  You can mount the ramfs with:
+      mount -t ramfs none /mnt/wherever
+
+  Then just create and use files. When the filesystem is unmounted, all
+  its contents are lost.
+
+  NOTE! This filesystem is probably most useful not as a real
+  filesystem, but as an example of how virtual filesystems can be
+  written.
+
+Resource limits:
+
+By default a ramfs will be limited to using half of (physical) memory
+for storing file contents, a bit over that when the metadata is
+included. The resource usage limits of ramfs can be controlled with
+the following mount options:
+
+       maxsize=NNN
+               Sets the maximum allowed memory usage of the
+filesystem to NNN kilobytes. This will be rounded down to a multiple
+of the page size. The default is half of physical memory. NB.  unlike
+most of the other limits, setting this to zero does *not* mean no
+limit, but will actually limit the size of the filesystem data to zero
+pages. There might be a use for this in some perverse situation.
+
+       maxfilesize=NNN
+               Sets the maximum size of a single file on the
+filesystem to NNN kilobytes. This will be rounded down to a multiple
+of the page size. If NNN=0 there is no limit. The default is no limit.
+
+       maxdentries=NNN
+               Sets the maximum number of directory entries (hard
+links) on the filesystem to NNN. If NNN=0 there is no limit. By
+default this is set to maxsize/4.
+
+       maxinodes=NNN
+               Sets the maximum number of inodes (i.e. distinct
+files) on the filesystem to NNN. If NNN=0 there is no limit. The
+default is no limit (but there can never be more inodes than dentries).

Het draaien van services op een RamDisk

Ik heb een idee, dus let goed op: zou het niet heel erg gaaf zijn als je je services (zoals een web server, database server, of een DNS server) op een ramdisk kon draaien? Normaal gesproken bevat de standaard webserver niet al te veel heel grote bestanden. En een DNS server bestaat normaal gesproken ook niet uit al te veel bestanden. Je zou zelfs een database server in het geheugen kunnen draaien als die enkel tijdelijke data moet opslaan.

Ram is op dit moment vrij goedkoop. Ik heb net 128 meg ram voor $120 gekocht, en ik ga er vanuit dat de prijs nog verder zal dalen. En 128 meg ram is al meer dan voldoende om mijn webserver in te draaien. Als mijn webserver ook een paar grote bestanden bevat, kan ik httpd.conf zo instellen dat hij in een andere directory, niet op de ramdisk, naar deze bestanden zoekt. Mijn DNS server is zeer klein. Mijn grootste database server is slechts 28 meg. En uitgaande van het feit dat je op dit moment relatief goedkoop computers kunt kopen met 1 gig aan geheugen, denk ik dat het erg gaaf is om alles dat ik heb in het geheugen te draaien. Het enige probleem met de database server is dat je eerst al je gegevens moet wegschrijven naar een andere database server, anders kan je het kwijtraken. Dit is een traag proces, maar aangezien je meestal moet lezen en niet hoeft te schrijven, zou dit de snelheid van de database server een heel eind moeten kunnen vergroten. Misschien kunnen we een mirror van een harde schijf aanmaken.

Ik heb ook dit al uitgelegd in een ander artikel, dus lees daarover hier verder: http://www.gnujobs.com/mark/articles/Ramdisk.html#Example.
Vervang wel deze commando's :

        ### Make the ramdisk partitions
/sbin/mkfs -t ext2 /dev/ram0
/sbin/mkfs -t ext2 /dev/ram1
/sbin/mkfs -t ext2 /dev/ram2

        ### Mount the ramdisks to their appropriate places

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

door de volgende (verhoog het getal als je niet voldoende hebt aan 10 meg):
mount -t ramfs none /home/httpd/cgi-bin -o maxsize=10000
mount -t ramfs none /home/httpd/icons -o maxsize=10000
mount -t ramfs none /home/httpd/html -o maxsize=10000

Ramdisk en Raid

Waarom zou je een ramdisk en een harde schijf partitie willen combineren in een raid partitie? Ik heb geen idee! Maar misschien vind je er op termijn wel een functie voor. Intelligente besturingssystemen zitten zo in elkaar dat je er dingen mee kan doen waarvoor nog geen directe noodzaak is. En dat is een van de redenen dat commerciële besturingssystemen minder populair worden en vervangen worden door gratis software; de commerciële dingen zijn geschreven door idioten die alleen geinteresseerd zijn in geld en niet in technologie.

Er bestaan drie problemen bij het combineren van een ramdisk met een harde schijf partitie.

  1. Ik weet niet hoe dit werkt bij ramfs, maar ik kan het wel voor elkaar krijgen met /dev/ram. Misschien werkt het als je een harde schijf partitie kunt formatteren met het bestandssysteem dat ramfs gebruikt. Ik heb geen idee wat de VFS laag precies is, dus ik zal hier waarschijnlijk later nog eens naar moeten kijken.
  2. Als de gespiegelde raid echt parallel draait, dan helpt de extra snelheid die het geheugen aankan niet. Ik weet niet of het mogelijk is om een gespiegelde raid te maken die alleen leest van de ramdisk, want dan is het mogelijk om hier extra voordeel uit te halen.
  3. Je zult na een herstart de ramdisk opnieuw moeten aanleggen.
Om de raid te initialiseren, heb ik mijn /etc/raidtab als volgt bewerkt:
  raiddev /dev/md3
          raid-level      1
          nr-raid-disks   2
          nr-spare-disks  0
          chunk-size     4
          persistent-superblock 1
          device          /dev/hdb6
          raid-disk       1
          device          /dev/ram3
          raid-disk       0
Daarna heb ik
mkraid /dev/md3
mkfs -t ext2 /dev/md3
mkdir -p /RAID1
mount /dev/md3 /RAID1
...gedraaid.
Probleem: bij een herstart is de ramdisk weg. Dus, bij een herstart:
raidstart /dev/md3
raidhotadd /dev/md3 /dev/ram3
mount /dev/md3 /RAID1
Onthoud wel dat het nutteloos is om de harde schijf partitie groter dan 4 meg te maken als je de oude ramdisks niet groter hebt gemaakt dan 4 meg.

Het zou wel heel gaaf zijn om een gespiegelde raid met 3 partities te maken. 1 is de ramdisk, en de andere 2 zijn de harde schijf partities, hierdoor is het ook geen probleem om de ramdisk alleen om uit te lezen in te stellen. Ik weet niet of het mogelijk is om leesacties slechts te beperken tot 1 partitie in de raid, maar het zou wel heel leuk zijn als dat mogelijk was.


Opmerkingen

Dit is waarschijnlijk de belangrijkste sectie van het artikel. Ik ben gek op Linux, omdat je het jezelf er ook heel lastig mee kunt maken. Er is niets waar je zoveel van leert.
  1. Ramfs gebruikt standaard de helft van je fysieke geheugen (swap ruimte niet meegerekend). Dus, als je er twee van aanlegt, en deze 2 volledig vult, zal je computer vast komen te zitten door een geheugentekort, net als die van mij deed. Geef alstublief een maximaal te gebruiken hoeveelheid geheugen op voor de ramdisk.
  2. Ik denk dat ramfs een eigen type bestandssysteem is, en niet zoiets als ext2, dus verwacht niet dat je bestanden exact hetzelfde zijn of exact hetzelfde formaat hebben wanneer je ze kopieert van schijf naar ramfs en vice-versa (bijv. met behulp van rsync of tar). Je zult waarschijnlijk geen grote verschillen zien, maar aangezien ramfs geen ext2 is, kunnen de eigenschappen op enkele punten verschillen.
  3. Ik heb de documenten over ramfs in de kernel gelezen, en het lijkt er niet op dat ramfs bedoeld is voor uitgebreid gebruik, maar ik zou niet weten waarom niet. Het werkt zoals ik dat wil.
Ik ben nog niet klaar met ramdisk.
  1. Ik wil weten of ik een raid kan maken met ramfs en een harde schijf.
  2. Als ik het voor elkaar kan krijgen,wordt er in de raid slechts van een van de partities gelezen.
  3. Ik wil een service, zoals een webserver, op een ramdisk met raid zetten. De truc is hier de raid zo te gebruiken dat je de gegevens bij iedere verandering bewaard blijven. Dat is waarom de raid zo ontzettend belangrijk is voor me ---- Dan kan ik deze services veilig in het geheugen zetten, en alle snelheidsvoordelen van geheugen boven een harde schijf hebben, mits:
  4. Het configureren van een computer zodat hij opstart vanaf een cdrom, een service opstart en de veranderingen downloadt vanaf het netwerk. Een harde schijf is dan niet nodig. Dit zou wel gaaf zijn; zo zou je een webserver (of iets anders) kunnen draaien vanaf een computer met cdrom en geheugen, maar zonder harde schijf. Als je er voor 1 gig aan geheugen in kan stoppen, zou ik niet weten waarom je het systeem niet volledig vanaf een cdrom kunt draaien. Dit is, uit veilighidsoverwegingen, een goed idee. Je hoeft hem alleen maar op te starten, de veranderingen in te laden (veiligheids updates) van een beveiligde bron, de services te starten en je computer is lekker schoon en niet te hacken. De webserver zou nooit iets moeten bewaren op de lokale computer, maar het log en informatie op een andere pc via een beveiligde verbinding of via een intern netwerk moeten wegschrijven. Ik heb in het verleden al vaker opstartbare netwerk cdrom's met ramdisk gemaakt. Het zou leuk zijn om dit eerdere project te gebruiken om deze doelen te bereiken.

Bronnen

  1. kernel/v2.4/patch/patch-2.4.3-ac2/linux.ac_Documentation_filesystems_ramfs.txt.html
  2. http://genericbooks.com/LDP/HOWTO/Software-RAID-HOWTO.html
  3. Kleine databases versnellen (LinuxFocus)
  4. Gebruik van een RAMdisk onder Linux (LinuxFocus)
  5. Als dit artikel verandert, dan zal het hier beschikbaar zijn: http://www.gnujobs.com/Articles/21/Ramdisk2.html

Dank aan Katja voor de hulp!

Copyright � 4/2001 Mark Nielsen
Article Version 1.3 : Date Last Changed Sat May 19 06:04:06 2001