Za��zen� ramdisk a loop

V nov�m j�d�e najdeme vylep�enou verzi ramdisku, tedy mo�nosti u�it� ��sti pam�ti jako velice rychl�ho diskov�ho prostoru, kter� lze p�ipojit (p�imontovat) k adres��ov�mu stromu, �i sp��e �ast�ji, tvo�� ko�enov� syst�m adres��ov�ho stromu na r�zn�ch disketov�ch instalac�; nap��klad instala�n�ch disket syst�mu �i opravn� diskety.

Zcela nov�m za��zen�m ve stabiln�m j�d�e je zp�tnovazebn� (loopback) za��zen� loop (resp. /dev/loopx; ). Pomoc� tohoto za��zen� lze pracovat z jak�mkoli souborem (v unixov�m smyslu slova) jako s diskov�m prostorem. Lze tedy vytvo�it �i editovat soubor obsahuj�c� obraz diskety, nap��klad, u�ivatel dosemu se m��e prob�rat obrazem bootovac� diskety tak, jako kdyby se prob�ral soubory p��mo na disket� sam�. Pomoc� tohoto za��zen� lze rovn� vytvo�it komprimovan� obraz ramdisku pro na�i ur�ovac� bootovac� disketu p��mo do souboru.

Ramdisk

V nov�m j�d�e je explicite imlementov�no 16 ramdisk�, lze jich ov�em nakonfigurovat a� 255. Pro toho, kdo hodl� u��vat v�ce ne� jeden ramdisk, je vhodn� krom� /dev/ramdisk a /dev/ram m�t mo�nost p��stupu i k dal��m ramdisk�m, je proto t�eba vytvo�it specieln� soubory /dev/ramn; . K tomu poslou�� jednoduch� script:

#!/bin/sh
#          Script na vytvo�en� spec. soubor� ramdisku

DISKS="1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16"

for disk in ${DISKS}
do
 echo " Vytv���m /dev/ram$disk"
 mknod /dev/ram$disk b 1 $disk
done
#           Konec scriptu

Velikost ramdisku je limitov�va pouze velikost� pam�ti.

Uve�me si nyn� nejednodu��� p��pad pr�ce z ramdiskem. Nabootovali jsme system z nov�m j�drem a chceme se pod�vat jak se ramdisk pou��v�, vytvo��me ramdisk o velikosti 2MB a vytvo��me na n�m filesyst�m EXT2 a p�imontujeme ho k adres��ov�mu stromu na m�sto /mnt.

1. Vy�i�t�n� a p�ipraven� prostoru ramdisku o velikosti 2MB (2048kB):
   dd if=/dev/zero of=/dev/ram1 bs=1k count=2048
   Napnili jsme za��zen� /dev/ram1 NULLami ze za��zen� /dev/zero, p�i�em� jsme pou��vali bloky o velikosti 1kByte a takov�ch blok� bylo lze napo��tati 2048.
2. Na vy�i�t�n�m prostoru vytvo��me filesyst�m:
   mke2fs -vm0 /dev/ram1 2048
   Vytvo�ili jsme filesyst�m EXT2 na prostoru ramdisku o velikosti 2048kB, p�i�m� jsme na programu cht�li aby byl upov�dan� (-v) a aby na nov�m filesyst�mu nerezervoval ��dn� m�sto pro superu�ivatele (-m0).
3. No a zb�v� ji� jen p�ipojit ramdisk k syst�mu soubor�:
   mount /dev/ram1 /mnt -t ext2
   P�ipojili jsme za��zen� /dev/ram1, je� obsahuje p�ipraven� filesyst�m EXT2 (-t ext2) k adres��ov�mu stromu v m�st� /mnt.

V�ce o ramdisku

Ramdisku jako ko�enov�ho diskov�ho prostoru m��eme pou��t tehdy, d�me-li n�jak�m zp�sobem bootovan�mu j�dru zpr�vu, �e m� hledat ramdisk a tak� kde ho m� hledat. Tyto �daje lze j�dru p�edat jako parametr, nap��klad pomoc� zav�d��e syst�mu LILO.

Pro bootovac� disketu je l�pe pou��t jin�ho zp�sobu. Na za��tku bootovac�ho obrazu j�dra je n�kolik byt�, kter� specifikuj� za��zen�, je� obsahuje ko�enov� filesyst�m, video m�d, parametry ramdisku a za��zen� ur�en� pro swap. K t�mto informac�m lze p�istupovat pomoc� rdev(8).

Pro n�s jsou d�le�it� parametry ramdisku. D��ve tato ��st bootovac�ho obrazu j�dra obsahovala velikost ramdisku, ta je nyn� explicitè nastavena na 4MB. Co dan� j�dra m� na tomto m�st� zaps�no zjist�te pomoc� p��kazu: rdev -r za��zen�, kde za��zen� je za��zen�, �i soubor obsahuj�c� bootovac� obraz j�dra.

Informace o ramdisku zab�r� dva byty.

Spodn�ch 11 bit� (bit 0--10) obsahuje offset ramdisku na dan�m za��zen� (v 1k bloc�ch), tj. offset do 2MB. Bit 14 indikuje, zda se bude p�i bootov�n� nahr�vat ramdisk a bit 15 indikuje, zda m� b�t ti�t�na v�zva na v�m�nu media p�ed po��tkem �ten� ramdisku. Bity 11--13 nejsou v sou�asn� dob� vyu�ity.

K �emu je to dobr�? Pomoc� takov�ho �e�en� m��eme p�esko�it nutnost dvou disket, bootovac� a t� s ko�enov�m filesyst�mem. Jeliko� kernel je komprimov�n zab�r� na bootovac� disket�, �ekn�me, do 400kB a zbyl�ch 1040kB je voln�ch, nevyu�it�ch. A toto voln� m�sto lze zaplnit zkomprimovan�m obrazem ramdisku.

Nech� m�me skompilovan� nov� kernel zImage a obraz ramdisku RAM.img.gz. K vytvo�en� jedn� bootovac� diskety syst�mu, kter� jako ko�enov�ho filesyst�mu u�ije ramdisku sta�� ud�lat toto:

1. Nahr�t obraz kernelu na disketu: dd if=zImage of=/dev/fd0 bs=1k
2. Nahr�t na tu samou disketu zkomrimovan� obraz ramdisku. P�i�em� v tomto p��pad� pou�ijeme offset 400kB, je� je tro�ku v�t�� ne� kernel, tak�e p��padn� nov�, lep��, v�t�� kernel budeme moci nahr�t na disketu stejnou disketu bez toho, �ebychom poru�ili obraz ramdisku. Tedy nahrajeme obraz ramdisku s offsetem 400k, st�le pou��v�me velikost bloku (bs) 1kB: dd if=RAM.img.gz of=/dev/fd0 bs=1k seek=400
3. Nyn� u� zb�v� jen nastavit p��znaky:
   1. �ekneme j�dru, kter� je na disket�, �e ko�enov� filesyst�m m� hledat na disket�: rdev /dev/fd0 /dev/fd0
   2. No a nyn� �ekneme j�dru, �e m� hledat ramdisk (14. bit) s offsetem 400k (bity 0--10) a �e m� vypsat v�zvu p�ed t�m, ne� za�ne ��st obraz ramdisku (15. bit). Tedy des�tkov� bude p��znak ramdisku a tento p��znak zap��eme na vymezen� m�sto j�dra rdev -r /dev/fd0 49552

Loop

Jak ji� bylo �e�eno, za��zen� loop umo��uje pracovat pouze s obsahem souboru tak, jako by to byl samostatn� diskov� prostor. Za��zen� loop umo��uje i zak�dov�n� takov�ho prostoru.

Nejprve si pou�it� za��zen� loop uk�ene na jednoduch�m p��klad�. Vytvo�me si op�t bin�rn� obraz ramdisku o velikosti 2MB, kter� pot� m��eme pou��t obdobn� jako obraz vytvo�en� pomoc� ramdisku.

1. Nejprve si vytvo�me soubor, kter� budeme plnit:
   dd if=/dev/zero of=RAMd.img bs=1k count=2048
2. Tento soubor p�ipojme k jednomu ze za��zen� loop nap��klad k /dev/loop0, k tomu slou�� p��kaz losetup(8):
   losetup /dev/loop0 RAMd.img
3. Te� na za��zen�, pota�mo v souboru RAMd.img vytvo��me filesyst�m EXT2:
   mke2fs /dev/loop0 2048
4. A ji� n�m nic nebr�n� p�ipojit filesyst�m na /dev/loop0 k na�emu adres��ov�mu stromu, nap��klad k adres��i /loop, kter� pro tento p��pad vytvo��me:
   mkdir /loop
mount /dev/lopp0 /loop -t ext2
5. A nyn� m��eme na /loop vytvo�it ko�enov� filesyst�m ramdisku.
6. Pot� adres�� /loop odmontujeme:
   umount /loop
7. Na z�v�r soubor odpoj�me od za��zen� /dev/loop0:
   losetup -d /dev/loop0

Nejmen�� distribuce Linuxu

V tomto odstavci si uk�eme, �e pomoc� za��zen� loop a ramdisku lze vytvo�it jednodisketovou pln� funk�n� distribuci linuxu. Tuto distribuci naleznete na ftp://gd.tuwien.ac.at/pub/pss/aux/opsys/linux/DLX/. My se nyn� budeme sp��e zab�vat t�m jak�m zp�sobem jsou pou�ity ramdisk a loop spole�n� v t�to distribuci, pro nikoho by pak nem�l b�ti probl�m vytvo�iti si takov� jednodiskov� linux s�m.

My�lenka:

Co v�e na ramdisk?

V�e pot�ebn� si skop�rujte do p��slu�n�ho stromu v adres��i ./rd-tree a nezapome�te p�idat scripty mountloop a umountloop, kter� jsou pops�ny n��e.

Velikost u�it�ho m�sta v tomto adres��i mus� b�t, po nakop�rov�n� v�eho po�ebn�ho, men�� ne� 2700kB, aby zbylo trocha m�sta na ramdisku pro /tmp, jej� u��v� nap��klad editor!

Postup pr�ce

Vytvo��me si komprimovan� obraz ramdisku ramImage.gz, tj. pomoc� loop p�imontujeme soubor o velikosti 2840kB do n�j p�ekop�rujeme obsah adres��e ./rd-tree, odmontujeme a soubor skomprimujeme pomoc� gzipu. To v�e ud�l� script createImage:

#!/bin/sh
#
#            Script createImage upraveno podle scriptu Ericha Boehma
#

RD_SIZE=2840

#########################################
#
# Pot�ebn� adres��e a za��zen�

RDHOME=.
RD_SOURCE=$RDHOME/rd-tree/*
RD_IMAGE=$RDHOME/ramImage.gz

MNTDIR=/mnt                    # kam se do�asn� p�ipoj� loop?
LOOPDEV=/dev/loop0             # u�it� za��zen� loop
TMPFILE=/tmp/loop_tmp          # do�asn� soubor, na kter� se p�ipoj� loop 
FLOPPYDEV=/dev/fd0             # pou�it� disketov� jednotka

echo 
echo "---------------------------------------------------"
echo "Tvo��m obraz ramdisku..."
echo "                    --> chvilku to potrv�"
echo "---------------------------------------------------"
echo

# vytvo�en� do�asn�ho souboru o velikosti $RD_SIZE 
echo "Pln�m soubor $TMPFILE na velikost $RD_SIZE"
dd if=/dev/zero of=$TMPFILE bs=1k count=$RD_SIZE > /dev/null
# a p�i�azen� tohoto souboru za��zen� loop
echo "P�ipojuji $TMPFILE k $LOOPDEV"
losetup $LOOPDEV $TMPFILE

# vytvo�en� ext2 fs na za��zen� loop
echo "Na $LOOPDEV tvo��m ext2t filesyst�m"
mke2fs -m 0 $LOOPDEV > /dev/null
# p�imontov�n� za��zen� loop k adres��ov�mu stromu
echo "Montuji $LOOPDEV na $MNTDIR"
mount $LOOPDEV $MNTDIR -t ext2

# p�ekop�rov�n� pot�ebn�ho do vytv��en�ho souboru
echo "Kop�ruji v�e pot�ebn� z $RD_SOURCE do $MNTDIR"
cp -a $RD_SOURCE $MNTDIR

# odmontov�n� a odpojen� za��zen� loop od souboru 
echo "Odmontov�v�m $MNTDIR a odpojuji soubor od $LOOPDEV"
umount $MNTDIR
losetup -d $LOOPDEV

# vytvo�en� zagzipovan�ho obrazu ramdisku
echo "Komprimuji obraz ramdisku $TMPFILE do souboru $RD_IMAGE"
dd if=$TMPFILE bs=1k | gzip -9v > $RD_IMAGE
echo "Ma�u $TMPFILE"
rm -f $TMPFILE

# bezpe�nostn� vy�k�n� na dobu a� se v�e zap��e na medium
sync
echo "Hotovo --- konec"
############ Konec scriptu createImage

Nyn� ji� m�me v�e pot�ebn� soubor zImage a ramImage.gz, proto bude dobr� pop�em��let jak v�e na disketu um�st�me. Nejprve p�ijde j�dro o velikosti KERNELSIZE pak bychom cht�li um�stit ramdisk o velikosti IMAGESIZE a za n�m zbude m�sto na EXT2-FS, kter� budeme p�ipojovat pomoc� za��zen� loop. K tomu v�emu je t�eba ur�it offsety. Offset pro ramdisk se ulo�� pomoc� rdev jako p��znak do obrazu kernelu, ale offset zbyl�ho diskov�ho m�sta pro loop budeme pot�ebovat n�kde ulo�it, jeliko� bychom se pak k tomuto m�stu t�ko propracov�vali. Proto hned za zImage do dal��ho 1kB bloku zap��eme offset m�sta pro loop, tento blok nazveme looptable.

Napln�n� diskety bude vypadat asi takto: =0.5mm

V obr�zku uveden� symboly maj� n�sleduj�c� v�znam: looptable (); prvn� blok looptable (t), ramdisku (r) a m�sta pro ext2 fs (l); posledn� blok obrazu kernelu K= 0+KERNELSIZE a posledn� blok obrazu ramdisku IMAGESIZE. Z obr�zku je patrn�, �e , .

Tak zn�me v�e pot�ebn�, abychom mohli pochopit n�sleduj�c� script WriteDisk, kter� vypo��t� v�echny pot�ebn� offsety a pak v�e ulo�� na spr�vn� m�sto na disku:

#!/bin/sh
# 
#               Script WriteDisk upraveno podle Ericha Boehma
# 

#
# definice prom�nn�ch 

RDHOME=.
RD_KERNEL=$RDHOME/zImage
RD_IMAGE=$RDHOME/ramImage.gz

LOOPDEV=/dev/loop0        # za��zen� loop, kter� hodl�me pou��t
FLOPPYDEV=/dev/fd0        # disketov� jednotka, na kterou se v�e zap��e

# V�po�ty velikost� 

KERNELSIZE=`ls -s $RD_KERNEL | cut -f2 '-d '`  # velikost obrazu kernelu
IMAGESIZE=`ls -s $RD_IMAGE | awk '{print $1}'` # velikost obrazu ramdisku

LOOPTABLE=$[$KERNELSIZE + 1]                   # offset pro looptable v kB
RDSTART=$[$KERNELSIZE + 2]                     # offset ramdisku  v kB
LOOPSTART=$[1024 * ($RDSTART + $IMAGESIZE)]  # offset pro m�sto na EXT2-FS
#                                                v bytech     
# velikost voln�ho m�sta na ext2 fs
LOOPSIZE=$[1440 - ($RDSTART + $IMAGESIZE)]

# P��prava p��znaku ramdisku, kter� se ulo�� do kernelu
#   nastaven� bit 14 (2^14=16384) znamen�, �e se m� hledat ramdisk.
#    Je po�n� nastavit i bit 15 (tj. p�i��st 2^15) aby se objevil prompt

RD_FLAG=$[$RDSTART + 16384]

#########################################
#
# za��tek 

echo
echo "-------------------------------"
echo "vytv���m disk ..."
echo "-------------------------------"
echo "velikost kernelu        : $KERNELSIZE  kByte"
echo "velikost ramdisku       : $IMAGESIZE  kByte"
echo "offset ramdisku         : $RDSTART  kByte"
echo "offset zbyl�ho m�sta    : $LOOPSTART  Byte"
echo "offset tabulky looptable: $LOOPTABLE  kByte"
echo "velikost  zbytku na loop: $LOOPSIZE  kByte"
echo

# nastaven� p��znak� kernelu a z�pis kernelu na disketu
echo " Nastavuji p��znaky pomoc� rdev --- pro ramdisk u�iji  $RD_FLAG"
rdev $RD_KERNEL $FLOPPYDEV		# nastaven� bootvac�ho za��zen�
rdev -r $RD_KERNEL $RD_FLAG	        # nastaven� p��znak� ramdisku
rdev -R $RD_KERNEL 0		        # u�it� VGA 
echo "Kop�ruji $RD_KERNEL na $FLOPPYDEV"
cp $RD_KERNEL $FLOPPYDEV		# kop�rov�n� kernelu na disk

# z�pis obrazu ramdisku na disk s offsetem RDSTART
echo "Kop�ruji $RD_IMAGE na $FLOPPYDEV p�i�em� p�esko��m prvn�ch $RDSTART kB"
dd if=$RD_IMAGE of=$FLOPPYDEV bs=1k seek=$RDSTART

# z�pis po��tku zbyl�ho m�sta do looptable
#        konverze sync znamen�, �e se nevyu�it� m�sto bloku zapln� NULLami
echo \
  "Zapisuji hodnotu $LOOPSTART na $FLOPPYDEV, p�eskakuji prvn�ch $LOOPTABLE kB"
echo "$LOOPSTART" | dd of=$FLOPPYDEV bs=1k seek=$LOOPTABLE conv=sync

# vytvo�en� filesyst�mu ext2 na zbyl�m m�st�
echo "Tvo��m ext2 fs na $FLOPPYDEV od bloku $LOOPSTART + 1"
losetup $LOOPDEV $FLOPPYDEV -o $LOOPSTART # p�ipojen� m�sta s offsetem LOOPSTART
mke2fs -m 0 $LOOPDEV   > /dev/null        # vytvo�en� filesyst�mu 
losetup -d $LOOPDEV                       # odpojen�

sync                                      # vy�k�n� na skute�n� z�pis na medium
echo
echo "hotovo --- disk byl vyto�en"
################ Konec scriptu WriteDisk

Abychom mohli vyu��t zbyl�ch asi 100kB, na nich� jsme vytvo�ili syst�m soubor� EXT2, je t�eba nejprve ur�it, kde je na disket� looptable, pak mus�me looptable p�e��st a podle obsahu ur�it offset m�sta, kde je vytvo�en ext2-fs, toto m�sto se pak pomoc� losetup p�i�ad� za��zen� loop, nap�. /dev/loop0, a za��zen� loop se pot� p�ipoj� ke ko�enov�mu syst�mu soubor� na ramdisku na m�sto, �ekn�me, /loop. P�i vytv��en� ./rd-tree je dobr� na tuto skute�nost pomyslet a je dobr� n�kam vhodn� um�stit scripty mountloop a umountloop, krer� za n�s provedou ve�kerou �pinavou pr�ci s v�po�ty offsetu, �ten�m looptable a montov�n�m:

#!/bin/sh
#            Script mountloop  podle Ericha Boehma
#

# Vypo�ten� polohy looptable:

LOOPTABLE=$[(`rdev -r /dev/fd0 | cut -f2 '-d '` & 16383) - 1]

#   Pozn�mka:
#   rdev -r /dev/fd0  p�e�te p��znak pro ramdisk z kernelu na disket�
#   v�sledek p��kazu rdev se o�e�e tak, aby zbylo pouze ��slo bez
#   komet��� a z tohoto ��sla se odstran� byty 14 a 15 p�es 
#   masku 0x7FFF (16383). T�m jsme z�skali offset ramdisku a v�me, �e
#   looptable je o jeden 1kB blok d��ve


# p�e�teme si z looptable offset pro filesyst�m ext2 na konci diskety
# a uprav�me ho tak, aby zbylo pouze ��slo.

LOOPSTART=`dd if=/dev/fd0 bs=1k skip=$LOOPTABLE count=1 | tr -cd '0-9'`

# p�ipoj�me filesyst�m ext2 na disket� s offsetem LOOPSTART k za��zen� loop0

losetup /dev/loop0 /dev/fd0 -o $LOOPSTART

# neexistuje-li adres�� /loop tak ho vytvo��me 
#                                         a p�imontujeme na� /dev/loop0

if [ ! -d /loop ]; then
  mkdir /loop
fi
mount /dev/loop0 /loop -t ext2
######### Konec scriptu mountloop 


#!/bin/sh
#
#            Script umountloop  podle Ericha Boehma
#
# odmontujeme /loop a odpoj�me disketu od  /dev/loop0 
umount /loop
losetup -d /dev/loop0
######### Konec scriptu umountloop

No a nyn� bychom m�li bez probl�m� nabootvat z pr�v� vytvo�en� diskety. Je z�ejm�, �e je t�eba m�ti v�ce ne� 4MB RAM, jeliko� jen pro samotn� obraz ramdisku jsme zvolili velikost 2840kB. Jestli�e jsme naplnili ramdisk spr�vn�, m�l by se n�m rozb�hnout jednodisketov� Linux.