A qualcuno potrebbe servire....Creare un live cd.
PARTE 1
Creare un floppy avviabile
con slackware dare
makebootdisk
(vi verrà chiesto quale kernel copiare nel floppy ed automaticamente il floppy verrà formattato con fs
vfat o msdos da 1.68Mb e verranno trasferiti alcuni file quali
syslinux.cfg
ldlinux.sys //file che rende di fatto il floppy vero e proprio avviabile (credo)
kernel
maessage.txt //file contente istruzioni principali o informazioni di benvenuto
f1.txt //file che viene visualizzato premendo f1
f2.txt //file che viene visualizzato premendo f2
Se non abbiamo makebootdisk dobbiamo procedere come segue
formattare un floppy disk con filesystem msdos o vfat
mkfs -t msdos /dev/fd0u1440
o usare
fdformat
Noi possiamo anche formattarlo da 1.44 Mb
Poi diamo
syslinux /dev/fd0 ##Rende un floppy avviabile, (copia quel file ldlinux.sys sul floppy appunto)
copiare un kernel funzionante (che stia in un floppy meno di 1.44 Mb quindi) nel floppy
con ad esempio
mount /dev/fd0 /mnt/floppy
cd /mnt/floppy
cp /boot/vmlinuz /mnt/floppy
cd /mnt/floppy
Creiamo il file syslinux.cfg nel floppy
#syslinux.cfg dovrà contenere qualcosa come testo di configurazione.
#Esempio un file syslinux.cfg
#(se non sbaglio contiene una sorta di lilo.conf che avvia il sistema.)
cat > syslinux.cfg
display message.txt
default vmlinuz ramdisk_size=100000 root=/dev/hdc
prompt 1
F1 help.txt
F2 help2.txt
label eml
kernel vmlinuz
append ramdisk_size=200000 root=/dev/hdc
(praticamente si dice che si legge vmlinuz come immagine del kernel, viene letto il filesystem root da /dev/hdc (che sarà il nostro cdrom) e cosa importante viene settata una ram di blocchi 100000.
Dare control-Z
creiamo il file di benvenuto
cat > message.txt
Benvenuti in minilinux
Premere F1 per l'help
Dare control-Z
creiamo il file di help che verrà visualizzato premendo f1 help.txt
cat > help.txt
Messaggio di help 1
Inserite cosa volete
Dare control-Z
creiamo il file di help che verrà visualizzato premendo f2 help2.txt
cat > help2.txt
Messaggio di help 2
Inserite cosa volete
Dare control-Z
smontiamo il floppy con
cd /
umount /mnt/floppy
e copiamo il nostro floppy in un file immagine chiamato floppy.img (file immagine di un floppy avviabile)
dd if=/dev/fd0 of=/floppy.img bs=1440k count=1 oppure
cp /dev/fd0 /floppy.img // copia il floppy e ne fa un immagine in /
PARTE 2
a questo punto creiamo una cartella...chiamata mnt2
mkdir /mnt2
in questa cartella andremo a copiare tutto ciò che vogliamo compaia nel nostro linux
ossia copiamo ad esempio in questo modo
cp -r /boot /mnt2
cp -dpr /bin /mnt2
cp -dpr /sbin /mnt2
cp -dpR /dev /mnt2
cp -dpR /var /mnt2
cp -dpr /etc /mnt2
mkdir /mnt2/proc
mkdir /mnt2/tmp
mkdir /mnt2/sys
cp -dpR /lib /mnt2
mkdir /mnt2/home
mkdir /mnt2/home/ftp
mkdir /mnt2/mnt
mkdir /mnt2/mnt/floppy
mkdir /mnt2/mnt/cdrom
mkdir /mnt2/mnt/dvd
mkdir /mnt2/mnt/digicam
mkdir /mnt2/mnt/ram
mkdir /mnt2/mnt/ram2
mkdir /mnt2/mnt/c
mkdir /mnt2/mnt/d
mkdir /mnt2/mnt/e
mkdir /mnt2/mnt/f
mkdir /mnt2/mnt/g
mkdir /mnt2/mnt/proc
cp -dR /usr/ /mnt2
Ora in /mnt2 avremo il nostro minilinux.
Copiamo anche l'immagine del floppy floppy.img in /boot con
cp /floppy.img /boot
Andiamo in /mnt2/etc/rc.d/
e modifichiamo rc.S in questo modo
#!/bin/sh
PS1='\u:\w>\$'
export PS1
DIS="/dev/ram0"
clear
trap "" 1 2 3 15
echo "Benvenuti in Mini Linux"
echo "Scegliere il dispositivo sul quale caricare MiniLinux"
echo "es. /dev/hda6 oppure /dev/hdb5, /dev/hda1 ecc.."
echo "Il default e' /dev/ram0"
echo "Fare molta attenzione: tutti i dati verrano cancellati irrimediabilmente"
echo "Il dispositivo verra' formattato.Enter per confermare il default"
read DISPO
if [ "$DISPO" != "" ]; then
DIS=$DISPO
echo "Al termine del caricamento modificare il file /etc/lilo.conf aggiungendo:"
echo "image = /boot/vmlinuz"
echo "root = $DIS"
echo "label = Minilinux"
echo "Salvare il file e digitare:"
echo "lilo"
fi
echo "Sto per formattare $DIS"
echo "Enter per confermare - Altro per riavviare"
read OPZ
if [ "$OPZ" = "" ]; then
mkfs.ext2 $DIS
mount $DIS /mnt
else
echo "Riavvio sistema"
mount -t proc /proc /proc
reboot
fi
echo "Creazione filesystem root e caricamento in $DIS"
echo "Al termine del caricamento in caso di problemi con alcuni comandi digitare:"
echo "chroot /mnt"
echo "mount -t proc /proc /proc"
echo "mkswap /dev/hdb6 ******** dove /dev/hdb6 sara' la partizione di swap"
echo "swapon /dev/hdb6"
echo "Enter per continuare"
read ENTRATA
clear
echo "Attendere....."
/sbin/swapon -a
cp -r /boot /mnt
echo "/boot copiata"
cp -dpr /bin /mnt
echo "/bin copiata"
cp -dpr /sbin /mnt
echo "/sbin copiata"
cp -dpR /dev /mnt
echo "Dispositivi copiati"
cp -dpR /var /mnt
echo "/var copiata"
cp -dpr /etc /mnt
echo "/etc copiata"
if [ "$DIS" != "/dev/ram0" ]; then
rm /mnt/etc/rc.d/rc.S
cp /mnt/etc/rc.d/rc.SD /mnt/etc/rc.d/rc.S
fi
cp -dpR /lib /mnt
echo "Librerie copiate"
# cp -r /boot /mnt
mkdir /mnt/proc
mkdir /mnt/proc/mounts
mount -t proc /proc /mnt/proc
echo "Processi ricostruiti"
mkdir /mnt/tmp
echo "Creazione directory file temporanei /tmp terminata"
cp -r /root /mnt
mkdir /mnt/home
mkdir /mnt/home/ftp
mkdir /mnt/mnt
mkdir /mnt/mnt/floppy
mkdir /mnt/mnt/cdrom
mkdir /mnt/mnt/dvd
mkdir /mnt/mnt/digicam
mkdir /mnt/mnt/ram
mkdir /mnt/mnt/ram2
mkdir /mnt/mnt/c
mkdir /mnt/mnt/d
mkdir /mnt/mnt/e
mkdir /mnt/mnt/f
mkdir /mnt/mnt/g
mkdir /mnt/mnt/proc
cp /usr/bin/fdformat /mnt/bin
echo "Creazione directory di mount /mnt terminata"
echo "A causa delle notevoli dimensioni e' possibile scegliere se copiare"
echo "la directory /usr in memoria.In questa directory sono contenuti molti"
echo "comandi importanti e numerosi file di configurazione."
echo "Se possibile si consiglia di caricarla in memoria"
echo "Copiare questa directory (s/n)?"
read ANDREA
if [ "$ANDREA" = "s" ]; then
echo "Sto copiando /usr"
rm /mnt/bin/fdformat
cp -dR /usr/ /mnt
echo "/usr copiata"
fi
echo "Caricamento e creazione del filesystem root terminata"
clear
echo "Benvenuti in Mini Linux "
echo "******************* IMPORTANTE *******************"
echo "Digitare subito"
echo "chroot /mnt"
echo "all'avvio di ogni console"
echo "**************************************************"
echo "Per configurare periferiche usb, tastiera"
echo "caricare i moduli ntfs, apm, ide-scsi e scsi_debug"
echo "digitare minilinux"
echo "**************************************************"
echo "Digitare"
echo "chroot /mnt"
echo "adesso"
echo "**************************************************"
#chroot /mnt
#mount -t proc /proc /proc
E andiamo anche a modificare il file /mnt2/etc/inittab in questo modo
#/etc/inittab
# Boot-time system configuration/initialization script.
# This is run first except when booting in single-user mode.
::sysinit:/etc/rc.d/rc.S
# Login /bin/sh invocations on selected ttys.
#
# Start a shell on the console
::respawn:-/bin/sh
# Start an "askfirst" shell on tty2 and tty3
tty2::askfirst:-/bin/sh
tty3::askfirst:-/bin/sh
tty4::askfirst:-/bin/sh
tty5::askfirst:-/bin/sh
tty6::askfirst:-/bin/sh
#c5:2345:respawn:/sbin/agetty 38400 tty5
#c6:2345:respawn:/sbin/agetty 38400 tty6
# /sbin/getty invocations for selected ttys.
#
#tty1::respawn:/sbin/getty 38400 tty1
#tty2::respawn:/sbin/getty 38400 tty2
# Example of how to put a getty on a serial line (for a terminal)
#
#ttyS0::respawn:/sbin/getty -L ttyS0 9600 vt100
#ttyS1::respawn:/sbin/getty -L ttyS1 9600 vt100
#
# Example how to put a getty on a modem line.
#ttyS2::respawn:/sbin/getty -x0 -s 57600 ttyS2
# Reboot when ctrl-alt-del keys are pressed.
::ctrlaltdel:/sbin/reboot
#::ctrlaltdel:/sbin/brc
# Stuff to do before halting or rebooting.
::shutdown:/sbin/swapoff -a >/dev/null 2>&
Questo perchè quando il cdrom si avvierà partirà succederà pressapoco questo:
Parte il cd avviabile richiamato dal bios.
Il cd avviabile parte grazie all'immagine del floppy avviabile che abbiamo creato (floppy.img) contenuta nel cd per l'appunto
Nel floppy c'è il kernel vmlinuz.
Viene caricato il kernel.
In seguito viene caricato dall'immagine avviabile del floppy lo script syslinux.cfg che setta il filesystem root su /dev/hdc e setta una ramdisk di dimensione 100000 in blocchi (il file che fa questo è syslinux.cfg)
Poi il tutto passa al processo init...letto da /dev/hdc
init andrà a leggersi un sacco di cose fra le quali /etc/inittab e /etc/rc.d/rc.S (in slackware)
rc.S secondo come lo abbiamo creato noi copia il linux da /dev/hdc al disposisitivo /dev/ram0 (che viene creato e formattato nelle prime righe dell' rc.S stesso)
Precisazione il file syslinux.cfg setta la grandezza della ramdisk con ramdisk_size=100000
Nello script /mnt2/etc/rc.d/rc.S (in slackware) viene formattato /dev/ram0 (che dobbiamo aver copiato all'inizio (con cp -dpR /dev /mnt2)
Se in /dev/ non c'era ram0 dobbiamo crearlo noi...come non lo so ma sicuramente con mknod.)
Ora Terminato lo script rc.S abbiamo in /dev/ram0 (montato su /mnt quindi difatto in /mnt) il nostro linux.
In sostanza abbiamo il nostro linux in memoria.A questo punto...non ci resta che dare appena compare il prompt un bel
chroot /mnt (oppure inserirlo anch'esso in rc.S ma consiglio di darlo da prompt poichè c'è qualche problema con la shell)
ossia diciamo al nostro linux che finora è stato caricato interamente da cdrom (ossia da dove era caricato il filesystem root dall'inizio cioè nel mio caso da /dev/hdc secondo quanto impostato in syslinux.cfg) di cambiare il filesystem di root da /dev/hdc in sola lettura a /mnt in scrittura e lettura.
Bene a questo punto il gioco è fatto e linux è pronto per essere usato..
Non resta che caricare un po' di moduli ad esempio con
insmod ntfs
insmod apm
(se li avete naturalmente copiati dall'harddisk al cdrom inizialmente) e se il kernel inserito nell'immagine del floppy era predisposto a caricare questi moduli ad esempio.
IO mi sono creato uno script avviabile che ho chiamato minilinux è che è così fatto:
Parte 3
#!/bin/sh
# This is a function to unload the USB mouse/keyboard modules:
usb_kbd_down() {
modprobe -r keybdev mousedev usbmouse hid usbkbd input uhci usb-uhci usb-ohci uhci-hcd ohci-hcd ehci-hcd 2> /dev/null
umount usbfs 2> /dev/null
modprobe -r usbcore 2> /dev/null
}
# This is a function to attempt to enable a USB keyboard.
# If this causes problems for you, use "nousb" as a kernel
# command line option at boot time.
usb_kbd_up() {
# If nousb was given at boot, skip.
if ! cat /proc/cmdline | grep nousb 1> /dev/null 2> /dev/null ; then
# If there aren't even any modules for this kernel, skip.
if [ -d /lib/modules/`uname -r` ]; then
# If usbcore is already loaded, skip.
if ! grep usbcore /proc/modules 1> /dev/null 2> /dev/null ; then
modprobe -q usbcore >/dev/null 2>&1
# Try to mount usbfs:
if [ -d /proc/bus/usb -a ! -f /proc/bus/usb/devices ]; then
mount -t usbfs usbfs /proc/bus/usb
fi
# Try to load all the hub modules:
modprobe -q ehci-hcd >/dev/null 2>&1
modprobe -q ohci-hcd >/dev/null 2>&1
modprobe -q uhci-hcd >/dev/null 2>&1
modprobe -q usb-ohci >/dev/null 2>&1
# NOTE: this prefers "usb-uhci"; you may prefer "uhci".
modprobe -q usb-uhci >/dev/null 2>&1 || modprobe -q uhci >/dev/null 2>&1
# modprobe -q uhci >/dev/null 2>&1 || modprobe -q usb-uhci >/dev/null 2>&1
# Load input core:
modprobe -q input >/dev/null 2>&1
# Load USB keyboard:
modprobe -q usbkbd >/dev/null 2>&1
# Load Human Interface Device (HID) USB module:
modprobe -q hid >/dev/null 2>&1
# Load mouse (just in case (TM)) and keyboard USB input modules:
modprobe -q mousedev >/dev/null 2>&1
modprobe -q keybdev >/dev/null 2>&1
# Give these some time to register:
sleep 2
# Next, take a look to see if there are devices detected.
# If not, unload the modules.
if [ ! -r /proc/bus/usb/devices ]; then
usb_kbd_down
break
elif cat /proc/bus/usb/devices | grep -i Driver=usb_mouse 1> /dev/null 2> /dev/null ; then
# Looks like a mouse.
break
elif cat /proc/bus/usb/devices | grep -i Driver=hid 1> /dev/null 2> /dev/null ; then
# Probably a keyboard (but could be a game pad :)
break
elif [ -d /proc/bus/usb/devices/001 ]; then # we're REALLY not picky here...
break
else
# Nothing? Fine, we'll give up.
echo "No USB devices found. Unloading USB subsystem..."
usb_kbd_down
fi
fi
fi
fi
}
# remove /etc/mtab* so mount creates the /etc/mtab file
/bin/rm -f /etc/mtab* /etc/nologin
/bin/mount -av -t nonfs
#/sbin/swapon -a 2> /dev/null
if [ -x /sbin/ldconfig ]; then
/sbin/ldconfig -v
fi
## Detect serial console from kernel command line:
if cat /proc/cmdline | grep console=ttyS 1> /dev/null 2> /dev/null ; then
SERIAL_CONSOLE="true"
fi
# USB keyboard?
usb_kbd_up
# Replace some startup binaries with better versions:
( cd /bin
rm -f grep gzip tar gunzip zcat df
ln -sf df.bin df
ln -sf grep.bin grep
ln -sf gzip.bin gzip
ln -sf tar-1.13 tar
ln -sf gzip gunzip
ln -sf gzip zcat
)
# Make detected partitions:
/dev/makedevs.sh
if [ -x /etc/rc.d/rc.inet1 ]; then
/bin/sh /etc/rc.d/rc.inet1
fi
/sbin/syslogd 2> /dev/null
sleep 1
/sbin/klogd -c 3 1> /dev/null
/bin/setterm -blank 0
echo
echo "<OPZIONI PER CARICAMENTO MAPPA CARATTERI DELLA TASTIERA>"
echo
echo "Se non stai usando una tastiera Inglese, hai la possibilità di cambiarla"
echo "con quella del tuo paese. Per selezionare una mappa diversa di caratteri"
echo "per la tua tastiera digita 1 adesso.Scegli it.map se la tastiera e' italiana."
echo "Altrimenti premi solo enter per confermare la tastiera inglese"
echo -n "Digita 1 per selezionare la mappa di caratteri per la tua tastiera: "
read ONE
if [ "$ONE" = "1" ]; then
/usr/lib/setup/SeTkeymap
fi
clear
# If possible, figure out what kernel we just booted with:
#unset SLACK_KERNEL
#for ARG in `cat /proc/cmdline` ; do
# if [ "`echo $ARG | cut -f 1 -d =`" = "SLACK_KERNEL" ]; then
# IMAGE="`echo $ARG | cut -f 2 -d =`"
# SLACK_KERNEL=$IMAGE
# fi
#done
#export SLACK_KERNEL
alias ll='ls -al --color=auto'
insmod apm
insmod ntfs
insmod ide-scsi
insmod scsi_debug
clear
echo "Mini Linux login: enter per proseguire"
echo "Per espellere il cd digitare:"
echo "cdrecord -dev=ATAPI:0,0,0 -eject"
echo "I tre numeri 0,0,0 (bus,target,lun) potrebbero necessitare"
echo "di modifiche a seconda della configurazione del bus, masterizzatore ecc..."
echo "Esempio masterizzatore sul secondo bus:"
echo "senza emulazione scsi:cdrecord -dev=ATAPI:1,0,0 -eject"
echo "Esempio secondo masterizzatore sul primo bus"
echo "con emulazione scsi: cdrecord -dev=0,1,0 -eject"
minilinux che io ho inserito nel cd nella directory /bin...praticamente configura le periferiche usb, carica i moduli che a me interessano ed infine da qualche informazione utile e permette di settare la tastiera.
Bene ma noi dobbiamo ancora creare il cdrom...allora dicevamo che in /mnt2 c'è il nostro linux...
copiamo in /mnt2/boot l'immagine avviabile del floppy floppy.img
cp /floppy.img /mnt2/boot/ se non lo avevamo già fatto prima..
Poi entriamo in /mnt2 e diamo il comandone del secolo che creerà l'immagine iso del cd da scrivere utilizzando come avvio l'immagine di un floppy avviabile ( il nostro floppy.img)
cd /mnt2
mkisofs -v -R -J -V "Live CD" -b boot/floppy.img -c boot/catalogo.b -o livecd.iso /mnt2
Questo comando creera' il file catalogo.b utile a rendere il cd avviabile e lo inserirà nel file livecd.iso che conterra' tutta la directoty /mnt2 utilizzando come avvio l'immagine del floppy avviabile (floppy.img che badate bene deve trovarsi all'interno della directory contente il nostro linux.Io per comodità l'ho copiata in /boot (vedi sopra))
Di fatto questo comandone del secolo crea un file chiamato livecd.iso che sarà quello da scrivere nel cd...
Bene ora abbiamo livecd.iso...scriviamo adesso sul cd con
Controllate i parametri che potrebbero differire a seconda dei casi (i tre numerini 0,0,0 che rappresentano scsibus, masterizzatore (0 o 1) e lun (che non so cos'è ma che di solito è sempre 0).Se non avete caricato il modulo scsi dovrete dare ATAPI:0,0,0 al posto di 0,0,0 da solo)..(può essere utile dare
cdrecord -scanbus per capire come è configurato il nostro bus..
.quindi...
da /mnt2
cdrecord -v dev=0,0,0 -data livecd.iso
man cdrecord per le mille opzioni da usare con cdrecord
Parte 4
Se usiamo isolinux.... approfondimenti..
Utilizzando isolinux (che fa di fatto le stesse cose che fa syslinux) possiamo evitarci di creare l'immagine del floppy avviabile poiche l'immagine è già isolinux.bin.
Tuttavia per utilizzare questo secondo metodo vedere le istruzioni di isolinux (file che si trova in questa cartella)
Comune ad entrambi i metodi e tuttavia l'uso di initrd.gz
Io nell'esmempio del primo metodo non ne faccio uso ma si potrebbe anche fare così-
Desrizione processo di avvio:
Parte il kernel (che può trovarsi o sul cd live in una directory che noi andremo a specificare dal prompt, oppure sarà incluso nelle immagini avviabili create da syslinux e poi inglobate nel file floppy.img oppure create da isolinux (isolinux.bin)
Il kernel automaticamente contiene in sè un codice che va ha cercare se esiste un'immagine sul cd compressa con gzip di un filesystem linux da caricare in memoria prima di caricare il vero linux.
Questa sarà specificata negli script syslinux.cfg o isolinux.cfg oppure lo diremo noi dal prompt con initrd=nomeimmaginecompressa.gz
Dunque il kernel cerca questa prima immagine che deve contenere un linux in miniatura che serve per caricare in memoria dei moduli che permettano a questo prelinux di caricare il linux vero e proprio che si troverà da qualche parte.
Io creo un filesystem linux in miniatura (che non può occupare mi sembra più di 10 mb u giu di lì)
Come faccio?
O me lo creo io creandomi proprio le directory bin, sbin, lib eccc con i file essenziali e poi creo un immagine compressa (esempio prima con mkisofs creo un immagine iso del prelinux che poi comprimo con gzip -0 prelinux.iso) oppure sotto slackware esiste il comando mkinitrd che crea in automatico questo mini prelinux avviato in automatico dal kernel
il comando mkinitrd
es
mkinitrd -c -k 2.4.29 -m ext2:resiserfs:apm -f ext3 root=/dev/hda5
crea sotto la directory boot del nostro sistema slackware una directory initrd-tree (che contiene tutto in prelinux in miniatura e un file initrd.gz contente script preziosi quali ad esempio linuxrc linuxrc.cfg ecc..)
il file linuxrc che va a leggersi linuxrc.cfg è il cuore di tutto l'initrd.gz in quanto è lo script che il kernel va a cercare per primo se e solo se viene trovata l'immagine initrd.gz specificata da noi al prompt.
linuxrc tanto per capirci e il file che la knoppix usa per configurare tutto il sistema già all'avvio.
Tuttavia bisogna distinguere due cose.Nell'esempio quando io ho creato la mia initrd.gz a manina (in questa directory c'è un file che spiega come realizzare l'initrd.gz da zero a manina initrd.html) in initrd.gz c'è anche già la directory initrd-tree che il comando mkinitrd invece separa dal file compresso .gz.
Adesso spieghiamo cosa fa quel comando mkinitrd
-c cancello la vecchia initrd-tree se già presente o creata in passato (sotto /boot)
-k 2.4.29 specifico che versione del kernel
-m mod1:mod2:mod3 specifico quali moduli inserire nell'immagine initrd.gz (che sarà il mio prelinux.Se ad esempio ho sull'hardisk un linux con reiserfs su hda6 per avviarlo dovrò all'avvio aver già caricato in memoria il modulo reiserfs per poter caricare quel linux su hda6.A questo serve poi initrd.gz)
-f ext3 dice ext3 dice a initrd.gz che il filesystem di root del linux che andrà a caricare sarà ext3
root =/dev/hda5 dice a initrd.gz che terminato il suo caricamento in memoria dovrà cercare su hda5 il processo init che darà l'avvio al linux che si troverà in quella partizione.
(attenzione se al prompt abbiamo dato root=/dev/hda7 o root=/dev/ram0 verrà cercata initrd.gz o su hda7 o su ram0.Attenzione:se questa non viene trovata verrà cercato init (e quindi il linux da caricare su hda7 o su ram0) ma se viene trovata initrd.gz su hda7 o su ram0 nell'esempio, ora il controllo passerà a initrd.gz la quale terminato il proprio caricamento andrà a cercare il linux dul device specificato con mkinitrd.
Se non specifichiamo root=/dev/xxx in mkinitrd allora mkinitrd suppone di usare come device in cui cercare il filesystem di root quello specificato al prompt o di default nell'impostazione di avvio (isolinux.cfg o syslinux.cfg)
vedere anche man mkinitrd
Dunque il kernel è partito ha caricato initrd.gz e ora passa il controllo a linuxrc che configura il tutto.
Naturalmente dal prompt di comando o da isolinux.cfg dovremo ricordarci di specificare che initrd.gz (in realtà il ramdisk) va montato in rw in questo modo:
Alla comparsa del prompt digitiamo (o Aggiungiamo in syslinux.cfg o isolinux.cfg):
esempio
/boot/vmlinuz initrd=/boot/initrd.gz load_ramdisk=1 ramdisk_size=100000 rw root=/dev/ram
Vedere nel file syslinux-3.07.tar.gz presente in questa directory la documentazione.
Ora quindi linuxrc avrà fatto il suo dovere.Termninato questo script initrd.gz andrà a cercare se l'opzione root=/dev/xxx è stata specificata con mkinitrd altrimenti andrà a cercare init seguendo le istruzioni del prompt o isolinux.cfg o syslinux.cfg.
Supponiamo che noi abbiamo dato al prompt
root=/dev/ram
initrd.gz è stata trovata
e mkinitrd con root=/dev/hda8
allora initrd è stata caricata in ram e adesso initrd cerca linux (o il processo init su hda8)
Se non fosse stata trovata initrd.gz nell'esempio veniva cercato linux in ram e avremmo ottenuto kernel panic...ma bando alle ciance..
Ora il processo init è il primo processo che da l'avvio al linux verò e proprio.
QUesto processo va a leggersi il file /etc/inittab e in seguito lo script rc.S (che sotto slackware si trova sotto /etc/rc.d/)
rc.S è dinuovo il secondo cuore del sistema nel caso non fosse stata trovata initrd.gz dal kernel e quindi neanche lo script linuxrc tutto ciò che vogliamo faccia il nostro linux all'avvio lo possiamo inserire in questo script..
Vedere metodo 1 che non utilizza initrd.gz e fa tutto con rc.S.
Vantaggi e svantaggi di usare initrd o no.
Usarla rende tutto molto più veloce il processo di avvio e il primo filesystem (quello del prelinux) può essere montato subito in lettura e scrittura;anzi deve montato così).Usare rc.S invece è molto ma molto più laborioso e lungo perchè si deve formattare la memoria e copiare tutto in memoria senza poter montare tutto subito..tuttavia la sequenza è molto più lineare e chiara e alla fine fornisce gli stessi optional.
Spero vi sia utile!!!
CIAO CIAO!!!!
Se ci sono cose sbagliate.... che ci volete fare sono i miei appunti di informatica libera..
CIAO! :biifu: :biifu:
